app.py

#!/usr/bin/env python3
"""
NOMOS NBA QUANT AI — REAL Genetic Evolution (HF Space)
========================================================
RUNS 24/7 on HuggingFace Space (2 vCPU / 16GB RAM).

NOT a fake LLM wrapper. REAL ML:
  - Population of 60 individuals across 5 islands (island model GA)
  - Walk-forward backtest fitness (Brier + LogLoss + Sharpe + ECE)
  - NSGA-II style Pareto front ranking (multi-objective)
  - 13 model types including neural nets (LSTM, Transformer, TabNet, etc.)
  - Island migration every 10 generations for diversity
  - Adaptive mutation decay (0.15 → 0.05) + tournament pressure
  - Memory management: GC between evaluations for 16GB RAM
  - Gradio dashboard showing live evolution progress
  - JSON API for crew agents on VM

Target: Brier < 0.20 | ROI > 5% | Sharpe > 1.0
"""

import os, sys, json, time, math, threading, warnings, random, traceback, gc
import numpy as np
from pathlib import Path
from datetime import datetime, timezone, timedelta
from collections import defaultdict, Counter
from copy import deepcopy

warnings.filterwarnings("ignore")

# ── Env ──
for f in [Path(".env"), Path(".env.local")]:
    if f.exists():
        for line in f.read_text().splitlines():
            line = line.strip()
            if not line or line.startswith("#"):
                continue
            if line.startswith("export "):
                line = line[7:]
            if "=" in line:
                k, v = line.split("=", 1)
                os.environ.setdefault(k.strip(), v.strip().strip("'\""))

# ML imports
from sklearn.model_selection import TimeSeriesSplit, cross_val_predict
from sklearn.metrics import brier_score_loss, accuracy_score, log_loss
from sklearn.calibration import CalibratedClassifierCV
from sklearn.linear_model import LogisticRegression
from sklearn.neural_network import MLPClassifier
from sklearn.preprocessing import StandardScaler
from sklearn.pipeline import Pipeline
from sklearn.base import clone, BaseEstimator, ClassifierMixin
import xgboost as xgb
import lightgbm as lgbm

import gradio as gr
from fastapi import FastAPI, Request
from fastapi.responses import JSONResponse

# GPU detection (determines if neural models are viable)
try:
    import torch as _torch
    _HAS_GPU = _torch.cuda.is_available()
except ImportError:
    _HAS_GPU = False

# ── Run Logger (Supabase logging + auto-cut) ──
try:
    sys.path.insert(0, str(Path(__file__).resolve().parent.parent))
    from evolution.run_logger import RunLogger
    _HAS_LOGGER = True
except ImportError:
    _HAS_LOGGER = False
    print("[WARN] run_logger not available — logging disabled")

# ── Paths (use /data for HF Space persistent storage) ──
_persistent = Path("/data")
DATA_DIR = _persistent if _persistent.exists() else Path("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)

# Copy bundled game data to persistent storage if not already there
_repo_hist = Path("data/historical")
if _repo_hist.exists() and DATA_DIR != Path("data"):
    import shutil
    for f in _repo_hist.glob("games-*.json"):
        dest = HIST_DIR / f.name
        if not dest.exists():
            shutil.copy2(f, dest)
            print(f"Copied {f.name} to persistent storage")

VM_URL = os.environ.get("VM_CALLBACK_URL", "http://34.136.180.66:8080")
ODDS_API_KEY = os.environ.get("ODDS_API_KEY", "")

# ── Post-hoc Platt/Isotonic Calibration (D5: raw ECE=0.2758, target <0.05) ──
# Pure stdlib — no sklearn dependency for the calibration lookup.
_CAL_MAP_PATH = Path("data/calibration-map.json")

def _load_cal_map():
    """Load calibration map. Returns (bin_edges, raw_centers, cal_centers) or None."""
    for p in [_CAL_MAP_PATH, DATA_DIR / "calibration-map.json"]:
        if p.exists():
            try:
                d = json.loads(p.read_text())
                return d["bin_edges"], d["raw_centers"], d["calibrated_centers"]
            except Exception as e:
                print(f"[calibration] Failed to load {p}: {e}")
    print("[calibration] calibration-map.json not found — using identity")
    return None

def _apply_cal(raw_prob: float, cal_map) -> float:
    """Apply piecewise-linear calibration. Falls back to identity if cal_map is None."""
    if cal_map is None:
        return raw_prob
    bin_edges, raw_centers, cal_centers = cal_map
    p = max(0.0, min(1.0, float(raw_prob)))
    if p == 0.0: return 0.0
    if p == 1.0: return 1.0
    # Find bin
    i = len(bin_edges) - 2
    for j in range(len(bin_edges) - 1):
        if bin_edges[j] <= p < bin_edges[j + 1]:
            i = j
            break
    raw_c = raw_centers[i]
    cal_c = cal_centers[i]
    n = len(raw_centers)
    if p < raw_c:
        if i == 0:
            t = p / raw_c if raw_c > 0 else 0.5
            cal_low, cal_high = 0.0, cal_c
        else:
            span = raw_c - raw_centers[i - 1]
            t = (p - raw_centers[i - 1]) / span if span > 0 else 0.5
            cal_low, cal_high = cal_centers[i - 1], cal_c
    else:
        if i == n - 1:
            span = 1.0 - raw_c
            t = (p - raw_c) / span if span > 0 else 0.5
            cal_low, cal_high = cal_c, 1.0
        else:
            span = raw_centers[i + 1] - raw_c
            t = (p - raw_c) / span if span > 0 else 0.5
            cal_low, cal_high = cal_c, cal_centers[i + 1]
    t = max(0.0, min(1.0, t))
    return round(max(0.0, min(1.0, cal_low + t * (cal_high - cal_low))), 4)

_CAL_MAP = _load_cal_map()

# ═══════════════════════════════════════════════════════
# LIVE STATE (shared between evolution thread + Gradio)
# ═══════════════════════════════════════════════════════

live = {
    "status": "STARTING",
    "cycle": 0,
    "generation": 0,
    "best_brier": 1.0,
    "best_roi": 0.0,
    "best_sharpe": 0.0,
    "best_features": 0,
    "best_model_type": "none",
    "pop_size": 0,
    "mutation_rate": 0.15,
    "stagnation": 0,
    "games": 0,
    "feature_candidates": 0,
    "gpu": False,
    "log": [],
    "history": [],
    "top5": [],
    "started_at": datetime.now(timezone.utc).isoformat(),
    "last_update": "never",
    "n_islands": 5,
    "island_sizes": [],
    "pareto_front_size": 0,
}


def log(msg, level="INFO"):
    ts = datetime.now(timezone.utc).strftime("%H:%M:%S")
    entry = f"[{ts}] [{level}] {msg}"
    print(entry, flush=True)
    live["log"].append(entry)
    if len(live["log"]) > 500:
        live["log"] = live["log"][-500:]
    live["last_update"] = datetime.now(timezone.utc).isoformat()


# ═══════════════════════════════════════════════════════
# 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_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,
}
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),
}
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():
    existing = {f.stem.replace("games-", "") for f in HIST_DIR.glob("games-*.json")}
    log(f"Cached seasons: {sorted(existing) if existing else 'none'}")

    # Count total cached games
    total_cached = 0
    for f in HIST_DIR.glob("games-*.json"):
        try:
            total_cached += len(json.loads(f.read_text()))
        except:
            pass
    log(f"Total cached games: {total_cached}")

    # If we have enough data, skip NBA API entirely (it's slow and unreliable)
    if total_cached >= 500:
        log(f"Enough cached data ({total_cached} games). Skipping NBA API pull.")
        return

    try:
        from nba_api.stats.endpoints import leaguegamefinder
    except ImportError:
        log("nba_api not installed — using cached data only", "WARN")
        return

    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:
        log("All seasons cached — skipping NBA API pull")
        return
    log(f"Missing seasons: {missing} — pulling from NBA API (timeout 20s each, max 3)")
    pulled = 0
    for season in missing[:3]:  # Max 3 pulls to avoid long startup
        log(f"Pulling {season}...")
        try:
            time.sleep(2)
            finder = leaguegamefinder.LeagueGameFinder(
                season_nullable=season, league_id_nullable="00",
                season_type_nullable="Regular Season", timeout=20)
            df = finder.get_data_frames()[0]
            if df.empty:
                log(f"  {season}: empty response", "WARN")
                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))
                log(f"  {len(games)} games for {season}")
                pulled += 1
        except Exception as e:
            log(f"  {season} failed (skipping): {e}", "WARN")
    if pulled == 0 and total_cached < 500:
        log("WARNING: No data available — evolution cannot start", "ERROR")


def load_all_games():
    games = []
    for f in sorted(HIST_DIR.glob("games-*.json")):
        data = json.loads(f.read_text())
        games.extend(data if isinstance(data, list) else data.get("games", []))
    games.sort(key=lambda g: g.get("game_date", g.get("date", "")))
    return games


# ═══════════════════════════════════════════════════════
# FEATURE ENGINE (164 features)
# ═══════════════════════════════════════════════════════

_FEATURE_CACHE = Path("/tmp/nba_feature_cache.npz")

def build_features(games):
    """Build features using the full NBAFeatureEngine. Caches to disk for fast restarts."""
    # ── Try disk cache first (saves ~50min on restart) ──
    if _FEATURE_CACHE.exists():
        try:
            cache = np.load(_FEATURE_CACHE, allow_pickle=True)
            X, y = cache["X"], cache["y"]
            feature_names = list(cache["feature_names"])
            if X.shape[0] >= len(games) - 200:  # Accept cache if within ~200 games
                print(f"[CACHE] Loaded feature matrix from disk: {X.shape}")
                return X, y, feature_names
            else:
                print(f"[CACHE] Stale ({X.shape[0]} vs {len(games)} games), rebuilding")
        except Exception as e:
            print(f"[CACHE] Load failed ({e}), rebuilding")

    try:
        from features.engine import NBAFeatureEngine
        engine = NBAFeatureEngine()
        X, y, feature_names = engine.build(games)
        X = np.nan_to_num(np.array(X, dtype=np.float64))
        y = np.array(y, dtype=np.int32)
        # ── Save to disk cache ──
        try:
            np.savez_compressed(_FEATURE_CACHE, X=X, y=y, feature_names=np.array(feature_names))
            print(f"[CACHE] Saved feature matrix to disk: {X.shape}")
        except Exception as ce:
            print(f"[CACHE] Save failed: {ce}")
        return X, y, feature_names
    except Exception as e:
        print(f"[WARN] NBAFeatureEngine failed ({e}), falling back to inline features")
    # ── Fallback: inline 213 features (legacy) ──
    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_, ar_ = team_results[home], 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
        def ppg(r, n): s = r[-n:]; return sum(x[4] for x in s) / len(s) if s else 100
        def papg(r, n): s = r[-n:]; return sum(x[5] for x in s) / len(s) if s else 100
        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
        def consistency(r, n):
            s = r[-n:]
            if len(s) < 3: return 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: 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_d(r, team):
            if not r: return 0
            lo = r[-1][3]
            if lo in ARENA_COORDS and team in ARENA_COORDS: return haversine(*ARENA_COORDS[lo], *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: 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 = [], []

        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}"])

        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"])

        ht, at = travel_d(hr_, home), travel_d(ar_, away)
        row.extend([min(h_rest, 7), min(a_rest, 7), h_rest - a_rest, float(h_rest <= 1), float(a_rest <= 1),
                     ht / 1000, at / 1000, (ht - at) / 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_alt", "a_alt", "alt_delta", "tz_shift", "h_g7d", "a_g7d", "sched_dens", "pad1"])

        for prefix, tr in [("h", hr_), ("a", ar_)]:
            s5, s10, ss = sos(tr, 5), sos(tr, 10), sos(tr, 82)
            wa = 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)
            wb = 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, wa, wb, 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}_mq"])

        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_str", "rel_pd", "off_match", "def_match", "tempo_diff", "cons_edge",
                          "elo_h", "elo_a", "elo_diff", "elo_h_n", "elo_a_n", "elo_d_n"])

        h_gp, a_gp = min(len(hr_), 82) / 82.0, min(len(ar_), 82) / 82.0
        h_wp82, a_wp82 = wp(hr_, 82), wp(ar_, 82)
        row.extend([1.0, sp, math.sin(2 * math.pi * month / 12), math.cos(2 * math.pi * month / 12),
                     dow / 6.0, float(dow >= 5), h_gp, a_gp,
                     h_wp82 + a_wp82, h_wp82 - a_wp82,
                     float(h_wp82 > 0.5 and a_wp82 > 0.5), ppg(hr_, 10) + ppg(ar_, 10)])
        if first:
            names.extend(["home_ct", "season_ph", "month_sin", "month_cos", "dow", "weekend",
                          "h_gp", "a_gp", "comb_wp", "wp_diff", "playoff_race", "exp_total"])

        # ── ADDITIONAL FEATURES (v2 — tanking, season context, advanced) ──

        # Tanking detection: teams with <35% WP after ASB are likely tanking
        h_tanking = float(h_wp82 < 0.35 and h_gp > 0.5)
        a_tanking = float(a_wp82 < 0.35 and a_gp > 0.5)
        # Playoff motivation: teams between 40-60% WP fighting for spots
        h_playoff_fight = float(0.40 <= h_wp82 <= 0.60 and h_gp > 0.6)
        a_playoff_fight = float(0.40 <= a_wp82 <= 0.60 and a_gp > 0.6)
        # Elite team indicator (>65% WP and coasting?)
        h_elite = float(h_wp82 > 0.65)
        a_elite = float(a_wp82 > 0.65)
        # Season trajectory: recent form vs overall (improvement/decline)
        h_trajectory = wp(hr_, 10) - h_wp82
        a_trajectory = wp(ar_, 10) - a_wp82
        # Scoring volatility
        h_vol = consistency(hr_, 15) if len(hr_) >= 15 else consistency(hr_, 10)
        a_vol = consistency(ar_, 15) if len(ar_) >= 15 else consistency(ar_, 10)
        # Defensive rating proxy
        h_drtg = papg(hr_, 10)
        a_drtg = papg(ar_, 10)
        h_ortg = ppg(hr_, 10)
        a_ortg = ppg(ar_, 10)
        h_netrtg = h_ortg - h_drtg
        a_netrtg = a_ortg - a_drtg
        # Pace proxy (total points)
        h_pace = (ppg(hr_, 10) + papg(hr_, 10)) / 2
        a_pace = (ppg(ar_, 10) + papg(ar_, 10)) / 2
        pace_diff = h_pace - a_pace
        # Close game performance (clutch proxy)
        h_close_wp = sum(1 for x in hr_[-20:] if abs(x[2]) <= 5 and x[1]) / max(sum(1 for x in hr_[-20:] if abs(x[2]) <= 5), 1)
        a_close_wp = sum(1 for x in ar_[-20:] if abs(x[2]) <= 5 and x[1]) / max(sum(1 for x in ar_[-20:] if abs(x[2]) <= 5), 1)
        # Blowout tendency
        h_blowout_rate = blowout_pct(hr_, 20)
        a_blowout_rate = blowout_pct(ar_, 20)
        # Home/away specific performance
        h_home_games = [x for x in hr_ if True]  # All results are at home for home team
        a_away_games = [x for x in ar_ if True]
        h_home_wp = wp(hr_, 82)  # Proxy (would need H/A split)
        a_away_wp = wp(ar_, 82)
        # Strength of schedule recent (last 5 opponents)
        h_recent_sos = sos(hr_, 5)
        a_recent_sos = sos(ar_, 5)
        # Win percentage vs good/bad teams (already have but add differential)
        h_quality_diff = (sum(1 for r in hr_ if wp(team_results[r[3]], 82) > 0.5 and r[1]) / max(sum(1 for r in hr_ if wp(team_results[r[3]], 82) > 0.5), 1)) - (sum(1 for r in hr_ if wp(team_results[r[3]], 82) <= 0.5 and r[1]) / max(sum(1 for r in hr_ if wp(team_results[r[3]], 82) <= 0.5), 1))
        a_quality_diff = (sum(1 for r in ar_ if wp(team_results[r[3]], 82) > 0.5 and r[1]) / max(sum(1 for r in ar_ if wp(team_results[r[3]], 82) > 0.5), 1)) - (sum(1 for r in ar_ if wp(team_results[r[3]], 82) <= 0.5 and r[1]) / max(sum(1 for r in ar_ if wp(team_results[r[3]], 82) <= 0.5), 1))
        # Form acceleration (last 3 vs last 10)
        h_accel = wp(hr_, 3) - wp(hr_, 10)
        a_accel = wp(ar_, 3) - wp(ar_, 10)
        # Elo confidence (distance from 1500)
        h_elo_conf = abs(team_elo[home] - 1500) / 300
        a_elo_conf = abs(team_elo[away] - 1500) / 300
        # Combined metrics
        matchup_quality = (h_wp82 + a_wp82) / 2  # How good is this game?
        competitiveness = 1 - abs(h_wp82 - a_wp82)  # How close are teams?
        upset_potential = max(0, a_wp82 - h_wp82)  # Away team better?

        row.extend([
            h_tanking, a_tanking, h_playoff_fight, a_playoff_fight, h_elite, a_elite,
            h_trajectory, a_trajectory, h_trajectory - a_trajectory,
            h_vol, a_vol, abs(h_vol - a_vol),
            h_drtg, a_drtg, h_ortg, a_ortg, h_netrtg, a_netrtg, h_netrtg - a_netrtg,
            h_pace, a_pace, pace_diff,
            h_close_wp, a_close_wp, h_close_wp - a_close_wp,
            h_blowout_rate, a_blowout_rate,
            h_recent_sos, a_recent_sos, h_recent_sos - a_recent_sos,
            h_quality_diff, a_quality_diff,
            h_accel, a_accel, h_accel - a_accel,
            h_elo_conf, a_elo_conf,
            matchup_quality, competitiveness, upset_potential,
            # Interaction features
            h_wp82 * h_rest, a_wp82 * a_rest,  # quality × rest
            h_netrtg * float(h_rest >= 2), a_netrtg * float(a_rest >= 2),  # net rating when rested
            h_trajectory * h_gp, a_trajectory * a_gp,  # trajectory weighted by games played
            (team_elo[home] - team_elo[away]) * sp,  # Elo diff × season phase
            competitiveness * sp,  # Tighter games matter more late season
            h_close_wp * competitiveness,  # Clutch ability in close matchups
        ])
        if first:
            names.extend([
                "h_tanking", "a_tanking", "h_playoff_fight", "a_playoff_fight", "h_elite", "a_elite",
                "h_trajectory", "a_trajectory", "trajectory_diff",
                "h_volatility", "a_volatility", "volatility_diff",
                "h_drtg", "a_drtg", "h_ortg", "a_ortg", "h_netrtg", "a_netrtg", "netrtg_diff",
                "h_pace", "a_pace", "pace_diff",
                "h_clutch_wp", "a_clutch_wp", "clutch_diff",
                "h_blowout_rate", "a_blowout_rate",
                "h_recent_sos", "a_recent_sos", "recent_sos_diff",
                "h_quality_diff", "a_quality_diff",
                "h_form_accel", "a_form_accel", "accel_diff",
                "h_elo_confidence", "a_elo_confidence",
                "matchup_quality", "competitiveness", "upset_potential",
                "h_quality_rest", "a_quality_rest",
                "h_netrtg_rested", "a_netrtg_rested",
                "h_traj_weighted", "a_traj_weighted",
                "elo_season_interaction", "compete_season_interaction",
                "clutch_compete_interaction",
            ])

        # ── CROSS-WINDOW MOMENTUM + INTERACTIONS (v3 — Adam/Evolution Agent) ──
        for prefix, tr in [("h", hr_), ("a", ar_)]:
            wp_accel_v = wp(tr, 3) - 2 * wp(tr, 10) + wp(tr, 20) if len(tr) >= 20 else 0.0
            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 = pts_for ** 13.91 / max(1, pts_for ** 13.91 + pts_against ** 13.91) if pts_for > 0 else 0.5
            pts_l = [x[4] for x in tr[-10:]] if len(tr) >= 5 else [100]
            p_vol = (sum((p - sum(pts_l)/len(pts_l))**2 for p in pts_l) / len(pts_l)) ** 0.5 if len(pts_l) > 1 else 0
            recent_w = [x for x in tr[-10:] if x[1]]
            w_qual = sum(wp(team_results[x[3]], 82) for x in recent_w) / max(len(recent_w), 1) if recent_w else 0.5
            margins_10 = [x[2] for x in tr[-10:]] if len(tr) >= 5 else [0]
            if len(margins_10) >= 3:
                xv = list(range(len(margins_10))); xm = sum(xv)/len(xv); ym = sum(margins_10)/len(margins_10)
                m_slope = sum((x-xm)*(y-ym) for x,y in zip(xv,margins_10)) / max(sum((x-xm)**2 for x in xv), 1e-9)
            else:
                m_slope = 0.0
            row.extend([wp_accel_v, pyth, p_vol / 10.0, w_qual, m_slope,
                         ppg(tr, 3) / max(ppg(tr, 20), 1), papg(tr, 3) / max(papg(tr, 20), 1)])
            if first:
                names.extend([f"{prefix}_wp_accel", f"{prefix}_pyth_exp", f"{prefix}_pts_vol",
                              f"{prefix}_win_quality", f"{prefix}_margin_slope",
                              f"{prefix}_off_ratio", f"{prefix}_def_ratio"])
        # Key interaction features
        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, wp_d ** 2, elo_d ** 2 / 10000.0,
            h_netrtg * a_netrtg / 100.0,
            float(h_wp82 > 0.6 and a_wp82 < 0.4), float(h_rest >= 3 and a_rest <= 1),
        ])
        if first:
            names.extend(["elo_rest_x", "wp_diff_sq", "elo_diff_sq",
                          "netrtg_product", "mismatch_flag", "rest_mismatch_flag"])

        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))

    return np.nan_to_num(np.array(X, dtype=np.float64)), np.array(y, dtype=np.int32), feature_names


