Update app.py

app.py

@@ -1,20 +1,11 @@
 """
 RCEA Lite v1.0 — Regime-Conditioned Evidence Accumulation
-Mathematical trading system with causal HMM regime detection.
-
-NO supervised ML, NO predictive classifiers.
-HMM is used exclusively for probabilistic regime detection (forward filtering only).
-
-Author: Quantitative Development
-License: MIT
+Causal HMM regime detection. No supervised ML.
 """
 
-import os
-import math
-import time
-import warnings
+import math, time, warnings
 from datetime import datetime, timezone
-from typing import Dict, List, Optional, Tuple
+from typing import List, Optional, Tuple
 
 import numpy as np
 import pandas as pd
@@ -24,1133 +15,459 @@ from hmmlearn import hmm
 
 warnings.filterwarnings("ignore")
 
-# ---------------------------------------------------------------------------
-# Configuration
-# ---------------------------------------------------------------------------
-
-BINANCE_BASE = "https://api.binance.com"
-BINANCE_DATA = "https://data-api.binance.vision"  # fallback
-
-REQUEST_TIMEOUT = 15
-MAX_RETRIES = 3
-RETRY_DELAY = 1.5
-
-# 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
-
-# Regime labels
-REGIME_TREND = 0
-REGIME_MEAN_REV = 1
-REGIME_COMPRESSION = 2
+# ---------- Config ----------
+HOSTS = ["https://api.binance.com", "https://data-api.binance.vision", "https://api.binance.us"]
+TIMEOUT, RETRIES, DELAY = 20, 3, 1.5
+COMMISSION, SLIPPAGE = 0.001, 0.0005
+COST = 2 * (COMMISSION + SLIPPAGE)
 REGIME_NAMES = ["TREND", "MEAN_REVERSION", "COMPRESSION"]
+HMM_K = 3
+TRAIN_FRAC, PURGE, EMBARGO = 0.60, 5, 3
+MIN_HMM, MIN_SIG = 200, 100
+LEV_PRE = ("3L", "3S", "5L", "5S", "BULL", "BEAR", "UP", "DOWN")
+LEV_SUF = ("3LUSDT", "3SUSDT", "5LUSDT", "5SUSDT", "BULLUSDT", "BEARUSDT", "UPUSDT", "DOWNUSDT")
+FEAT_COLS = ["ret", "atr_norm", "ema_diff_norm", "efficiency", "rsi_dev", "dist_ma"]
 
-# HMM parameters (fixed, transparent — no per-run optimisation)
-HMM_N_COMPONENTS = 3
-HMM_N_ITER = 100
-HMM_COVARIANCE_TYPE = "diag"
-HMM_RANDOM_STATE = 42
-
-# Walk-forward
-TRAIN_FRACTION = 0.60
-PURGE_BARS = 5
-EMBARGO_BARS = 3
-
-# Minimum data requirements
-MIN_BARS_FOR_HMM = 200
-MIN_BARS_FOR_SIGNAL = 100
-
-# 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")
-
-
-# ---------------------------------------------------------------------------
-# Utilities
-# ---------------------------------------------------------------------------
 
-def _safe_float(x) -> Optional[float]:
+# ---------- Helpers ----------
+def _f(x):
     try:
