Upload 7 files

gimme5_predictor.py

@@ -0,0 +1,230 @@
+#!/usr/bin/env python3
+"""Gimme5 wrapper ONLY (NO engine edits).
+
+Adds (wrapper-side only):
+- Diversified Ticket (escapes consensus collapse by mixing sets)
+- Counter-Ticket when collapse ~= top_cluster (anti-stagnation)
+- De-dup strike tickets in printed output
+- Timestamped outputs written to pred_outputs/
+
+This file calls your existing lotto_predictor.predict_for_game_v3().
+"""
+
+import argparse
+import importlib
+import random
+from collections import Counter
+from datetime import datetime
+from pathlib import Path
+
+import numpy as np
+
+
+def set_seed(seed: int) -> None:
+    random.seed(seed)
+    np.random.seed(seed)
+
+
+def _get_god_sets(res: dict):
+    return res.get("god_sets") or res.get("godmode_sets") or res.get("god_mode_sets") or []
+
+
+def _pick_style(sets, style_name: str):
+    for s in sets:
+        if (s.get("style") or "").lower() == style_name.lower():
+            return s
+    return None
+
+
+def _norm_nums(nums):
+    if not nums:
+        return None
+    try:
+        return tuple(int(x) for x in nums)
+    except Exception:
+        return tuple(nums)
+
+
+def _fmt(nums):
+    return "-".join(str(int(x)) for x in nums)
+
+
+def build_diversified_ticket(god_sets):
+    if not god_sets:
+        return None
+
+    top = _pick_style(god_sets, "top_cluster") or god_sets[0]
+    high = _pick_style(god_sets, "high_cluster") or _pick_style(god_sets, "wide_spread") or (god_sets[1] if len(god_sets) > 1 else top)
+    low = _pick_style(god_sets, "low_cluster") or (god_sets[2] if len(god_sets) > 2 else high)
+
+    picked = []
+
+    def add_from(src, upto):
+        for n in (src.get("numbers") or []):
+            n = int(n)
+            if n not in picked:
+                picked.append(n)
+            if len(picked) >= upto:
+                break
+
+    # 2 from top, 2 from high/wide, 1 from low
+    add_from(top, 2)
+    add_from(high, 4)
+    add_from(low, 5)
+
+    # If still short, fill from global freq
+    if len(picked) < 5:
+        freq = Counter()
+        for s in god_sets:
+            for n in (s.get("numbers") or []):
+                freq[int(n)] += 1
+        for n, _ in freq.most_common():
+            if n not in picked:
+                picked.append(n)
+            if len(picked) >= 5:
+                break
+
+    return sorted(picked[:5])
+
+
+def build_counter_ticket(god_sets):
+    """Choose numbers that are least represented across sets (anti-collapse)."""
+    if not god_sets:
+        return None
+    freq = Counter()
+    pool = set()
+    for s in god_sets:
+        for n in (s.get("numbers") or []):
+            n = int(n)
+            freq[n] += 1
+            pool.add(n)
+
+    least = sorted(pool, key=lambda n: (freq[n], n))
+
+    pref = []
+    for style in ("high_cluster", "wide_spread"):
+        s = _pick_style(god_sets, style)
+        if s:
+            for n in (s.get("numbers") or []):
+                n = int(n)
+                if n not in pref:
+                    pref.append(n)
+
+    combined = []
+    for n in pref + least:
+        if n not in combined:
+            combined.append(n)
+        if len(combined) >= 5:
+            break
+    return sorted(combined[:5]) if len(combined) >= 5 else None
+
+
+def collapse_similarity(a, b):
+    if not a or not b:
+        return 0
+    sa, sb = set(a), set(b)
+    return len(sa & sb)
+
+
+def build_text(res: dict):
+    lines = []
+    lines.append(\"WRAPPER BUILD: FORCE_ANCHORS_v1\")
+    lines.append(\"\")
+    lines.append("GAME: G5 (Gimme 5)")
+    lines.append(f"GENERATED: {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}")
+    lines.append("")
+
+    if res.get("numbers"):
+        lines.append("PRIMARY:")
+        lines.append(_fmt(res["numbers"]))
+        lines.append("")
+
+    god_sets = _get_god_sets(res)
+    if god_sets:
+        lines.append("GOD MODE SETS:")
+        for s in god_sets:
+            nums = s.get("numbers") or []
+            if nums:
+                lines.append(f"- {s.get('style','set')}: {_fmt(nums)}")
+        lines.append("")
+
+    strike = res.get("strike_tickets") or {}
+    collapse_nums = None
+    top_nums = None
+    if isinstance(strike, dict) and strike:
+        lines.append("STRIKE TICKETS:")
+        seen = set()
+        for k, v in strike.items():
+            if not isinstance(v, dict):
+                continue
+            nums = v.get("numbers") or []
+            t = _norm_nums(nums)
+            if t and t in seen:
+                continue
+            if t:
+                seen.add(t)
+            if (k or "").lower() == "collapse":
+                collapse_nums = [int(x) for x in nums] if nums else None
+            lines.append(f"- {k}: {_fmt(nums)}")
+        lines.append("")
+
+    top = _pick_style(god_sets, "top_cluster")
+    if top and top.get("numbers"):
+        top_nums = [int(x) for x in (top.get("numbers") or [])]
+
+    div = build_diversified_ticket(god_sets)
+    if div:
+        lines.append("DIVERSIFIED TICKET (wrapper-generated):")
+        lines.append(_fmt(div))
+        lines.append("")
+
+    if collapse_nums and top_nums:
+        sim = collapse_similarity(collapse_nums, top_nums)
+        if sim >= 4:
+            counter = build_counter_ticket(god_sets)
+            if counter:
+                lines.append("COUNTER-TICKET (anti-collapse, wrapper-generated):")
+                lines.append(_fmt(counter))
+                lines.append("")
+
+    return "\n".join(lines)
+
+
+def main():
+    ap = argparse.ArgumentParser()
+    ap.add_argument("--csv", default="gimme5_results.csv", help="CSV file in repo or full local path")
+    ap.add_argument("--seed", type=int, default=5105, help="Repro seed (wrapper-level, G5 default)")
+    ap.add_argument("--out-dir", default="pred_outputs", help="Write timestamped results here")
+    ap.add_argument("--no-deep-low", action="store_true")
+    ap.add_argument("--no-tight-relax", action="store_true")
+    ap.add_argument("--no-mid-carry", action="store_true")
+    ap.add_argument("--no-wildcard", action="store_true")
+    args = ap.parse_args()
+
+    set_seed(args.seed)
+
+    engine = importlib.import_module("lotto_predictor")
+
+    if hasattr(engine, "PATCH_UI_FLAGS") and isinstance(getattr(engine, "PATCH_UI_FLAGS"), dict):
+        engine.PATCH_UI_FLAGS.update({
+            "deep_low_patch": not args.no_deep_low,
+            "tight_relax_patch": not args.no_tight_relax,
+            "mid_carry_patch": not args.no_mid_carry,
+            "wildcard_strike": not args.no_wildcard,
+        })
+
+    res = engine.predict_for_game_v3(Path(args.csv), "gimme5", run_backtest=False)
+
+    text = build_text(res)
+
+    outp = Path(args.out_dir)
+    outp.mkdir(parents=True, exist_ok=True)
+    ts = datetime.now().strftime("%Y-%m-%d_%H-%M-%S")
+    out_file = outp / f"g5_godmode_{ts}.txt"
+    out_file.write_text(text, encoding="utf-8")
+
+    print(text)
+
+
+if __name__ == "__main__":
+    main()

l4l_predictor.py

@@ -0,0 +1,32 @@
+import json
+from pathlib import Path
+from lotto_predictor import predict_for_game_v3, NumpyEncoder
+
+def main():
+    # Lucky for Life CSV path
+    csv_path = Path("Lucky For Life.csv")
+    
+    try:
+        # Run prediction for Lucky for Life (game key "l4l")
+        print("Generating Lucky for Life prediction...")
+        res = predict_for_game_v3(csv_path, "l4l", run_backtest=False)
+        
+        print("Prediction:")
+        print(json.dumps(res, indent=2, cls=NumpyEncoder))
+        
+        print(f"\nPredicted Numbers: {res['numbers']}")
+        if res.get('star'):
+            print(f"Lucky Ball: {res['star']}")
+        
+        # Print model info if present
+        model_info = res.get('model_info', {})
+        print(f"\nModel built for {model_info.get('numbers_modeled', 0)} "
+              f"out of {model_info.get('total_possible', 0)} possible numbers")
+        
+    except Exception as e:
+        print(f"Prediction failed: {str(e)}")
+        import traceback
+        traceback.print_exc()
+
+if __name__ == "__main__":
+    main()

la_predictor.py

@@ -0,0 +1,2050 @@
+#!/usr/bin/env python3
+"""
+LOTTO PREDICTOR V5.3 ULTRA - GOD MODE
+
+Upgrades vs V5.2:
+- New GOD-MODE style: "top_cluster"
+  * Explicitly packs the top 3 highest-score numbers (not banned)
+    into one hyper-focused combo, then fills the rest.
+- Gimme5-specific tuning:
+  * Short-window ML weights increased for Gimme5
+  * Agent weights adjusted to favor recency / hot/cold / clusters more
+    for Gimme5, while other games keep the older balanced mix.
+- V5.3 ULTRA layer:
+  * Regime & trend-aware adjustment (low/flat/high volatility, high_run/low_run)
+  * Low-zone boost + cold-burst correction
+  * Anti-lock usage limiter across sets + coverage optimizer
+  * Mega Millions specific refinements for main numbers
+  * Lotto America specific main-range + Star Ball tweaks + neighbor-chaser
+  * Megabucks specific main-range tweaks (mid/high band support, soften 1–3)
+  * Powerball specific main-range tweaks (core band support, soften extremes)
+  * Lucky for Life specific main-range tweaks (central band support, soften extremes + neighbor-chaser)
+  * Gimme 5 neighbor-chaser with micro-boost around recent hot core numbers
+  * Mega Millions legacy Megaball 25→1–24 remap so all history fits MB 1–24
+  * Enhanced star/bonus picker (V5.3.1) with low-zone + cold-burst logic
+
+Features:
+- Multi-game, multi-agent, multi-window prediction engine
+- Games supported:
+    * gimme5 (Gimme 5)
+    * la (Lotto America)
+    * mb (Megabucks)
+    * mm (Mega Millions)
+    * pb (Powerball)
+    * l4l (Lucky for Life)
+- Multi-window ML:
+    * Short (20 draws), Medium (80 draws), Long (400 draws or all)
+- Agents per number:
+    * ML agent (RF + ET + GB + XGB + MLP ensemble)
+    * Hot/Cold frequency agent
+    * Bayesian frequency agent
+    * Recency agent
+    * RL-style "good draw" agent
+    * Pattern agent (sum/odd-even/high-low/range)
+    * Cluster compression agent (recent density bands)
+    * Drift agent (low/high sum shifts)
+    * Parity drift agent (odd/even imbalance)
+- Combination search:
+    * GOD-MODE Monte Carlo over agent scores + pattern scoring
+    * LAST-4 repeater ban rule (YOUR CUSTOM RULE):
+        - If a number appears in EACH of the last 4 consecutive draws,
+          it is banned from prediction. (We do NOT ban all numbers
+          that simply appeared in the last 4 once.)
+    * Generates multiple GOD MODE combos with different pattern styles:
+        - top_cluster (hyper-focused, forced top-3 core)
+        - balanced
+        - low_cluster
+        - high_cluster
+        - tight_cluster
+        - wide_spread
+- API:
+    * predict_for_game_v3(csv_path, game_key, run_backtest=False)
+    * predict_for_game(csv_path, game_key, run_backtest=False)
+    * generate_wheel_numbers(...)
+    * get_wheel_for_game(...)
+    * get_hot_cold_analysis(...)
+    * load_and_prepare_data(...)
+"""
+
+from __future__ import annotations
+
+import json
+import random
+from collections import Counter
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Dict, List, Optional, Tuple
+
+import numpy as np
+import pandas as pd
+import warnings
+
+warnings.filterwarnings("ignore")
+
+
+# ============================================================
+# JSON encoder for numpy types
+# ============================================================
+
+class NumpyEncoder(json.JSONEncoder):
+    def default(self, obj):
+        if isinstance(obj, (np.integer, np.int64)):
+            return int(obj)
+        if isinstance(obj, (np.floating, np.float64)):
+            return float(obj)
+        if isinstance(obj, np.ndarray):
+            return obj.tolist()
+        return super().default(obj)
+
+
+# ============================================================
+# Game configuration
+# ============================================================
+
+@dataclass
+class GameConfig:
+    name: str
+    csv_date_col: str
+    main_cols: List[str]
+    star_col: Optional[str]
+    main_min: int
+    main_max: int
+    star_min: Optional[int] = None
+    star_max: Optional[int] = None
+    sum_min: int = 0
+    sum_max: int = 1000
+    clean_func: Optional[str] = None
+    draw_frequency: str = "Unknown"  # used by engine/app
+
+
+GAME_CONFIGS: Dict[str, GameConfig] = {
+    "gimme5": GameConfig(
+        name="Gimme 5",
+        csv_date_col="Date",
+        main_cols=["1", "2", "3", "4", "5"],
+        star_col=None,
+        main_min=1,
+        main_max=39,
+        sum_min=40,
+        sum_max=160,
+        draw_frequency="5x/week",
+    ),
+    "la": GameConfig(
+        name="Lotto America",
+        csv_date_col="DrawDate",
+        main_cols=["1", "2", "3", "4", "5"],
+        star_col="SB",
+        main_min=1,
+        main_max=52,
+        star_min=1,
+        star_max=10,
+        sum_min=70,
+        sum_max=210,
+        draw_frequency="3x/week",
+    ),
+    "mb": GameConfig(
+        name="Megabucks",
+        csv_date_col="Date",
+        main_cols=["1", "2", "3", "4", "5"],
+        star_col="Megaball",
+        main_min=1,
+        main_max=41,
+        star_min=1,
+        star_max=6,
+        sum_min=45,
+        sum_max=165,
+        draw_frequency="3x/week",
+    ),
+    "mm": GameConfig(
+        name="Mega Millions",
+        csv_date_col="Date",
+        main_cols=["1", "2", "3", "4", "5"],
+        star_col="MB",
+        main_min=1,
+        main_max=70,
+        star_min=1,
+        star_max=24,  # modern format (Megaball 1–24, legacy 25 remapped below)
+        sum_min=75,
+        sum_max=280,
+        draw_frequency="2x/week",
+    ),
+    "pb": GameConfig(
+        name="Powerball",
+        csv_date_col="DrawDate",
+        main_cols=["1", "2", "3", "4", "5"],
+        star_col="PB",
+        main_min=1,
+        main_max=69,
+        star_min=1,
+        star_max=26,
+        sum_min=65,
+        sum_max=265,
+        clean_func="clean_powerball_df",
+        draw_frequency="3x/week",
+    ),
+    "l4l": GameConfig(
+        name="Lucky for Life",
+        csv_date_col="Draw Date",
+        main_cols=["Ball 1", "Ball 2", "Ball 3", "Ball 4", "Ball 5"],
+        star_col="Lucky Ball",
+        main_min=1,
+        main_max=48,
+        star_min=1,
+        star_max=18,
+        sum_min=60,
+        sum_max=200,
+        draw_frequency="Daily",
+    ),
+}
+
+
+# ============================================================
+# Cleaning / Date / Recency helpers
+# ============================================================
+
+def clean_powerball_df(raw_df: pd.DataFrame) -> pd.DataFrame:
+    """
+    Example cleanup for Powerball: drop Double Play / malformed rows.
+    Adapt if your PB CSV has extra columns.
+    """
+    df = raw_df.copy()
+    if "DrawDate" in df.columns:
+        mask = ~df["DrawDate"].astype(str).str.contains("Double Play", na=False)
+        df = df[mask]
+    return df.reset_index(drop=True)
+
+
+def _ensure_datetime(df: pd.DataFrame, date_col: str) -> pd.DataFrame:
+    df = df.copy()
+    df[date_col] = pd.to_datetime(df[date_col], errors="coerce")
+    invalid = df[date_col].isna().sum()
+    if invalid > 0:
+        df = df.dropna(subset=[date_col])
+    df = df.sort_values(date_col).reset_index(drop=True)
+
+    df["Date"] = pd.to_datetime(df[date_col], errors="coerce")
+    df["DayOfWeek"] = df["Date"].dt.dayofweek
+    df["Month"] = df["Date"].dt.month
+    df["Year"] = df["Date"].dt.year
+    df["DayOfYear"] = df["Date"].dt.dayofyear
+    return df
+
+
+def _limit_history(df: pd.DataFrame, max_rows: int) -> pd.DataFrame:
+    if len(df) > max_rows:
+        return df.tail(max_rows).reset_index(drop=True)
+    return df.reset_index(drop=True)
+
+
+# ============================================================
+# Structural features per draw
+# ============================================================
+
+def calculate_structural_features(df: pd.DataFrame, cfg: GameConfig) -> pd.DataFrame:
+    df = df.copy()
+    df["sum_total"] = df[cfg.main_cols].sum(axis=1)
+    df["mean_val"] = df[cfg.main_cols].mean(axis=1)
+    df["std_val"] = df[cfg.main_cols].std(axis=1)
+
+    df["even_count"] = df[cfg.main_cols].apply(
+        lambda row: sum(1 for v in row if v % 2 == 0), axis=1
+    )
+    df["odd_count"] = len(cfg.main_cols) - df["even_count"]
+
+    df["range_span"] = df[cfg.main_cols].max(axis=1) - df[cfg.main_cols].min(axis=1)
+
+    midpoint = (cfg.main_min + cfg.main_max) / 2.0
+    df["high_count"] = df[cfg.main_cols].apply(
+        lambda row: sum(1 for v in row if v > midpoint), axis=1
+    )
+    df["low_count"] = len(cfg.main_cols) - df["high_count"]
+
+    def count_consecutive(values):
+        s = sorted(values)
+        return sum(1 for i in range(len(s) - 1) if s[i + 1] - s[i] == 1)
+
+    def avg_gap(values):
+        s = sorted(values)
+        gaps = [s[i + 1] - s[i] for i in range(len(s) - 1)]
+        return float(np.mean(gaps)) if gaps else 0.0
+
+    df["consecutive_count"] = df[cfg.main_cols].apply(count_consecutive, axis=1)
+    df["avg_gap"] = df[cfg.main_cols].apply(avg_gap, axis=1)
+
+    return df
+
+
+def create_frequency_features(
+    df: pd.DataFrame,
+    cfg: GameConfig,
+    windows: List[int] = [20, 80, 400],
+) -> Dict[int, Dict[str, float]]:
+    freq: Dict[int, Dict[str, float]] = {}
+    for num in range(cfg.main_min, cfg.main_max + 1):
+        freq[num] = {}
+        total_hits = (df[cfg.main_cols] == num).sum().sum()
+        freq[num]["overall_freq"] = total_hits / max(len(df), 1)
+
+        for w in windows:
+            sub = df.tail(w) if len(df) >= w else df
+            hits = (sub[cfg.main_cols] == num).sum().sum()
+            freq[num][f"freq_{w}"] = hits / max(len(sub), 1)
+
+        last_idx = -1
+        for i in range(len(df) - 1, -1, -1):
+            if num in df.iloc[i][cfg.main_cols].values:
+                last_idx = i
+                break
+        if last_idx == -1:
+            freq[num]["days_since_last"] = float(len(df))
+        else:
+            freq[num]["days_since_last"] = float(len(df) - 1 - last_idx)
+    return freq
+
+
+# ============================================================
+# Multi-window ML ensemble
+# ============================================================
+
+try:
+    from xgboost import XGBClassifier
+    _HAS_XGB = True
+except ImportError:
+    from sklearn.ensemble import GradientBoostingClassifier as XGBClassifier
+    _HAS_XGB = False
+
+from sklearn.ensemble import (
+    RandomForestClassifier,
+    ExtraTreesClassifier,
+    GradientBoostingClassifier,
+    VotingClassifier,
+)
+from sklearn.neural_network import MLPClassifier
+from sklearn.model_selection import train_test_split
+from sklearn.preprocessing import StandardScaler
+from sklearn.metrics import accuracy_score
+
+
+def _build_window_ml_models(
+    df: pd.DataFrame,
+    cfg: GameConfig,
+    window: int,
+) -> Dict[int, Dict]:
+    """
+    Train a per-number ML ensemble for a given window size.
+    Returns {num: {"model": VotingClassifier, "scaler": StandardScaler, "feature_cols": [...], "accuracy": float}}
+    """
+    if len(df) < 40:
+        return {}
+
+    sub = df.tail(window) if len(df) > window else df
+    feats = calculate_structural_features(sub, cfg)
+
+    base_cols = [
+        "DayOfWeek",
+        "Month",
+        "sum_total",
+        "even_count",
+        "odd_count",
+        "range_span",
+        "consecutive_count",
+        "avg_gap",
+        "high_count",
+    ]
+    feature_cols = [c for c in base_cols if c in feats.columns]
+    X = feats[feature_cols].fillna(0.0)
+
+    scaler = StandardScaler()
+    X_scaled = scaler.fit_transform(X)
+
+    models: Dict[int, Dict] = {}
+
+    for num in range(cfg.main_min, cfg.main_max + 1):
+        y = (sub[cfg.main_cols] == num).any(axis=1).astype(int)
+        if y.sum() < 4:
+            continue
+
+        try:
+            X_train, X_test, y_train, y_test = train_test_split(
+                X_scaled, y, test_size=0.2, random_state=42, stratify=y
+            )
+
+            rf = RandomForestClassifier(
+                n_estimators=120,
+                max_depth=7,
+                random_state=42,
+                class_weight="balanced",
+            )
+            et = ExtraTreesClassifier(
+                n_estimators=120,
+                max_depth=7,
+                random_state=42,
+                class_weight="balanced",
+            )
+            gb = GradientBoostingClassifier(
+                n_estimators=120,
+                max_depth=3,
+                learning_rate=0.08,
+                random_state=42,
+            )
+            if _HAS_XGB:
+                xgb = XGBClassifier(
+                    n_estimators=120,
+                    max_depth=3,
+                    learning_rate=0.08,
+                    subsample=0.9,
+                    colsample_bytree=0.9,
+                    eval_metric="logloss",
+                    random_state=42,
+                )
+            else:
+                xgb = XGBClassifier(
+                    n_estimators=120,
+                    max_depth=3,
+                    random_state=42,
+                )
+
+            mlp = MLPClassifier(
+                hidden_layer_sizes=(32, 16),
+                max_iter=600,
+                random_state=42,
+                alpha=0.0005,
+            )
+
+            ensemble = VotingClassifier(
+                estimators=[
+                    ("rf", rf),
+                    ("et", et),
+                    ("gb", gb),
+                    ("xgb", xgb),
+                    ("mlp", mlp),
+                ],
+                voting="soft",
+            )
+
+            ensemble.fit(X_train, y_train)
+            y_pred = ensemble.predict(X_test)
+            acc = accuracy_score(y_test, y_pred)
+
+            if acc >= 0.52:
+                models[num] = {
+                    "model": ensemble,
+                    "scaler": scaler,
+                    "feature_cols": feature_cols,
+                    "accuracy": acc,
+                }
+
+        except Exception:
+            continue
+
+    return models
+
+
+def build_multiwindow_ml(
+    df: pd.DataFrame,
+    cfg: GameConfig,
+    windows: List[int] = [20, 80, 400],
+) -> Dict[int, Dict[str, object]]:
+    """
+    Train ML models in multiple history windows and store them per number.
+    result[num] = {"short": {...}, "medium": {...}, "long": {...}}
+    """
+    models_by_window: Dict[int, Dict[str, object]] = {}
+
+    if len(df) < 40:
+        return {}
+
+    for w in windows:
+        label = "short" if w <= 20 else ("medium" if w <= 120 else "long")
+        mw = _build_window_ml_models(df, cfg, w)
+        for num, info in mw.items():
+            if num not in models_by_window:
+                models_by_window[num] = {}
+            models_by_window[num][label] = info
+
+    return models_by_window
+
+
+# ============================================================
+# Multi-agent per-number scoring (V5.2 + Gimme5 tuning)
+# ============================================================
+
+def compute_agent_scores(
+    df: pd.DataFrame,
+    cfg: GameConfig,
+    ml_models: Dict[int, Dict[str, object]],
+    freq_features: Dict[int, Dict[str, float]],
+) -> Dict[int, Dict[str, float]]:
+    """
+    Compute scores from multiple agents for each number:
+      - ml_agent
+      - hotcold_agent
+      - bayes_agent
+      - recency_agent
+      - rl_agent
+      - pattern_agent
+      - cluster_agent
+      - drift_agent
+      - parity_agent
+    """
+    scores: Dict[int, Dict[str, float]] = {}
+
+    df_struct = calculate_structural_features(df, cfg)
+    latest_feat = df_struct.iloc[[-1]].copy()
+
+    base_cols = [
+        "DayOfWeek",
+        "Month",
+        "sum_total",
+        "even_count",
+        "odd_count",
+        "range_span",
+        "consecutive_count",
+        "avg_gap",
+        "high_count",
+    ]
+    latest_feat = latest_feat.reindex(columns=base_cols, fill_value=0.0)
+
+    # Global stats for drift / cluster
+    sums = df[cfg.main_cols].sum(axis=1)
+    sum_mean = float(sums.mean())
+    sum_std = float(sums.std()) if sums.std() > 0 else 1.0
+
+    total_draws = len(df)
+
+    # Good draws mask for RL (sums near mean)
+    good_mask = (abs(sums - sum_mean) <= sum_std)
+    good_indices = df.index[good_mask]
+
+    # RL rewards
+    rl_rewards: Dict[int, float] = {}
+    for num in range(cfg.main_min, cfg.main_max + 1):
+        if total_draws <= 0:
+            rl_rewards[num] = 0.5
+            continue
+        good_hits = 0
+        for idx in good_indices:
+            if num in df.loc[idx, cfg.main_cols].values:
+                good_hits += 1
+        rl_rewards[num] = good_hits / max(len(good_indices), 1)
+
+    # Cluster agent: based on recent 40 draws, density in +/-2 window
+    recent_n = min(40, len(df))
+    recent = df.tail(recent_n) if recent_n > 0 else df
+    cluster_counts: Dict[int, float] = {}
+    if recent_n > 0:
+        all_recent_nums = recent[cfg.main_cols].values.flatten()
+        all_recent_nums = [int(v) for v in all_recent_nums if not pd.isna(v)]
+        hist = Counter(all_recent_nums)
+        for num in range(cfg.main_min, cfg.main_max + 1):
+            window_sum = 0
+            for k in range(num - 2, num + 3):
+                if cfg.main_min <= k <= cfg.main_max:
+                    window_sum += hist.get(k, 0)
+            cluster_counts[num] = window_sum
+        if cluster_counts:
+            max_cluster = max(cluster_counts.values()) or 1
+            for num in cluster_counts.keys():
+                cluster_counts[num] = cluster_counts[num] / max_cluster
+    else:
+        for num in range(cfg.main_min, cfg.main_max + 1):
+            cluster_counts[num] = 0.5
+
+    # Drift agent: compare recent sums vs older sums (20 vs 80)
+    recent_window = min(20, len(df))
+    mid_window = min(80, len(df))
+    if mid_window > recent_window >= 5:
+        recent_sums = sums.tail(recent_window)
+        older_sums = sums.tail(mid_window).head(mid_window - recent_window)
+        recent_mean = float(recent_sums.mean())
+        older_mean = float(older_sums.mean()) if len(older_sums) > 0 else recent_mean
+        if older_mean > 0:
+            drift_ratio = (recent_mean - older_mean) / older_mean
+        else:
+            drift_ratio = 0.0
+    else:
+        drift_ratio = 0.0
+
+    # Parity drift: even/odd balance in last 40 draws
+    if len(df) >= 10:
+        last_k = df.tail(min(40, len(df)))
+        even_counts = last_k[cfg.main_cols].apply(
+            lambda row: sum(1 for v in row if v % 2 == 0), axis=1
+        )
+        even_mean_recent = float(even_counts.mean())
+        expected_even = len(cfg.main_cols) / 2.0
+        parity_delta = even_mean_recent - expected_even
+    else:
+        parity_delta = 0.0
+
+    # Pre-calc uniform position mapping for drift
+    span = cfg.main_max - cfg.main_min if cfg.main_max > cfg.main_min else 1
+
+    # Is this Gimme5? (name is "Gimme 5")
+    is_gimme5 = cfg.name.lower().startswith("gimme")
+
+    for num in range(cfg.main_min, cfg.main_max + 1):
+        scores[num] = {}
+
+        # ML agent
+        ml_score = 0.5
+        if num in ml_models:
+            cfg_models = ml_models[num]
+            probs = []
+            weights = []
+            for label, info in cfg_models.items():
+                model = info["model"]
+                scaler = info["scaler"]
+                feature_cols = info["feature_cols"]
+                X_latest = latest_feat[feature_cols].fillna(0.0)
+                X_scaled = scaler.transform(X_latest)
+                if hasattr(model, "predict_proba"):
+                    p = model.predict_proba(X_scaled)[0][1]
+                else:
+                    p = 0.5
+                probs.append(p)
+                # V5.2: Gimme5 → stronger short-window weighting
+                if is_gimme5:
+                    if label == "short":
+                        weights.append(0.6)
+                    elif label == "medium":
+                        weights.append(0.25)
+                    else:
+                        weights.append(0.15)
+                else:
+                    if label == "short":
+                        weights.append(0.5)
+                    elif label == "medium":
+                        weights.append(0.3)
+                    else:
+                        weights.append(0.2)
+            if probs:
+                p_arr = np.array(probs)
+                w_arr = np.array(weights)
+                ml_score = float((p_arr * w_arr).sum() / w_arr.sum())
+        scores[num]["ml_agent"] = float(np.clip(ml_score, 0.0, 1.0))
+
+        # Hot/cold agent
+        fdata = freq_features[num]
+        f_20 = fdata.get("freq_20", 0.0)
+        f_80 = fdata.get("freq_80", 0.0)
+        f_400 = fdata.get("freq_400", fdata.get("overall_freq", 0.0))
+        hot_score = 0.5 * f_20 + 0.3 * f_80 + 0.2 * f_400
+        scores[num]["hotcold_agent"] = float(np.clip(hot_score * 5.0, 0.0, 1.0))
+
+        # Bayesian agent
+        hits = (df[cfg.main_cols] == num).sum().sum()
+        bayes_mean = (hits + 1.0) / (total_draws + 2.0)
+        scores[num]["bayes_agent"] = float(np.clip(bayes_mean * 8.0, 0.0, 1.0))
+
+        # Recency agent
+        days_since_last = fdata.get("days_since_last", float(total_draws))
+        recency_score = 1.0 / (1.0 + 0.08 * days_since_last)
+        scores[num]["recency_agent"] = float(np.clip(recency_score, 0.0, 1.0))
+
+        # RL agent
+        rl_raw = rl_rewards[num]
+        scores[num]["rl_agent"] = float(np.clip(rl_raw * 5.0, 0.0, 1.0))
+
+        # Pattern agent: how well this number participates in "good" patterns
+        pattern_hits = 0
+        pattern_total = 0
+        for idx in range(total_draws):
+            row_nums = df.loc[idx, cfg.main_cols].values
+            if num not in row_nums:
+                continue
+            row_sum = row_nums.sum()
+            even_cnt = sum(1 for v in row_nums if v % 2 == 0)
+            in_range = (cfg.sum_min <= row_sum <= cfg.sum_max)
+            balanced = even_cnt in (2, 3)
+            if in_range and balanced:
+                pattern_hits += 1
+            pattern_total += 1
+        pattern_score = (pattern_hits / pattern_total) if pattern_total > 0 else 0.5
+        scores[num]["pattern_agent"] = float(np.clip(pattern_score, 0.0, 1.0))
+
+        # Cluster agent (recent density in +/-2 around num)
+        scores[num]["cluster_agent"] = float(
+            np.clip(cluster_counts.get(num, 0.5), 0.0, 1.0)
+        )
+
+        # Drift agent: if sums drifting lower, prefer low; if higher, prefer high
+        if drift_ratio < -0.03:  # trending lower
+            pos = (num - cfg.main_min) / span
+            drift_score = 1.0 - pos  # low numbers ~1, high ~0
+        elif drift_ratio > 0.03:  # trending higher
+            pos = (num - cfg.main_min) / span
+            drift_score = pos  # high numbers ~1, low ~0
+        else:
+            drift_score = 0.5
+        scores[num]["drift_agent"] = float(np.clip(drift_score, 0.0, 1.0))
+
+        # Parity drift agent: favor even or odd depending on recent imbalance
+        if abs(parity_delta) < 0.2:
+            parity_score = 0.5
+        else:
+            is_even = (num % 2 == 0)
+            if parity_delta > 0:  # more evens recently
+                parity_score = 0.8 if is_even else 0.2
+            else:  # more odds recently
+                parity_score = 0.8 if not is_even else 0.2
+        scores[num]["parity_agent"] = float(np.clip(parity_score, 0.0, 1.0))
+
+    # Normalize each agent across all numbers (0..1)
+    if scores:
+        agent_names = list(next(iter(scores.values())).keys())
+        for agent in agent_names:
+            vals = np.array([scores[n][agent] for n in scores.keys()])
+            vmin, vmax = vals.min(), vals.max()
+            if vmax > vmin:
+                for n in scores.keys():
+                    scores[n][agent] = float(
+                        (scores[n][agent] - vmin) / (vmax - vmin)
+                    )
+            else:
+                for n in scores.keys():
+                    scores[n][agent] = 0.5
+
+    return scores
+
+
+def combine_agent_scores(
+    agent_scores: Dict[int, Dict[str, float]],
+    cfg: GameConfig,
+) -> Dict[int, float]:
+    """
+    Combine multi-agent scores into a single score per number.
+    V5.2: uses a different profile for Gimme5 vs other games.
+    """
+    is_gimme5 = cfg.name.lower().startswith("gimme")
+
+    if is_gimme5:
+        # Gimme5: faster game, lean more on short-window / recency / clusters
+        weights = {
+            "ml_agent":      0.20,
+            "hotcold_agent": 0.20,
+            "bayes_agent":   0.10,
+            "recency_agent": 0.15,
+            "rl_agent":      0.10,
+            "pattern_agent": 0.05,
+            "cluster_agent": 0.12,
+            "drift_agent":   0.04,
+            "parity_agent":  0.04,
+        }
+    else:
+        # Other games: more balanced
+        weights = {
+            "ml_agent":      0.25,
+            "hotcold_agent": 0.18,
+            "bayes_agent":   0.12,
+            "recency_agent": 0.08,
+            "rl_agent":      0.12,
+            "pattern_agent": 0.08,
+            "cluster_agent": 0.08,
+            "drift_agent":   0.05,
+            "parity_agent":  0.04,
+        }
+
+    final_scores: Dict[int, float] = {}
+    for num, agents in agent_scores.items():
+        total = 0.0
+        for name, w in weights.items():
+            total += w * agents.get(name, 0.5)
+        final_scores[num] = float(total)
+
+    if final_scores:
+        vals = np.array(list(final_scores.values()))
+        vmin, vmax = vals.min(), vals.max()
+        if vmax > vmin:
+            for n in final_scores.keys():
+                final_scores[n] = float((final_scores[n] - vmin) / (vmax - vmin))
+        else:
+            for n in final_scores.keys():
+                final_scores[n] = 0.5
+
+    return final_scores
+
+
+# ============================================================
+# Combination scoring & generation
+# ============================================================
+
+def score_combo_pattern(
+    combo: List[int],
+    df: pd.DataFrame,
+    cfg: GameConfig,
+    style: str = "balanced",
+) -> float:
+    """
+    Score a candidate combination:
+    - Sum vs history & config
+    - Even/odd mix
+    - Range & gaps
+    plus style-specific tweaks for multi-style GOD MODE.
+    """
+    combo = sorted(combo)
+    score = 0.0
+
+    sums = df[cfg.main_cols].sum(axis=1)
+    sum_mean = float(sums.mean())
+    sum_std = float(sums.std()) if sums.std() > 0 else 1.0
+
+    combo_sum = sum(combo)
+    if cfg.sum_min <= combo_sum <= cfg.sum_max:
+        score += 1.0
+        z = abs(combo_sum - sum_mean) / sum_std
+        score += max(0.0, 1.5 - z)
+    else:
+        score -= 1.0
+
+    even_count = sum(1 for v in combo if v % 2 == 0)
+    if even_count in (2, 3):
+        score += 1.0
+    elif even_count in (1, 4):
+        score += 0.2
+    else:
+        score -= 0.5
+
+    combo_range = max(combo) - min(combo)
+    hist_range = df[cfg.main_cols].max(axis=1) - df[cfg.main_cols].min(axis=1)
+    mean_r = float(hist_range.mean()) if len(hist_range) > 0 else combo_range
+    if mean_r > 0:
+        diff = abs(combo_range - mean_r) / mean_r
+        if diff < 0.3:
+            score += 0.7
+        elif diff < 0.6:
+            score += 0.2
+        else:
+            score -= 0.2
+
+    gaps = [combo[i + 1] - combo[i] for i in range(len(combo) - 1)]
+    avg_gap = float(np.mean(gaps)) if gaps else 0.0
+
+    midpoint = (cfg.main_min + cfg.main_max) / 2.0
+    low_count = sum(1 for v in combo if v <= midpoint)
+    high_count = len(combo) - low_count
+
+    if style == "low_cluster":
+        if low_count >= 3:
+            score += 0.7
+        if combo_range <= (cfg.main_max - cfg.main_min) * 0.5:
+            score += 0.3
+    elif style == "high_cluster":
+        if high_count >= 3:
+            score += 0.7
+        if combo_range <= (cfg.main_max - cfg.main_min) * 0.5:
+            score += 0.3
+    elif style == "tight_cluster":
+        if combo_range <= (cfg.main_max - cfg.main_min) * 0.4:
+            score += 0.8
+        if avg_gap <= 8:
+            score += 0.4
+    elif style == "wide_spread":
+        if combo_range >= (cfg.main_max - cfg.main_min) * 0.6:
+            score += 0.8
+        if avg_gap >= 6:
+            score += 0.4
+    elif style == "top_cluster":
+        # Reward combos staying fairly central and not too extreme
+        if combo_range <= (cfg.main_max - cfg.main_min) * 0.6:
+            score += 0.5
+        if avg_gap <= 10:
+            score += 0.3
+
+    return score
+
+
+def generate_godmode_combo(
+    df: pd.DataFrame,
+    cfg: GameConfig,
+    final_scores: Dict[int, float],
+    banned_nums: Optional[set] = None,
+    n_candidates: int = 6000,
+    style: str = "balanced",
+) -> Tuple[List[int], float]:
+    """
+    Monte Carlo search for best combination for a given style.
+    style ∈ {"balanced", "low_cluster", "high_cluster", "tight_cluster", "wide_spread", "top_cluster"}
+    (for "top_cluster" a separate helper is usually used, but style is kept
+    here for consistency).
+    """
+    if banned_nums is None:
+        banned_nums = set()
+
+    filtered_scores = {n: s for n, s in final_scores.items() if n not in banned_nums}
+    if not filtered_scores:
+        filtered_scores = final_scores.copy()
+
+    numbers = list(filtered_scores.keys())
+    weights = np.array(list(filtered_scores.values()), dtype=float)
+    if weights.sum() <= 0:
+        weights = np.ones_like(weights)
+    weights /= weights.sum()
+
+    best_combo: Optional[List[int]] = None
+    best_score = -1e9
+
+    for _ in range(n_candidates):
+        combo = list(
+            np.random.choice(numbers, size=len(cfg.main_cols), replace=False, p=weights)
+        )
+        combo.sort()
+        pat_score = score_combo_pattern(combo, df, cfg, style=style)
+        synergy = float(np.mean([filtered_scores[n] for n in combo]))
+        total_score = pat_score + synergy * 2.0
+        if total_score > best_score:
+            best_score = total_score
+            best_combo = combo
+
+    if best_combo is None:
+        best_combo = sorted(
+            np.random.choice(numbers, size=len(cfg.main_cols), replace=False).tolist()
+        )
+
+    return best_combo, float(best_score)
+
+
+def generate_top_cluster_combo(
+    df: pd.DataFrame,
+    cfg: GameConfig,
+    final_scores: Dict[int, float],
+    banned_nums: Optional[set] = None,
+    top_n_core: int = 3,
+    n_candidates: int = 3000,
+) -> Tuple[List[int], float]:
+    """
+    Hyper-focused combo that forces top K highest-score numbers together
+    in a single line, then fills the remaining spots with other strong numbers.
+    """
+    if banned_nums is None:
+        banned_nums = set()
+
+    sorted_nums = sorted(
+        ((n, s) for n, s in final_scores.items() if n not in banned_nums),
+        key=lambda kv: kv[1],
+        reverse=True,
+    )
+    if not sorted_nums:
+        sorted_nums = sorted(final_scores.items(), key=lambda kv: kv[1], reverse=True)
+
+    core = [n for n, _ in sorted_nums[:top_n_core]]
+    core = core[: len(cfg.main_cols)]  # safety
+
+    remaining_pool = [n for n, _ in sorted_nums if n not in core]
+    if len(remaining_pool) < (len(cfg.main_cols) - len(core)):
+        # not enough left, just fall back
+        return generate_godmode_combo(
+            df, cfg, final_scores, banned_nums=banned_nums, n_candidates=n_candidates, style="top_cluster"
+        )
+
+    remaining_weights = np.array([final_scores[n] for n in remaining_pool], dtype=float)
+    if remaining_weights.sum() <= 0:
+        remaining_weights = np.ones_like(remaining_weights)
+    remaining_weights /= remaining_weights.sum()
+
+    best_combo: Optional[List[int]] = None
+    best_score = -1e9
+
+    needed = len(cfg.main_cols) - len(core)
+
+    for _ in range(n_candidates):
+        support = list(
+            np.random.choice(
+                remaining_pool,
+                size=needed,
+                replace=False,
+                p=remaining_weights,
+            )
+        )
+        combo = sorted(core + support)
+        pat_score = score_combo_pattern(combo, df, cfg, style="top_cluster")
+        synergy = float(np.mean([final_scores[n] for n in combo]))
+        total_score = pat_score + synergy * 2.0
+        if total_score > best_score:
+            best_score = total_score
+            best_combo = combo
+
+    if best_combo is None:
+        # extreme fallback
+        return generate_godmode_combo(
+            df, cfg, final_scores, banned_nums=banned_nums, n_candidates=n_candidates, style="top_cluster"
+        )
+
+    return best_combo, float(best_score)
+
+
+def _compute_sum_regime_and_trend(df: pd.DataFrame, cfg: GameConfig) -> Dict[str, object]:
+    """
+    Analyze recent sums to detect:
+      - volatility regime: low / flat / high
+      - short-term trend: high_run / low_run / none
+    """
+    sums = df[cfg.main_cols].sum(axis=1)
+    if len(sums) == 0:
+        return {
+            "regime": "unknown",
+            "volatility": 0.0,
+            "trend": "none",
+            "mean": 0.0,
+            "std": 1.0,
+        }
+
+    recent = sums.tail(40) if len(sums) > 40 else sums
+    mean = float(recent.mean())
+    std = float(recent.std()) if recent.std() > 0 else 1.0
+
+    z = (recent - mean) / std
+    vol = float(np.mean(np.abs(z)))
+
+    if vol < 0.8:
+        regime = "low"
+    elif vol > 1.2:
+        regime = "high"
+    else:
+        regime = "flat"
+
+    last_k = min(6, len(recent))
+    tail = recent.tail(last_k)
+    hi_th = mean + 0.5 * std
+    lo_th = mean - 0.5 * std
+
+    last3 = tail.tail(3)
+    if all(v > hi_th for v in last3):
+        trend = "high_run"
+    elif all(v < lo_th for v in last3):
+        trend = "low_run"
+    else:
+        trend = "none"
+
+    return {
+        "regime": regime,
+        "volatility": vol,
+        "trend": trend,
+        "mean": mean,
+        "std": std,
+    }
+
+
+def _compute_coldness(df: pd.DataFrame, cfg: GameConfig) -> Dict[int, float]:
+    """
+    Coldness score per number in [0,1], where 1 = very cold, 0 = very hot.
+    """
+    all_nums = df[cfg.main_cols].values.flatten()
+    all_nums = [int(v) for v in all_nums if not pd.isna(v)]
+    if not all_nums:
+        return {n: 0.5 for n in range(cfg.main_min, cfg.main_max + 1)}
+
+    freq = Counter(all_nums)
+    values = list(freq.values())
+    if not values:
+        return {n: 0.5 for n in range(cfg.main_min, cfg.main_max + 1)}
+
+    f_min = min(values)
+    f_max = max(values)
+    denom = max(f_max - f_min, 1)
+
+    coldness: Dict[int, float] = {}
+    for n in range(cfg.main_min, cfg.main_max + 1):
+        f = freq.get(n, 0)
+        cold = (f_max - f) / denom  # high when f is small
+        coldness[n] = float(np.clip(cold, 0.0, 1.0))
+    return coldness
+
+
+def _adjust_scores_v5_3(
+    df: pd.DataFrame,
+    cfg: GameConfig,
+    base_scores: Dict[int, float],
+) -> Tuple[Dict[int, float], Dict[str, object], Dict[int, float]]:
+    """
+    V5.3 ULTRA correction layer:
+      1) Dynamic regime detection (low/flat/high volatility).
+      2) Low-zone boost (roughly bottom 1/3rd of the range).
+      3) Inverse-trend feature (reversal agent).
+      4) Cold-burst: slight boost to colder numbers, dampen over-hot.
+      5) Mega Millions specific high-band refinements.
+      6) Lotto America specific main-range tweaks + neighbor-chaser.
+      7) Megabucks specific main-range tweaks.
+      8) Powerball specific main-range tweaks.
+      9) Lucky for Life specific main-range tweaks + neighbor-chaser for mids.
+     10) Gimme 5 neighbor-chaser with micro-boost around recent hot core numbers.
+    Returns:
+      adjusted_scores, regime_info, coldness_map
+    """
+    if not base_scores:
+        return base_scores, {"regime": "unknown"}, {
+            n: 0.5 for n in range(cfg.main_min, cfg.main_max + 1)
+        }
+
+    regime_info = _compute_sum_regime_and_trend(df, cfg)
+    regime = regime_info.get("regime", "flat")
+    trend = regime_info.get("trend", "none")
+
+    span = max(cfg.main_max - cfg.main_min, 1)
+    mid = cfg.main_min + span / 2.0
+    low_cut = cfg.main_min + int(span * 0.33)
+    regime_info["low_zone_cut"] = low_cut
+
+    coldness = _compute_coldness(df, cfg)
+
+    vals = np.array(list(base_scores.values()), dtype=float)
+    vmin, vmax = float(vals.min()), float(vals.max())
+    norm_scores: Dict[int, float] = {}
+    if vmax > vmin:
+        for n, s in base_scores.items():
+            norm_scores[n] = float((s - vmin) / (vmax - vmin))
+    else:
+        for n in base_scores.keys():
+            norm_scores[n] = 0.5
+
+    # Lucky for Life neighbor-chaser: identify recent hot mids (11–38)
+    l4l_hot_mids: set = set()
+    if cfg.name == "Lucky for Life":
+        recent_draws = df[cfg.main_cols].tail(30)
+        vals_mid = recent_draws.values.flatten()
+        mids = [
+            int(v)
+            for v in vals_mid
+            if not pd.isna(v) and 11 <= int(v) <= 38
+        ]
+        if mids:
+            freq_mid = Counter(mids)
+            l4l_hot_mids = {
+                n for n, _ in sorted(
+                    freq_mid.items(), key=lambda kv: kv[1], reverse=True
+                )[:6]
+            }
+
+    # Gimme 5 neighbor-chaser: identify recent hot core numbers (5–35)
+    g5_hot_core: set = set()
+    if cfg.name == "Gimme 5":
+        recent_g5 = df[cfg.main_cols].tail(25)
+        vals_g = recent_g5.values.flatten()
+        gnums = [int(v) for v in vals_g if not pd.isna(v)]
+        if gnums:
+            freq_g = Counter(gnums)
+            ordered = sorted(freq_g.items(), key=lambda kv: kv[1], reverse=True)
+            core_list: List[int] = []
+            for n, _ in ordered:
+                if 5 <= n <= 35:
+                    core_list.append(n)
+                if len(core_list) >= 6:
+                    break
+            g5_hot_core = set(core_list)
+
+    # Lotto America neighbor-chaser: identify recent hot core band numbers (15–45)
+    la_hot_core: set = set()
+    if cfg.name == "Lotto America":
+        recent_la = df[cfg.main_cols].tail(30)
+        vals_la = recent_la.values.flatten()
+        lans = [int(v) for v in vals_la if not pd.isna(v)]
+        if lans:
+            freq_la = Counter(lans)
+            ordered_la = sorted(
+                freq_la.items(), key=lambda kv: kv[1], reverse=True
+            )
+            core_la: List[int] = []
+            for n, _ in ordered_la:
+                if 15 <= n <= 45:
+                    core_la.append(n)
+                if len(core_la) >= 6:
+                    break
+            la_hot_core = set(core_la)
+
+    adjusted: Dict[int, float] = {}
+    for n, s in norm_scores.items():
+        m = 1.0
+        pos = (n - cfg.main_min) / span
+        in_low_zone = n <= low_cut
+
+        # Low-zone boost
+        if in_low_zone:
+            m *= 1.18  # low-zone probability boost
+
+        # Regime-specific tweaks
+        if regime == "high":
+            if s > 0.7:
+                m *= 0.92
+            elif s < 0.4:
+                m *= 1.08
+        elif regime == "low":
+            if s > 0.7:
+                m *= 1.05
+            elif s < 0.3:
+                m *= 0.90
+        else:
+            if s > 0.8:
+                m *= 0.97
+            elif s < 0.2:
+                m *= 1.03
+
+        # Trend inversion: favor reversal side a bit
+        if trend == "high_run":
+            if n <= mid:
+                m *= 1.10
+            else:
+                m *= 0.90
+        elif trend == "low_run":
+            if n >= mid:
+                m *= 1.10
+            else:
+                m *= 0.90
+
+        # Cold-burst factor
+        c = coldness.get(n, 0.5)
+        if regime == "high":
+            m *= (1.0 + 0.25 * c)
+        else:
+            m *= (1.0 + 0.15 * c)
+
+        # Mega Millions specific high-band refinements
+        if cfg.name == "Mega Millions":
+            # Boost 34–36 band
+            if 34 <= n <= 36:
+                m *= 1.06
+            # Boost 37–39 ridge
+            if 37 <= n <= 39:
+                m *= 1.05
+            # Soften extreme high cooling 65+ so 69-style hits are not suppressed
+            if n >= 65:
+                m *= 1.03
+
+        # Lotto America specific main-range tweaks (V5.3 ULTRA + neighbor-chaser)
+        if cfg.name == "Lotto America":
+            # Slight boost to mid-band 20–40
+            if 20 <= n <= 40:
+                m *= 1.04
+            # Mild damp on extreme ends to avoid overshooting
+            if n <= 5 or n >= 50:
+                m *= 0.96
+            # Tiny neighbor-chaser boost: ±1 around recent hot core numbers
+            if la_hot_core:
+                if (n - 1 in la_hot_core) or (n + 1 in la_hot_core):
+                    m *= 1.03
+
+        # Megabucks specific main-range tweaks (V5.3 ULTRA)
+        if cfg.name == "Megabucks":
+            # Slight boost to mid-band 18–32 (common MB hit zone)
+            if 18 <= n <= 32:
+                m *= 1.04
+            # Soft boost for upper range 35–41 so high numbers like 41 don't get over-cooled
+            if 35 <= n <= 41:
+                m *= 1.03
+            # Mild dampening on ultra-low extremes 1–3
+            if n <= 3:
+                m *= 0.96
+
+        # Powerball specific main-range tweaks (V5.3 ULTRA)
+        if cfg.name == "Powerball":
+            # Slight boost to core mid-band 20–45 (heavy PB activity zone)
+            if 20 <= n <= 45:
+                m *= 1.04
+            # Soft support for secondary band 10–19 and 46–59
+            if (10 <= n <= 19) or (46 <= n <= 59):
+                m *= 1.02
+            # Mild dampening on extreme ends 1–3 and 65–69
+            if n <= 3 or n >= 65:
+                m *= 0.96
+
+        # Lucky for Life specific main-range tweaks (V5.3 ULTRA, stronger + neighbor-chaser)
+        if cfg.name == "Lucky for Life":
+            # Stronger boost to core central band 14–36 where many hits cluster
+            if 14 <= n <= 36:
+                m *= 1.06
+            # Secondary soft support for broader mid band 11–38
+            if 11 <= n <= 38:
+                m *= 1.02
+            # Slightly stronger dampening on outer extremes 1–4 and 45–48
+            if n <= 4 or n >= 45:
+                m *= 0.95
+            # Tiny neighbor-chaser boost: ±1 around recent hot mids
+            if l4l_hot_mids:
+                if (n - 1 in l4l_hot_mids) or (n + 1 in l4l_hot_mids):
+                    m *= 1.03  # ~3% nudge, just enough to surface neighbors
+
+        # Gimme 5 neighbor-chaser with micro-boost: tiny nudge around recent hot core numbers
+        if cfg.name == "Gimme 5" and g5_hot_core:
+            if (n - 1 in g5_hot_core) or (n + 1 in g5_hot_core):
+                m *= 1.05  # micro-boosted neighbor effect
+
+        adjusted[n] = float(max(m * s, 0.0))
+
+    vals = np.array(list(adjusted.values()), dtype=float)
+    vmin, vmax = float(vals.min()), float(vals.max())
+    if vmax > vmin:
+        for n in adjusted.keys():
+            adjusted[n] = float((adjusted[n] - vmin) / (vmax - vmin))
+    else:
+        for n in adjusted.keys():
+            adjusted[n] = 0.5
+
+    return adjusted, regime_info, coldness
+
+
+def pick_star_ball(df: pd.DataFrame, cfg: GameConfig) -> Optional[int]:
+    """
+    V5.3.1 Mega / bonus ball picker.
+
+    Improvements over V5.2:
+    - Uses all-time + medium-term + short-term frequencies.
+    - Adds a cold-burst factor (prefer colder balls slightly).
+    - Favors low-zone bonus numbers a bit more (good for Mega Millions MB 1–12).
+    - Respects cfg.star_min / cfg.star_max for all games.
+    - Lotto America: extra boost for SB 1–5.
+    - Powerball: mild preference for PB 1–15.
+    - Lucky for Life: mild mid-band Lucky Ball tilt (7–15).
+    """
+    if not cfg.star_col:
+        return None
+
+    df = df.copy()
+    df[cfg.star_col] = pd.to_numeric(df[cfg.star_col], errors="coerce")
+    df = df.dropna(subset=[cfg.star_col])
+    if df.empty:
+        return None
+
+    series = df[cfg.star_col].astype(int)
+    freq_all = Counter(series)
+
+    recent_med = series.tail(40) if len(series) > 40 else series
+    freq_med = Counter(recent_med)
+
+    recent_short = series.tail(15) if len(series) > 15 else series
+    freq_short = Counter(recent_short)
+
+    # Build base weights from multiple horizons
+    weights: Dict[int, float] = {}
+    all_vals = []
+    for s in range(cfg.star_min, cfg.star_max + 1):
+        w = (
+            0.50 * freq_med.get(s, 0)
+            + 0.30 * freq_all.get(s, 0)
+            + 0.20 * freq_short.get(s, 0)
+        )
+        weights[s] = float(w)
+        all_vals.append(w)
+
+    # Avoid degenerate case
+    if not all_vals or max(all_vals) == 0:
+        return int(random.randint(cfg.star_min, cfg.star_max))
+
+    # Coldness (for cold-burst boosting)
+    vals = [freq_all.get(s, 0) for s in range(cfg.star_min, cfg.star_max + 1)]
+    f_min, f_max = min(vals), max(vals)
+    denom = max(f_max - f_min, 1)
+    coldness: Dict[int, float] = {}
+    for s in range(cfg.star_min, cfg.star_max + 1):
+        f = freq_all.get(s, 0)
+        cold = (f_max - f) / denom  # high when f is small
+        coldness[s] = float(np.clip(cold, 0.0, 1.0))
+
+    # Low-zone boost (e.g., MB 1–12)
+    span = cfg.star_max - cfg.star_min
+    low_cut = cfg.star_min + int(span * 0.5)  # bottom half considered "low zone"
+
+    adjusted: Dict[int, float] = {}
+    for s in range(cfg.star_min, cfg.star_max + 1):
+        base = weights.get(s, 0.0)
+        c = coldness.get(s, 0.5)
+        m = 1.0
+
+        # Low-zone preference
+        if s <= low_cut:
+            m *= 1.12  # +12% for low-zone stars
+
+        # Lotto America: extra preference for SB 1–5
+        if cfg.name == "Lotto America" and s <= 5:
+            m *= 1.08
+
+        # Powerball: mild preference for PB 1–15 zone
+        if cfg.name == "Powerball" and s <= 15:
+            m *= 1.05
+
+        # Lucky for Life: mid-band preference for Lucky Ball 7–15
+        if cfg.name == "Lucky for Life" and 7 <= s <= 15:
+            m *= 1.05
+
+        # Cold-burst
+        m *= (1.0 + 0.25 * c)  # up to +25% for very cold bonus balls
+
+        adjusted[s] = max(base * m, 0.0)
+
+    # Normalize to probabilities
+    stars = list(adjusted.keys())
+    wts = [adjusted[s] for s in stars]
+    total = float(sum(wts))
+    if total <= 0:
+        return int(random.randint(cfg.star_min, cfg.star_max))
+
+    probs = [w / total for w in wts]
+    choice = int(np.random.choice(stars, p=probs))
+    return choice
+
+
+# ============================================================
+# Last-4 repeater ban rule (your custom rule)
+# ============================================================
+
+def get_last4_repeater_ban(df: pd.DataFrame, cfg: GameConfig) -> set:
+    """
+    Your rule:
+    - Look at the most recent 4 draws.
+    - If a number appears in EACH of those 4 draws,
+      it is banned from prediction.
+    - We do NOT ban all numbers that just appeared once or twice.
+    """
+    if len(df) < 4:
+        return set()
+
+    last4 = df[cfg.main_cols].tail(4).values
+    cnt = Counter()
+    for row in last4:
+        unique_nums = {int(v) for v in row if not pd.isna(v)}
+        for n in unique_nums:
+            cnt[n] += 1
+
+    banned = {n for n, c in cnt.items() if c == 4}
+    return banned
+
+
+# ============================================================
+# GOD MODE V5.3 prediction (multi-style, including top_cluster)
+# ============================================================
+
+def generate_prediction_v4_god(  # name kept for compatibility
+    raw_df: pd.DataFrame,
+    cfg: GameConfig,
+) -> Dict[str, object]:
+    """
+    Main GOD MODE engine (V5.3.1 ULTRA behavior on top of V5.2).
+    - Builds multi-window ML models
+    - Computes multi-agent scores (including cluster/drift/parity)
+    - Applies last-4 repeater ban (your consecutive rule)
+    - Applies V5.3.1 corrections:
+        * regime detection (low/flat/high)
+        * low-zone boost
+        * inverse trend correction
+        * cold-burst correction
+        * anti-lock rule (prevent over-using same number across sets)
+        * coverage optimizer across the 5–6 styles
+    - Generates styled combos:
+        top_cluster, balanced, low_cluster, high_cluster, tight_cluster, wide_spread
+    """
+    df = _ensure_datetime(raw_df, cfg.csv_date_col)
+    if cfg.clean_func and cfg.clean_func in globals():
+        df = globals()[cfg.clean_func](df)
+
+    if len(df) < 40:
+        raise ValueError("Insufficient history (<40 draws) for GOD-MODE engine.")
+
+    df_long = _limit_history(df, 400)
+
+    # Core multi-window ML + agent scoring
+    ml_models = build_multiwindow_ml(df_long, cfg, windows=[20, 80, 400])
+    freq_features = create_frequency_features(df_long, cfg, windows=[20, 80, 400])
+    agent_scores = compute_agent_scores(df_long, cfg, ml_models, freq_features)
+
+    base_scores = combine_agent_scores(agent_scores, cfg)
+
+    # V5.3.1 correction layer (regime, low-zone, inverse trend, cold-burst)
+    final_scores, regime_info, coldness = _adjust_scores_v5_3(df_long, cfg, base_scores)
+
+    # Last-4 repeater ban (your rule)
+    banned_nums = get_last4_repeater_ban(df_long, cfg)
+
+    god_sets: List[Dict[str, object]] = []
+    usage_counts: Counter = Counter()  # track usage across all styles
+
+    def _make_style_scores(style_name: str, scores: Dict[int, float]) -> Dict[int, float]:
+        """
+        Per-style adjustment:
+        - Anti-lock rule (cap over-used numbers).
+        - Extra cold-burst compensation if a lock is happening.
+        - Micro-clustering: boost neighbors of strong numbers a bit.
+        """
+        adjusted_style: Dict[int, float] = {}
+        # Detect whether any number has been used twice already
+        max_used = max(usage_counts.values()) if usage_counts else 0
+        lock_phase = (max_used >= 2)
+
+        # Precompute which numbers are "strong" for micro-clustering
+        vals = np.array(list(scores.values()), dtype=float)
+        if vals.size == 0:
+            return scores
+        vmin, vmax = float(vals.min()), float(vals.max())
+        thresh = vmin + 0.75 * (vmax - vmin) if vmax > vmin else vmin
+        strong_numbers = {n for n, s in scores.items() if s >= thresh}
+
+        for n, s in scores.items():
+            m = 1.0
+            used = usage_counts.get(n, 0)
+
+            # Anti-lock across sets
+            if used >= 2:
+                m *= 0.25
+            elif used == 1:
+                m *= 0.65
+
+            # Extra cold compensation in lock phase
+            if lock_phase:
+                c = coldness.get(n, 0.5)
+                m *= (1.0 + 0.40 * c)
+
+            # Micro-clustering: if this number neighbors a strong number, give it a nudge
+            if (n - 1 in strong_numbers) or (n + 1 in strong_numbers):
+                m *= 1.08
+
+            adjusted_style[n] = max(m * s, 0.0)
+
+        # Normalize to [0,1]
+        vals = np.array(list(adjusted_style.values()), dtype=float)
+        if vals.size == 0:
+            return scores
+        vmin, vmax = float(vals.min()), float(vals.max())
+        if vmax > vmin:
+            for k in adjusted_style.keys():
+                adjusted_style[k] = float((adjusted_style[k] - vmin) / (vmax - vmin))
+        else:
+            for k in adjusted_style.keys():
+                adjusted_style[k] = 0.5
+
+        return adjusted_style
+
+    # 1) TOP-CLUSTER combo: force highest-score core together
+    top_combo, top_score = generate_top_cluster_combo(
+        df_long,
+        cfg,
+        final_scores,
+        banned_nums=banned_nums,
+        top_n_core=3,
+        n_candidates=3000,
+    )
+    top_star = pick_star_ball(df_long, cfg)
+    god_sets.append(
+        {
+            "style": "top_cluster",
+            "numbers": [int(x) for x in sorted(top_combo)],
+            "star": int(top_star) if top_star is not None else None,
+            "score": float(top_score),
+        }
+    )
+    usage_counts.update(int(x) for x in top_combo)
+
+    # 2) Other main styles
+    styles = [
+        "balanced",
+        "low_cluster",
+        "high_cluster",
+        "tight_cluster",
+        "wide_spread",
+    ]
+
+    for style in styles:
+        style_scores = _make_style_scores(style, final_scores)
+        combo, combo_score = generate_godmode_combo(
+            df_long,
+            cfg,
+            style_scores,
+            banned_nums=banned_nums,
+            n_candidates=4000,
+            style=style,
+        )
+        star = pick_star_ball(df_long, cfg)
+        god_sets.append(
+            {
+                "style": style,
+                "numbers": [int(x) for x in sorted(combo)],
+                "star": int(star) if star is not None else None,
+                "score": float(combo_score),
+            }
+        )
+        usage_counts.update(int(x) for x in combo)
+
+    # Coverage optimizer: adjust last 1–2 sets if coverage is weak
+    if len(god_sets) >= 4:
+        # Compute global coverage & high-score candidates
+        all_used = set()
+        for s in god_sets:
+            all_used.update(int(x) for x in s["numbers"])
+
+        # Target extra numbers: high-score but not yet used
+        sorted_nums = sorted(final_scores.items(), key=lambda kv: kv[1], reverse=True)
+        coverage_targets = [int(n) for n, sc in sorted_nums if int(n) not in all_used][:15]
+
+        def _rebuild_for_coverage(style_name: str, base_scores: Dict[int, float]) -> Tuple[List[int], float]:
+            coverage_scores: Dict[int, float] = {}
+            for n, s in base_scores.items():
+                m = 1.0
+                if n in coverage_targets:
+                    m *= 1.25  # strong push for uncovered high-score numbers
+                # small micro-cluster around coverage targets
+                if (n - 1 in coverage_targets) or (n + 1 in coverage_targets):
+                    m *= 1.08
+                coverage_scores[n] = max(m * s, 0.0)
+
+            vals = np.array(list(coverage_scores.values()), dtype=float)
+            if vals.size == 0:
+                coverage_scores = base_scores
+            else:
+                vmin, vmax = float(vals.min()), float(vals.max())
+                if vmax > vmin:
+                    for k in coverage_scores.keys():
+                        coverage_scores[k] = float((coverage_scores[k] - vmin) / (vmax - vmin))
+                else:
+                    coverage_scores[k] = 0.5
+
+            combo, score = generate_godmode_combo(
+                df_long,
+                cfg,
+                coverage_scores,
+                banned_nums=banned_nums,
+                n_candidates=4000,
+                style=style_name,
+            )
+            return [int(x) for x in sorted(combo)], float(score)
+
+        # Rebuild last 1–2 styles for better coverage (usually tight_cluster & wide_spread)
+        for idx in range(len(god_sets) - 2, len(god_sets)):
+            style_name = god_sets[idx]["style"]
+            if style_name in ("tight_cluster", "wide_spread", "high_cluster"):
+                new_nums, new_score = _rebuild_for_coverage(style_name, final_scores)
+                god_sets[idx]["numbers"] = new_nums
+                god_sets[idx]["score"] = new_score
+
+    # Select primary combo: prefer balanced, else fall back to top_cluster
+    primary = next((s for s in god_sets if s["style"] == "balanced"), god_sets[0])
+
+    sorted_nums = sorted(final_scores.items(), key=lambda kv: kv[1], reverse=True)
+    top_explain = sorted_nums[:10]
+
+    explanation = {
+        "top_numbers": [
+            {"num": int(n), "score": float(round(s, 4))} for n, s in top_explain
+        ],
+        "banned_last4_repeater": sorted(int(x) for x in banned_nums),
+        "regime": regime_info,
+        "usage_counts": {int(k): int(v) for k, v in usage_counts.items()},
+    }
+
+    model_info = {
+        "numbers_modeled": len(ml_models),
+        "total_possible": cfg.main_max - cfg.main_min + 1,
+    }
+
+    result = {
+        "game": cfg.name,
+        "numbers": primary["numbers"],
+        "star": primary["star"],
+        "meta": {
+            "numbers_scored": len(final_scores),
+            "history_used": len(df_long),
+            "styles": [s["style"] for s in god_sets],
+        },
+        "godmode_sets": god_sets,
+        "explanation": explanation,
+        "model_info": model_info,
+    }
+    return result
+
+
+# ============================================================
+# Backtesting
+# ============================================================
+
+def enhanced_backtest(
+    df: pd.DataFrame,
+    cfg: GameConfig,
+    n_tests: int = 200,
+) -> Dict[str, float]:
+    df = _ensure_datetime(df, cfg.csv_date_col)
+    if cfg.clean_func and cfg.clean_func in globals():
+        df = globals()[cfg.clean_func](df)
+
+    if len(df) < 80:
+        return {"error": "Insufficient data for backtest (need >80 draws)"}
+
+    total_tests = min(n_tests, len(df) - 60)
+    print(f"[BACKTEST] {cfg.name}: running {total_tests} tests...")
+
+    stats = {
+        "hit_0": 0,
+        "hit_1": 0,
+        "hit_2": 0,
+        "hit_3": 0,
+        "hit_4": 0,
+        "hit_5": 0,
+        "rnd_0": 0,
+        "rnd_1": 0,
+        "rnd_2": 0,
+        "rnd_3": 0,
+        "rnd_4": 0,
+        "rnd_5": 0,
+        "sum_errors": [],
+        "even_match": 0,
+    }
+
+    for idx in range(60, 60 + total_tests):
+        if (idx - 59) % 30 == 0:
+            print(f"  progress: {idx - 59}/{total_tests}")
+
+        train_df = df.iloc[:idx].copy()
+        actual_row = df.iloc[idx]
+        actual_nums = sorted(int(x) for x in actual_row[cfg.main_cols].values)
+
+        try:
+            pred = generate_prediction_v4_god(train_df, cfg)
+            pred_nums = sorted(pred["numbers"])
+        except Exception:
+            pred_nums = sorted(
+                random.sample(
+                    range(cfg.main_min, cfg.main_max + 1),
+                    len(cfg.main_cols),
+                )
+            )
+
+        hits = len(set(pred_nums) & set(actual_nums))
+        stats[f"hit_{hits}"] += 1
+
+        rnd_nums = sorted(
+            random.sample(
+                range(cfg.main_min, cfg.main_max + 1),
+                len(cfg.main_cols),
+            )
+        )
+        rnd_hits = len(set(rnd_nums) & set(actual_nums))
+        stats[f"rnd_{rnd_hits}"] += 1
+
+        stats["sum_errors"].append(abs(sum(pred_nums) - sum(actual_nums)))
+        if sum(v % 2 == 0 for v in pred_nums) == sum(
+            v % 2 == 0 for v in actual_nums
+        ):
+            stats["even_match"] += 1
+
+    out: Dict[str, float] = {}
+    for i in range(6):
+        out[f"model_hit_{i}_rate"] = round(
+            stats[f"hit_{i}"] / max(total_tests, 1) * 100.0, 2
+        )
+        out[f"random_hit_{i}_rate"] = round(
+            stats[f"rnd_{i}"] / max(total_tests, 1) * 100.0, 2
+        )
+
+    out["avg_sum_error"] = round(float(np.mean(stats["sum_errors"])), 2)
+    out["even_count_accuracy"] = round(
+        stats["even_match"] / max(total_tests, 1) * 100.0, 2
+    )
+    out["model_3plus_rate"] = round(
+        sum(stats[f"hit_{i}"] for i in range(3, 6)) / max(total_tests, 1) * 100.0, 2
+    )
+    out["random_3plus_rate"] = round(
+        sum(stats[f"rnd_{i}"] for i in range(3, 6)) / max(total_tests, 1) * 100.0, 2
+    )
+    return out
+
+
+# ============================================================
+# CSV loading + public API
+# ============================================================
+
+def load_csv_for_game(csv_path: Path, game_key: str) -> Tuple[pd.DataFrame, GameConfig]:
+    cfg = GAME_CONFIGS[game_key]
+    df = pd.read_csv(csv_path)
+
+    # Basic main number cleaning
+    for col in cfg.main_cols:
+        if col not in df.columns:
+            raise ValueError(f"Expected column '{col}' in CSV for {cfg.name}")
+        df[col] = pd.to_numeric(df[col], errors="coerce")
+        mask_bad = (df[col].isna()) | (df[col] < cfg.main_min) | (df[col] > cfg.main_max)
+        if mask_bad.any():
+            df = df[~mask_bad]
+
+    # Bonus/Star cleaning
+    if cfg.star_col and cfg.star_col in df.columns:
+        df[cfg.star_col] = pd.to_numeric(df[cfg.star_col], errors="coerce")
+
+        # Mega Millions legacy Megaball patch:
+        # Before April 2025 many CSVs still have MB 1–25.
+        # We remap any values > star_max back into 1–star_max cyclically,
+        # so old draws are kept but MB is always in 1–24.
+        if cfg.name == "Mega Millions":
+            legacy_mask = df[cfg.star_col] > cfg.star_max
+            if legacy_mask.any():
+                df.loc[legacy_mask, cfg.star_col] = (
+                    (df.loc[legacy_mask, cfg.star_col] - 1) % cfg.star_max
+                ) + 1
+
+        mask_bad_star = (
+            df[cfg.star_col].isna()
+            | (df[cfg.star_col] < cfg.star_min)
+            | (df[cfg.star_col] > cfg.star_max)
+        )
+        if mask_bad_star.any():
+            df = df[~mask_bad_star]
+
+    if cfg.csv_date_col not in df.columns:
+        raise ValueError(f"Expected date column '{cfg.csv_date_col}' in CSV for {cfg.name}")
+
+    df[cfg.csv_date_col] = pd.to_datetime(df[cfg.csv_date_col], errors="coerce")
+    df = df.dropna(subset=[cfg.csv_date_col])
+    df = df.sort_values(cfg.csv_date_col).reset_index(drop=True)
+
+    if cfg.clean_func and cfg.clean_func in globals():
+        df = globals()[cfg.clean_func](df)
+
+    return df, cfg
+
+
+def predict_for_game_v3(
+    csv_path: Path,
+    game_key: str,
+    run_backtest: bool = False,
+) -> Dict[str, object]:
+    """
+    Public API (same name/signature as earlier versions).
+    If run_backtest=True -> run enhanced_backtest.
+    Else -> run GOD-MODE prediction (V5.3 ULTRA).
+    """
+    df, cfg = load_csv_for_game(Path(csv_path), game_key)
+    if run_backtest:
+        return enhanced_backtest(df, cfg)
+    return generate_prediction_v4_god(df, cfg)
+
+
+def predict_for_game(
+    csv_path: Path,
+    game_key: str,
+    run_backtest: bool = False,
+):
+    """
+    Backwards-compatible wrapper for older code that imports `predict_for_game`.
+    """
+    return predict_for_game_v3(csv_path=Path(csv_path), game_key=game_key, run_backtest=run_backtest)
+
+
+# ============================================================
+# Wheel generation + hot/cold analysis
+# ============================================================
+
+def generate_wheel_numbers(raw_df: pd.DataFrame, cfg: GameConfig) -> Dict[str, object]:
+    """
+    Generate a 20-number wheel using frequency, recency, and multi-agent ranking.
+    """
+    df = _ensure_datetime(raw_df, cfg.csv_date_col)
+    if cfg.clean_func and cfg.clean_func in globals():
+        df = globals()[cfg.clean_func](df)
+
+    if len(df) < 40:
+        return {"error": "Insufficient history (<40) for wheel generation"}
+
+    df_long = _limit_history(df, 400)
+
+    ml_models = build_multiwindow_ml(df_long, cfg, windows=[20, 80, 400])
+    freq_features = create_frequency_features(df_long, cfg, windows=[20, 80, 400])
+    agent_scores = compute_agent_scores(df_long, cfg, ml_models, freq_features)
+    final_scores = combine_agent_scores(agent_scores, cfg)
+
+    banned = get_last4_repeater_ban(df_long, cfg)
+    wheel_pool = {n: s for n, s in final_scores.items() if n not in banned}
+    if len(wheel_pool) < 20:
+        wheel_pool = final_scores.copy()
+
+    sorted_nums = sorted(wheel_pool.items(), key=lambda x: x[1], reverse=True)
+    wheel_nums = [n for n, _ in sorted_nums[:20]]
+
+    freq_all = Counter(df_long[cfg.main_cols].values.flatten())
+    hot = [n for n, _ in freq_all.most_common(10)]
+    cold = [n for n, _ in freq_all.most_common()[-10:]]
+
+    return {
+        "wheel_numbers": wheel_nums,
+        "hot_count": len(set(wheel_nums) & set(hot)),
+        "cold_count": len(set(wheel_nums) & set(cold)),
+        "warm_count": len(wheel_nums) - len(set(wheel_nums) & set(hot)) - len(set(wheel_nums) & set(cold)),
+        "banned_last4_repeater": sorted(banned),
+        "hot_cold_analysis": {
+            "hot": hot,
+            "cold": cold,
+        },
+    }
+
+
+def get_wheel_for_game(csv_path: Path, game_key: str) -> Dict[str, object]:
+    df, cfg = load_csv_for_game(Path(csv_path), game_key)
+    return generate_wheel_numbers(df, cfg)
+
+
+def get_hot_cold_analysis(
+    csv_path: Path,
+    game_key: str,
+    top_n: int = 10,
+) -> Dict[str, object]:
+    """
+    Helper for app/engine: top-N hottest and coldest numbers for the given game,
+    plus full frequency table.
+    """
+    df, cfg = load_csv_for_game(Path(csv_path), game_key)
+
+    all_nums = []
+    for col in cfg.main_cols:
+        all_nums.extend(df[col].tolist())
+    all_nums = [int(x) for x in all_nums if not pd.isna(x)]
+
+    freq = Counter(all_nums)
+    sorted_freq = sorted(freq.items(), key=lambda kv: kv[1], reverse=True)
+    hot = [n for n, _ in sorted_freq[:top_n]]
+    cold = [n for n, _ in sorted(freq.items(), key=lambda kv: kv[1])[:top_n]]
+
+    return {
+        "hot": hot,
+        "cold": cold,
+        "frequency": {int(n): int(c) for n, c in freq.items()},
+    }
+
+
+def load_and_prepare_data(csv_path: Path, game_key: str) -> Tuple[pd.DataFrame, GameConfig]:
+    """
+    Backwards-compatible wrapper for older engine code.
+    Loads CSV, cleans & validates it, and returns (DataFrame, GameConfig).
+    """
+    csv_path = Path(csv_path)
+    df, cfg = load_csv_for_game(csv_path, game_key)
+    return df, cfg
+
+
+# ============================================================
+# CLI (pretty output)
+# ============================================================
+
+if __name__ == "__main__":
+    import argparse
+    import os
+
+    parser = argparse.ArgumentParser(
+        description="Lotto Predictor V5.3 ULTRA GOD MODE (multi-agent, multi-window, cluster-aware, top_cluster style)"
+    )
+    parser.add_argument(
+        "--game",
+        required=True,
+        choices=list(GAME_CONFIGS.keys()),
+        help="Game key: " + ", ".join(GAME_CONFIGS.keys()),
+    )
+    parser.add_argument("--csv", required=True, help="Path to CSV for the game")
+    parser.add_argument(
+        "--backtest",
+        action="store_true",
+        help="Run backtest instead of prediction",
+    )
+    parser.add_argument(
+        "--save-json",
+        action="store_true",
+        help="Also save full JSON result to godmode_last_result_<game>.json",
+    )
+    args = parser.parse_args()
+
+    result = predict_for_game_v3(
+        csv_path=Path(args.csv),
+        game_key=args.game,
+        run_backtest=args.backtest,
+    )
+
+    # -------------------------------
+    # Backtest mode: pretty summary
+    # -------------------------------
+    if args.backtest:
+        if "error" in result:
+            print(f"\n[BACKTEST ERROR] {result['error']}")
+        else:
+            print("\n==============================================")
+            print(f"  BACKTEST RESULTS - {GAME_CONFIGS[args.game].name}")
+            print("==============================================\n")
+
+            print(f"  Model 3+ hits rate : {result.get('model_3plus_rate', 0)} %")
+            print(f"  Random 3+ hits rate: {result.get('random_3plus_rate', 0)} %")
+            print(f"  Avg sum error      : {result.get('avg_sum_error', 0)}")
+            print(f"  Even-count accuracy: {result.get('even_count_accuracy', 0)} %")
+            print("\n  Hit-rate table (Model vs Random):")
+            print("    Matches |  Model %   | Random %")
+            print("   ---------+-----------+----------")
+            for i in range(6):
+                m = result.get(f"model_hit_{i}_rate", 0)
+                r = result.get(f"random_hit_{i}_rate", 0)
+                print(f"      {i:1d}     | {m:7.2f} % | {r:7.2f} %")
+            print("\n==============================================\n")
+    else:
+        # -------------------------------
+        # Prediction mode: nice compact view
+        # -------------------------------
+        game_name = result.get("game", GAME_CONFIGS[args.game].name)
+        numbers = result.get("numbers", [])
+        star = result.get("star", None)
+        meta = result.get("meta", {})
+        god_sets = result.get("godmode_sets", [])
+        expl = result.get("explanation", {})
+        top_nums = expl.get("top_numbers", [])
+        banned = expl.get("banned_last4_repeater", [])
+        model_info = result.get("model_info", {})
+
+        print("\n==============================================")
+        print(f"   V5.3 ULTRA GOD MODE RESULT - {game_name}")
+        print("==============================================\n")
+
+        # Primary combo
+        nums_str = "-".join(str(n) for n in numbers)
+        if star is not None:
+            print(f"  PRIMARY PICK : {nums_str}  (Star: {star})")
+        else:
+            print(f"  PRIMARY PICK : {nums_str}")
+        print()
+
+        # Multi-style sets
+        if god_sets:
+            print("  GOD MODE SETS (multi-style):\n")
+            for i, s in enumerate(god_sets, start=1):
+                s_nums = "-".join(str(n) for n in s.get("numbers", []))
+                s_style = s.get("style", "unknown").replace("_", " ").title()
+                s_star = s.get("star", None)
+                if s_star is not None:
+                    print(f"    {i}) {s_style:<12} -> {s_nums}  (Star: {s_star})")
+                else:
+                    print(f"    {i}) {s_style:<12} -> {s_nums}")
+            print()
+
+        # Top-10 favorite numbers
+        if top_nums:
+            fav_str = ", ".join(f"{t['num']} ({t['score']:.3f})" for t in top_nums)
+            just_nums = ", ".join(str(t["num"]) for t in top_nums)
+            print("  TOP 10 FAVORITE NUMBERS (by score):")
+            print(f"    Numbers: {just_nums}")
+            print(f"    Detail : {fav_str}")
+            print()
+
+        # Banned last-4 repeaters
+        if banned:
+            print("  BANNED (4-in-a-row repeaters):")
+            print(f"    {', '.join(str(b) for b in banned)}")
+            print()
+        else:
+            print("  BANNED (4-in-a-row repeaters): none")
+            print()
+
+        # Meta / model info
+        print(f"  Numbers scored   : {meta.get('numbers_scored', 'N/A')}")
+        print(f"  History used     : {meta.get('history_used', 'N/A')} draws")
+        print(
+            f"  ML coverage      : {model_info.get('numbers_modeled', 0)}/"
+            f"{model_info.get('total_possible', 0)} numbers"
+        )
+        if meta.get("styles"):
+            print(f"  Styles evaluated : {', '.join(meta['styles'])}")
+        print("\n==============================================\n")
+
+    # Optional: save full JSON snapshot for debugging / records
+    if args.save_json:
+        out_name = f"godmode_last_result_{args.game}.json"
+        try:
+            with open(out_name, "w", encoding="utf-8") as f:
+                json.dump(result, f, indent=2, cls=NumpyEncoder)
+            print(f"[INFO] Full JSON result saved to: {os.path.abspath(out_name)}")
+        except Exception as e:
+            print(f"[WARN] Could not save JSON result: {e}")

mb_predictor.py

@@ -0,0 +1,84 @@
+# import json
+# from pathlib import Path
+# from lotto_predictor import predict_for_game, NumpyEncoder
+
+# def main():
+#     csv_path = Path("mb_results.csv")
+#     try:
+#         # Run prediction
+#         print("Generating prediction...")
+#         res = predict_for_game(csv_path, "mb", allow_sequences=True, include_wheel=False, wheel_template_path=Path("wheel.txt"), run_backtest=False)
+#         print("Prediction:")
+#         print(json.dumps(res, indent=2, cls=NumpyEncoder))
+#     except Exception as e:
+#         print(f"Prediction failed: {str(e)}")
+    
+#     try:
+#         # Run backtest
+#         print("Starting backtest...")
+#         backtest_res = predict_for_game(csv_path, "mb", allow_sequences=True, include_wheel=False, wheel_template_path=Path("wheel.txt"), run_backtest=True)
+#         print("Backtest Results:")
+#         print(json.dumps(backtest_res, indent=2, cls=NumpyEncoder))
+#     except Exception as e:
+#         print(f"Backtest failed: {str(e)}")
+
+# if __name__ == "__main__":
+#     main()
+
+
+import json
+from pathlib import Path
+from lotto_predictor import predict_for_game_v3, NumpyEncoder
+
+def main():
+    csv_path = Path("mb_results.csv")
+    
+    try:
+        # Run prediction
+        print("Generating prediction...")
+        res = predict_for_game_v3(csv_path, "mb", run_backtest=False)
+        print("Prediction:")
+        print(json.dumps(res, indent=2, cls=NumpyEncoder))
+        print(f"\nPredicted Numbers: {res['numbers']}")
+        if res.get('star'):
+            print(f"Star Ball: {res['star']}")
+        
+        # Print model info
+        model_info = res.get('model_info', {})
+        print(f"\nModel built for {model_info.get('numbers_modeled', 0)} out of {model_info.get('total_possible', 0)} numbers")
+        
+    except Exception as e:
+        print(f"Prediction failed: {str(e)}")
+        import traceback
+        traceback.print_exc()
+    
+    # try:
+    #     # Run backtest
+    #     print("\n" + "="*50)
+    #     print("Starting backtest...")
+    #     backtest_res = predict_for_game_v3(csv_path, "mb", run_backtest=True)
+    #     print("\nBacktest Results:")
+    #     print(json.dumps(backtest_res, indent=2, cls=NumpyEncoder))
+        
+    #     # Print summary
+    #     if 'error' not in backtest_res:
+    #         print(f"\nBacktest Summary:")
+    #         print(f"Model 3+ matches: {backtest_res.get('model_3plus_rate', 0)}%")
+    #         print(f"Random 3+ matches: {backtest_res.get('random_3plus_rate', 0)}%")
+    #         print(f"Average sum error: {backtest_res.get('avg_sum_error', 0)}")
+    #         print(f"Even count accuracy: {backtest_res.get('even_count_accuracy', 0)}%")
+            
+    #         # Show hit rates comparison
+    #         print("\nHit Rate Comparison:")
+    #         for i in range(6):
+    #             model_rate = backtest_res.get(f'model_hit_{i}_rate', 0)
+    #             random_rate = backtest_res.get(f'random_hit_{i}_rate', 0)
+    #             print(f"{i} matches: Model {model_rate}% vs Random {random_rate}%")
+        
+    # except Exception as e:
+    #     print(f"Backtest failed: {str(e)}")
+    #     import traceback
+    #     traceback.print_exc()
+
+if __name__ == "__main__":
+    main()

mm_predictor.py

@@ -0,0 +1,85 @@
+# import json
+# from pathlib import Path
+# from lotto_predictor import predict_for_game, NumpyEncoder
+
+# def main():
+#     csv_path = Path("mm_results.csv")
+#     try:
+#         # Run prediction
+#         print("Generating prediction...")
+#         res = predict_for_game(csv_path, "mm", allow_sequences=True, include_wheel=False, wheel_template_path=Path("wheel.txt"), run_backtest=False)
+#         print("Prediction:")
+#         print(json.dumps(res, indent=2, cls=NumpyEncoder))
+#     except Exception as e:
+#         print(f"Prediction failed: {str(e)}")
+    
+#     try:
+#         # Run backtest
+#         print("Starting backtest...")
+#         backtest_res = predict_for_game(csv_path, "mm", allow_sequences=True, include_wheel=False, wheel_template_path=Path("wheel.txt"), run_backtest=True)
+#         print("Backtest Results:")
+#         print(json.dumps(backtest_res, indent=2, cls=NumpyEncoder))
+#     except Exception as e:
+#         print(f"Backtest failed: {str(e)}")
+
+# if __name__ == "__main__":
+#     main()
+
+
+
+import json
+from pathlib import Path
+from lotto_predictor import predict_for_game_v3, NumpyEncoder
+
+def main():
+    csv_path = Path("mm_results.csv")
+    
+    try:
+        # Run prediction
+        print("Generating prediction...")
+        res = predict_for_game_v3(csv_path, "mm", run_backtest=False)
+        print("Prediction:")
+        print(json.dumps(res, indent=2, cls=NumpyEncoder))
+        print(f"\nPredicted Numbers: {res['numbers']}")
+        if res.get('star'):
+            print(f"Star Ball: {res['star']}")
+        
+        # Print model info
+        model_info = res.get('model_info', {})
+        print(f"\nModel built for {model_info.get('numbers_modeled', 0)} out of {model_info.get('total_possible', 0)} numbers")
+        
+    except Exception as e:
+        print(f"Prediction failed: {str(e)}")
+        import traceback
+        traceback.print_exc()
+    
+    # try:
+    #     # Run backtest
+    #     print("\n" + "="*50)
+    #     print("Starting backtest...")
+    #     backtest_res = predict_for_game_v3(csv_path, "mm", run_backtest=True)
+    #     print("\nBacktest Results:")
+    #     print(json.dumps(backtest_res, indent=2, cls=NumpyEncoder))
+        
+    #     # Print summary
+    #     if 'error' not in backtest_res:
+    #         print(f"\nBacktest Summary:")
+    #         print(f"Model 3+ matches: {backtest_res.get('model_3plus_rate', 0)}%")
+    #         print(f"Random 3+ matches: {backtest_res.get('random_3plus_rate', 0)}%")
+    #         print(f"Average sum error: {backtest_res.get('avg_sum_error', 0)}")
+    #         print(f"Even count accuracy: {backtest_res.get('even_count_accuracy', 0)}%")
+            
+    #         # Show hit rates comparison
+    #         print("\nHit Rate Comparison:")
+    #         for i in range(6):
+    #             model_rate = backtest_res.get(f'model_hit_{i}_rate', 0)
+    #             random_rate = backtest_res.get(f'random_hit_{i}_rate', 0)
+    #             print(f"{i} matches: Model {model_rate}% vs Random {random_rate}%")
+        
+    # except Exception as e:
+    #     print(f"Backtest failed: {str(e)}")
+    #     import traceback
+    #     traceback.print_exc()
+
+if __name__ == "__main__":
+    main()

pb_predictor.py

@@ -0,0 +1,84 @@
+# import json
+# from pathlib import Path
+# from lotto_predictor import predict_for_game, NumpyEncoder
+
+# def main():
+#     csv_path = Path("pb_results.csv")
+#     try:
+#         # Run prediction
+#         print("Generating prediction...")
+#         res = predict_for_game(csv_path, "pb", allow_sequences=True, include_wheel=False, wheel_template_path=Path("wheel.txt"), run_backtest=False)
+#         print("Prediction:")
+#         print(json.dumps(res, indent=2, cls=NumpyEncoder))
+#     except Exception as e:
+#         print(f"Prediction failed: {str(e)}")
+    
+#     try:
+#         # Run backtest
+#         print("Starting backtest...")
+#         backtest_res = predict_for_game(csv_path, "pb", allow_sequences=True, include_wheel=False, wheel_template_path=Path("wheel.txt"), run_backtest=True)
+#         print("Backtest Results:")
+#         print(json.dumps(backtest_res, indent=2, cls=NumpyEncoder))
+#     except Exception as e:
+#         print(f"Backtest failed: {str(e)}")
+
+# if __name__ == "__main__":
+#     main()
+
+
+import json
+from pathlib import Path
+from lotto_predictor import predict_for_game_v3, NumpyEncoder
+
+def main():
+    csv_path = Path("pb_results.csv")
+    
+    try:
+        # Run prediction
+        print("Generating prediction...")
+        res = predict_for_game_v3(csv_path, "pb", run_backtest=False)
+        print("Prediction:")
+        print(json.dumps(res, indent=2, cls=NumpyEncoder))
+        print(f"\nPredicted Numbers: {res['numbers']}")
+        if res.get('star'):
+            print(f"Star Ball: {res['star']}")
+        
+        # Print model info
+        model_info = res.get('model_info', {})
+        print(f"\nModel built for {model_info.get('numbers_modeled', 0)} out of {model_info.get('total_possible', 0)} numbers")
+        
+    except Exception as e:
+        print(f"Prediction failed: {str(e)}")
+        import traceback
+        traceback.print_exc()
+    
+    # try:
+    #     # Run backtest
+    #     print("\n" + "="*50)
+    #     print("Starting backtest...")
+    #     backtest_res = predict_for_game_v3(csv_path, "pb", run_backtest=True)
+    #     print("\nBacktest Results:")
+    #     print(json.dumps(backtest_res, indent=2, cls=NumpyEncoder))
+        
+    #     # Print summary
+    #     if 'error' not in backtest_res:
+    #         print(f"\nBacktest Summary:")
+    #         print(f"Model 3+ matches: {backtest_res.get('model_3plus_rate', 0)}%")
+    #         print(f"Random 3+ matches: {backtest_res.get('random_3plus_rate', 0)}%")
+    #         print(f"Average sum error: {backtest_res.get('avg_sum_error', 0)}")
+    #         print(f"Even count accuracy: {backtest_res.get('even_count_accuracy', 0)}%")
+            
+    #         # Show hit rates comparison
+    #         print("\nHit Rate Comparison:")
+    #         for i in range(6):
+    #             model_rate = backtest_res.get(f'model_hit_{i}_rate', 0)
+    #             random_rate = backtest_res.get(f'random_hit_{i}_rate', 0)
+    #             print(f"{i} matches: Model {model_rate}% vs Random {random_rate}%")
+        
+    # except Exception as e:
+    #     print(f"Backtest failed: {str(e)}")
+    #     import traceback
+    #     traceback.print_exc()
+
+if __name__ == "__main__":
+    main()

predictor_common.py

@@ -0,0 +1,67 @@
+#!/usr/bin/env python3
+from __future__ import annotations
+import json, random
+from datetime import datetime
+from pathlib import Path
+from typing import Any, Dict, Optional
+import numpy as np
+
+def set_reproducible_seeds(seed: int = 42) -> None:
+    random.seed(seed)
+    np.random.seed(seed)
+
+def configure_engine_flags(engine_mod, *, deep_low=True, tight_relax=True, mid_carry=True, wildcard=True):
+    flags = {
+        "deep_low_patch": bool(deep_low),
+        "tight_relax_patch": bool(tight_relax),
+        "mid_carry_patch": bool(mid_carry),
+        "wildcard_strike": bool(wildcard),
+    }
+    if hasattr(engine_mod, "PATCH_UI_FLAGS") and isinstance(getattr(engine_mod, "PATCH_UI_FLAGS"), dict):
+        engine_mod.PATCH_UI_FLAGS.update(flags)
+
+def summarize_result(game_key: str, res: Dict[str, Any]) -> str:
+    lines = [f"GAME: {game_key}", f"GENERATED: {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}", ""]
+    nums = res.get("numbers") or []
+    star = res.get("star", None)
+    if nums:
+        lines.append(f"PRIMARY: {'-'.join(map(str, nums))}" + (f" | ⭐ {star}" if star is not None else ""))
+        lines.append("")
+    god_sets = res.get("god_sets") or res.get("godmode_sets") or res.get("god_mode_sets") or []
+    if god_sets:
+        lines.append("GOD MODE SETS:")
+        for s in god_sets:
+            sn = s.get("numbers") or []
+            ss = s.get("star", None)
+            if sn:
+                lines.append(f"- {s.get('style','set')}: {'-'.join(map(str, sn))}" + (f" | ⭐ {ss}" if ss is not None else ""))
+        lines.append("")
+    strike = res.get("strike_tickets") or {}
+    if strike:
+        lines.append("STRIKE TICKETS:")
+        for k, v in strike.items():
+            sn = (v or {}).get("numbers") or []
+            ss = (v or {}).get("star", None)
+            if sn:
+                lines.append(f"- {k}: {'-'.join(map(str, sn))}" + (f" | ⭐ {ss}" if ss is not None else ""))
+        lines.append("")
+    wc = res.get("wildcard")
+    if wc:
+        sn = (wc or {}).get("numbers") or []
+        ss = (wc or {}).get("star", None)
+        if sn:
+            lines.append(f"WILDCARD PROFILE: {'-'.join(map(str, sn))}" + (f" | ⭐ {ss}" if ss is not None else ""))
+    return "\n".join(lines)
+
+def run_prediction(engine_mod, csv_filename: str, game_key: str, *, seed: int,
+                   deep_low=True, tight_relax=True, mid_carry=True, wildcard=True,
+                   out_dir: Optional[str] = None) -> Dict[str, Any]:
+    set_reproducible_seeds(seed)
+    configure_engine_flags(engine_mod, deep_low=deep_low, tight_relax=tight_relax, mid_carry=mid_carry, wildcard=wildcard)
+    res = engine_mod.predict_for_game_v3(Path(csv_filename), game_key, run_backtest=False)
+    outp = Path(out_dir or ".")
+    outp.mkdir(parents=True, exist_ok=True)
+    ts = datetime.now().strftime("%Y-%m-%d_%H-%M-%S")
+    base = f"{game_key}_godmode_{ts}"
+    (outp / f"{base}.txt").write_text(summarize_result(game_key, res), encoding="utf-8")
+    return res