# ═══════════════════════════════════════════════════════
# GENETIC INDIVIDUAL
# ═══════════════════════════════════════════════════════

# All model types the GA can evolve (14 total)
ALL_MODEL_TYPES = [
    # Tree-based (fast, reliable)
    "xgboost", "xgboost_brier", "lightgbm", "lightgbm_brier", "catboost", "random_forest", "extra_trees",
    # Ensemble
    "stacking",
    # Neural nets (slower, potentially more powerful)
    "mlp", "lstm", "transformer", "tabnet", "ft_transformer", "deep_ensemble",
    # AutoML
    "autogluon",
]

# Neural net types (need special memory handling)
NEURAL_NET_TYPES = {"lstm", "transformer", "tabnet", "ft_transformer", "deep_ensemble", "mlp", "autogluon"}

# Fast model types (for islands that prioritize speed)
FAST_MODEL_TYPES = ["xgboost", "xgboost_brier", "lightgbm", "lightgbm_brier", "random_forest", "extra_trees", "logistic_regression"]

# CPU-viable model types (tree-based + stacking w/ MLP meta-learner, excludes neural nets)
# Stacking re-added: v2 MLP(50,50) meta-learner replaces LR (was 0.24733, expect -0.003 Brier)
# logistic_regression added: MDPI 2026 shows LR achieves best Brier (0.199) among tabular models
# due to inherent calibration — beating XGBoost (0.202) and RF on probability quality
# lightgbm_brier added: LGBMRegressor(MSE) on binary labels = Brier minimisation (Apr 8, cycle79)
CPU_MODEL_TYPES = ["xgboost", "xgboost_brier", "lightgbm", "lightgbm_brier", "catboost", "random_forest", "extra_trees", "logistic_regression", "stacking"]


# ── Custom Brier objective for XGBoost ──
def _brier_objective(y_true, y_pred):
    """Custom XGBoost objective that directly minimizes Brier score.
    Brier = (sigmoid(raw) - y)^2, so gradient = 2*(p-y)*p*(1-p), hess ≈ 2*p*(1-p).
    Note: XGBoost sklearn API (>=2.0) passes (labels, preds) as numpy arrays."""
    p = 1.0 / (1.0 + np.exp(-np.clip(y_pred, -30, 30)))
    grad = 2.0 * (p - y_true) * p * (1.0 - p)
    hess = 2.0 * p * (1.0 - p) + 1e-6  # Simplified + stability
    return grad, hess


# ── LightGBM Brier classifier — MSE on binary labels = Brier minimisation ──
# Training LGBMRegressor(objective='regression') on y∈{0,1} directly minimises
# E[(p-y)^2] = Brier score. Avoids custom-objective predict_proba complications.
# Added: cycle79 Apr 8, 2026 — arXiv 2508.02725 Aug 2025 (NCAA: Brier-loss → −0.016 vs BCE)
class LGBMBrierClassifier(BaseEstimator, ClassifierMixin):
    """sklearn-compatible wrapper: LGBMRegressor trained on binary labels.
    Equivalent to minimising Brier score directly. predict_proba-compatible.
    Inherits BaseEstimator for get_params/set_params (required by sklearn clone)."""

    def __init__(self, n_estimators=100, max_depth=-1, learning_rate=0.05,
                 subsample=0.8, num_leaves=31, reg_alpha=0.0, reg_lambda=1.0,
                 min_child_samples=20, feature_fraction=0.7,
                 random_state=42, n_jobs=-1):
        self._reg = lgbm.LGBMRegressor(
            n_estimators=n_estimators, max_depth=max_depth,
            learning_rate=learning_rate, subsample=subsample,
            num_leaves=num_leaves, reg_alpha=reg_alpha, reg_lambda=reg_lambda,
            min_child_samples=min_child_samples, colsample_bytree=feature_fraction,
            objective='regression',  # MSE on {0,1} labels = Brier minimisation
            random_state=random_state, n_jobs=n_jobs, verbose=-1,
        )
        self.classes_ = np.array([0, 1])

    def fit(self, X, y, **kwargs):
        self._reg.fit(X, y)
        return self

    def predict_proba(self, X):
        p = np.clip(self._reg.predict(X), 0.0, 1.0)
        return np.column_stack([1.0 - p, p])

    def predict(self, X):
        p = self._reg.predict(X)
        return (p >= 0.5).astype(int)


class Individual:
    MAX_FEATURES = 200  # Hard cap — individuals above this waste compute

    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(50, 300),
            "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(CPU_MODEL_TYPES if not _HAS_GPU else ALL_MODEL_TYPES),
            "calibration": random.choices(["none", "sigmoid", "venn_abers", "beta", "lr_meta", "lr_platt", "isotonic_temporal"], weights=[11, 12, 22, 22, 9, 10, 14], k=1)[0],  # cycle97: 2x isotonic_temporal (MDPI2026 ~0.199 Brier LR+isotonic)
            # Neural net hyperparams (used only for NN model types)
            "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, "composite": 0.0}
        self.pareto_rank = 999   # NSGA-II rank (0 = Pareto front)
        self.crowding_dist = 0.0  # NSGA-II crowding distance
        self.island_id = -1       # Which island this individual belongs to
        self.generation = 0
        self._enforce_feature_cap()

    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 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": dict(self.hyperparams),
                "fitness": dict(self.fitness), "generation": self.generation,
                "pareto_rank": self.pareto_rank, "island_id": self.island_id,
                "feature_indices": self.selected_indices()}

    @staticmethod
    def crossover(p1, p2):
        child = Individual.__new__(Individual)
        n = len(p1.features)
        pt1, pt2 = sorted(random.sample(range(n), 2))
        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]
                child.hyperparams[key] = int(round(val)) if isinstance(p1.hyperparams[key], int) else val
            elif isinstance(p1.hyperparams[key], bool):
                child.hyperparams[key] = random.choice([p1.hyperparams[key], p2.hyperparams[key]])
            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, "composite": 0.0}
        child.pareto_rank = 999
        child.crowding_dist = 0.0
        child.island_id = random.choice([p1.island_id, p2.island_id]) if hasattr(p1, 'island_id') else -1
        child.generation = max(p1.generation, p2.generation) + 1
        child._enforce_feature_cap()
        return child

    def mutate(self, rate=0.03, feature_importance=None):
        """Directed mutation: bias towards features that top performers use."""
        for i in range(len(self.features)):
            if random.random() < rate:
                if feature_importance is not None and i < len(feature_importance):
                    imp = feature_importance[i]
                    if self.features[i] == 0 and imp > 0.5:
                        self.features[i] = 1
                    elif self.features[i] == 1 and imp < 0.15:
                        self.features[i] = 0
                    else:
                        self.features[i] = 1 - self.features[i]
                else:
                    self.features[i] = 1 - self.features[i]
        if random.random() < 0.15: self.hyperparams["n_estimators"] = max(50, min(200, self.hyperparams["n_estimators"] + random.randint(-50, 50)))
        if random.random() < 0.15: self.hyperparams["max_depth"] = max(2, min(8, self.hyperparams["max_depth"] + random.randint(-2, 2)))
        if random.random() < 0.15: self.hyperparams["learning_rate"] = max(0.001, min(0.3, self.hyperparams["learning_rate"] * 10 ** random.uniform(-0.3, 0.3)))
        if random.random() < 0.08: self.hyperparams["model_type"] = random.choice(CPU_MODEL_TYPES if not _HAS_GPU else ALL_MODEL_TYPES)
        # Calibration mutation: venn_abers boosted 14→25 to match init weight and preserve demonstrated
        # advantage (S13 pareto_best_brier 0.21773 used venn_abers; delta -0.00543 vs no calibration).
        # "none" reduced 22→16: GA was drifting back to uncalibrated models, losing hard-won gains.
        # Brain cycle 82, 2026-04-09.
        if random.random() < 0.05: self.hyperparams["calibration"] = random.choices(["none", "sigmoid", "venn_abers", "beta", "lr_meta", "lr_platt", "isotonic_temporal"], weights=[9, 12, 25, 20, 9, 10, 15], k=1)[0]  # cycle97: 2x isotonic_temporal weight
        # Neural net hyperparams mutation
        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)))
        if random.random() < 0.10: self.hyperparams["nn_epochs"] = max(10, min(200, self.hyperparams.get("nn_epochs", 50) + random.randint(-20, 20)))
        self._enforce_feature_cap()


# ═══════════════════════════════════════════════════════
# NSGA-II PARETO RANKING
# ═══════════════════════════════════════════════════════

def _dominates(a, b):
    """Individual a dominates b if a is no worse in all objectives and strictly better in at least one.
    Objectives: minimize brier, maximize roi, maximize sharpe, minimize calibration, minimize features.
    Feature count is a 5th objective to prevent bloated genomes (Feat=200 takeover)."""
    fa, fb = a.fitness, b.fitness
    # Parsimony pressure: penalize feature bloat as a real objective
    a_feat_score = -min(a.n_features, 200) / 200.0  # lower features = higher score (negated for minimize)
    b_feat_score = -min(b.n_features, 200) / 200.0
    a_vals = (-fa["brier"], fa["roi"], fa["sharpe"], -fa["calibration"], a_feat_score)
    b_vals = (-fb["brier"], fb["roi"], fb["sharpe"], -fb["calibration"], b_feat_score)
    at_least_one_better = False
    for av, bv in zip(a_vals, b_vals):
        if av < bv:
            return False
        if av > bv:
            at_least_one_better = True
    return at_least_one_better


def nsga2_rank(population):
    """Assign NSGA-II Pareto rank and crowding distance to each individual.
    Returns population sorted by (rank ASC, crowding_dist DESC)."""
    n = len(population)
    if n == 0:
        return population

    # Fast non-dominated sorting
    dominated_by = [0] * n  # count of how many dominate this individual
    dominates_set = [[] for _ in range(n)]  # indices this individual dominates
    fronts = [[]]

    for i in range(n):
        for j in range(i + 1, n):
            if _dominates(population[i], population[j]):
                dominates_set[i].append(j)
                dominated_by[j] += 1
            elif _dominates(population[j], population[i]):
                dominates_set[j].append(i)
                dominated_by[i] += 1

    for i in range(n):
        if dominated_by[i] == 0:
            population[i].pareto_rank = 0
            fronts[0].append(i)

    rank = 0
    while fronts[rank]:
        next_front = []
        for i in fronts[rank]:
            for j in dominates_set[i]:
                dominated_by[j] -= 1
                if dominated_by[j] == 0:
                    population[j].pareto_rank = rank + 1
                    next_front.append(j)
        rank += 1
        fronts.append(next_front)

    # Crowding distance per front (5 objectives including parsimony)
    objectives = [
        lambda ind: ind.fitness["brier"],       # minimize
        lambda ind: -ind.fitness["roi"],         # maximize (negate for sorting)
        lambda ind: -ind.fitness["sharpe"],      # maximize
        lambda ind: ind.fitness["calibration"],  # minimize
        lambda ind: ind.n_features / 200.0,     # minimize (parsimony pressure)
    ]

    for front_indices in fronts:
        if not front_indices:
            continue
        front = [population[i] for i in front_indices]
        for ind in front:
            ind.crowding_dist = 0.0

        for obj_fn in objectives:
            front_sorted = sorted(range(len(front)), key=lambda k: obj_fn(front[k]))
            front[front_sorted[0]].crowding_dist = float('inf')
            front[front_sorted[-1]].crowding_dist = float('inf')
            obj_range = obj_fn(front[front_sorted[-1]]) - obj_fn(front[front_sorted[0]])
            if obj_range < 1e-10:
                continue
            for k in range(1, len(front_sorted) - 1):
                front[front_sorted[k]].crowding_dist += (
                    obj_fn(front[front_sorted[k + 1]]) - obj_fn(front[front_sorted[k - 1]])
                ) / obj_range

    # Also compute composite for backwards compatibility (weighted sum)
    for ind in population:
        f = ind.fitness
        feature_penalty = 0.003 * max(0, ind.n_features - 80)  # Stronger penalty: 3x, threshold 80
        ind.fitness["composite"] = round(
            0.40 * (1 - f["brier"]) +
            0.25 * max(0, f["roi"]) +
            0.20 * max(0, min(f["sharpe"], 3) / 3) +
            0.15 * (1 - f["calibration"])
            - feature_penalty, 5)

    # Sort: primary = pareto_rank ASC, secondary = crowding_dist DESC
    population.sort(key=lambda x: (x.pareto_rank, -x.crowding_dist))
    return population


# ═══════════════════════════════════════════════════════
# ISLAND MODEL
# ═══════════════════════════════════════════════════════

class IslandModel:
    """Manages multiple sub-populations (islands) with periodic migration."""

    def __init__(self, n_islands=5, island_size=100, n_features=164,
                 target_features=65, migration_interval=10, migrants_per_island=5):
        self.n_islands = n_islands
        self.island_size = island_size
        self.total_pop = n_islands * island_size
        self.n_features = n_features
        self.target_features = target_features
        self.migration_interval = migration_interval
        self.migrants_per_island = migrants_per_island
        self.islands = []  # list of lists of Individuals

        # Each island can specialize — assign model type biases
        # On CPU (all HF Spaces), neural models are skipped (brier=0.28 penalty).
        # Use all 5 islands for productive CPU tree-based exploration.
        if _HAS_GPU:
            self.island_specializations = [
                FAST_MODEL_TYPES,                                      # Island 0: fast tree models
                ["catboost", "stacking", "extra_trees"],               # Island 1: ensemble specialists
                ["mlp", "tabnet", "ft_transformer"],                   # Island 2: neural nets
                ["lstm", "transformer", "deep_ensemble"],              # Island 3: deep learning
                ALL_MODEL_TYPES,                                       # Island 4: unrestricted
            ]
        else:
            self.island_specializations = [
                ["extra_trees", "random_forest"],                      # Island 0: tree specialists (best models)
                ["xgboost", "xgboost_brier"],                          # Island 1: XGBoost variants
                ["lightgbm", "catboost"],                              # Island 2: gradient boosters
                ["catboost", "extra_trees", "random_forest"],             # Island 3: diverse trees
                FAST_MODEL_TYPES,                                      # Island 4: unrestricted fast
            ]

    def initialize(self):
        """Create initial population across all islands."""
        self.islands = []
        for island_id in range(self.n_islands):
            island = []
            specialization = self.island_specializations[island_id]
            for _ in range(self.island_size):
                mt = random.choice(specialization)
                ind = Individual(self.n_features, self.target_features, model_type=mt)
                ind.island_id = island_id
                island.append(ind)
            self.islands.append(island)

    def get_all_individuals(self):
        """Flatten all islands into a single list."""
        return [ind for island in self.islands for ind in island]

    def set_all_individuals(self, population):
        """Distribute a flat population back into islands."""
        self.islands = []
        for island_id in range(self.n_islands):
            start = island_id * self.island_size
            end = start + self.island_size
            island = population[start:end]
            for ind in island:
                ind.island_id = island_id
            self.islands.append(island)
        # Handle any remainder (from injections, etc.)
        remainder = population[self.n_islands * self.island_size:]
        if remainder:
            for ind in remainder:
                target_island = random.randint(0, self.n_islands - 1)
                ind.island_id = target_island
                self.islands[target_island].append(ind)

    def migrate(self, generation):
        """Migrate best individuals between islands every migration_interval generations."""
        if generation % self.migration_interval != 0 or generation == 0:
            return False

        n_migrate = self.migrants_per_island
        # Collect best from each island
        migrants = []
        for island in self.islands:
            island.sort(key=lambda x: (x.pareto_rank, -x.crowding_dist))
            best = island[:n_migrate]
            # Deep copy migrants (they stay on original island too)
            for ind in best:
                clone = Individual.__new__(Individual)
                clone.features = ind.features[:]
                clone.hyperparams = dict(ind.hyperparams)
                clone.fitness = dict(ind.fitness)
                clone.pareto_rank = ind.pareto_rank
                clone.crowding_dist = ind.crowding_dist
                clone.n_features = ind.n_features
                clone.generation = ind.generation
                migrants.append(clone)

        random.shuffle(migrants)

        # Distribute migrants to next island (ring topology)
        for i, island in enumerate(self.islands):
            # Remove worst n_migrate from this island
            island.sort(key=lambda x: (x.pareto_rank, -x.crowding_dist))
            island_trimmed = island[:self.island_size - n_migrate]
            # Add migrants from the pool
            received = migrants[i * n_migrate:(i + 1) * n_migrate]
            for ind in received:
                ind.island_id = i
            island_trimmed.extend(received)
            self.islands[i] = island_trimmed

        return True

    def get_island_stats(self):
        """Return per-island statistics."""
        stats = []
        for i, island in enumerate(self.islands):
            if not island:
                stats.append({"island": i, "size": 0})
                continue
            models = Counter(ind.hyperparams["model_type"] for ind in island)
            briers = [ind.fitness["brier"] for ind in island if ind.fitness["brier"] < 1.0]
            stats.append({
                "island": i,
                "size": len(island),
                "specialization": self.island_specializations[i],
                "model_dist": dict(models.most_common(5)),
                "best_brier": min(briers) if briers else 1.0,
                "avg_brier": sum(briers) / len(briers) if briers else 1.0,
                "pareto_front_count": sum(1 for ind in island if ind.pareto_rank == 0),
            })
        return stats

    def to_state_dict(self):
        """Serialize for persistence."""
        return {
            "n_islands": self.n_islands,
            "island_size": self.island_size,
            "migration_interval": self.migration_interval,
            "migrants_per_island": self.migrants_per_island,
            "islands": [
                [{"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,
                  "island_id": ind.island_id,
                  "pareto_rank": getattr(ind, 'pareto_rank', 999)}
                 for ind in island]
                for island in self.islands
            ]
        }

    @classmethod
    def from_state_dict(cls, state, n_features):
        """Restore from persisted state."""
        im = cls(
            n_islands=state["n_islands"],
            island_size=state.get("island_size", 100),
            n_features=n_features,
            migration_interval=state.get("migration_interval", 10),
            migrants_per_island=state.get("migrants_per_island", 5),
        )
        im.islands = []
        for island_data in state["islands"]:
            island = []
            for d in island_data:
                ind = Individual.__new__(Individual)
                ind.features = d["features"]
                ind.hyperparams = d["hyperparams"]
                ind.fitness = d["fitness"]
                ind.generation = d.get("generation", 0)
                ind.island_id = d.get("island_id", -1)
                ind.pareto_rank = d.get("pareto_rank", 999)
                ind.crowding_dist = 0.0
                ind.n_features = sum(ind.features)
                # Ensure new hyperparams exist
                ind.hyperparams.setdefault("nn_hidden_dims", 128)
                ind.hyperparams.setdefault("nn_n_layers", 2)
                ind.hyperparams.setdefault("nn_dropout", 0.3)
                ind.hyperparams.setdefault("nn_epochs", 50)
                ind.hyperparams.setdefault("nn_batch_size", 64)
                # Ensure model_type is valid (on CPU, force tree-based models)
                _valid_types = CPU_MODEL_TYPES if not _HAS_GPU else ALL_MODEL_TYPES
                if ind.hyperparams.get("model_type") not in _valid_types:
                    ind.hyperparams["model_type"] = random.choice(_valid_types)
                island.append(ind)
            im.islands.append(island)
        return im