-        v = float(x)
-        return v if math.isfinite(v) else None
+        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 _sig(x):
+    return 1.0 / (1.0 + math.exp(-x)) if x >= 0 else math.exp(x) / (1.0 + math.exp(x))
 
 
-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 _ema(a, span):
+    al = 2.0 / (span + 1.0)
+    o = np.empty_like(a, dtype=float); o[0] = a[0]
+    for i in range(1, len(a)): o[i] = al * a[i] + (1 - al) * o[i - 1]
+    return o
 
 
-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]
+def _atr(h, l, c, p=14):
+    n = len(c); tr = np.empty(n)
+    tr[0] = h[0] - l[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)
+        tr[i] = max(h[i] - l[i], abs(h[i] - c[i-1]), abs(l[i] - c[i-1]))
+    return _ema(tr, p)
 
 
-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)
+def _rsi(c, p=14):
+    d = np.diff(c, prepend=c[0])
+    g = np.where(d > 0, d, 0.0); ls = np.where(d < 0, -d, 0.0)
+    ag, al = _ema(g, p), _ema(ls, p)
+    rs = np.where(al > 1e-12, ag / al, 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
-            return None
-        except (requests.RequestException, ValueError):
-            time.sleep(RETRY_DELAY * (attempt + 1))
+# ---------- Binance ----------
+def _req(path, params, timeout=TIMEOUT):
+    last = None
+    for attempt in range(RETRIES):
+        for base in HOSTS:
+            try:
+                r = requests.get(base + path, params=params, timeout=timeout,
+                                 headers={"User-Agent": "RCEA-Lite/1.0"})
+                if r.status_code == 200:
+                    d = r.json()
+                    if isinstance(d, list): return d
+                    last = f"non-list {type(d).__name__}"
+                elif r.status_code in (418, 429):
+                    last = f"HTTP {r.status_code}"; time.sleep(5 * (attempt + 1))
+                elif r.status_code >= 500:
+                    last = f"HTTP {r.status_code}"; time.sleep(DELAY * (attempt + 1))
+                else:
+                    last = f"HTTP {r.status_code}: {r.text[:100]}"; break
+            except requests.RequestException as e:
+                last = f"{type(e).__name__}: {e}"
+        time.sleep(DELAY * (attempt + 1))
+    print(f"[RCEA] {path} failed: {last}", flush=True)
     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_pairs(n=30):
+    info = _req("/api/v3/exchangeInfo", {}, timeout=30)
+    if not info: return []
+    syms = set()
+    for s in info:
+        if s.get("status") != "TRADING" or s.get("quoteAsset") != "USDT": continue
+        sym, base = s.get("symbol", ""), s.get("baseAsset", "").upper()
+        if not sym or not base: continue
+        if any(base.startswith(p) for p in LEV_PRE): continue
+        if any(sym.upper().endswith(p) for p in LEV_SUF): continue
+        syms.add(sym)
+    tick = _req("/api/v3/ticker/24hr", {})
+    if not tick: return []
+    cand = []
+    for t in tick:
+        s = t.get("symbol")
+        if s not in syms: continue
+        q = _f(t.get("quoteVolume"))
+        if q and q > 0: cand.append((s, q))
+    cand.sort(key=lambda x: x[1], reverse=True)
+    out = [c[0] for c in cand[:n]]
+    print(f"[RCEA] {len(out)} pairs resolved", flush=True)
+    return out
 
-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
 
+def fetch_klines(sym, interval, limit=1000):
+    raw = _req("/api/v3/klines", {"symbol": sym, "interval": interval, "limit": min(limit, 1000)})
+    if not raw: return None
+    now = int(datetime.now(timezone.utc).timestamp() * 1000)
     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,
-        })
-
-    if len(rows) < MIN_BARS_FOR_HMM:
-        return None
+        if not isinstance(k, list) or len(k) < 7: continue
+        if int(k[6]) >= now: continue
+        o, h, l, c, v = _f(k[1]), _f(k[2]), _f(k[3]), _f(k[4]), _f(k[5])
+        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})
+    if len(rows) < MIN_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])))
+# ---------- Features ----------
+def features(df):
+    c = df["close"].values.astype(float)
+    h = df["high"].values.astype(float)
+    lo = df["low"].values.astype(float)
+    n = len(c)
+    o = pd.DataFrame(index=df.index)
+    o["close"] = c
+    r = np.zeros(n); r[1:] = np.diff(c) / c[:-1]; o["ret"] = r
+    a14 = _atr(h, lo, c, 14); o["atr"] = a14
+    o["atr_norm"] = a14 / np.where(c > 0, c, 1.0)
+    ef, es = _ema(c, 12), _ema(c, 26)
+    o["ema_fast"], o["ema_slow"] = ef, es
+    o["ema_diff_norm"] = (ef - es) / np.where(c > 0, c, 1.0)
+    lb, eff = 10, np.zeros(n)
+    for i in range(lb, n):
+        net = c[i] - c[i - lb]; path = np.sum(np.abs(np.diff(c[i - lb: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)
-    )
-
-    # 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,
-    )
-    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]
-
+    o["efficiency"] = eff
+    mom = np.zeros(n); mom[10:] = (c[10:] - c[:-10]) / np.where(c[:-10] > 0, c[:-10], 1.0)
+    o["momentum"] = mom
+    am = np.zeros(n); am[1:] = np.diff(c) / np.where(a14[1:] > 1e-12, a14[1:], 1.0)
+    o["atr_move"] = am
+    rs = _rsi(c, 14); o["rsi"] = rs; o["rsi_dev"] = (rs - 50.0) / 50.0
+    rm = pd.Series(c).rolling(20, min_periods=20).mean().values
+    dm = np.where(rm > 0, (c - rm) / rm, 0.0); o["dist_ma"] = np.nan_to_num(dm)
+    ae = np.where(a14 > 1e-12, (c - rm) / a14, 0.0); o["atr_extension"] = np.nan_to_num(ae)
+    a5, a20 = _atr(h, lo, c, 5), _atr(h, lo, c, 20)
+    o["vol_ratio"] = np.where(a20 > 1e-12, a5 / a20, 1.0)
+    ph, pl_ = np.roll(h, 1), np.roll(lo, 1)
+    ph[0], pl_[0] = h[0], lo[0]
+    o["prev_high"], o["prev_low"] = ph, pl_
+    o["breakout"] = np.where(c > ph, 1.0, np.where(c < pl_, -1.0, 0.0))
+    return o.replace([np.inf, -np.inf], np.nan).fillna(0.0)
+
+
+# ---------- HMM ----------
+def fit_hmm(f):
+    ntr = min(max(MIN_HMM, int(len(f) * TRAIN_FRAC)), len(f) - 20)
+    if ntr < MIN_HMM: return None
+    X = f.iloc[:ntr][FEAT_COLS].values
+    mu, sd = X.mean(0), X.std(0); sd[sd < 1e-12] = 1.0
+    m = hmm.GaussianHMM(n_components=HMM_K, covariance_type="diag",
+                        n_iter=100, random_state=42, tol=1e-4)
+    try: m.fit((X - mu) / sd)
+    except Exception: return None
+    m._mu, m._sd = mu, sd
+    return m
+
+
+def forward_filter(m, f):
+    n = len(f)
+    post = np.ones((n, HMM_K)) / HMM_K
+    ntr = min(max(MIN_HMM, int(n * TRAIN_FRAC)), n - 20)
+    if ntr < 10: return post
+    X = (f[FEAT_COLS].values - m._mu) / m._sd
+    ls, lt = np.log(m.startprob_ + 1e-300), np.log(m.transmat_ + 1e-300)
+    le = np.zeros((n, HMM_K))
+    for k in range(HMM_K):
+        cov = m.covars_[k]; var = np.diag(cov) if cov.ndim > 1 else cov
+        var = np.maximum(var, 1e-6); d = X - m.means_[k]
+        le[:, k] = -0.5 * np.sum(d * d / var, 1) - 0.5 * np.sum(np.log(2 * np.pi * var))
+    a = np.zeros((n, HMM_K)); a[0] = ls + le[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 k in range(HMM_K):
+            terms = a[t - 1] + lt[:, k]; mx = terms.max()
+            a[t, k] = le[t, k] + mx + np.log(np.exp(terms - mx).sum())
     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)
