Update app.py

app.py

@@ -1,1794 +1,1156 @@
+"""
+RCEA Lite v1.0 — Regime-Conditioned Evidence Accumulation
+Mathematical trading system with causal HMM regime detection.
 
-import warnings
-warnings.filterwarnings("ignore")
-
-import time
-import numpy as np
-import pandas as pd
-import ccxt
-import gradio as gr
-import optuna
-
-from hmmlearn.hmm import GaussianHMM
-from sklearn.preprocessing import StandardScaler
-
-
-# ============================================================
-# CONFIG
-# ============================================================
-
-SYMBOL = "BTC/USDT:USDT"
-TIMEFRAME = "1h"
-TIMEFRAME_MS = 60 * 60 * 1000
-
-MACRO_FEATURES = [
-    "log_return",
-    "realized_volatility",
-    "range_return"
-]
-
-MICRO_FEATURES = [
-    "return_zscore",
-    "autocorrelation",
-    "volume_zscore"
-]
-
-N_MACRO = 3
-N_MICRO = 2
-N_JOINT = N_MACRO * N_MICRO
-
-MIN_TRAIN_ROWS = 300
-MIN_RELIABLE_TRADES = 30
-
-
-# ============================================================
-# OKX DATA
-# ============================================================
-
-def fetch_data(candle_count):
-
-    exchange = ccxt.okx({
-        "enableRateLimit": True,
-        "timeout": 30000,
-        "options": {
-            "defaultType": "swap"
-        }
-    })
-
-    exchange.load_markets()
-
-    if SYMBOL not in exchange.markets:
-        raise ValueError(
-            f"{SYMBOL} OKX piyasasında bulunamadı."
-        )
-
-    now = exchange.milliseconds()
-
-    cursor = now - (
-        int(candle_count) + 30
-    ) * TIMEFRAME_MS
-
-    candles = []
-
-    for _ in range(60):
-
-        batch = exchange.fetch_ohlcv(
-            SYMBOL,
-            timeframe=TIMEFRAME,
-            since=cursor,
-            limit=100
-        )
-
-        if not batch:
-            break
-
-        candles.extend(batch)
-
-        last_timestamp = batch[-1][0]
-
-        if last_timestamp < cursor:
-            break
-
-        cursor = last_timestamp + TIMEFRAME_MS
-
-        if len(candles) >= candle_count + 100:
-            break
-
-        if last_timestamp >= now - TIMEFRAME_MS:
-            break
-
-        time.sleep(
-            exchange.rateLimit / 1000
-        )
-
-    if not candles:
-        raise ValueError("OKX veri döndürmedi.")
-
-    df = pd.DataFrame(
-        candles,
-        columns=[
-            "timestamp",
-            "open",
-            "high",
-            "low",
-            "close",
-            "volume"
-        ]
-    )
-
-    df = (
-        df.drop_duplicates("timestamp")
-        .sort_values("timestamp")
-        .reset_index(drop=True)
-    )
-
-    now = exchange.milliseconds()
-
-    # Yalnızca kapanmış mumlar
-    df = df[
-        df["timestamp"] + TIMEFRAME_MS <= now
-    ].copy()
-
-    for col in [
-        "open", "high", "low", "close", "volume"
-    ]:
-        df[col] = pd.to_numeric(
-            df[col],
-            errors="coerce"
-        )
-
-    df = df.replace(
-        [np.inf, -np.inf],
-        np.nan
-    ).dropna()
-
-    df = df[
-        (df["close"] > 0) &
-        (df["high"] >= df["low"]) &
-        (df["low"] > 0)
-    ]
-
-    df = df.tail(
-        int(candle_count)
-    ).reset_index(drop=True)
-
-    if len(df) < 500:
-        raise ValueError(
-            f"Yeterli veri yok: {len(df)} mum."
-        )
-
-    df["raw_i"] = np.arange(len(df))
-
-    return df
-
-
-# ============================================================
-# CAUSAL MATHEMATICAL FEATURES
-# ============================================================
-
-def create_features(raw):
-
-    df = raw.copy()
-
-    log_close = np.log(df["close"])
-
-    returns = log_close.diff()
-
-    # Macro layer
-    df["log_return"] = returns
-
-    df["realized_volatility"] = (
-        returns.rolling(24).std()
-    )
-
-    df["range_return"] = np.log(
-        df["high"] / df["low"]
-    )
-
-    # Micro layer
-    rolling_mean = returns.rolling(48).mean()
-
-    rolling_std = returns.rolling(48).std()
-
-    df["return_zscore"] = (
-        (returns - rolling_mean) /
-        rolling_std.replace(0, np.nan)
-    )
-
-    df["autocorrelation"] = (
-        returns.rolling(48).corr(
-            returns.shift(1)
-        )
-    )
-
-    log_volume = np.log1p(
-        df["volume"].clip(lower=0)
-    )
-
-    volume_mean = log_volume.rolling(48).mean()
-
-    volume_std = log_volume.rolling(48).std()
-
-    df["volume_zscore"] = (
-        (log_volume - volume_mean) /
-        volume_std.replace(0, np.nan)
-    )
-
-    df = df.replace(
-        [np.inf, -np.inf],
-        np.nan
-    )
-
-    return df
-
-
-# ============================================================
-# DATASET
-# ============================================================
-
-def prepare_dataset(raw, horizon):
-
-    df = create_features(raw)
-
-    required = (
-        MACRO_FEATURES +
-        MICRO_FEATURES
-    )
-
-    live = df.dropna(
-        subset=required
-    ).copy()
-
-    future_close = live["close"].shift(
-        -int(horizon)
-    )
-
-    live["target"] = np.where(
-        future_close.notna(),
-        (
-            future_close > live["close"]
-        ).astype(float),
-        np.nan
-    )
-
-    dataset = live.dropna(
-        subset=["target"]
-    ).copy()
-
-    dataset = dataset.reset_index(drop=True)
-
-    live = live.reset_index(drop=True)
-
-    if len(dataset) < MIN_TRAIN_ROWS:
-        raise ValueError(
-            f"Yeterli eğitim verisi yok: {len(dataset)}"
-        )
-
-    return dataset, live
-
-
-# ============================================================
-# GAUSSIAN HMM FORWARD FILTER
-# ============================================================
-
-def forward_filter(
-    model,
-    X_scaled,
-    initial_alpha=None
-):
-
-    means = model.means_
-
-    covars = np.asarray(
-        model.covars_
-    )
-
-    if covars.ndim == 3:
-
-        variances = np.diagonal(
-            covars,
-            axis1=1,
-            axis2=2
-        )
-
-    else:
-
-        variances = covars
-
-    variances = np.maximum(
-        variances,
-        1e-8
-    )
-
-    n_states = model.n_components
-
-    n_features = X_scaled.shape[1]
-
-    log_emissions = np.zeros(
-        (len(X_scaled), n_states)
-    )
-
-    # Gaussian emission likelihood
-    for state in range(n_states):
-
-        diff = (
-            X_scaled - means[state]
-        )
-
-        log_emissions[:, state] = -0.5 * (
-            n_features * np.log(2 * np.pi)
-            + np.sum(
-                np.log(variances[state])
-            )
-            + np.sum(
-                diff ** 2 / variances[state],
-                axis=1
-            )
-        )
-
-    transition = model.transmat_
-
-    if initial_alpha is None:
-
-        alpha = model.startprob_.copy()
-
-        first_observation = 0
-
-    else:
-
-        alpha = np.asarray(
-            initial_alpha,
-            dtype=float
-        ).copy()
-
-        first_observation = 0
-
-    posterior = []
-
-    for i in range(len(X_scaled)):
-
-        if i > 0 or initial_alpha is not None:
-
-            alpha = alpha @ transition
-
-        log_alpha = (
-            np.log(
-                np.maximum(alpha, 1e-300)
-            )
-            + log_emissions[i]
-        )
-
-        log_alpha -= np.max(log_alpha)
-
-        alpha = np.exp(log_alpha)
-
-        total = alpha.sum()
-
-        if (
-            total <= 0
-            or not np.isfinite(total)
-        ):
-
-            alpha = (
-                np.ones(n_states) / n_states
-            )
-
-        else:
-
-            alpha /= total
-
-        posterior.append(
-            alpha.copy()
-        )
-
-    posterior = np.asarray(posterior)
-
-    return posterior, alpha.copy()
-
-
-# ============================================================
-# HMM LAYER
-# ============================================================
-
-class HMMLayer:
-
-    def __init__(
-        self,
-        n_states,
-        random_state=42
-    ):
-
-        self.n_states = n_states
-
-        self.scaler = StandardScaler()
-
-        self.model = GaussianHMM(
-            n_components=n_states,
-            covariance_type="diag",
-            n_iter=150,
-            tol=0.001,
-            min_covar=1e-4,
-            random_state=random_state
-        )
-
-        self.fitted = False
-
-    def fit(self, X):
-
-        X = np.asarray(
-            X,
-            dtype=float
-        )
-
-        X_scaled = self.scaler.fit_transform(
-            X
-        )
-
-        self.model.fit(X_scaled)
-
-        self.fitted = True
-
-        return self
-
-    def filter(
-        self,
-        X,
-        initial_alpha=None
-    ):
-
-        if not self.fitted:
-            raise RuntimeError(
-                "HMM katmanı eğitilmedi."
-            )
-
-        X = np.asarray(
-            X,
-            dtype=float
-        )
-
-        X_scaled = self.scaler.transform(
-            X
-        )
-
-        return forward_filter(
-            self.model,
-            X_scaled,
-            initial_alpha
-        )
-
-
-# ============================================================
-# HIERARCHICAL HMM
-# ============================================================
-
-class HierarchicalHMM:
-
-    def __init__(self):
-
-        self.macro = HMMLayer(
-            N_MACRO,
-            random_state=42
-        )
-
-        self.micro = HMMLayer(
-            N_MICRO,
-            random_state=73
-        )
-
-        self.compatibility = None
-
-    def fit(self, train_df):
-
-        macro_X = train_df[
-            MACRO_FEATURES
-        ].values
-
-        micro_X = train_df[
-            MICRO_FEATURES
-        ].values
-
-        self.macro.fit(macro_X)
-
-        self.micro.fit(micro_X)
-
-        macro_post, self.last_macro = (
-            self.macro.filter(macro_X)
-        )
-
-        micro_post, self.last_micro = (
-            self.micro.filter(micro_X)
-        )
-
-        # Macro-micro compatibility matrix.
-        # Estimated only from training observations.
-        compatibility = np.zeros(
-            (N_MACRO, N_MICRO)
-        )
-
-        for m in range(N_MACRO):
-
-            for u in range(N_MICRO):
-
-                compatibility[m, u] = (
-                    np.sum(
-                        macro_post[:, m]
-                        * micro_post[:, u]
-                    )
-                    + 0.5
-                )
-
-        compatibility /= (
-            compatibility.sum(
-                axis=1,
-                keepdims=True
-            )
-        )
-
-        self.compatibility = compatibility
-
-        train_joint = self.combine(
-            macro_post,
-            micro_post
-        )
-
-        return train_joint
-
-    def combine(
-        self,
-        macro_post,
-        micro_post
-    ):
-
-        joint = np.zeros(
-            (
-                len(macro_post),
-                N_MACRO,
-                N_MICRO
-            )
-        )
-
-        for m in range(N_MACRO):
-
-            weighted_micro = (
-                micro_post *
-                self.compatibility[m]
-            )
-
-            denominator = (
-                weighted_micro.sum(
-                    axis=1,
-                    keepdims=True
-                )
-            )
-
-            conditional_micro = (
-                weighted_micro /
-                np.maximum(
-                    denominator,
-                    1e-12
-                )
-            )
-
-            joint[:, m, :] = (
-                macro_post[:, m, None]
-                * conditional_micro
-            )
-
-        joint = joint.reshape(
-            len(joint),
-            N_JOINT
-        )
-
-        joint /= np.maximum(
-            joint.sum(axis=1, keepdims=True),
-            1e-12
-        )
-
-        return joint
-
-    def predict_future(self, future_df):
-
-        macro_X = future_df[
-            MACRO_FEATURES
-        ].values
-
-        micro_X = future_df[
-            MICRO_FEATURES
-        ].values
-
-        macro_post, last_macro = (
-            self.macro.filter(
-                macro_X,
-                initial_alpha=self.last_macro
-            )
-        )
-
-        micro_post, last_micro = (
-            self.micro.filter(
-                micro_X,
-                initial_alpha=self.last_micro
-            )
-        )
-
-        joint = self.combine(
-            macro_post,
-            micro_post
-        )
-
-        self.last_macro = last_macro
-
-        self.last_micro = last_micro
-
-        return joint
-
-
-# ============================================================
-# BAYESIAN REGIME MODEL
-# ============================================================
-
-class BayesianRegimeModel:
-
-    def __init__(self):
-
-        self.prior_alpha = 2.0
-
-        self.prior_beta = 2.0
-
-        self.state_probabilities = None
-
-    def fit(
-        self,
-        joint_posterior,
-        targets
-    ):
-
-        targets = np.asarray(
-            targets,
-            dtype=float
-        )
-
-        probabilities = []
-
-        for state in range(N_JOINT):
-
-            weights = joint_posterior[:, state]
-
-            positive = np.sum(
-                weights * targets
-            )
-
-            negative = np.sum(
-                weights * (1 - targets)
-            )
-
-            posterior_up = (
-                self.prior_alpha + positive
-            ) / (
-                self.prior_alpha
-                + self.prior_beta
-                + positive
-                + negative
-            )
-
-            probabilities.append(
-                posterior_up
-            )
-
-        self.state_probabilities = np.asarray(
-            probabilities
-        )
-
-        return self
-
-    def predict(self, joint_posterior):
-
-        return (
-            joint_posterior
-            @ self.state_probabilities
-        )
-
-
-# ============================================================
-# COMPLETE MODEL FIT
-# ============================================================
-
-def fit_predict(
-    train_df,
-    future_df
-):
-
-    if len(train_df) < MIN_TRAIN_ROWS:
-        raise ValueError(
-            "HMM eğitimi için yeterli veri yok."
-        )
-
-    hierarchy = HierarchicalHMM()
-
-    train_joint = hierarchy.fit(
-        train_df
-    )
-
-    bayesian = BayesianRegimeModel()
-
-    bayesian.fit(
-        train_joint,
-        train_df["target"].values
-    )
-
-    future_joint = hierarchy.predict_future(
-        future_df
-    )
-
-    probabilities = bayesian.predict(
-        future_joint
-    )
-
-    return {
-        "probabilities": probabilities,
-        "joint": future_joint,
-        "macro_micro_compatibility": hierarchy.compatibility,
-        "state_probabilities": bayesian.state_probabilities,
-        "hierarchy": hierarchy
-    }
-
-
-# ============================================================
-# BACKTEST ENGINE
-# ============================================================
-
-def simulate_trades(
-    raw,
-    dataset,
-    indices,
-    probabilities,
-    threshold,
-    stop_multiplier,
-    horizon,
-    fee_rate,
-    slippage_bps
-):
-
-    trades = []
-
-    if len(indices) == 0:
-        return trades
-
-    last_raw_i = int(
-        dataset.iloc[indices[-1]]["raw_i"]
-    )
-
-    cost = (
-        2 * fee_rate
-        + 2 * slippage_bps / 10000
-    )
-
-    last_exit_i = -1
-
-    for row_i, probability in zip(
-        indices,
-        probabilities
-    ):
-
-        row = dataset.iloc[row_i]
-
-        signal_raw_i = int(
-            row["raw_i"]
-        )
-
-        entry_i = signal_raw_i + 1
-
-        exit_limit = (
-            entry_i + int(horizon) - 1
-        )
-
-        if exit_limit > last_raw_i:
-            continue
-
-        if exit_limit >= len(raw):
-            continue
-
-        if entry_i <= last_exit_i:
-            continue
-
-        if probability >= threshold:
-
-            direction = 1
-
-        elif probability <= 1 - threshold:
-
-            direction = -1
-
-        else:
-
-            continue
-
-        entry_price = float(
-            raw.iloc[entry_i]["open"]
-        )
-
-        volatility = float(
-            row["realized_volatility"]
-        )
-
-        if (
-            not np.isfinite(volatility)
-            or volatility <= 0
-        ):
-            continue
-
-        risk_pct = np.clip(
-            volatility
-            * np.sqrt(horizon)
-            * stop_multiplier,
-            0.002,
-            0.05
-        )
-
-        distance = (
-            entry_price * risk_pct
-        )
-
-        if direction == 1:
-
-            stop = entry_price - distance
-
-            target = entry_price + 2 * distance
-
-        else:
-
-            stop = entry_price + distance
-
-            target = entry_price - 2 * distance
-
-        exit_price = None
-
-        reason = "TIME"
-
-        for j in range(
-            entry_i,
-            exit_limit + 1
-        ):
-
-            candle = raw.iloc[j]
-
-            high = float(candle["high"])
-
-            low = float(candle["low"])
-
-            if direction == 1:
-
-                hit_stop = low <= stop
-
-                hit_target = high >= target
-
-            else:
-
-                hit_stop = high >= stop
-
-                hit_target = low <= target
-
-            # Conservative same-candle rule.
-            if hit_stop:
-
-                exit_price = stop
-
-                reason = "STOP"
-
-                break
-
-            if hit_target:
-
-                exit_price = target
-
-                reason = "TARGET"
-
-                break
-
-        if exit_price is None:
-
-            exit_price = float(
-                raw.iloc[exit_limit]["close"]
-            )
-
-        if direction == 1:
-
-            gross = (
-                exit_price / entry_price - 1
-            )
-
-        else:
-
-            gross = (
-                entry_price / exit_price - 1
-            )
-
-        net = gross - cost
-
-        trades.append({
-            "direction": (
-                "LONG" if direction == 1
-                else "SHORT"
-            ),
-            "entry": entry_price,
-            "exit": exit_price,
-            "probability": float(probability),
-            "reason": reason,
-            "gross_return": gross,
-            "net_return": net
-        })
-
-        last_exit_i = exit_limit
-
-    return trades
-
-
-# ============================================================
-# METRICS
-# ============================================================
-
-def calculate_metrics(trades):
-
-    if not trades:
-
-        return {
-            "trades": 0,
-            "win_rate": 0.0,
-            "profit_factor": 0.0,
-            "net_return": 0.0,
-            "max_drawdown": 0.0
-        }
-
-    returns = np.asarray(
-        [t["net_return"] for t in trades],
-        dtype=float
-    )
-
-    wins = returns[returns > 0]
-
-    losses = returns[returns < 0]
-
-    if len(losses):
-
-        pf = (
-            wins.sum()
-            / abs(losses.sum())
-        )
-
-    elif len(wins):
-
-        pf = 999.0
-
-    else:
-
-        pf = 0.0
-
-    equity = np.cumprod(
-        1 + returns
-    )
-
-    peaks = np.maximum.accumulate(
-        np.concatenate([
-            [1.0],
-            equity
-        ])
-    )[1:]
-
-    drawdown = (
-        1 - equity / peaks
-    )
-
-    return {
-        "trades": len(trades),
-        "win_rate": float(
-            np.mean(returns > 0)
-        ),
-        "profit_factor": float(pf),
-        "net_return": float(
-            equity[-1] - 1
-        ),
-        "max_drawdown": float(
-            np.max(drawdown)
-        )
-    }
-
-
-# ============================================================
-# OPTUNA DEVELOPMENT
-# ============================================================
+NO supervised ML, NO predictive classifiers.
+HMM is used exclusively for probabilistic regime detection (forward filtering only).
 
-def optimize_parameters(
-    dataset,
-    raw,
-    horizon,
-    fee_rate,
-    slippage_bps,
-    trials
-):
+Author: Quantitative Development
+License: MIT
+"""
 