def _gc_cleanup():
    """Force garbage collection to manage 16GB RAM with 500 individuals."""
    gc.collect()
    try:
        import torch
        if torch.cuda.is_available():
            torch.cuda.empty_cache()
    except ImportError:
        pass


# ═══════════════════════════════════════════════════════
# FITNESS EVALUATION
# ═══════════════════════════════════════════════════════

def _evaluate_stacking(ind, X_sub, y_eval, hp_eval, n_splits, fast):
    """Stacking: XGBoost + LightGBM + CatBoost + ExtraTrees base models → LogisticRegression meta-learner.
    Uses 4 diverse base models for maximum ensemble benefit. CatBoost forced to CPU to avoid CUDA conflicts."""
    splits = n_splits if fast else max(n_splits, 3)
    tscv = TimeSeriesSplit(n_splits=splits)
    base_est = min(hp_eval.get("n_estimators", 100), 100)
    depth = min(hp_eval.get("max_depth", 6), 6)
    lr = hp_eval.get("learning_rate", 0.1)

    briers, rois, all_p, all_y = [], [], [], []
    PURGE_GAP = 5
    for ti, vi in tscv.split(X_sub):
        try:
            # Purge last PURGE_GAP games from training to prevent temporal leakage
            ti_safe = ti[:-PURGE_GAP] if len(ti) > PURGE_GAP + 50 else ti
            X_tr, y_tr = X_sub[ti_safe], y_eval[ti_safe]
            X_val, y_val = X_sub[vi], y_eval[vi]

            # Build 4 diverse base models
            base_models = []
            # XGBoost — gradient boosting with histogram
            base_models.append(xgb.XGBClassifier(
                n_estimators=base_est, max_depth=depth, learning_rate=lr,
                subsample=hp_eval.get("subsample", 0.8),
                colsample_bytree=hp_eval.get("colsample_bytree", 0.8),
                reg_alpha=0.01, reg_lambda=0.1,
                eval_metric="logloss", random_state=42, n_jobs=-1, tree_method="hist"))
            # LightGBM — leaf-wise boosting (different inductive bias)
            base_models.append(lgbm.LGBMClassifier(
                n_estimators=base_est, max_depth=depth, learning_rate=lr,
                subsample=hp_eval.get("subsample", 0.8),
                num_leaves=min(2 ** depth - 1, 31),
                reg_alpha=0.01, reg_lambda=0.1,
                min_child_samples=20, feature_fraction=0.7,
                boosting_type="dart", drop_rate=0.1,
                verbose=-1, random_state=42, n_jobs=-1))
            # CatBoost — ordered boosting (FORCED CPU to avoid CUDA device conflicts)
            try:
                from catboost import CatBoostClassifier
                base_models.append(CatBoostClassifier(
                    iterations=min(base_est, 100), depth=min(depth, 6),
                    learning_rate=lr, l2_leaf_reg=max(hp_eval.get("reg_lambda", 3.0), 1.0),
                    verbose=0, random_state=42,
                    task_type='CPU', thread_count=-1))
            except (ImportError, Exception):
                from sklearn.ensemble import RandomForestClassifier
                base_models.append(RandomForestClassifier(
                    n_estimators=base_est, max_depth=depth,
                    random_state=42, n_jobs=-1))
            # ExtraTrees — randomized splits (more diversity for stacking)
            from sklearn.ensemble import ExtraTreesClassifier
            base_models.append(ExtraTreesClassifier(
                n_estimators=base_est, max_depth=depth,
                min_samples_leaf=5, max_features="sqrt",
                random_state=42, n_jobs=-1))

            # Get OOF predictions from each base model using inner CV
            inner_cv = TimeSeriesSplit(n_splits=4)
            oof_preds = np.zeros((len(X_tr), len(base_models)))
            for m_idx, bm in enumerate(base_models):
                try:
                    oof = cross_val_predict(bm, X_tr, y_tr, cv=inner_cv, method="predict_proba")[:, 1]
                    oof_preds[:, m_idx] = oof
                except Exception:
                    oof_preds[:, m_idx] = 0.5

            # Train meta-learner on OOF predictions (regularized to prevent stacking overfit)
            # Calibrate meta-learner with Platt scaling for better probability estimates
            # v2: MLP meta-learner (was LR, -0.003 Brier expected)
            meta_base = MLPClassifier(hidden_layer_sizes=(50, 50), max_iter=500,
                                      early_stopping=True, validation_fraction=0.15,
                                      learning_rate='adaptive', random_state=42)
            try:
                meta = CalibratedClassifierCV(meta_base, method='sigmoid', cv=3)
                meta.fit(oof_preds, y_tr)
            except Exception:
                # Fallback: uncalibrated if not enough data for calibration CV
                meta = meta_base
                meta.fit(oof_preds, y_tr)

            # Train base models on full training fold for validation predictions
            val_preds = np.zeros((len(X_val), len(base_models)))
            for m_idx, bm in enumerate(base_models):
                try:
                    bm_fresh = type(bm)(**bm.get_params())
                    bm_fresh.fit(X_tr, y_tr)
                    val_preds[:, m_idx] = bm_fresh.predict_proba(X_val)[:, 1]
                except Exception:
                    val_preds[:, m_idx] = 0.5

            # Final stacked prediction
            p = meta.predict_proba(val_preds)[:, 1]
            briers.append(brier_score_loss(y_val, p))
            rois.append(_log_loss_score(p, y_val))
            all_p.extend(p); all_y.extend(y_val)
        except Exception as e:
            log(f"Stacking fold failed: {str(e)[:80]}", "WARN")
            briers.append(0.28); rois.append(0.0)

    return briers, rois, all_p, all_y


def _prune_correlated_features(X_sub, threshold=0.95):
    """Drop redundant features: for any pair with |corr| > threshold, drop the one with lower variance.

    Args:
        X_sub: numpy array (n_samples, n_features) — already selected features
        threshold: correlation threshold (default 0.95)

    Returns:
        (X_pruned, keep_mask): pruned array and boolean mask of kept column indices
    """
    try:
        n_cols = X_sub.shape[1]
        if n_cols < 2:
            return X_sub, np.ones(n_cols, dtype=bool)

        # Compute pairwise Pearson correlation
        corr = np.corrcoef(X_sub, rowvar=False)

        # Handle NaN correlations (constant columns, etc.)
        corr = np.nan_to_num(corr, nan=0.0)

        # Compute variance for each column (used to decide which to drop)
        variances = np.var(X_sub, axis=0)

        # Greedy pruning: iterate upper triangle, mark lower-variance feature for removal
        to_drop = set()
        for i in range(n_cols):
            if i in to_drop:
                continue
            for j in range(i + 1, n_cols):
                if j in to_drop:
                    continue
                if abs(corr[i, j]) > threshold:
                    # Drop the feature with lower variance
                    if variances[i] < variances[j]:
                        to_drop.add(i)
                        break  # i is dropped, no need to check more pairs for i
                    else:
                        to_drop.add(j)

        keep_mask = np.ones(n_cols, dtype=bool)
        for idx in to_drop:
            keep_mask[idx] = False

        return X_sub[:, keep_mask], keep_mask
    except Exception:
        # If anything fails, skip pruning entirely
        return X_sub, np.ones(X_sub.shape[1], dtype=bool)


EVAL_TIMEOUT_S = 120  # Max seconds per individual evaluation — prevents hung models

def _eval_with_timeout(fn, timeout, *args, **kwargs):
    """Run fn with a wall-clock timeout. Returns True if completed, False if timed out."""
    from concurrent.futures import ThreadPoolExecutor, TimeoutError as FuturesTimeout
    with ThreadPoolExecutor(max_workers=1) as pool:
        try:
            pool.submit(fn, *args, **kwargs).result(timeout=timeout)
            return True
        except FuturesTimeout:
            return False
        except Exception:
            return False

