Update app.py

app.py

@@ -1,7 +1,19 @@
+"""
+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
+"""
+
 import logging
 import sys
 import time
-from typing import List, Optional
+from typing import List, Optional, Dict, Any
 
 import gradio as gr
 
@@ -17,7 +29,7 @@ from regime import detect_regime
 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
+from scorer import compute_structure_score, score_token, rank_tokens, format_score_bar, quality_tier
 
 logging.basicConfig(
     level=logging.INFO,
@@ -26,16 +38,35 @@ logging.basicConfig(
 )
 logger = logging.getLogger("main")
 
-_TREND_EMOJI = {"bullish": "🟢", "ranging": "🟡", "bearish": "🔴"}
-_BREAKOUT_LABEL = {1: "↑ UP", -1: "↓ DOWN", 0: "—"}
+_TREND_ICON = {"bullish": "▲", "ranging": "◆", "bearish": "▼"}
+_BREAKOUT_LABEL = {1: "↑ UP", -1: "↓ DN", 0: " — "}
+_DIR_LABEL = {1: "LONG", -1: "SHORT", 0: "NONE"}
+
 
+def infer_direction(trend: str, breakout: int) -> int:
+    if trend == "bullish" or breakout == 1:
+        return 1
+    if trend == "bearish" or breakout == -1:
+        return -1
+    return 0
 
-def analyze_single(symbol: str, df, account_equity: float) -> dict:
+
+def analyze_single(
+    symbol: str,
+    df,
+    account_equity: float,
+    consec_losses: int = 0,
+    equity_drawdown_pct: float = 0.0,
+) -> Dict[str, Any]:
     regime_data = detect_regime(df)
-    volume_data = analyze_volume(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)
-    vetoed, veto_reason = apply_veto(regime_data, volume_data, structure_score)
+
+    direction = infer_direction(regime_data["trend"], volume_data["breakout"])
+    vetoed, veto_reason = apply_veto(regime_data, volume_data, structure_score, direction=direction)
     scores = score_token(regime_data, volume_data, vetoed)
+
     risk_data = evaluate_risk(
         close=float(df["close"].iloc[-1]),
         atr=regime_data["atr"],
@@ -43,300 +74,349 @@ def analyze_single(symbol: str, df, account_equity: float) -> dict:
         regime_score=regime_data["regime_score"],
         vol_ratio=regime_data["vol_ratio"],
         volume_score=volume_data["volume_score"],
+        regime_confidence=regime_data["regime_confidence"],
+        vol_compressed=regime_data["vol_compressed"],
+        consec_losses=consec_losses,
+        equity_drawdown_pct=equity_drawdown_pct,
         account_equity=account_equity,
     )
+
     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"],
+        "vol_expanding_from_base": regime_data["vol_expanding_from_base"],
         "vol_expanding": regime_data["vol_expanding"],
-        "atr_pct": regime_data["atr_pct"],
+        "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,
     }
 
 
-def build_summary_table(ranked: list, top_n: int) -> str:
-    header = (
-        f"{'#':>3}  {'Symbol':<14}  {'Score':>6}  {'Regime':>7}  "
-        f"{'Volume':>7}  {'Structure':>10}  {'Trend':<8}  "
-        f"{'VolRatio':>8}  {'Spike':>5}  {'BOS':>5}  {'Status'}\n"
+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"
     )
-    separator = "─" * 110 + "\n"
-    rows = header + separator
-    for rank, (sym, data) in enumerate(ranked[:top_n], 1):
-        trend_icon = _TREND_EMOJI.get(data["trend"], "⚪")
-        breakout_lbl = _BREAKOUT_LABEL.get(data["breakout"], "—")
-        spike_lbl = "✓" if data["spike"] else "✗"
-        status = "VETOED" if data["vetoed"] else "OK"
+    sep = "─" * col_w + "\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    "
         rows += (
-            f"{rank:>3}  {sym:<14}  {data['total_score']:>6.4f}  "
-            f"{data['regime_score']:>7.4f}  {data['volume_score']:>7.4f}  "
-            f"{data['structure_score']:>10.4f}  "
-            f"{trend_icon} {data['trend']:<6}  "
-            f"{data['vol_ratio']:>8.2f}  {spike_lbl:>5}  "
-            f"{breakout_lbl:>5}  {status}\n"
+            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"
         )
     return rows
 
 
-def build_top_setup_detail(data: dict) -> str:
+def build_best_detail(data: Dict[str, Any]) -> str:
     r = data["risk"]
     sym = data["symbol"]
