Update app.py

app.py

@@ -1,13 +1,25 @@
 """
-main.py — Gradio interface orchestrating the full analysis pipeline.
-
-Changes vs prior version:
-- regime_data["atr_series"] passed into analyze_volume for consistent ATR
-- Consecutive loss state tracked per-session via gr.State
-- Equity drawdown guard plumbed into risk_engine
-- Direction inference: long only when bullish/ranging, short when bearish
-- Output shows absorption, failed breakout, ADX, compression state
-- Quality tier displayed alongside scores
+main.py — Gradio interface with integrated ML probability filter.
+
+Pipeline:
+    OHLCV Data
+        │
+        ▼
+    Rule Engine (regime + volume + scoring + veto)
+        │
+        ├─► Vetoed → skip (no ML call, save compute)
+        │
+        └─► Approved by rules
+                │
+                ▼
+            ML Filter (LightGBM / HGBM probability)
+                │
+                ├─► prob < threshold → FILTERED (shown as ML_REJECT)
+                │
+                └─► prob >= threshold → Risk Engine → Final setup
+                            │
+                            ▼
+                        Ranked output with ML prob overlay
 """
 
 import logging
@@ -30,6 +42,8 @@ from volume_analysis import analyze_volume
 from risk_engine import evaluate_risk
 from veto import apply_veto, veto_summary
 from scorer import compute_structure_score, score_token, rank_tokens, format_score_bar, quality_tier
