feat(pairs): attiva ETH/BTC 15m flat-skip in PORT06 (BLEND, mezza size)

Origine: gioco "Blind Traders" (100 agenti ciechi su BTC/ETH anonimizzati) -> vincitore = spread ETH/BTC reversion a 15m. Testato sul serio col gate PORT06: non duplicato (corr 1h vs 15m = 0.37), robusto (16/16 celle Sharpe>1), edge NON artefatto delle candele flat ETH 15m (filtrandole resta l'83% dello Sharpe). Percorso live costruito e validato: - pairs_research.pairs_sim_flat: engine generalizzato con exit LIVE-REALIZABLE (arma exit_ready, esce alla 1a barra pulita); regression-lock a pairs_sim. - PairsWorker: flat_skip + exit_ready + rilevamento flat da OHLC (1h byte-exact). - runner: fetch diretto dei timeframe sub-orari + override position_size per-sleeve. - validate_worker_pairs: replay worker == backtest a 15m (8452 vs 8453 trade). - _defs/build_everything: sleeve PR_ETHBTC_15M (mezza size, pos 0.10) -> PORT06 FULL 6.43->7.20, OOS 8.58->9.66, DD giu'. Rischio bilanciato col 1h. - smoke live: Cerbero serve candele 15m fresche; worker ticca. Diari docs/diary/2026-06-09-*. Caveat slippage: mezza size = blend-tilt prudente. Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>
2026-06-09 11:48:15 +00:00
parent 5d45f4ef6e
commit d25d897fd1
20 changed files with 1727 additions and 60 deletions
@@ -95,6 +95,98 @@ def pairs_sim(a, b, tf="1h", n=50, z_in=2.0, z_exit=0.5, max_bars=72,
                eq_ts=eq_ts, eq_v=eq_v)


+def aligned_ohlc(a: str, b: str, tf: str = "1h"):
+    """Come aligned ma con OHLC di ENTRAMBE le gambe (serve a rilevare candele flat)."""
+    da = load_data(a, tf)[["timestamp", "open", "high", "low", "close"]].rename(
+        columns=lambda x: x + "_a" if x != "timestamp" else x)
+    db = load_data(b, tf)[["timestamp", "open", "high", "low", "close"]].rename(
+        columns=lambda x: x + "_b" if x != "timestamp" else x)
+    m = da.merge(db, on="timestamp", how="inner").reset_index(drop=True)
+    m["dt"] = pd.to_datetime(m["timestamp"], unit="ms", utc=True)
+    return m
+
+
+def is_flat_ohlc(o, h, l, c):
+    """Candela flat (O=H=L=C): prezzo fermo / liquidita' zero -> fill non eseguibile."""
+    return (o == h) & (h == l) & (l == c)
+
+
+def pairs_sim_flat(a, b, tf="1h", n=50, z_in=2.0, z_exit=0.5, max_bars=72,
+                   jump_max=0.08, fee_rt=FEE_RT, lev=LEV, pos=POS, split_frac=0.0,
+                   flat_skip=False, scan_buffer=192):
+    """Engine pairs GENERALIZZATO con opzione flat-skip LIVE-REALIZABLE.
+
+    Identico a pairs_sim quando flat_skip=False (regression-lock verificato).
+    Con flat_skip=True:
+      - ENTRY: saltata se la barra d'ingresso e' flat in UNA delle due gambe (prezzo stale).
+      - EXIT: la condizione di uscita (|z|<=z_exit O bars>=max_bars) arma 'exit_ready';
+        si esce al CLOSE della PRIMA barra PULITA successiva (mai a un prezzo passato).
+        scan_buffer = barre extra oltre max_bars concesse per trovare la barra pulita.
+    Questa e' la stessa regola implementata nel PairsWorker live (flat_skip) -> parita'.
+    """
+    m = aligned_ohlc(a, b, tf)
+    ca, cb = m["close_a"].values, m["close_b"].values
+    N = len(ca)
+    if flat_skip:
+        flat = (is_flat_ohlc(m["open_a"].values, m["high_a"].values, m["low_a"].values, ca)
+                | is_flat_ohlc(m["open_b"].values, m["high_b"].values, m["low_b"].values, cb))
+    else:
+        flat = np.zeros(N, dtype=bool)
+    r = np.log(ca / cb)
+    dr = np.abs(np.diff(r, prepend=r[0]))
+    ma = pd.Series(r).rolling(n).mean().values
+    sd = pd.Series(r).rolling(n).std().values
+    z = (r - ma) / np.where(sd == 0, np.nan, sd)
+    ts = m["dt"]
+    split = int(N * split_frac)
+    fee = 2 * fee_rt * lev
+    cap = peak = 1000.0; dd = 0.0; last = -1
+    trades = wins = 0; rets = []; yearly = {}
+    eq_ts, eq_v = [], []
+    n_skip_entry = 0
+    kmax = max_bars + (scan_buffer if flat_skip else 0)
+    for i in range(n + 1, N - 1):
+        if i < split or np.isnan(z[i]) or dr[i] > jump_max or i <= last:
+            continue
+        if z[i] <= -z_in:
+            d = 1
+        elif z[i] >= z_in:
+            d = -1
+        else:
+            continue
+        if flat[i]:
+            n_skip_entry += 1
+            continue                                   # niente ingresso su barra stale
+        # uscita live-realizable: arma a |z|<=z_exit o max_bars, esci alla prima barra pulita
+        exit_ready = False; j = i
+        for k in range(1, kmax + 1):
+            jj = i + k
+            if jj >= N:
+                j = N - 1; break
+            if not exit_ready and (abs(z[jj]) <= z_exit or k >= max_bars):
+                exit_ready = True
+            if exit_ready and not flat[jj]:
+                j = jj; break
+            j = jj
+        retA = (ca[j] - ca[i]) / ca[i]
+        retB = (cb[j] - cb[i]) / cb[i]
+        ret = (retA - retB) * d * lev - fee
+        cap = max(cap + cap * pos * ret, 10.0)
+        peak = max(peak, cap); dd = max(dd, (peak - cap) / peak)
+        trades += 1; wins += ret > 0; rets.append(ret * pos); last = j
+        eq_ts.append(ts.iloc[j]); eq_v.append(cap)
+        yearly[ts.iloc[i].year] = yearly.get(ts.iloc[i].year, 0.0) + ret * 100
+    yrs_span = (ts.iloc[-1] - ts.iloc[max(split, 0)]).days / 365.25 or 1
+    sharpe = 0.0
+    if len(rets) > 1 and np.std(rets) > 0:
+        sharpe = float(np.mean(rets) / np.std(rets) * np.sqrt(trades / yrs_span))
+    ret_tot = (cap / 1000 - 1) * 100
+    cagr = ((cap / 1000) ** (1 / yrs_span) - 1) * 100 if cap > 0 else -100
+    return dict(trades=trades, win=wins / trades * 100 if trades else 0, ret=ret_tot,
+                cagr=cagr, dd=dd * 100, sharpe=sharpe, yearly=yearly,
+                eq_ts=eq_ts, eq_v=eq_v, n_skip_entry=n_skip_entry)
+
+
 def check_no_lookahead():
    """Perturba il FUTURO del ratio e verifica che z[i] non cambi (causalita')."""
    m = aligned("ETH", "BTC")