-    n = len(dataset)
+import os
+import math
+import time
+import warnings
+from datetime import datetime, timezone
+from typing import Dict, List, Optional, Tuple
 
-    dev_end = int(n * 0.60)
+import numpy as np
+import pandas as pd
+import requests
+import gradio as gr
+from hmmlearn import hmm
 
-    development = dataset.iloc[
-        :dev_end
-    ].reset_index(drop=True)
+warnings.filterwarnings("ignore")
 
-    if len(development) < MIN_TRAIN_ROWS + 150:
-        raise ValueError(
-            "Optimizasyon için daha fazla veri gerekli."
-        )
+# ---------------------------------------------------------------------------
+# Configuration
+# ---------------------------------------------------------------------------
 
-    # Three chronological development folds.
-    boundaries = np.linspace(
-        int(len(development) * 0.50),
-        len(development),
-        4,
-        dtype=int
-    )
+BINANCE_BASE = "https://api.binance.com"
+BINANCE_DATA = "https://data-api.binance.vision"  # fallback
 
-    def objective(trial):
+REQUEST_TIMEOUT = 15
+MAX_RETRIES = 3
+RETRY_DELAY = 1.5
 
-        threshold = trial.suggest_float(
-            "threshold",
-            0.54,
-            0.72
-        )
+# Trading cost assumptions
+COMMISSION_PER_SIDE = 0.001   # 0.10%
+SLIPPAGE_PER_SIDE = 0.0005    # 0.05%
+TOTAL_COST_PER_TRADE = 2 * (COMMISSION_PER_SIDE + SLIPPAGE_PER_SIDE)  # round-trip
 
