Update app.py

app.py

@@ -1,35 +1,40 @@
 """
-RCEA Lite v1.0 — OKX Edition
-Regime-Conditioned Evidence Accumulation. Causal HMM. No supervised ML.
+RCEA Lite v1.0 — Forex Edition (GitHub CSV)
+Regime-Conditioned Evidence Accumulation + BOCPD.
+Causal. No supervised ML. No API key required.
 """
 
 import math, time, warnings
 from datetime import datetime, timezone
-from typing import List, Optional
 
 import numpy as np
 import pandas as pd
-import requests
 import gradio as gr
 from hmmlearn import hmm
 
 warnings.filterwarnings("ignore")
 
 # ---------- Config ----------
-OKX_BASE = "https://www.okx.com"
-TIMEOUT, RETRIES, DELAY = 20, 3, 1.5
-COMMISSION, SLIPPAGE = 0.001, 0.0005
+GITHUB_RAW = "https://raw.githubusercontent.com/ejtraderLabs/historical-data/main"
+FOREX_SYMBOLS = [
+    "EURUSD", "GBPUSD", "USDJPY", "AUDUSD", "USDCAD",
+    "USDCHF", "EURGBP", "EURJPY", "GBPJPY", "EURCHF",
+    "AUDJPY", "XAUUSD",
+]
+TF_MAP = {"15m": "m15", "1h": "h1", "4h": "h4", "1d": "d1"}
+COMMISSION, SLIPPAGE = 0.0002, 0.0001
 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 = 150, 80
-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"]
+TARGET_BARS = 2000
 
-TF_MAP = {"15m": "15m", "1h": "1H", "4h": "4H", "1d": "1D"}
-TARGET_BARS = 1000
+BOCPD_HAZARD = 1.0 / 250.0
+BOCPD_MAX_RUN = 300
+BOCPD_PRIOR_MU, BOCPD_PRIOR_KAPPA = 0.0, 0.1
+BOCPD_PRIOR_ALPHA, BOCPD_PRIOR_BETA = 0.1, 1e-4
 
 
 # ---------- Helpers ----------
@@ -67,135 +72,105 @@ def _rsi(c, p=14):
     return 100.0 - 100.0 / (1.0 + rs)
 
 
-# ---------- OKX API ----------
-def _req(path, params, timeout=TIMEOUT):
-    last = None
-    for attempt in range(RETRIES):
-        try:
-            r = requests.get(OKX_BASE + path, params=params, timeout=timeout,
-                             headers={"User-Agent": "RCEA-Lite/1.0"})
-            if r.status_code == 200:
-                j = r.json()
-                if j.get("code") == "0":
-                    return j.get("data")
-                last = f"code={j.get('code')} msg={j.get('msg', '')[:100]}"
-            elif r.status_code in (429, 418):
-                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_pairs(n=30):
-    """Fetch USDT spot pairs ranked by 24h quote volume on OKX."""
-    inst = _req("/api/v5/public/instruments", {"instType": "SPOT"})
-    if not inst:
-        print("[RCEA] instruments unavailable", flush=True)
-        return []
-
-    usdt_syms = set()
-    for i in inst:
-        if i.get("state") != "live" or i.get("quoteCcy") != "USDT":
-            continue
-        sym, base = i.get("instId", ""), i.get("baseCcy", "").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
-        usdt_syms.add(sym)
-
-    if not usdt_syms:
-        print("[RCEA] no USDT spot pairs found", flush=True)
-        return []
-
-    tick = _req("/api/v5/market/tickers", {"instType": "SPOT"})
-    if not tick:
-        print("[RCEA] tickers unavailable", flush=True)
-        return []
-
-    cand = []
-    for t in tick:
-        sym = t.get("instId", "")
-        if sym not in usdt_syms:
-            continue
-        q = _f(t.get("volCcy24h"))
-        if q and q > 0:
-            cand.append((sym, q))
-    cand.sort(key=lambda x: x[1], reverse=True)
-    out = [c[0] for c in cand[:n]]
-    print(f"[RCEA] {len(out)} OKX USDT pairs resolved", flush=True)
-    return out
-
-
-def fetch_klines(inst_id, timeframe, target_bars=TARGET_BARS):
-    """
-    Fetch OHLCV from OKX with pagination ('after' = oldest ts so far).
-    Excludes unconfirmed candles (confirm != '1').
-    """
-    bar = TF_MAP[timeframe]
-    all_rows = []
-    after = None
-    max_pages = 10
-
-    for page in range(max_pages):
-        params = {"instId": inst_id, "bar": bar, "limit": "300"}
-        if after:
-            params["after"] = str(after)
-        raw = _req("/api/v5/market/candles", params)
-        if not raw:
-            break
-
-        got_new = 0
-        for k in raw:
-            if not isinstance(k, list) or len(k) < 9:
-                continue
-            if k[8] != "1":
-                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
-            all_rows.append({"ts": int(k[0]),
-                             "open": o, "high": h, "low": l, "close": c, "volume": v})
-            got_new += 1
-
-        if got_new == 0:
-            break
+# ---------- BOCPD ----------
+def _student_t_pdf(x, mu, kappa, alpha, beta):
+    scale2 = np.maximum(beta * (kappa + 1.0) / (alpha * kappa), 1e-12)
+    df = 2.0 * alpha
+    z = (x - mu) / np.sqrt(scale2)
+    log_norm = (math.lgamma((df + 1.0) / 2.0) - math.lgamma(df / 2.0)
+                - 0.5 * np.log(df * np.pi) - 0.5 * np.log(scale2))
+    return np.exp(log_norm - 0.5 * (df + 1.0) * np.log1p(z * z / df))
 