+from feature_builder import build_feature_dict, validate_features
+from ml_filter import TradeFilter
 
 logging.basicConfig(
     level=logging.INFO,
@@ -38,9 +52,12 @@ logging.basicConfig(
 )
 logger = logging.getLogger("main")
 
-_TREND_ICON = {"bullish": "▲", "ranging": "◆", "bearish": "▼"}
-_BREAKOUT_LABEL = {1: "↑ UP", -1: "↓ DN", 0: " — "}
-_DIR_LABEL = {1: "LONG", -1: "SHORT", 0: "NONE"}
+# Load ML filter once at startup (None if not yet trained)
+_TRADE_FILTER: Optional[TradeFilter] = TradeFilter.load_or_none()
+
+_TREND_ICON  = {"bullish": "▲", "ranging": "◆", "bearish": "▼"}
+_BREAK_LABEL = {1: "↑UP", -1: "↓DN", 0: " — "}
+_DIR_LABEL   = {1: "LONG", -1: "SHORT", 0: "NONE"}
 
 
 def infer_direction(trend: str, breakout: int) -> int:
@@ -57,16 +74,42 @@ def analyze_single(
     account_equity: float,
     consec_losses: int = 0,
     equity_drawdown_pct: float = 0.0,
+    use_ml: bool = True,
 ) -> Dict[str, Any]:
-    regime_data = detect_regime(df)
-    # Pass consistent ATR series from regime into volume analysis
-    volume_data = analyze_volume(df, atr_series=regime_data["atr_series"])
-    structure_score = compute_structure_score(regime_data)
-
-    direction = infer_direction(regime_data["trend"], volume_data["breakout"])
-    vetoed, veto_reason = apply_veto(regime_data, volume_data, structure_score, direction=direction)
+    # ── RULE ENGINE ───────────────────────────────────────────────────────────
+    regime_data  = detect_regime(df)
+    volume_data  = analyze_volume(df, atr_series=regime_data["atr_series"])
+    structure_sc = compute_structure_score(regime_data)
+    direction    = infer_direction(regime_data["trend"], volume_data["breakout"])
+    vetoed, veto_reason = apply_veto(regime_data, volume_data, structure_sc, direction=direction)
     scores = score_token(regime_data, volume_data, vetoed)
 
+    # ── ML FILTER ─────────────────────────────────────────────────────────────
+    ml_prob       = None
+    ml_approved   = None
+    ml_reject_reason = ""
+
+    if use_ml and _TRADE_FILTER is not None and not vetoed:
+        try:
+            feat = build_feature_dict(regime_data, volume_data, scores)
+            if validate_features(feat):
+                result = _TRADE_FILTER.predict(regime_data, volume_data, scores)
+                ml_prob     = result.probability
+                ml_approved = result.approved
+                ml_reject_reason = result.reject_reason
+            else:
+                ml_approved = None  # pass through if features invalid
+        except Exception as e:
+            logger.warning(f"{symbol}: ML filter error: {e}")
+            ml_approved = None
+
+    # ── RISK ENGINE ───────────────────────────────────────────────────────────
+    # Only compute full risk if not vetoed by rules AND not rejected by ML
+    final_approved = (
+        not vetoed and
+        (ml_approved is None or ml_approved)
+    )
+
     risk_data = evaluate_risk(
         close=float(df["close"].iloc[-1]),
         atr=regime_data["atr"],
@@ -79,132 +122,151 @@ def analyze_single(
         consec_losses=consec_losses,
         equity_drawdown_pct=equity_drawdown_pct,
         account_equity=account_equity,
-    )
+    ) if final_approved else {}
 
     return {
-        "symbol": symbol,
-        "close": float(df["close"].iloc[-1]),
-        "trend": regime_data["trend"],
-        "adx": regime_data["adx"],
-        "di_plus": regime_data["di_plus"],
-        "di_minus": regime_data["di_minus"],
-        "vol_ratio": regime_data["vol_ratio"],
-        "vol_compressed": regime_data["vol_compressed"],
+        "symbol":             symbol,
+        "close":              float(df["close"].iloc[-1]),
+        "trend":              regime_data["trend"],
+        "adx":                regime_data["adx"],
+        "di_plus":            regime_data["di_plus"],
+        "di_minus":           regime_data["di_minus"],
+        "vol_ratio":          regime_data["vol_ratio"],
+        "vol_compressed":     regime_data["vol_compressed"],
         "vol_expanding_from_base": regime_data["vol_expanding_from_base"],
-        "vol_expanding": regime_data["vol_expanding"],
-        "dist_atr": regime_data["dist_atr"],
-        "price_extended": regime_data["price_extended_long"] or regime_data["price_extended_short"],
-        "regime_confidence": regime_data["regime_confidence"],
-        "spike": volume_data["spike"],
-        "climax": volume_data["climax"],
-        "absorption": volume_data["absorption"],
-        "failed_breakout": volume_data["failed_breakout"],
-        "recent_failed": volume_data["recent_failed_count"],
-        "breakout": volume_data["breakout"],
-        "obv_slope": volume_data["obv_slope_norm"],
-        "delta_sign": volume_data["delta_sign"],
-        "direction": direction,
-        "vetoed": vetoed,
-        "veto_reason": veto_reason,
-        "regime_score": scores["regime_score"],
-        "volume_score": scores["volume_score"],
-        "structure_score": scores["structure_score"],
-        "confidence_score": scores["confidence_score"],
-        "total_score": scores["total_score"],
-        "risk": risk_data,
+        "vol_expanding":      regime_data["vol_expanding"],
+        "dist_atr":           regime_data["dist_atr"],
+        "price_extended":     regime_data["price_extended_long"] or regime_data["price_extended_short"],
+        "regime_confidence":  regime_data["regime_confidence"],
+        "spike":              volume_data["spike"],
+        "climax":             volume_data["climax"],
+        "absorption":         volume_data["absorption"],
+        "failed_breakout":    volume_data["failed_breakout"],
+        "recent_failed":      volume_data["recent_failed_count"],
+        "breakout":           volume_data["breakout"],
+        "obv_slope":          volume_data["obv_slope_norm"],
+        "delta_sign":         volume_data["delta_sign"],
+        "direction":          direction,
+        "rule_vetoed":        vetoed,
+        "veto_reason":        veto_reason,
+        "ml_prob":            ml_prob,
+        "ml_approved":        ml_approved,
+        "ml_reject_reason":   ml_reject_reason,
+        "final_approved":     final_approved,
+        "regime_score":       scores["regime_score"],
+        "volume_score":       scores["volume_score"],
+        "structure_score":    scores["structure_score"],
+        "confidence_score":   scores["confidence_score"],
+        "total_score":        scores["total_score"],
+        "risk":               risk_data,
     }
 
 
+def _ml_status(d: Dict) -> str:
+    if _TRADE_FILTER is None:
+        return "NO_MODEL"
+    if d["rule_vetoed"]:
+        return "RULE_VET"
+    if d["ml_prob"] is None:
+        return "ML_ERR  "
+    prob_str = f"{d['ml_prob']:.3f}"
+    return f"✓{prob_str}" if d["ml_approved"] else f"✗{prob_str}"
+
+
 def build_ranked_table(ranked: list, top_n: int) -> str:
-    col_w = 110
     hdr = (
         f"{'#':>3}  {'Symbol':<14}  {'Score':>7}  {'Tier':>4}  "
-        f"{'Regime':>6}  {'Vol':>6}  {'Struct':>6}  {'Conf':>6}  "
-        f"{'Trend':>7}  {'ADX':>5}  {'VRatio':>6}  "
-        f"{'Absorb':>6}  {'FakBO':>5}  {'Status'}\n"
+        f"{'Regime':>6}  {'Vol':>6}  {'S':>5}  {'C':>5}  "
+        f"{'Trend':>7}  {'ADX':>5}  {'VR':>5}  "
+        f"{'ML':>8}  {'Status'}\n"
     )
-    sep = "─" * col_w + "\n"
+    sep  = "─" * 105 + "\n"
     rows = hdr + sep
 
     for rank, (sym, d) in enumerate(ranked[:top_n], 1):
-        icon = _TREND_ICON.get(d["trend"], "?")
-        tier = quality_tier(d["total_score"])
-        absorb = "YES⚠" if d.get("absorption") else " no"
-        fakebo = f"{d.get('recent_failed', 0)}x" if d.get("recent_failed", 0) > 0 else " —"
-        status = "VETOED" if d["vetoed"] else "OK    "
+        icon   = _TREND_ICON.get(d["trend"], "?")
+        tier   = quality_tier(d["total_score"])
+        ml_str = _ml_status(d)
+
+        if d["rule_vetoed"]:
+            status = "RULE_VET"
+        elif not d["final_approved"]:
+            status = "ML_FILT "
+        else:
+            status = "OK      "
+
         rows += (
             f"{rank:>3}  {sym:<14}  {d['total_score']:>7.4f}  {tier:>4}  "
             f"{d['regime_score']:>6.3f}  {d['volume_score']:>6.3f}  "
-            f"{d['structure_score']:>6.3f}  {d['confidence_score']:>6.3f}  "
-            f"{icon} {d['trend']:<5}  {d['adx']:>5.1f}  {d['vol_ratio']:>6.2f}  "
-            f"{absorb:>6}  {fakebo:>5}  {status}\n"
+            f"{d['structure_score']:>5.3f}  {d['confidence_score']:>5.3f}  "
+            f"{icon} {d['trend']:<5}  {d['adx']:>5.1f}  {d['vol_ratio']:>5.2f}  "
+            f"{ml_str:>8}  {status}\n"
         )
     return rows
 
 
 def build_best_detail(data: Dict[str, Any]) -> str:
-    r = data["risk"]
+    r = data.get("risk", {})
     sym = data["symbol"]
     icon = _TREND_ICON.get(data["trend"], "?")
-    dir_lbl = _DIR_LABEL.get(data["direction"], "?")
 
     vol_state = []
-    if data["vol_compressed"]:
-        vol_state.append("COMPRESSED")
-    if data["vol_expanding_from_base"]:
-        vol_state.append("EXPANDING FROM BASE ✓")
+    if data["vol_compressed"]:          vol_state.append("COMPRESSED")
+    if data["vol_expanding_from_base"]: vol_state.append("EXPANDING FROM BASE ✓")
     if data["vol_expanding"] and not data["vol_expanding_from_base"]:
         vol_state.append("EXPANDING (no base)")
-    vol_state_str = " | ".join(vol_state) if vol_state else "NORMAL"
+    vol_state_str = " | ".join(vol_state) or "NORMAL"
+
+    ml_section = ""
+    if _TRADE_FILTER is not None:
+        prob_str = f"{data['ml_prob']:.4f}" if data["ml_prob"] is not None else "N/A"
+        thresh_str = f"{_TRADE_FILTER.threshold:.4f}"
+        decision = "APPROVED ✓" if data["ml_approved"] else "FILTERED ✗"
+        ml_section = (
+            f"\n  ── ML PROBABILITY FILTER ─────────────────────────\n"
+            f"  P(win):          {prob_str}\n"
+            f"  Threshold:       {thresh_str}\n"
+            f"  ML Decision:     {decision}\n"
+        )
+
+    risk_section = ""
+    if r:
+        risk_section = (
+            f"\n  ── RISK PARAMETERS ────────────────────────────────\n"
+            f"  Entry:           {r.get('entry_price', 0):.8f}\n"
+            f"  ATR:             {r.get('atr', 0):.8f}  ({r.get('atr_pct', 0):.3f}%)\n"
+            f"  Stop Mult:       {r.get('stop_mult', 0):.1f}x ATR\n"
+            f"  LONG  → Stop: {r.get('stop_long', 0):.8f}  Target: {r.get('target_long', 0):.8f}\n"
+            f"  SHORT → Stop: {r.get('stop_short', 0):.8f}  Target: {r.get('target_short', 0):.8f}\n"
+            f"  R:R Ratio:       1 : {r.get('rr_ratio', 2):.1f}\n"
+            f"  Risk Fraction:   {r.get('risk_fraction', 0):.4f}%\n"
+            f"  $ At Risk:       ${r.get('dollar_at_risk', 0):.2f}\n"
+            f"  Position Size:   ${r.get('position_notional', 0):.2f} notional\n"
+            f"  Leverage (est):  {r.get('leverage_implied', 0):.2f}x\n"
+            f"  Consec. Losses:  {r.get('consec_losses', 0)}\n"
+            f"  Sizing Halted:   {'YES ⛔' if r.get('sizing_halted') else 'no'}\n"
+        )
 
     lines = [
         "═" * 64,
-        f"  BEST APPROVED SETUP: {sym}  [{dir_lbl}]",
+        f"  BEST APPROVED SETUP: {sym}  [{_DIR_LABEL.get(data['direction'], '?')}]",
         "═" * 64,
         f"  Trend:            {icon} {data['trend'].upper()}",
         f"  ADX:              {data['adx']:.1f}  (DI+ {data['di_plus']:.1f} / DI- {data['di_minus']:.1f})",
         f"  Vol State:        {vol_state_str}",
-        f"  Vol Ratio:        {data['vol_ratio']:.2f}x",
         f"  Dist from Mean:   {data['dist_atr']:.2f} ATR",
         f"  Regime Confidence:{data['regime_confidence']:.3f}",
-        f"",
-        f"  ── SCORES ───────────────────────────────────────",
+        "",
+        "  ── SCORES ──────────────────────────────────────────",
         f"  Regime:     {format_score_bar(data['regime_score'])}",
         f"  Volume:     {format_score_bar(data['volume_score'])}",
         f"  Structure:  {format_score_bar(data['structure_score'])}",
         f"  Confidence: {format_score_bar(data['confidence_score'])}",
-        f"  ─────────────────────────────────────────────────",
         f"  TOTAL:      {format_score_bar(data['total_score'])}",
-        f"",
-        f"  ── VOLUME FLAGS ─────────────────────────────────",
-        f"  Spike:           {'YES ✓' if data['spike'] else 'no'}",
-        f"  Climax:          {'YES ⚠' if data['climax'] else 'no'}",
-        f"  Absorption:      {'YES ⚠ SELL PRESSURE' if data['absorption'] else 'no'}",
-        f"  Failed Breakout: {'YES ⚠' if data['failed_breakout'] else 'no'}",
-        f"  Recent Fakes:    {data['recent_failed']}",
-        f"  Breakout Dir:    {_BREAKOUT_LABEL.get(data['breakout'], '—')}",
-        f"  OBV Slope:       {data['obv_slope']:+.4f}",
-        f"  Delta (5-bar):   {'BUYING ↑' if data['delta_sign'] > 0 else 'SELLING ↓'}",
-        f"",
-        f"  ── RISK PARAMETERS ─────────────────────────────",
-        f"  Entry:           {r['entry_price']:.8f}",
-        f"  ATR:             {r['atr']:.8f}  ({r['atr_pct']:.3f}%)",
-        f"  Stop Multiplier: {r['stop_mult']:.1f}x ATR (adaptive)",
-        f"  Stop Distance:   {r['stop_distance']:.8f}",
-        f"",
-        f"  LONG  → Stop: {r['stop_long']:.8f}  Target: {r['target_long']:.8f}",
-        f"  SHORT → Stop: {r['stop_short']:.8f}  Target: {r['target_short']:.8f}",
-        f"  R:R Ratio:       1 : {r['rr_ratio']:.1f}",
-        f"",
-        f"  Risk Fraction:   {r['risk_fraction']:.4f}%",
-        f"  $ At Risk:       ${r['dollar_at_risk']:.2f}",
-        f"  Position Size:   ${r['position_notional']:.2f} notional",
-        f"  Leverage (est):  {r['leverage_implied']:.2f}x",
-        f"  Risk Quality:    {r['risk_quality']:.0%}",
-        f"  Consec. Losses:  {r['consec_losses']}",
-        f"  Drawdown Guard:  {'HALTED ⛔' if r['sizing_halted'] else 'active'}",
-        "═" * 64,
     ]
+    lines.append(ml_section)
+    lines.append(risk_section)
+    lines.append("═" * 64)
     return "\n".join(lines)
 
 
@@ -212,10 +274,9 @@ def parse_symbols(raw: str) -> List[str]:
     out = []
     for tok in raw.replace(",", " ").replace("\n", " ").split():
         tok = tok.strip().upper()
-        if not tok:
-            continue
-        out.append(tok if "-" in tok else f"{tok}-USDT")
-    return out if out else DEFAULT_SYMBOLS
+        if tok:
+            out.append(tok if "-" in tok else f"{tok}-USDT")
+    return out or DEFAULT_SYMBOLS
 
 
 def run_analysis(
@@ -225,15 +286,25 @@ def run_analysis(
     drawdown_pct: float,
     top_n: int,
     use_live: bool,
+    use_ml: bool,
     progress=gr.Progress(track_tqdm=False),
 ) -> str:
     t0 = time.time()
     lines = []
 
-    lines.append("━" * 66)
-    lines.append("  OKX QUANTITATIVE ANALYSIS ENGINE  v2")
-    lines.append("  (with absorption, compression & fake-breakout filters)")
-    lines.append("━" * 66)
+    ml_status_str = "ACTIVE" if (_TRADE_FILTER is not None and use_ml) else (
+        "DISABLED" if not use_ml else "NOT TRAINED (run train.py)"
+    )
+
+    lines += [
+        "━" * 68,
+        "  OKX QUANTITATIVE ANALYSIS ENGINE  v3",
+        f"  ML Filter: {ml_status_str}",
+        "━" * 68,
+    ]
+
+    if _TRADE_FILTER is not None and use_ml:
+        lines.append(f"  ML threshold: {_TRADE_FILTER.threshold:.4f}  |  Stats: {_TRADE_FILTER.stats()}")
 
     if use_live:
         lines.append("⟳  Fetching live OKX instrument list...")
@@ -241,11 +312,11 @@ def run_analysis(
         lines.append(f"✓  {len(symbols)} live USDT instruments")
     else:
         symbols = parse_symbols(symbols_input)
-        lines.append(f"✓  {len(symbols)} symbol(s) to analyze")
+        lines.append(f"✓  {len(symbols)} symbol(s)")
 
     lines.append(
-        f"   Equity: ${equity:,.0f}  |  Consec Losses: {int(consec_losses)}"
-        f"  |  Drawdown: {drawdown_pct:.1f}%  |  TF: {TIMEFRAME}"
+        f"   Equity: ${equity:,.0f}  |  Losses: {int(consec_losses)}"
+        f"  |  DD: {drawdown_pct:.1f}%  |  TF: {TIMEFRAME}"
     )
     lines.append("")
 
@@ -255,7 +326,7 @@ def run_analysis(
         progress(i / t, desc=f"Fetching {sym} ({i}/{t})")
 
     ohlcv_map = fetch_multiple(symbols, min_bars=50, progress_callback=prog_cb)
-    lines.append(f"✓  Fetched {len(ohlcv_map)}/{total}  |  Analyzing...")
+    lines.append(f"✓  Fetched {len(ohlcv_map)}/{total}")
     lines.append("")
 
     all_results: Dict[str, Any] = {}
@@ -268,46 +339,52 @@ def run_analysis(
                 account_equity=equity,
                 consec_losses=int(consec_losses),
                 equity_drawdown_pct=drawdown_pct / 100.0,
+                use_ml=use_ml,
             )
         except Exception as exc:
-            logger.error(f"{sym} analysis failed: {exc}", exc_info=True)
+            logger.error(f"{sym}: {exc}", exc_info=True)
             errors.append(sym)
 
     if errors:
-        lines.append(f"⚠  Failed: {', '.join(errors)}")
+        lines.append(f"⚠  Errors: {', '.join(errors)}")
 
     ranked = rank_tokens(all_results)
-    approved = [(s, d) for s, d in ranked if not d["vetoed"]]
-    vetoed_n = len(ranked) - len(approved)
 
-    lines.append(
-        f"  RESULTS: {len(all_results)} analyzed  |  "
-        f"{len(approved)} approved  |  {vetoed_n} vetoed"
-    )
-    lines.append("")
-    lines.append("  RANKED SETUPS")
-    lines.append("─" * 110)
-    lines.append(build_ranked_table(ranked, int(top_n)))
-
-    if approved:
-        best_sym, best_data = approved[0]
-        lines.append("")
-        lines.append(build_best_detail(best_data))
+    rule_vetoed_n = sum(1 for _, d in ranked if d["rule_vetoed"])
+    ml_filtered_n = sum(1 for _, d in ranked if not d["rule_vetoed"] and not d["final_approved"])
+    approved_n    = sum(1 for _, d in ranked if d["final_approved"])
+
+    lines += [
+        f"  {len(all_results)} analyzed  |  {approved_n} approved  |  "
+        f"{rule_vetoed_n} rule-vetoed  |  {ml_filtered_n} ML-filtered",
+        "",
+        "  RANKED SETUPS",
+        "─" * 105,
+        build_ranked_table(ranked, int(top_n)),
+    ]
+
+    final_approved = [(s, d) for s, d in ranked if d["final_approved"]]
+    if final_approved:
+        best_sym, best_data = final_approved[0]
+        lines += ["", build_best_detail(best_data)]
     else:
-        lines.append("")
-        lines.append("  ⚠  No approved setups — all tokens vetoed.")
-        lines.append("     Consider: checking market regime, reducing symbol list,")
-        lines.append("     or verifying OKX API connectivity.")
+        lines += [
+            "",
+            "  ⚠  No fully approved setups.",
+            "     Possible causes: market regime unfavorable, ML model not trained,",
+            "     or all signals vetoed by rule engine.",
+        ]
 
-    lines.append("")
-    lines.append(f"  ✓  Complete in {time.time() - t0:.1f}s")
-    lines.append("━" * 66)
+    if _TRADE_FILTER is not None and use_ml:
+        lines += ["", f"  ML session stats: {_TRADE_FILTER.stats()}"]
+
+    lines += ["", f"  ✓  Complete in {time.time() - t0:.1f}s", "━" * 68]
     return "\n".join(lines)
 
 
 def build_app() -> gr.Blocks:
     with gr.Blocks(
-        title="OKX Quant Engine v2",
+        title="OKX Quant Engine v3",
         theme=gr.themes.Base(
             primary_hue="slate",
             neutral_hue="zinc",
@@ -315,51 +392,43 @@ def build_app() -> gr.Blocks:
         ),
         css="""
         body, .gradio-container {
-            background: #080c12 !important;
+            background: #060a10 !important;
             font-family: 'JetBrains Mono', monospace !important;
-            max-width: 1200px !important;
+            max-width: 1280px !important;
         }
         .gr-button-primary {
             background: linear-gradient(90deg, #1a6bff, #0044cc) !important;
             border: none !important;
             font-weight: 700 !important;
             letter-spacing: 0.06em !important;
-            text-transform: uppercase !important;
         }
         #output_box textarea {
             font-family: 'JetBrains Mono', monospace !important;
-            font-size: 12.5px !important;
+            font-size: 12px !important;
             line-height: 1.55 !important;
-            background: #0b0f18 !important;
-            color: #b8c8e0 !important;
-            border: 1px solid #1a2238 !important;
-            min-height: 720px !important;
-        }
-        label, .label-wrap {
-            font-family: 'JetBrains Mono', monospace !important;
-            color: #5a7090 !important;
-            font-size: 11px !important;
-            letter-spacing: 0.09em !important;
-            text-transform: uppercase !important;
+            background: #0a0e18 !important;
+            color: #b0c4de !important;
+            border: 1px solid #182030 !important;
+            min-height: 740px !important;
         }
-        h1, h2, h3 { color: #c8daf0 !important; font-family: 'JetBrains Mono', monospace !important; }
-        p { color: #445566 !important; font-size: 12px !important; }
-        .gr-panel, .gr-box { background: #0d1220 !important; border: 1px solid #1a2238 !important; }
+        label { color: #4a6080 !important; font-size: 11px !important; text-transform: uppercase !important; letter-spacing: 0.09em !important; }
+        h1, h2 { color: #c0d4f0 !important; font-family: 'JetBrains Mono', monospace !important; }
+        p { color: #384858 !important; font-size: 12px !important; }
+        .gr-panel { background: #0c1020 !important; border: 1px solid #182030 !important; }
         """,
     ) as app:
-        gr.Markdown("# ◈ OKX QUANT ENGINE  v2")
+        gr.Markdown("# ◈ OKX QUANT ENGINE  v3")
         gr.Markdown(
-            "ADX regime · absorption detection · volatility compression filter"
-            " · fake breakout identification · adaptive risk scaling"
+            "ADX · absorption detection · volatility compression · "
+            "fake breakout filter · **LightGBM probability layer** · adaptive risk"
         )
 
         with gr.Row():
             with gr.Column(scale=2):
                 symbols_box = gr.Textbox(
-                    label="Symbols  (comma / newline — blank = 100 defaults)",
+                    label="Symbols  (comma / newline — blank = defaults)",
                     placeholder="BTC-USDT, ETH-USDT, SOL-USDT ...",
-                    lines=4,
-                    value="",
+                    lines=4, value="",
                 )
             with gr.Column(scale=1):
                 equity_slider = gr.Slider(
@@ -369,43 +438,35 @@ def build_app() -> gr.Blocks:
                 )
                 top_n_slider = gr.Slider(
                     label="Top N  to Display",
-                    minimum=5, maximum=100, step=5,
-                    value=TOP_N_DEFAULT,
+                    minimum=5, maximum=100, step=5, value=TOP_N_DEFAULT,
                 )
             with gr.Column(scale=1):
-                consec_loss_input = gr.Slider(
-                    label="Consecutive Losses  (current streak)",
-                    minimum=0, maximum=10, step=1, value=0,
-                )
-                drawdown_input = gr.Slider(
-                    label="Current Drawdown from Peak  (%)",
-                    minimum=0.0, maximum=30.0, step=0.5, value=0.0,
-                )
-                live_check = gr.Checkbox(
-                    label="Fetch live instruments from OKX  (100+ symbols)",
-                    value=False,
+                consec_loss = gr.Slider(label="Consecutive Losses", minimum=0, maximum=10, step=1, value=0)
+                drawdown    = gr.Slider(label="Drawdown from Peak  (%)", minimum=0.0, maximum=30.0, step=0.5, value=0.0)
+                live_check  = gr.Checkbox(label="Fetch live OKX instruments  (100+)", value=False)
+                ml_check    = gr.Checkbox(
+                    label=f"Enable ML Filter  (model: {'LOADED' if _TRADE_FILTER else 'NOT TRAINED'})",
+                    value=_TRADE_FILTER is not None,
                 )
 
         run_btn = gr.Button("▶  RUN ANALYSIS", variant="primary", size="lg")
         output_box = gr.Textbox(
             label="Analysis Output",
-            lines=45, max_lines=120,
+            lines=50, max_lines=150,
             interactive=False,
             elem_id="output_box",
         )
 
         run_btn.click(
             fn=run_analysis,
-            inputs=[
-                symbols_box, equity_slider, consec_loss_input,
-                drawdown_input, top_n_slider, live_check,
-            ],
+            inputs=[symbols_box, equity_slider, consec_loss, drawdown, top_n_slider, live_check, ml_check],
             outputs=output_box,
         )
 
         gr.Markdown(
             "**Research use only. Not financial advice.**  "
-            "All signals are probabilistic — no system eliminates risk."
+            "Train the ML filter: `python train.py --use-defaults`  |  "
+            "Re-optimize threshold: `python threshold_optimizer.py`"
         )
 
     return app
@@ -413,10 +474,8 @@ def build_app() -> gr.Blocks:
 
 if __name__ == "__main__":
     import argparse
-    parser = argparse.ArgumentParser(description="OKX Quant Engine v2")
+    parser = argparse.ArgumentParser()
     parser.add_argument("--port", type=int, default=7860)
     parser.add_argument("--share", action="store_true")
-    args = parser.parse_args()
-
-    app = build_app()
-    app.launch(server_name="0.0.0.0", server_port=args.port, share=args.share, show_error=True)
+    a = parser.parse_args()
+    build_app().launch(server_name="0.0.0.0", server_port=a.port, share=a.share, show_error=True)