-        stop_multiplier = trial.suggest_float(
-            "stop_multiplier",
-            0.8,
-            2.2
-        )
+# Regime labels
+REGIME_TREND = 0
+REGIME_MEAN_REV = 1
+REGIME_COMPRESSION = 2
+REGIME_NAMES = ["TREND", "MEAN_REVERSION", "COMPRESSION"]
 
-        fold_scores = []
+# HMM parameters (fixed, transparent — no per-run optimisation)
+HMM_N_COMPONENTS = 3
+HMM_N_ITER = 100
+HMM_COVARIANCE_TYPE = "diag"
+HMM_RANDOM_STATE = 42
 
-        total_trades = 0
+# Walk-forward
+TRAIN_FRACTION = 0.60
+PURGE_BARS = 5
+EMBARGO_BARS = 3
 
-        for k in range(3):
+# Minimum data requirements
+MIN_BARS_FOR_HMM = 200
+MIN_BARS_FOR_SIGNAL = 100
 
-            val_start = boundaries[k]
+# Leveraged-token exclusion patterns (prefix matching, case-insensitive)
+LEVERAGED_PREFIXES = ("3L", "3S", "5L", "5S", "BULL", "BEAR", "UP", "DOWN")
+LEVERAGED_SUFFIXES = ("3LUSDT", "3SUSDT", "5LUSDT", "5SUSDT",
+                      "BULLUSDT", "BEARUSDT", "UPUSDT", "DOWNUSDT")
 
-            val_end = boundaries[k + 1]
 
-            train_end = val_start - horizon
+# ---------------------------------------------------------------------------
+# Utilities
+# ---------------------------------------------------------------------------
 
-            if train_end < MIN_TRAIN_ROWS:
+def _safe_float(x) -> Optional[float]:
+    try:
+        v = float(x)
+        return v if math.isfinite(v) else None
+    except (TypeError, ValueError):
+        return None
+
+
+def _sigmoid(x: float) -> float:
+    if x >= 0:
+        z = math.exp(-x)
+        return 1.0 / (1.0 + z)
+    z = math.exp(x)
+    return z / (1.0 + z)
+
+
+def _ema(arr: np.ndarray, span: int) -> np.ndarray:
+    """Exponential moving average, causal (no future data)."""
+    alpha = 2.0 / (span + 1.0)
+    out = np.empty_like(arr, dtype=float)
+    out[0] = arr[0]
+    for i in range(1, len(arr)):
+        out[i] = alpha * arr[i] + (1.0 - alpha) * out[i - 1]
+    return out
+
+
+def _atr(high: np.ndarray, low: np.ndarray, close: np.ndarray, period: int = 14) -> np.ndarray:
+    """Average True Range, causal."""
+    n = len(close)
+    tr = np.empty(n, dtype=float)
+    tr[0] = high[0] - low[0]
+    for i in range(1, n):
+        tr[i] = max(high[i] - low[i], abs(high[i] - close[i - 1]), abs(low[i] - close[i - 1]))
+    return _ema(tr, period)
+
+
+def _rsi(close: np.ndarray, period: int = 14) -> np.ndarray:
+    """RSI, causal, using Wilder smoothing."""
+    n = len(close)
+    delta = np.diff(close, prepend=close[0])
+    gain = np.where(delta > 0, delta, 0.0)
+    loss = np.where(delta < 0, -delta, 0.0)
+    avg_gain = _ema(gain, period)
+    avg_loss = _ema(loss, period)
+    rs = np.where(avg_loss > 1e-12, avg_gain / avg_loss, 100.0)
+    return 100.0 - 100.0 / (1.0 + rs)
+
+
+# ---------------------------------------------------------------------------
+# Binance data fetching
+# ---------------------------------------------------------------------------
+
+def _request_with_retry(url: str, params: dict, base: str = BINANCE_BASE) -> Optional[list]:
+    """GET with retries and timeout. Returns JSON list or None."""
+    for attempt in range(MAX_RETRIES):
+        try:
+            r = requests.get(base + url, params=params, timeout=REQUEST_TIMEOUT)
+            if r.status_code == 200:
+                data = r.json()
+                if isinstance(data, list):
+                    return data
+                return None
+            if r.status_code == 429 or r.status_code >= 500:
+                time.sleep(RETRY_DELAY * (attempt + 1))
                 continue