-    trend_icon = _TREND_EMOJI.get(data["trend"], "⚪")
+    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_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"
+
     lines = [
-        "═" * 60,
-        f"  BEST SETUP: {sym}",
-        "═" * 60,
-        f"  Trend:          {trend_icon} {data['trend'].upper()}",
-        f"  Close Price:    {r['entry_price']:.8f}",
+        "═" * 64,
+        f"  BEST APPROVED SETUP: {sym}  [{dir_lbl}]",
+        "═" * 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 ──────────────────────────────",
-        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"  Total:          {format_score_bar(data['total_score'])}",
+        f"  ── 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"  ── RISK PARAMETERS ──────────────────────",
-        f"  ATR:            {r['atr']:.8f} ({r['atr_pct']:.3f}%)",
-        f"  Vol Ratio:      {r['vol_ratio']:.2f}x  (quality: {r['risk_quality']:.0%})",
-        f"  Risk Fraction:  {r['risk_fraction']:.3f}%",
-        f"  $ At Risk:      ${r['dollar_at_risk']:.2f}",
-        f"  Position Size:  ${r['position_notional']:.2f} notional",
-        f"  Leverage (est): {r['leverage_implied']:.1f}x",
+        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"  ── LONG SCENARIO ───────────────────────",
-        f"  Stop Loss:      {r['stop_long']:.8f}",
-        f"  Take Profit:    {r['target_long']:.8f}",
-        f"  R:R Ratio:      1 : {r['rr_ratio']:.1f}",
+        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"  ── SHORT SCENARIO ──────────────────────",
-        f"  Stop Loss:      {r['stop_short']:.8f}",
-        f"  Take Profit:    {r['target_short']:.8f}",
-        f"  R:R Ratio:      1 : {r['rr_ratio']:.1f}",
+        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"  Volume Spike:   {'YES ✓' if data['spike'] else 'NO ✗'}",
-        f"  Volume Climax:  {'YES ⚠' if data['climax'] else 'NO'}",
-        f"  Breakout:       {_BREAKOUT_LABEL.get(data['breakout'], '—')}",
-        f"  OBV Slope:      {data['obv_slope']:+.4f}",
-        f"  Delta (5-bar):  {'BUYING ↑' if data['delta_sign'] > 0 else 'SELLING ↓'}",
-        "═" * 60,
+        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,
     ]
     return "\n".join(lines)
 
 
-def parse_symbol_list(raw: str) -> List[str]:
-    symbols = []
+def parse_symbols(raw: str) -> List[str]:
+    out = []
     for tok in raw.replace(",", " ").replace("\n", " ").split():
         tok = tok.strip().upper()
-        if tok and "-" in tok:
-            symbols.append(tok)
-        elif tok:
-            symbols.append(f"{tok}-USDT")
-    return symbols if symbols else DEFAULT_SYMBOLS
+        if not tok:
+            continue
+        out.append(tok if "-" in tok else f"{tok}-USDT")
+    return out if out else DEFAULT_SYMBOLS
 
 
 def run_analysis(
     symbols_input: str,
     equity: float,
+    consec_losses: int,
+    drawdown_pct: float,
     top_n: int,
-    use_live_instruments: bool,
+    use_live: bool,
     progress=gr.Progress(track_tqdm=False),
 ) -> str:
-    start_ts = time.time()
-    output_lines = []
-
-    output_lines.append("━" * 60)
-    output_lines.append("  OKX QUANTITATIVE ANALYSIS ENGINE")
-    output_lines.append("━" * 60)
-
-    if use_live_instruments:
-        output_lines.append("⟳ Fetching live instrument list from OKX...")
-        symbols = fetch_instruments("SPOT")
-        if not symbols:
-            output_lines.append("⚠ Failed to fetch live instruments. Using defaults.")
-            symbols = DEFAULT_SYMBOLS
-        else:
-            output_lines.append(f"✓ Found {len(symbols)} live USDT spot instruments")
+    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)
+
+    if use_live:
+        lines.append("⟳  Fetching live OKX instrument list...")
+        symbols = fetch_instruments("SPOT") or DEFAULT_SYMBOLS
+        lines.append(f"✓  {len(symbols)} live USDT instruments")
     else:
-        symbols = parse_symbol_list(symbols_input)
-        output_lines.append(f"✓ Analyzing {len(symbols)} symbol(s)")
+        symbols = parse_symbols(symbols_input)
+        lines.append(f"✓  {len(symbols)} symbol(s) to analyze")
 