def evaluate(ind, X, y, n_splits=2, fast=True, eval_counter=[0]):
    """Two-tier evaluation: fast (subsample + 2-fold) or full (all data + 3-fold).
    Includes memory management for 16GB RAM and per-eval timeout."""
    # Periodic GC to manage memory with large population
    eval_counter[0] += 1
    if eval_counter[0] % GC_INTERVAL == 0:
        _gc_cleanup()

    # Neural net models: cap features more aggressively to reduce memory
    is_nn = ind.hyperparams.get("model_type") in NEURAL_NET_TYPES
    max_features = 120 if is_nn else 200

    selected = ind.selected_indices()
    if len(selected) < 15 or len(selected) > max_features:
        ind.fitness = {"brier": 0.30, "roi": 0.0, "sharpe": 0.0, "calibration": 0.15, "composite": -1.0,
                       "features_pruned": 0}
        return

    # Skip neural models entirely on CPU — they're too slow
    if is_nn and not _HAS_GPU:
        ind.fitness = {"brier": 0.28, "roi": 0.0, "sharpe": 0.0, "calibration": 0.15, "composite": -0.5,
                       "features_pruned": 0}
        return

    # Fast mode: subsample recent games for speed
    if fast and X.shape[0] > FAST_EVAL_GAMES:
        X_eval, y_eval = X[-FAST_EVAL_GAMES:], y[-FAST_EVAL_GAMES:]
    else:
        X_eval, y_eval = X, y

    X_sub = np.nan_to_num(X_eval[:, selected], nan=0.0, posinf=1e6, neginf=-1e6)

    # ── Correlation pruning: drop redundant features (|corr| > 0.95) ──
    n_before = X_sub.shape[1]
    X_sub, _keep_mask = _prune_correlated_features(X_sub, threshold=0.95)
    n_pruned = n_before - X_sub.shape[1]

    hp = ind.hyperparams

    # Cap estimators for speed (fast mode) — 80 is enough for ranking on CPU
    hp_eval = dict(hp)
    if fast:
        hp_eval["n_estimators"] = min(hp["n_estimators"], 80)

    # ── STACKING: special path ──
    if hp_eval["model_type"] == "stacking":
        briers, rois, all_p, all_y = _evaluate_stacking(ind, X_sub, y_eval, hp_eval, n_splits, fast)
    else:
        # ── Standard single-model path ──
        model = _build(hp_eval)
        if model is None: ind.fitness["composite"] = -1.0; return

        splits = n_splits if fast else max(n_splits, 3)
        tscv = TimeSeriesSplit(n_splits=splits)
        briers, rois, all_p, all_y = [], [], [], []
        PURGE_GAP = 5  # 5-game buffer between train/test to prevent lookahead
        for ti, vi in tscv.split(X_sub):
            try:
                # Purge last PURGE_GAP games from training to avoid temporal leakage
                ti_safe = ti[:-PURGE_GAP] if len(ti) > PURGE_GAP + 50 else ti
                m = clone(model)
                # Calibration: none (default), sigmoid (Platt), venn_abers (MAPIE), beta (BetaCalibration), or lr_meta (LR meta-calibration)
                cal_method = hp_eval.get("calibration", "none")
                if cal_method == "isotonic":
                    cal_method = "none"  # Isotonic empirically hurts Brier (+0.003 to +0.007)
                _beta_cal = None    # beta calibrator applied post-predict
                _lr_meta_cal = None  # LR meta-calibrator applied post-predict
                _platt_cal = None  # LR Platt scaler applied post-predict
                _model_fitted = False  # tracks whether m.fit() was already called
                if cal_method == "venn_abers":
                    try:
                        from mapie.classification import MapieClassifier
                        m_inner = clone(m)
                        m_inner.fit(X_sub[ti_safe], y_eval[ti_safe])
                        mapie = MapieClassifier(m_inner, method="lac", cv="prefit")
                        mapie.fit(X_sub[ti_safe[-200:]], y_eval[ti_safe[-200:]])
                        m = mapie  # MapieClassifier wraps fitted model
                        _model_fitted = True
                        cal_method = "none"
                    except (ImportError, Exception):
                        cal_method = "none"  # Fallback if MAPIE not installed
                if cal_method == "beta":
                    try:
                        from betacal import BetaCalibration
                        # Fit base model, then fit beta calibrator on a held-out slice
                        m.fit(X_sub[ti_safe], y_eval[ti_safe])
                        _model_fitted = True
                        cal_slice = ti_safe[-200:] if len(ti_safe) > 200 else ti_safe
                        raw_p = m.predict_proba(X_sub[cal_slice])[:, 1]
                        _beta_cal = BetaCalibration(parameters="abm")
                        _beta_cal.fit(raw_p.reshape(-1, 1), y_eval[cal_slice])
                        cal_method = "none"
                    except (ImportError, Exception):
                        cal_method = "none"  # Fallback if betacal not installed
                if cal_method == "lr_meta":
                    try:
                        # LR meta-calibration: train base model, fit 1-feature LR on held-out raw probs.
                        # Equivalent to Platt scaling but trained explicitly on a temporal hold-out slice
                        # rather than via sklearn's cross-validated CalibratedClassifierCV.  This avoids
                        # the small-fold instability that sigmoid cv=3 can suffer on <200 samples.
                        m.fit(X_sub[ti_safe], y_eval[ti_safe])
                        _model_fitted = True
                        cal_slice = ti_safe[-200:] if len(ti_safe) > 200 else ti_safe
                        raw_p = m.predict_proba(X_sub[cal_slice])[:, 1]
                        _lr_meta_cal = LogisticRegression(
                            C=1.0, solver="lbfgs", max_iter=500, random_state=42
                        )
                        _lr_meta_cal.fit(raw_p.reshape(-1, 1), y_eval[cal_slice])
                        cal_method = "none"
                    except Exception:
                        cal_method = "none"  # Fallback: uncalibrated
                if cal_method == "lr_platt":
                    # Post-hoc Platt scaling: fit base model, then LR on held-out probs
                    # More reliable than CalibratedClassifierCV(cv=3) with time series data
                    m.fit(X_sub[ti_safe], y_eval[ti_safe])
                    _model_fitted = True
                    cal_size = min(400, max(50, len(ti_safe) // 3))
                    if len(ti_safe) > cal_size + 50:
                        cal_slice = ti_safe[-cal_size:]
                    else:
                        cal_slice = ti_safe
                    raw_p = m.predict_proba(X_sub[cal_slice])[:, 1].reshape(-1, 1)
                    _platt_cal = LogisticRegression(C=1.0, max_iter=200, random_state=42)
                    try:
                        _platt_cal.fit(raw_p, y_eval[cal_slice])
                    except Exception:
                        _platt_cal = None
                    cal_method = "none"
                _isotonic_cal = None
                if cal_method == "isotonic_temporal":
                    # Temporal isotonic calibration: uses held-out slice (not CV folds).
                    # Avoids the overfitting failure of sklearn's CalibratedClassifierCV(method='isotonic').
                    # Research (MDPI 2026): isotonic on temporal holdout achieves Brier ~0.199 for LR.
                    # Reliable on NBA dataset (9500+ games >> 1000-sample threshold for isotonic).
                    try:
                        from sklearn.isotonic import IsotonicRegression
                        m.fit(X_sub[ti_safe], y_eval[ti_safe])
                        _model_fitted = True
                        cal_size = min(400, max(50, len(ti_safe) // 3))
                        cal_slice = ti_safe[-cal_size:] if len(ti_safe) > cal_size + 50 else ti_safe
                        raw_p = m.predict_proba(X_sub[cal_slice])[:, 1]
                        _isotonic_cal = IsotonicRegression(out_of_bounds="clip")
                        _isotonic_cal.fit(raw_p, y_eval[cal_slice])
                    except Exception:
                        _isotonic_cal = None
                    cal_method = "none"
                if cal_method == "sigmoid":
                    m = CalibratedClassifierCV(m, method=cal_method, cv=3)
                if not _model_fitted:
                    m.fit(X_sub[ti_safe], y_eval[ti_safe])
                p = m.predict_proba(X_sub[vi])[:, 1]
                if _beta_cal is not None:
                    p = _beta_cal.predict(p.reshape(-1, 1))
                if _lr_meta_cal is not None:
                    p = _lr_meta_cal.predict_proba(p.reshape(-1, 1))[:, 1]
                if _platt_cal is not None:
                    p = _platt_cal.predict_proba(p.reshape(-1, 1))[:, 1]
                if _isotonic_cal is not None:
                    p = _isotonic_cal.predict(p)
                p = np.clip(p, 0.025, 0.975)  # clip extremes → Brier gain ~0.003
                briers.append(brier_score_loss(y_eval[vi], p))
                rois.append(_log_loss_score(p, y_eval[vi]))
                all_p.extend(p); all_y.extend(y_eval[vi])
            except Exception:
                briers.append(0.28); rois.append(0.0)

    if not briers:
        ind.fitness = {"brier": 0.30, "roi": 0.0, "sharpe": 0.0, "calibration": 0.15, "composite": -1.0,
                       "features_pruned": n_pruned}
        return
    ab = np.mean(briers)
    ar = np.mean(rois)  # log_loss_score: 0 = coin flip, 1 = great calibration
    # Sharpe of calibration: consistency of log-loss scores across folds
    sh = np.mean(rois) / max(np.std(rois), 0.01) if len(rois) > 1 else 0.0
    ce = _ece(np.array(all_p), np.array(all_y)) if all_p else 0.15
    # FITNESS: Brier 40% + log_loss_score 25% + Sharpe_of_calibration 20% + ECE 15%
    # log_loss_score breaks the circular ROI problem: rewards calibration without
    # comparing model to itself. Sharpe measures consistency across folds.
    n_features = len(selected)
    feature_penalty = 0.001 * max(0, n_features - 65)  # Soft pressure toward 65 features
    composite = (0.40 * (1 - ab)
                 + 0.25 * ar  # ar is already in [0, 1] from _log_loss_score
                 + 0.20 * max(0, min(sh, 3) / 3)
                 + 0.15 * (1 - ce)
                 - feature_penalty)
    ind.fitness = {"brier": round(ab, 5), "roi": round(ar, 4), "sharpe": round(sh, 4),
                   "calibration": round(ce, 4),
                   "composite": round(composite, 5),
                   "features_pruned": n_pruned}


def _build(hp):
    try:
        mt = hp["model_type"]
        n_est = min(hp["n_estimators"], 200)  # Cap for speed
        depth = min(hp["max_depth"], 8)       # Cap to prevent overfitting
        lr = hp["learning_rate"]
        # Enforce minimum regularization to prevent overfitting
        reg_a = max(hp["reg_alpha"], 0.01)
        reg_l = max(hp["reg_lambda"], 0.1)
        if mt == "xgboost":
            return xgb.XGBClassifier(n_estimators=n_est, max_depth=depth,
                                     learning_rate=lr, subsample=hp["subsample"],
                                     colsample_bytree=hp["colsample_bytree"], min_child_weight=hp["min_child_weight"],
                                     reg_alpha=reg_a, reg_lambda=reg_l,
                                     eval_metric="logloss", random_state=42, n_jobs=-1, tree_method="hist")
        elif mt == "xgboost_brier":
            return xgb.XGBClassifier(n_estimators=n_est, max_depth=depth,
                                     learning_rate=lr, subsample=hp["subsample"],
                                     colsample_bytree=hp["colsample_bytree"], min_child_weight=hp["min_child_weight"],
                                     reg_alpha=reg_a, reg_lambda=reg_l,
                                     objective=_brier_objective,
                                     eval_metric="logloss", random_state=42, n_jobs=-1, tree_method="hist")
        elif mt == "lightgbm":
            return lgbm.LGBMClassifier(n_estimators=n_est, max_depth=depth,
                                       learning_rate=lr, subsample=hp["subsample"],
                                       num_leaves=min(2 ** depth - 1, 31),
                                       reg_alpha=reg_a, reg_lambda=reg_l,
                                       min_child_samples=20, feature_fraction=0.7,
                                       boosting_type="dart", drop_rate=0.1,
                                       verbose=-1, random_state=42, n_jobs=-1)
        elif mt == "lightgbm_brier":
            # LGBMBrierClassifier: MSE on {0,1} labels = direct Brier minimisation.
            # GBDT (not DART) for compatibility. num_leaves tuned same as lightgbm.
            return LGBMBrierClassifier(
                n_estimators=n_est, max_depth=depth, learning_rate=lr,
                subsample=hp["subsample"], num_leaves=min(2 ** depth - 1, 31),
                reg_alpha=reg_a, reg_lambda=reg_l,
                min_child_samples=20, feature_fraction=hp.get("colsample_bytree", 0.7),
                random_state=42, n_jobs=-1,
            )
        elif mt == "catboost":
            from catboost import CatBoostClassifier
            return CatBoostClassifier(iterations=min(n_est, 100), depth=min(depth, 6),
                                      learning_rate=lr, l2_leaf_reg=hp["reg_lambda"],
                                      verbose=0, random_state=42,
                                      task_type='CPU', thread_count=-1)
        elif mt == "random_forest":
            from sklearn.ensemble import RandomForestClassifier
            return RandomForestClassifier(n_estimators=n_est, max_depth=depth,
                                          min_samples_leaf=max(int(hp["min_child_weight"]), 5),
                                          max_features="sqrt", random_state=42, n_jobs=-1)
        elif mt == "extra_trees":
            from sklearn.ensemble import ExtraTreesClassifier
            return ExtraTreesClassifier(n_estimators=n_est, max_depth=depth,
                                        min_samples_leaf=max(int(hp["min_child_weight"]), 5),
                                        max_features="sqrt", random_state=42, n_jobs=-1)
        elif mt == "logistic_regression":
            # MDPI 2026: LR achieves best Brier (0.199) among tabular models for NBA prediction.
            # Inherently well-calibrated probabilities. C maps from reg_lambda (inverse regularization).
            C = max(0.01, 1.0 / max(hp.get("reg_lambda", 1.0), 0.01))
            C = min(C, 100.0)  # cap to avoid overfitting
            return Pipeline([
                ('scaler', StandardScaler()),
                ('lr', LogisticRegression(C=C, max_iter=500, solver='lbfgs',
                                          random_state=42, n_jobs=-1))
            ])
        elif mt == "mlp":
            hidden = hp.get("nn_hidden_dims", 128)
            n_layers = hp.get("nn_n_layers", 3)
            layers = tuple([hidden // (2 ** i) for i in range(n_layers) if hidden // (2 ** i) >= 16])
            if not layers:
                layers = (64, 32)
            return Pipeline([
                ('scaler', StandardScaler()),
                ('mlp', MLPClassifier(
                    hidden_layer_sizes=layers,
                    activation='relu',
                    max_iter=min(hp.get("nn_epochs", 500), 500),
                    early_stopping=True,
                    validation_fraction=0.15,
                    random_state=42
                ))
            ])
        elif mt == "lstm":
            # LSTM via sklearn-compatible wrapper (falls back to MLP if pytorch unavailable)
            try:
                return _build_pytorch_model(hp, model_type="lstm")
            except Exception:
                return _build_mlp_fallback(hp)
        elif mt == "transformer":
            try:
                return _build_pytorch_model(hp, model_type="transformer")
            except Exception:
                return _build_mlp_fallback(hp)
        elif mt == "tabnet":
            try:
                from pytorch_tabnet.tab_model import TabNetClassifier
                return TabNetClassifier(
                    n_d=hp.get("nn_hidden_dims", 64), n_a=hp.get("nn_hidden_dims", 64),
                    n_steps=max(3, hp.get("nn_n_layers", 3)),
                    gamma=1.3, lambda_sparse=1e-3,
                    cat_dims=[], cat_emb_dim=[],
                    optimizer_params=dict(lr=lr),
                    mask_type="entmax",
                    max_epochs=min(hp.get("nn_epochs", 50), 50),
                    patience=10, batch_size=hp.get("nn_batch_size", 128),
                    verbose=0, seed=42,
                )
            except ImportError:
                return _build_mlp_fallback(hp)
        elif mt == "ft_transformer":
            # Feature Tokenizer + Transformer — falls back to MLP
            try:
                return _build_pytorch_model(hp, model_type="ft_transformer")
            except Exception:
                return _build_mlp_fallback(hp)
        elif mt == "deep_ensemble":
            # Ensemble of 3 MLPs with different random seeds
            try:
                return _build_deep_ensemble(hp)
            except Exception:
                return _build_mlp_fallback(hp)
        elif mt == "autogluon":
            # AutoGluon wraps multiple models — heavy, use sparingly
            try:
                return _build_autogluon(hp)
            except ImportError:
                return _build_mlp_fallback(hp)
        elif mt == "stacking":
            # Return None — stacking is handled specially in evaluate()
            return None
        else:
            return xgb.XGBClassifier(n_estimators=n_est, max_depth=depth,
                                     learning_rate=lr, eval_metric="logloss",
                                     random_state=42, n_jobs=-1, tree_method="hist")
    except Exception:
        from sklearn.ensemble import GradientBoostingClassifier
        return GradientBoostingClassifier(n_estimators=min(hp["n_estimators"], 100), max_depth=min(hp["max_depth"], 6),
                                          learning_rate=hp["learning_rate"], random_state=42)


def _build_mlp_fallback(hp):
    """Fallback MLP when a neural net type fails to build."""
    hidden = hp.get("nn_hidden_dims", 128)
    return Pipeline([
        ('scaler', StandardScaler()),
        ('mlp', MLPClassifier(
            hidden_layer_sizes=(hidden, hidden // 2, max(hidden // 4, 16)),
            activation='relu', max_iter=300, early_stopping=True,
            validation_fraction=0.15, random_state=42
        ))
    ])


def _build_pytorch_model(hp, model_type="lstm"):
    """Build a PyTorch-based sklearn-compatible classifier (LSTM/Transformer/FT-Transformer).
    Wraps in a sklearn Pipeline with StandardScaler for compatibility with the eval loop."""
    try:
        import torch
        import torch.nn as nn
        from sklearn.base import BaseEstimator, ClassifierMixin

        class PytorchTabularClassifier(BaseEstimator, ClassifierMixin):
            """Lightweight sklearn-compatible wrapper for PyTorch tabular models."""

            def __init__(self, model_type="lstm", hidden_dim=128, n_layers=2,
                         dropout=0.3, epochs=50, batch_size=64, lr=0.001):
                self.model_type = model_type
                self.hidden_dim = hidden_dim
                self.n_layers = n_layers
                self.dropout = dropout
                self.epochs = epochs
                self.batch_size = batch_size
                self.lr = lr
                self.model_ = None
                self.scaler_ = StandardScaler()
                self.classes_ = np.array([0, 1])

            def _build_net(self, input_dim):
                if self.model_type == "lstm":
                    class LSTMNet(nn.Module):
                        def __init__(self, input_dim, hidden, n_layers, dropout):
                            super().__init__()
                            self.lstm = nn.LSTM(input_dim, hidden, n_layers,
                                                batch_first=True, dropout=dropout if n_layers > 1 else 0)
                            self.fc = nn.Sequential(
                                nn.Dropout(dropout), nn.Linear(hidden, hidden // 2),
                                nn.ReLU(), nn.Linear(hidden // 2, 1), nn.Sigmoid())
                        def forward(self, x):
                            x = x.unsqueeze(1)  # (batch, 1, features)
                            _, (h, _) = self.lstm(x)
                            return self.fc(h[-1]).squeeze(-1)
                    return LSTMNet(input_dim, self.hidden_dim, self.n_layers, self.dropout)
                elif self.model_type == "transformer":
                    class TransformerNet(nn.Module):
                        def __init__(self, input_dim, hidden, n_layers, dropout):
                            super().__init__()
                            self.embedding = nn.Linear(input_dim, hidden)
                            encoder_layer = nn.TransformerEncoderLayer(
                                d_model=hidden, nhead=max(1, hidden // 32),
                                dim_feedforward=hidden * 2, dropout=dropout, batch_first=True)
                            self.encoder = nn.TransformerEncoder(encoder_layer, num_layers=n_layers)
                            self.fc = nn.Sequential(nn.Linear(hidden, 1), nn.Sigmoid())
                        def forward(self, x):
                            x = self.embedding(x).unsqueeze(1)
                            x = self.encoder(x)
                            return self.fc(x[:, 0]).squeeze(-1)
                    return TransformerNet(input_dim, self.hidden_dim, self.n_layers, self.dropout)
                else:  # ft_transformer
                    class FTTransformerNet(nn.Module):
                        def __init__(self, input_dim, hidden, n_layers, dropout):
                            super().__init__()
                            self.feature_tokens = nn.Linear(1, hidden)
                            encoder_layer = nn.TransformerEncoderLayer(
                                d_model=hidden, nhead=max(1, hidden // 32),
                                dim_feedforward=hidden * 2, dropout=dropout, batch_first=True)
                            self.encoder = nn.TransformerEncoder(encoder_layer, num_layers=n_layers)
                            self.cls_token = nn.Parameter(torch.randn(1, 1, hidden))
                            self.fc = nn.Sequential(nn.Linear(hidden, 1), nn.Sigmoid())
                        def forward(self, x):
                            # x: (batch, features) -> per-feature tokens
                            tokens = self.feature_tokens(x.unsqueeze(-1))  # (batch, features, hidden)
                            cls = self.cls_token.expand(x.size(0), -1, -1)
                            tokens = torch.cat([cls, tokens], dim=1)
                            tokens = self.encoder(tokens)
                            return self.fc(tokens[:, 0]).squeeze(-1)
                    return FTTransformerNet(input_dim, self.hidden_dim, self.n_layers, self.dropout)

            def fit(self, X, y):
                X = self.scaler_.fit_transform(X)
                X_t = torch.FloatTensor(X)
                y_t = torch.FloatTensor(y.astype(float))
                self.model_ = self._build_net(X.shape[1])
                optimizer = torch.optim.Adam(self.model_.parameters(), lr=self.lr, weight_decay=1e-4)
                criterion = nn.BCELoss()
                self.model_.train()
                best_loss = float('inf')
                patience_counter = 0
                for epoch in range(self.epochs):
                    indices = torch.randperm(len(X_t))
                    total_loss = 0
                    n_batches = 0
                    for start in range(0, len(X_t), self.batch_size):
                        batch_idx = indices[start:start + self.batch_size]
                        optimizer.zero_grad()
                        pred = self.model_(X_t[batch_idx])
                        loss = criterion(pred, y_t[batch_idx])
                        loss.backward()
                        torch.nn.utils.clip_grad_norm_(self.model_.parameters(), 1.0)
                        optimizer.step()
                        total_loss += loss.item()
                        n_batches += 1
                    avg_loss = total_loss / max(n_batches, 1)
                    if avg_loss < best_loss - 0.001:
                        best_loss = avg_loss
                        patience_counter = 0
                    else:
                        patience_counter += 1
                        if patience_counter >= 10:
                            break
                return self

            def predict_proba(self, X):
                X = self.scaler_.transform(X)
                self.model_.eval()
                with torch.no_grad():
                    probs = self.model_(torch.FloatTensor(X)).numpy()
                return np.column_stack([1 - probs, probs])

            def predict(self, X):
                return (self.predict_proba(X)[:, 1] > 0.5).astype(int)

            def get_params(self, deep=True):
                return {"model_type": self.model_type, "hidden_dim": self.hidden_dim,
                        "n_layers": self.n_layers, "dropout": self.dropout,
                        "epochs": self.epochs, "batch_size": self.batch_size, "lr": self.lr}

        return PytorchTabularClassifier(
            model_type=model_type,
            hidden_dim=hp.get("nn_hidden_dims", 128),
            n_layers=hp.get("nn_n_layers", 2),
            dropout=hp.get("nn_dropout", 0.3),
            epochs=min(hp.get("nn_epochs", 50), 50),  # Cap at 50 for speed
            batch_size=hp.get("nn_batch_size", 64),
            lr=hp.get("learning_rate", 0.001),
        )
    except ImportError:
        raise  # Let caller handle fallback


def _build_deep_ensemble(hp):
    """Ensemble of 3 MLPs with different seeds — sklearn compatible."""
    from sklearn.ensemble import VotingClassifier
    hidden = hp.get("nn_hidden_dims", 128)
    estimators = []
    for seed in [42, 123, 456]:
        mlp = Pipeline([
            ('scaler', StandardScaler()),
            ('mlp', MLPClassifier(
                hidden_layer_sizes=(hidden, hidden // 2, max(hidden // 4, 16)),
                activation='relu', max_iter=min(hp.get("nn_epochs", 200), 200),
                early_stopping=True, validation_fraction=0.15, random_state=seed
            ))
        ])
        estimators.append((f"mlp_{seed}", mlp))
    return VotingClassifier(estimators=estimators, voting='soft', n_jobs=1)


def _build_autogluon(hp):
    """AutoGluon TabularPredictor wrapped for sklearn compatibility."""
    try:
        from autogluon.tabular import TabularPredictor
        from sklearn.base import BaseEstimator, ClassifierMixin
        import pandas as pd
        import tempfile

        class AutoGluonWrapper(BaseEstimator, ClassifierMixin):
            def __init__(self, time_limit=60):
                self.time_limit = time_limit
                self.predictor_ = None
                self.classes_ = np.array([0, 1])
                self._tmpdir = tempfile.mkdtemp()

            def fit(self, X, y):
                df = pd.DataFrame(X)
                df["target"] = y
                self.predictor_ = TabularPredictor(
                    label="target", path=self._tmpdir, verbosity=0
                ).fit(df, time_limit=self.time_limit, presets="best_quality")
                return self

            def predict_proba(self, X):
                df = pd.DataFrame(X)
                probs = self.predictor_.predict_proba(df)
                return probs.values if hasattr(probs, 'values') else np.column_stack([1 - probs, probs])

            def predict(self, X):
                return (self.predict_proba(X)[:, 1] > 0.5).astype(int)

            def get_params(self, deep=True):
                return {"time_limit": self.time_limit}

        return AutoGluonWrapper(time_limit=min(hp.get("nn_epochs", 60), 60))
    except ImportError:
        raise


def _simulate_betting_legacy(probs, actuals, edge=0.05):
    """LEGACY: Circular ROI — compares model to itself (1/prob as fair odds). DEPRECATED."""
    stake, profit, n = 10, 0, 0
    for p, a in zip(probs, actuals):
        if p > 0.5 + edge:
            n += 1; profit += stake * (1 / p - 1) if a == 1 else -stake
        elif p < 0.5 - edge:
            n += 1; profit += stake * (1 / (1 - p) - 1) if a == 0 else -stake
    return profit / (n * stake) if n > 0 else 0.0


def _log_loss_score(probs, actuals):
    """Log-loss proxy for ROI: measures calibration quality without circular odds.

    Returns a score in [0, 1] range where:
      - 0.6931 (coin flip / no skill) maps to 0.0
      - 0.5 (good calibration) maps to 1.0
      - Lower log-loss = higher score = better edge potential
    Clamps to [0, 1] range.
    """
    try:
        probs = np.clip(np.asarray(probs, dtype=float), 1e-7, 1 - 1e-7)
        actuals = np.asarray(actuals, dtype=float)
        if len(probs) < 10:
            return 0.0
        ll = log_loss(actuals, probs)
        # Linear map: 0.6931 (coin flip) → 0.0, 0.5 → 1.0
        # score = (0.6931 - ll) / (0.6931 - 0.5)
        COIN_FLIP = 0.6931
        GOOD_TARGET = 0.5
        score = (COIN_FLIP - ll) / (COIN_FLIP - GOOD_TARGET)
        return float(np.clip(score, 0.0, 1.0))
    except Exception:
        # Fallback: use legacy method if log_loss fails
        return max(0.0, _simulate_betting_legacy(probs, actuals))


def _ece(probs, actuals, n_bins=10):
    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


# ═══════════════════════════════════════════════════════
# EVOLUTION ENGINE
# ═══════════════════════════════════════════════════════

# ── Runtime config (env-overridable for multi-Space island model) ──
# S10 (primary): exploitation — proven optimal params
# S11 (secondary): exploration — higher mutation, wider feature search
import os as _os
_SPACE_ROLE = _os.environ.get("SPACE_ROLE", "exploitation")  # "exploitation" or "exploration"
_SPACE_ID = _os.environ.get("SPACE_ID", _os.environ.get("SPACE_HOST", "unknown"))  # e.g. "Nomos42/nba-evo-5"

_ROLE_CONFIGS = {
    "exploitation": {  # S10: proven optimal
        "POP_SIZE": 60, "BASE_MUT": 0.09, "MUT_DECAY_RATE": 0.998, "MUT_FLOOR": 0.05,
        "CROSSOVER_RATE": 0.80, "TARGET_FEATURES": 63, "TOURNAMENT_SIZE": 7, "DIVERSITY_RESTART": 30,
    },
    "exploration": {  # S11: wider search
        "POP_SIZE": 60, "BASE_MUT": 0.15, "MUT_DECAY_RATE": 0.999, "MUT_FLOOR": 0.08,
        "CROSSOVER_RATE": 0.70, "TARGET_FEATURES": 80, "TOURNAMENT_SIZE": 5, "DIVERSITY_RESTART": 20,
    },
    "extra_trees_specialist": {  # S12: extra_trees focus, tight features
        "POP_SIZE": 60, "BASE_MUT": 0.08, "MUT_DECAY_RATE": 0.998, "MUT_FLOOR": 0.04,
        "CROSSOVER_RATE": 0.80, "TARGET_FEATURES": 60, "TOURNAMENT_SIZE": 7, "DIVERSITY_RESTART": 25,
    },
    "catboost_specialist": {  # S13: catboost focus, medium exploration
        "POP_SIZE": 60, "BASE_MUT": 0.10, "MUT_DECAY_RATE": 0.998, "MUT_FLOOR": 0.05,
        "CROSSOVER_RATE": 0.80, "TARGET_FEATURES": 66, "TOURNAMENT_SIZE": 6, "DIVERSITY_RESTART": 25,
    },
    "neural_specialist": {  # S14: neural models — GPU ONLY (Colab), skip on CPU HF Spaces
        "POP_SIZE": 40, "BASE_MUT": 0.12, "MUT_DECAY_RATE": 0.999, "MUT_FLOOR": 0.06,
        "CROSSOVER_RATE": 0.75, "TARGET_FEATURES": 50, "TOURNAMENT_SIZE": 5, "DIVERSITY_RESTART": 15,
    },
    "lightgbm_specialist": {  # S14 on CPU: LightGBM is fastest tree model
        "POP_SIZE": 60, "BASE_MUT": 0.08, "MUT_DECAY_RATE": 0.998, "MUT_FLOOR": 0.04,
        "CROSSOVER_RATE": 0.85, "TARGET_FEATURES": 55, "TOURNAMENT_SIZE": 7, "DIVERSITY_RESTART": 25,
    },
    "wide_search": {  # S15: diversity, moderate feature search (120 was too slow on CPU)
        "POP_SIZE": 50, "BASE_MUT": 0.18, "MUT_DECAY_RATE": 0.999, "MUT_FLOOR": 0.08,
        "CROSSOVER_RATE": 0.65, "TARGET_FEATURES": 80, "TOURNAMENT_SIZE": 4, "DIVERSITY_RESTART": 15,
    },
}
_cfg = _ROLE_CONFIGS.get(_SPACE_ROLE, _ROLE_CONFIGS["exploitation"])
POP_SIZE = _cfg["POP_SIZE"]
BASE_MUT = _cfg["BASE_MUT"]
MUT_DECAY_RATE = _cfg["MUT_DECAY_RATE"]
MUT_FLOOR = _cfg["MUT_FLOOR"]
CROSSOVER_RATE = _cfg["CROSSOVER_RATE"]
TARGET_FEATURES = _cfg["TARGET_FEATURES"]
TOURNAMENT_SIZE = _cfg["TOURNAMENT_SIZE"]
DIVERSITY_RESTART = _cfg["DIVERSITY_RESTART"]

N_ISLANDS = 5
ISLAND_SIZE = POP_SIZE // N_ISLANDS
ELITE_SIZE = max(2, POP_SIZE // 10)
ELITE_PER_ISLAND = max(1, ISLAND_SIZE // 6)

N_SPLITS = 2             # 2-fold fast eval (3-fold only for FULL_EVAL_TOP)
GENS_PER_CYCLE = 3       # Save every 3 gens
COOLDOWN = 5             # Minimal cooldown
FAST_EVAL_GAMES = 5000   # Subsample for fast eval (was 8000 — too slow on CPU)
FULL_EVAL_TOP = 5        # Full eval for top 5 only (was 10 — halves slow full evals)
MIGRATION_INTERVAL = 8   # Migration every 8 gens
MIGRANTS_PER_ISLAND = 3  # 3 migrants per island (25% of island)
GC_INTERVAL = 10         # Force garbage collection every N individuals evaluated

# ── Feature importance tracking (directed mutation) ──
_feature_importance = None  # numpy array: how often each feature appears in top individuals

# ── Shared state for /api/predict (set from evolution_loop) ──
_evo_X = None          # Full feature matrix
_evo_y = None          # Labels
_evo_features = None   # Feature names list
_evo_best = None       # Best individual (dict with features, hyperparams, fitness)
_evo_games = None      # Raw games list (for building today's features)

# ── Checkpoint system (monotonic ratchet) ──
_checkpoints = []      # Last 10 checkpoints: [{best, brier, generation, timestamp}]
CHECKPOINT_DIR = Path(__file__).parent / "data" / "checkpoints"
CHECKPOINT_DIR.mkdir(parents=True, exist_ok=True)

# ── Remote Config (mutable at runtime via API) ──
remote_config = {
    "pending_reset": False,
    "pending_params": {},
    "injected_features": [],     # Feature ideas from OpenClaw
    "commands": [],              # Queued commands (restart, diversify, etc.)
    "pending_elites": [],        # Promoted configs (e.g. from Karpathy GPU runs)
    "promotion_log": [],         # Last 50 promotion events
}


def _adaptive_tournament_size(population, base_size=4):
    """Adaptive tournament size based on population diversity.
    Low diversity -> larger tournaments (stronger selection pressure).
    High diversity -> smaller tournaments (preserve exploration)."""
    if not population:
        return base_size
    composites = [ind.fitness.get("composite", 0) for ind in population]
    diversity = np.std(composites) if len(composites) > 1 else 0
    if diversity < 0.005:
        return min(base_size + 3, 10)  # Very low diversity: strong pressure
    elif diversity < 0.01:
        return min(base_size + 1, 8)
    elif diversity > 0.05:
        return max(base_size - 1, 2)   # High diversity: weak pressure
    return base_size


def evolution_loop():
    """Main 24/7 genetic evolution loop — runs in background thread.
    Uses island model with 5 sub-populations of 100, NSGA-II Pareto ranking,
    adaptive mutation decay, and memory management for 16GB RAM."""
    global TARGET_FEATURES, CROSSOVER_RATE, COOLDOWN, POP_SIZE, N_ISLANDS, ISLAND_SIZE
    global _evo_X, _evo_y, _evo_features, _evo_best, _evo_games
    log("=" * 60)
    log("REAL GENETIC EVOLUTION LOOP v4 — ISLAND MODEL + NSGA-II")
    log(f"Pop: {POP_SIZE} ({N_ISLANDS} islands x {ISLAND_SIZE}) | Target features: {TARGET_FEATURES} | Gens/cycle: {GENS_PER_CYCLE}")
    log(f"Mutation: {BASE_MUT} -> {MUT_FLOOR} (decay {MUT_DECAY_RATE}/gen) | Crossover: {CROSSOVER_RATE}")
    log(f"Migration: every {MIGRATION_INTERVAL} gens, {MIGRANTS_PER_ISLAND} per island")
    log("=" * 60)

    # ── Supabase Run Logger + Auto-Cut ──
    global _global_logger
    run_logger = None
    if _HAS_LOGGER:
        try:
            run_logger = RunLogger(local_dir=str(DATA_DIR / "run-logs"))
            _global_logger = run_logger
            # Test DB connection explicitly
            db_url = os.environ.get("DATABASE_URL", "")
            if db_url:
                log(f"[RUN-LOGGER] DATABASE_URL set ({db_url[:25]}...)")
                try:
                    import psycopg2
                    conn = psycopg2.connect(db_url, connect_timeout=10, options="-c search_path=public")
                    cur = conn.cursor()
                    cur.execute("SELECT COUNT(*) FROM public.nba_evolution_gens")
                    cnt = cur.fetchone()[0]
                    conn.close()
                    log(f"[RUN-LOGGER] Supabase CONNECTED — {cnt} existing gen rows")
                except Exception as e:
                    log(f"[RUN-LOGGER] Supabase connection FAILED: {e}", "ERROR")
            else:
                log("[RUN-LOGGER] DATABASE_URL NOT SET — logging local only", "WARN")
            log("[RUN-LOGGER] Initialized — auto-cut ACTIVE")
        except Exception as e:
            log(f"[RUN-LOGGER] Init failed: {e} — continuing without", "WARN")

    live["status"] = "LOADING DATA"
    pull_seasons()
    games = load_all_games()
    live["games"] = len(games)
    log(f"Games loaded: {len(games)}")

    if len(games) < 500:
        log("NOT ENOUGH GAMES", "ERROR")
        live["status"] = "ERROR: no data"
        return

    live["status"] = "BUILDING FEATURES"
    X, y, feature_names = build_features(games)
    log(f"Raw feature matrix: {X.shape} ({X.shape[1]} features)")

    # ── CRITICAL: Remove zero-variance (noise) features ──
    # Categories 11-15 (referee, player, quarter, defense, polymarket) have no data
    # and compute to constant defaults (0.0, 0.5, etc.). These add noise, not signal.
    live["status"] = "FILTERING NOISE FEATURES"
    variances = np.var(X, axis=0)
    valid_mask = variances > 1e-10  # Keep only features with real variance
    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"NOISE FILTER: removed {n_removed} zero-variance features (no real data)")
    n_feat = X.shape[1]
    live["feature_candidates"] = n_feat
    log(f"Clean feature matrix: {X.shape} ({n_feat} usable features)")

    # ── Share state for /api/predict ──
    _evo_X = X
    _evo_y = y
    _evo_features = feature_names
    _evo_games = games

    # Try restore state — island model
    island_model = None
    generation = 0
    best_ever = None
    stagnation = 0
    mutation_rate = BASE_MUT

    state_file = STATE_DIR / "population.json"
    restored = False
    if state_file.exists():
        try:
            st = json.loads(state_file.read_text())
            generation = st["generation"]
            stagnation = st.get("stagnation_counter", 0)
            mutation_rate = st.get("mutation_rate", BASE_MUT)

            # Try island model restore first
            if "island_model" in st:
                island_model = IslandModel.from_state_dict(st["island_model"], n_feat)
                log(f"RESTORED island model: gen {generation}, {N_ISLANDS} islands")
                restored = True
            elif "population" in st:
                # Legacy flat population — convert to island model
                population = []
                for d in st["population"]:
                    ind = Individual.__new__(Individual)
                    ind.features = d["features"]; ind.hyperparams = d["hyperparams"]
                    ind.fitness = d["fitness"]; ind.generation = d.get("generation", 0)
                    ind.n_features = sum(ind.features)
                    ind.pareto_rank = d.get("pareto_rank", 999)
                    ind.crowding_dist = 0.0
                    ind.island_id = d.get("island_id", -1)
                    # Ensure new hyperparams exist
                    ind.hyperparams.setdefault("nn_hidden_dims", 128)
                    ind.hyperparams.setdefault("nn_n_layers", 2)
                    ind.hyperparams.setdefault("nn_dropout", 0.3)
                    ind.hyperparams.setdefault("nn_epochs", 50)
                    ind.hyperparams.setdefault("nn_batch_size", 64)
                    _valid_types = CPU_MODEL_TYPES if not _HAS_GPU else ALL_MODEL_TYPES
                    if ind.hyperparams.get("model_type") not in _valid_types:
                        ind.hyperparams["model_type"] = random.choice(_valid_types)
                    population.append(ind)

                # Convert flat population to island model
                island_model = IslandModel(n_islands=N_ISLANDS, island_size=ISLAND_SIZE,
                                           n_features=n_feat, target_features=TARGET_FEATURES,
                                           migration_interval=MIGRATION_INTERVAL,
                                           migrants_per_island=MIGRANTS_PER_ISLAND)
                # Keep elites from old population, fill rest
                elites = sorted(population, key=lambda x: x.fitness.get("composite", 0), reverse=True)[:ELITE_SIZE]
                for e in elites:
                    if len(e.features) < n_feat:
                        e.features.extend([random.randint(0, 1) for _ in range(n_feat - len(e.features))])
                    elif len(e.features) > n_feat:
                        e.features = e.features[:n_feat]
                    e.n_features = sum(e.features)
                island_model.initialize()
                # Inject elites into island 0
                for i, e in enumerate(elites):
                    if i < len(island_model.islands[0]):
                        island_model.islands[0][i] = e
                log(f"MIGRATED legacy pop to island model: {len(population)} -> {N_ISLANDS}x{ISLAND_SIZE}")
                restored = True

            if st.get("best_ever"):
                be = st["best_ever"]
                best_ever = Individual.__new__(Individual)
                best_ever.features = be["features"]; best_ever.hyperparams = be["hyperparams"]
                best_ever.fitness = be["fitness"]; best_ever.generation = be.get("generation", 0)
                best_ever.n_features = sum(best_ever.features)
                best_ever.pareto_rank = be.get("pareto_rank", 0)
                best_ever.crowding_dist = 0.0
                best_ever.island_id = be.get("island_id", 0)
                best_ever.hyperparams.setdefault("nn_hidden_dims", 128)
                best_ever.hyperparams.setdefault("nn_n_layers", 2)
                best_ever.hyperparams.setdefault("nn_dropout", 0.3)
                best_ever.hyperparams.setdefault("nn_epochs", 50)
                best_ever.hyperparams.setdefault("nn_batch_size", 64)
            log(f"RESTORED: gen {generation}, best Brier={best_ever.fitness['brier']:.4f}" if best_ever else "RESTORED: no best yet")
        except Exception as e:
            log(f"Restore failed: {e}", "WARN")
            traceback.print_exc()
            island_model = None

    # Initialize fresh island model if not restored
    if island_model is None:
        island_model = IslandModel(n_islands=N_ISLANDS, island_size=ISLAND_SIZE,
                                   n_features=n_feat, target_features=TARGET_FEATURES,
                                   migration_interval=MIGRATION_INTERVAL,
                                   migrants_per_island=MIGRANTS_PER_ISLAND)
        island_model.initialize()
        log(f"FRESH island model: {N_ISLANDS} islands x {ISLAND_SIZE} = {POP_SIZE} individuals")
        log(f"Island specializations: {[s[:3] for s in island_model.island_specializations]}")

    live["pop_size"] = POP_SIZE
    live["n_islands"] = N_ISLANDS
    live["island_sizes"] = [len(isl) for isl in island_model.islands]

    # ── INFINITE LOOP (Island Model + NSGA-II) ──
    cycle = 0
    # Cycle-level stagnation: counts cycles where best_brier didn't beat all-time record.
    # Unlike per-generation stagnation (which resets on diversify), this is never gamed.
    # Trigger: if stuck for CYCLE_STAGNATION_HARD cycles → emergency full reset of model types.
    _cycles_no_brier_improvement = 0
    _brier_at_last_cycle_improvement = float(best_ever.fitness["brier"]) if best_ever else 1.0
    CYCLE_STAGNATION_HARD = 25  # ~25 cycles × 3-5 min = ~75-125 min without improvement

    while True:
        cycle += 1
        live["cycle"] = cycle
        live["status"] = f"EVOLVING (cycle {cycle})"
        log(f"\n{'='*50}")
        log(f"CYCLE {cycle} — {GENS_PER_CYCLE} generations | Mut={mutation_rate:.4f}")
        log(f"{'='*50}")
        cycle_start = time.time()

        for gen_i in range(GENS_PER_CYCLE):
            generation += 1
            live["generation"] = generation
            gen_start = time.time()

            # ── EVALUATE ALL ISLANDS (with per-individual timeout) ──
            population = island_model.get_all_individuals()
            _timed_out = 0
            for i, ind in enumerate(population):
                # Skip re-eval of elites (per-island top ELITE_PER_ISLAND)
                if ind.pareto_rank == 0 and ind.fitness.get("composite", 0) > 0:
                    continue
                _t0 = time.time()
                evaluate(ind, X, y, N_SPLITS, fast=True)
                _dur = time.time() - _t0
                if _dur > EVAL_TIMEOUT_S:
                    # This eval was too slow — penalize and warn
                    ind.fitness = {"brier": 0.29, "roi": 0.0, "sharpe": 0.0,
                                   "calibration": 0.15, "composite": -0.5, "features_pruned": 0}
                    _timed_out += 1
            if _timed_out:
                log(f"[TIMEOUT] {_timed_out}/{len(population)} individuals exceeded {EVAL_TIMEOUT_S}s")

            # ── NSGA-II PARETO RANKING (global) ──
            population = nsga2_rank(population)

            # ── FULL EVAL: top FULL_EVAL_TOP get precise 3-fold on ALL data ──
            for ind in population[:FULL_EVAL_TOP]:
                evaluate(ind, X, y, n_splits=3, fast=False)

            # Re-rank after full eval
            population = nsga2_rank(population)
            best = population[0]
            pareto_front_size = sum(1 for ind in population if ind.pareto_rank == 0)

            # ── Memory cleanup after full population eval ──
            _gc_cleanup()

            # ── Update feature importance from top performers ──
            global _feature_importance
            if _feature_importance is None:
                _feature_importance = np.zeros(n_feat)
            top_features = np.zeros(n_feat)
            for ind in population[:20]:  # Top 20 (was 10) — more signal with 500 pop
                for idx in ind.selected_indices():
                    if idx < n_feat:
                        top_features[idx] += 1
            _feature_importance = 0.7 * _feature_importance + 0.3 * (top_features / 20.0)

            # Track best ever
            prev_brier = best_ever.fitness["brier"] if best_ever else 1.0
            if best_ever is None or best.fitness["composite"] > best_ever.fitness["composite"]:
                best_ever = Individual.__new__(Individual)
                best_ever.features = best.features[:]
                best_ever.hyperparams = dict(best.hyperparams)
                best_ever.fitness = dict(best.fitness)
                best_ever.n_features = best.n_features
                best_ever.generation = generation
                best_ever.pareto_rank = best.pareto_rank
                best_ever.crowding_dist = best.crowding_dist
                best_ever.island_id = best.island_id
                # Share for /api/predict
                _evo_best = {
                    "features": best_ever.features[:],
                    "hyperparams": dict(best_ever.hyperparams),
                    "fitness": dict(best_ever.fitness),
                    "generation": best_ever.generation,
                    "n_features": best_ever.n_features,
                }

            # Stagnation detection — track BOTH Brier and composite
            prev_best_composite = best_ever.fitness["composite"] if best_ever else 0.0
            brier_stagnant = abs(best.fitness["brier"] - prev_brier) < 0.0005
            composite_stagnant = abs(best.fitness["composite"] - prev_best_composite) < 0.001
            if brier_stagnant and composite_stagnant:
                stagnation += 1
            elif not brier_stagnant:
                stagnation = max(0, stagnation - 2)  # Partial reset on real improvement
            else:
                stagnation = max(0, stagnation - 1)

            # ── Adaptive mutation: decay over time, boost on stagnation ──
            # Base decay: starts at BASE_MUT, decays toward MUT_FLOOR
            # Data analysis: 0.10-0.15 has 80% improvement rate vs 18% at >=0.20
            # So caps are set to keep mutation in the productive range
            mutation_rate *= MUT_DECAY_RATE
            mutation_rate = max(MUT_FLOOR, mutation_rate)
            # Stagnation boost (capped at 0.15 — data shows >=0.20 is destructive)
            if stagnation >= 10:
                mutation_rate = min(0.15, mutation_rate * 1.5)
            elif stagnation >= 7:
                mutation_rate = min(0.13, mutation_rate * 1.3)
            elif stagnation >= 3:
                mutation_rate = min(0.12, mutation_rate * 1.15)

            # ── Adaptive tournament size ──
            tourney_size = _adaptive_tournament_size(population, TOURNAMENT_SIZE)

            # ── Distribute population back to islands ──
            island_model.set_all_individuals(population)

            # ── MIGRATION between islands ──
            migrated = island_model.migrate(generation)
            if migrated:
                log(f"  MIGRATION: {MIGRANTS_PER_ISLAND} individuals exchanged between {N_ISLANDS} islands")

            # Update live state
            live["best_brier"] = best_ever.fitness["brier"]
            live["best_roi"] = best_ever.fitness["roi"]
            live["best_sharpe"] = best_ever.fitness["sharpe"]
            live["best_features"] = best_ever.n_features
            live["best_model_type"] = best_ever.hyperparams["model_type"]
            live["mutation_rate"] = round(mutation_rate, 4)
            live["stagnation"] = stagnation
            live["pareto_front_size"] = pareto_front_size
            live["island_sizes"] = [len(isl) for isl in island_model.islands]
            live["history"].append({
                "gen": generation, "brier": best.fitness["brier"], "roi": best.fitness["roi"],
                "composite": best.fitness["composite"], "features": best.n_features,
                "pareto_front": pareto_front_size,
            })
            if len(live["history"]) > 500:
                live["history"] = live["history"][-500:]

            ge = time.time() - gen_start
            log(f"Gen {generation}: Brier={best.fitness['brier']:.4f} ROI={best.fitness['roi']:.1%} "
                f"Sharpe={best.fitness['sharpe']:.2f} Feat={best.n_features} "
                f"Model={best.hyperparams['model_type']} Pareto={pareto_front_size} "
                f"Mut={mutation_rate:.4f} Stag={stagnation} ({ge:.0f}s)")

            # ── Supabase: log generation ──
            try:
                _db_url = os.environ.get("DATABASE_URL", "")
                if _db_url:
                    import psycopg2
                    _dbconn = psycopg2.connect(_db_url, connect_timeout=10, options="-c search_path=public")
                    _dbconn.autocommit = True
                    _cur = _dbconn.cursor()
                    pop_diversity = float(np.std([ind.fitness.get("composite", 0) for ind in population]))
                    avg_comp = float(np.mean([ind.fitness.get("composite", 0) for ind in population]))
                    _cur.execute("""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, float(best.fitness["brier"]), float(best.fitness["roi"]),
                         float(best.fitness["sharpe"]), float(best.fitness["composite"]),
                         int(best.n_features), str(best.hyperparams["model_type"]),
                         float(mutation_rate), avg_comp, pop_diversity, float(ge),
                         bool(stagnation == 0 and generation > 1)))
                    log(f"[SUPABASE] Gen {generation} logged OK")
                    for rank, ind in enumerate(population[:10]):
                        _cur.execute("""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, float(ind.fitness["brier"]), float(ind.fitness["roi"]),
                             float(ind.fitness["sharpe"]), float(ind.fitness["composite"]),
                             int(ind.n_features), str(ind.hyperparams["model_type"])))
                    _cur.close()
                    _dbconn.close()
            except Exception as e:
                log(f"[SUPABASE] Gen log FAILED: {e}", "ERROR")

            # ── Auto-Cut check ──
            if run_logger:
                try:
                    pop_diversity = float(np.std([ind.fitness.get("composite", 0) for ind in population]))
                    avg_comp = float(np.mean([ind.fitness.get("composite", 0) for ind in population]))
                    run_logger.log_generation(
                        cycle=cycle, generation=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=mutation_rate, avg_composite=avg_comp,
                        pop_diversity=pop_diversity, duration_s=ge)
                    top10 = [{"brier": ind.fitness["brier"], "roi": ind.fitness["roi"],
                              "sharpe": ind.fitness["sharpe"], "composite": ind.fitness["composite"],
                              "n_features": ind.n_features, "model_type": ind.hyperparams["model_type"]}
                             for ind in population[:10]]
                    run_logger.log_top_evals(generation, top10)
                    engine_state = {
                        "mutation_rate": mutation_rate, "stagnation": stagnation,
                        "pop_size": len(population), "pop_diversity": float(pop_diversity),
                    }
                    cut_actions = run_logger.check_auto_cut(best.fitness, engine_state)
                    for action in cut_actions:
                        atype = action["type"]
                        params = action.get("params", {})
                        if atype == "config":
                            remote_config["pending_params"].update(params)
                        elif atype == "emergency_diversify":
                            remote_config["commands"].append("diversify")
                        elif atype == "full_reset":
                            remote_config["pending_reset"] = True
                        elif atype == "flag":
                            live["pause_betting"] = params.get("pause_betting", False)
                except Exception as e:
                    log(f"[RUN-LOGGER] Gen log error: {e}", "WARN")

            # ── EVOLVE EACH ISLAND independently ──
            for island_id in range(N_ISLANDS):
                island = island_model.islands[island_id]
                island.sort(key=lambda x: (x.pareto_rank, -x.crowding_dist))

                new_island = []
                # Elitism per island
                for i in range(min(ELITE_PER_ISLAND, len(island))):
                    e = Individual.__new__(Individual)
                    e.features = island[i].features[:]; e.hyperparams = dict(island[i].hyperparams)
                    e.fitness = dict(island[i].fitness); e.n_features = island[i].n_features
                    e.generation = island[i].generation; e.island_id = island_id
                    e.pareto_rank = island[i].pareto_rank; e.crowding_dist = island[i].crowding_dist
                    new_island.append(e)

                # Stagnation injection (per-island) — tiered response
                if stagnation >= 7:
                    n_inject = ISLAND_SIZE // 3
                    specialization = island_model.island_specializations[island_id]
                    n_random = n_inject // 3      # 1/3 fully random
                    n_mutant = n_inject // 3      # 1/3 mutants of best
                    n_cross_island = n_inject - n_random - n_mutant  # 1/3 from other islands' best
                    # Random fresh individuals
                    for _ in range(n_random):
                        fresh = Individual(n_feat, TARGET_FEATURES, model_type=random.choice(specialization))
                        fresh.island_id = island_id
                        new_island.append(fresh)
                    # Targeted mutants of island's best
                    if island:
                        island_best = min(island, key=lambda x: x.fitness.get("brier", 1.0))
                        for _ in range(n_mutant):
                            mutant = Individual.__new__(Individual)
                            mutant.features = island_best.features[:]
                            mutant.hyperparams = dict(island_best.hyperparams)
                            mutant.fitness = {"brier": 1.0, "roi": 0.0, "sharpe": 0.0, "calibration": 1.0, "composite": 0.0}
                            mutant.n_features = island_best.n_features
                            mutant.generation = generation
                            mutant.island_id = island_id
                            mutant.pareto_rank = 999
                            mutant.crowding_dist = 0.0
                            mutant.mutate(0.20)  # Heavy mutation
                            new_island.append(mutant)
                    # Cross-island pollination: inject best from OTHER islands
                    other_islands = [i for i in range(N_ISLANDS) if i != island_id]
                    for _ in range(n_cross_island):
                        src = random.choice(other_islands)
                        src_island = island_model.islands[src]
                        if src_island:
                            donor = min(src_island, key=lambda x: x.fitness.get("brier", 1.0))
                            cross = Individual.__new__(Individual)
                            cross.features = donor.features[:]
                            cross.hyperparams = dict(donor.hyperparams)
                            cross.fitness = {"brier": 1.0, "roi": 0.0, "sharpe": 0.0, "calibration": 1.0, "composite": 0.0}
                            cross.n_features = donor.n_features
                            cross.generation = generation
                            cross.island_id = island_id
                            cross.pareto_rank = 999
                            cross.crowding_dist = 0.0
                            cross.mutate(0.15)  # Moderate mutation to adapt to new island
                            new_island.append(cross)
                elif stagnation >= 3:
                    # Mild injection: 10% fresh per island
                    n_inject = max(2, ISLAND_SIZE // 10)
                    specialization = island_model.island_specializations[island_id]
                    for _ in range(n_inject):
                        fresh = Individual(n_feat, TARGET_FEATURES, model_type=random.choice(specialization))
                        fresh.island_id = island_id
                        new_island.append(fresh)

                if stagnation >= DIVERSITY_RESTART:
                    n_restart = ISLAND_SIZE // 2
                    new_island = new_island[:ELITE_PER_ISLAND]
                    specialization = island_model.island_specializations[island_id]
                    for _ in range(n_restart):
                        fresh = Individual(n_feat, TARGET_FEATURES, model_type=random.choice(specialization))
                        fresh.island_id = island_id
                        new_island.append(fresh)

                # Fill with crossover + mutation (within island)
                while len(new_island) < ISLAND_SIZE:
                    cs = random.sample(island, min(tourney_size, len(island)))
                    p1 = min(cs, key=lambda x: (x.pareto_rank, -x.crowding_dist))  # NSGA-II selection
                    cs2 = random.sample(island, min(tourney_size, len(island)))
                    p2 = min(cs2, key=lambda x: (x.pareto_rank, -x.crowding_dist))
                    if random.random() < CROSSOVER_RATE:
                        child = Individual.crossover(p1, p2)
                    else:
                        child = Individual.__new__(Individual)
                        child.features = p1.features[:]; child.hyperparams = dict(p1.hyperparams)
                        child.fitness = {"brier": 1.0, "roi": 0.0, "sharpe": 0.0, "calibration": 1.0, "composite": 0.0}
                        child.n_features = p1.n_features; child.generation = generation
                        child.pareto_rank = 999; child.crowding_dist = 0.0
                    child.island_id = island_id
                    child.mutate(mutation_rate, feature_importance=_feature_importance)
                    new_island.append(child)

                island_model.islands[island_id] = new_island[:ISLAND_SIZE]

            # Reset stagnation after emergency restart
            if stagnation >= DIVERSITY_RESTART:
                stagnation = 0

        # ── Save state ──
        live["status"] = "SAVING"
        try:
            population = island_model.get_all_individuals()
            sel_names = [feature_names[i] for i in best_ever.selected_indices() if i < len(feature_names)] if best_ever else []
            state_data = {
                "timestamp": datetime.now(timezone.utc).isoformat(),
                "generation": generation, "n_features": n_feat,
                "stagnation_counter": stagnation, "mutation_rate": mutation_rate,
                "island_model": island_model.to_state_dict(),
                "best_ever": {"features": best_ever.features,
                              "hyperparams": {k: (float(v) if isinstance(v, np.floating) else v) for k, v in best_ever.hyperparams.items()},
                              "fitness": best_ever.fitness, "generation": best_ever.generation,
                              "island_id": getattr(best_ever, 'island_id', 0),
                              "pareto_rank": getattr(best_ever, 'pareto_rank', 0)} if best_ever else None,
                "history": live["history"][-200:],
            }
            (STATE_DIR / "population.json").write_text(json.dumps(state_data, default=str))

            island_stats = island_model.get_island_stats()
            results = {
                "timestamp": datetime.now(timezone.utc).isoformat(),
                "cycle": cycle, "generation": generation, "pop_size": POP_SIZE,
                "n_islands": N_ISLANDS, "island_size": ISLAND_SIZE,
                "mutation_rate": round(mutation_rate, 4), "stagnation": stagnation,
                "pareto_front_size": sum(1 for ind in population if ind.pareto_rank == 0),
                "best": {"brier": best_ever.fitness["brier"], "roi": best_ever.fitness["roi"],
                         "sharpe": best_ever.fitness["sharpe"], "n_features": best_ever.n_features,
                         "model_type": best_ever.hyperparams["model_type"],
                         "pareto_rank": getattr(best_ever, 'pareto_rank', 0),
                         "selected_features": sel_names[:30]},
                "top5": [ind.to_dict() for ind in sorted(population, key=lambda x: x.fitness["composite"], reverse=True)[:5]],
                "island_stats": island_stats,
                "history_last20": live["history"][-20:],
            }
            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))

            live["top5"] = results["top5"]
            log(f"Results saved: evolution-{ts}.json")

            # ── Cycle-level stagnation tracking (not gamed by per-gen diversify resets) ──
            _current_brier = best_ever.fitness["brier"]
            if _current_brier < _brier_at_last_cycle_improvement - 0.0002:
                _cycles_no_brier_improvement = 0
                _brier_at_last_cycle_improvement = _current_brier
                log(f"[CYCLE-STAG] Brier improved to {_current_brier:.5f} — counter reset")
            else:
                _cycles_no_brier_improvement += 1
                log(f"[CYCLE-STAG] No improvement for {_cycles_no_brier_improvement} cycles "
                    f"(best={_current_brier:.5f}, need <{_brier_at_last_cycle_improvement - 0.0002:.5f})")

            # Hard intervention: if stuck for CYCLE_STAGNATION_HARD cycles, reseed model types
            if _cycles_no_brier_improvement >= CYCLE_STAGNATION_HARD:
                log(f"[CYCLE-STAG] HARD RESET after {_cycles_no_brier_improvement} cycles stuck — "
                    f"reseeding model type distribution", "WARN")
                # Replace bottom 60% of population with fresh individuals using unexplored model types
                all_inds = island_model.get_all_individuals()
                all_inds.sort(key=lambda x: x.fitness.get("composite", 0), reverse=True)
                keep = all_inds[:int(len(all_inds) * 0.4)]  # keep top 40%
                unused_types = [t for t in CPU_MODEL_TYPES
                                if t not in {i.hyperparams.get("model_type") for i in keep}]
                if not unused_types:
                    unused_types = CPU_MODEL_TYPES
                for idx, ind in enumerate(all_inds[int(len(all_inds) * 0.4):]):
                    mt = unused_types[idx % len(unused_types)]
                    fresh = Individual(n_feat, TARGET_FEATURES, model_type=mt)
                    fresh.island_id = ind.island_id
                    # Replace in island
                    for isl in island_model.islands:
                        for i, m in enumerate(isl):
                            if m is ind:
                                isl[i] = fresh
                                break
                mutation_rate = min(0.15, mutation_rate * 2.0)
                _cycles_no_brier_improvement = 0
                log(f"[CYCLE-STAG] Reseeded {len(all_inds) - len(keep)} individuals with types: "
                    f"{unused_types[:5]}. Mutation boosted to {mutation_rate:.4f}")

            # ── Supabase: log cycle ──
            try:
                _db_url = os.environ.get("DATABASE_URL", "")
                if _db_url:
                    import psycopg2
                    _dbconn = psycopg2.connect(_db_url, connect_timeout=10, options="-c search_path=public")
                    _dbconn.autocommit = True
                    _cur = _dbconn.cursor()
                    pop_diversity = float(np.std([ind.fitness.get("composite", 0) for ind in population]))
                    avg_comp = float(np.mean([ind.fitness.get("composite", 0) for ind in population]))
                    _cur.execute("""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, float(best_ever.fitness["brier"]), float(best_ever.fitness["roi"]),
                         float(best_ever.fitness["sharpe"]), float(best_ever.fitness.get("calibration", 0)),
                         float(best_ever.fitness["composite"]), int(best_ever.n_features),
                         str(best_ever.hyperparams["model_type"]), POP_SIZE, float(mutation_rate),
                         float(CROSSOVER_RATE), stagnation, len(games), n_feat,
                         float(time.time() - cycle_start), avg_comp, pop_diversity,
                         json.dumps(results.get("top5", [])[:5], default=str),
                         json.dumps(sel_names[:50], default=str)))
                    _cur.close()
                    _dbconn.close()
                    log("[SUPABASE] Cycle logged OK")
            except Exception as e:
                log(f"[SUPABASE] Cycle log FAILED: {e}", "ERROR")
        except Exception as e:
            log(f"Save error: {e}", "ERROR")
            traceback.print_exc()

        # VM callback
        try:
            import urllib.request
            body = json.dumps({"generation": generation, "brier": best_ever.fitness["brier"],
                               "roi": best_ever.fitness["roi"], "features": best_ever.n_features,
                               "pop_size": POP_SIZE, "n_islands": N_ISLANDS}, default=str).encode()
            req = urllib.request.Request(f"{VM_URL}/callback/evolution", data=body,
                                        headers={"Content-Type": "application/json"})
            urllib.request.urlopen(req, timeout=10)
            log("VM callback OK")
        except Exception:
            pass

        # ── Check remote commands from OpenClaw ──
        if remote_config["pending_params"]:
            params = remote_config["pending_params"]
            log(f"REMOTE CONFIG UPDATE: {params}")
            if "pop_size" in params:
                new_total = min(int(params["pop_size"]), 1000)  # Cap at 1000
                new_island_size = new_total // N_ISLANDS
                if new_island_size != ISLAND_SIZE:
                    ISLAND_SIZE = new_island_size
                    POP_SIZE = N_ISLANDS * ISLAND_SIZE
                    # Resize each island
                    for isl_idx in range(N_ISLANDS):
                        isl = island_model.islands[isl_idx]
                        if len(isl) < ISLAND_SIZE:
                            spec = island_model.island_specializations[isl_idx]
                            while len(isl) < ISLAND_SIZE:
                                isl.append(Individual(n_feat, TARGET_FEATURES, model_type=random.choice(spec)))
                        elif len(isl) > ISLAND_SIZE:
                            isl.sort(key=lambda x: x.fitness.get("composite", 0), reverse=True)
                            island_model.islands[isl_idx] = isl[:ISLAND_SIZE]
                    island_model.island_size = ISLAND_SIZE
                    live["pop_size"] = POP_SIZE
                    log(f"Population resized: {N_ISLANDS} x {ISLAND_SIZE} = {POP_SIZE}")
            if "n_islands" in params:
                # Changing island count is complex — queue for next restart
                log(f"n_islands change requested ({params['n_islands']}) — will take effect on restart")
            if "mutation_rate" in params:
                mutation_rate = min(float(params["mutation_rate"]), 0.15)
                log(f"Mutation rate set to {mutation_rate}")
            if "target_features" in params:
                TARGET_FEATURES = min(int(params["target_features"]), 150)
                log(f"Target features set to {TARGET_FEATURES}")
            if "crossover_rate" in params:
                CROSSOVER_RATE = float(params["crossover_rate"])
            if "cooldown" in params:
                COOLDOWN = int(params["cooldown"])
            if "migration_interval" in params:
                island_model.migration_interval = int(params["migration_interval"])
                log(f"Migration interval set to {island_model.migration_interval}")
            remote_config["pending_params"] = {}

        if remote_config["pending_reset"]:
            log("REMOTE RESET: Reinitializing 50% of each island with fresh individuals")
            for isl_idx in range(N_ISLANDS):
                isl = island_model.islands[isl_idx]
                isl.sort(key=lambda x: x.fitness.get("composite", 0), reverse=True)
                n_keep = max(ELITE_PER_ISLAND, ISLAND_SIZE // 4)
                kept = isl[:n_keep]
                spec = island_model.island_specializations[isl_idx]
                while len(kept) < ISLAND_SIZE:
                    kept.append(Individual(n_feat, TARGET_FEATURES, model_type=random.choice(spec)))
                island_model.islands[isl_idx] = kept
            stagnation = 0
            mutation_rate = BASE_MUT
            remote_config["pending_reset"] = False
            log(f"Reset complete: {N_ISLANDS} islands refreshed, {POP_SIZE} total")

        for cmd in remote_config.get("commands", []):
            if cmd == "diversify":
                for isl_idx in range(N_ISLANDS):
                    isl = island_model.islands[isl_idx]
                    n_new = ISLAND_SIZE // 3
                    isl.sort(key=lambda x: x.fitness.get("composite", 0), reverse=True)
                    isl = isl[:ISLAND_SIZE - n_new]
                    spec = island_model.island_specializations[isl_idx]
                    for _ in range(n_new):
                        isl.append(Individual(n_feat, TARGET_FEATURES, model_type=random.choice(spec)))
                    island_model.islands[isl_idx] = isl
                log(f"REMOTE DIVERSIFY: 1/3 of each island replaced")
            elif cmd == "boost_mutation":
                mutation_rate = min(0.15, mutation_rate * 1.5)
                log(f"REMOTE: mutation boosted to {mutation_rate}")
        remote_config["commands"] = []

        # ── Consume pending elite promotions (e.g. from Karpathy GPU wins) ──
        if remote_config.get("pending_elites"):
            for elite_cfg in remote_config["pending_elites"]:
                try:
                    feat_idxs = elite_cfg.get("feature_indices", [])
                    mask = [0] * n_feat
                    for idx in feat_idxs:
                        if 0 <= int(idx) < n_feat:
                            mask[int(idx)] = 1
                    ind = Individual.__new__(Individual)
                    ind.features = mask
                    ind.hyperparams = {
                        "n_estimators": int(elite_cfg.get("n_estimators", 200)),
                        "max_depth": int(elite_cfg.get("max_depth", 6)),
                        "learning_rate": float(elite_cfg.get("learning_rate", 0.05)),
                        "subsample": float(elite_cfg.get("subsample", 0.8)),
                        "colsample_bytree": float(elite_cfg.get("colsample_bytree", 0.7)),
                        "min_child_weight": int(elite_cfg.get("min_samples_leaf", 5)),
                        "reg_alpha": float(elite_cfg.get("reg_alpha", 0.01)),
                        "reg_lambda": float(elite_cfg.get("reg_lambda", 0.1)),
                        "model_type": elite_cfg.get("model_type", "random_forest"),
                        "calibration": elite_cfg.get("calibration", "venn_abers"),
                        "nn_hidden_dims": 128, "nn_n_layers": 2, "nn_dropout": 0.3,
                        "nn_epochs": 50, "nn_batch_size": 64,
                    }
                    ind.fitness = {"brier": 1.0, "roi": 0.0, "sharpe": 0.0, "calibration": 1.0, "composite": 0.0}
                    ind.pareto_rank = 999; ind.crowding_dist = 0.0
                    ind.island_id = 0; ind.generation = generation
                    ind._enforce_feature_cap()
                    isl0 = island_model.islands[0]
                    if isl0:
                        isl0.sort(key=lambda x: x.fitness.get("composite", 0))
                        isl0[0] = ind
                    src = elite_cfg.get("brier_source", "unknown")
                    log(f"REMOTE PROMOTE: injected elite ({ind.hyperparams['model_type']} "
                        f"n_est={ind.hyperparams['n_estimators']} n_feat={ind.n_features}) src={src}")
                    remote_config["promotion_log"].append({
                        "ts": time.time(), "generation": generation,
                        "model_type": ind.hyperparams["model_type"],
                        "n_features": ind.n_features, "source": src,
                    })
                    if len(remote_config["promotion_log"]) > 50:
                        remote_config["promotion_log"] = remote_config["promotion_log"][-50:]
                except Exception as e:
                    log(f"[PROMOTE] failed: {e}")
            remote_config["pending_elites"] = []

        # Refresh data every 10 cycles
        if cycle % 10 == 0:
            try:
                pull_seasons()
                new_games = load_all_games()
                if len(new_games) > len(games):
                    games = new_games
                    X, y, feature_names = build_features(games)
                    n_feat = X.shape[1]
                    live["games"] = len(games)
                    log(f"Data refreshed: {len(games)} games")
            except Exception as e:
                log(f"Refresh failed: {e}", "WARN")

        # Memory cleanup between cycles
        _gc_cleanup()

        ce = time.time() - cycle_start
        log(f"\nCycle {cycle} done in {ce:.0f}s | Best: Brier={best_ever.fitness['brier']:.4f} | Pareto front: {live.get('pareto_front_size', 0)}")
        live["status"] = f"COOLDOWN ({COOLDOWN}s)"
        time.sleep(COOLDOWN)


# ═══════════════════════════════════════════════════════
# GRADIO DASHBOARD
# ═══════════════════════════════════════════════════════

def dash_status():
    if not live["history"]:
        brier_trend = "No data yet"
    else:
        last5 = live["history"][-5:]
        brier_trend = " -> ".join(f"{h['brier']:.4f}" for h in last5)

    return f"""## NOMOS NBA QUANT — Island Model GA (NSGA-II)

| Metric | Value |
|--------|-------|
| **Status** | {live['status']} |
| **Cycle** | {live['cycle']} |
| **Generation** | {live['generation']} |
| **Best Brier** | {live['best_brier']:.4f} |
| **Best ROI** | {live['best_roi']:.1%} |
| **Best Sharpe** | {live['best_sharpe']:.2f} |
| **Best Features** | {live['best_features']} |
| **Model Type** | {live['best_model_type']} |
| **Population** | {live['pop_size']} ({live['n_islands']} islands) |
| **Pareto Front** | {live.get('pareto_front_size', 0)} individuals |
| **Mutation Rate** | {live['mutation_rate']:.4f} |
| **Stagnation** | {live['stagnation']} gens |
| **Games** | {live['games']:,} |
| **Feature Candidates** | {live['feature_candidates']} |
| **Island Sizes** | {live.get('island_sizes', [])} |
| **Started** | {live['started_at'][:19]} |

**Brier Trend**: {brier_trend}
**Target**: Brier < 0.20 | ROI > 5% | Sharpe > 1.0
"""


def dash_logs():
    return "\n".join(live["log"][-100:])


def dash_top5():
    rows = []
    for i, ind in enumerate(live.get("top5", [])):
        f = ind.get("fitness", {})
        h = ind.get("hyperparams", {})
        rows.append(f"| #{i+1} | {f.get('brier', '?'):.4f} | {f.get('roi', 0):.1%} | "
                     f"{f.get('sharpe', 0):.2f} | {ind.get('n_features', '?')} | "
                     f"{h.get('model_type', '?')} | {f.get('composite', 0):.4f} |")
    if not rows:
        return "No data yet — evolution starting..."
    return f"""### Top 5 Individuals

| Rank | Brier | ROI | Sharpe | Features | Model | Composite |
|------|-------|-----|--------|----------|-------|-----------|
{chr(10).join(rows)}
"""


def dash_history():
    if not live["history"]:
        return "{}"
    return json.dumps(live["history"][-30:], indent=2)


def dash_api():
    latest = RESULTS_DIR / "evolution-latest.json"
    if latest.exists():
        return latest.read_text()
    return "{}"


# ═══════════════════════════════════════════════════════
# FASTAPI REMOTE CONTROL API (called by OpenClaw autonomously)
# ═══════════════════════════════════════════════════════

control_api = FastAPI()


@control_api.get("/api/status")
async def api_status():
    # Deep-convert numpy types to native Python for JSON serialization
    def _safe(obj):
        if hasattr(obj, 'item'):  # numpy scalar
            return obj.item()
        if isinstance(obj, dict):
            return {k: _safe(v) for k, v in obj.items()}
        if isinstance(obj, (list, tuple)):
            return [_safe(x) for x in obj]
        if isinstance(obj, float):
            return round(obj, 6)
        return obj
    return JSONResponse(_safe(dict(live)))


@control_api.get("/api/best")
async def api_best():
    """Return best chromosome WITH feature indices for Kaggle seeding."""
    if _evo_best is None:
        return JSONResponse({"error": "no evolution best yet"}, status_code=404)
    indices = [i for i, b in enumerate(_evo_best.get("features", [])) if b]
    return JSONResponse({
        "brier": _evo_best.get("fitness", {}).get("brier", 1.0),
        "model_type": _evo_best.get("hyperparams", {}).get("model_type", "xgboost"),
        "features": indices,
        "n_features": _evo_best.get("n_features", len(indices)),
        "hyperparams": _evo_best.get("hyperparams", {}),
        "fitness": _evo_best.get("fitness", {}),
        "generation": _evo_best.get("generation", 0),
    })


@control_api.get("/api/results")
async def api_results():
    latest = RESULTS_DIR / "evolution-latest.json"
    if latest.exists():
        return JSONResponse(json.loads(latest.read_text()))
    return JSONResponse({"status": "no results yet"})


@control_api.post("/api/config")
async def api_config(request: Request):
    """Update GA parameters at runtime. OpenClaw calls this to apply improvements."""
    body = await request.json()
    allowed = {"pop_size", "mutation_rate", "target_features", "crossover_rate",
               "cooldown", "elite_size", "tournament_size", "n_islands",
               "migration_interval", "migrants_per_island"}
    updates = {k: v for k, v in body.items() if k in allowed}
    if not updates:
        return JSONResponse({"error": "no valid params", "allowed": list(allowed)}, status_code=400)
    remote_config["pending_params"].update(updates)
    log(f"[REMOTE] Config queued: {updates}")
    return JSONResponse({"status": "queued", "params": updates})


@control_api.post("/api/reset")
async def api_reset(request: Request):
    """Force population reset — keeps elites, replaces rest with fresh individuals."""
    remote_config["pending_reset"] = True
    log("[REMOTE] Population reset requested")
    return JSONResponse({"status": "reset queued"})


@control_api.post("/api/command")
async def api_command(request: Request):
    """Execute a command: diversify, boost_mutation, backfill_boxscores, etc."""
    body = await request.json()
    cmd = body.get("command", "")
    valid = ["diversify", "boost_mutation", "backfill_boxscores"]
    if cmd not in valid:
        return JSONResponse({"error": f"unknown command, valid: {valid}"}, status_code=400)

    if cmd == "backfill_boxscores":
        import threading
        def _run_backfill():
            try:
                import subprocess, sys
                log("[BACKFILL] Starting box score backfill...")
                live["backfill_progress"] = "running"
                result = subprocess.run(
                    [sys.executable, "ops/backfill-boxscores.py"],
                    capture_output=True, text=True, timeout=14400,  # 4h max
                    cwd=str(Path(__file__).parent.parent)
                )
                live["backfill_progress"] = "complete" if result.returncode == 0 else f"failed: {result.stderr[-200:]}"
                log(f"[BACKFILL] Done: rc={result.returncode}")
            except Exception as e:
                live["backfill_progress"] = f"error: {e}"
                log(f"[BACKFILL] Error: {e}")
        threading.Thread(target=_run_backfill, daemon=True).start()
        return JSONResponse({"status": "backfill started", "monitor": "/api/status → backfill_progress"})

    remote_config["commands"].append(cmd)
    log(f"[REMOTE] Command queued: {cmd}")
    return JSONResponse({"status": "command queued", "command": cmd})


@control_api.post("/api/checkpoint")
async def api_checkpoint(request: Request):
    """Save current best individual as a checkpoint."""
    global _checkpoints, _evo_best
    if not _evo_best:
        return JSONResponse({"error": "No evolution best available"}, status_code=400)

    cp = {
        "best": dict(_evo_best),
        "brier": _evo_best.get("fitness", {}).get("brier", 1.0),
        "generation": _evo_best.get("generation", 0),
        "timestamp": datetime.now().isoformat(),
    }
    _checkpoints.append(cp)
    if len(_checkpoints) > 10:
        _checkpoints = _checkpoints[-10:]

    # Persist to disk
    cp_file = CHECKPOINT_DIR / f"cp-{cp['generation']}-{int(time.time())}.json"
    cp_file.write_text(json.dumps(cp, indent=2, default=str))
    log(f"[CHECKPOINT] Saved gen {cp['generation']}, Brier {cp['brier']:.4f}")
    return JSONResponse({"status": "checkpoint saved", "brier": cp["brier"], "generation": cp["generation"]})


@control_api.post("/api/rollback")
async def api_rollback(request: Request):
    """Rollback to a specific checkpoint (by generation) or best checkpoint."""
    global _evo_best, _checkpoints
    body = await request.json()
    target_gen = body.get("generation")

    if not _checkpoints:
        return JSONResponse({"error": "No checkpoints available"}, status_code=400)

    if target_gen is not None:
        cp = next((c for c in _checkpoints if c["generation"] == target_gen), None)
        if not cp:
            return JSONResponse({"error": f"No checkpoint for gen {target_gen}"}, status_code=404)
    else:
        # Rollback to best (lowest Brier)
        cp = min(_checkpoints, key=lambda c: c["brier"])

    _evo_best = cp["best"]
    log(f"[ROLLBACK] Reverted to gen {cp['generation']}, Brier {cp['brier']:.4f}")
    return JSONResponse({"status": "rolled back", "brier": cp["brier"], "generation": cp["generation"]})


@control_api.get("/api/checkpoint/best")
async def api_checkpoint_best(request: Request):
    """Return the checkpoint with lowest Brier score."""
    if not _checkpoints:
        return JSONResponse({"error": "No checkpoints"}, status_code=404)
    best_cp = min(_checkpoints, key=lambda c: c["brier"])
    return JSONResponse({
        "brier": best_cp["brier"],
        "generation": best_cp["generation"],
        "timestamp": best_cp["timestamp"],
        "total_checkpoints": len(_checkpoints),
    })


@control_api.post("/api/inject-features")
async def api_inject_features(request: Request):
    """Receive feature ideas from OpenClaw's research. Stored for logging/tracking."""
    body = await request.json()
    features = body.get("features", [])
    if not features:
        return JSONResponse({"error": "no features provided"}, status_code=400)
    remote_config["injected_features"].extend(features)
    if len(remote_config["injected_features"]) > 200:
        remote_config["injected_features"] = remote_config["injected_features"][-200:]
    log(f"[REMOTE] {len(features)} feature ideas injected: {[f.get('name', '?') for f in features[:5]]}")
    return JSONResponse({"status": "injected", "count": len(features),
                         "total_pool": len(remote_config["injected_features"])})


@control_api.post("/api/promote-config")
async def api_promote_config(request: Request):
    """Promote a GPU-discovered config as an elite individual in island 0.

    Body (from data/karpathy/nba-best-config.json):
    {
      "model_type": "random_forest",
      "n_estimators": 275, "max_depth": 13, "min_samples_leaf": 5,
      "max_features_ratio": 0.32,
      "feature_indices": [0, 3, 7, ...],
      "brier_source": "karpathy_lightning_0.21218"
    }
    """
    body = await request.json()
    if not isinstance(body.get("feature_indices"), list) or len(body["feature_indices"]) == 0:
        return JSONResponse({"error": "feature_indices (non-empty list) required"}, status_code=400)
    remote_config["pending_elites"].append(body)
    return JSONResponse({
        "status": "queued",
        "queued_count": len(remote_config["pending_elites"]),
        "will_inject_into": "island_0",
        "source": body.get("brier_source", "unknown"),
    })


@control_api.get("/api/remote-log")
async def api_remote_log():
    """Return recent remote commands and injections."""
    return JSONResponse({
        "pending_params": remote_config["pending_params"],
        "pending_reset": remote_config["pending_reset"],
        "queued_commands": remote_config["commands"],
        "injected_features_count": len(remote_config["injected_features"]),
        "recent_features": remote_config["injected_features"][-10:],
        "pending_elites_count": len(remote_config.get("pending_elites", [])),
        "promotion_log": remote_config.get("promotion_log", [])[-10:],
        "log_tail": live["log"][-30:],
    })


# ═══════════════════════════════════════════════════════
# RUN LOGGER API — Supabase monitoring endpoints
# ═══════════════════════════════════════════════════════

# Global logger ref (set from evolution_loop thread)
_global_logger = None


@control_api.get("/api/run-stats")
async def api_run_stats():
    """Evolution run statistics from Supabase."""
    if not _global_logger:
        return JSONResponse({"error": "logger not initialized"}, status_code=503)
    try:
        stats = _global_logger.get_stats()
        return JSONResponse(stats)
    except Exception as e:
        return JSONResponse({"error": str(e)}, status_code=500)


@control_api.get("/api/cuts")
async def api_cuts():
    """Recent auto-cut events."""
    if not _global_logger:
        return JSONResponse({"error": "logger not initialized"}, status_code=503)
    try:
        cuts = _global_logger.get_recent_cuts(20)
        return JSONResponse({"cuts": [list(c) for c in cuts] if cuts else []})
    except Exception as e:
        return JSONResponse({"error": str(e)}, status_code=500)


@control_api.get("/api/brier-trend")
async def api_brier_trend():
    """Brier score trend (last 50 generations)."""
    if not _global_logger:
        return JSONResponse({"error": "logger not initialized"}, status_code=503)
    try:
        trend = _global_logger.get_brier_trend(50)
        return JSONResponse({"trend": trend})
    except Exception as e:
        return JSONResponse({"error": str(e)}, status_code=500)


@control_api.get("/api/recent-runs")
async def api_recent_runs():
    """Recent cycle summaries from Supabase."""
    if not _global_logger:
        return JSONResponse({"error": "logger not initialized"}, status_code=503)
    try:
        runs = _global_logger.get_recent_runs(20)
        return JSONResponse({"runs": [list(r) for r in runs] if runs else []})
    except Exception as e:
        return JSONResponse({"error": str(e)}, status_code=500)


# ═══════════════════════════════════════════════════════
# EXPERIMENT SUBMISSION (works on both S10 and S11)
# ═══════════════════════════════════════════════════════

@control_api.post("/api/experiment/submit")
async def api_experiment_submit(request: Request):
    """Submit an experiment to the Supabase queue for S11 evaluation.

    Works on both S10 and S11 — writes to Supabase, S11 picks up.
    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()
        valid_types = ["feature_test", "model_test", "calibration_test", "config_change"]
        exp_type = body.get("experiment_type")
        if exp_type not in valid_types:
            return JSONResponse({"error": f"Invalid experiment_type. Valid: {valid_types}"}, 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())}")
        db_url = os.environ.get("DATABASE_URL", "")
        if not db_url:
            return JSONResponse({"error": "DATABASE_URL not configured"}, status_code=503)

        import psycopg2
        conn = psycopg2.connect(db_url, connect_timeout=10, options="-c search_path=public")
        cur = conn.cursor()
        cur.execute("""
            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"),
        ))
        db_id = cur.fetchone()[0]
        conn.commit()
        conn.close()

        log(f"[EXPERIMENT] Queued: {exp_id_str} (type={exp_type}, agent={body.get('agent_name', 'unknown')})")
        return JSONResponse({
            "status": "queued",
            "id": db_id,
            "experiment_id": exp_id_str,
            "message": "Experiment queued for S11. It polls every 60s.",
        })
    except Exception as e:
        return JSONResponse({"error": f"Failed to queue experiment: {str(e)[:300]}"}, status_code=500)


# ═══════════════════════════════════════════════════════
# PREDICT API — Use evolved model for live predictions
# ═══════════════════════════════════════════════════════

@control_api.post("/api/predict")
async def api_predict(request: Request):
    """Generate predictions using the best evolved individual.

    Body: {"games": [{"home_team": "Boston Celtics", "away_team": "Miami Heat"}, ...]}
    Or: {"date": "2026-03-18"} to predict all games on a date (fetches from ESPN schedule).

    Returns probabilities from the evolved model trained on ALL historical data.
    """
    global _evo_X, _evo_y, _evo_features, _evo_best, _evo_games

    if _evo_best is None or _evo_X is None:
        return JSONResponse({"error": "evolution not ready — model still loading"}, status_code=503)

    body = await request.json()
    games_to_predict = body.get("games", [])
    date_str = body.get("date")

    # If date provided, fetch today's schedule from ESPN
    if date_str and not games_to_predict:
        try:
            import urllib.request
            url = f"https://site.api.espn.com/apis/site/v2/sports/basketball/nba/scoreboard?dates={date_str.replace('-', '')}"
            req = urllib.request.Request(url, headers={"User-Agent": "NomosQuant/1.0"})
            with urllib.request.urlopen(req, timeout=15) as resp:
                data = json.loads(resp.read().decode())
            for ev in data.get("events", []):
                comps = ev.get("competitions", [{}])[0]
                teams = comps.get("competitors", [])
                if len(teams) == 2:
                    home = next((t for t in teams if t.get("homeAway") == "home"), None)
                    away = next((t for t in teams if t.get("homeAway") == "away"), None)
                    if home and away:
                        games_to_predict.append({
                            "home_team": home["team"]["displayName"],
                            "away_team": away["team"]["displayName"],
                            "game_id": ev.get("id"),
                            "status": comps.get("status", {}).get("type", {}).get("name", ""),
                        })
        except Exception as e:
            return JSONResponse({"error": f"ESPN fetch failed: {e}"}, status_code=502)

    if not games_to_predict:
        return JSONResponse({"error": "no games to predict — provide 'games' array or 'date'"}, status_code=400)

    try:
        # Get best individual's config
        best = _evo_best
        selected = [i for i, b in enumerate(best["features"]) if b]
        hp = best["hyperparams"]

        if len(selected) < 5:
            return JSONResponse({"error": "best individual has too few features"}, status_code=503)

        # Train model on ALL historical data using best individual's features + hyperparams
        X_train = np.nan_to_num(_evo_X[:, selected], nan=0.0, posinf=1e6, neginf=-1e6)
        y_train = _evo_y

        hp_build = dict(hp)
        hp_build["n_estimators"] = min(hp.get("n_estimators", 150), 200)
        hp_build["max_depth"] = min(hp.get("max_depth", 6), 8)

        if hp_build.get("model_type") == "stacking":
            # For stacking, use XGBoost as fallback for prediction
            hp_build["model_type"] = "xgboost"

        model = _build(hp_build)
        if model is None:
            return JSONResponse({"error": "model build failed"}, status_code=500)

        # Apply calibration if specified
        _predict_lr_meta_cal = None  # LR meta-calibrator for post-predict application
        cal_method_build = hp_build.get("calibration", "none")
        if cal_method_build == "lr_meta":
            # LR meta-calibration: fit base model, then fit LR on a held-out calibration slice.
            # The LR calibrator is stored and applied after predict_proba at inference time.
            model.fit(X_train, y_train)
            cal_slice_size = min(200, max(50, len(X_train) // 5))
            X_cal = X_train[-cal_slice_size:]
            y_cal = y_train[-cal_slice_size:]
            raw_cal_p = model.predict_proba(X_cal)[:, 1]
            # v2: MLP meta-learner (was LR, -0.003 Brier expected)
            _predict_lr_meta_cal = MLPClassifier(
                hidden_layer_sizes=(50, 50), max_iter=500,
                early_stopping=True, validation_fraction=0.15,
                learning_rate='adaptive', random_state=42
            )
            _predict_lr_meta_cal.fit(raw_cal_p.reshape(-1, 1), y_cal)
        elif cal_method_build not in ("none", "venn_abers", "beta"):
            model = CalibratedClassifierCV(model, method=cal_method_build, cv=3)
            model.fit(X_train, y_train)
        else:
            model.fit(X_train, y_train)

        # Build features for today's games
        # We append each game to historical data and build features for the last row
        selected_names = [_evo_features[i] for i in selected if i < len(_evo_features)]
        predictions = []

        for game in games_to_predict:
            home = game.get("home_team", "")
            away = game.get("away_team", "")
            h_abbr = resolve(home)
            a_abbr = resolve(away)

            if not h_abbr or not a_abbr:
                predictions.append({
                    "home_team": home, "away_team": away,
                    "error": "team not recognized"
                })
                continue

            # Create a synthetic game entry (no score yet — we just need features)
            today = datetime.now(timezone.utc).strftime("%Y-%m-%d")
            synthetic_game = {
                "game_date": today,
                "home_team": home, "away_team": away,
                "home": {"team_name": home, "pts": 0},
                "away": {"team_name": away, "pts": 0},
            }

            # Build features for this game using historical context
            try:
                all_games = list(_evo_games) + [synthetic_game]
                X_all, y_all, fn_all = build_features(all_games)

                # Apply same variance filter
                if X_all.shape[1] != _evo_X.shape[1]:
                    # Feature count mismatch — use column mapping by name
                    fn_map = {name: i for i, name in enumerate(fn_all)}
                    game_vec = np.zeros(len(selected))
                    for j, si in enumerate(selected):
                        if si < len(_evo_features):
                            fname = _evo_features[si]
                            if fname in fn_map:
                                game_vec[j] = X_all[-1, fn_map[fname]]
                else:
                    game_vec = np.nan_to_num(X_all[-1, selected], nan=0.0, posinf=1e6, neginf=-1e6)

                raw_prob = model.predict_proba(game_vec.reshape(1, -1))[0, 1]
                if _predict_lr_meta_cal is not None:
                    raw_prob = _predict_lr_meta_cal.predict_proba(
                        np.array([[raw_prob]])
                    )[0, 1]
                prob = float(np.clip(raw_prob, 0.025, 0.975))

                # Apply post-hoc calibration (D5: raw ECE=0.2758, target <0.05)
                raw_prob = prob
                prob = _apply_cal(prob, _CAL_MAP)

                # Kelly criterion (25% fractional) — uses calibrated prob
                if prob > 0.55:
                    edge = prob - 0.5
                    kelly = (edge / 0.5) * 0.25  # fractional Kelly
                else:
                    kelly = 0.0

                predictions.append({
                    "home_team": home, "away_team": away,
                    "home_win_prob": round(prob, 4),
                    "away_win_prob": round(1 - prob, 4),
                    "raw_home_win_prob": round(raw_prob, 4),
                    "calibrated": _CAL_MAP is not None,
                    "confidence": round(abs(prob - 0.5) * 2, 4),
                    "kelly_stake": round(kelly, 4),
                    "model_type": best["hyperparams"]["model_type"],
                    "features_used": best["n_features"],
                    "brier_cv": best["fitness"]["brier"],
                })
            except Exception as e:
                predictions.append({
                    "home_team": home, "away_team": away,
                    "error": f"feature build failed: {str(e)[:100]}"
                })

        return JSONResponse({
            "predictions": predictions,
            "model": {
                "type": best["hyperparams"]["model_type"],
                "generation": best["generation"],
                "brier_cv": best["fitness"]["brier"],
                "roi_cv": best["fitness"]["roi"],
                "features": best["n_features"],
            },
            "timestamp": datetime.now(timezone.utc).isoformat(),
        })

    except Exception as e:
        return JSONResponse({"error": f"prediction failed: {str(e)[:200]}"}, status_code=500)


@control_api.post("/api/fit-calibration")
async def api_fit_calibration(request: Request):
    """Fit isotonic calibration from the best model's walk-forward holdout predictions.

    Uses the best evolved individual to produce OOS predictions via TimeSeriesSplit,
    then fits isotonic regression on (raw_prob, outcome) pairs.

    Returns JSON breakpoints compatible with IsotonicPostCalibrator.

    Body (optional):
      {"n_splits": 5, "n_breakpoints": 20, "write_local": true}
    """
    global _evo_X, _evo_y, _evo_features, _evo_best

    if _evo_best is None or _evo_X is None:
        return JSONResponse({"error": "evolution not ready"}, status_code=503)

    try:
        body = {}
        try:
            body = await request.json()
        except Exception:
            pass

        n_splits = body.get("n_splits", 5)
        n_breakpoints = body.get("n_breakpoints", 20)
        write_local = body.get("write_local", True)

        best = _evo_best
        selected = [i for i, b in enumerate(best["features"]) if b]
        hp = dict(best["hyperparams"])

        if len(selected) < 5:
            return JSONResponse({"error": "best individual has too few features"}, status_code=503)

        X_sub = np.nan_to_num(_evo_X[:, selected], nan=0.0, posinf=1e6, neginf=-1e6)
        y = _evo_y

        # Build the base model (no in-loop calibration — we want raw probs)
        hp_build = dict(hp)
        hp_build["calibration"] = "none"
        hp_build["n_estimators"] = min(hp.get("n_estimators", 150), 200)
        hp_build["max_depth"] = min(hp.get("max_depth", 6), 8)
        if hp_build.get("model_type") == "stacking":
            hp_build["model_type"] = "xgboost"

        model = _build(hp_build)
        if model is None:
            return JSONResponse({"error": "model build failed"}, status_code=500)

        # Walk-forward: collect OOS raw predictions
        tscv = TimeSeriesSplit(n_splits=n_splits)
        all_raw = []
        all_actual = []
        PURGE_GAP = 5

        for ti, vi in tscv.split(X_sub):
            try:
                ti_safe = ti[:-PURGE_GAP] if len(ti) > PURGE_GAP + 50 else ti
                m = clone(model)
                m.fit(X_sub[ti_safe], y[ti_safe])
                p = m.predict_proba(X_sub[vi])[:, 1]
                p = np.clip(p, 0.025, 0.975)
                all_raw.extend(p.tolist())
                all_actual.extend(y[vi].tolist())
            except Exception:
                pass

        if len(all_raw) < 50:
            return JSONResponse({
                "error": f"insufficient OOS predictions ({len(all_raw)}), need 50+"
            }, status_code=422)

        raw_arr = np.array(all_raw)
        act_arr = np.array(all_actual)

        # Brier before calibration
        brier_before = float(np.mean((raw_arr - act_arr) ** 2))

        # Fit isotonic regression (sklearn is available on HF Space)
        from sklearn.isotonic import IsotonicRegression
        ir = IsotonicRegression(out_of_bounds="clip", y_min=0.0, y_max=1.0)
        ir.fit(raw_arr, act_arr)

        # Produce compact breakpoints on a fine grid
        x_grid = np.linspace(0.0, 1.0, max(n_breakpoints, 10))
        y_grid = ir.predict(x_grid)
        y_grid = np.maximum.accumulate(y_grid)  # ensure strict monotonicity

        # Brier after calibration (in-sample, for reporting)
        cal_probs = ir.predict(raw_arr)
        brier_after = float(np.mean((cal_probs - act_arr) ** 2))

        # ECE before/after
        def _ece_quick(probs, actuals, n_bins=10):
            bins_e = np.linspace(0, 1, n_bins + 1)
            ece_val = 0.0
            for i in range(n_bins):
                mask = (probs >= bins_e[i]) & (probs < bins_e[i + 1])
                if mask.sum() == 0:
                    continue
                ece_val += mask.sum() / len(probs) * abs(probs[mask].mean() - actuals[mask].mean())
            return float(ece_val)

        ece_before = _ece_quick(raw_arr, act_arr)
        ece_after = _ece_quick(cal_probs, act_arr)

        now = datetime.now(timezone.utc).isoformat()
        result = {
            "x_points": [round(float(x), 4) for x in x_grid],
            "y_points": [round(float(y), 4) for y in y_grid],
            "metadata": {
                "identity": False,
                "n_samples": len(all_raw),
                "n_breakpoints": len(x_grid),
                "fitted_on": "HF Space",
                "fitted_at": now,
                "model_type": hp.get("model_type", "unknown"),
                "n_features": len(selected),
                "generation": best.get("generation", -1),
                "brier_before": round(brier_before, 5),
                "brier_after": round(brier_after, 5),
                "brier_delta": round(brier_after - brier_before, 5),
                "ece_before": round(ece_before, 5),
                "ece_after": round(ece_after, 5),
            },
            # Also output calibration-map.json format for scripts/calibration.py
            "calibration_map": {
                "_meta": {
                    "version": "3.0",
                    "created": now[:10],
                    "generated_at": now,
                    "source": "HF Space /api/fit-calibration (sklearn IsotonicRegression)",
                    "model_version": f"{hp.get('model_type', 'unknown')}-gen{best.get('generation', '?')}",
                    "n_games_used": len(all_raw),
                    "brier_before": round(brier_before, 5),
                    "brier_after": round(brier_after, 5),
                    "ece_before": round(ece_before, 5),
                    "ece_after": round(ece_after, 5),
                },
                "bin_edges": [0.0, 0.2, 0.4, 0.6, 0.8, 1.0],
                "raw_centers": [0.1, 0.3, 0.5, 0.7, 0.9],
                "calibrated_centers": [
                    round(float(ir.predict(np.array([c]))[0]), 4)
                    for c in [0.1, 0.3, 0.5, 0.7, 0.9]
                ],
                "bin_counts": [
                    int(((raw_arr >= lo) & (raw_arr < hi)).sum())
                    for lo, hi in [(0.0, 0.2), (0.2, 0.4), (0.4, 0.6), (0.6, 0.8), (0.8, 1.0)]
                ],
            },
        }

        # Optionally write to local persistent storage
        if write_local:
            bp_path = DATA_DIR / "isotonic_breakpoints.json"
            bp_path.write_text(json.dumps({
                "x_points": result["x_points"],
                "y_points": result["y_points"],
                "metadata": result["metadata"],
            }, indent=2))
            cm_path = DATA_DIR / "calibration-map.json"
            cm_path.write_text(json.dumps(result["calibration_map"], indent=2))
            # Update in-memory calibration map
            global _CAL_MAP
            _CAL_MAP = (
                result["calibration_map"]["bin_edges"],
                result["calibration_map"]["raw_centers"],
                result["calibration_map"]["calibrated_centers"],
            )

        return JSONResponse(result)

    except Exception as e:
        return JSONResponse({"error": f"fit-calibration failed: {str(e)[:300]}"}, status_code=500)


with gr.Blocks(title="NOMOS NBA QUANT — Genetic Evolution", theme=gr.themes.Monochrome()) as app:
    gr.Markdown("# NOMOS NBA QUANT AI — Island Model Genetic Evolution 24/7")
    gr.Markdown("*500 individuals across 5 islands (NSGA-II Pareto ranking). 13 model types including neural nets. Multi-objective: Brier + ROI + Sharpe + Calibration.*")

    with gr.Row():
        with gr.Column(scale=2):
            status_md = gr.Markdown(dash_status)
            top5_md = gr.Markdown(dash_top5)
        with gr.Column(scale=3):
            logs_box = gr.Textbox(label="Evolution Logs", value=dash_logs, lines=30, max_lines=30)

    with gr.Row():
        with gr.Column():
            hist_json = gr.Code(label="History (last 30 gens)", value=dash_history, language="json")
        with gr.Column():
            api_json = gr.Code(label="Latest Results (API)", value=dash_api, language="json")

    with gr.Row():
        refresh_btn = gr.Button("Refresh All", variant="primary")
        refresh_btn.click(dash_status, outputs=status_md)
        refresh_btn.click(dash_top5, outputs=top5_md)
        refresh_btn.click(dash_logs, outputs=logs_box)
        refresh_btn.click(dash_history, outputs=hist_json)
        refresh_btn.click(dash_api, outputs=api_json)

    timer = gr.Timer(15)
    timer.tick(dash_status, outputs=status_md)
    timer.tick(dash_top5, outputs=top5_md)
    timer.tick(dash_logs, outputs=logs_box)


# ── Register experiment endpoints BEFORE Gradio mount (Gradio catch-all at / swallows late routes) ──
if os.environ.get("EXPERIMENT_MODE"):
    from experiment_runner import experiment_loop, register_experiment_endpoints
    register_experiment_endpoints(control_api)
    log("Experiment endpoints registered on control_api")

# ── Mount FastAPI control API onto Gradio's app ──
gr_app = gr.mount_gradio_app(control_api, app, path="/")

# ── Launch background threads ──
if os.environ.get("EXPERIMENT_MODE"):
    _thread = threading.Thread(target=experiment_loop, daemon=True, name="ExperimentRunner")
    _thread.start()
    log("S11 EXPERIMENT RUNNER thread launched (EXPERIMENT_MODE=true)")
else:
    _thread = threading.Thread(target=evolution_loop, daemon=True, name="GeneticEvolution")
    _thread.start()
    log("Genetic evolution thread launched")

if __name__ == "__main__":
    import uvicorn
    mode = "EXPERIMENT RUNNER" if os.environ.get("EXPERIMENT_MODE") else "EVOLUTION"
    log(f"Starting with FastAPI + Gradio ({mode} mode, remote control API enabled)")
    uvicorn.run(gr_app, host="0.0.0.0", port=7860)


# ── Legacy DEAP-based island model stubs removed ──
# The island model is now natively implemented in the IslandModel class above.
# See: IslandModel, nsga2_rank, evolution_loop()


# (Legacy DEAP island model stubs have been removed — now using native IslandModel class)