-
-            train_df = development.iloc[
-                :train_end
-            ].reset_index(drop=True)
-
-            # Includes the purge/gap observations.
-            future_df = development.iloc[
-                train_end:val_end
-            ].reset_index(drop=True)
-
-            result = fit_predict(
-                train_df,
-                future_df
-            )
-
-            offset = val_start - train_end
-
-            val_probabilities = (
-                result["probabilities"][offset:]
-            )
-
-            # Map development-local indices to original dataset.
-            global_start = val_start
-
-            global_end = val_end
-
-            indices = np.arange(
-                global_start,
-                global_end
-            )
-
-            trades = simulate_trades(
-                raw,
-                dataset,
-                indices,
-                val_probabilities,
-                threshold,
-                stop_multiplier,
-                horizon,
-                fee_rate,
-                slippage_bps
-            )
-
-            metrics = calculate_metrics(
-                trades
-            )
-
-            total_trades += metrics["trades"]
-
-            score = (
-                metrics["net_return"] * 100
-                + min(metrics["profit_factor"], 4) * 1.5
-                + metrics["win_rate"] * 2
-                - metrics["max_drawdown"] * 20
-            )
-
-            fold_scores.append(score)
-
-        if not fold_scores:
-            return -100.0
-
-        # Avoid selecting a model that makes almost no trades.
-        if total_trades < 8:
-            return (
-                float(np.mean(fold_scores))
-                - (8 - total_trades) * 2
-            )
-
-        return float(
-            np.mean(fold_scores)
-        )
-
-    study = optuna.create_study(
-        direction="maximize",
-        sampler=optuna.samplers.TPESampler(
-            seed=42
-        )
-    )
-
-    study.optimize(
-        objective,
-        n_trials=int(trials),
-        show_progress_bar=False
-    )
-
-    return study.best_params, study.best_value
-
-
-# ============================================================
-# WALK-FORWARD EVALUATION
-# ============================================================
-
-def walk_forward_evaluation(
-    dataset,
-    raw,
-    horizon,
-    params,
-    fee_rate,
-    slippage_bps
-):
-
-    n = len(dataset)
-
-    start = int(n * 0.60)
-
-    end = int(n * 0.80)
-
-    boundaries = np.linspace(
-        start,
-        end,
-        5,
-        dtype=int
-    )
-
-    all_trades = []
-
-    fold_reports = []
-
-    for fold in range(4):
-
-        val_start = boundaries[fold]
-
-        val_end = boundaries[fold + 1]
-
-        train_end = val_start - horizon
-
-        train_df = dataset.iloc[
-            :train_end
-        ].reset_index(drop=True)
-
-        future_df = dataset.iloc[
-            train_end:val_end
-        ].reset_index(drop=True)
-
-        result = fit_predict(
-            train_df,
-            future_df
-        )
-
-        offset = val_start - train_end
-
-        probabilities = (
-            result["probabilities"][offset:]
-        )
-
-        indices = np.arange(
-            val_start,
-            val_end
-        )
-
-        trades = simulate_trades(
-            raw,
-            dataset,
-            indices,
-            probabilities,
-            params["threshold"],
-            params["stop_multiplier"],
-            horizon,
-            fee_rate,
-            slippage_bps
-        )
-
-        metrics = calculate_metrics(
-            trades
-        )
-
-        fold_reports.append({
-            "fold": fold + 1,
-            **metrics
+            return None
+        except (requests.RequestException, ValueError):
+            time.sleep(RETRY_DELAY * (attempt + 1))
+    return None
+
+
+def fetch_usdt_pairs(min_volume_rank: int = 30, max_pairs: int = 100) -> List[str]:
+    """
+    Fetch USDT spot trading pairs ranked by 24h quote volume.
+    Excludes leveraged tokens and non-trading symbols.
+    """
+    # 1. Exchange info for status
+    info = _request_with_retry("/api/v3/exchangeInfo", {})
+    if info is None:
+        info = _request_with_retry("/api/v3/exchangeInfo", {}, BINANCE_DATA)
+    if info is None:
+        return []
+
+    trading_symbols = set()
+    for s in info.get("symbols", []):
+        if s.get("status") != "TRADING":
+            continue
+        if s.get("quoteAsset") != "USDT":
+            continue
+        sym = s.get("symbol", "")
+        base = s.get("baseAsset", "")
+        # Exclude leveraged tokens
+        if any(base.upper().startswith(p) for p in LEVERAGED_PREFIXES):
+            continue
+        if any(sym.upper().endswith(p) for p in LEVERAGED_SUFFIXES):
+            continue
+        trading_symbols.add(sym)
+
+    if not trading_symbols:
+        return []
+
+    # 2. 24h ticker for volume ranking
+    tickers = _request_with_retry("/api/v3/ticker/24hr", {})
+    if tickers is None:
+        tickers = _request_with_retry("/api/v3/ticker/24hr", {}, BINANCE_DATA)
+    if tickers is None:
+        return []
+
+    candidates = []
+    for t in tickers:
+        sym = t.get("symbol", "")
+        if sym not in trading_symbols:
+            continue
+        qvol = _safe_float(t.get("quoteVolume"))
+        if qvol is None or qvol <= 0:
+            continue
+        candidates.append((sym, qvol))
+
+    candidates.sort(key=lambda x: x[1], reverse=True)
+    top = [c[0] for c in candidates[:max_pairs]]
+    return top[:max(min_volume_rank, len(top))]
+
+
+def fetch_klines(symbol: str, interval: str, limit: int = 1000) -> Optional[pd.DataFrame]:
+    """
+    Fetch OHLCV klines. Excludes unfinished candle (the most recent if still forming).
+    Returns DataFrame with columns: open, high, low, close, volume, quote_volume.
+    """
+    params = {"symbol": symbol, "interval": interval, "limit": min(limit, 1000)}
+    raw = _request_with_retry("/api/v3/klines", params)
+    if raw is None:
+        raw = _request_with_retry("/api/v3/klines", params, BINANCE_DATA)
+    if raw is None or len(raw) == 0:
+        return None
+
+    rows = []
+    now_ms = int(datetime.now(timezone.utc).timestamp() * 1000)
+    for k in raw:
+        if not isinstance(k, list) or len(k) < 7:
+            continue
+        close_time = int(k[6])
+        # Exclude unfinished candle
+        if close_time >= now_ms:
+            continue
+        o = _safe_float(k[1])
+        h = _safe_float(k[2])
+        l = _safe_float(k[3])
+        c = _safe_float(k[4])
+        v = _safe_float(k[5])
+        qv = _safe_float(k[7]) if len(k) > 7 else None
+        if None in (o, h, l, c, v) or min(o, h, l, c) <= 0:
+            continue
+        rows.append({
+            "open": o, "high": h, "low": l, "close": c,
+            "volume": v, "quote_volume": qv if qv else 0.0,
         })
 
-        all_trades.extend(trades)
-
-    return (
-        calculate_metrics(all_trades),
-        fold_reports
-    )
-
-
-# ============================================================
-# INDEPENDENT HOLDOUT
-# ============================================================
-
-def independent_holdout(
-    dataset,
-    raw,
-    horizon,
-    params,
-    fee_rate,
-    slippage_bps
-):
-
-    n = len(dataset)
-
-    split = int(n * 0.80)
-
-    train_end = split - horizon
-
-    train_df = dataset.iloc[
-        :train_end
-    ].reset_index(drop=True)
-
-    # Includes purge observations before holdout.
-    future_df = dataset.iloc[
-        train_end:n
-    ].reset_index(drop=True)
-
-    result = fit_predict(
-        train_df,
-        future_df
-    )
-
-    offset = split - train_end
-
-    probabilities = (
-        result["probabilities"][offset:]
-    )
-
-    indices = np.arange(
-        split,
-        n
-    )
-
-    trades = simulate_trades(
-        raw,
-        dataset,
-        indices,
-        probabilities,
-        params["threshold"],
-        params["stop_multiplier"],
-        horizon,
-        fee_rate,
-        slippage_bps
-    )
-
-    return (
-        calculate_metrics(trades),
-        trades
-    )
-
-
-# ============================================================
-# OVERFIT DIAGNOSTIC
-# ============================================================
-
-def overfit_diagnostic(wf, holdout):
-
-    if (
-        wf["trades"] < MIN_RELIABLE_TRADES
-        or holdout["trades"] < MIN_RELIABLE_TRADES
-    ):
-
-        return (
-            None,
-            "YETERSİZ VERİ",
-            "Her iki test bölümünde de en az 30 işlem gerekli."
-        )
-
-    win_gap = abs(
-        wf["win_rate"] - holdout["win_rate"]
-    )
-
-    pf_gap = abs(
-        min(wf["profit_factor"], 5)
-        - min(holdout["profit_factor"], 5)
-    ) / 5
-
-    return_gap = abs(
-        wf["net_return"] - holdout["net_return"]
-    )
-
-    score = (
-        win_gap * 40
-        + pf_gap * 35
-        + min(return_gap, 1) * 25
-    )
-
-    score = float(
-        np.clip(score, 0, 100)
-    )
-
-    if score < 20:
-        label = "DÜŞÜK FARK"
-
-    elif score < 40:
-        label = "ORTA FARK"
-
-    elif score < 65:
-        label = "YÜKSEK FARK"
-
-    else:
-        label = "ÇOK YÜKSEK FARK"
-
-    return (
-        score,
-        label,
-        "Bu değer gerçek overfit olasılığı değil, test bölümleri arasındaki performans farkıdır."
-    )
-
-
-# ============================================================
-# LIVE PREDICTION
-# ============================================================
-
-def live_prediction(
-    dataset,
-    live,
-    horizon,
-    params
-):
-
-    train_df = dataset.copy()
-
-    train_end_raw_i = int(
-        train_df["raw_i"].iloc[-1]
+    if len(rows) < MIN_BARS_FOR_HMM:
+        return None
+    return pd.DataFrame(rows)
+
+
+# ---------------------------------------------------------------------------
+# Feature engineering (all causal, no future data)
+# ---------------------------------------------------------------------------
+
+def compute_features(df: pd.DataFrame) -> pd.DataFrame:
+    """
+    Compute all features used by HMM and regime-conditioned evidence.
+    Every column uses only data available at or before each bar's close.
+    """
+    close = df["close"].values.astype(float)
+    high = df["high"].values.astype(float)
+    low = df["low"].values.astype(float)
+    n = len(close)
+
+    out = pd.DataFrame(index=df.index)
+    out["close"] = close
+
+    # Returns
+    ret = np.zeros(n)
+    ret[1:] = np.diff(close) / close[:-1]
+    out["ret"] = ret
+
+    # ATR
+    atr14 = _atr(high, low, close, 14)
+    out["atr"] = atr14
+    out["atr_norm"] = atr14 / np.where(close > 0, close, 1.0)
+
+    # EMAs
+    ema_fast = _ema(close, 12)
+    ema_slow = _ema(close, 26)
+    out["ema_fast"] = ema_fast
+    out["ema_slow"] = ema_slow
+    out["ema_diff_norm"] = (ema_fast - ema_slow) / np.where(close > 0, close, 1.0)
+
+    # Directional efficiency (Kaufman-like, causal)
+    lookback = 10
+    eff = np.zeros(n)
+    for i in range(lookback, n):
+        net = close[i] - close[i - lookback]
+        path = np.sum(np.abs(np.diff(close[i - lookback:i + 1])))
+        eff[i] = net / path if path > 1e-12 else 0.0
+    out["efficiency"] = eff
+
+    # Momentum (rate of change)
+    roc = np.zeros(n)
+    roc[10:] = (close[10:] - close[:-10]) / np.where(close[:-10] > 0, close[:-10], 1.0)
+    out["momentum"] = roc
+
+    # ATR-normalised price movement
+    out["atr_move"] = np.zeros(n)
+    out["atr_move"][1:] = np.diff(close) / np.where(atr14[1:] > 1e-12, atr14[1:], 1.0)
+
+    # RSI
+    rsi14 = _rsi(close, 14)
+    out["rsi"] = rsi14
+    out["rsi_dev"] = (rsi14 - 50.0) / 50.0
+
+    # Rolling mean & distance
+    roll_mean = pd.Series(close).rolling(20, min_periods=20).mean().values
+    out["dist_ma"] = np.where(roll_mean > 0, (close - roll_mean) / roll_mean, 0.0)
+    out["dist_ma"] = np.nan_to_num(out["dist_ma"], nan=0.0)
+
+    # ATR-normalised extension from rolling mean
+    out["atr_extension"] = np.where(atr14 > 1e-12, (close - roll_mean) / atr14, 0.0)
+    out["atr_extension"] = np.nan_to_num(out["atr_extension"], nan=0.0)
+
+    # Volatility contraction: short ATR vs long ATR
+    atr5 = _atr(high, low, close, 5)
+    atr20 = _atr(high, low, close, 20)
+    out["vol_ratio"] = np.where(atr20 > 1e-12, atr5 / atr20, 1.0)
+
+    # Previous range boundaries (causal: use previous bar's high/low)
+    out["prev_high"] = np.roll(high, 1)
+    out["prev_low"] = np.roll(low, 1)
+    out["prev_high"][0] = high[0]
+    out["prev_low"][0] = low[0]
+
+    # Breakout confirmation vs previous range
+    out["breakout"] = np.where(
+        close > out["prev_high"], 1.0,
+        np.where(close < out["prev_low"], -1.0, 0.0)
     )
 
-    future_df = live[
-        live["raw_i"] > train_end_raw_i
-    ].copy()
-
-    if future_df.empty:
-        raise ValueError(
-            "Canlı tahmin için yeni tamamlanmış mum bulunamadı."
-        )
-
-    future_df = future_df.reset_index(
-        drop=True
-    )
-
-    result = fit_predict(
-        train_df,
-        future_df
-    )
-
-    probability = float(
-        result["probabilities"][-1]
+    # Clean
+    out = out.replace([np.inf, -np.inf], np.nan).fillna(0.0)
+    return out
+
+
+# ---------------------------------------------------------------------------
+# HMM regime detection (forward filtering only, no Viterbi)
+# ---------------------------------------------------------------------------
+
+def fit_hmm_on_training(features: pd.DataFrame) -> Optional[hmm.GaussianHMM]:
+    """
+    Fit a 3-state Gaussian HMM on the training portion only.
+    Uses fixed, transparent parameters. No per-run optimisation.
+    """
+    n_train = max(MIN_BARS_FOR_HMM, int(len(features) * TRAIN_FRACTION))
+    n_train = min(n_train, len(features) - 20)
+    if n_train < MIN_BARS_FOR_HMM:
+        return None
+
+    train_feats = features.iloc[:n_train][
+        ["ret", "atr_norm", "ema_diff_norm", "efficiency", "rsi_dev", "dist_ma"]
+    ].values
+
+    # Standardise (fit on train only)
+    mu = train_feats.mean(axis=0)
+    sigma = train_feats.std(axis=0)
+    sigma[sigma < 1e-12] = 1.0
+    X_train = (train_feats - mu) / sigma
+
+    model = hmm.GaussianHMM(
+        n_components=HMM_N_COMPONENTS,
+        covariance_type=HMM_COVARIANCE_TYPE,
+        n_iter=HMM_N_ITER,
+        random_state=HMM_RANDOM_STATE,
+        tol=1e-4,
     )
-
-    threshold = params["threshold"]
-
-    if probability >= threshold:
-
+    try:
+        model.fit(X_train)
+    except Exception:
+        return None
+
+    # Store standardisation for inference
+    model._rcea_mu = mu
+    model._rcea_sigma = sigma
+    return model
+
+
+def forward_filter_regimes(
+    model: hmm.GaussianHMM, features: pd.DataFrame
+) -> np.ndarray:
+    """
+    Causal forward filtering: P(state_t | observations_1..t).
+    Uses the forward algorithm ONLY. No Viterbi, no smoothing, no future data.
+
+    Returns array shape (n_bars, 3) of normalised posterior probabilities.
+    For bars before HMM training data ends, probabilities are set to uniform
+    (or the model's stationary distribution if available) to avoid look-ahead.
+    """
+    n = len(features)
+    posteriors = np.ones((n, HMM_N_COMPONENTS)) / HMM_N_COMPONENTS
+
+    n_train = max(MIN_BARS_FOR_HMM, int(n * TRAIN_FRACTION))
+    n_train = min(n_train, n - 20)
+
+    # Bars before training end: use uniform prior (no information)
+    if n_train < 10:
+        return posteriors
+
+    feat_cols = ["ret", "atr_norm", "ema_diff_norm", "efficiency", "rsi_dev", "dist_ma"]
+    X_all = features[feat_cols].values
+    X_scaled = (X_all - model._rcea_mu) / model._rcea_sigma
+
+    # Forward algorithm manual implementation (log-space to prevent underflow)
+    log_start = np.log(model.startprob_ + 1e-300)
+    log_trans = np.log(model.transmat_ + 1e-300)
+
+    # Precompute log emission probabilities for all bars
+    # For GaussianHMM with diag covariance
+    n_comp = HMM_N_COMPONENTS
+    n_feat = X_scaled.shape[1]
+    log_emit = np.zeros((n, n_comp))
+    for k in range(n_comp):
+        mean = model.means_[k]
+        covar = model.covars_[k]
+        # diag: covar is 1-D
+        if covar.ndim > 1:
+            var = np.diag(covar)
+        else:
+            var = covar
+        var = np.maximum(var, 1e-6)
+        diff = X_scaled - mean  # (n, n_feat)
+        log_emit[:, k] = -0.5 * np.sum(diff ** 2 / var, axis=1) - 0.5 * np.sum(np.log(2 * np.pi * var))
+
+    # Forward recursion in log space
+    alpha = np.zeros((n, n_comp))
+    alpha[0] = log_start + log_emit[0]
+
+    for t in range(1, n):
+        # logsumexp over previous states
+        for k in range(n_comp):
+            terms = alpha[t - 1] + log_trans[:, k]
+            max_term = np.max(terms)
+            alpha[t, k] = log_emit[t, k] + max_term + np.log(np.sum(np.exp(terms - max_term)))
+
+    # Normalise to get posteriors
+    for t in range(n):
+        a = alpha[t]
+        max_a = np.max(a)
+        exp_a = np.exp(a - max_a)
+        s = np.sum(exp_a)
+        if s > 1e-300:
+            posteriors[t] = exp_a / s
+        else:
+            posteriors[t] = np.ones(n_comp) / n_comp
+
+    # Only use posteriors from training end onward; before that, uniform
+    posteriors[:n_train] = np.ones((n_train, n_comp)) / n_comp
+    return posteriors
+
+
+# ---------------------------------------------------------------------------
+# Regime-conditioned evidence
+# ---------------------------------------------------------------------------
+
+def compute_regime_evidence(
+    features: pd.DataFrame, regime_probs: np.ndarray
+) -> Tuple[np.ndarray, np.ndarray, np.ndarray, np.ndarray]:
+    """
+    Compute raw evidence per regime and combine via posterior probabilities.
+
+    Returns:
+        E_raw: array (n,)
+        E_accum: array (n,)
+        P_long: array (n,)
+        P_short: array (n,)
+    """
+    n = len(features)
+    close = features["close"].values
+    ema_fast = features["ema_fast"].values
+    ema_slow = features["ema_slow"].values
+    efficiency = features["efficiency"].values
+    momentum = features["momentum"].values
+    atr_move = features["atr_move"].values
+    rsi_dev = features["rsi_dev"].values
+    dist_ma = features["dist_ma"].values
+    atr_ext = features["atr_extension"].values
+    vol_ratio = features["vol_ratio"].values
+    breakout = features["breakout"].values
+
+    # TREND evidence: directional
+    e_trend = np.zeros(n)
+    for i in range(n):
+        score = 0.0
+        # EMA relationship
+        if close[i] > ema_fast[i] > ema_slow[i]:
+            score += 0.4
+        elif close[i] < ema_fast[i] < ema_slow[i]:
+            score -= 0.4
+        # Directional efficiency
+        score += 0.3 * efficiency[i]
+        # Momentum
+        score += 0.3 * np.tanh(momentum[i] * 10)
+        # ATR-normalised movement
+        score += 0.2 * np.tanh(atr_move[i])
+        e_trend[i] = np.tanh(score * 2.0)
+
+    # MEAN REVERSION evidence: contrarian
+    e_mean = np.zeros(n)
+    for i in range(n):
+        score = 0.0
+        # RSI deviation (invert: high RSI -> short signal)
+        score -= 0.4 * np.tanh(rsi_dev[i] * 3)
+        # Distance from rolling mean
+        score -= 0.4 * np.tanh(dist_ma[i] * 20)
+        # ATR-normalised extension
+        score -= 0.3 * np.tanh(atr_ext[i] * 2)
+        e_mean[i] = np.tanh(score * 2.0)
+
+    # COMPRESSION evidence: breakout direction
+    e_comp = np.zeros(n)
+    for i in range(n):
+        score = 0.0
+        # Volatility contraction strengthens breakout signal
+        contraction = max(0.0, 1.0 - vol_ratio[i])
+        score += breakout[i] * (0.5 + 0.5 * contraction)
+        e_comp[i] = np.tanh(score * 2.0)
+
+    # Combine using posterior probabilities
+    E_raw = np.zeros(n)
+    for i in range(n):
+        p = regime_probs[i]
+        E_raw[i] = p[REGIME_TREND] * e_trend[i] + p[REGIME_MEAN_REV] * e_mean[i] + p[REGIME_COMPRESSION] * e_comp[i]
+
+    # Evidence accumulation with memory coefficient
+    lam = 0.85  # default; can be overridden by UI
+    E_accum = np.zeros(n)
+    E_accum[0] = E_raw[0]
+    for i in range(1, n):
+        E_accum[i] = lam * E_accum[i - 1] + (1.0 - lam) * E_raw[i]
+
+    # Directional probabilities
+    k = 4.0
+    P_long = np.array([_sigmoid(k * e) for e in E_accum])
+    P_short = 1.0 - P_long
+
+    return E_raw, E_accum, P_long, P_short
+
+
+def generate_signals(
+    features: pd.DataFrame,
+    regime_probs: np.ndarray,
+    E_accum: np.ndarray,
+    P_long: np.ndarray,
+    P_short: np.ndarray,
+    evidence_threshold: float,
+    min_regime_conf: float,
+) -> List[dict]:
+    """
+    Generate LONG/SHORT/NO TRADE signals for the most recent bar.
+    Returns list of signal dicts (one per symbol, but this function is per-symbol).
+    """
+    n = len(features)
+    signals = []
+
+    # Current bar (last closed)
+    i = n - 1
+    if i < MIN_BARS_FOR_SIGNAL:
+        return signals
+
+    p = regime_probs[i]
+    dominant_regime = int(np.argmax(p))
+    regime_conf = float(p[dominant_regime])
+
+    # Apply minimum regime confidence filter
+    if regime_conf < min_regime_conf:
+        return signals
+
+    e = E_accum[i]
+    pl = P_long[i]
+    ps = P_short[i]
+
+    signal = "NO TRADE"
+    if e > evidence_threshold and pl > 0.5:
         signal = "LONG"
-
-    elif probability <= 1 - threshold:
-
+    elif e < -evidence_threshold and ps > 0.5:
         signal = "SHORT"
 
-    else:
-
-        signal = "NO TRADE"
-
-    latest = future_df.iloc[-1]
-
-    price = float(
-        latest["close"]
-    )
-
-    volatility = float(
-        latest["realized_volatility"]
-    )
+    signals.append({
+        "signal": signal,
+        "evidence": float(e),
+        "P_long": float(pl),
+        "P_short": float(ps),
+        "regime_probs": {
+            "TREND": float(p[0]),
+            "MEAN_REVERSION": float(p[1]),
+            "COMPRESSION": float(p[2]),
+        },
+        "dominant_regime": REGIME_NAMES[dominant_regime],
+        "regime_conf": regime_conf,
+        "close": float(features["close"].values[i]),
+    })
+    return signals
+
+
+# ---------------------------------------------------------------------------
+# Backtest engine
+# ---------------------------------------------------------------------------
+
+def backtest_symbol(
+    symbol: str,
+    features: pd.DataFrame,
+    regime_probs: np.ndarray,
+    E_accum: np.ndarray,
+    P_long: np.ndarray,
+    P_short: np.ndarray,
+    evidence_threshold: float,
+    min_regime_conf: float,
+    max_holding_bars: int,
+) -> List[dict]:
+    """
+    Chronological backtest for one symbol. No look-ahead.
+    ATR-based stop, 2R take-profit. Conservative when stop & target both hit.
+    """
+    trades = []
+    n = len(features)
+    close = features["close"].values
+    high = features["high"].values
+    low = features["low"].values
+    atr = features["atr"].values
+
+    in_position = False
+    entry_idx = 0
+    entry_price = 0.0
+    direction = 0  # +1 long, -1 short
+    stop_price = 0.0
+    target_price = 0.0
+    regime_at_entry = ""
+    regime_conf_at_entry = 0.0
+
+    # Start from index MIN_BARS_FOR_SIGNAL to ensure enough history
+    start = max(MIN_BARS_FOR_SIGNAL, int(n * TRAIN_FRACTION) + PURGE_BARS + EMBARGO_BARS)
+
+    for i in range(start, n):
+        if not in_position:
+            # Check for entry signal
+            p = regime_probs[i]
+            dominant = int(np.argmax(p))
+            conf = float(p[dominant])
+            if conf < min_regime_conf:
+                continue
 
-    risk_pct = np.clip(
-        volatility
-        * np.sqrt(horizon)
-        * params["stop_multiplier"],
-        0.002,
-        0.05
-    )
+            e = E_accum[i]
+            pl = P_long[i]
+            ps = P_short[i]
 
-    distance = price * risk_pct
+            entry_dir = 0
+            if e > evidence_threshold and pl > 0.5:
+                entry_dir = 1
+            elif e < -evidence_threshold and ps > 0.5:
+                entry_dir = -1
 
-    if signal == "LONG":
+            if entry_dir == 0:
+                continue
 
-        stop = price - distance
+            # Enter at next bar's open (conservative: signal at close, fill next open)
+            # But we don't have open in features; use next close? No — use current close + slippage.
+            # To avoid look-ahead: signal generated at close of bar i, entry at open of bar i+1.
+            # Since we don't store open, we use close[i] as proxy with slippage.
+            # This is slightly optimistic (close vs next open), so we add extra slippage.
+            entry_price = close[i] * (1.0 + SLIPPAGE_PER_SIDE * entry_dir)
+            atr_val = atr[i]
+            if atr_val < 1e-12:
+                continue
 
-        target = price + 2 * distance
+            direction = entry_dir
+            entry_idx = i
+            in_position = True
 
-    elif signal == "SHORT":
+            if direction == 1:
+                stop_price = entry_price - 1.5 * atr_val
+                target_price = entry_price + 3.0 * atr_val  # 2R (1.5 ATR risk, 3.0 ATR reward)
+            else:
+                stop_price = entry_price + 1.5 * atr_val
+                target_price = entry_price - 3.0 * atr_val
 
-        stop = price + distance
+            regime_at_entry = REGIME_NAMES[dominant]
+            regime_conf_at_entry = conf
 
-        target = price - 2 * distance
+        else:
+            # In position: check exit
+            bars_held = i - entry_idx
 
-    else:
+            if direction == 1:
+                # Long
+                hit_stop = low[i] <= stop_price
+                hit_target = high[i] >= target_price
+            else:
+                # Short
+                hit_stop = high[i] >= stop_price
+                hit_target = low[i] <= target_price
+
+            exit_price = None
+            exit_reason = None
+
+            if hit_stop and hit_target:
+                # Conservative: assume stop hit first
+                exit_price = stop_price
+                exit_reason = "STOP (both touched, conservative)"
+            elif hit_stop:
+                exit_price = stop_price
+                exit_reason = "STOP"
+            elif hit_target:
+                exit_price = target_price
+                exit_reason = "TARGET"
+            elif bars_held >= max_holding_bars:
+                exit_price = close[i]
+                exit_reason = "TIME"
+
+            if exit_price is not None:
+                # Apply exit slippage
+                exit_price_adj = exit_price * (1.0 - SLIPPAGE_PER_SIDE * direction)
+
+                # Gross return
+                if direction == 1:
+                    gross_ret = (exit_price_adj - entry_price) / entry_price
+                else:
+                    gross_ret = (entry_price - exit_price_adj) / entry_price
+
+                # Net return after round-trip costs
+                net_ret = gross_ret - TOTAL_COST_PER_TRADE
+
+                trades.append({
+                    "symbol": symbol,
+                    "direction": "LONG" if direction == 1 else "SHORT",
+                    "entry_bar": entry_idx,
+                    "exit_bar": i,
+                    "bars_held": bars_held,
+                    "entry_price": entry_price,
+                    "exit_price": exit_price_adj,
+                    "stop_price": stop_price,
+                    "target_price": target_price,
+                    "exit_reason": exit_reason,
+                    "gross_return": gross_ret,
+                    "net_return": net_ret,
+                    "regime": regime_at_entry,
+                    "regime_conf": regime_conf_at_entry,
+                    "win": net_ret > 0,
+                })
+                in_position = False
 
-        stop = None
+    return trades
 
-        target = None
 
-    joint = result["joint"][-1]
+# ---------------------------------------------------------------------------
+# Performance metrics
+# ---------------------------------------------------------------------------
 
-    macro_prob = joint.reshape(
-        N_MACRO,
-        N_MICRO
-    ).sum(axis=1)
+def compute_metrics(trades: List[dict]) -> dict:
+    if not trades:
+        return {
+            "total_trades": 0, "win_rate": 0.0, "profit_factor": 0.0,
+            "net_expectancy": 0.0, "avg_win": 0.0, "avg_loss": 0.0,
+            "max_drawdown": 0.0, "net_compounded_return": 0.0,
+            "long_trades": 0, "short_trades": 0,
+            "long_win_rate": 0.0, "short_win_rate": 0.0,
+        }
 
-    micro_prob = joint.reshape(
-        N_MACRO,
-        N_MICRO
-    ).sum(axis=0)
+    net_rets = np.array([t["net_return"] for t in trades])
+    wins = net_rets[net_rets > 0]
+    losses = net_rets[net_rets <= 0]
+
+    total = len(net_rets)
+    win_rate = len(wins) / total if total > 0 else 0.0
+    gross_profit = wins.sum() if len(wins) > 0 else 0.0
+    gross_loss = abs(losses.sum()) if len(losses) > 0 else 0.0
+    profit_factor = gross_profit / gross_loss if gross_loss > 1e-12 else float("inf")
+    net_expectancy = net_rets.mean()
+    avg_win = wins.mean() if len(wins) > 0 else 0.0
+    avg_loss = losses.mean() if len(losses) > 0 else 0.0
+
+    # Compounded return
+    equity = np.cumprod(1.0 + net_rets)
+    net_compounded = equity[-1] - 1.0 if len(equity) > 0 else 0.0
+
+    # Max drawdown
+    peak = np.maximum.accumulate(equity)
+    dd = (equity - peak) / peak
+    max_dd = dd.min() if len(dd) > 0 else 0.0
+
+    # Long/Short
+    long_trades = [t for t in trades if t["direction"] == "LONG"]
+    short_trades = [t for t in trades if t["direction"] == "SHORT"]
+    long_wins = sum(1 for t in long_trades if t["win"])
+    short_wins = sum(1 for t in short_trades if t["win"])
 
     return {
-        "signal": signal,
-        "long_probability": probability,
-        "short_probability": 1 - probability,
-        "price": price,
-        "stop": stop,
-        "target": target,
-        "risk_pct": risk_pct,
-        "macro": macro_prob,
-        "micro": micro_prob,
-        "joint": joint,
-        "state_probabilities": result[
-            "state_probabilities"
-        ]
+        "total_trades": total,
+        "win_rate": win_rate,
+        "profit_factor": profit_factor,
+        "net_expectancy": net_expectancy,
+        "avg_win": avg_win,
+        "avg_loss": avg_loss,
+        "max_drawdown": max_dd,
+        "net_compounded_return": net_compounded,
+        "long_trades": len(long_trades),
+        "short_trades": len(short_trades),
+        "long_win_rate": long_wins / len(long_trades) if long_trades else 0.0,
+        "short_win_rate": short_wins / len(short_trades) if short_trades else 0.0,
     }
 
 
-# ============================================================
-# MAIN APPLICATION
-# ============================================================
+def regime_breakdown(trades: List[dict]) -> pd.DataFrame:
+    if not trades:
+        return pd.DataFrame()
+    rows = []
+    for regime in REGIME_NAMES:
+        rt = [t for t in trades if t["regime"] == regime]
+        if not rt:
+            rows.append({"Regime": regime, "Trades": 0, "WinRate": 0.0,
+                         "ProfitFactor": 0.0, "NetExp": 0.0})
+            continue
+        net = np.array([t["net_return"] for t in rt])
+        wins = net[net > 0]
+        losses = net[net <= 0]
+        gp = wins.sum() if len(wins) else 0
+        gl = abs(losses.sum()) if len(losses) else 0
+        pf = gp / gl if gl > 1e-12 else float("inf")
+        rows.append({
+            "Regime": regime,
+            "Trades": len(rt),
+            "WinRate": len(wins) / len(rt),
+            "ProfitFactor": pf,
+            "NetExp": net.mean(),
+        })
+    return pd.DataFrame(rows)
 
-def run_app(
-    candle_count,
-    horizon,
-    trials,
-    fee_percent,
-    slippage_bps
-):
 
+def coin_breakdown(trades: List[dict]) -> pd.DataFrame:
+    if not trades:
+        return pd.DataFrame()
+    symbols = sorted(set(t["symbol"] for t in trades))
+    rows = []
+    for sym in symbols:
+        st = [t for t in trades if t["symbol"] == sym]
+        net = np.array([t["net_return"] for t in st])
+        wins = net[net > 0]
+        rows.append({
+            "Symbol": sym,
+            "Trades": len(st),
+            "WinRate": len(wins) / len(st) if st else 0.0,
+            "NetExp": net.mean() if len(net) else 0.0,
+            "TotalNet": net.sum() if len(net) else 0.0,
+        })
+    return pd.DataFrame(rows).sort_values("TotalNet", ascending=False)
+
+
+# ---------------------------------------------------------------------------
+# Main pipeline
+# ---------------------------------------------------------------------------
+
+def run_rcea_scan(
+    timeframe: str,
+    n_coins: int,
+    evidence_threshold: float,
+    evidence_memory: float,
+    min_regime_conf: float,
+    max_holding: int,
+    progress=gr.Progress(),
+) -> Tuple[str, str, pd.DataFrame, pd.DataFrame, pd.DataFrame]:
+    """
+    Main entry point. Fetches data, runs HMM, generates signals, backtests.
+    Returns display strings and DataFrames.
+    """
+    # Clamp inputs
+    n_coins = max(30, min(100, int(n_coins)))
+    evidence_threshold = max(0.0, min(1.0, float(evidence_threshold)))
+    evidence_memory = max(0.0, min(0.99, float(evidence_memory)))
+    min_regime_conf = max(0.0, min(1.0, float(min_regime_conf)))
+    max_holding = max(5, min(200, int(max_holding)))
+
+    if timeframe not in ("15m", "1h", "4h", "1d"):
+        return "ERROR: Invalid timeframe", "", pd.DataFrame(), pd.DataFrame(), pd.DataFrame()
+
+    # 1. Fetch pairs
+    progress(0.02, desc="Fetching USDT pairs...")
     try:
-
-        optuna.logging.set_verbosity(
-            optuna.logging.WARNING
-        )
-
-        fee_rate = (
-            float(fee_percent) / 100
-        )
-
-        raw = fetch_data(
-            int(candle_count)
-        )
-
-        dataset, live = prepare_dataset(
-            raw,
-            int(horizon)
-        )
-
-        # 1. Optimize only on first 60%.
-        params, best_score = optimize_parameters(
-            dataset,
-            raw,
-            int(horizon),
-            fee_rate,
-            float(slippage_bps),
-            int(trials)
-        )
-
-        # 2. Walk-forward: 60%-80%.
-        wf, fold_reports = walk_forward_evaluation(
-            dataset,
-            raw,
-            int(horizon),
-            params,
-            fee_rate,
-            float(slippage_bps)
-        )
-
-        # 3. Independent holdout: last 20%.
-        holdout, holdout_trades = independent_holdout(
-            dataset,
-            raw,
-            int(horizon),
-            params,
-            fee_rate,
-            float(slippage_bps)
-        )
-
-        # 4. Overfit diagnostic.
-        overfit_score, overfit_label, overfit_note = (
-            overfit_diagnostic(
-                wf,
-                holdout
-            )
-        )
-
-        # 5. Live model.
-        live_result = live_prediction(
-            dataset,
-            live,
-            int(horizon),
-            params
-        )
-
-        last_timestamp = pd.to_datetime(
-            int(raw.iloc[-1]["timestamp"]),
-            unit="ms",
-            utc=True
-        )
-
-        macro = live_result["macro"]
-
-        micro = live_result["micro"]
-
-        state_probs = live_result[
-            "state_probabilities"
-        ]
-
-        joint = live_result["joint"]
-
-        def pct(x):
-            return f"%{100*x:.2f}"
-
-        def price_text(x):
-            if x is None:
-                return "Yok"
-            return f"{x:,.2f} USDT"
-
-        report = f"""
-# OKX BTC/USDT — HIERARCHICAL QUANT
-
-**Model:** Hierarchical HMM + Bayesian Regime Model
-
-## Canlı tahmin
-
-# {live_result['signal']}
-
-| Metrik | Sonuç |
-|---|---:|
-| BTC fiyatı | {price_text(live_result['price'])} |
-| LONG olasılığı | {pct(live_result['long_probability'])} |
-| SHORT olasılığı | {pct(live_result['short_probability'])} |
-| Stop-loss | {price_text(live_result['stop'])} |
-| 2R hedef | {price_text(live_result['target'])} |
-| Risk mesafesi | {pct(live_result['risk_pct'])} |
-| Son mum | {last_timestamp} |
-
-## Üst katman — Macro HMM
-
-| Gizli durum | Olasılık |
-|---|---:|
-| Macro 1 | {pct(macro[0])} |
-| Macro 2 | {pct(macro[1])} |
-| Macro 3 | {pct(macro[2])} |
-
-Bu durumların sırası her eğitimde değişebilir. Model bunları önceden bullish/bearish diye etiketlemez.
-
-## Alt katman — Micro HMM
-
-| Gizli durum | Olasılık |
-|---|---:|
-| Micro 1 | {pct(micro[0])} |
-| Micro 2 | {pct(micro[1])} |
-
-## Birleşik altı rejim
-
-| Rejim | Olasılık | Bayesian LONG |
-|---|---:|---:|
-| M1-U1 | {pct(joint[0])} | {pct(state_probs[0])} |
-| M1-U2 | {pct(joint[1])} | {pct(state_probs[1])} |
-| M2-U1 | {pct(joint[2])} | {pct(state_probs[2])} |
-| M2-U2 | {pct(joint[3])} | {pct(state_probs[3])} |
-| M3-U1 | {pct(joint[4])} | {pct(state_probs[4])} |
-| M3-U2 | {pct(joint[5])} | {pct(state_probs[5])} |
-
-## Walk-forward — %60 ile %80 arası
-
-| Metrik | Sonuç |
-|---|---:|
-| İşlem sayısı | {wf['trades']} |
-| Win rate | {pct(wf['win_rate'])} |
-| Profit Factor | {wf['profit_factor']:.2f} |
-| Net getiri | {pct(wf['net_return'])} |
-| Max drawdown | {pct(wf['max_drawdown'])} |
-
-## Bağımsız holdout — Son %20
-
-| Metrik | Sonuç |
-|---|---:|
-| İşlem sayısı | {holdout['trades']} |
-| Win rate | {pct(holdout['win_rate'])} |
-| Profit Factor | {holdout['profit_factor']:.2f} |
-| Net getiri | {pct(holdout['net_return'])} |
-| Max drawdown | {pct(holdout['max_drawdown'])} |
-
-## Overfit fark göstergesi
-
-**{overfit_label}**
-
-{(
-    f"{overfit_score:.1f}/100"
-    if overfit_score is not None
-    else "Hesaplanamadı"
-)}
-
-{overfit_note}
-
-## Optuna parametreleri
-
-| Parametre | Değer |
-|---|---:|
-| LONG/SHORT eşiği | {params['threshold']:.4f} |
-| Stop multiplier | {params['stop_multiplier']:.4f} |
-| Optuna skoru | {best_score:.4f} |
-
-## Walk-forward fold detayları
-
-| Fold | İşlem | Win rate | PF | Net getiri |
-|---|---:|---:|---:|---:|
-"""
-
-        for fold in fold_reports:
-
-            report += (
-                f"| {fold['fold']} "
-                f"| {fold['trades']} "
-                f"| {pct(fold['win_rate'])} "
-                f"| {fold['profit_factor']:.2f} "
-                f"| {pct(fold['net_return'])} |\n"
-            )
-
-        report += """
----
-
-### Model sınırlamaları
-
-- Rejimler gizlidir; Macro 1'in daima bullish olması beklenmemelidir.
-- Forward filtering kullanılır; gelecekteki mumlar canlı rejim olasılığına girmez.
-- HMM parametreleri her eğitim döneminde yalnızca o dönemin eğitim verisiyle öğrenilir.
-- Holdout verisi Optuna optimizasyonunda kullanılmaz.
-- 30'dan az işlem varsa performans istatistikleri güvenilir kabul edilmemelidir.
-- Backtest funding, likidasyon, gerçek spread ve emir defteri derinliğini tam modellemez.
-- 2R hedefi ve sonuçlar garanti edilmiş değildir.
-"""
-
-        return report
-
+        pairs = fetch_usdt_pairs(n_coins, n_coins)
     except Exception as e:
+        return f"ERROR fetching pairs: {e}", "", pd.DataFrame(), pd.DataFrame(), pd.DataFrame()
 
-        return (
-            "# UYGULAMA HATASI\n\n"
-            f"`{type(e).__name__}: {str(e)}`"
-        )
-
+    if not pairs:
+        return "ERROR: No USDT pairs found. Check network connectivity.", "", pd.DataFrame(), pd.DataFrame(), pd.DataFrame()
 
-# ============================================================
-# GRADIO UI
-# ============================================================
-
-with gr.Blocks(
-    title="OKX Hierarchical Bayesian Quant",
-    theme=gr.themes.Soft()
-) as demo:
+    # 2. For each pair, fetch klines, compute features, fit HMM, generate signals
+    all_signals = []
+    all_trades = []
+    analyzed = 0
+    failed = []
 
-    gr.Markdown(
-        """
-# BTC/USDT Hierarchical Bayesian Quant
+    # Limit concurrent processing to avoid rate limits
+    for idx, sym in enumerate(pairs):
+        progress((idx + 1) / len(pairs) * 0.9, desc=f"Processing {sym} ({idx+1}/{len(pairs)})")
+        time.sleep(0.15)  # gentle rate limiting
 
-**Macro HMM → Micro HMM → 6 latent regimes → Bayesian LONG/SHORT**
+        try:
+            df = fetch_klines(sym, timeframe, limit=1000)
+        except Exception:
+            df = None
 
-OKX perpetual swap · 1H · Long + Short
+        if df is None or len(df) < MIN_BARS_FOR_HMM:
+            failed.append(sym)
+            continue
 
-Klasik RSI, MACD, EMA veya Supertrend kullanılmaz.
-"""
-    )
+        try:
+            features = compute_features(df)
+            model = fit_hmm_on_training(features)
+            if model is None:
+                failed.append(sym)
+                continue
 
-    with gr.Row():
+            regime_probs = forward_filter_regimes(model, features)
+
+            # Override lambda for accumulation
+            _, E_accum, P_long, P_short = compute_regime_evidence(features, regime_probs)
+
+            # Re-accumulate with user lambda
+            n = len(features)
+            # Recompute raw evidence (we have E_raw from compute_regime_evidence but it used default lam)
+            # Recompute raw evidence cleanly
+            e_trend = np.zeros(n)
+            e_mean = np.zeros(n)
+            e_comp = np.zeros(n)
+            close = features["close"].values
+            ema_fast = features["ema_fast"].values
+            ema_slow = features["ema_slow"].values
+            efficiency = features["efficiency"].values
+            momentum = features["momentum"].values
+            atr_move = features["atr_move"].values
+            rsi_dev = features["rsi_dev"].values
+            dist_ma = features["dist_ma"].values
+            atr_ext = features["atr_extension"].values
+            vol_ratio = features["vol_ratio"].values
+            breakout = features["breakout"].values
+
+            for i in range(n):
+                # Trend
+                s = 0.0
+                if close[i] > ema_fast[i] > ema_slow[i]: s += 0.4
+                elif close[i] < ema_fast[i] < ema_slow[i]: s -= 0.4
+                s += 0.3 * efficiency[i]
+                s += 0.3 * np.tanh(momentum[i] * 10)
+                s += 0.2 * np.tanh(atr_move[i])
+                e_trend[i] = np.tanh(s * 2.0)
+
+                # Mean reversion
+                s = 0.0
+                s -= 0.4 * np.tanh(rsi_dev[i] * 3)
+                s -= 0.4 * np.tanh(dist_ma[i] * 20)
+                s -= 0.3 * np.tanh(atr_ext[i] * 2)
+                e_mean[i] = np.tanh(s * 2.0)
+
+                # Compression
+                contraction = max(0.0, 1.0 - vol_ratio[i])
+                e_comp[i] = np.tanh(breakout[i] * (0.5 + 0.5 * contraction) * 2.0)
+
+            E_raw = np.zeros(n)
+            for i in range(n):
+                p = regime_probs[i]
+                E_raw[i] = p[0] * e_trend[i] + p[1] * e_mean[i] + p[2] * e_comp[i]
+
+            E_accum = np.zeros(n)
+            E_accum[0] = E_raw[0]
+            for i in range(1, n):
+                E_accum[i] = evidence_memory * E_accum[i - 1] + (1.0 - evidence_memory) * E_raw[i]
+
+            P_long = np.array([_sigmoid(4.0 * e) for e in E_accum])
+            P_short = 1.0 - P_long
+
+            # Signals for latest bar
+            sigs = generate_signals(features, regime_probs, E_accum, P_long, P_short,
+                                    evidence_threshold, min_regime_conf)
+            for s in sigs:
+                s["symbol"] = sym
+            all_signals.extend(sigs)
+
+            # Backtest
+            trades = backtest_symbol(sym, features, regime_probs, E_accum, P_long, P_short,
+                                     evidence_threshold, min_regime_conf, max_holding)
+            all_trades.extend(trades)
+
+            analyzed += 1
+        except Exception:
+            failed.append(sym)
+            continue
 
-        candle_count = gr.Slider(
-            minimum=1000,
-            maximum=5000,
-            value=3000,
-            step=500,
-            label="OKX mum sayısı"
-        )
+    progress(1.0, desc="Done")
+
+    # 3. Build report strings
+    scan_lines = []
+    scan_lines.append(f"# RCEA Lite Market Scan Report")
+    scan_lines.append(f"**Timeframe:** {timeframe}")
+    scan_lines.append(f"**Coins requested:** {n_coins}")
+    scan_lines.append(f"**Coins successfully analyzed:** {analyzed}")
+    scan_lines.append(f"**Coins failed / insufficient data:** {len(failed)}")
+    if failed:
+        scan_lines.append(f"*Failed symbols: {', '.join(failed[:20])}{'...' if len(failed)>20 else ''}*")
+    scan_lines.append(f"**Evidence threshold:** {evidence_threshold}")
+    scan_lines.append(f"**Evidence memory (λ):** {evidence_memory}")
+    scan_lines.append(f"**Min regime confidence:** {min_regime_conf}")
+    scan_lines.append(f"**Max holding bars:** {max_holding}")
+    scan_lines.append(f"**Total trades (backtest):** {len(all_trades)}")
+    scan_lines.append(f"**Timestamp (UTC):** {datetime.now(timezone.utc).strftime('%Y-%m-%d %H:%M:%S')}")
+
+    if len(all_trades) < 30:
+        scan_lines.append(f"\n⚠️ **WARNING:** Only {len(all_trades)} trades generated. "
+                          f"Target is ≥30 genuine trades. Do NOT interpret metrics as statistically significant.")
+
+    scan_report = "\n".join(scan_lines)
+
+    # 4. Signal table
+    if all_signals:
+        sig_df = pd.DataFrame([{
+            "Symbol": s["symbol"],
+            "Signal": s["signal"],
+            "Evidence": round(s["evidence"], 4),
+            "P(Long)": round(s["P_long"], 4),
+            "P(Short)": round(s["P_short"], 4),
+            "Regime": s["dominant_regime"],
+            "Regime Conf": round(s["regime_conf"], 4),
+            "P(Trend)": round(s["regime_probs"]["TREND"], 4),
+            "P(MeanRev)": round(s["regime_probs"]["MEAN_REVERSION"], 4),
+            "P(Compress)": round(s["regime_probs"]["COMPRESSION"], 4),
+            "Close": s["close"],
+        } for s in all_signals])
+        # Sort: actionable signals first
+        sig_df["_priority"] = sig_df["Signal"].map({"LONG": 0, "SHORT": 0, "NO TRADE": 1})
+        sig_df = sig_df.sort_values(["_priority", "Evidence"], ascending=[True, False]).drop(columns=["_priority"])
+    else:
+        sig_df = pd.DataFrame(columns=["Symbol", "Signal", "Evidence", "P(Long)", "P(Short)",
+                                       "Regime", "Regime Conf", "P(Trend)", "P(MeanRev)",
+                                       "P(Compress)", "Close"])
+
+    # 5. Trade history
+    if all_trades:
+        trade_df = pd.DataFrame([{
+            "Symbol": t["symbol"],
+            "Direction": t["direction"],
+            "Entry Bar": t["entry_bar"],
+            "Exit Bar": t["exit_bar"],
+            "Bars Held": t["bars_held"],
+            "Entry": round(t["entry_price"], 6),
+            "Exit": round(t["exit_price"], 6),
+            "Stop": round(t["stop_price"], 6),
+            "Target": round(t["target_price"], 6),
+            "Exit Reason": t["exit_reason"],
+            "Gross Ret": round(t["gross_return"], 6),
+            "Net Ret": round(t["net_return"], 6),
+            "Regime": t["regime"],
+            "Regime Conf": round(t["regime_conf"], 4),
+            "Win": t["win"],
+        } for t in all_trades])
+        trade_df = trade_df.sort_values(["Symbol", "Entry Bar"])
+    else:
+        trade_df = pd.DataFrame(columns=["Symbol", "Direction", "Entry Bar", "Exit Bar",
+                                         "Bars Held", "Entry", "Exit", "Stop", "Target",
+                                         "Exit Reason", "Gross Ret", "Net Ret",
+                                         "Regime", "Regime Conf", "Win"])
+
+    # 6. Metrics
+    metrics = compute_metrics(all_trades)
+    metrics_lines = []
+    metrics_lines.append("# Performance Metrics (net of costs)")
+    metrics_lines.append(f"**Total trades:** {metrics['total_trades']}")
+    metrics_lines.append(f"**Win rate:** {metrics['win_rate']:.2%}")
+    metrics_lines.append(f"**Profit factor:** {metrics['profit_factor']:.3f}")
+    metrics_lines.append(f"**Net expectancy:** {metrics['net_expectancy']:.6f}")
+    metrics_lines.append(f"**Average win:** {metrics['avg_win']:.6f}")
+    metrics_lines.append(f"**Average loss:** {metrics['avg_loss']:.6f}")
+    metrics_lines.append(f"**Max drawdown:** {metrics['max_drawdown']:.2%}")
+    metrics_lines.append(f"**Net compounded return:** {metrics['net_compounded_return']:.2%}")
+    metrics_lines.append(f"**Long trades:** {metrics['long_trades']} (win rate: {metrics['long_win_rate']:.2%})")
+    metrics_lines.append(f"**Short trades:** {metrics['short_trades']} (win rate: {metrics['short_win_rate']:.2%})")
+    if metrics["total_trades"] < 30:
+        metrics_lines.append("\n⚠️ **Insufficient trades for reliable statistics.** Results are descriptive only.")
+    metrics_str = "\n".join(metrics_lines)
+
+    # 7. Regime & coin breakdowns
+    regime_df = regime_breakdown(all_trades)
+    coin_df = coin_breakdown(all_trades)
+
+    return scan_report, metrics_str, sig_df, trade_df, regime_df, coin_df
+
+
+# ---------------------------------------------------------------------------
+# Gradio UI
+# ---------------------------------------------------------------------------
+
+def build_ui():
+    with gr.Blocks(title="RCEA Lite v1.0", theme=gr.themes.Soft()) as demo:
+        gr.Markdown("""
+        # RCEA Lite v1.0 — Regime-Conditioned Evidence Accumulation
+        **Mathematical trading system** | HMM regime detection (causal forward filtering) | No supervised ML
+        """)
+
+        with gr.Row():
+            with gr.Column(scale=1):
+                timeframe = gr.Dropdown(
+                    choices=["15m", "1h", "4h", "1d"],
+                    value="1h",
+                    label="Timeframe",
+                )
+                n_coins = gr.Slider(30, 100, value=30, step=1, label="Number of coins (USDT pairs by 24h volume)")
+                evidence_threshold = gr.Slider(0.0, 1.0, value=0.15, step=0.01,
+                                               label="Evidence threshold (|E| > threshold for trade)")
+                evidence_memory = gr.Slider(0.0, 0.99, value=0.85, step=0.01,
+                                           label="Evidence memory coefficient (λ)")
+                min_regime_conf = gr.Slider(0.0, 1.0, value=0.40, step=0.01,
+                                           label="Minimum regime confidence")
+                max_holding = gr.Slider(10, 200, value=48, step=1,
+                                       label="Max holding period (bars)")
+                run_btn = gr.Button("🚀 Run RCEA Lite Scan", variant="primary")
+
+            with gr.Column(scale=2):
+                scan_output = gr.Markdown(label="Market Scan Report")
+                metrics_output = gr.Markdown(label="Performance Metrics")
+
+        with gr.Tabs():
+            with gr.Tab("📡 Current Signals"):
+                signals_table = gr.Dataframe(
+                    label="Long / Short / No Trade signals",
+                    wrap=True,
+                    interactive=False,
+                )
 
-        horizon = gr.Slider(
-            minimum=2,
-            maximum=24,
-            value=6,
-            step=1,
-            label="Tahmin ufku (saat)"
-        )
+            with gr.Tab("📜 Trade History"):
+                trades_table = gr.Dataframe(
+                    label="Backtest trade history",
+                    wrap=True,
+                    interactive=False,
+                )
 
-    with gr.Row():
+            with gr.Tab("📊 Regime Breakdown"):
+                regime_table = gr.Dataframe(
+                    label="Performance by market regime",
+                    interactive=False,
+                )
 
-        trials = gr.Slider(
-            minimum=5,
-            maximum=40,
-            value=10,
-            step=5,
-            label="Optuna denemesi"
-        )
+            with gr.Tab("🪙 Coin Breakdown"):
+                coin_table = gr.Dataframe(
+                    label="Performance by coin",
+                    interactive=False,
+                )
 
-        fee_percent = gr.Slider(
-            minimum=0,
-            maximum=0.20,
-            value=0.05,
-            step=0.01,
-            label="Komisyon % / taraf"
+        run_btn.click(
+            fn=run_rcea_scan,
+            inputs=[timeframe, n_coins, evidence_threshold, evidence_memory,
+                    min_regime_conf, max_holding],
+            outputs=[scan_output, metrics_output, signals_table, trades_table,
+                     regime_table, coin_table],
         )
 
-        slippage_bps = gr.Slider(
-            minimum=0,
-            maximum=20,
-            value=2,
-            step=1,
-            label="Kayma baz puan / taraf"
-        )
+        gr.Markdown("""
+        ---
+        **Disclaimer:** This is a research tool. Past backtest performance does not guarantee future results.
+        All returns are net of estimated commissions (0.10% per side) and slippage (0.05% per side).
+        HMM is used for regime detection only; no supervised machine-learning prediction is employed.
+        """)
 
-    run_button = gr.Button(
-        "HIERARCHICAL QUANT ANALİZİ",
-        variant="primary"
-    )
+    return demo
 
-    output = gr.Markdown()
-
-    run_button.click(
-        fn=run_app,
-        inputs=[
-            candle_count,
-            horizon,
-            trials,
-            fee_percent,
-            slippage_bps
-        ],
-        outputs=output
-    )
 
+# ---------------------------------------------------------------------------
+# Entry point
+# ---------------------------------------------------------------------------
 
 if __name__ == "__main__":
-
-    demo.queue()
-
-    demo.launch()
+    demo = build_ui()
+    demo.launch(server_name="0.0.0.0", server_port=7860)