+        e = np.exp(a[t] - a[t].max()); post[t] = e / e.sum()
+    post[:ntr] = 1.0 / HMM_K
+    return post
+
+
+# ---------- Evidence ----------
+def evidence(f, rp, lam):
+    n = len(f)
+    c = f["close"].values; ef = f["ema_fast"].values; es = f["ema_slow"].values
+    eff = f["efficiency"].values; mom = f["momentum"].values; am = f["atr_move"].values
+    rd = f["rsi_dev"].values; dm = f["dist_ma"].values; ae = f["atr_extension"].values
+    vr = f["vol_ratio"].values; bo = f["breakout"].values
+    et, em, ec = np.zeros(n), np.zeros(n), 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 e < -evidence_threshold and ps > 0.5:
-        signal = "SHORT"
-
-    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)
-
+        s = 0.0
+        if c[i] > ef[i] > es[i]: s += 0.4
+        elif c[i] < ef[i] < es[i]: s -= 0.4
+        s += 0.3 * eff[i] + 0.3 * np.tanh(mom[i] * 10) + 0.2 * np.tanh(am[i])
+        et[i] = np.tanh(s * 2.0)
+        s = -0.4 * np.tanh(rd[i] * 3) - 0.4 * np.tanh(dm[i] * 20) - 0.3 * np.tanh(ae[i] * 2)
+        em[i] = np.tanh(s * 2.0)
+        contr = max(0.0, 1.0 - vr[i])
+        ec[i] = np.tanh(bo[i] * (0.5 + 0.5 * contr) * 2.0)
+    raw = rp[:, 0] * et + rp[:, 1] * em + rp[:, 2] * ec
+    acc = np.zeros(n); acc[0] = raw[0]
+    for i in range(1, n): acc[i] = lam * acc[i - 1] + (1 - lam) * raw[i]
+    pl = np.array([_sig(4.0 * x) for x in acc])
+    return acc, pl, 1.0 - pl
+
+
+# ---------- Signal + backtest ----------
+def latest_signal(f, rp, acc, pl, ps, thr, mconf):
+    i = len(f) - 1
+    if i < MIN_SIG: return None
+    p = rp[i]; dom = int(np.argmax(p)); conf = float(p[dom])
+    if conf < mconf: return None
+    e, l, s = float(acc[i]), float(pl[i]), float(ps[i])
+    sig = "LONG" if e > thr and l > 0.5 else "SHORT" if e < -thr and s > 0.5 else "NO TRADE"
+    return {"signal": sig, "evidence": e, "P_long": l, "P_short": s,
+            "regime_probs": {REGIME_NAMES[j]: float(p[j]) for j in range(HMM_K)},
+            "dominant_regime": REGIME_NAMES[dom], "regime_conf": conf,
+            "close": float(f["close"].values[i])}
+
+
+def backtest(sym, f, rp, acc, pl, ps, thr, mconf, maxhold):
+    n = len(f); c = f["close"].values; h = f["high"].values; lo = f["low"].values
+    atr = f["atr"].values
+    trades = []; in_pos = False; ei = eprice = d = sp = tp = 0
+    reg = ""; rconf = 0.0
+    start = max(MIN_SIG, int(n * TRAIN_FRAC) + PURGE + EMBARGO)
     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