-    output_lines.append(f"  Timeframe: {TIMEFRAME}  |  Candles: {CANDLE_LIMIT}  |  Equity: ${equity:,.0f}")
-    output_lines.append("")
+    lines.append(
+        f"   Equity: ${equity:,.0f}  |  Consec Losses: {int(consec_losses)}"
+        f"  |  Drawdown: {drawdown_pct:.1f}%  |  TF: {TIMEFRAME}"
+    )
+    lines.append("")
 
-    fetched_count = [0]
     total = len(symbols)
 
-    def progress_cb(i, t, sym):
-        fetched_count[0] = i
+    def prog_cb(i, t, sym):
         progress(i / t, desc=f"Fetching {sym} ({i}/{t})")
 
-    ohlcv_map = fetch_multiple(
-        symbols,
-        min_bars=50,
-        progress_callback=progress_cb,
-    )
-
-    output_lines.append(f"✓ Fetched {len(ohlcv_map)}/{total} symbols successfully")
-    output_lines.append("")
+    ohlcv_map = fetch_multiple(symbols, min_bars=50, progress_callback=prog_cb)
+    lines.append(f"✓  Fetched {len(ohlcv_map)}/{total}  |  Analyzing...")
+    lines.append("")
 
-    all_results = {}
-    failed = []
+    all_results: Dict[str, Any] = {}
+    errors = []
 
     for sym, df in ohlcv_map.items():
         try:
-            all_results[sym] = analyze_single(sym, df, account_equity=equity)
+            all_results[sym] = analyze_single(
+                sym, df,
+                account_equity=equity,
+                consec_losses=int(consec_losses),
+                equity_drawdown_pct=drawdown_pct / 100.0,
+            )
         except Exception as exc:
-            logger.error(f"Analysis error for {sym}: {exc}", exc_info=True)
-            failed.append(sym)
+            logger.error(f"{sym} analysis failed: {exc}", exc_info=True)
+            errors.append(sym)
 
-    if failed:
-        output_lines.append(f"⚠ Analysis failed for: {', '.join(failed)}")
-        output_lines.append("")
+    if errors:
+        lines.append(f"⚠  Failed: {', '.join(errors)}")
 
     ranked = rank_tokens(all_results)
-
     approved = [(s, d) for s, d in ranked if not d["vetoed"]]
-    vetoed_count = sum(1 for _, d in ranked if d["vetoed"])
+    vetoed_n = len(ranked) - len(approved)
 
-    output_lines.append(f"  RESULTS: {len(all_results)} analyzed  |  {len(approved)} approved  |  {vetoed_count} vetoed")
-    output_lines.append("")
-    output_lines.append("  TOP SETUPS RANKED BY TOTAL SCORE")
-    output_lines.append("─" * 110)
-    output_lines.append(build_summary_table(ranked, int(top_n)))
+    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]
-        output_lines.append("")
-        output_lines.append(build_top_setup_detail(best_data))
+        lines.append("")
+        lines.append(build_best_detail(best_data))
     else:
-        output_lines.append("")
-        output_lines.append("  ⚠ No approved setups found — all tokens vetoed.")
-
-    elapsed = time.time() - start_ts
-    output_lines.append("")
-    output_lines.append(f"  ✓ Analysis complete in {elapsed:.1f}s")
-    output_lines.append("━" * 60)
-
-    return "\n".join(output_lines)
+        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.append("")
+    lines.append(f"  ✓  Complete in {time.time() - t0:.1f}s")
+    lines.append("━" * 66)
+    return "\n".join(lines)
 
 
-def build_interface() -> gr.Blocks:
+def build_app() -> gr.Blocks:
     with gr.Blocks(
-        title="OKX Quant Analysis Engine",
+        title="OKX Quant Engine v2",
         theme=gr.themes.Base(
             primary_hue="slate",
-            neutral_hue="slate",
+            neutral_hue="zinc",
             font=[gr.themes.GoogleFont("JetBrains Mono"), "monospace"],
         ),
         css="""
-        body { background: #0a0a0f; }
-        .gradio-container {
-            background: #0a0a0f !important;
-            max-width: 1100px !important;
+        body, .gradio-container {
+            background: #080c12 !important;
             font-family: 'JetBrains Mono', monospace !important;
+            max-width: 1200px !important;
         }
         .gr-button-primary {
-            background: #1a6bff !important;
+            background: linear-gradient(90deg, #1a6bff, #0044cc) !important;
             border: none !important;
-            font-family: 'JetBrains Mono', monospace !important;
             font-weight: 700 !important;
-            letter-spacing: 0.05em !important;
+            letter-spacing: 0.06em !important;
+            text-transform: uppercase !important;
         }
-        .gr-button-primary:hover { background: #0050e0 !important; }
         #output_box textarea {
             font-family: 'JetBrains Mono', monospace !important;
-            font-size: 13px !important;
-            background: #0f0f1a !important;
-            color: #c8d0e0 !important;
-            border: 1px solid #1e2236 !important;
-            min-height: 700px !important;
+            font-size: 12.5px !important;
+            line-height: 1.55 !important;
+            background: #0b0f18 !important;
+            color: #b8c8e0 !important;
+            border: 1px solid #1a2238 !important;
+            min-height: 720px !important;
         }
-        label, .gr-form label {
+        label, .label-wrap {
             font-family: 'JetBrains Mono', monospace !important;
-            color: #8899bb !important;
+            color: #5a7090 !important;
             font-size: 11px !important;
-            letter-spacing: 0.08em !important;
+            letter-spacing: 0.09em !important;
             text-transform: uppercase !important;
         }
-        .gr-panel { background: #0d0d18 !important; border: 1px solid #1e2236 !important; }
-        h1 { color: #e0e8ff !important; font-family: 'JetBrains Mono', monospace !important; letter-spacing: 0.05em !important; }
-        p { color: #5a6a8a !important; font-family: 'JetBrains Mono', monospace !important; font-size: 12px !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; }
         """,
     ) as app:
-
-        gr.Markdown("# ◈ OKX QUANT ANALYSIS ENGINE")
-        gr.Markdown("Multi-token regime detection · volume analysis · dynamic risk · veto scoring")
+        gr.Markdown("# ◈ OKX QUANT ENGINE  v2")
+        gr.Markdown(
+            "ADX regime · absorption detection · volatility compression filter"
+            " · fake breakout identification · adaptive risk scaling"
+        )
 
         with gr.Row():
             with gr.Column(scale=2):
                 symbols_box = gr.Textbox(
-                    label="Symbols (comma or newline separated — leave blank for defaults)",
+                    label="Symbols  (comma / newline — blank = 100 defaults)",
                     placeholder="BTC-USDT, ETH-USDT, SOL-USDT ...",
                     lines=4,
                     value="",
                 )
             with gr.Column(scale=1):
                 equity_slider = gr.Slider(
-                    label="Account Equity (USD)",
-                    minimum=100,
-                    maximum=1_000_000,
-                    step=100,
+                    label="Account Equity  ($)",
+                    minimum=100, maximum=1_000_000, step=500,
                     value=DEFAULT_ACCOUNT_EQUITY,
                 )
                 top_n_slider = gr.Slider(
-                    label="Top N Results to Show",
-                    minimum=5,
-                    maximum=100,
-                    step=5,
+                    label="Top N  to Display",
+                    minimum=5, maximum=100, step=5,
                     value=TOP_N_DEFAULT,
                 )
-                live_instruments = gr.Checkbox(
-                    label="Fetch live instruments from OKX (100+ symbols)",
+            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,
                 )
 
         run_btn = gr.Button("▶  RUN ANALYSIS", variant="primary", size="lg")
-
         output_box = gr.Textbox(
             label="Analysis Output",
-            lines=40,
-            max_lines=100,
+            lines=45, max_lines=120,
             interactive=False,
             elem_id="output_box",
         )
 
         run_btn.click(
             fn=run_analysis,
-            inputs=[symbols_box, equity_slider, top_n_slider, live_instruments],
+            inputs=[
+                symbols_box, equity_slider, consec_loss_input,
+                drawdown_input, top_n_slider, live_check,
+            ],
             outputs=output_box,
         )
 
         gr.Markdown(
-            "**Signals are for research purposes only. Not financial advice.**  "
-            "Data sourced from OKX public REST API."
+            "**Research use only. Not financial advice.**  "
+            "All signals are probabilistic — no system eliminates risk."
         )
 
     return app
 
 
 if __name__ == "__main__":
-    app = build_interface()
-    app.launch(
-        server_name="0.0.0.0",
-        server_port=7860,
-        show_error=True,
-        share=False,
-    )
+    import argparse
+    parser = argparse.ArgumentParser(description="OKX Quant Engine v2")
+    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)