-        try:
-            after = int(raw[-1][0])
-        except (IndexError, ValueError):
-            break
 
-        if len(all_rows) >= target_bars:
-            break
-        time.sleep(0.12)
+def bocpd_changepoint_prob(returns, hazard=BOCPD_HAZARD, max_run=BOCPD_MAX_RUN):
+    n = len(returns); cp_prob = np.zeros(n)
+    R = np.array([1.0])
+    mu_arr = np.array([BOCPD_PRIOR_MU]); kappa_arr = np.array([BOCPD_PRIOR_KAPPA])
+    alpha_arr = np.array([BOCPD_PRIOR_ALPHA]); beta_arr = np.array([BOCPD_PRIOR_BETA])
 
-    if len(all_rows) < MIN_HMM:
+    for t in range(n):
+        x = returns[t]
+        pred = _student_t_pdf(x, mu_arr, kappa_arr, alpha_arr, beta_arr)
+        growth = R * pred * (1.0 - hazard)
+        cp = np.sum(R * pred * hazard)
+        denom = cp + growth.sum()
+        cp_prob[t] = cp / denom if denom > 1e-300 else 0.0
+
+        R_new = np.empty(len(R) + 1); R_new[0] = cp; R_new[1:] = growth
+        s = R_new.sum(); R_new = R_new / s if s > 1e-300 else np.array([1.0])
+
+        new_mu = np.empty(len(R_new)); new_kappa = np.empty(len(R_new))
+        new_alpha = np.empty(len(R_new)); new_beta = np.empty(len(R_new))
+        new_mu[0] = BOCPD_PRIOR_MU; new_kappa[0] = BOCPD_PRIOR_KAPPA
+        new_alpha[0] = BOCPD_PRIOR_ALPHA; new_beta[0] = BOCPD_PRIOR_BETA
+        new_kappa[1:] = kappa_arr + 1.0
+        new_mu[1:] = (kappa_arr * mu_arr + x) / new_kappa[1:]
+        new_alpha[1:] = alpha_arr + 0.5
+        new_beta[1:] = beta_arr + 0.5 * kappa_arr * (x - mu_arr) ** 2 / new_kappa[1:]
+
+        if len(R_new) > max_run:
+            R_new = R_new[:max_run]; new_mu = new_mu[:max_run]
+            new_kappa = new_kappa[:max_run]; new_alpha = new_alpha[:max_run]
+            new_beta = new_beta[:max_run]; R_new = R_new / R_new.sum()
+
+        R = R_new; mu_arr = new_mu; kappa_arr = new_kappa
+        alpha_arr = new_alpha; beta_arr = new_beta
+    return cp_prob
+
+
+# ---------- Data (GitHub CSV) ----------
+def fetch_pairs(n, api_key=None):
+    pairs = FOREX_SYMBOLS[:max(1, min(n, len(FOREX_SYMBOLS)))]
+    print(f"[RCEA] {len(pairs)} forex symbols selected", flush=True)
+    return pairs
+
+
+def fetch_klines(symbol, timeframe, api_key=None, target_bars=TARGET_BARS):
+    tf = TF_MAP.get(timeframe)
+    if tf is None:
         return None