-
-            e = E_accum[i]
-            pl = P_long[i]
-            ps = P_short[i]
-
-            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 entry_dir == 0:
-                continue
-
-            # 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
-
-            direction = entry_dir
-            entry_idx = i
-            in_position = True
-
-            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
-
-            regime_at_entry = REGIME_NAMES[dominant]
-            regime_conf_at_entry = conf
-
+        if not in_pos:
+            p = rp[i]; dom = int(np.argmax(p)); conf = float(p[dom])
+            if conf < mconf: continue
+            ed = 1 if acc[i] > thr and pl[i] > 0.5 else -1 if acc[i] < -thr and ps[i] > 0.5 else 0
+            if ed == 0 or atr[i] < 1e-12: continue
+            eprice = c[i] * (1.0 + SLIPPAGE * ed); d = ed; ei = i; in_pos = True
+            if d == 1: sp, tp = eprice - 1.5 * atr[i], eprice + 3.0 * atr[i]
+            else:       sp, tp = eprice + 1.5 * atr[i], eprice - 3.0 * atr[i]
+            reg, rconf = REGIME_NAMES[dom], conf
         else:
-            # In position: check exit
-            bars_held = i - entry_idx
-
-            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
-
+            bh = i - ei
+            hs = lo[i] <= sp if d == 1 else h[i] >= sp
+            ht = h[i] >= tp if d == 1 else lo[i] <= tp
+            xp = xr = None
+            if hs and ht: xp, xr = sp, "STOP (both, conservative)"
+            elif hs: xp, xr = sp, "STOP"
+            elif ht: xp, xr = tp, "TARGET"
+            elif bh >= maxhold: xp, xr = c[i], "TIME"
+            if xp is not None:
+                xa = xp * (1.0 - SLIPPAGE * d)
+                gr = (xa - eprice) / eprice if d == 1 else (eprice - xa) / eprice
+                nr = gr - COST
+                trades.append({"symbol": sym, "direction": "LONG" if d == 1 else "SHORT",
+                               "entry_bar": ei, "exit_bar": i, "bars_held": bh,
+                               "entry_price": eprice, "exit_price": xa,
+                               "stop_price": sp, "target_price": tp,
+                               "exit_reason": xr, "gross_return": gr, "net_return": nr,
+                               "regime": reg, "regime_conf": rconf, "win": nr > 0})
+                in_pos = False
     return trades
 
 
-# ---------------------------------------------------------------------------
-# Performance metrics
-# ---------------------------------------------------------------------------
-
-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,
-        }
-
-    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 {
-        "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,
-    }
-
-
-def regime_breakdown(trades: List[dict]) -> pd.DataFrame:
+# ---------- Metrics ----------
+def metrics(trades):
     if not trades:
-        return pd.DataFrame()
+        return dict(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)
+    r = np.array([t["net_return"] for t in trades])
+    w, l = r[r > 0], r[r <= 0]
+    gp = w.sum() if len(w) else 0.0; gl = abs(l.sum()) if len(l) else 0.0
+    eq = np.cumprod(1 + r); peak = np.maximum.accumulate(eq)
+    dd = (eq - peak) / peak
+    longs = [t for t in trades if t["direction"] == "LONG"]
+    shorts = [t for t in trades if t["direction"] == "SHORT"]
+    lw = sum(1 for t in longs if t["win"]); sw = sum(1 for t in shorts if t["win"])
+    return dict(total_trades=len(r),
+                win_rate=len(w) / len(r), profit_factor=gp / gl if gl > 1e-12 else 999.0,
+                net_expectancy=float(r.mean()), avg_win=float(w.mean()) if len(w) else 0.0,
+                avg_loss=float(l.mean()) if len(l) else 0.0,
+                max_drawdown=float(dd.min()) if len(dd) else 0.0,
+                net_compounded_return=float(eq[-1] - 1) if len(eq) else 0.0,
+                long_trades=len(longs), short_trades=len(shorts),
+                long_win_rate=lw / len(longs) if longs else 0.0,
+                short_win_rate=sw / len(shorts) if shorts else 0.0)
+
+
+def regime_table(trades):
+    if not trades: return pd.DataFrame(columns=["Regime", "Trades", "WinRate", "PF", "NetExp"])
     rows = []
-    for regime in REGIME_NAMES:
-        rt = [t for t in trades if t["regime"] == regime]
+    for reg in REGIME_NAMES:
+        rt = [t for t in trades if t["regime"] == reg]
         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(),
-        })
+            rows.append({"Regime": reg, "Trades": 0, "WinRate": 0.0, "PF": 0.0, "NetExp": 0.0}); continue
+        n = np.array([t["net_return"] for t in rt])
+        w, l = n[n > 0], n[n <= 0]
+        gp = w.sum() if len(w) else 0.0; gl = abs(l.sum()) if len(l) else 0.0
+        rows.append({"Regime": reg, "Trades": len(rt),
+                     "WinRate": round(len(w) / len(rt), 4),
+                     "PF": round(gp / gl, 4) if gl > 1e-12 else 999.0,
+                     "NetExp": round(float(n.mean()), 6)})
     return pd.DataFrame(rows)
 
 
-def coin_breakdown(trades: List[dict]) -> pd.DataFrame:
-    if not trades:
-        return pd.DataFrame()
-    symbols = sorted(set(t["symbol"] for t in trades))
+def coin_table(trades):
+    if not trades: return pd.DataFrame(columns=["Symbol", "Trades", "WinRate", "NetExp", "TotalNet"])
     rows = []
-    for sym in symbols:
+    for sym in sorted({t["symbol"] for t in trades}):
         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,
-        })
+        n = np.array([t["net_return"] for t in st])
+        w = n[n > 0]
+        rows.append({"Symbol": sym, "Trades": len(st),
+                     "WinRate": round(len(w) / len(st), 4),
+                     "NetExp": round(float(n.mean()), 6),
+                     "TotalNet": round(float(n.sum()), 6)})
     return pd.DataFrame(rows).sort_values("TotalNet", ascending=False)
 
 
-# ---------------------------------------------------------------------------
-# Main pipeline
-# ---------------------------------------------------------------------------
+# ---------- Pipeline (always 6 outputs) ----------
+def run(timeframe, n_coins, thr, lam, mconf, maxhold, progress=gr.Progress()):
+    def err(msg, detail=""):
+        return msg, detail, pd.DataFrame(), pd.DataFrame(), pd.DataFrame(), pd.DataFrame()
 
-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)))
+    thr = max(0.0, min(1.0, float(thr)))
+    lam = max(0.0, min(0.99, float(lam)))
+    mconf = max(0.0, min(1.0, float(mconf)))
+    maxhold = max(5, min(200, int(maxhold)))
 
     if timeframe not in ("15m", "1h", "4h", "1d"):
-        return "ERROR: Invalid timeframe", "", pd.DataFrame(), pd.DataFrame(), pd.DataFrame()
+        return err("ERROR: Invalid timeframe")
 
