Delete app.py

app.py

@@ -1,4199 +0,0 @@
-# ================================================================
-# main.py — OKX QUANT ENGINE v5
-# ================================================================
-#
-# Advanced research pipeline:
-#
-# OHLCV
-#   │
-#   ├── Regime Switching
-#   ├── Multi-Timeframe Proxy
-#   ├── Volume / Structure
-#   ├── Order-Flow Proxy
-#   ├── Feature Interactions
-#   │
-#   ▼
-# ML Probability
-#   │
-#   ├── Probability calibration
-#   ├── Historical similarity
-#   ├── Walk-forward validation
-#   ├── Overfit detector
-#   ├── Monte Carlo robustness
-#   └── Online performance memory
-#   │
-#   ▼
-# Dynamic TP/SL
-#   │
-#   ▼
-# Adaptive Meta Engine
-#   │
-#   ▼
-# Correlation-aware Risk
-#   │
-#   ▼
-# FINAL SETUP
-#
-# Research use only.
-# ================================================================
-
-import logging
-import sys
-import time
-import math
-import json
-import os
-from typing import List, Optional, Dict, Any, Tuple
-
-import numpy as np
-import pandas as pd
-import gradio as gr
-
-from config import (
-    DEFAULT_SYMBOLS,
-    TOP_N_DEFAULT,
-    DEFAULT_ACCOUNT_EQUITY,
-    TIMEFRAME,
-    CANDLE_LIMIT,
-)
-
-from data_fetcher import (
-    fetch_multiple,
-    fetch_instruments,
-)
-
-from regime import detect_regime
-from volume_analysis import analyze_volume
-from risk_engine import evaluate_risk
-from veto import apply_veto
-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
-# ================================================================
-
-logging.basicConfig(
-    level=logging.INFO,
-    format="%(asctime)s [%(levelname)s] %(name)s: %(message)s",
-    stream=sys.stdout,
-)
-
-logger = logging.getLogger("main")
-
-
-# ================================================================
-# MODEL
-# ================================================================
-
-_TRADE_FILTER: Optional[TradeFilter] = TradeFilter.load_or_none()
-
-
-# ================================================================
-# CONSTANTS
-# ================================================================
-
-_TREND_ICON = {
-    "bullish": "▲",
-    "ranging": "◆",
-    "bearish": "▼",
-}
-
-_DIR_LABEL = {
-    1: "LONG",
-    -1: "SHORT",
-    0: "NONE",
-}
-
-
-# ================================================================
-# ADVANCED CONFIG
-# ================================================================
-
-ENGINE_CONFIG = {
-
-    # Meta decision
-    "meta_threshold": 0.64,
-    "hard_threshold": 0.40,
-
-    # Historical similarity
-    "similarity_window": 32,
-    "similarity_history": 400,
-    "similarity_k": 30,
-
-    # Walk-forward
-    "wf_min_train": 60,
-    "wf_test_size": 25,
-    "wf_step": 25,
-
-    # Monte Carlo
-    "mc_iterations": 10000,
-    "mc_sample_size": 100,
-
-    # Dynamic TP / SL
-    "tp_grid": [
-        1.25,
-        1.50,
-        1.75,
-        2.00,
-        2.25,
-        2.50,
-        2.75,
-        3.00,
-    ],
-
-    "sl_grid": [
-        0.75,
-        0.90,
-        1.00,
-        1.10,
-        1.25,
-        1.50,
-    ],
-
-    # Historical forward horizon
-    "forward_bars": 5,
-
-    # Noise
-    "max_noise": 0.80,
-
-    # Minimum samples
-    "min_history": 30,
-
-    # Online memory
-    "memory_file": "trade_memory.json",
-
-    # Meta weights
-    "weights": {
-
-        "rule": 0.13,
-
-        "ml": 0.14,
-
-        "trend": 0.08,
-
-        "momentum": 0.07,
-
-        "mtf": 0.08,
-
-        "orderflow": 0.08,
-
-        "similarity": 0.09,
-
-        "walkforward": 0.09,
-
-        "stability": 0.07,
-
-        "montecarlo": 0.07,
-
-        "noise": 0.05,
-
-        "freshness": 0.05,
-    },
-}
-
-
-# ================================================================
-# HELPERS
-# ================================================================
-
-def safe_float(
-    x,
-    default=0.0,
-):
-
-    try:
-
-        x = float(x)
-
-        if math.isfinite(x):
-            return x
-
-    except Exception:
-        pass
-
-    return default
-
-
-def clamp(
-    x,
-    lo=0.0,
-    hi=1.0,
-):
-
-    return max(
-        lo,
-        min(
-            hi,
-            safe_float(x),
-        ),
-    )
-
-
-def sigmoid(x):
-
-    x = np.clip(
-        x,
-        -40,
-        40,
-    )
-
-    return float(
-        1.0 /
-        (
-            1.0 +
-            np.exp(-x)
-        )
-    )
-
-
-def close_series(df):
-
-    if (
-        df is None
-        or
-        "close" not in df.columns
-    ):
-        return pd.Series(
-            dtype=float
-        )
-
-    return (
-        pd.to_numeric(
-            df["close"],
-            errors="coerce",
-        )
-        .replace(
-            [np.inf, -np.inf],
-            np.nan,
-        )
-        .dropna()
-    )
-
-
-def returns_series(df):
-
-    close = close_series(df)
-
-    if len(close) < 3:
-        return pd.Series(
-            dtype=float
-        )
-
-    return (
-        close
-        .pct_change()
-        .replace(
-            [np.inf, -np.inf],
-            np.nan,
-        )
-        .dropna()
-    )
-
-
-# ================================================================
-# DIRECTION
-# ================================================================
-
-def infer_direction(
-    trend,
-    breakout,
-):
-
-    if (
-        trend == "bullish"
-        or
-        breakout == 1
-    ):
-        return 1
-
-    if (
-        trend == "bearish"
-        or
-        breakout == -1
-    ):
-        return -1
-
-    return 0
-
-
-# ================================================================
-# 1. REGIME SWITCHING
-# ================================================================
-
-def regime_switch_engine(
-    df,
-    regime_data,
-):
-
-    close = close_series(df)
-    ret = returns_series(df)
-
-    if len(close) < 40:
-
-        return {
-            "state": "UNKNOWN",
-            "stability": 0.5,
-            "transition_risk": 0.5,
-            "volatility_state": "NORMAL",
-        }
-
-    recent = ret.iloc[-20:]
-    older = ret.iloc[-60:-20]
-
-    recent_vol = safe_float(
-        recent.std()
-    )
-
-    old_vol = safe_float(
-        older.std(),
-        recent_vol,
-    )
-
-    vol_ratio = (
-        recent_vol /
-        max(
-            old_vol,
-            1e-9,
-        )
-    )
-
-    trend = regime_data.get(
-        "trend",
-        "ranging",
-    )
-
-    adx = safe_float(
-        regime_data.get(
-            "adx",
-            0,
-        )
-    )
-
-    if (
-        vol_ratio > 2.0
-        and
-        adx > 25
-    ):
-
-        state = (
-            "VOLATILE_TREND"
-        )
-
-    elif (
-        vol_ratio > 1.8
-    ):
-
-        state = (
-            "VOLATILITY_EXPANSION"
-        )
-
-    elif (
-        vol_ratio < 0.65
-        and
-        adx < 20
-    ):
-
-        state = "COMPRESSION"
-
-    elif (
-        adx >= 30
-        and
-        trend == "bullish"
-    ):
-
-        state = "STRONG_BULL"
-
-    elif (
-        adx >= 30
-        and
-        trend == "bearish"
-    ):
-
-        state = "STRONG_BEAR"
-
-    elif adx < 20:
-
-        state = "RANGE"
-
-    else:
-
-        state = "TRANSITION"
-
-    transition_risk = clamp(
-        abs(
-            math.log(
-                max(
-                    vol_ratio,
-                    1e-6,
-                )
-            )
-        )
-        / 2.0
-    )
-
-    stability = clamp(
-        1.0 -
-        transition_risk
-    )
-
-    if vol_ratio > 2.5:
-        stability *= 0.70
-
-    return {
-
-        "state":
-            state,
-
-        "stability":
-            clamp(stability),
-
-        "transition_risk":
-            clamp(
-                transition_risk
-            ),
-
-        "volatility_state":
-            (
-                "EXPANSION"
-                if vol_ratio > 1.5
-                else
-                "COMPRESSION"
-                if vol_ratio < 0.7
-                else
-                "NORMAL"
-            ),
-
-        "vol_ratio":
-            vol_ratio,
-    }
-
-
-# ================================================================
-# 2. MULTI-TIMEFRAME PROXY
-# ================================================================
-
-def resample_ohlcv(
-    df,
-    rule,
-):
-
-    if df is None:
-        return None
-
-    x = df.copy()
-
-    if not isinstance(
-        x.index,
-        pd.DatetimeIndex,
-    ):
-
-        return None
-
-    required = {
-        "open",
-        "high",
-        "low",
-        "close",
-        "volume",
-    }
-
-    if not required.issubset(
-        x.columns
-    ):
-        return None
-
-    try:
-
-        y = x.resample(
-            rule
-        ).agg({
-
-            "open": "first",
-
-            "high": "max",
-
-            "low": "min",
-
-            "close": "last",
-
-            "volume": "sum",
-
-        }).dropna()
-
-        return y
-
-    except Exception:
-
-        return None
-
-
-def timeframe_direction(
-    frame,
-):
-
-    if frame is None:
-        return 0, 0.5
-
-    close = close_series(
-        frame
-    )
-
-    if len(close) < 15:
-        return 0, 0.5
-
-    r = (
-        close.iloc[-1] /
-        close.iloc[-11] -
-        1
-    )
-
-    if r > 0.003:
-        d = 1
-
-    elif r < -0.003:
-        d = -1
-
-    else:
-        d = 0
-
-    strength = clamp(
-        sigmoid(
-            abs(r) /
-            0.01
-        ) - 0.5
-    ) * 2
-
-    return d, strength
-
-
-def multi_timeframe_engine(
-    df,
-    direction,
-):
-
-    results = {}
-
-    frames = {
-        "BASE": df,
-    }
-
-    # These require a DatetimeIndex.
-    if isinstance(
-        df.index,
-        pd.DatetimeIndex,
-    ):
-
-        for name, rule in {
-            "15M": "15min",
-            "1H": "1h",
-            "4H": "4h",
-        }.items():
-
-            r = resample_ohlcv(
-                df,
-                rule,
-            )
-
-            if r is not None:
-                frames[name] = r
-
-    values = []
-
-    for name, frame in frames.items():
-
-        d, strength = (
-            timeframe_direction(
-                frame
-            )
-        )
-
-        results[name] = {
-            "direction": d,
-            "strength": strength,
-        }
-
-        if direction != 0:
-            values.append(
-                1.0
-                if d == direction
-                else
-                0.0
-                if d != 0
-                else
-                0.5
-            )
-
-    agreement = (
-        float(
-            np.mean(values)
-        )
-        if values
-        else
-        0.5
-    )
-
-    return {
-        "timeframes":
-            results,
-
-        "agreement":
-            clamp(agreement),
-    }
-
-
-# ================================================================
-# 3. ORDER-FLOW PROXY
-# ================================================================
-
-def orderflow_proxy(
-    df,
-):
-
-    if df is None:
-        return {
-            "buy_pressure": 0.5,
-            "sell_pressure": 0.5,
-            "imbalance": 0.0,
-            "absorption": 0.5,
-            "breakout_quality": 0.5,
-        }
-
-    required = {
-        "open",
-        "high",
-        "low",
-        "close",
-        "volume",
-    }
-
-    if not required.issubset(
-        df.columns
-    ):
-
-        return {
-            "buy_pressure": 0.5,
-            "sell_pressure": 0.5,
-            "imbalance": 0.0,
-            "absorption": 0.5,
-            "breakout_quality": 0.5,
-        }
-
-    x = df.tail(50).copy()
-
-    rng = (
-        x["high"] -
-        x["low"]
-    ).replace(
-        0,
-        np.nan,
-    )
-
-    body = (
-        x["close"] -
-        x["open"]
-    )
-
-    body_ratio = (
-        body / rng
-    ).replace(
-        [np.inf, -np.inf],
-        np.nan,
-    ).fillna(0)
-
-    buy = (
-        ((body_ratio + 1) / 2)
-        * x["volume"]
-    )
-
-    sell = (
-        ((1 - body_ratio) / 2)
-        * x["volume"]
-    )
-
-    buy_total = safe_float(
-        buy.sum()
-    )
-
-    sell_total = safe_float(
-        sell.sum()
-    )
-
-    total = max(
-        buy_total + sell_total,
-        1e-9,
-    )
-
-    buy_pressure = (
-        buy_total /
-        total
-    )
-
-    sell_pressure = (
-        sell_total /
-        total
-    )
-
-    imbalance = (
-        buy_pressure -
-        sell_pressure
-    )
-
-    # Absorption proxy:
-    # high volume + small body
-    volume_z = (
-        x["volume"] -
-        x["volume"].rolling(
-            20
-        ).mean()
-    ) / (
-        x["volume"].rolling(
-            20
-        ).std() + 1e-9
-    )
-
-    small_body = (
-        abs(body_ratio) < 0.25
-    )
-
-    absorption_hits = (
-        (
-            volume_z > 1.5
-        )
-        &
-        small_body
-    )
-
-    absorption = clamp(
-        float(
-            absorption_hits.mean()
-        )
-    )
-
-    last_range = safe_float(
-        rng.iloc[-1],
-        1e-9,
-    )
-
-    last_body = abs(
-        safe_float(
-            body.iloc[-1]
-        )
-    )
-
-    breakout_quality = clamp(
-        last_body /
-        max(
-            last_range,
-            1e-9,
-        )
-    )
-
-    return {
-
-        "buy_pressure":
-            clamp(
-                buy_pressure
-            ),
-
-        "sell_pressure":
-            clamp(
-                sell_pressure
-            ),
-
-        "imbalance":
-            imbalance,
-
-        "absorption":
-            absorption,
-
-        "breakout_quality":
-            breakout_quality,
-    }
-
-
-# ================================================================
-# 4. FEATURE INTERACTIONS
-# ================================================================
-
-def feature_interactions(
-    regime_data,
-    volume_data,
-    ml_prob,
-    meta_base=0.5,
-):
-
-    adx = safe_float(
-        regime_data.get(
-            "adx",
-            0,
-        )
-    )
-
-    vol_ratio = safe_float(
-        regime_data.get(
-            "vol_ratio",
-            1,
-        )
-    )
-
-    volume_score = clamp(
-        volume_data.get(
-            "volume_score",
-            0.5,
-        )
-    )
-
-    breakout = (
-        volume_data.get(
-            "breakout",
-            0,
-        )
-    )
-
-    ml = (
-        0.5
-        if ml_prob is None
-        else clamp(
-            ml_prob
-        )
-    )
-
-    adx_component = clamp(
-        adx / 50
-    )
-
-    volume_component = clamp(
-        vol_ratio / 2
-    )
-
-    interactions = {
-
-        "adx_volume":
-            clamp(
-                adx_component *
-                volume_component
-            ),
-
-        "adx_breakout":
-            clamp(
-                adx_component *
-                (
-                    1
-                    if breakout != 0
-                    else 0.5
-                )
-            ),
-
-        "ml_volume":
-            clamp(
-                ml *
-                volume_score
-            ),
-
-        "ml_regime":
-            clamp(
-                ml *
-                adx_component
-            ),
-
-        "breakout_volume":
-            clamp(
-                (
-                    1
-                    if breakout != 0
-                    else 0.5
-                )
-                *
-                volume_score
-            ),
-
-        "composite":
-            clamp(
-                np.mean(
-                    [
-                        adx_component *
-                        volume_component,
-
-                        ml *
-                        volume_score,
-
-                        adx_component *
-                        (
-                            1
-                            if breakout != 0
-                            else 0.5
-                        ),
-                    ]
-                )
-            ),
-    }
-
-    return interactions
-
-
-# ================================================================
-# 5. HISTORICAL SIMILARITY
-# ================================================================
-
-def build_state_vector(
-    df,
-    direction,
-):
-
-    close = close_series(df)
-    ret = returns_series(df)
-
-    if len(close) < 40:
-        return None
-
-    recent = close.iloc[-20:]
-
-    returns = (
-        recent
-        .pct_change()
-        .dropna()
-    )
-
-    features = [
-
-        safe_float(
-            returns.mean()
-        ),
-
-        safe_float(
-            returns.std()
-        ),
-
-        safe_float(
-            returns.skew()
-        ),
-
-        safe_float(
-            abs(
-                returns.mean()
-            ) /
-            (
-                returns.std()
-                + 1e-9
-            )
-        ),
-
-        safe_float(
-            close.iloc[-1] /
-            close.iloc[-11] -
-            1
-        ),
-
-        safe_float(
-            close.iloc[-1] /
-            close.iloc[-21] -
-            1
-        ),
-
-        safe_float(
-            close.iloc[-1] /
-            close.iloc[-31] -
-            1
-        ),
-
-    ]
-
-    return np.asarray(
-        features,
-        dtype=float,
-    )
-
-
-def historical_similarity(
-    df,
-    direction,
-):
-
-    close = close_series(df)
-
-    if (
-        direction == 0
-        or
-        len(close) < 100
-    ):
-
-        return {
-            "score": 0.5,
-            "matches": 0,
-            "edge": 0.5,
-            "median_return": 0.0,
-        }
-
-    current = build_state_vector(
-        df,
-        direction,
-    )
-
-    if current is None:
-        return {
-            "score": 0.5,
-            "matches": 0,
-            "edge": 0.5,
-            "median_return": 0.0,
-        }
-
-    values = close.values
-
-    history = min(
-        len(values) - 10,
-        ENGINE_CONFIG[
-            "similarity_history"
-        ],
-    )
-
-    window = ENGINE_CONFIG[
-        "similarity_window"
-    ]
-
-    candidates = []
-
-    for end in range(
-        window,
-        history,
-    ):
-
-        start = (
-            len(values) -
-            history +
-            end -
-            window
-        )
-
-        if start < 0:
-            continue
-
-        segment = (
-            close.iloc[
-                start:
-                start + window
-            ]
-        )
-
-        if len(segment) < window:
-            continue
-
-        temp = pd.DataFrame({
-            "close": segment
-        })
-
-        state = build_state_vector(
-            temp,
-            direction,
-        )
-
-        if state is None:
-            continue
-
-        dist = np.linalg.norm(
-            current -
-            state
-        )
-
-        future_index = (
-            start +
-            window +
-            ENGINE_CONFIG[
-                "forward_bars"
-            ]
-        )
-
-        if (
-            future_index >=
-            len(values)
-        ):
-            continue
-
-        entry = values[
-            start + window - 1
-        ]
-
-        future = values[
-            future_index
-        ]
-
-        if entry <= 0:
-            continue
-
-        forward_return = (
-            (
-                future /
-                entry
-            ) - 1
-        ) * direction
-
-        candidates.append(
-            (
-                dist,
-                forward_return,
-            )
-        )
-
-    if not candidates:
-
-        return {
-            "score": 0.5,
-            "matches": 0,
-            "edge": 0.5,
-            "median_return": 0.0,
-        }
-
-    candidates.sort(
-        key=lambda x: x[0]
-    )
-
-    selected = candidates[
-        :ENGINE_CONFIG[
-            "similarity_k"
-        ]
-    ]
-
-    returns = np.asarray(
-        [
-            x[1]
-            for x in selected
-        ]
-    )
-
-    edge = float(
-        np.mean(
-            returns > 0
-        )
-    )
-
-    median_return = float(
-        np.median(
-            returns
-        )
-    )
-
-    score = clamp(
-        0.5 +
-        (
-            edge -
-            0.5
-        ) * 1.5
-    )
-
-    return {
-
-        "score":
-            score,
-
-        "matches":
-            len(selected),
-
-        "edge":
-            edge,
-
-        "median_return":
-            median_return,
-    }
-
-
-# ================================================================
-# 6. HISTORICAL EDGE
-# ================================================================
-
-def historical_edge(
-    df,
-    direction,
-    horizon=5,
-):
-
-    close = close_series(
-        df
-    )
-
-    if (
-        direction == 0
-        or
-        len(close) <
-        horizon + 30
-    ):
-
-        return {
-            "hit_rate": 0.5,
-            "samples": 0,
-            "returns": [],
-        }
-
-    values = close.values
-
-    outcomes = []
-
-    for i in range(
-        0,
-        len(values) -
-        horizon,
-    ):
-
-        entry = values[i]
-
-        future = values[
-            i + horizon
-        ]
-
-        if entry <= 0:
-            continue
-
-        move = (
-            future /
-            entry -
-            1
-        )
-
-        signed = (
-            move *
-            direction
-        )
-
-        outcomes.append(
-            signed
-        )
-
-    if len(outcomes) < 30:
-
-        return {
-            "hit_rate": 0.5,
-            "samples":
-                len(outcomes),
-            "returns":
-                outcomes,
-        }
-
-    hit = float(
-        np.mean(
-            np.asarray(
-                outcomes
-            ) > 0
-        )
-    )
-
-    return {
-
-        "hit_rate":
-            clamp(hit),
-
-        "samples":
-            len(outcomes),
-
-        "returns":
-            outcomes,
-    }
-
-
-# ================================================================
-# 7. MONTE CARLO
-# ================================================================
-
-def monte_carlo_engine(
-    hit_rate,
-    rr=2.0,
-):
-
-    hit_rate = clamp(
-        hit_rate,
-        0.01,
-        0.99,
-    )
-
-    iterations = ENGINE_CONFIG[
-        "mc_iterations"
-    ]
-
-    sample_size = ENGINE_CONFIG[
-        "mc_sample_size"
-    ]
-
-    rng = np.random.default_rng()
-
-    wins = (
-        rng.random(
-            (
-                iterations,
-                sample_size,
-            )
-        )
-        <
-        hit_rate
-    )
-
-    pnl = (
-        wins * rr -
-        (~wins) * 1.0
-    )
-
-    total = pnl.sum(
-        axis=1
-    )
-
-    positive_probability = float(
-        np.mean(
-            total > 0
-        )
-    )
-
-    cumulative = np.cumsum(
-        pnl,
-        axis=1,
-    )
-
-    running_max = np.maximum.accumulate(
-        cumulative,
-        axis=1,
-    )
-
-    drawdown = (
-        running_max -
-        cumulative
-    )
-
-    max_dd = np.max(
-        drawdown,
-        axis=1,
-    )
-
-    worst5 = float(
-        np.percentile(
-            total,
-            5,
-        )
-    )
-
-    median_dd = float(
-        np.median(
-            max_dd
-        )
-    )
-
-    robustness = clamp(
-        0.70 *
-        positive_probability
-        +
-        0.30 *
-        sigmoid(
-            worst5 /
-            max(
-                sample_size,
-                1
-            )
-        )
-    )
-
-    return {
-
-        "robustness":
-            robustness,
-
-        "positive_probability":
-            positive_probability,
-
-        "median_pnl":
-            float(
-                np.median(
-                    total
-                )
-            ),
-
-        "worst5":
-            worst5,
-
-        "median_max_dd":
-            median_dd,
-    }
-
-
-# ================================================================
-# 8. DYNAMIC TP / SL
-# ================================================================
-
-def optimize_tp_sl(
-    df,
-    direction,
-):
-
-    close = close_series(
-        df
-    )
-
-    if (
-        direction == 0
-        or
-        len(close) < 80
-    ):
-
-        return {
-
-            "sl_atr":
-                1.0,
-
-            "tp_atr":
-                2.0,
-
-            "expectancy":
-                0.0,
-
-            "robustness":
-                0.5,
-        }
-
-    returns = (
-        close
-        .pct_change()
-        .dropna()
-    )
-
-    volatility = safe_float(
-        returns.std(),
-        0.01,
-    )
-
-    # Approximate ATR percentage
-    atr_pct = max(
-        volatility *
-        1.5,
-        1e-5,
-    )
-
-    best = None
-
-    for sl in ENGINE_CONFIG[
-        "sl_grid"
-    ]:
-
-        for tp in ENGINE_CONFIG[
-            "tp_grid"
-        ]:
-
-            rr = tp / sl
-
-            # Historical directional edge
-            edge = historical_edge(
-                df,
-                direction,
-                horizon=5,
-            )[
-                "hit_rate"
-            ]
-
-            expectancy = (
-                edge * rr
-                -
-                (1 - edge)
-            )
-
-            # Penalize excessive TP
-            # relative to current volatility
-            tp_penalty = max(
-                0,
-                (
-                    tp *
-                    atr_pct
-                ) /
-                0.05 -
-                1
-            )
-
-            adjusted = (
-                expectancy -
-                0.10 *
-                tp_penalty
-            )
-
-            candidate = {
-
-                "sl_atr":
-                    sl,
-
-                "tp_atr":
-                    tp,
-
-                "expectancy":
-                    adjusted,
-
-                "robustness":
-                    clamp(
-                        0.5 +
-                        adjusted /
-                        2
-                    ),
-
-            }
-
-            if (
-                best is None
-                or
-                candidate[
-                    "expectancy"
-                ]
-                >
-                best[
-                    "expectancy"
-                ]
-            ):
-
-                best = candidate
-
-    return best or {
-
-        "sl_atr": 1.0,
-        "tp_atr": 2.0,
-        "expectancy": 0.0,
-        "robustness": 0.5,
-    }
-
-
-# ================================================================
-# 9. WALK-FORWARD
-# ================================================================
-
-def walk_forward_validation(
-    df,
-    direction,
-):
-
-    close = close_series(
-        df
-    )
-
-    minimum = (
-        ENGINE_CONFIG[
-            "wf_min_train"
-        ]
-        +
-        ENGINE_CONFIG[
-            "wf_test_size"
-        ]
-    )
-
-    if (
-        direction == 0
-        or
-        len(close) < minimum
-    ):
-
-        return {
-
-            "score":
-                0.5,
-
-            "expectancy":
-                0.0,
-
-            "profit_factor":
-                1.0,
-
-            "folds":
-                0,
-        }
-
-    values = close.values
-
-    train = ENGINE_CONFIG[
-        "wf_min_train"
-    ]
-
-    test = ENGINE_CONFIG[
-        "wf_test_size"
-    ]
-
-    step = ENGINE_CONFIG[
-        "wf_step"
-    ]
-
-    fold_scores = []
-    fold_returns = []
-
-    start = train
-
-    while (
-        start + test <=
-        len(values)
-    ):
-
-        train_data = values[
-            :start
-        ]
-
-        test_data = values[
-            start:
-            start + test
-        ]
-
-        if len(train_data) < 20:
-            break
-
-        train_ret = (
-            train_data[-1] /
-            train_data[-11] -
-            1
-        )
-
-        expected_direction = (
-            1
-            if train_ret > 0
-            else
-            -1
-        )
-
-        test_returns = (
-            test_data[-1] /
-            test_data[0] -
-            1
-        )
-
-        signed = (
-            test_returns *
-            direction
-        )
-
-        # Whether current direction
-        # was aligned with observed test
-        correct = (
-            1.0
-            if signed > 0
-            else
-            0.0
-        )
-
-        # Small contribution from
-        # consistency of train direction
-        consistency = (
-            1.0
-            if expected_direction ==
-            direction
-            else
-            0.5
-        )
-
-        score = (
-            0.75 *
-            correct
-            +
-            0.25 *
-            consistency
-        )
-
-        fold_scores.append(
-            score
-        )
-
-        fold_returns.append(
-            signed
-        )
-
-        start += step
-
-    if not fold_scores:
-
-        return {
-
-            "score":
-                0.5,
-
-            "expectancy":
-                0.0,
-
-            "profit_factor":
-                1.0,
-
-            "folds":
-                0,
-        }
-
-    score = float(
-        np.mean(
-            fold_scores
-        )
-    )
-
-    positive = [
-        x
-        for x in fold_returns
-        if x > 0
-    ]
-
-    negative = [
-        abs(x)
-        for x in fold_returns
-        if x < 0
-    ]
-
-    profit_factor = (
-        sum(positive) /
-        max(
-            sum(negative),
-            1e-9,
-        )
-    )
-
-    return {
-
-        "score":
-            clamp(score),
-
-        "expectancy":
-            float(
-                np.mean(
-                    fold_returns
-                )
-            ),
-
-        "profit_factor":
-            float(
-                min(
-                    profit_factor,
-                    10
-                )
-            ),
-
-        "folds":
-            len(
-                fold_scores
-            ),
-    }
-
-
-# ================================================================
-# 10. OVERFIT DETECTOR
-# ================================================================
-
-def overfit_detector(
-    df,
-    direction,
-):
-
-    close = close_series(
-        df
-    )
-
-    if (
-        direction == 0
-        or
-        len(close) < 100
-    ):
-
-        return {
-
-            "risk":
-                0.5,
-
-            "train_pf":
-                1.0,
-
-            "test_pf":
-                1.0,
-        }
-
-    values = close.values
-
-    split = int(
-        len(values) *
-        0.70
-    )
-
-    train = values[
-        :split
-    ]
-
-    test = values[
-        split:
-    ]
-
-    def pf(
-        arr
-    ):
-
-        r = (
-            arr[1:] /
-            arr[:-1] -
-            1
-        ) * direction
-
-        pos = r[
-            r > 0
-        ].sum()
-
-        neg = abs(
-            r[
-                r < 0
-            ].sum()
-        )
-
-        return float(
-            pos /
-            max(
-                neg,
-                1e-9
-            )
-        )
-
-    train_pf = pf(
-        train
-    )
-
-    test_pf = pf(
-        test
-    )
-
-    degradation = clamp(
-        (
-            train_pf -
-            test_pf
-        )
-        /
-        max(
-            abs(train_pf),
-            1e-9
-        )
-    )
-
-    risk = clamp(
-        degradation
-    )
-
-    return {
-
-        "risk":
-            risk,
-
-        "train_pf":
-            train_pf,
-
-        "test_pf":
-            test_pf,
-
-        "degradation":
-            degradation,
-    }
-
-
-# ================================================================
-# 11. NOISE ENGINE
-# ================================================================
-
-def noise_engine(
-    df,
-):
-
-    ret = returns_series(
-        df
-    )
-
-    if len(ret) < 20:
-        return 0.5
-
-    signs = np.sign(
-        ret.iloc[-80:]
-    )
-
-    alternation = float(
-        np.mean(
-            signs.iloc[1:].values
-            !=
-            signs.iloc[:-1].values
-        )
-    )
-
-    up = float(
-        np.mean(
-            signs > 0
-        )
-    )
-
-    down = float(
-        np.mean(
-            signs < 0
-        )
-    )
-
-    probs = [
-        up,
-        down,
-    ]
-
-    entropy = 0
-
-    for p in probs:
-
-        if p > 0:
-
-            entropy -= (
-                p *
-                math.log(
-                    p,
-                    2,
-                )
-            )
-
-    entropy = clamp(
-        entropy
-    )
-
-    return clamp(
-        0.55 *
-        entropy
-        +
-        0.45 *
-        alternation
-    )
-
-
-# ================================================================
-# 12. SIGNAL FRESHNESS
-# ================================================================
-
-def signal_freshness(
-    df,
-    direction,
-):
-
-    ret = returns_series(
-        df
-    )
-
-    if (
-        direction == 0
-        or
-        len(ret) < 20
-    ):
-        return 0.5
-
-    signed = (
-        ret *
-        direction
-    )
-
-    threshold = (
-        signed.std() *
-        0.75
-    )
-
-    idx = np.where(
-        signed.values >
-        threshold
-    )[0]
-
-    if len(idx) == 0:
-        return 0.5
-
-    bars_since = (
-        len(signed) -
-        1 -
-        idx[-1]
-    )
-
-    return clamp(
-        math.exp(
-            -bars_since /
-            12
-        )
-    )
-
-
-# ================================================================
-# 13. MOMENTUM
-# ================================================================
-
-def momentum_score(
-    df,
-    direction,
-):
-
-    close = close_series(
-        df
-    )
-
-    if (
-        direction == 0
-        or
-        len(close) < 30
-    ):
-        return 0.5
-
-    vals = []
-
-    for w in [
-        5,
-        10,
-        20,
-    ]:
-
-        move = (
-            close.iloc[-1] /
-            close.iloc[-w - 1] -
-            1
-        )
-
-        signed = (
-            move *
-            direction
-        )
-
-        vals.append(
-            sigmoid(
-                signed /
-                0.02
-            )
-        )
-
-    return clamp(
-        np.mean(vals)
-    )
-
-
-# ================================================================
-# 14. TREND PERSISTENCE
-# ================================================================
-
-def trend_persistence(
-    df,
-    direction,
-):
-
-    ret = returns_series(
-        df
-    )
-
-    if (
-        direction == 0
-        or
-        len(ret) < 20
-    ):
-        return 0.5
-
-    signed = (
-        ret.iloc[-40:] *
-        direction
-    )
-
-    return clamp(
-        np.mean(
-            signed > 0
-        )
-    )
-
-
-# ================================================================
-# 15. CORRELATION ENGINE
-# ================================================================
-
-def correlation_engine(
-    results,
-):
-
-    symbols = list(
-        results.keys()
-    )
-
-    if len(symbols) < 2:
-
-        return {
-            s: 0.5
-            for s in symbols
-        }
-
-    # Without raw data from every symbol,
-    # use direction concentration as a
-    # conservative portfolio correlation proxy.
-
-    long_count = sum(
-        1
-        for s in symbols
-        if results[s][
-            "direction"
-        ] == 1
-    )
-
-    short_count = sum(
-        1
-        for s in symbols
-        if results[s][
-            "direction"
-        ] == -1
-    )
-
-    n = max(
-        len(symbols),
-        1,
-    )
-
-    concentration = max(
-        long_count,
-        short_count,
-    ) / n
-
-    exposure_score = clamp(
-        1.0 -
-        concentration *
-        0.5
-    )
-
-    return {
-        s:
-            exposure_score
-        for s in symbols
-    }
-
-
-# ================================================================
-# 16. ONLINE MEMORY
-# ================================================================
-
-class OnlineMemory:
-
-    def __init__(
-        self,
-        path=None,
-    ):
-
-        self.path = (
-            path
-            or
-            ENGINE_CONFIG[
-                "memory_file"
-            ]
-        )
-
-        self.data = []
-
-        self.load()
-
-    def load(self):
-
-        if not os.path.exists(
-            self.path
-        ):
-            return
-
-        try:
-
-            with open(
-                self.path,
-                "r",
-                encoding="utf-8",
-            ) as f:
-
-                self.data = json.load(
-                    f
-                )
-
-        except Exception:
-
-            self.data = []
-
-    def save(self):
-
-        try:
-
-            with open(
-                self.path,
-                "w",
-                encoding="utf-8",
-            ) as f:
-
-                json.dump(
-                    self.data[
-                        -5000:
-                    ],
-                    f,
-                    indent=2,
-                )
-
-        except Exception as e:
-
-            logger.warning(
-                f"Memory save error: {e}"
-            )
-
-    def add(
-        self,
-        symbol,
-        direction,
-        meta_score,
-        outcome,
-        regime,
-    ):
-
-        self.data.append({
-
-            "time":
-                time.time(),
-
-            "symbol":
-                symbol,
-
-            "direction":
-                direction,
-
-            "meta_score":
-                meta_score,
-
-            "outcome":
-                outcome,
-
-            "regime":
-                regime,
-        })
-
-        self.save()
-
-    def performance(
-        self,
-        regime=None,
-    ):
-
-        rows = self.data
-
-        if regime is not None:
-
-            rows = [
-                x
-                for x in rows
-                if x.get(
-                    "regime"
-                ) == regime
-            ]
-
-        if len(rows) < 20:
-
-            return 0.5
-
-        outcomes = [
-            x.get(
-                "outcome",
-                0,
-            )
-            for x in rows[-200:]
-        ]
-
-        return clamp(
-            np.mean(
-                np.asarray(
-                    outcomes
-                ) > 0
-            )
-        )
-
-
-_MEMORY = OnlineMemory()
-
-
-# ================================================================
-# 17. META ENGINE
-# ================================================================
-
-def adaptive_meta_engine(
-    df,
-    direction,
-    regime_data,
-    volume_data,
-    scores,
-    ml_prob,
-):
-
-    # --------------------------------------------------------------
-    # Base components
-    # --------------------------------------------------------------
-
-    rule_score = clamp(
-        np.mean([
-            clamp(
-                scores.get(
-                    "regime_score",
-                    0.5
-                )
-            ),
-
-            clamp(
-                scores.get(
-                    "volume_score",
-                    0.5
-                )
-            ),
-
-            clamp(
-                scores.get(
-                    "structure_score",
-                    0.5
-                )
-            ),
-
-            clamp(
-                scores.get(
-                    "confidence_score",
-                    0.5
-                )
-            ),
-        ])
-    )
-
-    ml_score = (
-        0.5
-        if ml_prob is None
-        else clamp(
-            ml_prob
-        )
-    )
-
-    trend_score = (
-        trend_persistence(
-            df,
-            direction
-        )
-    )
-
-    momentum = momentum_score(
-        df,
-        direction,
-    )
-
-    noise = noise_engine(
-        df
-    )
-
-    freshness = signal_freshness(
-        df,
-        direction,
-    )
-
-    regime = regime_switch_engine(
-        df,
-        regime_data,
-    )
-
-    mtf = multi_timeframe_engine(
-        df,
-        direction,
-    )
-
-    orderflow = orderflow_proxy(
-        df
-    )
-
-    similarity = historical_similarity(
-        df,
-        direction,
-    )
-
-    wf = walk_forward_validation(
-        df,
-        direction,
-    )
-
-    overfit = overfit_detector(
-        df,
-        direction,
-    )
-
-    hist = historical_edge(
-        df,
-        direction,
-        ENGINE_CONFIG[
-            "forward_bars"
-        ],
-    )
-
-    mc = monte_carlo_engine(
-        hist[
-            "hit_rate"
-        ],
-        rr=2.0,
-    )
-
-    dynamic_exit = optimize_tp_sl(
-        df,
-        direction,
-    )
-
-    interactions = feature_interactions(
-        regime_data,
-        volume_data,
-        ml_prob,
-    )
-
-    memory_score = _MEMORY.performance(
-        regime.get(
-            "state"
-        )
-    )
-
-    # --------------------------------------------------------------
-    # Meta
-    # --------------------------------------------------------------
-
-    w = ENGINE_CONFIG[
-        "weights"
-    ]
-
-    components = {
-
-        "rule":
-            rule_score,
-
-        "ml":
-            ml_score,
-
-        "trend":
-            trend_score,
-
-        "momentum":
-            momentum,
-
-        "mtf":
-            mtf[
-                "agreement"
-            ],
-
-        "orderflow":
-            clamp(
-                0.5 +
-                orderflow[
-                    "imbalance"
-                ] / 2
-            ),
-
-        "similarity":
-            similarity[
-                "score"
-            ],
-
-        "walkforward":
-            wf[
-                "score"
-            ],
-
-        "stability":
-            regime[
-                "stability"
-            ],
-
-        "montecarlo":
-            mc[
-                "robustness"
-            ],
-
-        "noise":
-            1.0 - noise,
-
-        "freshness":
-            freshness,
-    }
-
-    meta = 0.0
-
-    for key, value in components.items():
-
-        meta += (
-            w[key] *
-            value
-        )
-
-    # Interaction bonus
-    meta += (
-        0.05 *
-        interactions[
-            "composite"
-        ]
-    )
-
-    # Online memory modifier
-    meta *= (
-        0.95 +
-        0.10 *
-        memory_score
-    )
-
-    # Overfitting penalty
-    meta *= (
-        1.0 -
-        0.25 *
-        overfit[
-            "risk"
-        ]
-    )
-
-    # Uncertainty
-    uncertainty = np.mean([
-        abs(
-            ml_score -
-            hist[
-                "hit_rate"
-            ]
-        ),
-
-        1.0 -
-        regime[
-            "stability"
-        ],
-
-        noise,
-
-        1.0 -
-        mtf[
-            "agreement"
-        ],
-
-        overfit[
-            "risk"
-        ],
-    ])
-
-    meta *= (
-        1.0 -
-        0.18 *
-        uncertainty
-    )
-
-    meta = clamp(
-        meta
-    )
-
-    # --------------------------------------------------------------
-    # Hard veto
-    # --------------------------------------------------------------
-
-    veto_reasons = []
-
-    if noise >= ENGINE_CONFIG[
-        "max_noise"
-    ]:
-
-        veto_reasons.append(
-            "HIGH_NOISE"
-        )
-
-    if regime[
-        "stability"
-    ] < 0.20:
-
-        veto_reasons.append(
-            "REGIME_UNSTABLE"
-        )
-
-    if (
-        hist["samples"] >=
-        ENGINE_CONFIG[
-            "min_history"
-        ]
-        and
-        hist["hit_rate"] < 0.32
-    ):
-
-        veto_reasons.append(
-            "WEAK_HISTORY"
-        )
-
-    if (
-        overfit["risk"] >
-        0.75
-    ):
-
-        veto_reasons.append(
-            "OVERFIT_RISK"
-        )
-
-    if meta < ENGINE_CONFIG[
-        "hard_threshold"
-    ]:
-
-        veto_reasons.append(
-            "LOW_META"
-        )
-
-    hard_veto = (
-        len(veto_reasons) > 0
-    )
-
-    approved = (
-        not hard_veto
-        and
-        meta >= ENGINE_CONFIG[
-            "meta_threshold"
-        ]
-    )
-
-    return {
-
-        "meta_score":
-            meta,
-
-        "approved":
-            approved,
-
-        "hard_veto":
-            hard_veto,
-
-        "veto_reasons":
-            veto_reasons,
-
-        "uncertainty":
-            uncertainty,
-
-        "components":
-            components,
-
-        "regime":
-            regime,
-
-        "mtf":
-            mtf,
-
-        "orderflow":
-            orderflow,
-
-        "similarity":
-            similarity,
-
-        "walkforward":
-            wf,
-
-        "overfit":
-            overfit,
-
-        "historical":
-            hist,
-
-        "montecarlo":
-            mc,
-
-        "dynamic_exit":
-            dynamic_exit,
-
-        "interactions":
-            interactions,
-
-        "memory_score":
-            memory_score,
-
-        "noise":
-            noise,
-
-        "freshness":
-            freshness,
-
-        "trend":
-            trend_score,
-
-        "momentum":
-            momentum,
-    }
-
-
-# ================================================================
-# 18. SINGLE SYMBOL
-# ================================================================
-
-def analyze_single(
-    symbol,
-    df,
-    account_equity,
-    consec_losses=0,
-    equity_drawdown_pct=0.0,
-    use_ml=True,
-):
-
-    # --------------------------------------------------------------
-    # Rule
-    # --------------------------------------------------------------
-
-    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
-    # --------------------------------------------------------------
-
-    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
-                )
-
-        except Exception as e:
-
-            logger.warning(
-                f"{symbol}: ML error: {e}"
-            )
-
-    # --------------------------------------------------------------
-    # Advanced engine
-    # --------------------------------------------------------------
-
-    meta = adaptive_meta_engine(
-        df,
-        direction,
-        regime_data,
-        volume_data,
-        scores,
-        ml_prob,
-    )
-
-    ml_pass = (
-        ml_approved is None
-        or
-        ml_approved
-    )
-
-    final_approved = (
-        not vetoed
-        and
-        ml_pass
-        and
-        meta[
-            "approved"
-        ]
-    )
-
-    # --------------------------------------------------------------
-    # Risk
-    # --------------------------------------------------------------
-
-    risk_data = {}
-
-    if final_approved:
-
-        risk_data = evaluate_risk(
-
-            close=float(
-                df[
-                    "close"
-                ].iloc[-1]
-            ),
-
-            atr=regime_data[
-                "atr"
-            ],
-
-            atr_pct=regime_data[
-                "atr_pct"
-            ],
-
-            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,
-        )
-
-        # Dynamic TP/SL overlay
-        exit_data = meta[
-            "dynamic_exit"
-        ]
-
-        risk_data[
-            "optimized_sl_atr"
-        ] = exit_data[
-            "sl_atr"
-        ]
-
-        risk_data[
-            "optimized_tp_atr"
-        ] = exit_data[
-            "tp_atr"
-        ]
-
-        risk_data[
-            "optimized_expectancy"
-        ] = exit_data[
-            "expectancy"
-        ]
-
-    # --------------------------------------------------------------
-    # Result
-    # --------------------------------------------------------------
-
-    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":
-            regime_data[
-                "vol_expanding"
-            ],
-
-        "dist_atr":
-            regime_data[
-                "dist_atr"
-            ],
-
-        "regime_confidence":
-            regime_data[
-                "regime_confidence"
-            ],
-
-        "breakout":
-            volume_data[
-                "breakout"
-            ],
-
-        "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"
-            ],
-
-        "meta":
-            meta,
-
-        "risk":
-            risk_data,
-    }
-
-
-# ================================================================
-# STATUS
-# ================================================================
-
-def ml_status(d):
-
-    if _TRADE_FILTER is None:
-        return "NO_MODEL"
-
-    if d[
-        "rule_vetoed"
-    ]:
-        return "RULE_VET"
-
-    if d[
-        "ml_prob"
-    ] is None:
-        return "N/A"
-
-    return (
-        f"{'✓' if d['ml_approved'] else '✗'}"
-        f"{d['ml_prob']:.3f}"
-    )
-
-
-def meta_status(d):
-
-    m = d[
-        "meta"
-    ]
-
-    prefix = (
-        "✓"
-        if m[
-            "approved"
-        ]
-        else
-        "✗"
-    )
-
-    return (
-        f"{prefix}"
-        f"{m['meta_score']:.3f}"
-    )
-
-
-# ================================================================
-# TABLE
-# ================================================================
-
-def build_ranked_table(
-    ranked,
-    top_n,
-):
-
-    header = (
-        f"{'#':>3} "
-        f"{'Symbol':<13} "
-        f"{'Score':>7} "
-        f"{'Meta':>7} "
-        f"{'ML':>7} "
-        f"{'MTF':>6} "
-        f"{'SIM':>6} "
-        f"{'WF':>6} "
-        f"{'MC':>6} "
-        f"{'Noise':>6} "
-        f"{'Stab':>6} "
-        f"{'Regime':<20} "
-        f"{'Status'}\n"
-    )
-
-    out = (
-        header +
-        "─" * 135 +
-        "\n"
-    )
-
-    for i, (
-        sym,
-        d,
-    ) in enumerate(
-        ranked[:top_n],
-        1,
-    ):
-
-        m = d[
-            "meta"
-        ]
-
-        status = (
-            "OK"
-            if d[
-                "final_approved"
-            ]
-            else
-            "RULE_VET"
-            if d[
-                "rule_vetoed"
-            ]
-            else
-            "META_VET"
-        )
-
-        out += (
-
-            f"{i:>3} "
-
-            f"{sym:<13} "
-
-            f"{d['total_score']:>7.3f} "
-
-            f"{m['meta_score']:>7.3f} "
-
-            f"{ml_status(d):>7} "
-
-            f"{m['mtf']['agreement']:>6.3f} "
-
-            f"{m['similarity']['score']:>6.3f} "
-
-            f"{m['walkforward']['score']:>6.3f} "
-
-            f"{m['montecarlo']['robustness']:>6.3f} "
-
-            f"{m['noise']:>6.3f} "
-
-            f"{m['regime']['stability']:>6.3f} "
-
-            f"{m['regime']['state']:<20} "
-
-            f"{status}\n"
-        )
-
-    return out
-
-
-# ================================================================
-# DETAIL
-# ================================================================
-
-def build_detail(
-    d,
-):
-
-    m = d[
-        "meta"
-    ]
-
-    r = d.get(
-        "risk",
-        {}
-    )
-
-    direction = _DIR_LABEL.get(
-        d[
-            "direction"
-        ],
-        "NONE",
-    )
-
-    lines = [
-
-        "═" * 72,
-
-        f"BEST SETUP: "
-        f"{d['symbol']} "
-        f"[{direction}]",
-
-        "═" * 72,
-
-        "",
-
-        "── MARKET ──────────────────────────────────────────",
-
-        f"Price:             {d['close']:.8f}",
-
-        f"Trend:             {d['trend']}",
-
-        f"ADX:               {d['adx']:.2f}",
-
-        f"DI+:               {d['di_plus']:.2f}",
-
-        f"DI-:               {d['di_minus']:.2f}",
-
-        f"Volume ratio:      {d['vol_ratio']:.3f}",
-
-        "",
-
-        "── REGIME ─────────────────────────────────────────",
-
-        f"State:             "
-        f"{m['regime']['state']}",
-
-        f"Stability:         "
-        f"{m['regime']['stability']:.4f}",
-
-        f"Transition risk:   "
-        f"{m['regime']['transition_risk']:.4f}",
-
-        f"Volatility state:  "
-        f"{m['regime']['volatility_state']}",
-
-        "",
-
-        "── MULTI-TIMEFRAME ───────────────────────────────",
-
-        f"Agreement:         "
-        f"{m['mtf']['agreement']:.4f}",
-
-    ]
-
-    for tf, x in m[
-        "mtf"
-    ][
-        "timeframes"
-    ].items():
-
-        lines.append(
-            f"{tf:<18}"
-            f"{x['direction']:>3} "
-            f"strength={x['strength']:.3f}"
-        )
-
-    lines += [
-
-        "",
-
-        "── MACHINE LEARNING ──────────────────────────────",
-
-        f"Raw probability:   "
-        f"{d['ml_prob'] if d['ml_prob'] is not None else 'N/A'}",
-
-        "",
-
-        "── HISTORICAL SIMILARITY ─────────────────────────",
-
-        f"Matches:           "
-        f"{m['similarity']['matches']}",
-
-        f"Similarity score:  "
-        f"{m['similarity']['score']:.4f}",
-
-        f"Directional edge:  "
-        f"{m['similarity']['edge']:.4f}",
-
-        f"Median return:     "
-        f"{m['similarity']['median_return']:.5f}",
-
-        "",
-
-        "── ORDER FLOW PROXY ──────────────────────────────",
-
-        f"Buy pressure:      "
-        f"{m['orderflow']['buy_pressure']:.4f}",
-
-        f"Sell pressure:     "
-        f"{m['orderflow']['sell_pressure']:.4f}",
-
-        f"Imbalance:         "
-        f"{m['orderflow']['imbalance']:.4f}",
-
-        f"Absorption:        "
-        f"{m['orderflow']['absorption']:.4f}",
-
-        f"Breakout quality:  "
-        f"{m['orderflow']['breakout_quality']:.4f}",
-
-        "",
-
-        "── WALK FORWARD ──────────────────────────────────",
-
-        f"Score:             "
-        f"{m['walkforward']['score']:.4f}",
-
-        f"Expectancy:        "
-        f"{m['walkforward']['expectancy']:.5f}",
-
-        f"Profit factor:     "
-        f"{m['walkforward']['profit_factor']:.3f}",
-
-        f"Folds:             "
-        f"{m['walkforward']['folds']}",
-
-        "",
-
-        "── OVERFIT DETECTOR ──────────────────────────────",
-
-        f"Train PF:          "
-        f"{m['overfit']['train_pf']:.3f}",
-
-        f"Test PF:           "
-        f"{m['overfit']['test_pf']:.3f}",
-
-        f"Degradation:       "
-        f"{m['overfit']['degradation']:.3f}",
-
-        f"Overfit risk:      "
-        f"{m['overfit']['risk']:.3f}",
-
-        "",
-
-        "── MONTE CARLO ──────────────────────────────────",
-
-        f"Iterations:        "
-        f"{ENGINE_CONFIG['mc_iterations']:,}",
-
-        f"P(positive):       "
-        f"{m['montecarlo']['positive_probability']:.4f}",
-
-        f"Robustness:        "
-        f"{m['montecarlo']['robustness']:.4f}",
-
-        f"Median PnL:        "
-        f"{m['montecarlo']['median_pnl']:.2f}R",
-
-        f"Worst 5%:          "
-        f"{m['montecarlo']['worst5']:.2f}R",
-
-        f"Median MaxDD:      "
-        f"{m['montecarlo']['median_max_dd']:.2f}R",
-
-        "",
-
-        "── DYNAMIC EXIT ──────────────────────────────────",
-
-        f"SL:                "
-        f"{m['dynamic_exit']['sl_atr']:.2f} ATR",
-
-        f"TP:                "
-        f"{m['dynamic_exit']['tp_atr']:.2f} ATR",
-
-        f"Expected R:        "
-        f"{m['dynamic_exit']['expectancy']:.4f}",
-
-        "",
-
-        "── ADAPTIVE META ─────────────────────────────────",
-
-        f"Rule:              "
-        f"{m['components']['rule']:.4f}",
-
-        f"ML:                "
-        f"{m['components']['ml']:.4f}",
-
-        f"Trend:             "
-        f"{m['components']['trend']:.4f}",
-
-        f"Momentum:          "
-        f"{m['components']['momentum']:.4f}",
-
-        f"MTF:               "
-        f"{m['components']['mtf']:.4f}",
-
-        f"Order Flow:        "
-        f"{m['components']['orderflow']:.4f}",
-
-        f"Similarity:        "
-        f"{m['components']['similarity']:.4f}",
-
-        f"Walk Forward:      "
-        f"{m['components']['walkforward']:.4f}",
-
-        f"Stability:         "
-        f"{m['components']['stability']:.4f}",
-
-        f"Monte Carlo:       "
-        f"{m['components']['montecarlo']:.4f}",
-
-        f"Noise:             "
-        f"{m['noise']:.4f}",
-
-        f"Freshness:         "
-        f"{m['freshness']:.4f}",
-
-        "",
-
-        "═══════════════════════════════════════════════���══",
-
-        f"META SCORE:        "
-        f"{m['meta_score']:.4f}",
-
-        f"UNCERTAINTY:       "
-        f"{m['uncertainty']:.4f}",
-
-        f"MEMORY SCORE:      "
-        f"{m['memory_score']:.4f}",
-
-    ]
-
-    if m[
-        "veto_reasons"
-    ]:
-
-        lines.append(
-            "META VETO: "
-            +
-            ", ".join(
-                m[
-                    "veto_reasons"
-                ]
-            )
-        )
-
-    lines.append(
-        "══════════════════════════════════════════════════"
-    )
-
-    if r:
-
-        lines += [
-
-            "",
-
-            "── RISK ───────────────────────────────────────────",
-
-            f"Entry:             "
-            f"{r.get('entry_price', 0):.8f}",
-
-            f"ATR:               "
-            f"{r.get('atr', 0):.8f}",
-
-            f"Risk fraction:     "
-            f"{r.get('risk_fraction', 0):.4f}%",
-
-            f"$ at risk:         "
-            f"${r.get('dollar_at_risk', 0):.2f}",
-
-            f"Position notional: "
-            f"${r.get('position_notional', 0):.2f}",
-
-            f"Leverage:          "
-            f"{r.get('leverage_implied', 0):.2f}x",
-
-            f"Optimized SL:      "
-            f"{r.get('optimized_sl_atr', 0):.2f} ATR",
-
-            f"Optimized TP:      "
-            f"{r.get('optimized_tp_atr', 0):.2f} ATR",
-
-        ]
-
-    return "\n".join(
-        lines
-    )
-
-
-# ================================================================
-# SYMBOL PARSER
-# ================================================================
-
-def parse_symbols(
-    raw,
-):
-
-    result = []
-
-    for token in (
-        raw
-        .replace(",", " ")
-        .replace("\n", " ")
-        .split()
-    ):
-
-        token = token.strip().upper()
-
-        if not token:
-            continue
-
-        result.append(
-            token
-            if "-"
-            in token
-            else
-            f"{token}-USDT"
-        )
-
-    return (
-        result
-        or
-        DEFAULT_SYMBOLS
-    )
-
-
-# ================================================================
-# MAIN ANALYSIS
-# ================================================================
-
-def run_analysis(
-    symbols_input,
-    equity,
-    consec_losses,
-    drawdown_pct,
-    top_n,
-    use_live,
-    use_ml,
-    progress=gr.Progress(
-        track_tqdm=False
-    ),
-):
-
-    t0 = time.time()
-
-    output = []
-
-    output += [
-
-        "━" * 78,
-
-        "  OKX QUANT ENGINE v5",
-
-        "  ADAPTIVE MULTI-LAYER RESEARCH ENGINE",
-
-        "━" * 78,
-
-    ]
-
-    # --------------------------------------------------------------
-    # Symbols
-    # --------------------------------------------------------------
-
-    if use_live:
-
-        output.append(
-            "⟳ Fetching live OKX instruments..."
-        )
-
-        symbols = (
-            fetch_instruments(
-                "SPOT"
-            )
-            or
-            DEFAULT_SYMBOLS
-        )
-
-    else:
-
-        symbols = parse_symbols(
-            symbols_input
-        )
-
-    output.append(
-        f"✓ Symbols: {len(symbols)}"
-    )
-
-    output.append(
-        f"✓ Timeframe: {TIMEFRAME}"
-    )
-
-    output.append(
-        f"✓ Equity: ${equity:,.0f}"
-    )
-
-    output.append("")
-
-    # --------------------------------------------------------------
-    # Data
-    # --------------------------------------------------------------
-
-    def callback(
-        i,
-        total,
-        symbol,
-    ):
-
-        progress(
-            i /
-            max(total, 1),
-            desc=
-                f"Fetching {symbol}"
-        )
-
-    data = fetch_multiple(
-        symbols,
-        min_bars=100,
-        progress_callback=
-            callback,
-    )
-
-    output.append(
-        f"✓ Fetched "
-        f"{len(data)}/{len(symbols)}"
-    )
-
-    output.append("")
-
-    # --------------------------------------------------------------
-    # Analyze
-    # --------------------------------------------------------------
-
-    results = {}
-
-    errors = []
-
-    for symbol, df in (
-        data.items()
-    ):
-
-        try:
-
-            results[
-                symbol
-            ] = analyze_single(
-
-                symbol,
-
-                df,
-
-                account_equity=
-                    equity,
-
-                consec_losses=
-                    int(
-                        consec_losses
-                    ),
-
-                equity_drawdown_pct=
-                    drawdown_pct /
-                    100.0,
-
-                use_ml=
-                    use_ml,
-            )
-
-        except Exception as e:
-
-            logger.error(
-                f"{symbol}: {e}",
-                exc_info=True,
-            )
-
-            errors.append(
-                symbol
-            )
-
-    if errors:
-
-        output.append(
-            "Errors: "
-            +
-            ", ".join(
-                errors
-            )
-        )
-
-    # --------------------------------------------------------------
-    # Correlation
-    # --------------------------------------------------------------
-
-    correlation = (
-        correlation_engine(
-            results
-        )
-    )
-
-    for symbol in results:
-
-        results[
-            symbol
-        ][
-            "portfolio_score"
-        ] = correlation.get(
-            symbol,
-            0.5,
-        )
-
-        # Slight portfolio concentration penalty
-        results[
-            symbol
-        ][
-            "meta"
-        ][
-            "meta_score"
-        ] = clamp(
-            results[
-                symbol
-            ][
-                "meta"
-            ][
-                "meta_score"
-            ]
-            *
-            (
-                0.90 +
-                0.10 *
-                correlation.get(
-                    symbol,
-                    0.5,
-                )
-            )
-        )
-
-        # Re-evaluate final decision
-        m = results[
-            symbol
-        ][
-            "meta"
-        ]
-
-        results[
-            symbol
-        ][
-            "final_approved"
-        ] = (
-            results[
-                symbol
-            ][
-                "final_approved"
-            ]
-            and
-            m[
-                "meta_score"
-            ]
-            >=
-            ENGINE_CONFIG[
-                "meta_threshold"
-            ]
-        )
-
-    # --------------------------------------------------------------
-    # Ranking
-    # --------------------------------------------------------------
-
-    ranked = rank_tokens(
-        results
-    )
-
-    approved = [
-        x
-        for x in ranked
-        if x[1][
-            "final_approved"
-        ]
-    ]
-
-    rule_veto = sum(
-        1
-        for _, d in ranked
-        if d[
-            "rule_vetoed"
-        ]
-    )
-
-    meta_veto = sum(
-        1
-        for _, d in ranked
-        if (
-            not d[
-                "rule_vetoed"
-            ]
-            and
-            d[
-                "meta"
-            ][
-                "hard_veto"
-            ]
-        )
-    )
-
-    # --------------------------------------------------------------
-    # Output
-    # --------------------------------------------------------------
-
-    output += [
-
-        "",
-
-        f"Analyzed: {len(results)}",
-
-        f"Approved: {len(approved)}",
-
-        f"Rule veto: {rule_veto}",
-
-        f"Meta veto: {meta_veto}",
-
-        "",
-
-        "RANKED SETUPS",
-
-        "─" * 135,
-
-        build_ranked_table(
-            ranked,
-            int(top_n),
-        ),
-
-    ]
-
-    # --------------------------------------------------------------
-    # Best
-    # --------------------------------------------------------------
-
-    if approved:
-
-        best_symbol, best = (
-            approved[0]
-        )
-
-        output += [
-
-            "",
-
-            build_detail(
-                best
-            ),
-
-        ]
-
-    else:
-
-        output += [
-
-            "",
-
-            "⚠ NO FULLY APPROVED SETUP",
-
-            "",
-
-            "The engine rejected the available setups",
-            "after combining rule, ML, historical,",
-            "walk-forward, regime, noise and robustness",
-            "conditions.",
-
-        ]
-
-    # --------------------------------------------------------------
-    # Footer
-    # --------------------------------------------------------------
-
-    output += [
-
-        "",
-
-        f"Completed in "
-        f"{time.time() - t0:.2f}s",
-
-        "━" * 78,
-
-        "Research use only. Not financial advice.",
-
-    ]
-
-    return "\n".join(
-        output
-    )
-
-
-# ================================================================
-# GRADIO
-# ================================================================
-
-def build_app():
-
-    with gr.Blocks(
-
-        title=
-            "OKX Quant Engine v5",
-
-        theme=
-            gr.themes.Base(
-                primary_hue=
-                    "slate",
-                neutral_hue=
-                    "zinc",
-                font=[
-                    gr.themes.GoogleFont(
-                        "JetBrains Mono"
-                    ),
-                    "monospace",
-                ],
-            ),
-
-        css="""
-
-        body,
-        .gradio-container {
-
-            background:
-                #060a10 !important;
-
-            font-family:
-                'JetBrains Mono',
-                monospace !important;
-
-            max-width:
-                1450px !important;
-        }
-
-        .gr-button-primary {
-
-            background:
-                linear-gradient(
-                    90deg,
-                    #1a6bff,
-                    #0044cc
-                ) !important;
-
-            border:
-                none !important;
-
-            font-weight:
-                700 !important;
-        }
-
-        #output_box textarea {
-
-            font-family:
-                'JetBrains Mono',
-                monospace !important;
-
-            font-size:
-                12px !important;
-
-            line-height:
-                1.55 !important;
-
-            background:
-                #0a0e18 !important;
-
-            color:
-                #b0c4de !important;
-
-            border:
-                1px solid #182030 !important;
-
-            min-height:
-                900px !important;
-        }
-
-        """,
-
-    ) as app:
-
-        gr.Markdown(
-            "# ◈ OKX QUANT ENGINE v5"
-        )
-
-        gr.Markdown(
-            """
-**Multi-Regime · Multi-Timeframe · ML · Similarity ·
-Walk-Forward · Overfit Detection · Order-Flow Proxy ·
-Monte Carlo · Dynamic TP/SL · Adaptive Meta Engine**
-"""
-        )
-
-        with gr.Row():
-
-            with gr.Column(
-                scale=2
-            ):
-
-                symbols = gr.Textbox(
-
-                    label=
-                        "Symbols",
-
-                    placeholder=
-                        "BTC-USDT, ETH-USDT, SOL-USDT",
-
-                    lines=4,
-                )
-
-            with gr.Column(
-                scale=1
-            ):
-
-                equity = gr.Slider(
-
-                    label=
-                        "Account Equity",
-
-                    minimum=100,
-
-                    maximum=1_000_000,
-
-                    step=500,
-
-                    value=
-                        DEFAULT_ACCOUNT_EQUITY,
-                )
-
-                top_n = gr.Slider(
-
-                    label=
-                        "Top N",
-
-                    minimum=5,
-
-                    maximum=100,
-
-                    step=5,
-
-                    value=
-                        TOP_N_DEFAULT,
-                )
-
-            with gr.Column(
-                scale=1
-            ):
-
-                losses = gr.Slider(
-
-                    label=
-                        "Consecutive Losses",
-
-                    minimum=0,
-
-                    maximum=10,
-
-                    step=1,
-
-                    value=0,
-                )
-
-                dd = gr.Slider(
-
-                    label=
-                        "Drawdown %",
-
-                    minimum=0,
-
-                    maximum=30,
-
-                    step=0.5,
-
-                    value=0,
-                )
-
-                live = gr.Checkbox(
-
-                    label=
-                        "Live OKX Instruments",
-
-                    value=False,
-                )
-
-                ml = gr.Checkbox(
-
-                    label=
-                        "ML Filter",
-
-                    value=(
-                        _TRADE_FILTER
-                        is not None
-                    ),
-                )
-
-        gr.Markdown(
-            f"""
-### Engine Configuration
-
-Meta threshold: **{ENGINE_CONFIG['meta_threshold']:.2f}**
-
-Monte Carlo simulations: **{ENGINE_CONFIG['mc_iterations']:,}**
-
-Similarity matches: **{ENGINE_CONFIG['similarity_k']}**
-
-Walk-forward validation: **ON**
-
-Overfit detection: **ON**
-
-Dynamic TP/SL: **ON**
-
-Online performance memory: **ON**
-"""
-        )
-
-        button = gr.Button(
-            "▶ RUN QUANT ENGINE",
-            variant=
-                "primary",
-            size=
-                "lg",
-        )
-
-        output = gr.Textbox(
-
-            label=
-                "Engine Output",
-
-            lines=60,
-
-            max_lines=200,
-
-            interactive=False,
-
-            elem_id=
-                "output_box",
-        )
-
-        button.click(
-
-            fn=
-                run_analysis,
-
-            inputs=[
-                symbols,
-                equity,
-                losses,
-                dd,
-                top_n,
-                live,
-                ml,
-            ],
-
-            outputs=
-                output,
-        )
-
-        gr.Markdown(
-            """
-**Research use only.**
-
-Bu sistem istatistiksel/algoritmik araştırma yapar.
-Hiçbir skor veya Monte Carlo sonucu gelecekteki getiriyi garanti etmez.
-"""
-        )
-
-    return app
-
-
-# ================================================================
-# ENTRY
-# ================================================================
-
-if __name__ == "__main__":
-
-    import argparse
-
-    parser = argparse.ArgumentParser()
-
-    parser.add_argument(
-        "--port",
-        type=int,
-        default=7860,
-    )
-
-    parser.add_argument(
-        "--share",
-        action="store_true",
-    )
-
-    args = parser.parse_args()
-
-    build_app().launch(
-
-        server_name=
-            "0.0.0.0",
-
-        server_port=
-            args.port,
-
-        share=
-            args.share,
-
-        show_error=True,
-    )