+    symbol = symbol.upper()
+    url = f"{GITHUB_RAW}/{symbol}/{symbol}{tf}.csv"
+    try:
+        df = pd.read_csv(url)
+    except Exception as e:
+        print(f"[RCEA] {symbol} CSV fetch failed: {e}", flush=True)
+        return None
+
+    df.columns = [c.strip().lower() for c in df.columns]
+    if "date" in df.columns:
+        df = df.rename(columns={"date": "datetime"})
+    elif "time" in df.columns:
+        df = df.rename(columns={"time": "datetime"})
 
-    df = (pd.DataFrame(all_rows)
-          .drop_duplicates(subset=["ts"])
-          .sort_values("ts")
-          .reset_index(drop=True))
+    required = {"open", "high", "low", "close"}
+    if not required.issubset(df.columns):
+        print(f"[RCEA] {symbol}: missing columns", flush=True)
+        return None
+
+    for col in ["open", "high", "low", "close"]:
+        df[col] = pd.to_numeric(df[col], errors="coerce")
+    if "tick_volume" in df.columns:
+        df["volume"] = pd.to_numeric(df["tick_volume"], errors="coerce").fillna(0.0)
+    elif "volume" in df.columns:
+        df["volume"] = pd.to_numeric(df["volume"], errors="coerce").fillna(0.0)
+    else:
+        df["volume"] = 0.0
+
+    df = df.dropna(subset=["open", "high", "low", "close"]).reset_index(drop=True)
+    if len(df) > target_bars:
+        df = df.iloc[-target_bars:].reset_index(drop=True)
+    if len(df) < MIN_HMM:
+        print(f"[RCEA] {symbol}: insufficient rows ({len(df)})", flush=True)
+        return None
     return df[["open", "high", "low", "close", "volume"]]
 
 
 # ---------- 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
+    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)
@@ -217,8 +192,7 @@ def features(df):
     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]
+    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)
@@ -239,8 +213,7 @@ def fit_hmm(f):
 
 
 def forward_filter(m, f):
-    n = len(f)
-    post = np.ones((n, HMM_K)) / HMM_K
+    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
@@ -261,10 +234,9 @@ def forward_filter(m, f):
     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
+# ---------- Evidence + BOCPD blend ----------
+def evidence(f, rp, lam, cp_prob):
+    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
@@ -279,54 +251,39 @@ def evidence(f, rp, lam):
         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
+    rp_blended = rp * (1.0 - cp_prob[:, None]) + (1.0 / HMM_K) * cp_prob[:, None]
+    raw = rp_blended[:, 0] * et + rp_blended[:, 1] * em + rp_blended[:, 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
+    return acc, pl, 1.0 - pl, rp_blended
 
 
 # ---------- Signal + Backtest ----------
-def latest_signal(f, rp, acc, pl, ps, thr, mconf):
+def latest_signal(f, rp_blended, acc, pl, ps, thr, mconf, cp_prob):
     i = len(f) - 1
     if i < MIN_SIG: return None
-    p = rp[i]; dom = int(np.argmax(p)); conf = float(p[dom])
+    p = rp_blended[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])}
+            "changepoint": float(cp_prob[i]), "close": float(f["close"].values[i])}
 
 
-def backtest(sym, f, rp, acc, pl, ps, thr, mconf, maxhold):
+def backtest(sym, f, rp_blended, acc, pl, ps, thr, mconf, maxhold, cp_prob):
     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