-    # 1. Fetch pairs
     progress(0.02, desc="Fetching USDT pairs...")
-    try:
-        pairs = fetch_usdt_pairs(n_coins, n_coins)
-    except Exception as e:
-        return f"ERROR fetching pairs: {e}", "", pd.DataFrame(), pd.DataFrame(), pd.DataFrame()
-
+    try: pairs = fetch_pairs(n_coins)
+    except Exception as e: return err(f"ERROR fetching pairs: {e}")
     if not pairs:
-        return "ERROR: No USDT pairs found. Check network connectivity.", "", pd.DataFrame(), pd.DataFrame(), pd.DataFrame()
-
-    # 2. For each pair, fetch klines, compute features, fit HMM, generate signals
-    all_signals = []
-    all_trades = []
-    analyzed = 0
-    failed = []
-
-    # 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
-
-        try:
-            df = fetch_klines(sym, timeframe, limit=1000)
-        except Exception:
-            df = None
-
-        if df is None or len(df) < MIN_BARS_FOR_HMM:
-            failed.append(sym)
-            continue
-
+        return err("ERROR: No USDT pairs found.\n\n"
+                   "Possible causes: Binance API blocked from this region, rate limit, or timeout. "
+                   "Check Space logs for `[RCEA] ...` messages.")
+
+    signals, trades, analyzed, failed = [], [], 0, []
+    for i, sym in enumerate(pairs):
+        progress((i + 1) / len(pairs) * 0.9, desc=f"{sym} ({i+1}/{len(pairs)})")
+        time.sleep(0.15)
+        df = fetch_klines(sym, timeframe)
+        if df is None: failed.append(sym); continue
         try:
-            features = compute_features(df)
-            model = fit_hmm_on_training(features)
-            if model is None:
-                failed.append(sym)
-                continue
-
-            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)
-
+            f = features(df)
+            m = fit_hmm(f)
+            if m is None: failed.append(sym); continue
+            rp = forward_filter(m, f)
+            acc, pl, ps = evidence(f, rp, lam)
+            s = latest_signal(f, rp, acc, pl, ps, thr, mconf)
+            if s: s["symbol"] = sym; signals.append(s)
+            trades.extend(backtest(sym, f, rp, acc, pl, ps, thr, mconf, maxhold))
             analyzed += 1
-        except Exception:
-            failed.append(sym)
-            continue
-
+        except Exception as e:
+            print(f"[RCEA] {sym}: {e}", flush=True); failed.append(sym)
     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:
+    scan = ["# RCEA Lite Market Scan Report",
+            f"**Timeframe:** {timeframe}",
+            f"**Coins requested:** {n_coins}",
+            f"**Analyzed:** {analyzed}",
+            f"**Failed:** {len(failed)}",
+            f"**Trades:** {len(trades)}",
+            f"**Threshold:** {thr} | **λ:** {lam} | **MinConf:** {mconf} | **MaxHold:** {maxhold}",
+            f"**UTC:** {datetime.now(timezone.utc).strftime('%Y-%m-%d %H:%M:%S')}"]
+    if len(trades) < 30:
+        scan.append(f"\n⚠️ Only {len(trades)} trades — target ≥30. Metrics are descriptive only.")
+    scan_report = "\n".join(scan)
+
+    if signals:
         sig_df = pd.DataFrame([{
-            "Symbol": s["symbol"],
-            "Signal": s["signal"],
+            "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(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"])
+            "Close": s["close"]} for s in signals])
+        sig_df["_p"] = sig_df["Signal"].map({"LONG": 0, "SHORT": 0, "NO TRADE": 1})
+        sig_df = sig_df.sort_values(["_p", "Evidence"], ascending=[True, False]).drop(columns="_p")
     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"])
