research(exit-lab): 34 agenti su exit dinamiche → EXIT-16 close-confirm SL PROMOSSO a livello PORT06

23 famiglie esplorate (harness condiviso exit_lab, train/OOS embargo nov-2023, tutto lo storico 1h 2018-2026) + 10 verifiche avversariali + test PORT06. 'Cavalcare il prezzo' non esiste (4a conferma: oltre il TP=media non c'e' coda). Scoperta: lo SL intrabar fisso e' il distruttore di valore n.1 delle fade (stop da wick = falsi negativi). Forma robusta: SL solo su CHIUSURA oltre sl0±0.5·ATR14 — PORT06 FULL Sharpe 6.47→7.84 DD 4.10→2.60, OOS 8.82→10.06. Collaterali: bias gap-through dell'engine sugli stop stretti; ramo -2% del worker morto con sl=0. Diario: docs/diary/2026-06-04-exit-lab.md Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>
2026-06-04 21:16:58 +00:00
parent 3accc91f84
commit ad65a0b344
36 changed files with 5116 additions and 0 deletions
@@ -0,0 +1,108 @@
+"""EXIT-18 — SL STRUTTURALE su swing low/high (structural / chandelier-by-structure).
+
+Idea: invece di uno stop FISSO a sl0 (ATR dall'entrata), uno stop ancorato alla
+STRUTTURA recente del prezzo. Per un long: il livello "naturale" sotto cui la tesi
+mean-reversion e' invalidata e' il minimo dello swing recente; se il prezzo rompe
+sotto il minimo degli ultimi n bar la fade ha torto. Simmetrico per lo short sul
+massimo recente.
+
+  long  (d=1):  level(j) = min(low[j-n .. j-1]) - buf
+  short (d=-1): level(j) = max(high[j-n .. j-1]) + buf
+  buf = 0.25 * atr14[j-1]
+
+SOLO-STRINGENTE: lo stop parte da sl0 (protezione iniziale invariata) e si aggiorna
+SOLO se il livello swing e' PIU' PROTETTIVO (cricchetto):
+  long :  cur_stop = max(cur_stop, level)   (lo stop puo' solo SALIRE)
+  short:  cur_stop = min(cur_stop, level)   (lo stop puo' solo SCENDERE)
+Cosi' man mano che il prezzo (per una fade vincente) torna verso la media, lo swing
+low/high sale/scende e lo stop segue, bloccando profitto. Non si allenta MAI.
+
+TP fisso (tp0) e horizon=max_bars invariati: questa famiglia cambia SOLO lo stop.
+
+ANTI-LOOK-AHEAD (contratto): levels(j) usa SOLO dati con indice <= j-1:
+  - massimi/minimi sullo slice [j-n .. j-1]  (lookback chiuso a j-1);
+  - buffer da atr14[j-1] (indicatore causale, valore del bar precedente).
+Mantengo cur_stop in modo incrementale ma lo aggiorno con i bar fino a j-1, mai j.
+Nessun dato del bar j o successivi entra nel livello attivo nel bar j.
+
+MECCANISMO ATTESO: lo stop strutturale e' tipicamente PIU' LASCO di sl0 all'inizio
+(il minimo recente puo' stare oltre sl0): in quel caso il cricchetto lo IGNORA e
+resta a sl0 (non allentiamo mai). Quando invece la struttura si stringe (lo swing
+low risale verso il prezzo dopo che la fade comincia a funzionare) lo stop SALE,
+proteggendo i guadagni di un trade che poi rintraccia prima del TP.
+Prior dal repo (ladder scartato): il TP della fade sta alla MEDIA, dove il movimento
+e' esaurito -> oltre il TP non c'e' runner. Qui non tocchiamo il TP, quindi non
+puntiamo a cavalcare oltre: cerchiamo SOLO di tagliare meglio i loser/ristagni
+proteggendo profitto. RISCHIO (fade = mean-reversion): stringere lo stop su un
+pullback transitorio stoppa fuori trade che sarebbero rientrati al TP -> winner
+tagliati e stop-rate su. Lo misuriamo.
+
+GRID: n in {5, 10, 20} (3 celle).
+"""
+import sys
+from pathlib import Path
+
+import numpy as np
+
+sys.path.insert(0, str(Path(__file__).resolve().parents[1]))
+
+from exit_lab import ExitPolicy, evaluate  # noqa: E402
+
+
+class SwingStop(ExitPolicy):
+    name = "swing_stop"
+
+    def __init__(self, ctx, i, d, entry, tp0, sl0, mb, n=10, **params):
+        super().__init__(ctx, i, d, entry, tp0, sl0, mb, **params)
+        self.n = int(n)
+        self.low = ctx["low"]
+        self.high = ctx["high"]
+        self.atr14 = ctx["atr14"]
+        # stop a cricchetto: parte dalla protezione iniziale, puo' solo stringersi
+        self.cur_stop = sl0
+        # indice fino a cui ho gia' incorporato i bar nel cricchetto (escluso)
+        self._last_seen = i
+
+    def _swing_level(self, j: int):
+        """Livello swing causale usando SOLO low/high su [j-n .. j-1] e atr14[j-1]."""
+        lo = max(self.i, j - self.n)            # non andare prima dell'entrata
+        hi = j                                   # slice [lo:hi] => indici <= j-1
+        if hi <= lo:
+            return None
+        a = self.atr14[j - 1]
+        if not np.isfinite(a):
+            a = 0.0
+        buf = 0.25 * a
+        if self.d == 1:
+            return float(np.min(self.low[lo:hi])) - buf
+        else:
+            return float(np.max(self.high[lo:hi])) + buf
+
+    def levels(self, j: int):
+        d = self.d
+        # aggiorna il cricchetto bar-per-bar fino a j-1 (causale). Per ogni bar k
+        # passato calcolo il livello swing attivo "a quel momento" e stringo lo stop.
+        while self._last_seen < j:
+            self._last_seen += 1
+            k = self._last_seen
+            lvl = self._swing_level(k)
+            if lvl is None:
+                continue
+            if d == 1:
+                if lvl > self.cur_stop:          # cricchetto long: lo stop solo SALE
+                    self.cur_stop = lvl
+            else:
+                if lvl < self.cur_stop:          # cricchetto short: lo stop solo SCENDE
+                    self.cur_stop = lvl
+        return self.tp0, self.cur_stop, 1.0
+
+
+GRID = [
+    {"n": 5},
+    {"n": 10},
+    {"n": 20},
+]
+
+
+if __name__ == "__main__":
+    evaluate(SwingStop, GRID)