-
-    # Backtest begins immediately after HMM training window + purge + embargo.
-    train_end = int(n * TRAIN_FRAC)
-    start = train_end + PURGE + EMBARGO
-    start = max(start, 30)          # need indicator warm-up
-    start = min(start, n - 2)
-
-    # DEBUG metrics
-    if start < n:
-        pass_thr = int((np.abs(acc[start:]) > thr).sum())
-        pass_conf = int((rp[start:].max(axis=1) >= mconf).sum())
-        both = int(((np.abs(acc[start:]) > thr) &
-                    (rp[start:].max(axis=1) >= mconf)).sum())
-        print(f"[BT] {sym}: n={n} start={start} window={n-start} "
-              f"|acc|=[{np.abs(acc[start:]).min():.3f},{np.abs(acc[start:]).max():.3f}] "
-              f"thr_pass={pass_thr} conf_pass={pass_conf} both={both}",
-              flush=True)
+    start = min(max(int(n * TRAIN_FRAC) + PURGE + EMBARGO, 30), n - 2)
 
     for i in range(start, n):
         if not in_pos:
-            p = rp[i]; dom = int(np.argmax(p)); conf = float(p[dom])
-            if conf < mconf: continue
+            p = rp_blended[i]; dom = int(np.argmax(p)); conf = float(p[dom])
+            if conf < mconf or cp_prob[i] > 0.5: 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
@@ -365,13 +322,12 @@ def metrics(trades):
     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
+    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,
+    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,
@@ -388,11 +344,9 @@ def regime_table(trades):
         rt = [t for t in trades if t["regime"] == reg]
         if not rt:
             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]
+        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),
+        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)
@@ -403,83 +357,67 @@ def coin_table(trades):
     rows = []
     for sym in sorted({t["symbol"] for t in trades}):
         st = [t for t in trades if t["symbol"] == sym]
-        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)})
+        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)
 
 
 # ---------- Pipeline ----------
-def run(timeframe, n_coins, thr, lam, mconf, maxhold, progress=gr.Progress()):
+def run(timeframe, n_pairs, thr, lam, mconf, maxhold, progress=gr.Progress()):
     def err(msg, detail=""):
         return msg, detail, pd.DataFrame(), pd.DataFrame(), pd.DataFrame(), pd.DataFrame()
 
-    n_coins = max(30, min(100, int(n_coins)))
-    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)))
-
+    n_pairs = max(1, min(12, int(n_pairs)))
+    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 TF_MAP:
         return err("ERROR: Invalid timeframe")
 
-    progress(0.02, desc="Fetching OKX USDT pairs...")
-    try: pairs = fetch_pairs(n_coins)
-    except Exception as e: return err(f"ERROR fetching pairs: {e}")
-    if not pairs:
-        return err("ERROR: No OKX USDT pairs found.\n\n"
-                   "Possible causes: OKX API blocked from this region, rate limit, or timeout. "
-                   "Check Space logs for `[RCEA] ...` messages.")
+    progress(0.02, desc="Selecting forex symbols...")
+    pairs = fetch_pairs(n_pairs)
 
     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:
-            print(f"[RCEA] {sym}: insufficient candles", flush=True)
             failed.append(sym); continue
         try:
-            f = features(df)
-            m = fit_hmm(f)
-            if m is None:
-                print(f"[RCEA] {sym}: HMM fit failed (n={len(f)})", flush=True)
-                failed.append(sym); continue
+            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)
+            cp_prob = bocpd_changepoint_prob(f["ret"].values)
+            acc, pl, ps, rp_blended = evidence(f, rp, lam, cp_prob)
+            s = latest_signal(f, rp_blended, acc, pl, ps, thr, mconf, cp_prob)
             if s: s["symbol"] = sym; signals.append(s)