+                                        "Regime", "Regime Conf", "P(Trend)", "P(MeanRev)",
+                                        "P(Compress)", "Close"])
+
+    if trades:
+        tr_df = pd.DataFrame([{
+            "Symbol": t["symbol"], "Direction": t["direction"],
+            "Entry Bar": t["entry_bar"], "Exit Bar": t["exit_bar"],
+            "Bars": 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),
+            "Reason": t["exit_reason"],
+            "Gross": round(t["gross_return"], 6), "Net": round(t["net_return"], 6),
+            "Regime": t["regime"], "Regime Conf": round(t["regime_conf"], 4),
+            "Win": t["win"]} for t in trades]).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,
-                )
-
-            with gr.Tab("📜 Trade History"):
-                trades_table = gr.Dataframe(
-                    label="Backtest trade history",
-                    wrap=True,
-                    interactive=False,
-                )
-
-            with gr.Tab("📊 Regime Breakdown"):
-                regime_table = gr.Dataframe(
-                    label="Performance by market regime",
-                    interactive=False,
-                )
-
-            with gr.Tab("🪙 Coin Breakdown"):
-                coin_table = gr.Dataframe(
-                    label="Performance by coin",
-                    interactive=False,
-                )
-
-        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],
-        )
-
-        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.
-        """)
-
-    return demo
-
+        tr_df = pd.DataFrame(columns=["Symbol", "Direction", "Entry Bar", "Exit Bar", "Bars",
+                                       "Entry", "Exit", "Stop", "Target", "Reason",
+                                       "Gross", "Net", "Regime", "Regime Conf", "Win"])
+
+    m = metrics(trades)
+    m_str = "\n".join([
+        "# Performance Metrics (net of costs)",
+        f"**Total trades:** {m['total_trades']}",
+        f"**Win rate:** {m['win_rate']:.2%}",
+        f"**Profit factor:** {m['profit_factor']:.3f}",
+        f"**Net expectancy:** {m['net_expectancy']:.6f}",
+        f"**Avg win / loss:** {m['avg_win']:.6f} / {m['avg_loss']:.6f}",
+        f"**Max DD:** {m['max_drawdown']:.2%}",
+        f"**Net compounded:** {m['net_compounded_return']:.2%}",
+        f"**Long:** {m['long_trades']} ({m['long_win_rate']:.2%}) | "
+        f"**Short:** {m['short_trades']} ({m['short_win_rate']:.2%})",
+    ])
+    if m["total_trades"] < 30:
+        m_str += "\n\n⚠️ Insufficient trades for reliable statistics."
+
+    return scan_report, m_str, sig_df, tr_df, regime_table(trades), coin_table(trades)
+
+
+# ---------- UI ----------
+with gr.Blocks(title="RCEA Lite v1.0") as demo:
+    gr.Markdown("# RCEA Lite v1.0 — Regime-Conditioned Evidence Accumulation\n"
+                "HMM regime detection (causal forward filtering) · No supervised ML")
+    with gr.Row():
+        with gr.Column(scale=1):
+            tf = gr.Dropdown(["15m", "1h", "4h", "1d"], value="1h", label="Timeframe")
+            nc = gr.Slider(30, 100, value=30, step=1, label="Coins")
+            thr_i = gr.Slider(0.0, 1.0, value=0.15, step=0.01, label="Evidence threshold")
+            lam_i = gr.Slider(0.0, 0.99, value=0.85, step=0.01, label="Memory λ")
+            mc_i = gr.Slider(0.0, 1.0, value=0.40, step=0.01, label="Min regime confidence")
+            mh_i = gr.Slider(10, 200, value=48, step=1, label="Max holding (bars)")
+            btn = gr.Button("🚀 Run Scan", variant="primary")
+        with gr.Column(scale=2):
+            scan_out = gr.Markdown(label="Scan Report")
+            met_out = gr.Markdown(label="Metrics")
+    with gr.Tabs():
+        with gr.Tab("📡 Signals"): sig_tbl = gr.Dataframe(interactive=False, wrap=True)
+        with gr.Tab("📜 Trades"): tr_tbl = gr.Dataframe(interactive=False, wrap=True)
+        with gr.Tab("📊 Regime"): reg_tbl = gr.Dataframe(interactive=False)
+        with gr.Tab("🪙 Coins"): coin_tbl = gr.Dataframe(interactive=False)
+    btn.click(run, inputs=[tf, nc, thr_i, lam_i, mc_i, mh_i],
+              outputs=[scan_out, met_out, sig_tbl, tr_tbl, reg_tbl, coin_tbl])
+    gr.Markdown("---\n**Disclaimer:** Research tool. Net of 0.10% commission + 0.05% slippage per side. "
+                "No supervised ML prediction is used.")
 
-# ---------------------------------------------------------------------------
-# Entry point
-# ---------------------------------------------------------------------------
 
 if __name__ == "__main__":
-    demo = build_ui()
     demo.launch(server_name="0.0.0.0", server_port=7860)