-            sym_trades = backtest(sym, f, rp, acc, pl, ps, thr, mconf, maxhold)
+            sym_trades = backtest(sym, f, rp_blended, acc, pl, ps, thr, mconf, maxhold, cp_prob)
             trades.extend(sym_trades)
-            print(f"[RCEA] {sym}: candles={len(f)} signal={s['signal'] if s else 'NONE'} "
-                  f"trades={len(sym_trades)}", flush=True)
+            print(f"[RCEA] {sym}: candles={len(f)} cp_recent={cp_prob[-1]:.3f} "
+                  f"signal={s['signal'] if s else 'NONE'} trades={len(sym_trades)}", flush=True)
             analyzed += 1
         except Exception as e:
             print(f"[RCEA] {sym}: EXC {e}", flush=True); failed.append(sym)
     progress(1.0, desc="Done")
 
-    scan = ["# RCEA Lite — OKX Market Scan",
-            f"**Timeframe:** {timeframe} | **OKX bar:** {TF_MAP[timeframe]}",
-            f"**Coins requested:** {n_coins}",
+    scan = ["# RCEA Lite — Forex + BOCPD",
+            f"**Timeframe:** {timeframe}",
+            f"**Pairs requested:** {n_pairs}",
             f"**Analyzed:** {analyzed}",
             f"**Failed:** {len(failed)}",
             f"**Total 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. Try threshold=0.04, "
-                    f"λ=0.65, MinConf=0.25, or Coins=100.")
+        scan.append(f"\n⚠️ Only {len(trades)} trades. Try threshold=0.04, λ=0.65, MinConf=0.25.")
     scan_report = "\n".join(scan)
 
     if 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),
+            "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), "Changepoint": round(s["changepoint"], 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),
@@ -488,20 +426,19 @@ def run(timeframe, n_coins, thr, lam, mconf, maxhold, progress=gr.Progress()):
         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"])
+                                        "Regime", "Regime Conf", "Changepoint", "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"],
+            "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"])
+            "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:
         tr_df = pd.DataFrame(columns=["Symbol", "Direction", "Entry Bar", "Exit Bar", "Bars",
                                        "Entry", "Exit", "Stop", "Target", "Reason",
@@ -510,13 +447,10 @@ def run(timeframe, n_coins, thr, lam, mconf, maxhold, progress=gr.Progress()):
     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"**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"**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%})",
     ])
@@ -527,13 +461,13 @@ def run(timeframe, n_coins, thr, lam, mconf, maxhold, progress=gr.Progress()):
 
 
 # ---------- UI ----------
-with gr.Blocks(title="RCEA Lite v1.0 — OKX") as demo:
-    gr.Markdown("# RCEA Lite v1.0 — OKX Edition\n"
-                "HMM regime detection (causal forward filtering) · No supervised ML · Data: OKX")
+with gr.Blocks(title="RCEA Lite v1.0 — Forex") as demo:
+    gr.Markdown("# RCEA Lite v1.0 — Forex Edition\n"
+                "HMM + BOCPD · Causal · No supervised ML · Data: GitHub CSV (no API key)")
     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=50, step=1, label="Coins")
+            nc = gr.Slider(1, 12, value=12, step=1, label="Pairs")
             thr_i = gr.Slider(0.0, 1.0, value=0.06, step=0.01, label="Evidence threshold")
             lam_i = gr.Slider(0.0, 0.99, value=0.70, step=0.01, label="Memory λ")
             mc_i = gr.Slider(0.0, 1.0, value=0.30, step=0.01, label="Min regime confidence")
@@ -546,11 +480,11 @@ with gr.Blocks(title="RCEA Lite v1.0 — OKX") as demo:
         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)
+        with gr.Tab("🪙 Pairs"): 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**Data source:** OKX public REST API. "
-                "Net of 0.10% commission + 0.05% slippage per side.")
+    gr.Markdown("---\n**Data:** ejtraderLabs/historical-data (12 forex pairs, 10y OHLCV). "
+                "Net of 0.02% commission + 0.01% slippage per side.")
 
 
 if __name__ == "__main__":