research(report): resoconto PROTETTO (soft-guard DD -4%) anno-per-anno -> combo + TP01 + GTAA singoli

Report che mette combo (TP01+GTAA 50/50), TP01 e GTAA sulla stessa griglia giorni-di-borsa (esposizione 1x, come dentro al combo), applica la guardia-DD -4% a ciascuna serie e tira fuori per anno: NL (net liquidation da $2000), DD intra-anno, rendimento, Sharpe + riga TOT con CAGR. Combo protetto: CAGR +9.1% / DD 5.8% / Sh 1.38 (2022 -1.8%); baseline +11.3% / 8.4% / 1.48. Aggiunto data/paper_combo/ al .gitignore (stato paper runtime, come gli altri paper dir). Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>
research(stops): SL classici vs soft-guard -> il soft-guard vince (lo SL duro whippa nel grind)
2026-06-23 14:16:59 +00:00 · 2026-06-23 13:09:43 +00:00 · 2026-06-23 12:59:07 +00:00 · 2026-06-23 12:55:14 +00:00 · 2026-06-23 12:44:54 +00:00 · 2026-06-23 12:37:23 +00:00
45 changed files with 3676 additions and 0 deletions
@@ -0,0 +1,7 @@
+# Credenziali IB Gateway PAPER per la ricerca dati (account paper, es. DUQ513966).
+# COPIA questo file in  .env.ibgw  (gitignored) e riempi i valori REALI.
+#   cp .env.ibgw.example .env.ibgw && chmod 600 .env.ibgw && nano .env.ibgw
+# NON committare mai .env.ibgw. Sono credenziali del CONTO PAPER (nessun denaro reale),
+# l'API e' comunque READ_ONLY (solo dati storici, nessun ordine).
+TWS_USERID=il_tuo_username_paper
+TWS_PASSWORD=la_tua_password_paper
@@ -6,6 +6,8 @@ build/
 .venv/
 .env
 !.env.example
+.env.ibgw
+!.env.ibgw.example
 .vscode/
 .idea/
 .DS_Store
@@ -63,3 +65,4 @@ scripts/research/blind/leaderboard.json

 # forward-monitor runtime state (regenerable, forward-only)
 data/paper_prevday/
+data/paper_combo/
@@ -13,3 +13,20 @@ services:
      # token mainnet (sola lettura) per lo "Shadow live": conto/posizioni reali sulla dashboard.
      # Montato a runtime (NON nell'immagine: .env.mainnet e' dockerignored). Solo letture, nessun ordine.
      - ./.env.mainnet:/app/.env.mainnet:ro
+
+  # IB Gateway (PAPER) per la RICERCA DATI Interactive Brokers — replica il setup provato di BuzWay
+  # (scout). IBC fa login automatico headless; nessuna GUI desktop. API READ-ONLY (solo dati storici,
+  # MAI ordini). Bind SOLO su 127.0.0.1 -> non esposto in rete. Credenziali in .env.ibgw (gitignored).
+  # host 4002 -> container 4004 (socat paper), esattamente come nel connect("127.0.0.1", 4002).
+  ib-gateway:
+    image: ghcr.io/gnzsnz/ib-gateway:stable
+    container_name: pythagoras-ibgw
+    restart: unless-stopped
+    env_file: .env.ibgw
+    environment:
+      TRADING_MODE: paper
+      READ_ONLY_API: "yes"          # SOLO dati: nessun ordine possibile via API
+      TWOFA_TIMEOUT_ACTION: restart
+      TIME_ZONE: Europe/Rome
+    ports:
+      - "127.0.0.1:4002:4004"       # gateway paper (socat) raggiungibile solo da localhost dell'host
@@ -0,0 +1,62 @@
+# 2026-06-22 — Sweep 65-agenti: crypto -> mercati IB (mercati × timing × anni)
+
+## Obiettivo (goal utente)
+Usare >=50 agenti per prendere l'anticipazione crypto->equity e trovare la MIGLIORE soluzione,
+provando diversi mercati e timing, su piu' anni.
+
+## Setup
+- **Dati**: universo IB esteso a **26 ETF certificati** (azioni US/settori/intl/bond/credito/oro/
+  commodity/REIT), cache su disco (`fetch_ib_equities.py` + BROAD2). Crypto BTC/ETH 1h (Deribit).
+- **Harness onesto** (`crypto_lead_harness.py`): per ogni sessione equity, lead = crypto nella
+  finestra equity-CHIUSO [P 21:00 -> D 13:00 UTC] (overnight; il weekend e' il caso lungo). Predice
+  gap/intraday/full. Metriche: corr, **t incrementale vs sessione equity precedente**, Sharpe
+  eseguibile (sign(lead)*predict, net costi) FULL/IS/OOS, **hit per-anno**.
+- **Workflow** (`wf_crypto_lead.js`): grid 416 config (2 lead × 26 mercati × 2 giorni × 2 predict ×
+  2 finestre). **52 agenti sweep** -> **12 agenti verifica avversariale** (stress 10bps + OOS 2024+ +
+  multi-anno) -> **1 sintesi**. Totale **65 agenti**, 1.7M token.
+
+## Risultato
+
+### Fenomeno fortissimo: crypto overnight -> GAP di apertura equity
+Cluster coerente in cima, TUTTI predict=gap/overnight, su ogni target risk-on:
+| lead->target | t-incr | Sh OOS@4bps | @10bps | OOS-recente | anni+ |
+|---|---|---|---|---|---|
+| ETH->IWM gap | 17.1 | 2.49 | 1.96 | 2.41 | 7/8 |
+| ETH->QQQ gap | 17.9 | 2.36 | 1.83 | 2.31 | 7/8 |
+| ETH->XLK gap | 17.4 | 2.40 | 1.93 | 2.30 | 7/8 |
+| **BTC->QQQ gap** | 15.0 | 2.31 | 1.78 | 2.16 | **9/9** |
+| BTC->SPY gap | 14.4 | 2.14 | 1.69(lf) | 2.03 | 9/9 |
+
+Statisticamente schiacciante (t 14-18, sopra Bonferroni su 416 test), regge stress costi e OOS
+recente, **positivo 8-9 anni su 8-9**.
+
+### Ma DUE killer (i verificatori avversariali concordi)
+1. **NON tradabile via ETF**: il gap e' gia' prezzato all'open dell'ETF -> serve un FUTURE indice
+   tenuto overnight (MNQ/MES/M2K). A $0.5-2k il margin overnight di anche un micro consuma il
+   capitale e rischia la liquidazione su un gap avverso -> **fuori portata per costruzione**.
+2. **E' RISK-BETA, non alpha**: la finestra-lead crypto e' quasi CONTEMPORANEA al gap (stesso shock
+   macro overnight, equity chiuso). t enorme = co-movimento risk-on/off, non ETH/BTC che *anticipa*.
+   Firma: la forza e' negli anni alta-vol (2022 hit 0.71-0.75), piatta negli anni calmi (2019/21/23).
+   corr ~0.37 -> beta implicito ~37%, alpha residuo piccolo.
+
+### L'unico tradabile via ETF e' troppo debole
+ETH->XLE intraday 6h (compri XLE al day-open, chiudi +6h): Sh OOS 0.48@4bps **-> 0.15@10bps** (annuo
+4.1%->1.0%), t-incr 2.38 **sotto Bonferroni** (~3.5 su 416 test). Edge netto onesto ~ZERO.
+
+## Verdetto (sintesi multi-agente)
+**Nessun edge proprietario deployabile a basso capitale.** Il fenomeno crypto->equity-overnight e'
+statisticamente reale e robustissimo su 9 anni, ma e' (a) risk-beta condiviso, non anticipazione
+sfruttabile, e (b) catturabile solo con futures overnight, fuori dal nostro capitale. L'unica
+versione ETF-eseguibile e' dentro il rumore da multiple-testing. Coerente col soffitto del progetto:
+"niente di nuovo regge" alla verifica onesta.
+
+**Migliore soluzione (come FENOMENO da forward-monitor, non deploy):** BTC->QQQ gap overnight — la
+storia piu' lunga (9/9 anni), lead noto prima dell'open. Da monitorare; deployabile solo con capitale
+~>$20-30k su micro-futures indice e con i costi notturni modellati.
+
+## Lezione
+Anche con 65 agenti e una ricerca esaustiva su mercati/timing/anni, la disciplina onesta
+(tradabilita' al capitale reale + multiple-testing + beta-vs-alpha) riduce un "Sharpe 2.5 su 9 anni"
+a un non-edge per noi. Il valore della ricerca: aver QUANTIFICATO e CLASSIFICATO il fenomeno
+(risk-beta overnight) invece di scambiarlo per alpha.
+Artefatti: `crypto_lead_harness.py`, `wf_crypto_lead.js`.
@@ -0,0 +1,53 @@
+# 2026-06-22 — Crypto × mercati IB: correlazioni e ANTICIPAZIONI (lead-lag)
+
+## Obiettivo
+Cercare correlazioni e soprattutto ANTICIPAZIONI tra crypto e mercati IB: un mercato fa capire
+l'andamento dell'altro? Dati: cache su disco (BTC/ETH Deribit 1h->1d UTC; ETF eq_* con OPEN). Nessun
+IB online. Disciplina: attenzione ai tranelli di timing daily (crypto chiude 00:00 UTC, US equity
+21:00 -> lag-0 contaminato), test del segno + OOS + multiple-testing.
+Script: `crypto_macro_leadlag.py`, `crypto_weekend_signal.py`.
+
+## (1) Correlazione contemporanea
+Crypto = asset RISK-ON: corr BTC/ETH ~ **+0.32/0.37** con SPY/QQQ/IWM, **+0.25/0.28** con HYG
+(credito), **+0.13** GLD, **~-0.02** TLT (bond). Atteso.
+
+## (2) Lead-lag giornaliero: NIENTE
+corr(BTC_{t-k}, ETF_t) ha picco a **k=0** (~0.32) e crolla a rumore (±0.05) per |k|>=1. Al daily
+**nessuno anticipa l'altro** (ne' crypto->equity ne' viceversa). Honest negative.
+
+## (3) EFFETTO WEEKEND: anticipazione PULITA, significativa, OOS-robusta
+La crypto si muove Sab+Dom (azionario chiuso) -> quel movimento e' info PRIOR al lunedi'.
+- **Anticipa il GAP del lunedi'**: corr +0.22/+0.24 (SPY/QQQ/IWM/HYG), hit 59-62%, e **si RAFFORZA
+  OOS (2022+): +0.30/+0.36**. Coerente su 4 ETF (non cherry-pick).
+- Intraday del lunedi' (open->close) piu' debole ma presente (corr 0.10-0.15, OOS 0.18-0.22).
+
+### Validazione avversariale
+- **(A) INCREMENTALE vs venerdi'**: regressione `Mon ~ weekend_crypto + friday_eq`. Coeff weekend
+  crypto significativo ovunque (QQQ gap **t=+4.7**, intr t=+2.9; SPY +4.4/+2.0; IWM +4.7/+2.7);
+  friday_eq NON significativo. -> e' info CRYPTO-SPECIFICA del weekend, non momentum equity.
+- **(B) TRADABILE** (osservo weekend crypto Dom 24:00, entro Monday OPEN, esco CLOSE, net 4bps):
+  | ETF | hit | Sharpe FULL / IS / OOS22+ | long-flat OOS | ann |
+  |---|---|---|---|---|
+  | QQQ | 60% | 1.46 / 1.61 / 1.33 | **1.91** | ~+9-11% |
+  | SPY | 60% | 0.96 / 0.91 / 1.01 | 1.70 | ~+5% |
+  | IWM | 56% | 0.89 / 0.73 / 1.04 | 1.07 | ~+6% |
+
+## Verdetto
+**Trovata UNA anticipazione reale**: il weekend crypto anticipa il lunedi' azionario (massimo su QQQ,
+risk-on/tech). Significativa (t>4 sul gap), incrementale al venerdi', tradabile net costi, **regge e
+si rafforza OOS**, coerente su piu' ETF. Meccanismo economico sensato: crypto = proxy 24/7 del
+risk-sentiment; nel weekend l'equity e' chiuso e lunedi' "recupera" la direzione crypto.
+
+### Caveat onesti
+- **Capacita' bassa**: ~52 lunedi'/anno, intraday -> ~+9%/yr sul capitale impiegato il lunedi', non
+  una macchina da compounding. E' un segnale TATTICO, non un cornerstone.
+- Il GAP (t=4.7) e' piu' forte dell'intraday (t=2.9) ma per catturarlo serve entrare PRIMA del Monday
+  open -> via **futures indice IB (MNQ/MES, aperti la domenica sera)**: enhancement eseguibile da
+  validare (cattura gap+sessione).
+- Multiple-testing 3 ETF x 2 target: ma TUTTI significativi e coerenti -> effetto ampio, non fortuna.
+- Niente IB online qui (cache); per il deploy servirebbe il feed crypto live la domenica sera.
+
+## Prossimo (se si procede)
+Validare la variante FUTURES (MNQ domenica sera -> cattura il gap del lunedi') e il sizing a basso
+capitale; eventualmente paper-trade. E' la prima ANTICIPAZIONE cross-mercato trovata: crypto come
+lead di sentiment sul lunedi' equity.
@@ -0,0 +1,40 @@
+# 2026-06-22 — Combo DEPLOYABLE: TP01 (Deribit) + GTAA (IB)
+
+## Perche'
+Il combo crypto-pieno (TP01+XS01+VRP01)+GTAA diversificava (Sharpe 1.81), ma XS01/VRP01 sono
+STAT-MODE (non eseguibili a $600). Validazione del combo ONESTO/eseguibile: solo le gambe deployable
+a basso capitale — TP01 (gia' armato live su Deribit) + GTAA vt12 (eseguibile su IB, frazioni,
+switch mensile). `eq_tp01_gtaa_combo.py`. TP01 compoundato sul calendario giorni-di-borsa.
+
+## Risultati (finestra comune 2019-03 .. 2026-06, ~7y)
+| | Sharpe | CAGR | volAnn | maxDD |
+|---|---|---|---|---|
+| TP01 (crypto, Deribit) | 1.25 | 16.4% | 12.9% | 14% |
+| GTAA vt12 (equity, IB) | 1.12 | 6.0% | 5.3% | 8% |
+| **blend 50/50** | **1.48** | 11.3% | 7.5% | **8%** |
+| blend 40/60 (best cap-mix) | 1.52 | 10.2% | 6.6% | 8% |
+| risk-parity (29c/71e) | 1.52 | 9.1% | 5.9% | 8% |
+
+**corr TP01<->GTAA = +0.21**. Il blend (1.48-1.52) batte entrambe le gambe (best solo 1.25),
+maxDD 14%->8%. **DIVERSIFICA anche da deployable.**
+
+## Caveat onesti
+- Per-anno 50/50: 2019 2.11, 2020 2.51, 2021 1.66, **2022 -2.64**, 2023 1.40, 2024 1.73, 2025 0.98,
+  2026 0.94. Anni boom iniziali gonfiano lo Sharpe assoluto; il **2022 e' negativo** (trend whipsaw
+  su entrambe le gambe nel bear). Recenti ~0.95. -> il numero robusto e' il GUADAGNO da
+  diversificazione (+0.27 Sharpe del blend vs solo), non il livello assoluto.
+- **Costo deployability**: crypto-pieno+GTAA = 1.81 vs deployable = 1.48. I ~0.33 di Sharpe persi sono
+  cio' che XS01/VRP01 darebbero se eseguibili (servirebbe ~20k).
+- **Cross-venue** Deribit+IB: due conti, capitale split. Entrambe switch mensile/basso turnover,
+  frazionabili a $0.5-2k.
+
+## Verdetto
+Combo deployable VALIDO: due trend difensivi scorrelati (corr 0.21) su mercati diversi -> Sharpe
+~1.5 / maxDD ~8%, meglio di ciascuna gamba. E' il candidato concreto per un paper-trade cross-venue.
+NON risolve EUR50/g (resta capitale), ma e' la migliore configurazione rischio-aggiustata
+EFFETTIVAMENTE eseguibile trovata finora. Lezione cross-mercato confermata: il salto di qualita' non
+e' un nuovo alpha ma un SECONDO mercato scorrelato.
+
+## Prossimo (se si procede)
+Paper-trade della gamba GTAA su IB (forward-only, come paper_trend per TP01), per validare
+l'esecuzione cross-venue a rischio zero prima di qualunque capitale reale.
@@ -0,0 +1,57 @@
+# 2026-06-22 — EQ-GTAA01 (trend multi-asset) + COMBO cross-mercato equity×crypto
+
+## (1) EQ-GTAA01 — trend difensivo multi-asset (GTAA)
+
+EQ-TREND01 (trend su SPY) taglia il DD. Diversificare le SORGENTI di trend (azioni US/tech/small +
+bond + oro + high-yield) migliora il rischio-aggiustato. `eq_gtaa_trend.py`: ogni asset gestito col
+proprio trend long-flat (TSMOM multi-orizzonte), equal-weight tra gli asset disponibili (outer-join,
+cash dove off/assente). Universo SPY/QQQ/IWM/TLT/GLD/HYG. Causale, netto fee, OOS 2015+.
+
+| strategia | CAGR | Sharpe (pre15/OOS) | maxDD | corr SPY |
+|---|---|---|---|---|
+| SPY buy&hold | 9.7% | 0.58 (0.45/0.82) | 55% | — |
+| EW statico (no trend) | 9.4% | 0.59 | 62% | 0.89 |
+| SPY-trend mono | 5.5% | 0.56 (/0.78) | 30% | 0.72 |
+| **GTAA lf vt12%** | 3.8% | **0.64** (0.53/**0.89**) | **15%** | **0.64** |
+| GTAA vt12 (6-asset, 2016+) | 5.6% | **1.08** | **8%** | 0.60 |
+
+DD nei bear (GTAA vs SPY): dot-com 32%/49% · GFC **14%/55%** · COVID **10%/34%** · 2022 11%/24%.
+Marginale vs SPY: corr 0.64; 50/50 uplift +0.041 FULL / **+0.086 OOS** (meglio del mono-SPY). Plateau
+stabile (Sh 0.55-0.61, DD 25-35%). **Migliore sleeve equity**: Sharpe più alto, maxDD bassissimo
+(8-15%), corr SPY più bassa (0.64) = diversificatore migliore. Tradeoff: CAGR molto più basso
+(fortemente difensiva). Caveat: la finestra 6-asset (Sh 1.08) è tutta OOS ma un solo regime (toro).
+
+## (2) COMBO cross-mercato — equity-trend × crypto
+
+La via che alza il Sharpe COMPLESSIVO senza nuovo alpha: combinare due book scorrelati.
+`eq_crypto_combo.py`: crypto = portafoglio attivo TP01+XS01+VRP01 (`StrategyPortfolio.combined_daily`,
+rinormalizzato); equity = GTAA lf vt12%. Crypto compoundato sul calendario giorni-di-borsa (cattura
+i weekend). Finestra comune = era crypto (2019-03 .. 2026-06, 1827 giorni di borsa).
+
+| | Sharpe | CAGR | volAnn | maxDD |
+|---|---|---|---|---|
+| crypto TP01+XS01+VRP01 | 1.60 | 18.7% | 11.1% | 14% |
+| equity GTAA vt12 | 1.12 | 6.0% | 5.3% | 8% |
+| **blend 50/50** | **1.81** | 12.4% | 6.6% | **7%** |
+| risk-parity (32c/68e) | 1.78 | 10.1% | 5.5% | 8% |
+
+**Correlazione crypto↔equity = +0.167** (bassissima). Il blend 50/50 fa **Sharpe 1.81 > di ciascuno**
+(crypto 1.60, equity 1.12), **maxDD dimezzato 14%→7%**. VERDETTO: DIVERSIFICA (blend > miglior solo
+di +0.21 Sharpe). È il guadagno STRUTTURALE: due fonti di rischio scorrelate alzano il Sharpe
+complessivo senza cercare un nuovo edge.
+
+### Caveat onesti
+- **Finestra crypto corta (~7y) e favorevole**: il crypto Sharpe 1.60 e' alto (regime toro + XS01/VRP01
+  STAT-MODE a storia corta). Gli SHARPE ASSOLUTI sono ottimistici. Ma il PUNTO della diversificazione
+  (corr 0.17, blend > solo, DD dimezzato) è robusto al livello assoluto.
+- **Cross-venue**: crypto su Deribit, equity su IB → due conti, due percorsi d'esecuzione. A $0.5-2k
+  totali, ogni sleeve è minuscola. La parte equity (GTAA) e la TP01 sono entrambe eseguibili a basso
+  capitale; XS01/VRP01 restano STAT-MODE (il blend "reale" deployable è ~TP01 + GTAA).
+
+## Lettura strategica
+Il fronte equity da' due cose: (a) una sleeve difensiva robusta (GTAA, maxDD ~10%), (b) — piu'
+importante — un DIVERSIFICATORE quasi-scorrelato al crypto che alza il Sharpe del portafoglio
+complessivo da ~1.6 a ~1.8. Non risolve €50/g (resta capitale), ma e' il primo miglioramento
+STRUTTURALE del rischio-aggiustato complessivo trovato in tutta la ricerca post-reset, ed e' del tipo
+giusto (diversificazione vera, non alpha fittizio). Prossimo: validare il combo deployable TP01+GTAA
+(solo le due gambe eseguibili), e valutare l'operativita' cross-venue.
@@ -0,0 +1,45 @@
+# 2026-06-22 — Fronte EQUITY aperto + EQ-MOM01 (momentum settoriale): NON batte SPY
+
+## Apertura fronte (branch research/equities-ib)
+
+Le 4 ondate crypto hanno esaurito gli angoli su BTC/ETH (soffitto ~1.3). L'unico modo di superarlo è
+un **mercato diverso**. Aperto il fronte azioni/ETF via IB (paper, `gnzsnz/ib-gateway`, read-only).
+
+**Dati certificati + cache su disco** (`fetch_ib_equities.py` → `data/raw/eq_*.parquet`, ADJUSTED_LAST
+div+split, gitignored = cache locale; loader `eqlib.py` con lru_cache → ricerca legge da disco, MAI
+da IB). Universo: 9 SPDR settoriali classici dal **1998 (27.5y)** + XLRE(2015)/XLC(2018) + SPY(1996,
+30y)/QQQ/IWM/GLD/HYG/TLT. Tutti integri (monotoni, no dup, no spike>50%, 0 gap lunghi).
+NB bug timestamp risolto: `pd.Timestamp` a risoluzione µs → salvati in secondi, corretti a ms.
+
+## EQ-MOM01 — momentum cross-sectional settoriale
+
+Costruzione causale (`eq_sector_momentum.py`): ogni 21g, momentum = blend lookback [63,126,252]g con
+skip-21 (12-1 classico), z-score cross-sectional. long-only top-k (full-invested, confronto
+like-for-like con SPY) e long-short (dollar-neutral, test alpha puro). Netto fee, hold-out OOS 2015+.
+
+### Risultati (9 settori, 1998-2026)
+| strategia | CAGR | Sharpe (pre15/OOS15+) | maxDD | corr SPY |
+|---|---|---|---|---|
+| **SPY buy&hold** | 8.2% | **0.51** (0.31/0.82) | 55% | — |
+| EW 9 settori | 8.9% | 0.56 (0.44/0.76) | 53% | 0.96 |
+| MOM long top-3 | 7.7% | 0.50 (0.32/0.76) | 47% | 0.85 |
+| MOM long vol-target 15% | 7.3% | 0.52 | 39% | 0.75 |
+| **MOM long-short top-3** | −0.9% | **−0.08** (−0.19/0.08) | 32% | −0.20 |
+
+### Verdetto: NESSUN edge vs SPY
+- **Long-short Sharpe −0.08** → l'alpha cross-sectional di momentum settoriale è **morto** su 27 anni
+  (decadimento post-2000 noto in letteratura). Niente alpha market-neutral.
+- **Long-only ≈ SPY**: corr 0.85, **uplift marginale ~0.00** (blend 75/25 +0.012 FULL / +0.001 OOS;
+  50/50 +0.015 / −0.010). È un SPY a beta più basso, non un edge. Plateau stabile ma sempre ~0.50
+  (vs SPY 0.51); sugli 11 settori (2018+) fa peggio (0.69 vs 0.82). Fee-robusto (ma niente da salvare).
+- L'unico beneficio (maxDD 55%→39%) è del **vol-target**, non del momentum (lo daresti a SPY stesso).
+
+## Lezione (coerente col progetto)
+Il momentum **relative-value** è morto anche in equity, come nel crypto (ortho wave). Il baseline
+equity da battere è SPY buy&hold (Sharpe ~0.51 full / 0.82 OOS), ostico come il toro crypto.
+
+## Prossimo angolo plausibile (NON ancora testato)
+L'analogo equity di TP01 (l'unica cosa che ha retto nel crypto = trend DIFENSIVO): **time-series
+trend su SPY long-flat/long-bonds** — non per battere il CAGR ma per **tagliare il 55% di drawdown**
+restando vicino al ritorno. È il punto dove vive il valore robusto in equity (e dove il cross-section
+NON guarda). Da provare con lo stesso gauntlet: marginale vs SPY, OOS lungo, plateau.
@@ -0,0 +1,48 @@
+# 2026-06-22 — EQ-TREND01: trend DIFENSIVO su SPY = edge difensivo REALE (analogo di TP01)
+
+## Contesto
+Il momentum cross-sectional settoriale è morto (EQ-MOM01: long-short Sharpe −0.08, long-only ≈ SPY).
+Ma nel crypto l'unica cosa che ha retto NON era relative-value: era **TP01**, un trend DIFENSIVO che
+taglia il drawdown. L'equity ha lo stesso buco: SPY buy&hold Sharpe ~0.54 ma maxDD **55%**.
+
+## Costruzione (causale, stile TP01)
+`eq_spy_trend.py`. TSMOM multi-orizzonte [21,63,126,252]g, target = frazione di orizzonti in
+trend-up (allocazione graduale 0..1), opz. vol-target. Posizione decisa a ≤i-1, tenuta da i. Netto
+fee. Varianti: long-flat (cash in risk-off), long-bonds (TLT, solo 2016+), SMA-200 (Faber). Dati da
+cache eqlib (ADJUSTED, nessun IB). Periodo 1997-2026, OOS 2015+.
+
+## Risultati
+| strategia | CAGR | Sharpe (pre15/OOS) | maxDD | in-mkt |
+|---|---|---|---|---|
+| SPY buy&hold | 9.0% | 0.54 (0.38/0.82) | 55% | 99% |
+| **SMA-200 (Faber)** | 7.0% | **0.65** (0.52/0.88) | **29%** | 76% |
+| TSMOM lf cap1.0 | 5.7% | 0.57 (0.44/0.78) | 30% | 92% |
+| TSMOM lf vt15% | 5.7% | 0.62 (0.51/0.78) | **25%** | 92% |
+
+**Drawdown nei bear (TSMOM vs SPY):** dot-com 26%/49% · GFC **19%/55%** · COVID 17%/34% · 2022 16%/24%.
+
+**Plateau** (long-flat): ogni config Sharpe 0.56-0.65 (> SPY 0.54), maxDD 25-31% (~metà di SPY).
+SMA-200 il più semplice E il migliore (Sh 0.65, OOS 0.88, DD 29%). **Fee-robusto** (Sh 0.48 a
+0.10%/lato), basso turnover.
+
+**Marginale vs SPY:** corr 0.73. blend 50/50 uplift +0.035 FULL / +0.031 OOS (modesto positivo);
+100% trend uplift −0.012 / −0.041 (nel toro recente la difesa costa).
+
+## Verdetto: edge DIFENSIVO reale (non alpha) — analogo di TP01
+- ✅ Sharpe 0.54→0.62/0.65, **maxDD dimezzato** (55%→~27%, nei bear lenti più che dimezzato),
+  plateau robusto, fee-robusto, **eseguibile a $0.5-2k** (switch mensile SPY/cash).
+- ⚠️ NON genera ritorno (CAGR −2/3pp): è risk-management, come TP01.
+- ⚠️ I tagli grossi (dot-com/GFC) sono IN-SAMPLE; l'OOS 2015-26 è quasi tutto toro → lì ha seguito
+  SPY a beta minore (ma COVID, OOS, dimezzato). La difesa "serve" nei bear, rari nell'OOS.
+- ⚠️ long-bonds (TLT) non convince (TLT distrutto 2022).
+
+## Lettura strategica
+Primo positivo del fronte equity, e dello stesso TIPO che ha retto nel crypto: trend difensivo, non
+relative-value. Conferma la lezione cross-mercato: **il valore robusto è nel ridurre il rischio
+(trend long-flat), non nel battere il buy&hold**. Da solo non risolve €50/g (problema di capitale).
+
+## Prossimo angolo plausibile
+**Trend multi-asset / GTAA** sull'universo ETF in cache (SPY/QQQ/IWM + TLT/GLD/HYG): un portafoglio
+di trend long-flat su classi d'attivo diverse di solito batte il trend mono-SPY sul rischio-aggiustato
+(diversificazione dei trend). + domanda cross-mercato: la sleeve equity-trend DIVERSIFICA il
+portafoglio crypto (TP01+XS01+VRP01)? (esecuzione split Deribit+IB).
@@ -0,0 +1,96 @@
+# 2026-06-22 — Funding-CARRY cross-sectional su Hyperliquid (FC01): LEAD fragile, NON regge
+
+## Contesto
+
+Onda "nuova ricerca mirata" (l'utente ha chiesto di cercare un angolo non coperto dalle due grandi
+ondate — sweep 104-ipotesi e ortho relative-value, entrambe esaurite sul *prezzo* BTC/ETH). L'unico
+meccanismo con una **fonte di ritorno diversa** non ancora testato su dati certi è il **carry da
+funding**: incassare il cashflow dei perp stando delta-neutral.
+
+### Scan di fattibilità dati (prima di tutto, lezione v2.0.0)
+- **Funding price-clock** (drift attorno agli stamp 00/08/16) sul feed Deribit certificato →
+  già testato nell'onda intraday (`agent_03_funding_clock_15m`) = **FAIL** ("il funding è un cashflow
+  perp-vs-spot; il prezzo index non ha drift tradabile attorno allo stamp al netto del trend").
+- **Funding carry su Deribit** (dove eseguiamo) → ccxt `fetch_funding_rate_history` = **0 righe**
+  (bloccato), Cerbero MCP espone solo `get_historical` (candele), endpoint funding = 404.
+- **Funding carry su Hyperliquid** → API pubblica `/info {"type":"fundingHistory"}` = **disponibile**,
+  oraria, tokenless, serie native dal 2023-05. HL è già l'universo certificato di XS01.
+
+### Dato scaricato e certificato
+`scripts/research/fetch_hl_funding.py` (backoff anti-429) → **19 major** (gli stessi di XS01),
+`data/raw/hlfund_<sym>_1h.parquet`. Certificazione: cadenza ~1h, **0 gap**, copertura 98-100%,
+funding annualizzato per asset da **APT +1.0%** a **NEAR +21.6%** (mediana ~+11.7%). Pochi `cap_hit`
+(ore con |funding|>0.06%/h) su INJ/TIA/SEI, plausibili in alt ad alta vol. Dato pulito.
+
+## Ipotesi e costruzione (FC01)
+
+Book dollar-neutral che **SHORTA i k perp ad alto funding** e **COMPRA i k a basso** → incassa il
+premio (chi è long paga il funding). Ritorno perp per un long = `price_ret − funding`. Causale come
+XS01: ogni H=10 giorni, segnale = media causale del funding giornaliero realizzato sugli ultimi L
+giorni (shift 1), rank cross-section, vol-target 20%, fee 0.05%/lato sul turnover.
+`scripts/research/funding_carry_hl.py`. Domanda chiave: **edge reale e ORTOGONALE a XS01**, o XS01
+travestito? (gli alt ad alto funding sono spesso i pompati = quelli che XS01 *compra*; qui li
+*shortiamo* → potenziale anti-correlazione, oppure il carry domina).
+
+## Risultati
+
+### Premio reale ma direzione-dipendente
+`carry` (short alto-funding) batte sistematicamente `anti` (long alto-funding, sempre molto negativo)
+→ **il premio di funding esiste**: shortare i perp ad alto funding paga, in aggregato.
+
+### Ma il book NON regge il gauntlet (19 asset, 2024-2026, 904g)
+- **Standalone base (L=7 k=5): FULL Sharpe −0.12, in-sample 0.44, HOLD −0.50, DD 28.6%**, −2.8%/anno.
+  Decadimento netto: 2024 **+0.44** → 2025 −0.06 → 2026 **−1.42**.
+- Correlazioni: TP01 −0.02, **XS01 −0.19** (ortogonale, come da ipotesi — NON è XS01 travestito),
+  VRP01 +0.05.
+- **`marginal_vs_tp01` = DILUTES**: `has_insample_edge=False` (in-sample 0.44 < 0.5),
+  `multicut_persistent=False`, blend w25 uplift FULL −0.21 / HOLD −0.39.
+- **Non aggiunge a XS01**: uplift w25 FULL −0.04 / HOLD −0.19.
+
+### Il colpo di grazia: FRAGILITÀ all'universo
+Un preview su 17 asset (mancavano NEAR e AAVE) dava FULL **+0.62**, ADDS, +0.22 uplift — un PASS
+tentatore. Sui 19 completi: **DILUTES**. Jackknife lascia-fuori-uno (base L=7 k=5):
+
+```
+19 asset:  FULL -0.12  HOLD -0.50
+-SUI   FULL -0.39      ...      -BTC  FULL +0.17
+-SEI   FULL -0.31               -AAVE FULL +0.26
+-BNB   FULL -0.29               -NEAR FULL +0.30
+=> FULL oscilla in [-0.39, +0.30] togliendo UN solo asset (range 0.70), attraversa lo zero.
+```
+
+Togliere **NEAR o AAVE** (i due assenti nel preview) **recupera il segno** → il preview era fortunato
+*proprio* perché quei due non c'erano ancora. **Un edge robusto non cambia segno per un singolo nome.**
+Le poche celle "buone" del plateau (es. L=7 k=3: HOLD 0.91) hanno **in-sample debole + hold-out forte**
+= la firma del hold-out-luck che la metodologia indurita uccide.
+
+## Perché fallisce (meccanismo)
+
+Tensione fondamentale **carry vs momentum**: il funding-carry shorta i forti (alto funding = domanda
+long aggressiva), ma in un mercato alt toro i forti **continuano a correre** (NEAR/AAVE: alto funding
+*e* prezzo su → shortarli perde più del premio incassato). Il premio di funding è reale in aggregato,
+ma il book cross-sectional equal-weight top-k è dominato da pochi nomi a funding estremo che *anche*
+trendano, e su 2.5 anni / 19 nomi questo basta a ribaltare il segno.
+
+## Verdetto
+
+**FC01 NON è uno sleeve.** Né deploy (è STAT-MODE: 10 gambe market-neutral, non eseguibile a $600),
+né lead affidabile: fragile all'universo (sign-flip su un nome), DILUTES vs TP01, non aggiunge a XS01,
+in-sample edge < 0.5, niente persistenza multi-cut, decadimento 2026. Conferma — di nuovo — il
+soffitto del progetto: promettente su un sottoinsieme fortunato, collassa sotto il gauntlet onesto.
+**Win metodologico:** lo scorer indurito + il jackknife d'universo hanno intercettato un falso
+positivo che il preview a 17 asset avrebbe promosso.
+
+## Lascito / lavoro futuro (NON inseguire ora)
+- I 19 parquet funding (`hlfund_*`) restano certificati per ricerca futura. Il fetcher NON va in cron
+  (FC01 fallito → niente da monitorare in forward).
+- Idee se mai si tornasse sul carry (NON ora): (a) **gate sul LIVELLO** di funding (short solo quando
+  estremo, regime-filter alla VRP01 IV-rank) invece dello short-top-k incondizionato; (b) cap sul peso
+  per-nome / neutralizzazione momentum per togliere il dominio NEAR/AAVE. Entrambe rischiano
+  overfitting su storia corta — soglia di prova alta.
+
+## Nota IB (thread parallelo, stessa sessione)
+Esplorato come fonte per il **basis CME crypto** (cugino eseguibile del carry). Gateway paper
+`gnzsnz/ib-gateway` su `127.0.0.1:4002` (read-only, `docker-compose.yml`), sonda `ib_probe.py`.
+Esito dati: **backtest del basis NON fattibile** (ContFuture back-adjusted; contratti scaduti = 1
+barra). IB resta valido per esecuzione/forward, non per scoprire l'edge. Dettagli nel corpo sessione.
@@ -0,0 +1,33 @@
+# 2026-06-23 — Combo DEPLOYABLE in PAPER: TP01 (Deribit) + GTAA (IB), cross-venue
+
+## Decisione
+Dopo aver esaurito (onestamente) la ricerca di nuovi edge e anticipazioni cross-mercato, l'unica cosa
+VERA e deployabile e' la DIVERSIFICAZIONE: TP01 (crypto, Deribit) + GTAA (equity, IB), corr ~0.21 ->
+blend Sharpe ~1.5, maxDD dimezzato (diari 2026-06-22-deployable-combo). Si va in PAPER cross-venue.
+
+## Costruito
+- **`src/portfolio/gtaa.py`** — GTAA come sleeve di prima classe: trend difensivo long-flat TSMOM
+  [21/63/126/252g], vol-target 12%, EW su SPY/QQQ/IWM/TLT/GLD/HYG. Espone `gtaa_returns()` (Sharpe
+  full 0.64, 7542 barre 1996+) e `gtaa_weights()` (pesi ETF CORRENTI azionabili). Legge cache eq_*.
+- **`scripts/live/paper_combo.py`** — paper-tracker FORWARD-ONLY del blend 50/50 TP01+GTAA (crypto
+  compoundato sul grid giorni-di-borsa). Stato in data/paper_combo/. Mostra le posizioni azionabili
+  su entrambi i venue. SOLO le gambe eseguibili (XS01/VRP01 STAT-MODE esclusi).
+- **`fetch_ib_equities.py --only SPY,QQQ,...`** — refresh mirato dei 6 ETF GTAA (per il cron).
+- **`scripts/cron_daily.sh`** — aggiunto: up gateway IB (idempotente) -> refresh ETF GTAA ->
+  avanza paper_combo. Dipendenza cross-venue gestita (gateway paper sempre-up, restart unless-stopped).
+
+## Stato iniziale (2026-06-23)
+Paper combo init a 2000, forward da 2026-06-22. Posizioni azionabili:
+- TP01 (Deribit): BTC/ETH 0.0x (flat, TSMOM risk-off — coerente col live).
+- GTAA (IB): SPY 13% / QQQ 8% / IWM 9% / TLT 17% / GLD 2% / HYG 17% / cash 34% (difensivo).
+Catena end-to-end testata: gateway -> refresh ETF -> avanza paper. OK.
+
+## Onesta'
+- E' PAPER (rischio zero). Valida l'OPERATIVITA' cross-venue prima di capitale reale.
+- Sharpe atteso ~1.5 e' ottimistico (finestra crypto corta/favorevole); il dato robusto e' la
+  diversificazione (corr 0.21, DD dimezzato), non il livello assoluto.
+- A capitale reale e' un portafoglio su DUE conti (Deribit ~$600 + IB); GTAA frazionabile a basso
+  capitale, TP01 gia' armato. Prossimo passo eventuale: dashboard del combo + (molto dopo) capitale.
+
+## Prossimo
+Lasciar girare il paper forward (cron giornaliero) e ricontrollare l'equity tra qualche settimana.
@@ -0,0 +1,38 @@
+# 2026-06-23 — Cross-market crypto-lead OLTRE l'SP500: bond, commodity, indici esteri -> niente
+
+## Obiettivo
+Estendere il test "crypto anticipa il mercato?" oltre SP500/azionario USA: commodity, bond, indici
+ESTERI (Europa/Asia, fasi orarie diverse = il caso a priori piu' favorevole a un lead vero).
+
+## Dati (IB, orari, cache fut_*_1h)
+ES/NQ/RTY (gia'); + ZN (T-note 10y), ESTX50 (Euro Stoxx50), DAX, NKD (Nikkei). Storia ~2-2.4y (2024+).
+Commodity GC/CL/HG: VUOTE (market-data subscription COMEX/NYMEX mancante sul paper) -> non testate.
+
+## Test (`fut_leadlag_generic.py`): crypto[T-8h->T] -> future[T->T+6h], non-sovrapposto, controllo=moto proprio future
+- ES/NQ/RTY: nessun edge (gia' noto).
+- ZN (bond): NEGATIVO (0/3 anni).
+- NKD (Nikkei): debole (t_crypto 0.2, Sharpe 0.66 ~ overnight drift, non crypto).
+- **ESTX50 / DAX: forte all'apparenza** — BTC->T0h: t_crypto ~7.8, Sharpe 2.5, ann ~22%, 3/3 anni.
+
+## Ma e' un ARTEFATTO DI CONFINE UTC (deep-dive `eu_overnight_deepdive.py`)
+- **Picco a coltello a T=00:00 UTC**: t/Sharpe salgono T20->T0 (2.5->7.8 / 0.24->2.45) e CROLLANO a
+  T=1h (t 1.3, Sharpe -0.09). Un lead vero non e' a coltello su una sola ora.
+- **GAP test**: inserendo 1h tra fine-segnale (00:00) e inizio-cattura, l'effetto MUORE
+  (Sharpe 2.45 -> -0.52, t 7.8 -> 1.6).
+- **Singola ora**: T=0h/H=1h (cattura 00:00->01:00) Sharpe +2.93 (t 8.7); T=1h/H=1h (01:00->02:00)
+  Sharpe -1.02. L'INTERO "edge" e' la barra di confine 00:00->01:00.
+- vs SEMPRE-LONG: always-long overnight e' negativo (-0.8/-1.2), quindi non e' overnight-drift; ma
+  l'uplift del crypto e' tutto nella barra di confine.
+-> Firma esatta di `day_boundary_robust` (CLAUDE.md): effetto che vive/muore spostando il confine del
+   giorno UTC di poche ore = etichettatura/contaminazione, NON anticipazione economica.
+
+## Verdetto
+NIENTE di tradabile oltre l'SP500 nemmeno. Su TUTTI i mercati il legame crypto->X e' o co-movimento
+contemporaneo (risk-beta) o artefatto di confine. L'anticipazione crypto->altri-mercati sfruttabile
+NON esiste su dati onesti (finestre non-sovrapposte + boundary-robust + gap). Conferma definitiva del
+soffitto del progetto, ora anche cross-mercato.
+
+## Cosa resta di valore (immutato)
+La diversificazione TP01(crypto)+GTAA(equity), corr 0.21 -> Sharpe portafoglio ~1.5, DD dimezzato.
+Quello e' strutturale e deployabile; l'anticipazione cross-mercato no.
+Script: fetch_ib_futures.py (multi-exchange), fut_leadlag_generic.py, eu_overnight_deepdive.py.
@@ -0,0 +1,29 @@
+# 2026-06-23 — "Monitor Deribit / trade IB": il gap crypto->equity e' LOOK-AHEAD
+
+## Idea testata (utente)
+Guardare crypto live su Deribit (24/7) e tradare l'indice su IB sul segnale del gap overnight.
+
+## Trappola trovata
+Il segnale crypto [P 21:00 -> D 13:00 UTC] e il "gap" equity [P close -> D open 13:30] coprono QUASI
+LE STESSE ORE. Condizionare il gap sul crypto-overnight = correlare due ritorni dello STESSO intervallo
+notturno -> look-ahead. All'entrata (D 13:00, pre-open) il gap e' GIA' avvenuto: non catturabile.
+
+## Prova (net 2bps, sqrt(252))
+| target | OVERLAP gap (look-ahead) | TRADABILE intraday (post-entrata) |
+|---|---|---|
+| SPY | Sharpe 3.60 (OOS 5.23) | -0.03 (OOS 0.12) |
+| QQQ | Sharpe 4.01 (OOS 5.47) | 0.25 (OOS 0.43) |
+| IWM | Sharpe 3.98 (OOS 5.72) | 0.15 (OOS 0.44) |
+
+Lo "Sharpe 5" e' artefatto. L'edge REALE tradabile via ETF (intraday, entri all'open) ~0, muore a costi.
+NB: anche i Sharpe "gap" del workflow 65-agenti erano (a) look-ahead di overlap e (b) sotto-annualizzati
+(sqrt(52) invece di sqrt(252)); il verdetto "non deployabile" resta, rafforzato.
+
+## Cosa resta possibile (non testato, serve dato)
+L'unica versione onesta dell'idea: entrare a META' notte via FUTURES IB e vedere se crypto [P21:00->T]
+predice il future indice [T->open] su finestre NON sovrapposte (crypto come sensore di rischio piu'
+veloce). Richiede dati INTRADAY dei futures (ES/NQ/RTY), non in cache -> data step se si vuole indagare.
+
+## Lezione
+Un risultato "troppo bello" (Sharpe 5) e' un test di disciplina: era overlap di finestre. Catturato.
+Script: crypto_overnight_equity.py (versione artefatto), crypto_overnight_honest.py (decomposizione).
@@ -0,0 +1,37 @@
+# 2026-06-23 — "Monitor Deribit / trade IB" su futures: test ONESTO non-sovrapposto -> edge ~0
+
+## Idea
+Monitorare crypto live (Deribit 24/7) ed entrare sul FUTURE indice IB (ES/NQ/RTY, tradato di notte)
+a meta' notte, catturando il moto SUCCESSIVO -> finestre NON sovrapposte (no look-ahead, vs il "gap"
+che era contemporaneo al segnale).
+
+## Dati
+`fetch_ib_futures.py` -> data/raw/fut_{es,nq,rty}_1h.parquet (ContFuture orario, UTC). ES 3y (2023-06+),
+NQ 2.75y, RTY 2.3y. (NB: ContFuture NON accetta endDateTime -> chiamata singola "4 Y" = ~3y max orari.)
+
+## Test (`fut_overnight_leadlag.py`)
+entrata a T (ora UTC notturna): segnale = crypto[P21:00->T]; controllo = future[P21:00->T] (moto
+PROPRIO del future); cattura = future[T->open 13:00]. Incrementale: crypto predice la cattura OLTRE il
+moto proprio del future? Trade: sign(crypto[P21:00->T]) * future[T->open], net 2bps. T in {0,3,6,9}h.
+
+## Risultati
+| future | miglior Sharpe (trade crypto) | t_crypto incrementale | esito |
+|---|---|---|---|
+| ES (S&P500) | ~0 / negativo (-0.03..-0.93) | 0..1.5 | NESSUN edge |
+| NQ (Nasdaq) | 0.41 (T=3h) | 0.5 (debole) | momentum del future, non crypto |
+| RTY (Russell) | 0.40-0.77 | 2.0-2.7 (BTC->RTY) | soffio debole, non robusto |
+
+- **SP500: NIENTE.** Il crypto della prima notte non predice l'ES della seconda. Il "Sharpe 5" del gap
+  era interamente look-ahead (finestre sovrapposte): catturato e ucciso.
+- **RTY (small-cap)** e' l'unico con t_crypto incrementale ~2-2.7 e crypto che AGGIUNGE oltre il moto
+  proprio del future (futOwn Sharpe negativo). MA: Sharpe 0.4-0.5 modesto, 24 config (multiple-testing),
+  storia 2.3y, per-anno INCOERENTE (BTC->RTY T=3h: 2024 +0.99 / 2025 +0.52 / 2026 -0.31).
+
+## Verdetto
+L'idea "monitor Deribit / trade IB" NON da' un edge tradabile, men che meno su SP500. Il forte
+fenomeno crypto<->equity e' CO-MOVIMENTO contemporaneo (risk-beta overnight), non anticipazione: quando
+si impone una finestra causale non-sovrapposta, l'edge svanisce (efficienza di mercato). L'unico
+residuo (crypto->small-cap overnight) e' debole, borderline su multiple-testing e instabile per anno
+-> forward-monitor al piu', NON deploy. Coerente col soffitto del progetto.
+
+Script: fetch_ib_futures.py, fut_overnight_leadlag.py. (look-ahead documentato: 2026-06-23-crypto-overnight-lookahead.md)
@@ -0,0 +1,66 @@
+# 2026-06-23 — Tail-hedge / protezione DD del combo (incl. OPZIONI): vince la guardia-drawdown
+
+## Obiettivo (goal utente)
+Trovare uno sleeve/overlay da AGGIUNGERE al combo (TP01+GTAA) per proteggere il drawdown e gli anni
+tipo 2022. Valutare anche le opzioni.
+
+## Diagnosi del rischio (decisiva)
+Il MaxDD del combo (1x) e' **8.4%** e il 2022 fu **-4.4%**: NON un crash, un **grind lento** (peggior
+giorno -2.8%, peggior mese 2022 -1.6%). Il doppio trend (TP01+GTAA long-flat) gia' taglia i crash
+veloci. Il tail residuo = (a) whipsaw da mercato choppy (2022), (b) gap/crash overnight LATENTE (TP01
+non reagisce intraday, non nel campione storico), (c) la LEVA.
+
+## Candidati testati (`tail_hedge_lab.py`)
+| protezione | MaxDD | 2022 | Sharpe | CAGR |
+|---|---|---|---|---|
+| combo baseline | 8.4% | -4.4% | 1.48 | 11.3% |
+| **+ guardia-DD -4%** | **5.8%** | **-1.8%** | 1.38 | 9.2% |
+| + vol-target 5% | 8.4% | -5.9% | 1.46 | 8.0% |
+| + opzioni (put/put-spread, budget 3%/y) | 8.4% | -4.4% | 1.48 | 11.3% |
+
+### OPZIONI (valutate): NON adatte al 2022
+- Put-spread/long-put LONG su indice 50/50 BTC/ETH (mirror di VRP01), premio BS su DVOL reale, payoff
+  sul path. Strike corretti (compra -0.30delta, vende -0.10delta).
+- Sempre-on costa **~50%/anno** di premio -> con budget 3%/anno size ~0.06-0.10x = effetto ~nullo.
+- Nel 2022 (grind, niente crash settimanali) **sanguinano** (scadono inutili) -> Δ2022 ~0.
+- Pagano SOLO nei crash secchi: stress -30% overnight -> put paga **+25% netto**, put-spread +3.8%.
+- Verdetto: assicurazione BLACK-SWAN cara e fuori-bersaglio per il grind. Utile solo come piccola
+  copertura del gap overnight latente, NON come fix del 2022.
+
+### GUARDIA DRAWDOWN: centra il rischio
+De-risk (esposizione 1.0->0.4) quando il DD da picco supera -4%, ri-rischia a -1.6%. Targetizza il
+grind: MaxDD 8.4%->5.8%, 2022 -4.4%->-1.8%, ogni anno DD intra <=5.4%. Costo: Sharpe 1.48->1.38,
+CAGR -2.1pp (de-risca sui cali, perde rimbalzo — prezzo onesto della protezione).
+
+### A LEVA (dove il tail morde)
+guard applicato pre-leva: 2x 2022 -15.6%->-10.9%, MaxDD 28%->24%; 3x resta MARGIN-CALL (DD 39%>=33%).
+-> la protezione rende il 2x sopportabile; il 3x va evitato comunque.
+
+## Raccomandazione
+AGGIUNGERE una **guardia-drawdown a livello di portafoglio** al combo (overlay, niente premio):
+e' la protezione che colpisce il rischio reale (grind/2022) a costo Sharpe minimo. Le opzioni NO come
+fix del 2022; eventualmente una micro-allocazione deep-OTM come assicurazione black-swan separata.
+Vol-target NON aiuta (il 2022 non e' uno spike di vol).
+
+## Onesta'
+- Il guard e' REATTIVO (de-risca dopo l'inizio del DD, restituisce un po' di rimbalzo) -> costa CAGR.
+- Trade: -2.1pp CAGR per dimezzare il MaxDD e azzerare quasi il 2022. Sensato se la priorita' e' il DD.
+- Parametri (-4% trigger) semplici; il meccanismo (non la soglia esatta) e' la sostanza.
+Script: tail_hedge_lab.py.
+
+## Aggiornamento — protezioni CLASSICHE (stop-loss), goal "prova anche SL" (`stops_lab.py`)
+Confronto equo (trigger/re-entry sul NAV di mercato, non sull'equity congelata):
+| protezione | Sharpe | MaxDD | 2022 | CAGR | in-mkt |
+|---|---|---|---|---|---|
+| baseline | 1.48 | 8.4% | -4.4% | 11.3% | 100% |
+| **soft-guard -4% (0.4x)** | **1.38** | **5.8%** | **-1.8%** | 9.2% | 100% |
+| trail-stop -4% (uscita tot.) | 1.07 | 7.5% | +0.0% | 6.6% | 42% |
+| trail-stop -6% (re:newhigh) | 1.34 | 6.6% | -2.1% | 9.0% | 72% |
+| trail-stop -8% | 1.41 | 8.3% | -4.2% | 10.0% | 87% |
+| stop mensile -5% | 1.48 | 8.4% | -4.4% | 11.3% | 100% (mai scatta) |
+| vol-stop (>90pctl) | 1.48 | 8.4% | -4.4% | 10.4% | 100% |
+
+VERDETTO: lo SL classico funziona solo a -6% (e resta inferiore al soft-guard); a -4% fa WHIPSAW
+(Sh 1.48->1.07, fuori mercato 58%) perche' l'uscita TOTALE viene choppata nel grind. Il soft-guard
+alla stessa soglia non whippa (de-risk parziale 0.4x). Stop mensile/vol inutili (bersaglio sbagliato).
+Conferma: per un DD da grind, de-risk PARZIALE > stop-loss duro. Soft-guard -4% confermato come scelta.
@@ -11,5 +11,10 @@ mkdir -p logs
  uv run python scripts/live/paper_portfolio.py                       # avanza paper TP01+XS01
  uv run python scripts/live/paper_prevday.py                         # forward-monitor lead prevday-breakout (PAPER, non deploy)
  uv run python scripts/live/live_execute.py --execute                # TP01 LIVE su Deribit (gated da config/live.json)
+  # --- COMBO cross-venue (PAPER): refresh ETF IB (GTAA) + avanza paper TP01+GTAA ---
+  docker compose up -d ib-gateway >/dev/null 2>&1                      # gateway IB paper (idempotente)
+  for i in $(seq 1 25); do (echo > /dev/tcp/127.0.0.1/4002) >/dev/null 2>&1 && break; sleep 6; done
+  uv run --with ib_async python scripts/research/fetch_ib_equities.py --only SPY,QQQ,IWM,TLT,GLD,HYG  # ETF GTAA freschi
+  uv run python scripts/live/paper_combo.py                           # avanza paper combo (forward-only)
  echo "===== done $(date -u '+%H:%M:%SZ') ====="
 } >> logs/cron_daily.log 2>&1
@@ -0,0 +1,117 @@
+"""PAPER COMBO — forward-only del combo cross-venue TP01 (Deribit) + GTAA (IB), NUDO vs PROTETTO.
+
+Le due gambe eseguibili a basso capitale (XS01/VRP01 STAT-MODE esclusi), scorrelate (corr ~0.21) ->
+blend Sharpe ~1.5, DD dimezzato. Traccia FORWARD-ONLY DUE versioni in parallelo:
+  * NUDO     = blend 50/50 TP01+GTAA
+  * PROTETTO = stesso blend + GUARDIA-DRAWDOWN -4% (de-risk a 0.4x quando il DD da picco supera -4%,
+               ri-rischia a -1.6%). Backtest: MaxDD 8.4%->5.8%, 2022 -4.4%->-1.8%, Sharpe 1.48->1.38
+               (diario 2026-06-23-tail-hedge-lab). Le opzioni NON aiutano il grind del 2022 -> escluse.
+Crypto compoundato sul grid giorni-di-borsa. NESSUNA esecuzione reale. Mostra posizioni azionabili.
+
+  uv run python scripts/live/paper_combo.py [--status|--reset]
+"""
+from __future__ import annotations
+import sys, json
+from pathlib import Path
+PROJECT_ROOT = Path(__file__).resolve().parents[2]
+sys.path.insert(0, str(PROJECT_ROOT))
+import numpy as np, pandas as pd
+from src.portfolio.sleeves import _tp01_returns, _tp01_positions
+from src.portfolio.gtaa import gtaa_returns, gtaa_weights
+
+STATE_DIR = PROJECT_ROOT / "data" / "paper_combo"
+STATE = STATE_DIR / "state.json"
+EQ = STATE_DIR / "equity.csv"
+INITIAL = 2000.0
+W_CRYPTO = 0.5
+DD_TRIGGER = 0.04   # guardia-drawdown della versione PROTETTA
+
+
+def combo_daily(wc: float = W_CRYPTO) -> pd.Series:
+    tp = _tp01_returns()
+    if tp.index.tz is None:
+        tp.index = tp.index.tz_localize("UTC")
+    eq = gtaa_returns().dropna()
+    grid = eq.index[eq.index >= tp.index[0]]
+    cum = (1.0 + tp).cumprod()
+    tpg = (cum.reindex(cum.index.union(grid)).ffill().reindex(grid)).pct_change()
+    J = pd.concat({"c": tpg, "e": eq.reindex(grid)}, axis=1).dropna()
+    return (wc * J["c"] + (1 - wc) * J["e"]).dropna()
+
+
+def apply_dd_guard(r: pd.Series, trigger: float = DD_TRIGGER) -> pd.Series:
+    """De-risk a 0.4x quando il DD da picco > trigger; ri-rischia a 1.0x quando < 0.4*trigger."""
+    rv = r.values; n = len(rv); eq = np.cumprod(1 + rv); pk = np.maximum.accumulate(eq)
+    expo = np.ones(n); on = True
+    for i in range(1, n):
+        ddi = (pk[i - 1] - eq[i - 1]) / pk[i - 1] if pk[i - 1] > 0 else 0.0
+        if ddi > trigger: on = False
+        if ddi < trigger * 0.4: on = True
+        expo[i] = 1.0 if on else 0.4
+    return pd.Series(expo * rv, index=r.index)
+
+
+def both_daily():
+    naked = combo_daily()
+    return naked, apply_dd_guard(naked)
+
+
+def load():
+    return json.loads(STATE.read_text()) if STATE.exists() else None
+
+
+def save(st):
+    STATE_DIR.mkdir(parents=True, exist_ok=True)
+    STATE.write_text(json.dumps(st, indent=2))
+
+
+def advance():
+    naked, guard = both_daily()
+    st = load()
+    if st is None or "equity_g" not in st:                # init (o migrazione a doppia versione)
+        last = str(naked.index[-1])
+        st = dict(start=last, last=last, initial=INITIAL, n_days=0, w_crypto=W_CRYPTO, dd_trigger=DD_TRIGGER,
+                  equity=INITIAL, peak=INITIAL, max_dd=0.0,
+                  equity_g=INITIAL, peak_g=INITIAL, max_dd_g=0.0)
+        save(st); EQ.write_text("date,nudo,protetto\n" + f"{last},{INITIAL},{INITIAL}\n")
+        return st
+    last = pd.Timestamp(st["last"])
+    nn = naked[naked.index > last]; gg = guard[guard.index > last]
+    if len(nn):
+        e = st["equity"]; pk = st["peak"]; dd = st["max_dd"]
+        eg = st["equity_g"]; pkg = st["peak_g"]; ddg = st["max_dd_g"]; lines = []
+        for d in nn.index:
+            e *= (1 + float(nn[d])); pk = max(pk, e); dd = max(dd, (pk - e) / pk if pk > 0 else 0)
+            eg *= (1 + float(gg[d])); pkg = max(pkg, eg); ddg = max(ddg, (pkg - eg) / pkg if pkg > 0 else 0)
+            lines.append(f"{d},{e:.4f},{eg:.4f}")
+        st.update(equity=e, peak=pk, max_dd=dd, equity_g=eg, peak_g=pkg, max_dd_g=ddg,
+                  last=str(nn.index[-1]), n_days=st["n_days"] + len(nn))
+        save(st)
+        with open(EQ, "a") as f:
+            f.write("\n".join(lines) + "\n")
+    return st
+
+
+def main():
+    a = sys.argv[1:]
+    if "--reset" in a:
+        for f in (STATE, EQ):
+            f.unlink(missing_ok=True)
+        print("paper combo azzerato.")
+    st = load() if "--status" in a else advance()
+    if st is None or "equity_g" not in st:
+        st = advance()
+    days = (pd.Timestamp(st["last"]) - pd.Timestamp(st["start"])).days
+    rn = st["equity"] / st["initial"] - 1; rg = st["equity_g"] / st["initial"] - 1
+    gw = gtaa_weights(); asof = gw.pop("_asof", "?"); cash = gw.pop("_cash", None)
+    print("PAPER COMBO — TP01 (Deribit) + GTAA (IB), forward-only, blend 50/50")
+    print(f"  start {st['start'][:10]} -> last {st['last'][:10]} ({days}g, {st['n_days']} barre)")
+    print(f"  NUDO     : eq {st['equity']:.2f}  ret {rn*100:+.2f}%  maxDD {st['max_dd']*100:.1f}%")
+    print(f"  PROTETTO : eq {st['equity_g']:.2f}  ret {rg*100:+.2f}%  maxDD {st['max_dd_g']*100:.1f}%  (guardia-DD -{st.get('dd_trigger',DD_TRIGGER)*100:.0f}%)")
+    print(f"  --- POSIZIONI AZIONABILI ---")
+    print(f"  TP01 (Deribit): {_tp01_positions()}")
+    print(f"  GTAA (IB, asof {asof}): " + ", ".join(f"{k} {v:.0%}" for k, v in gw.items() if v) + f"  | cash {cash:.0%}")
+
+
+if __name__ == "__main__":
+    main()
@@ -0,0 +1,74 @@
+"""Simulazione LEVA 1x/2x/3x su COMBO (TP01+GTAA) e TP01-solo, da $2k e $5k.
+
+Leva modellata onestamente: ritorno_giorno = L*r - (L-1)*financing/252 (costo del nozionale preso a
+prestito ~8%/anno blended: perp funding crypto + margin IB). MaxDD calcolato sul PERCORSO LEVATO REALE
+(non scalato: il compounding peggiora il DD oltre ×L). Check RUINA/margin-call: se l'equity tocca la
+soglia di liquidazione (perdita cumulata >= 1/L del picco -> margin call).
+
+CLAUDE.md: la leva NON e' la scorciatoia; raddoppia (e oltre) il drawdown. Caso base = 1x.
+"""
+import sys
+from pathlib import Path
+import numpy as np, pandas as pd
+ROOT = Path(__file__).resolve().parents[2]
+sys.path.insert(0, str(ROOT)); sys.path.insert(0, str(ROOT / "scripts" / "research"))
+from combo_yearly_report import combo_daily
+from src.portfolio.sleeves import _tp01_returns
+
+FIN = 0.08   # costo finanziamento annuo sul nozionale preso a prestito (perp funding + margin IB), blended
+
+
+def lever(ret: pd.Series, L: float) -> pd.Series:
+    return L * ret - (L - 1) * FIN / 252.0
+
+
+def analyze(ret: pd.Series, L: float, cap0: float):
+    r = lever(ret.dropna().sort_index(), L)
+    curve = cap0 * np.cumprod(1 + r.values)
+    peak = np.maximum.accumulate(curve)
+    dd = (peak - curve) / peak
+    maxdd = float(np.max(dd))
+    # margin call: perdita dal picco >= 1/L (a leva L, un drawdown del sottostante di 1/L azzera il margine)
+    ruin = bool(np.any(dd >= 1.0 / L - 1e-9)) if L > 1 else False
+    yrs = (r.index[-1] - r.index[0]).days / 365.25
+    cagr = (curve[-1] / cap0) ** (1 / yrs) - 1 if yrs > 0 and curve[-1] > 0 else -1
+    sh = float(r.mean() / r.std() * np.sqrt(252)) if r.std() > 0 else 0
+    worst_y = min((np.prod(1 + r[r.index.year == y].values) - 1) for y in sorted(set(r.index.year)))
+    return dict(L=L, final=float(curve[-1]), cagr=cagr, maxdd=maxdd, sharpe=sh, ruin=ruin,
+                worst_y=float(worst_y), perday=(curve[-1] - cap0) / yrs / 365)
+
+
+def main():
+    print("=" * 92)
+    print("  LEVA su COMBO vs TP01-solo — percorso reale (fin 8%/anno sul prestito), 2019-2026 (~7.3y)")
+    print("=" * 92)
+    strat = {"COMBO TP01+GTAA": combo_daily(), "TP01 solo (crypto)": _tp01_returns()}
+    for nm, r in strat.items():
+        if r.index.tz is None:
+            r.index = r.index.tz_localize("UTC")
+    for cap0 in (2000.0, 5000.0):
+        print(f"\n  ##### capitale iniziale ${cap0:,.0f} #####")
+        print(f"  {'strategia':20}{'leva':>5}{'CAGR':>8}{'MaxDD':>8}{'Sharpe':>8}{'pegg.anno':>10}{'$/giorno':>10}{'eq fine':>12}{'  RUINA?':>9}")
+        for nm, r in strat.items():
+            for L in (1, 2, 3):
+                a = analyze(r, L, cap0)
+                flag = "MARGIN-CALL" if a["ruin"] else "ok"
+                print(f"  {nm:20}{L:>4}x{a['cagr']*100:>7.1f}%{a['maxdd']*100:>7.1f}%{a['sharpe']:>8.2f}"
+                      f"{a['worst_y']*100:>9.1f}%{('$'+format(a['perday'],',.0f')):>10}{('$'+format(a['final'],',.0f')):>12}{flag:>11}")
+    # per-anno del COMBO a 2x e 3x da 2k (dettaglio)
+    print(f"\n  ##### COMBO per-anno a leva, da $2.000 #####")
+    cd = combo_daily()
+    for L in (2, 3):
+        print(f"\n  --- COMBO {L}x ---")
+        print(f"  {'anno':6}{'PnL %':>9}{'MaxDD %':>9}{'eq fine':>11}")
+        eq = 2000.0; r = lever(cd, L)
+        for y in sorted(set(r.index.year)):
+            ry = r[r.index.year == y]
+            if len(ry) < 5: continue
+            eq0 = eq; curve = eq0 * np.cumprod(1 + ry.values); peak = np.maximum.accumulate(curve)
+            ddp = float(np.max((peak - curve) / peak)); eq = float(curve[-1])
+            print(f"  {y:<6}{(eq/eq0-1)*100:>+8.1f}%{ddp*100:>8.1f}%{('$'+format(eq,',.0f')):>11}")
+
+
+if __name__ == "__main__":
+    main()
@@ -0,0 +1,90 @@
+"""Resoconto anno-per-anno CON PROTEZIONE (soft-guard DD -4%) — combo e singoli.
+
+Mette combo (TP01+GTAA 50/50), TP01 e GTAA sulla STESSA griglia giorni-di-borsa (come dentro al
+combo), applica la guardia-DD -4% a ciascuna serie (de-risk 1.0->0.4 a -4% dal picco, ri-rischia a
+-1.6%), e per ogni anno riporta: NL (net liquidation da $2000), DD intra-anno, rendimento (=CAGR
+1y), Sharpe. Riga TOT con CAGR e Sharpe complessivi.
+"""
+import sys
+from pathlib import Path
+import numpy as np, pandas as pd
+
+ROOT = Path(__file__).resolve().parents[2]
+sys.path.insert(0, str(ROOT))
+from src.portfolio.sleeves import _tp01_returns
+from src.portfolio.gtaa import gtaa_returns
+
+INITIAL = 2000.0
+ANN = np.sqrt(252.0)
+DD_TRIG = 0.04
+
+
+def dd_guard(r, dd_trigger=DD_TRIG):
+    """De-risk: esposizione 1.0->0.4 se DD da picco > dd_trigger; ri-rischia a dd_trigger*0.4."""
+    r = r.values; n = len(r); eq = np.cumprod(1 + r); pk = np.maximum.accumulate(eq)
+    expo = np.ones(n); on = True
+    for i in range(1, n):
+        ddi = (pk[i - 1] - eq[i - 1]) / pk[i - 1]
+        if ddi > dd_trigger: on = False
+        if ddi < dd_trigger * 0.4: on = True
+        expo[i] = 1.0 if on else 0.4
+    return pd.Series(expo * r, index=_idx)  # set below
+
+
+def legs_on_grid(wc=0.5):
+    """TP01(crypto, compoundato sul grid) e GTAA(equity) sulla stessa griglia giorni-di-borsa."""
+    tp = _tp01_returns()
+    if tp.index.tz is None:
+        tp.index = tp.index.tz_localize("UTC")
+    eq = gtaa_returns().dropna()
+    grid = eq.index[eq.index >= tp.index[0]]
+    cum = (1 + tp).cumprod()
+    tpg = cum.reindex(cum.index.union(grid)).ffill().reindex(grid).pct_change()
+    J = pd.concat({"c": tpg, "e": eq.reindex(grid)}, axis=1).dropna()
+    combo = wc * J["c"] + (1 - wc) * J["e"]
+    return combo, J["c"], J["e"]
+
+
+def sh(r): r = r.dropna().values; return float(np.mean(r) / np.std(r) * ANN) if len(r) > 5 and np.std(r) > 0 else 0.0
+def maxdd(curve): pk = np.maximum.accumulate(curve); return float(np.max((pk - curve) / pk)) if len(curve) else 0.0
+
+
+def yearly(ret, label):
+    ret = ret.dropna().sort_index()
+    print(f"\n  ===== {label} (guardia-DD -4%) =====")
+    print(f"  {'anno':6}{'NL inizio':>11}{'NL fine':>11}{'rend%':>9}{'DD%':>8}{'Sharpe':>9}")
+    eq = INITIAL
+    for y in sorted(set(ret.index.year)):
+        r = ret[ret.index.year == y]
+        if len(r) < 5: continue
+        eq0 = eq
+        curve = eq0 * np.cumprod(1 + r.values)
+        eq = float(curve[-1])
+        print(f"  {y:<6}{eq0:>11,.0f}{eq:>11,.0f}{(eq/eq0-1)*100:>+8.1f}%{maxdd(curve)*100:>7.1f}%{sh(r):>9.2f}")
+    yrs = (ret.index[-1] - ret.index[0]).days / 365.25
+    cagr = (eq / INITIAL) ** (1 / yrs) - 1 if yrs > 0 else 0
+    full_curve = INITIAL * np.cumprod(1 + ret.values)
+    print(f"  {'TOT':<6}{INITIAL:>11,.0f}{eq:>11,.0f}{(eq/INITIAL-1)*100:>+8.1f}%{maxdd(full_curve)*100:>7.1f}%{sh(ret):>9.2f}"
+          f"   |  CAGR {cagr*100:+.1f}%  ({yrs:.1f}y)")
+
+
+def main():
+    global _idx
+    print("=" * 78)
+    print("  RESOCONTO PROTETTO (soft-guard DD -4%) — da $2.000, anno per anno")
+    print("  Tutte e tre sulla griglia giorni-di-borsa del combo (dal 2019), esposizione 1x.")
+    print("=" * 78)
+    combo, tp, g = legs_on_grid()
+    for ret, lbl in [(combo, "COMBO TP01+GTAA 50/50"), (tp, "solo TP01 (crypto)"), (g, "solo GTAA (equity)")]:
+        _idx = ret.index
+        yearly(dd_guard(ret), lbl)
+    # confronto NON protetto (baseline) in coda, una riga TOT per riferimento
+    print("\n  --- riferimento NON protetto (baseline, TOT) ---")
+    for ret, lbl in [(combo, "COMBO"), (tp, "TP01"), (g, "GTAA")]:
+        yrs = (ret.index[-1] - ret.index[0]).days / 365.25
+        eqf = INITIAL * np.prod(1 + ret.values)
+        print(f"  {lbl:6} CAGR {((eqf/INITIAL)**(1/yrs)-1)*100:>+5.1f}%  DD {maxdd(INITIAL*np.cumprod(1+ret.values))*100:>4.1f}%  Sharpe {sh(ret):.2f}")
+
+
+if __name__ == "__main__":
+    main()
@@ -0,0 +1,99 @@
+"""Resoconto anno-per-anno della strategia combo (TP01+GTAA) + componenti, da $2.000.
+
+Per anno: PnL ($ e %), MaxDD (intra-anno), NumTrades, equity di fine anno (compounding da 2k).
+Combo = blend 50/50 TP01(Deribit) + GTAA(IB) (crypto compoundato su grid giorni-di-borsa).
+NumTrades: TP01 = cambi di target BTC/ETH (>0.05); GTAA = ribilanci MENSILI per-gamba (>2%).
+Onesto: il combo parte dal 2019 (crypto). GTAA-solo dato anche su 10y come contesto.
+"""
+import sys
+from pathlib import Path
+import numpy as np, pandas as pd
+
+ROOT = Path(__file__).resolve().parents[2]
+sys.path.insert(0, str(ROOT)); sys.path.insert(0, str(ROOT / "scripts" / "live"))
+from src.data.downloader import load_data
+from src.strategies.trend_portfolio import TrendPortfolio, CANONICAL, resample_1d
+from src.portfolio.sleeves import _tp01_returns
+from src.portfolio.gtaa import gtaa_returns, _exposure, _close, EQ_UNIVERSE
+INITIAL = 2000.0
+
+
+def tp01_trades_per_year():
+    tp = TrendPortfolio(**CANONICAL); cnt = {}
+    for a in ("BTC", "ETH"):
+        df = resample_1d(load_data(a, "1h")); tgt = tp.target_series(df)
+        idx = pd.DatetimeIndex(pd.to_datetime(df["datetime"]))
+        chg = pd.Series(np.abs(np.diff(tgt, prepend=tgt[0])) > 0.05, index=idx)
+        for y, c in chg.groupby(idx.year).sum().items():
+            cnt[int(y)] = cnt.get(int(y), 0) + int(c)
+    return cnt
+
+
+def gtaa_trades_per_year():
+    # pesi giornalieri -> ribilancio MENSILE realistico -> conta gambe cambiate >2%
+    W = {}
+    for a in EQ_UNIVERSE:
+        ex = _exposure(_close(a)) / len(EQ_UNIVERSE)
+        W[a] = ex
+    Wd = pd.concat(W, axis=1).dropna()
+    Wm = Wd.resample("ME").last()                       # peso a fine mese
+    chg = (Wm.diff().abs() > 0.02).sum(axis=1)          # gambe ribilanciate quel mese
+    return chg.groupby(chg.index.year).sum().astype(int).to_dict()
+
+
+def yearly(ret: pd.Series, trades: dict, label: str, start_capital=INITIAL):
+    ret = ret.dropna().sort_index()
+    print(f"\n  ===== {label} =====")
+    print(f"  {'anno':6}{'eq inizio':>12}{'PnL $':>12}{'PnL %':>9}{'MaxDD %':>9}{'NumTrades':>11}{'eq fine':>12}")
+    eq = start_capital
+    for y in sorted(set(ret.index.year)):
+        r = ret[ret.index.year == y]
+        if len(r) < 5:
+            continue
+        eq0 = eq
+        curve = eq0 * np.cumprod(1 + r.values)
+        peak = np.maximum.accumulate(curve)
+        dd = float(np.max((peak - curve) / peak)) if len(curve) else 0.0
+        eq = float(curve[-1])
+        pnl = eq - eq0
+        nt = trades.get(y, None)
+        print(f"  {y:<6}{eq0:>12,.0f}{pnl:>+12,.0f}{(eq/eq0-1)*100:>+8.1f}%{dd*100:>8.1f}%"
+              f"{(str(nt) if nt is not None else '—'):>11}{eq:>12,.0f}")
+    tot = eq / start_capital - 1
+    yrs = (ret.index[-1] - ret.index[0]).days / 365.25
+    cagr = (eq / start_capital) ** (1 / yrs) - 1 if yrs > 0 else 0
+    sh = float(r.mean()) if False else float(ret.mean() / ret.std() * np.sqrt(252))
+    print(f"  {'TOT':<6}{start_capital:>12,.0f}{eq-start_capital:>+12,.0f}{tot*100:>+8.1f}%"
+          f"{'':>9}{sum(v for v in trades.values()) if trades else 0:>11}{eq:>12,.0f}")
+    print(f"  -> da ${start_capital:,.0f} a ${eq:,.0f} in {yrs:.1f}y | CAGR {cagr*100:+.1f}% | Sharpe {sh:.2f}")
+
+
+def combo_daily(wc=0.5):
+    tp = _tp01_returns()
+    if tp.index.tz is None:
+        tp.index = tp.index.tz_localize("UTC")
+    eq = gtaa_returns().dropna()
+    grid = eq.index[eq.index >= tp.index[0]]
+    cum = (1 + tp).cumprod()
+    tpg = (cum.reindex(cum.index.union(grid)).ffill().reindex(grid)).pct_change()
+    J = pd.concat({"c": tpg, "e": eq.reindex(grid)}, axis=1).dropna()
+    return (wc * J["c"] + (1 - wc) * J["e"]).dropna()
+
+
+def main():
+    print("=" * 80)
+    print("  RESOCONTO STRATEGIA — da $2.000, anno per anno")
+    print("=" * 80)
+    tpt = tp01_trades_per_year(); gtt = gtaa_trades_per_year()
+    combo_tr = {y: tpt.get(y, 0) + gtt.get(y, 0) for y in set(tpt) | set(gtt)}
+    # COMBO (la strategia deployata)
+    yearly(combo_daily(), combo_tr, "COMBO TP01+GTAA 50/50 (deployabile, dal 2019)")
+    # componenti
+    tp = _tp01_returns(); tp.index = tp.index.tz_localize("UTC") if tp.index.tz is None else tp.index
+    yearly(tp, tpt, "solo TP01 (crypto, Deribit)")
+    g = gtaa_returns(); g10 = g[g.index >= (g.index[-1] - pd.Timedelta(days=3660))]
+    yearly(g10, gtt, "solo GTAA (equity, IB) — ULTIMI 10 ANNI")
+
+
+if __name__ == "__main__":
+    main()
@@ -0,0 +1,126 @@
+"""HARNESS parametrizzato — anticipazione crypto -> mercato (lead-lag eseguibile, onesto).
+
+Generalizza l'effetto weekend: la finestra-LEAD e' l'intervallo in cui l'equity e' CHIUSO e la crypto
+no (prev close 21:00 UTC -> next open 13:30 UTC). Il weekend e' il caso lungo (Ven 21:00 -> Lun 13:30).
+Per ogni sessione equity D (con sessione precedente P):
+  lead = crypto return su [lead_start, D 13:00]   (lead_start = P 21:00 se hours='overnight', else D13:00-hours)
+  predict target: gap = open[D]/close[P]-1 ; intraday = close[D]/open[D]-1 ; full = close[D]/close[P]-1
+  control = rendimento sessione precedente equity (close[P]/close[P_prev]-1)  -> test INCREMENTALE
+Filtro giorni: all | mon (solo lunedi'/weekend) | nonmon.
+
+Output JSON per config: n, corr, beta+t-stat del lead AL NETTO del control (incrementale), Sharpe
+settimanale/annualizzato del trade eseguibile (sign(lead)*predict - costo) FULL/IS/OOS(2022+),
+hit-rate, e PER-ANNO (hit e mean) per la robustezza multi-anno.
+
+  uv run python scripts/research/crypto_lead_harness.py --configs '[{"lead":"BTC","target":"QQQ","day":"mon","predict":"intraday","hours":"overnight"}]'
+Dati: cache su disco (crypto 1h, ETF eq_*). Nessun IB online. Vettoriale, veloce.
+"""
+import sys, json, argparse
+from pathlib import Path
+import numpy as np, pandas as pd
+
+ROOT = Path(__file__).resolve().parents[2]
+sys.path.insert(0, str(ROOT)); sys.path.insert(0, str(ROOT / "scripts" / "research"))
+from src.data.downloader import load_data
+import eqlib
+
+OOS_DEFAULT = "2022-01-01"
+OPEN_H = 13   # ~apertura US 13:30 UTC -> uso barra 13:00 (info nota prima dell'open per il lead)
+CLOSE_H = 21  # ~chiusura US 21:00 UTC
+
+_CRYPTO = {}
+def crypto_hourly(asset):
+    if asset not in _CRYPTO:
+        s = load_data(asset, "1h").set_index("datetime")["close"].astype(float)
+        full = pd.date_range(s.index[0].floor("h"), s.index[-1].ceil("h"), freq="h", tz="UTC")
+        _CRYPTO[asset] = s.reindex(s.index.union(full)).ffill().reindex(full)
+    return _CRYPTO[asset]
+
+
+def at(series, ts):
+    try:
+        return float(series.asof(ts))
+    except Exception:
+        return np.nan
+
+
+def evaluate(cfg, cost_rt=0.0004, oos=OOS_DEFAULT):
+    OOS = pd.Timestamp(oos, tz="UTC")
+    lead = cfg["lead"]; tgt = cfg["target"]; day = cfg.get("day", "all")
+    predict = cfg.get("predict", "intraday"); hours = cfg.get("hours", "overnight")
+    bc = crypto_hourly(lead)
+    try:
+        oc = eqlib.load_eq(tgt)["open"].astype(float); cc = eqlib.load_eq(tgt)["close"].astype(float)
+    except Exception as e:
+        return {**cfg, "err": f"no data {tgt}"}
+    idx = cc.index
+    rows = []
+    for j in range(2, len(idx)):
+        D = idx[j]; P = idx[j-1]; Pp = idx[j-2]
+        if day == "mon" and D.weekday() != 0: continue
+        if day == "nonmon" and D.weekday() == 0: continue
+        d_open = D.normalize() + pd.Timedelta(hours=OPEN_H)
+        p_close = P.normalize() + pd.Timedelta(hours=CLOSE_H)
+        lead_start = p_close if hours == "overnight" else d_open - pd.Timedelta(hours=int(hours))
+        c1 = at(bc, d_open); c0 = at(bc, lead_start)
+        if not (np.isfinite(c1) and np.isfinite(c0) and c0 > 0): continue
+        ld = c1 / c0 - 1.0
+        gap = oc[D] / cc[P] - 1.0
+        intr = cc[D] / oc[D] - 1.0
+        full = cc[D] / cc[P] - 1.0
+        ctrl = cc[P] / cc[Pp] - 1.0
+        rows.append((D, ld, gap, intr, full, ctrl))
+    if len(rows) < 60:
+        return {**cfg, "err": f"n={len(rows)}"}
+    D_ = pd.DataFrame(rows, columns=["d", "lead", "gap", "intraday", "full", "ctrl"]).set_index("d")
+    y = D_[predict].values; x = D_["lead"].values; ctrl = D_["ctrl"].values
+
+    def z(a):
+        sd = a.std(); return (a - a.mean()) / sd if sd > 0 else a * 0
+    corr = float(np.corrcoef(x, y)[0, 1])
+    # incrementale vs control (OLS standardizzato)
+    X = np.column_stack([np.ones(len(y)), z(x), z(ctrl)])
+    beta, *_ = np.linalg.lstsq(X, z(y), rcond=None)
+    resid = z(y) - X @ beta
+    dof = max(len(y) - 3, 1)
+    se = np.sqrt(np.sum(resid**2) / dof * np.diag(np.linalg.inv(X.T @ X)))
+    t_inc = float(beta[1] / se[1]) if se[1] > 0 else 0.0
+    # trade eseguibile: long-short e long-flat su segno del lead, intraday/predict, net costi
+    sign = np.sign(x)
+    def sharpe(r):
+        r = r[np.isfinite(r)]
+        return float(np.mean(r) / np.std(r) * np.sqrt(52)) if len(r) > 5 and np.std(r) > 0 else 0.0
+    ls = sign * y - cost_rt
+    lf = np.where(x > 0, y, 0.0) - np.where(x > 0, cost_rt, 0.0)
+    yrs = D_.index.year.values
+    def per_year(r):
+        out = {}
+        for yv in sorted(set(yrs)):
+            m = yrs == yv
+            if m.sum() >= 8:
+                out[int(yv)] = round(float(np.mean(np.sign(x[m]) == np.sign(y[m]))), 2)
+        return out
+    is_m = D_.index < OOS; oos_m = D_.index >= OOS
+    py = per_year(ls)
+    return {**cfg, "n": len(D_), "corr": round(corr, 3), "t_incremental": round(t_inc, 2),
+            "hit": round(float(np.mean(sign == np.sign(y))), 3),
+            "sh_ls_full": round(sharpe(ls), 2), "sh_ls_is": round(sharpe(ls[is_m]), 2),
+            "sh_ls_oos": round(sharpe(ls[oos_m]), 2),
+            "sh_lf_full": round(sharpe(lf), 2), "sh_lf_oos": round(sharpe(lf[oos_m]), 2),
+            "ann_ls_pct": round(float(np.nanmean(ls) * 52 * 100), 1),
+            "years_pos": int(sum(1 for v in py.values() if v > 0.5)), "years_tot": len(py),
+            "per_year_hit": py}
+
+
+def main():
+    ap = argparse.ArgumentParser()
+    ap.add_argument("--configs", required=True)
+    ap.add_argument("--cost", type=float, default=0.0004)
+    ap.add_argument("--oos", default=OOS_DEFAULT)
+    args = ap.parse_args()
+    cfgs = json.loads(args.configs)
+    print(json.dumps([evaluate(c, cost_rt=args.cost, oos=args.oos) for c in cfgs]))
+
+
+if __name__ == "__main__":
+    main()
@@ -0,0 +1,120 @@
+"""CRYPTO x MERCATI IB — correlazioni e ANTICIPAZIONI (lead-lag).
+
+Obiettivo: la crypto (24/7) anticipa i mercati IB (azioni/bond/oro/credito), o viceversa?
+Disciplina onesta: i tranelli di timing daily sono enormi (crypto chiude 00:00 UTC, US equity 21:00
+UTC -> il lag-0 e' contaminato), quindi (1) allineo i rendimenti sullo STESSO intervallo
+(compounding crypto sul grid giorni-di-borsa), (2) guardo i lag >=1 giorno, (3) test del segno con
+hit-rate e split in-sample/OOS, (4) flag multiple-testing.
+
+Ipotesi piu' pulita = EFFETTO WEEKEND: la crypto si muove Sab+Dom (azionario chiuso) -> quel
+movimento e' informazione PRIOR al lunedi'. Predice il gap/intraday del lunedi' azionario?
+Uso gli OPEN dei parquet eq_ (Monday open noto alle 13:30 UTC, weekend crypto noto alle 00:00 UTC).
+
+DATI: cache su disco (BTC/ETH Deribit 1h->1d UTC; ETF IB eq_*). Nessun IB online.
+"""
+import sys
+from pathlib import Path
+import numpy as np, pandas as pd
+
+ROOT = Path(__file__).resolve().parents[2]
+sys.path.insert(0, str(ROOT)); sys.path.insert(0, str(ROOT / "scripts" / "research"))
+from src.data.downloader import load_data
+import eqlib
+
+ETFS = ["SPY", "QQQ", "IWM", "TLT", "GLD", "HYG"]
+
+
+def crypto_daily_close(asset="BTC") -> pd.Series:
+    df = load_data(asset, "1h").set_index("datetime")["close"].astype(float)
+    return df.resample("1D").last().dropna()   # close ~00:00 UTC del giorno dopo
+
+
+def _ret(s):
+    return s.pct_change()
+
+
+def _corr_lags(x: pd.Series, y: pd.Series, lags=range(-5, 6)):
+    """corr(x_{t-k}, y_t): k>0 => x ANTICIPA y di k giorni. Allineati sullo stesso grid."""
+    J = pd.concat({"x": x, "y": y}, axis=1, join="inner").dropna()
+    out = {}
+    for k in lags:
+        out[k] = round(float(J["x"].shift(k).corr(J["y"])), 3)
+    return out
+
+
+def main():
+    print("=" * 98)
+    print("  CRYPTO x MERCATI IB — correlazioni & anticipazioni (lead-lag)")
+    print("=" * 98)
+    btc = crypto_daily_close("BTC"); eth = crypto_daily_close("ETH")
+    btc_r = _ret(btc); eth_r = _ret(eth)
+    # equity close + grid giorni-di-borsa
+    eq_close = {s: eqlib.load_eq(s)["close"].astype(float) for s in ETFS}
+    eq_open = {s: eqlib.load_eq(s)["open"].astype(float) for s in ETFS}
+    grid = eq_close["SPY"].index
+    grid = grid[grid >= btc.index[0]]
+    # crypto compoundato sul grid giorni-di-borsa (stesso intervallo dell'equity ret)
+    def to_grid(s):
+        cum = (1 + _ret(s)).cumprod()
+        return (cum.reindex(cum.index.union(grid)).ffill().reindex(grid)).pct_change()
+    btc_g = to_grid(btc); eth_g = to_grid(eth)
+
+    print(f"  overlap dal {grid[0].date()} ({len(grid)} giorni di borsa)\n")
+
+    print("  --- (1) CORRELAZIONE CONTEMPORANEA (stesso intervallo; lag0 contaminato da timing) ---")
+    print(f"    {'ETF':5} {'corr BTC':>9} {'corr ETH':>9}")
+    for s in ETFS:
+        er = _ret(eq_close[s]).reindex(grid)
+        cb = round(float(pd.concat([btc_g, er], axis=1).dropna().corr().iloc[0, 1]), 3)
+        ce = round(float(pd.concat([eth_g, er], axis=1).dropna().corr().iloc[0, 1]), 3)
+        print(f"    {s:5} {cb:>9} {ce:>9}")
+
+    print("\n  --- (2) LEAD-LAG BTC vs ETF: corr(BTC_{t-k}, ETF_t), k>0 = BTC ANTICIPA ---")
+    print(f"    {'ETF':5} " + " ".join(f"k{ k:+d}" for k in range(-3, 4)) + "   picco")
+    for s in ETFS:
+        er = _ret(eq_close[s]).reindex(grid)
+        cl = _corr_lags(btc_g, er, range(-3, 4))
+        peak = max(cl, key=lambda k: abs(cl[k]))
+        row = " ".join(f"{cl[k]:+.2f}" for k in range(-3, 4))
+        tag = f"k={peak:+d} ({'BTC->ETF' if peak>0 else 'ETF->BTC' if peak<0 else 'contemp'})"
+        print(f"    {s:5} {row}   {tag}")
+
+    print("\n  --- (3) EFFETTO WEEKEND: crypto Sab+Dom -> lunedi' azionario (anticipazione pulita) ---")
+    # weekend crypto = close(Dom 00:00 lun) / close(Ven) - 1 ; calcolato su crypto daily (calendario)
+    cal = pd.date_range(btc.index[0], btc.index[-1], freq="D", tz="UTC")
+    bc = btc.reindex(cal).ffill()
+    for s in ["SPY", "QQQ", "IWM", "HYG"]:
+        oc = eq_open[s]; cc = eq_close[s]
+        rows = []
+        for mon in grid:
+            if mon.weekday() != 0:      # solo lunedi'
+                continue
+            fri = mon - pd.Timedelta(days=3)
+            if fri not in cc.index:      # venerdi' non di borsa (festa) -> salta
+                continue
+            wk = float(bc.get(mon, np.nan) / bc.get(fri + pd.Timedelta(days=0), np.nan) - 1) if fri in bc.index else np.nan
+            # weekend crypto: da venerdi 00:00(close ven) a lunedi 00:00 -> usa bc[fri]..bc[mon]
+            wk = float(bc.loc[mon] / bc.loc[fri] - 1) if (mon in bc.index and fri in bc.index) else np.nan
+            gap = float(oc.loc[mon] / cc.loc[fri] - 1) if (mon in oc.index and fri in cc.index) else np.nan
+            intr = float(cc.loc[mon] / oc.loc[mon] - 1) if mon in oc.index else np.nan
+            rows.append((mon, wk, gap, intr))
+        D = pd.DataFrame(rows, columns=["mon", "wk", "gap", "intr"]).dropna().set_index("mon")
+        if len(D) < 50:
+            print(f"    {s}: pochi dati ({len(D)})"); continue
+        def stat(col):
+            c = float(D["wk"].corr(D[col]))
+            hit = float((np.sign(D["wk"]) == np.sign(D[col])).mean())
+            return c, hit
+        cg, hg = stat("gap"); ci, hi = stat("intr")
+        # OOS: split 2022
+        Dh = D[D.index >= pd.Timestamp("2022-01-01", tz="UTC")]
+        cg_o = float(Dh["wk"].corr(Dh["gap"])); ci_o = float(Dh["wk"].corr(Dh["intr"]))
+        print(f"    {s}: n={len(D)} | weekend-crypto -> Mon GAP corr {cg:+.2f} hit {hg*100:.0f}% (OOS22+ {cg_o:+.2f}) "
+              f"| Mon INTRADAY corr {ci:+.2f} hit {hi*100:.0f}% (OOS {ci_o:+.2f})")
+
+    print("\n  NB: lag-0/contemporanea contaminata dal timing (crypto chiude 00:00, equity 21:00 UTC).")
+    print("      Il GAP del lunedi' e' il test pulito (weekend crypto = info prior all'apertura).")
+
+
+if __name__ == "__main__":
+    main()
@@ -0,0 +1,88 @@
+"""DERIBIT-monitor -> IB-trade: il segnale crypto overnight AGGIUNGE al long-overnight indice?
+
+Idea utente: guardare crypto live su Deribit (24/7) e tradare l'indice su IB. Il GAP di apertura =
+movimento OVERNIGHT dei futures (MES/MNQ/M2K, tradati di notte) -> catturabile, net ~2bps.
+
+DOMANDA DECISIVA (test onesto): l'azionario ha gia' un OVERNIGHT PREMIUM noto (il drift positivo
+notturno). Quindi "long indice overnight" rende di suo. Il segnale crypto MIGLIORA quel baseline,
+o e' solo overnight-premium + beta? Confronto:
+  A) ALWAYS-LONG overnight (incondizionato) = cattura il premio notturno puro
+  B) LONG se crypto-overnight>0, else FLAT = usa il crypto come filtro
+  C) LONG/SHORT sul segno del crypto = il segnale pieno
+La metrica chiave e' B,C VS A (l'uplift del crypto sul puro premio notturno), non A in assoluto.
+
+Dati: cache su disco (crypto 1h Deribit; ETF eq_* = proxy del future indice). net 2bps RT (futures).
+"""
+import sys
+from pathlib import Path
+import numpy as np, pandas as pd
+
+ROOT = Path(__file__).resolve().parents[2]
+sys.path.insert(0, str(ROOT)); sys.path.insert(0, str(ROOT / "scripts" / "research"))
+import eqlib
+from crypto_lead_harness import crypto_hourly, at, OPEN_H, CLOSE_H
+
+OOS = pd.Timestamp("2022-01-01", tz="UTC")
+COST = 0.0002   # ~2bps RT micro-future (commissione + spread)
+
+
+def _sh(r):
+    r = np.asarray(r, float); r = r[np.isfinite(r)]
+    return float(np.mean(r) / np.std(r) * np.sqrt(252)) if len(r) > 5 and np.std(r) > 0 else 0.0
+
+
+def build(target="SPY", lead="BTC"):
+    bc = crypto_hourly(lead)
+    oc = eqlib.load_eq(target)["open"].astype(float); cc = eqlib.load_eq(target)["close"].astype(float)
+    idx = cc.index; rows = []
+    for j in range(1, len(idx)):
+        D = idx[j]; P = idx[j-1]
+        d_open = D.normalize() + pd.Timedelta(hours=OPEN_H)
+        p_close = P.normalize() + pd.Timedelta(hours=CLOSE_H)
+        c1 = at(bc, d_open); c0 = at(bc, p_close)
+        if not (np.isfinite(c1) and np.isfinite(c0) and c0 > 0):
+            continue
+        crypto = c1 / c0 - 1.0
+        overnight = oc[D] / cc[P] - 1.0       # gap = ritorno overnight del future indice (catturabile)
+        rows.append((D, crypto, overnight))
+    return pd.DataFrame(rows, columns=["d", "crypto", "on"]).set_index("d")
+
+
+def main():
+    print("=" * 92)
+    print("  CRYPTO overnight -> LONG INDICE OVERNIGHT (Deribit-monitor / IB-trade): aggiunge al premio?")
+    print("=" * 92)
+    print(f"  net {COST*1e4:.0f}bps RT (micro-future). overnight = open[D]/close[P]-1 (= move notturno future).\n")
+    for tgt in ("SPY", "QQQ", "IWM"):
+        for lead in ("BTC", "ETH"):
+            D = build(tgt, lead)
+            up = D[D["crypto"] > 0]["on"]; dn = D[D["crypto"] <= 0]["on"]
+            # strategie
+            A = D["on"].values - COST                                   # always-long
+            B = np.where(D["crypto"] > 0, D["on"], 0.0) - np.where(D["crypto"] > 0, COST, 0.0)  # long se crypto su
+            C = np.sign(D["crypto"]) * D["on"] - COST                   # long/short
+            shA, shB, shC = _sh(A), _sh(B), _sh(C)
+            # OOS
+            m = D.index >= OOS
+            print(f"  {tgt} <- {lead}: n={len(D)} | notti crypto-SU {len(up)} ret medio {up.mean()*1e4:+.1f}bps "
+                  f"| crypto-GIU {len(dn)} ret medio {dn.mean()*1e4:+.1f}bps  (spread {(up.mean()-dn.mean())*1e4:+.1f}bps)")
+            print(f"        Sharpe: A always-long {shA:.2f} | B long-if-cryptoUp {shB:.2f} | C long/short {shC:.2f}  "
+                  f"-> UPLIFT crypto B-A {shB-shA:+.2f}, C-A {shC-shA:+.2f}")
+            print(f"        OOS22+: A {_sh(A[m]):.2f} | B {_sh(B[m]):.2f} | C {_sh(C[m]):.2f} | "
+                  f"ann: A {np.nanmean(A)*252*100:+.1f}% B {np.nanmean(B)*252*100:+.1f}% C {np.nanmean(C)*252*100:+.1f}%")
+        print()
+
+    # focus SPY-BTC: per-anno A vs C, e sketch deploy
+    D = build("SPY", "BTC")
+    A = D["on"].values - COST; C = np.sign(D["crypto"]) * D["on"] - COST
+    print("  --- SPY<-BTC per-anno: Sharpe A(always-long) vs C(crypto long/short) ---")
+    for y in sorted(set(D.index.year)):
+        mm = D.index.year == y
+        if mm.sum() >= 40:
+            print(f"    {y}: A {_sh(A[mm]):+.2f}  C {_sh(C[mm]):+.2f}  (n={mm.sum()})")
+    print("\n  NB: se C-A ~ 0, il crypto NON aggiunge al premio overnight (e' solo il premio + beta).")
+    print("      Se C-A >> 0 e A gia' alto, il crypto e' un filtro REALE sul rischio notturno.")
+
+
+if __name__ == "__main__":
+    main()
@@ -0,0 +1,71 @@
+"""ONESTA' DI TIMING: il 'Sharpe 5' del crypto->overnight equity e' look-ahead?
+
+Test: separare la versione OVERLAP (segnale e ritorno coprono le stesse ore = look-ahead) dalla
+versione TRADABILE (segnale finisce all'ENTRATA, catturo solo il moto SUCCESSIVO).
+  segnale crypto = BTC [P 21:00 -> D 13:00 UTC]  (noto solo a D 13:00, poco prima dell'open 13:30)
+  - OVERLAP   capture = gap   = open[D]/close[P]-1   [P 21:00 -> D 13:30]  <-- sovrappone il segnale
+  - TRADABILE capture = intra = close[D]/open[D]-1   [D 13:30 -> D 21:00]  <-- DOPO l'entrata, pulito
+Se OVERLAP >> TRADABILE, il numero alto e' artefatto: all'open il gap e' gia' avvenuto, non lo catturi.
+Annualizzazione CORRETTA sqrt(252) (giornaliero), non sqrt(52).
+"""
+import sys
+from pathlib import Path
+import numpy as np, pandas as pd
+
+ROOT = Path(__file__).resolve().parents[2]
+sys.path.insert(0, str(ROOT)); sys.path.insert(0, str(ROOT / "scripts" / "research"))
+import eqlib
+from crypto_lead_harness import crypto_hourly, at, OPEN_H, CLOSE_H
+
+OOS = pd.Timestamp("2022-01-01", tz="UTC"); COST = 0.0002
+
+
+def _sh(r):
+    r = np.asarray(r, float); r = r[np.isfinite(r)]
+    return float(np.mean(r) / np.std(r) * np.sqrt(252)) if len(r) > 5 and np.std(r) > 0 else 0.0
+
+
+def build(target="SPY", lead="BTC"):
+    bc = crypto_hourly(lead)
+    oc = eqlib.load_eq(target)["open"].astype(float); cc = eqlib.load_eq(target)["close"].astype(float)
+    idx = cc.index; rows = []
+    for j in range(1, len(idx)):
+        D = idx[j]; P = idx[j-1]
+        c1 = at(bc, D.normalize() + pd.Timedelta(hours=OPEN_H))      # crypto a D 13:00 (entrata)
+        c0 = at(bc, P.normalize() + pd.Timedelta(hours=CLOSE_H))     # crypto a P 21:00
+        if not (np.isfinite(c1) and np.isfinite(c0) and c0 > 0):
+            continue
+        crypto = c1 / c0 - 1.0
+        gap = oc[D] / cc[P] - 1.0          # OVERLAP col segnale
+        intra = cc[D] / oc[D] - 1.0        # DOPO l'entrata (tradabile)
+        rows.append((D, crypto, gap, intra))
+    return pd.DataFrame(rows, columns=["d", "crypto", "gap", "intra"]).set_index("d")
+
+
+def main():
+    print("=" * 90)
+    print("  TIMING ONESTO: OVERLAP (look-ahead) vs TRADABILE — crypto overnight -> equity")
+    print("=" * 90)
+    print("  segnale noto a D13:00. OVERLAP=gap [copre il segnale]. TRADABILE=intraday [dopo entrata]. net 2bps, sqrt(252)\n")
+    for tgt in ("SPY", "QQQ", "IWM"):
+        D = build(tgt, "BTC")
+        for name, col in (("OVERLAP gap (look-ahead)", "gap"), ("TRADABILE intraday", "intra")):
+            C = np.sign(D["crypto"]) * D[col] - COST
+            m = D.index >= OOS
+            print(f"  {tgt} {name:26}: Sharpe long/short {_sh(C):.2f}  (OOS {_sh(C[m]):.2f})  ann {np.nanmean(C)*252*100:+.1f}%")
+        print()
+    print("  --- VERDETTO ---")
+    D = build("QQQ", "BTC")
+    cg = _sh(np.sign(D["crypto"]) * D["gap"] - COST)
+    ci = _sh(np.sign(D["crypto"]) * D["intra"] - COST)
+    print(f"  QQQ: gap(overlap) Sharpe {cg:.2f}  vs  intraday(tradabile) Sharpe {ci:.2f}")
+    print(f"  -> il moto che il crypto 'predice' avviene NELLA finestra del segnale (overnight), non dopo.")
+    print(f"     All'entrata (D13:00, pre-open) il gap e' gia' realizzato -> NON catturabile con l'ETF.")
+    print(f"     Cio' che resta da catturare (intraday) ha Sharpe ~{ci:.1f}: l'edge tradabile e' quello.")
+    print(f"  Per catturare PARTE dell'overnight servirebbe entrare a META' notte via FUTURES IB e")
+    print(f"  testare se il crypto [P21:00->T] predice il future [T->open] (finestre NON sovrapposte):")
+    print(f"  richiede dati intraday dei futures indice (ES/NQ), che NON abbiamo in cache -> data step.")
+
+
+if __name__ == "__main__":
+    main()
@@ -0,0 +1,97 @@
+"""WEEKEND CRYPTO -> LUNEDI' AZIONARIO — validazione avversariale dell'anticipazione.
+
+L'analisi lead-lag ha trovato UNA anticipazione pulita: il movimento crypto del weekend (Sab+Dom,
+azionario chiuso) anticipa il lunedi' azionario (gap corr ~0.24, OOS piu' forte). Prima di crederci,
+due test scettici:
+  (A) INCREMENTALE: aggiunge info OLTRE il rendimento del VENERDI'? (o e' solo momentum equity?)
+      regressione  Mon ~ weekend_crypto + friday_equity ; il coeff del crypto resta significativo?
+  (B) TRADABILE: segnale eseguibile = osservo weekend crypto (noto Dom 24:00 UTC), entro al Monday
+      OPEN, esco al Monday CLOSE. Net di costi (4 bps RT ETF). Sharpe/hit/OOS vs sempre-long lunedi'.
+
+DATI: cache su disco (BTC Deribit 1h->1d; ETF eq_* con OPEN). Nessun IB online.
+"""
+import sys
+from pathlib import Path
+import numpy as np, pandas as pd
+
+ROOT = Path(__file__).resolve().parents[2]
+sys.path.insert(0, str(ROOT)); sys.path.insert(0, str(ROOT / "scripts" / "research"))
+from src.data.downloader import load_data
+import eqlib
+
+OOS = pd.Timestamp("2022-01-01", tz="UTC")
+COST_RT = 0.0004   # 4 bps round-trip ETF (entry open + exit close)
+
+
+def _sh_weekly(r):
+    r = np.asarray(pd.Series(r).dropna(), float)
+    return float(np.mean(r) / np.std(r) * np.sqrt(52)) if len(r) > 2 and np.std(r) > 0 else 0.0
+
+
+def build(asset_etf="QQQ"):
+    btc = load_data("BTC", "1h").set_index("datetime")["close"].astype(float).resample("1D").last()
+    cal = pd.date_range(btc.index[0], btc.index[-1], freq="D", tz="UTC")
+    bc = btc.reindex(cal).ffill()
+    oc = eqlib.load_eq(asset_etf)["open"].astype(float)
+    cc = eqlib.load_eq(asset_etf)["close"].astype(float)
+    rows = []
+    for mon in cc.index:
+        if mon.weekday() != 0:
+            continue
+        fri = mon - pd.Timedelta(days=3)
+        thu = mon - pd.Timedelta(days=4)
+        if fri not in cc.index or fri not in bc.index or mon not in bc.index:
+            continue
+        wk = bc.loc[mon] / bc.loc[fri] - 1.0                        # weekend crypto (Ven 00:00 -> Lun 00:00)
+        fri_eq = (cc.loc[fri] / cc.loc[thu] - 1.0) if thu in cc.index else np.nan  # rendimento venerdi'
+        gap = oc.loc[mon] / cc.loc[fri] - 1.0
+        intr = cc.loc[mon] / oc.loc[mon] - 1.0                      # tradabile: open->close lunedi'
+        rows.append((mon, wk, fri_eq, gap, intr))
+    return pd.DataFrame(rows, columns=["mon", "wk", "fri_eq", "gap", "intr"]).dropna().set_index("mon")
+
+
+def main():
+    print("=" * 92)
+    print("  WEEKEND CRYPTO -> LUNEDI' AZIONARIO — validazione avversariale")
+    print("=" * 92)
+    for etf in ("QQQ", "SPY", "IWM"):
+        D = build(etf)
+        print(f"\n  ===== {etf}  (n={len(D)} lunedi', {D.index[0].date()}..{D.index[-1].date()}) =====")
+
+        # (A) INCREMENTALE vs venerdi' — regressione OLS standardizzata, t-stat su weekend_crypto
+        for tgt in ("gap", "intr"):
+            y = (D[tgt] - D[tgt].mean()) / D[tgt].std()
+            x1 = (D["wk"] - D["wk"].mean()) / D["wk"].std()
+            x2 = (D["fri_eq"] - D["fri_eq"].mean()) / D["fri_eq"].std()
+            X = np.column_stack([np.ones(len(D)), x1.values, x2.values])
+            beta, *_ = np.linalg.lstsq(X, y.values, rcond=None)
+            resid = y.values - X @ beta
+            se = np.sqrt(np.sum(resid**2) / (len(D) - 3) * np.diag(np.linalg.inv(X.T @ X)))
+            t_wk = beta[1] / se[1]; t_fri = beta[2] / se[2]
+            partial = float(pd.Series(resid).corr(x1))  # ~ contributo crypto al netto del resto
+            print(f"    [{tgt:4}] beta_weekendCrypto {beta[1]:+.3f} (t={t_wk:+.1f})  | "
+                  f"beta_fridayEq {beta[2]:+.3f} (t={t_fri:+.1f})  -> crypto {'INCREMENTALE' if abs(t_wk)>2 else 'non signif.'}")
+
+        # (B) TRADABILE: long lunedi' intraday se weekend crypto > 0, short se < 0 (net costi)
+        sig = np.sign(D["wk"].values)
+        gross = sig * D["intr"].values
+        net = gross - COST_RT
+        D2 = D.assign(net=net)
+        full = D2["net"]; oos = D2[D2.index >= OOS]["net"]; ins = D2[D2.index < OOS]["net"]
+        bh = D["intr"]  # baseline: sempre-long lunedi' intraday
+        hit = float((np.sign(gross) > 0).mean()) if False else float((sig == np.sign(D["intr"].values)).mean())
+        print(f"    TRADE (long/short Mon intraday su segno weekend-crypto, net {COST_RT*1e4:.0f}bps):")
+        print(f"      hit-rate segno {hit*100:.0f}% | Sharpe(sett.) FULL {_sh_weekly(full):.2f}  IS {_sh_weekly(ins):.2f}  OOS22+ {_sh_weekly(oos):.2f}")
+        print(f"      ritorno medio/lun {full.mean()*1e4:+.1f}bps (net) | baseline sempre-long {bh.mean()*1e4:+.1f}bps | "
+              f"ann.~{full.mean()*52*100:+.1f}%")
+        # long-flat (piu' realistico: long se crypto su, altrimenti cash)
+        lf = np.where(D["wk"].values > 0, D["intr"].values, 0.0) - np.where(D["wk"].values > 0, COST_RT, 0.0)
+        lfs = pd.Series(lf, index=D.index)
+        print(f"      variante LONG-FLAT (long se crypto su, else cash): Sharpe FULL {_sh_weekly(lfs):.2f}  "
+              f"OOS {_sh_weekly(lfs[lfs.index>=OOS]):.2f}  ann.~{lfs.mean()*52*100:+.1f}%")
+
+    print("\n  NB: ~52 lunedi'/anno -> Sharpe settimanale; OOS = 2022+. Multiple-testing: 3 ETF x 2 target.")
+
+
+if __name__ == "__main__":
+    main()
@@ -0,0 +1,84 @@
+"""CROSS-MARKET COMBO — la sleeve equity-trend DIVERSIFICA il portafoglio crypto?
+
+(2) dopo EQ-GTAA01. La via che alza il Sharpe COMPLESSIVO senza cercare nuovo alpha: combinare due
+book scorrelati su mercati diversi. crypto = portafoglio attivo TP01+XS01+VRP01 (src.portfolio);
+equity = GTAA lf vt12% (la migliore sleeve equity, corr SPY 0.64, maxDD ~15%). Se la correlazione
+crypto<->equity e' bassa, il blend ha Sharpe > di ciascuno.
+
+ALLINEAMENTO ONESTO: crypto e' calendario-giornaliero (7gg), equity giorni di borsa. Compoundo i
+rendimenti crypto sul grid dei giorni di borsa (cattura i weekend) prima di combinare. Finestra =
+era crypto (TP01 dal 2019). Esecuzione split Deribit+IB (lo noto: e' un portafoglio cross-venue).
+"""
+import sys
+from pathlib import Path
+import numpy as np, pandas as pd
+
+ROOT = Path(__file__).resolve().parents[2]
+sys.path.insert(0, str(ROOT)); sys.path.insert(0, str(ROOT / "scripts" / "research"))
+from eq_sector_momentum import _sh, _cagr, _dd
+from eq_gtaa_trend import gtaa
+from eq_spy_trend import tsmom_exposure, backtest, _series
+from src.portfolio.sleeves import active_sleeves
+from src.portfolio.portfolio import StrategyPortfolio
+
+ANN = np.sqrt(252.0)
+
+
+def _ann_vol(r):
+    return float(np.std(np.asarray(r, float)) * ANN)
+
+
+def compound_to_grid(daily: pd.Series, grid: pd.DatetimeIndex) -> pd.Series:
+    """Compounda una serie di rendimenti (calendario) sul grid dato (giorni di borsa): per ogni data
+    del grid, somma-composta i rendimenti dal punto precedente."""
+    cum = (1.0 + daily).cumprod()
+    cum = cum.reindex(cum.index.union(grid)).ffill().reindex(grid)
+    return (cum / cum.shift(1) - 1.0).dropna()
+
+
+def main():
+    print("=" * 96)
+    print("  CROSS-MARKET COMBO — equity-trend (GTAA) x crypto (TP01+XS01+VRP01)")
+    print("=" * 96)
+    # crypto blend (rinormalizzato, date diverse)
+    crypto = StrategyPortfolio(active_sleeves()).combined_daily()
+    if crypto.index.tz is None:
+        crypto.index = crypto.index.tz_localize("UTC")
+    # equity sleeve (giorni di borsa)
+    eq = gtaa(target_vol=0.12).dropna()
+    # allinea: compounda crypto sui giorni di borsa dell'equity
+    grid = eq.index[eq.index >= crypto.index[0]]
+    cr = compound_to_grid(crypto, grid)
+    J = pd.concat({"crypto": cr, "equity": eq.reindex(cr.index)}, axis=1).dropna()
+    print(f"  finestra comune {J.index[0].date()}..{J.index[-1].date()}  ({len(J)} giorni di borsa)\n")
+
+    c, e = J["crypto"], J["equity"]
+    print("  --- STANDALONE (sulla finestra comune) ---")
+    for nm, r in (("crypto TP01+XS01+VRP01", c), ("equity GTAA vt12", e)):
+        print(f"    {nm:24} Sh {_sh(r):>5.2f}  CAGR {_cagr(r.values,r.index)*100:>5.1f}%  volAnn {_ann_vol(r)*100:>4.1f}%  maxDD {_dd(r.values)*100:>4.0f}%")
+    print(f"\n  --- CORRELAZIONE crypto <-> equity = {c.corr(e):+.3f}  (bassa = diversifica) ---")
+
+    print("\n  --- BLEND (capitale) ---")
+    print(f"    {'mix':18} {'Sharpe':>7} {'CAGR%':>6} {'volAnn%':>7} {'maxDD%':>6}")
+    for wc in (1.0, 0.75, 0.5, 0.25, 0.0):
+        b = wc * c + (1 - wc) * e
+        print(f"    crypto {int(wc*100):>3}/{int((1-wc)*100):<3} eq  {_sh(b):>7.2f} {_cagr(b.values,b.index)*100:>6.1f} {_ann_vol(b)*100:>7.1f} {_dd(b.values)*100:>6.0f}")
+
+    # risk-parity (peso inverso alla vol) — il blend "giusto" quando le vol differiscono
+    vc, ve = _ann_vol(c), _ann_vol(e)
+    wc_rp = (1/vc) / (1/vc + 1/ve)
+    b_rp = wc_rp * c + (1 - wc_rp) * e
+    print(f"\n  --- RISK-PARITY (inv-vol: crypto {wc_rp*100:.0f}% / eq {(1-wc_rp)*100:.0f}%) ---")
+    print(f"    Sharpe {_sh(b_rp):.2f}  CAGR {_cagr(b_rp.values,b_rp.index)*100:.1f}%  volAnn {_ann_vol(b_rp)*100:.1f}%  maxDD {_dd(b_rp.values)*100:.0f}%")
+
+    # verdetto: il blender batte il migliore dei due?
+    best_solo = max(_sh(c), _sh(e))
+    best_blend = max(_sh(0.5*c+0.5*e), _sh(b_rp))
+    print(f"\n  --- VERDETTO ---")
+    print(f"    miglior standalone Sharpe = {best_solo:.2f} | miglior blend Sharpe = {best_blend:.2f} "
+          f"-> {'DIVERSIFICA (blend > solo)' if best_blend > best_solo + 0.03 else 'nessun guadagno netto'}")
+    print(f"    (nota: portafoglio cross-venue Deribit+IB; finestra crypto corta ~{len(J)//252}y)")
+
+
+if __name__ == "__main__":
+    main()
@@ -0,0 +1,109 @@
+"""EQ-GTAA01 — Trend difensivo MULTI-ASSET (GTAA) sull'universo ETF.
+
+EQ-TREND01 ha mostrato che il trend long-flat su SPY taglia il DD (analogo TP01). La diversificazione
+delle SORGENTI di trend (azioni US/tech/small + bond + oro + high-yield) di solito migliora il
+rischio-aggiustato del trend mono-asset. Qui: ogni asset gestito col proprio trend long-flat
+(TSMOM multi-orizzonte), equal-weight tra gli asset DISPONIBILI (la quota "off" o assente -> cash).
+
+DATI: cache eqlib (ADJUSTED, nessun IB). Start diversi -> outer-join con peso rinormalizzato sugli
+asset esistenti (come gli sleeve crypto). Finestra lunga: SPY/QQQ/IWM da ~2000; TLT(2016)/GLD(2004)/
+HYG(2007) entrano dopo. Riporto anche la finestra 6-asset comune (2016+).
+
+GIUDIZIO: vs SPY buy&hold, vs EW statico (isola il valore del TIMING di trend), vs SPY-trend mono;
+Sharpe full/pre15/OOS + maxDD + plateau. Causale, netto fee.
+"""
+import sys
+from pathlib import Path
+import numpy as np, pandas as pd
+
+ROOT = Path(__file__).resolve().parents[2]
+sys.path.insert(0, str(ROOT / "scripts" / "research"))
+import eqlib
+from eqlib import load_eq
+from eq_sector_momentum import _sh, _cagr, _dd, EQ_HOLDOUT, spy_bh
+from eq_spy_trend import tsmom_exposure, backtest, _series
+
+ASSETS = ["SPY", "QQQ", "IWM", "TLT", "GLD", "HYG"]
+
+
+def gated_returns(sym, horizons=(21, 63, 126, 252), fee_side=0.0002, target_vol=None, lev_cap=1.0):
+    """Rendimenti netti daily di UN asset gestito col proprio trend long-flat (cash quando off)."""
+    px = _series(sym)
+    ex = tsmom_exposure(px, horizons=horizons, target_vol=target_vol, lev_cap=lev_cap)
+    return backtest(px, ex, fee_side=fee_side)
+
+
+def gtaa(assets=ASSETS, horizons=(21, 63, 126, 252), fee_side=0.0002, target_vol=None):
+    """Portafoglio GTAA: media (equal-weight) dei rendimenti trend-gated sugli asset disponibili
+    ogni giorno (outer-join). La quota di asset assenti/in-cash resta in cash."""
+    cols = {a: gated_returns(a, horizons, fee_side, target_vol) for a in assets}
+    R = pd.concat(cols, axis=1).sort_index()
+    return R.mean(axis=1, skipna=True)   # EW sugli asset esistenti quel giorno
+
+
+def ew_buyhold(assets=ASSETS):
+    cols = {a: _series(a).pct_change() for a in assets}
+    return pd.concat(cols, axis=1).sort_index().mean(axis=1, skipna=True)
+
+
+def _row(name, r, common=None, bench=None):
+    r = r.dropna() if common is None else r.reindex(common).fillna(0.0)
+    h = r[r.index >= EQ_HOLDOUT]; ii = r[r.index < EQ_HOLDOUT]
+    tim = float((r != 0).mean()) * 100
+    extra = ""
+    if bench is not None:
+        J = pd.concat({"r": r, "b": bench}, axis=1, join="inner").dropna()
+        extra = f"  corrSPY {J['r'].corr(J['b']):+.2f}"
+    print(f"  {name:26} CAGR {_cagr(r.values, r.index)*100:>5.1f}%  Sh {_sh(r):>5.2f} "
+          f"(pre15 {_sh(ii):>5.2f}|OOS {_sh(h):>5.2f})  maxDD {_dd(r.values)*100:>4.0f}%  inMkt {tim:>3.0f}%{extra}")
+
+
+def main():
+    print("=" * 100)
+    print("  EQ-GTAA01 — Trend difensivo MULTI-ASSET (GTAA)")
+    print("=" * 100)
+    spy = spy_bh()
+    g = gtaa()                          # outer-join, finestra lunga
+    gl = g.dropna()
+    print(f"  finestra lunga (outer-join) {gl.index[0].date()}..{gl.index[-1].date()} ({len(gl)}g)  OOS {EQ_HOLDOUT.date()}+\n")
+
+    print("  --- BASELINE & confronti (finestra lunga) ---")
+    cl = gl.index
+    _row("SPY buy&hold", spy.reindex(cl).fillna(0))
+    _row("EW statico (no trend)", ew_buyhold().reindex(cl).fillna(0), bench=spy.reindex(cl).fillna(0))
+    _row("SPY-trend mono (TREND01)", backtest(_series("SPY"), tsmom_exposure(_series("SPY"))).reindex(cl).fillna(0), bench=spy.reindex(cl).fillna(0))
+    print("\n  --- GTAA (multi-asset trend) ---")
+    _row("GTAA lf", gl, bench=spy.reindex(cl).fillna(0))
+    _row("GTAA lf vt12%", gtaa(target_vol=0.12).reindex(cl).fillna(0), bench=spy.reindex(cl).fillna(0))
+
+    # finestra 6-asset comune (tutti gli ETF esistono): 2016+
+    tlt0 = _series("TLT").index[0]
+    c6 = gl.index[gl.index >= tlt0]
+    print(f"\n  --- finestra 6-asset comune ({c6[0].date()}+) ---")
+    _row("SPY buy&hold (6a win)", spy.reindex(c6).fillna(0))
+    _row("GTAA lf (6a win)", g.reindex(c6).fillna(0), bench=spy.reindex(c6).fillna(0))
+    _row("GTAA lf vt12 (6a win)", gtaa(target_vol=0.12).reindex(c6).fillna(0), bench=spy.reindex(c6).fillna(0))
+
+    # MARGINALE vs SPY
+    print("\n  --- MARGINALE vs SPY (GTAA lf, finestra lunga) ---")
+    J = pd.concat({"spy": spy, "c": gl}, axis=1, join="inner").dropna(); JH = J[J.index >= EQ_HOLDOUT]
+    print(f"    corr full {J['spy'].corr(J['c']):+.3f} | OOS {JH['spy'].corr(JH['c']):+.3f}")
+    for wt in (0.5, 1.0):
+        bf = _sh((1-wt)*J['spy']+wt*J['c'])-_sh(J['spy']); bh = _sh((1-wt)*JH['spy']+wt*JH['c'])-_sh(JH['spy'])
+        lbl = "100% GTAA" if wt == 1.0 else "50/50 SPY/GTAA"
+        print(f"    {lbl:16}: uplift Sharpe FULL {bf:+.3f}  OOS {bh:+.3f}")
+    print("    DD nei bear (GTAA vs SPY):")
+    for lo, hi, lbl in [("2000-03-01","2002-12-31","dot-com"),("2007-10-01","2009-06-30","GFC"),
+                        ("2020-02-01","2020-04-30","COVID"),("2022-01-01","2022-12-31","2022")]:
+        seg=lambda s: _dd(s.reindex(cl).fillna(0)[(cl>=pd.Timestamp(lo,tz='UTC'))&(cl<=pd.Timestamp(hi,tz='UTC'))].values)*100
+        print(f"      {lbl:8} GTAA {seg(gl):.0f}%  | SPY {seg(spy):.0f}%")
+
+    print("\n  --- PLATEAU (Sharpe FULL/pre15/OOS, DD, CAGR) GTAA lf, finestra lunga ---")
+    print(f"    {'horizons':22} {'FULL':>6} {'pre15':>6} {'OOS':>6} {'DD%':>5} {'CAGR%':>6}")
+    for hz in [(63,126,252),(21,63,126,252),(126,252),(252,)]:
+        r = gtaa(horizons=hz).reindex(cl).fillna(0); h=r[r.index>=EQ_HOLDOUT]; ii=r[r.index<EQ_HOLDOUT]
+        print(f"    {'x'.join(map(str,hz)):22} {_sh(r):>6.2f} {_sh(ii):>6.2f} {_sh(h):>6.2f} {_dd(r.values)*100:>5.0f} {_cagr(r.values,r.index)*100:>6.1f}")
+
+
+if __name__ == "__main__":
+    main()
@@ -0,0 +1,159 @@
+"""EQ-MOM01 — Momentum cross-sectional settoriale (SPDR), backtest onesto.
+
+Prima ricerca del fronte equity (branch research/equities-ib). L'edge "noioso e robusto" piu'
+plausibile in un mercato efficiente: ruotare nei settori a momentum forte. Domanda chiave (come nel
+crypto col soffitto TP01): NON "fa soldi?" (un long-only equity cavalca il toro) ma **batte/ADDS a
+SPY buy&hold?** — il baseline vero in equity. Anche vs equal-weight 9 settori (isola il timing del
+momentum dal tilt equal-weight).
+
+DATI: cache su disco eq_*.parquet (ADJUSTED div+split), via eqlib (nessun IB). 9 settori CLASSICI
+dal 1998 (27.5y) per il backtest lungo; 11 settori (2018+) come robustezza.
+
+COSTRUZIONE (causale): ogni REB giorni, momentum = blend di lookback [63,126,252]g con SKIP recente
+(12-1 classico), z-score cross-sectional mediato. long-only: full-invested nei top-k (confronto
+like-for-like con SPY). long-short: dollar-neutral top-k vs bottom-k. Posizione decisa a <= i-1,
+tenuta da i (W[:-1]*dret[1:]). Netto fee sul turnover. Opz. vol-target.
+
+GIUDIZIO: standalone (FULL / pre-2015 / hold-out 2015+ / per-anno, CAGR, Sharpe, maxDD) vs SPY e
+EW-settori; marginale vs SPY (corr, uplift blend full+hold, edge in-sample, persistenza multi-cut);
+plateau su lookback/k/reb/skip; sweep fee.
+"""
+import sys
+from pathlib import Path
+import numpy as np, pandas as pd
+
+ROOT = Path(__file__).resolve().parents[2]
+sys.path.insert(0, str(ROOT / "scripts" / "research"))
+import eqlib
+from eqlib import panel, load_eq, SECTORS_CLASSIC, SECTORS
+
+ANN = np.sqrt(252.0)
+EQ_HOLDOUT = pd.Timestamp("2015-01-01", tz="UTC")   # OOS lungo: ultimi ~11 anni (post-GFC, dove il momentum e' decaduto)
+
+
+def _sh(r):
+    r = np.asarray(pd.Series(r).dropna(), float)
+    return float(np.mean(r) / np.std(r) * ANN) if len(r) > 2 and np.std(r) > 0 else 0.0
+
+
+def _cagr(r, idx):
+    r = np.asarray(r, float); yrs = (idx[-1] - idx[0]).days / 365.25
+    return float(np.prod(1 + r) ** (1 / yrs) - 1) if yrs > 0 else 0.0
+
+
+def _dd(r):
+    eq = np.cumprod(1 + np.asarray(r, float)); pk = np.maximum.accumulate(eq)
+    return float(np.max((pk - eq) / pk)) if len(eq) else 0.0
+
+
+def momentum(universe=tuple(SECTORS_CLASSIC), lookbacks=(63, 126, 252), k=3, reb=21,
+             skip=21, mode="long", target_vol=None, fee_side=0.0002):
+    """Serie netta daily del book momentum settoriale. mode='long' (top-k full-invested) o
+    'ls' (dollar-neutral top-k vs bottom-k)."""
+    P = panel(universe, how="inner")
+    idx = P.index; px = P.values; n, A = px.shape
+    dret = np.vstack([np.zeros(A), px[1:] / px[:-1] - 1.0])
+    mlb = max(lookbacks) + skip
+    W = np.zeros((n, A)); w = np.zeros(A)
+    for i in range(n):
+        if i >= mlb and i % reb == 0:
+            score = np.zeros(A); cnt = 0
+            for Lb in lookbacks:
+                a, b = i - skip - Lb, i - skip
+                rL = px[b] / px[a] - 1.0
+                sd = rL.std()
+                if sd > 0:
+                    score += (rL - rL.mean()) / sd; cnt += 1
+            if cnt:
+                score /= cnt
+                order = np.argsort(score)
+                w = np.zeros(A)
+                if mode == "long":
+                    w[order[-k:]] = 1.0 / k                       # full-invested nei top-k
+                else:
+                    w[order[-k:]] = 0.5 / k; w[order[:k]] = -0.5 / k
+        W[i] = w
+    gross = np.zeros(n); gross[1:] = np.sum(W[:-1] * dret[1:], axis=1)
+    turn = np.zeros(n); turn[0] = np.abs(W[0]).sum(); turn[1:] = np.abs(np.diff(W, axis=0)).sum(axis=1)
+    net = gross - turn * fee_side
+    s = pd.Series(net, index=idx)
+    if target_vol:
+        rv = s.rolling(63, min_periods=20).std().shift(1) * ANN
+        scale = np.clip(np.nan_to_num(target_vol / rv.replace(0, np.nan).values, nan=0.0), 0, 3.0)
+        s = pd.Series(s.values * scale, index=idx)
+    return s
+
+
+def spy_bh():
+    d = load_eq("SPY")["close"].astype(float)
+    return pd.Series(d.values[1:] / d.values[:-1] - 1.0, index=d.index[1:])
+
+
+def ew_sectors_bh(universe=tuple(SECTORS_CLASSIC)):
+    P = panel(universe, how="inner"); dret = P.pct_change().dropna()
+    return dret.mean(axis=1)
+
+
+def _line(name, r, idx=None, bench=None):
+    idx = idx if idx is not None else r.index
+    r = r.reindex(idx).fillna(0.0) if hasattr(r, "reindex") else pd.Series(r, index=idx)
+    h = r[r.index >= EQ_HOLDOUT]; isamp = r[r.index < EQ_HOLDOUT]
+    extra = ""
+    if bench is not None:
+        J = pd.concat({"r": r, "b": bench}, axis=1, join="inner").dropna()
+        extra = f"  corr_SPY {J['r'].corr(J['b']):+.2f}"
+    print(f"  {name:26} CAGR {_cagr(r.values, r.index)*100:>5.1f}%  Sh {_sh(r):>5.2f}  "
+          f"(pre15 {_sh(isamp):>5.2f} | OOS15+ {_sh(h):>5.2f})  maxDD {_dd(r.values)*100:>4.0f}%{extra}")
+
+
+def main():
+    print("=" * 100)
+    print("  EQ-MOM01 — Momentum cross-sectional settoriale (9 SPDR classici, 1998+)")
+    print("=" * 100)
+    spy = spy_bh(); ew = ew_sectors_bh()
+    base = momentum()                                  # long, lb[63,126,252], k=3, reb21, skip21
+    common = base.index
+    print(f"  periodo {common[0].date()}..{common[-1].date()}  ({len(common)}g)  hold-out OOS = {EQ_HOLDOUT.date()}+\n")
+
+    print("  --- BASELINE da battere ---")
+    _line("SPY buy&hold", spy, common)
+    _line("EW 9 settori buy&hold", ew, common, bench=spy)
+    print("\n  --- EQ-MOM01 ---")
+    _line("MOM long top-3", base, common, bench=spy)
+    _line("MOM long top-3 vt15%", momentum(target_vol=0.15), common, bench=spy)
+    _line("MOM long-short top-3", momentum(mode="ls"), common, bench=spy)
+
+    # MARGINALE vs SPY (il test che conta in equity)
+    print("\n  --- MARGINALE vs SPY buy&hold (aggiunge al baseline?) ---")
+    J = pd.concat({"spy": spy, "c": base}, axis=1, join="inner").dropna()
+    JH = J[J.index >= EQ_HOLDOUT]
+    print(f"    corr(MOM,SPY) full {J['spy'].corr(J['c']):+.3f}  | OOS {JH['spy'].corr(JH['c']):+.3f}")
+    for wt in (0.25, 0.5):
+        bf = _sh((1-wt)*J["spy"]+wt*J["c"]) - _sh(J["spy"])
+        bh = _sh((1-wt)*JH["spy"]+wt*JH["c"]) - _sh(JH["spy"])
+        print(f"    blend {int((1-wt)*100)}/{int(wt*100)} SPY/MOM: uplift Sharpe FULL {bf:+.3f}  OOS {bh:+.3f}")
+    # per-decade (multi-cut onesto)
+    print("    Sharpe MOM per blocco: ", {f"{y}s": round(_sh(base[(base.index.year>=y)&(base.index.year<y+5)]),2)
+          for y in (1999,2004,2009,2014,2019,2024)})
+
+    # PLATEAU
+    print("\n  --- PLATEAU (Sharpe FULL / pre15 / OOS15+) long-only ---")
+    print(f"    {'cfg':24} {'FULL':>6} {'pre15':>6} {'OOS':>6} {'CAGR%':>6} {'DD%':>5}")
+    for lbs in [(126,), (63,126,252), (252,)]:
+        for k in (2, 3, 4):
+            for reb in (21,):
+                s = momentum(lookbacks=lbs, k=k, reb=reb)
+                tag = f"lb{'-'.join(map(str,lbs))} k{k}"
+                h=s[s.index>=EQ_HOLDOUT]; ii=s[s.index<EQ_HOLDOUT]
+                print(f"    {tag:24} {_sh(s):>6.2f} {_sh(ii):>6.2f} {_sh(h):>6.2f} {_cagr(s.values,s.index)*100:>6.1f} {_dd(s.values)*100:>5.0f}")
+
+    # sweep fee + robustezza 11 settori (2018+)
+    print("\n  --- ROBUSTEZZA ---")
+    for fee in (0.0, 0.0002, 0.0005, 0.001):
+        s = momentum(fee_side=fee); print(f"    fee {fee*100:.2f}%/lato: Sh FULL {_sh(s):.2f}  OOS {_sh(s[s.index>=EQ_HOLDOUT]):.2f}")
+    s11 = momentum(universe=tuple(SECTORS)); spy11 = spy.reindex(s11.index)
+    print(f"    11 settori (2018+): MOM Sh {_sh(s11):.2f} vs SPY {_sh(spy11):.2f}  (periodo {s11.index[0].date()}+)")
+
+
+if __name__ == "__main__":
+    main()
@@ -0,0 +1,146 @@
+"""EQ-TREND01 — Trend DIFENSIVO time-series su SPY (analogo equity di TP01).
+
+Il momentum cross-sectional settoriale e' morto (EQ-MOM01). Ma nel crypto l'unica cosa che ha retto
+NON era un alpha relative-value: era TP01, un trend DIFENSIVO che taglia il drawdown restando vicino
+al ritorno. L'equity ha lo stesso buco: SPY buy&hold fa Sharpe ~0.51 ma con maxDD 55% (due bear -50%:
+2000-02 e 2008-09). Domanda: un trend long-flat su SPY ALZA il Sharpe e DIMEZZA il DD restando
+investito nei tori? (NON cerchiamo di battere il CAGR — cerchiamo il taglio del rischio, come TP01.)
+
+DATI: cache su disco eq_spy/eq_tlt (ADJUSTED), via eqlib (nessun IB).
+COSTRUZIONE (causale, stile TP01): TSMOM multi-orizzonte [21,63,126,252]g (1/3/6/12 mesi); target =
+frazione di orizzonti in trend-up (0..1, allocazione graduale). Vol-target opz. Posizione decisa a
+<=i-1, tenuta da i. Netto fee sul turnover. Varianti: long-flat (cash in risk-off), long-bonds
+(TLT in risk-off, solo dal 2016), e SMA-200 binario (Faber) come riferimento classico.
+
+GIUDIZIO: vs SPY buy&hold (CAGR/Sharpe full-pre15-OOS15+/maxDD/time-in-market), marginale vs SPY,
+DD nei due bear storici, plateau (orizzonti/vol-target/cap leva), sweep fee.
+"""
+import sys
+from pathlib import Path
+import numpy as np, pandas as pd
+
+ROOT = Path(__file__).resolve().parents[2]
+sys.path.insert(0, str(ROOT / "scripts" / "research"))
+import eqlib
+from eqlib import load_eq
+from eq_sector_momentum import _sh, _cagr, _dd, EQ_HOLDOUT, spy_bh
+
+ANN = np.sqrt(252.0)
+
+
+def _series(sym):
+    d = load_eq(sym)["close"].astype(float)
+    return pd.Series(d.values, index=d.index)
+
+
+def tsmom_exposure(close: pd.Series, horizons=(21, 63, 126, 252), target_vol=None,
+                   lev_cap=1.0) -> pd.Series:
+    """Esposizione SPY in [0, lev_cap]: frazione di orizzonti in trend-up, opz. vol-targeted (causale)."""
+    px = close.values; n = len(px); tgt = np.zeros(n)
+    mh = max(horizons)
+    for i in range(mh, n):
+        tgt[i] = np.mean([1.0 if px[i] > px[i - H] else 0.0 for H in horizons])
+    s = pd.Series(tgt, index=close.index)
+    if target_vol:
+        ret = close.pct_change()
+        rv = ret.rolling(63, min_periods=20).std().shift(1) * ANN
+        scale = np.clip(np.nan_to_num(target_vol / rv.replace(0, np.nan).values, nan=0.0), 0, lev_cap / 0.0 if False else 10.0)
+        s = (s * scale).clip(0, lev_cap)
+    else:
+        s = s.clip(0, lev_cap)
+    return s
+
+
+def sma_timing(close: pd.Series, win=200) -> pd.Series:
+    """Faber: long se close > SMA(win), altrimenti flat. Binario {0,1}."""
+    sma = close.rolling(win, min_periods=win // 2).mean()
+    return (close > sma).astype(float)
+
+
+def backtest(close: pd.Series, exposure: pd.Series, risk_off: pd.Series | None = None,
+             fee_side=0.0002) -> pd.Series:
+    """Rendimenti netti: held = exposure ritardata di 1 (causale). La quota non in SPY (1-held, se
+    exposure<=1) va in risk_off (es. TLT) o cash (0). Fee sul turnover di SPY."""
+    ret = close.pct_change().fillna(0.0).values
+    exp = exposure.reindex(close.index).fillna(0.0).values
+    held = np.zeros(len(exp)); held[1:] = exp[:-1]
+    net = held * ret
+    if risk_off is not None:
+        ro = risk_off.reindex(close.index).pct_change().fillna(0.0).values
+        cash_w = np.clip(1.0 - held, 0.0, 1.0)        # quota fuori da SPY -> bonds
+        net = net + cash_w * ro
+    net = net - fee_side * np.abs(np.diff(held, prepend=0.0))
+    return pd.Series(net, index=close.index)
+
+
+def _row(name, r, common, bench=None):
+    r = r.reindex(common).fillna(0.0)
+    h = r[r.index >= EQ_HOLDOUT]; ii = r[r.index < EQ_HOLDOUT]
+    tim = float((r != 0).mean()) * 100
+    extra = ""
+    if bench is not None:
+        J = pd.concat({"r": r, "b": bench.reindex(common).fillna(0.0)}, axis=1).dropna()
+        extra = f"  corr {J['r'].corr(J['b']):+.2f}"
+    print(f"  {name:24} CAGR {_cagr(r.values, r.index)*100:>5.1f}%  Sh {_sh(r):>5.2f} "
+          f"(pre15 {_sh(ii):>5.2f}|OOS {_sh(h):>5.2f})  maxDD {_dd(r.values)*100:>4.0f}%  inMkt {tim:>3.0f}%{extra}")
+
+
+def _bear_dd(r, common, lo, hi, label):
+    seg = r.reindex(common).fillna(0.0)
+    seg = seg[(seg.index >= pd.Timestamp(lo, tz="UTC")) & (seg.index <= pd.Timestamp(hi, tz="UTC"))]
+    return f"{label}: {_dd(seg.values)*100:.0f}%"
+
+
+def main():
+    print("=" * 100)
+    print("  EQ-TREND01 — Trend DIFENSIVO time-series su SPY (analogo di TP01)")
+    print("=" * 100)
+    spy_px = _series("SPY"); spy = spy_bh()
+    common = spy_px.index[spy_px.index >= spy_px.index[252]]   # warmup 1y
+    print(f"  periodo {common[0].date()}..{common[-1].date()}  ({len(common)}g)  OOS = {EQ_HOLDOUT.date()}+\n")
+
+    print("  --- BASELINE ---")
+    _row("SPY buy&hold", spy, common)
+    print("\n  --- TREND long-flat (cash in risk-off) ---")
+    _row("SMA-200 (Faber)", backtest(spy_px, sma_timing(spy_px)), common, bench=spy)
+    _row("TSMOM lf cap1.0", backtest(spy_px, tsmom_exposure(spy_px)), common, bench=spy)
+    _row("TSMOM lf vt15 cap1.0", backtest(spy_px, tsmom_exposure(spy_px, target_vol=0.15, lev_cap=1.0)), common, bench=spy)
+    _row("TSMOM lf vt15 cap1.5", backtest(spy_px, tsmom_exposure(spy_px, target_vol=0.15, lev_cap=1.5)), common, bench=spy)
+
+    print("\n  --- TREND long-BONDS (TLT in risk-off, solo dove TLT esiste: 2016+) ---")
+    tlt = _series("TLT")
+    cb = spy_px.index[(spy_px.index >= tlt.index[0])]
+    _row("SPY b&h (2016+)", spy.reindex(cb), cb)
+    _row("TSMOM lf+TLT (2016+)", backtest(spy_px, tsmom_exposure(spy_px), risk_off=tlt), cb, bench=spy)
+
+    # MARGINALE vs SPY + DD nei bear
+    base = backtest(spy_px, tsmom_exposure(spy_px))
+    print("\n  --- MARGINALE vs SPY (TSMOM lf cap1.0) ---")
+    J = pd.concat({"spy": spy, "c": base}, axis=1, join="inner").dropna(); JH = J[J.index >= EQ_HOLDOUT]
+    print(f"    corr full {J['spy'].corr(J['c']):+.3f} | OOS {JH['spy'].corr(JH['c']):+.3f}")
+    for wt in (0.5, 1.0):
+        bf = _sh((1-wt)*J['spy']+wt*J['c']) - _sh(J['spy']); bh = _sh((1-wt)*JH['spy']+wt*JH['c']) - _sh(JH['spy'])
+        lbl = "100% TREND" if wt == 1.0 else f"{int((1-wt)*100)}/{int(wt*100)} SPY/TREND"
+        print(f"    {lbl:16}: uplift Sharpe FULL {bf:+.3f}  OOS {bh:+.3f}")
+    print("    DD nei bear storici (TSMOM vs SPY):")
+    for lo, hi, lbl in [("2000-03-01","2002-12-31","dot-com"), ("2007-10-01","2009-06-30","GFC"),
+                        ("2020-02-01","2020-04-30","COVID"), ("2022-01-01","2022-12-31","2022")]:
+        print(f"      {lbl:8}  TSMOM {_bear_dd(base,common,lo,hi,'')}  | SPY {_bear_dd(spy,common,lo,hi,'')}")
+
+    # PLATEAU
+    print("\n  --- PLATEAU (Sharpe FULL/pre15/OOS, maxDD, CAGR) long-flat cap1.0 ---")
+    print(f"    {'horizons':22} {'FULL':>6} {'pre15':>6} {'OOS':>6} {'DD%':>5} {'CAGR%':>6}")
+    for hz in [(63,126,252),(21,63,126,252),(126,252),(50,200),(200,)]:
+        ex = sma_timing(spy_px, 200) if hz == (200,) else tsmom_exposure(spy_px, horizons=hz)
+        r = backtest(spy_px, ex); h=r[r.index>=EQ_HOLDOUT]; ii=r[r.index<EQ_HOLDOUT]
+        tag = "SMA-200" if hz==(200,) else "x".join(map(str,hz))
+        print(f"    {tag:22} {_sh(r):>6.2f} {_sh(ii):>6.2f} {_sh(h):>6.2f} {_dd(r.values)*100:>5.0f} {_cagr(r.values,r.index)*100:>6.1f}")
+
+    print("\n  --- SWEEP FEE (TSMOM lf cap1.0) ---")
+    for fee in (0.0, 0.0002, 0.0005, 0.001):
+        r = backtest(spy_px, tsmom_exposure(spy_px), fee_side=fee)
+        print(f"    fee {fee*100:.2f}%/lato: Sh {_sh(r):.2f}  maxDD {_dd(r.values)*100:.0f}%")
+
+
+if __name__ == "__main__":
+    main()
@@ -0,0 +1,93 @@
+"""COMBO DEPLOYABLE — TP01 (Deribit) + GTAA (IB): le DUE gambe realmente eseguibili a basso capitale.
+
+Il combo crypto-pieno (TP01+XS01+VRP01)+GTAA diversificava (Sharpe 1.6->1.8), ma XS01/VRP01 sono
+STAT-MODE (non eseguibili a $600). Qui il combo ONESTO/deployable: solo le gambe eseguibili —
+  * TP01: TSMOM difensivo BTC/ETH, long-flat, gia' ARMATO live su Deribit;
+  * GTAA: trend difensivo multi-asset su ETF, eseguibile su IB (frazioni, switch mensile).
+Domanda: due trend difensivi su mercati diversi, scorrelati, danno un blend migliore di ciascuno?
+
+ALLINEAMENTO: TP01 e' calendario-giornaliero (crypto 7gg), GTAA giorni di borsa -> compoundo TP01 sul
+grid dei giorni di borsa (cattura i weekend). Finestra = era TP01 (BTC/ETH dal 2019).
+Confronto anche col combo crypto-pieno per quantificare il COSTO della deployability.
+"""
+import sys
+from pathlib import Path
+import numpy as np, pandas as pd
+
+ROOT = Path(__file__).resolve().parents[2]
+sys.path.insert(0, str(ROOT)); sys.path.insert(0, str(ROOT / "scripts" / "research"))
+from eq_sector_momentum import _sh, _cagr, _dd, EQ_HOLDOUT
+from eq_gtaa_trend import gtaa
+from eq_crypto_combo import compound_to_grid, _ann_vol
+from src.portfolio.sleeves import _tp01_returns, active_sleeves
+from src.portfolio.portfolio import StrategyPortfolio
+
+ANN = np.sqrt(252.0)
+
+
+def _stat(nm, r):
+    print(f"    {nm:26} Sh {_sh(r):>5.2f}  CAGR {_cagr(r.values,r.index)*100:>5.1f}%  "
+          f"volAnn {_ann_vol(r)*100:>4.1f}%  maxDD {_dd(r.values)*100:>4.0f}%")
+
+
+def main():
+    print("=" * 96)
+    print("  COMBO DEPLOYABLE — TP01 (Deribit) + GTAA (IB)")
+    print("=" * 96)
+    tp01 = _tp01_returns()
+    if tp01.index.tz is None:
+        tp01.index = tp01.index.tz_localize("UTC")
+    eq = gtaa(target_vol=0.12).dropna()
+    grid = eq.index[eq.index >= tp01.index[0]]
+    tp = compound_to_grid(tp01, grid)
+    J = pd.concat({"tp01": tp, "gtaa": eq.reindex(tp.index)}, axis=1).dropna()
+    print(f"  finestra comune {J.index[0].date()}..{J.index[-1].date()}  ({len(J)} giorni di borsa, ~{len(J)//252}y)\n")
+    t, g = J["tp01"], J["gtaa"]
+
+    print("  --- STANDALONE (finestra comune) ---")
+    _stat("TP01 (crypto, Deribit)", t)
+    _stat("GTAA vt12 (equity, IB)", g)
+    c = t.corr(g)
+    print(f"\n  --- CORRELAZIONE TP01 <-> GTAA = {c:+.3f} ---")
+
+    print("\n  --- BLEND (capitale) ---")
+    print(f"    {'mix':20} {'Sharpe':>7} {'CAGR%':>6} {'volAnn%':>7} {'maxDD%':>6}")
+    best = (-9, None)
+    for wt in (1.0, 0.75, 0.6, 0.5, 0.4, 0.25, 0.0):
+        b = wt * t + (1 - wt) * g
+        if _sh(b) > best[0]:
+            best = (_sh(b), wt)
+        print(f"    TP01 {int(wt*100):>3}/{int((1-wt)*100):<3} GTAA  {_sh(b):>7.2f} {_cagr(b.values,b.index)*100:>6.1f} {_ann_vol(b)*100:>7.1f} {_dd(b.values)*100:>6.0f}")
+
+    vt, vg = _ann_vol(t), _ann_vol(g)
+    wt_rp = (1/vt) / (1/vt + 1/vg)
+    b_rp = wt_rp * t + (1 - wt_rp) * g
+    print(f"\n  --- RISK-PARITY (inv-vol: TP01 {wt_rp*100:.0f}% / GTAA {(1-wt_rp)*100:.0f}%) ---")
+    _stat("risk-parity blend", b_rp)
+
+    # OOS (post-2023, per dare un taglio fuori dai primi anni TP01)
+    cut = pd.Timestamp("2023-01-01", tz="UTC")
+    print(f"\n  --- robustezza: blend 50/50 per taglio ---")
+    b50 = 0.5 * t + 0.5 * g
+    for lbl, sub in (("full", b50), (">=2023", b50[b50.index >= cut])):
+        print(f"    {lbl:10} Sh {_sh(sub):.2f}  maxDD {_dd(sub.values)*100:.0f}%")
+    print("    Sharpe 50/50 per anno:", {y: round(_sh(b50[b50.index.year == y]), 2) for y in sorted(set(b50.index.year))})
+
+    # VERDETTO + costo della deployability
+    best_solo = max(_sh(t), _sh(g))
+    print(f"\n  --- VERDETTO ---")
+    print(f"    miglior standalone {best_solo:.2f} | blend 50/50 {_sh(b50):.2f} | risk-parity {_sh(b_rp):.2f} | "
+          f"miglior cap-mix {best[0]:.2f} (TP01 {int(best[1]*100)}%)")
+    print(f"    -> {'DIVERSIFICA (blend > solo)' if max(_sh(b50),_sh(b_rp)) > best_solo + 0.03 else 'nessun guadagno netto'}")
+    # costo vs combo crypto-pieno
+    full = StrategyPortfolio(active_sleeves()).combined_daily()
+    if full.index.tz is None: full.index = full.index.tz_localize("UTC")
+    fc = compound_to_grid(full, J.index)
+    Jf = pd.concat({"f": fc, "g": g.reindex(fc.index)}, axis=1).dropna()
+    print(f"    costo deployability: blend 50/50 con crypto-PIENO Sh {_sh(0.5*Jf['f']+0.5*Jf['g']):.2f} "
+          f"vs deployable {_sh(b50):.2f}  (la differenza = cio' che lasciano XS01/VRP01 STAT-MODE)")
+    print(f"    (cross-venue Deribit+IB; entrambe switch mensile/basso turnover; frazionabili a $0.5-2k)")
+
+
+if __name__ == "__main__":
+    main()
@@ -0,0 +1,65 @@
+"""EQLIB — harness di ricerca EQUITY/ETF (branch research/equities-ib).
+
+Legge la CACHE su disco (data/raw/eq_*.parquet, ADJUSTED_LAST, scritta una volta da
+fetch_ib_equities.py) — MAI da IB. `lru_cache` -> ogni parquet si legge una sola volta per processo.
+"Memorizza i dati per non rileggerli ogni volta": la persistenza e' il parquet su disco + questa cache.
+
+Espone: universi (SECTORS/BROAD), load_eq(sym), panel(universe) allineato, e riusa lo scorer
+indurito di altlib (_sh, _dd_ret, _to_daily, marginal_vs_tp01) per giudicare i candidati con la
+stessa disciplina del lato crypto.
+"""
+from functools import lru_cache
+from pathlib import Path
+import numpy as np, pandas as pd
+
+ROOT = Path(__file__).resolve().parents[2]
+RAW = ROOT / "data" / "raw"
+
+# 11 SPDR settoriali. I 9 "classici" (sotto SECTORS_CLASSIC) partono 1998; XLRE 2015, XLC 2018.
+SECTORS = ["XLK", "XLF", "XLE", "XLV", "XLI", "XLP", "XLY", "XLU", "XLB", "XLRE", "XLC"]
+SECTORS_CLASSIC = ["XLK", "XLF", "XLE", "XLV", "XLI", "XLP", "XLY", "XLU", "XLB"]   # storia lunga (1998+)
+BROAD = ["SPY", "QQQ", "IWM", "TLT", "GLD", "HYG"]
+
+
+@lru_cache(maxsize=64)
+def load_eq(sym: str) -> pd.DataFrame:
+    """OHLCV aggiustato (dividendi+split) per `sym`, indicizzato datetime UTC. Cache su disco -> RAM."""
+    p = RAW / f"eq_{sym.lower()}_1d.parquet"
+    if not p.exists():
+        raise FileNotFoundError(f"{p} assente — gira: uv run --with ib_async python scripts/research/fetch_ib_equities.py")
+    d = pd.read_parquet(p).copy()
+    d.index = pd.to_datetime(d["timestamp"], unit="ms", utc=True)
+    return d[["open", "high", "low", "close", "volume"]]
+
+
+@lru_cache(maxsize=16)
+def _close_panel(universe: tuple) -> pd.DataFrame:
+    cols = {s: load_eq(s)["close"].astype(float) for s in universe}
+    return pd.concat(cols, axis=1).sort_index()
+
+
+def panel(universe=tuple(SECTORS), how: str = "inner") -> pd.DataFrame:
+    """Prezzi close aggiustati [date x asset]. how='inner' = date comuni a TUTTI (start = ETF piu' giovane);
+    'outer' = unione (NaN dove un ETF non esiste ancora)."""
+    P = _close_panel(tuple(universe))
+    return P.dropna(how="any") if how == "inner" else P
+
+
+def describe(universe=None):
+    universe = universe or (SECTORS + BROAD)
+    print(f"  {'sym':6} {'barre':>6} {'da':>11} {'a':>11} {'anni':>5}")
+    for s in universe:
+        try:
+            d = load_eq(s)
+            print(f"  {s:6} {len(d):>6} {str(d.index[0].date()):>11} {str(d.index[-1].date()):>11} "
+                  f"{(d.index[-1]-d.index[0]).days/365.25:>5.1f}")
+        except FileNotFoundError:
+            print(f"  {s:6}  (assente)")
+    Pc = panel(SECTORS_CLASSIC); Pa = panel(SECTORS)
+    print(f"\n  panel 9 settori CLASSICI: {Pc.shape[1]}x{len(Pc)}  start comune {Pc.index[0].date()}")
+    print(f"  panel 11 settori        : {Pa.shape[1]}x{len(Pa)}  start comune {Pa.index[0].date()}")
+
+
+if __name__ == "__main__":
+    print("=" * 70); print("  EQLIB — cache equity su disco (nessun IB)"); print("=" * 70)
+    describe()
@@ -0,0 +1,86 @@
+"""DEEP-DIVE: crypto[sessione USA] -> indice EUROPEO[overnight successivo]. Reale o artefatto?
+
+Lo sweep ha trovato un forte segnale: crypto[T-8h->T] (T~00:00 UTC, fine sessione USA) predice il
+future europeo (ESTX50/DAX)[T->T+6h] con t_crypto incrementale ~8, Sharpe 2.5, 3/3 anni. Verifiche:
+  (1) ROBUSTEZZA su T (ora entrata): un effetto vero non e' a coltello su una sola ora.
+  (2) vs SEMPRE-LONG: l'overnight ha un drift? il crypto AGGIUNGE oltre il long incondizionato?
+  (3) GAP 1-2h tra fine-segnale e inizio-cattura: se sopravvive, niente contaminazione di bordo.
+  (4) vs FUTURE-OWN: il crypto batte il momentum proprio del future (gia' nel t incrementale).
+Dati: cache (fut europei + crypto 1h). sqrt(252), net 2bps.
+"""
+import sys
+from pathlib import Path
+import numpy as np, pandas as pd
+
+ROOT = Path(__file__).resolve().parents[2]; RAW = ROOT / "data" / "raw"
+sys.path.insert(0, str(ROOT)); sys.path.insert(0, str(ROOT / "scripts" / "research"))
+from crypto_lead_harness import crypto_hourly, at
+COST = 0.0002
+
+
+def fut_hourly(sym):
+    d = pd.read_parquet(RAW / f"fut_{sym.lower()}_1h.parquet")
+    return pd.Series(d["close"].astype(float).values, index=pd.to_datetime(d["timestamp"], unit="ms", utc=True)).sort_index()
+
+
+def _sh(r):
+    r = np.asarray(r, float); r = r[np.isfinite(r)]
+    return float(np.mean(r) / np.std(r) * np.sqrt(252)) if len(r) > 5 and np.std(r) > 0 else 0.0
+
+
+def series(fut, bc, T, S=8, H=6, gap=0):
+    days = pd.date_range(fut.index[0].normalize(), fut.index[-1].normalize(), freq="D", tz="UTC")
+    rows = []
+    for D in days:
+        te = D + pd.Timedelta(hours=T)
+        f0, f1 = at(fut, te - pd.Timedelta(hours=S)), at(fut, te)
+        fcs, fce = at(fut, te + pd.Timedelta(hours=gap)), at(fut, te + pd.Timedelta(hours=gap + H))
+        c0, c1 = at(bc, te - pd.Timedelta(hours=S)), at(bc, te)
+        if not all(np.isfinite(v) and v > 0 for v in (f0, f1, fcs, fce, c0, c1)):
+            continue
+        rows.append((D, c1/c0 - 1, f1/f0 - 1, fce/fcs - 1))
+    Dd = pd.DataFrame(rows, columns=["d", "csig", "fctrl", "cap"]).set_index("d")
+    return Dd[Dd["cap"].abs() > 1e-9]
+
+
+def stats(Dd):
+    x, ctrl, y = Dd["csig"].values, Dd["fctrl"].values, Dd["cap"].values
+    def z(a):
+        s = a.std(); return (a - a.mean()) / s if s > 0 else a * 0
+    X = np.column_stack([np.ones(len(y)), z(x), z(ctrl)])
+    beta, *_ = np.linalg.lstsq(X, z(y), rcond=None)
+    resid = z(y) - X @ beta; dof = max(len(y) - 3, 1)
+    se = np.sqrt(np.sum(resid**2)/dof * np.diag(np.linalg.inv(X.T@X)))
+    t_c = float(beta[1]/se[1]) if se[1] > 0 else 0.0
+    crypto = np.sign(x)*y - COST
+    futown = np.sign(ctrl)*y - COST
+    always = y - COST
+    yrs = Dd.index.year.values
+    py = {int(v): round(_sh(crypto[yrs==v]),2) for v in sorted(set(yrs)) if (yrs==v).sum()>=30}
+    return dict(n=len(Dd), t_crypto=round(t_c,2), sh_crypto=round(_sh(crypto),2),
+                sh_futown=round(_sh(futown),2), sh_always=round(_sh(always),2),
+                ann_crypto=round(float(np.nanmean(crypto)*252*100),1), per_year=py)
+
+
+def main():
+    print("="*96); print("  DEEP-DIVE crypto -> indice EUROPEO overnight (reale o artefatto?)"); print("="*96)
+    bcs = {l: crypto_hourly(l) for l in ("BTC","ETH")}
+    for sym in ("ESTX50","DAX"):
+        fut = fut_hourly(sym)
+        print(f"\n  ===== {sym} =====")
+        print(f"  (1) ROBUSTEZZA su T (lead=BTC, S=8h H=6h gap=0): t_crypto | Sh crypto vs futown vs always-long")
+        for T in (20,21,22,23,0,1,2,3,4):
+            s = stats(series(fut, bcs["BTC"], T))
+            print(f"      T={T:>2}h: n={s['n']} t {s['t_crypto']:+.1f} | crypto {s['sh_crypto']:+.2f}  futown {s['sh_futown']:+.2f}  always {s['sh_always']:+.2f}  ann {s['ann_crypto']:+.1f}% {s['per_year']}")
+        print(f"  (3) GAP test (T=0h, cattura inizia +1h e +2h dopo il segnale):")
+        for g in (0,1,2):
+            s = stats(series(fut, bcs["BTC"], 0, gap=g))
+            print(f"      gap={g}h: t {s['t_crypto']:+.1f} | crypto {s['sh_crypto']:+.2f} always {s['sh_always']:+.2f}")
+        print(f"  (lead ETH, T=0h): ", end="")
+        s = stats(series(fut, bcs["ETH"], 0)); print(f"t {s['t_crypto']:+.1f} crypto {s['sh_crypto']:+.2f} always {s['sh_always']:+.2f} {s['per_year']}")
+    print("\n  LETTURA: se 'crypto' >> 'always' E >> 'futown' E regge su T e col gap -> lead REALE (crypto")
+    print("           anticipa il catch-up europeo). Se crypto ~ always -> e' solo overnight-drift europeo.")
+
+
+if __name__ == "__main__":
+    main()
@@ -0,0 +1,137 @@
+"""FETCH + CERTIFY funding rate Hyperliquid (API pubblica, tokenless) — per ricerca CARRY cross-sectional.
+
+CONTESTO (2026-06-22, onda "nuova ricerca mirata"). Le due grandi ondate (sweep 104-ipotesi +
+ortho relative-value) hanno esaurito gli angoli DIREZIONALI e RELATIVE-VALUE sul *prezzo* BTC/ETH.
+L'unico meccanismo con una fonte di ritorno DIVERSA non ancora testato su dati certi e' il CARRY da
+funding (incassare il cashflow perp, delta-neutral). Scan di fattibilita':
+  * funding price-clock sul feed Deribit certificato -> gia' testato (agent_03 intraday) = FAIL.
+  * funding carry su Deribit (dove eseguiamo) -> ccxt fetch_funding_rate_history = 0 righe (bloccato).
+  * funding carry su Hyperliquid -> API pubblica /info {"type":"fundingHistory"} = DISPONIBILE,
+    cadenza ORARIA, tokenless, serie native dal 2023-05-12. HL e' gia' l'universo certificato di XS01.
+
+DISCIPLINA (lezione v2.0.0): nessuna fiducia nel dato finche' non e' certificato. Qui certifichiamo:
+  (1) cadenza ~1h coerente, (2) gap interni, (3) copertura (giorni nativi reali per coin),
+  (4) plausibilita' magnitudine (|funding orario| tipico < ~0.06%/h = cap HL; outlier flaggati),
+  (5) il funding e' un CASHFLOW, non un prezzo -> niente cross-venue OHLC; il sanity check e'
+      che il funding medio sia ~positivo e piccolo (premio long-pays-short tipico dei perp crypto).
+
+Universo = i 19 major di XS01 (quelli che la strategia live userebbe). Output:
+  data/raw/hlfund_<sym>_1h.parquet  (namespace dedicato 'hlfund', NON tocca hl_<sym>_1d di XS01).
+"""
+import sys, time, datetime as dt
+from pathlib import Path
+import numpy as np, pandas as pd, requests
+
+ROOT = Path(__file__).resolve().parents[2]
+RAW = ROOT / "data" / "raw"
+RAW.mkdir(parents=True, exist_ok=True)
+
+# 19 major di XS01 (CLAUDE.md)
+UNIVERSE = ["BTC","ETH","SOL","BNB","XRP","DOGE","AVAX","LINK","LTC","ADA",
+            "ARB","OP","SUI","APT","INJ","TIA","SEI","NEAR","AAVE"]
+
+HL_INFO = "https://api.hyperliquid.xyz/info"
+START = int(dt.datetime(2023, 1, 1, tzinfo=dt.timezone.utc).timestamp() * 1000)
+HOUR_MS = 3600 * 1000
+
+
+def _post(payload, max_retry=6):
+    """POST con backoff esponenziale su 429/5xx (l'API pubblica HL throttla)."""
+    delay = 1.0
+    for attempt in range(max_retry):
+        r = requests.post(HL_INFO, json=payload, timeout=30)
+        if r.status_code == 429 or r.status_code >= 500:
+            time.sleep(delay)
+            delay = min(delay * 2, 20)  # 1,2,4,8,16,20
+            continue
+        r.raise_for_status()
+        return r.json()
+    r.raise_for_status()
+    return r.json()
+
+
+def fetch_funding(coin: str) -> pd.DataFrame:
+    """Pagina fundingHistory (max 500/req, orario) avanzando startTime fino a oggi."""
+    rows, start = [], START
+    seen = set()
+    while True:
+        d = _post({"type": "fundingHistory", "coin": coin, "startTime": start})
+        if not d:
+            break
+        new = [x for x in d if x["time"] not in seen]
+        for x in new:
+            seen.add(x["time"])
+            rows.append((x["time"], float(x["fundingRate"]), float(x.get("premium", "nan"))))
+        last = d[-1]["time"]
+        if len(d) < 500:  # ultima pagina
+            break
+        nxt = last + 1
+        if nxt <= start:  # niente progresso -> stop
+            break
+        start = nxt
+        time.sleep(0.35)  # gentile con l'API pubblica
+    if not rows:
+        return pd.DataFrame(columns=["ts", "funding", "premium"]).set_index("ts")
+    df = pd.DataFrame(rows, columns=["ts", "funding", "premium"]).drop_duplicates("ts").sort_values("ts")
+    df["ts"] = pd.to_datetime(df["ts"], unit="ms", utc=True)
+    return df.set_index("ts")
+
+
+def certify(coin: str, df: pd.DataFrame) -> dict:
+    if df.empty:
+        return {"coin": coin, "n": 0, "status": "VUOTO"}
+    idx = df.index
+    span_days = (idx[-1] - idx[0]).total_seconds() / 86400
+    # cadenza: differenze in ore
+    deltas_h = np.diff(idx.view("int64")) / 1e9 / 3600
+    median_dt = float(np.median(deltas_h)) if len(deltas_h) else float("nan")
+    gaps = int((deltas_h > 1.5).sum())  # buchi > 1.5h
+    expected = int(round(span_days * 24)) + 1
+    coverage = len(df) / expected if expected else float("nan")
+    f = df["funding"].values
+    # statistiche funding (orario)
+    ann = float(np.nanmean(f)) * 24 * 365  # funding annualizzato (carry teorico per chi paga)
+    cap_hits = int((np.abs(f) > 0.0006).sum())  # cap HL ~0.06%/h (4%/8h clamp); fuori = sospetto
+    status = "OK"
+    if coverage < 0.97 or gaps > 50:
+        status = "GAP"
+    if span_days < 365:
+        status = "corto<365g"
+    return {"coin": coin, "n": len(df), "primo": idx[0].date(), "ultimo": idx[-1].date(),
+            "giorni": round(span_days), "cad_h": round(median_dt, 3), "gap>1.5h": gaps,
+            "cover%": round(coverage * 100, 1), "fund_med_bps": round(float(np.nanmedian(f)) * 1e4, 4),
+            "fund_ann%": round(ann * 100, 1), "cap_hit": cap_hits, "status": status}
+
+
+def main():
+    print("=" * 100)
+    print("  FETCH + CERTIFY funding Hyperliquid (orario, tokenless) — 19 major XS01 -> data/raw/hlfund_*")
+    print("=" * 100)
+    rep = []
+    for sym in UNIVERSE:
+        try:
+            df = fetch_funding(sym)
+        except Exception as e:
+            print(f"  {sym:5} ERR {repr(e)[:80]}")
+            rep.append({"coin": sym, "n": 0, "status": "ERR"})
+            continue
+        c = certify(sym, df)
+        rep.append(c)
+        if c.get("n", 0) > 0:
+            out = RAW / f"hlfund_{sym.lower()}_1h.parquet"
+            df.to_parquet(out)
+        print(f"  {sym:5} n={c.get('n',0):>6} {str(c.get('primo','')):>10}->{str(c.get('ultimo','')):>10} "
+              f"cad={c.get('cad_h','?')}h gap={c.get('gap>1.5h','?')} cov={c.get('cover%','?')}% "
+              f"med={c.get('fund_med_bps','?')}bps ann={c.get('fund_ann%','?')}% cap_hit={c.get('cap_hit','?')} "
+              f"[{c['status']}]")
+    ok = [r["coin"] for r in rep if r.get("status") in ("OK",)]
+    short = [r["coin"] for r in rep if r.get("status") == "corto<365g"]
+    print("-" * 100)
+    print(f"  CERTIFICATI OK ({len(ok)}): {ok}")
+    if short:
+        print(f"  CORTI <365g ({len(short)}): {short}")
+    print(f"  Scritti in data/raw/hlfund_<sym>_1h.parquet (funding ORARIO, serie nativa).")
+
+
+if __name__ == "__main__":
+    main()
@@ -0,0 +1,134 @@
+"""FETCH + CERTIFY universo azioni/ETF da IB (ADJUSTED_LAST) -> data/raw/eq_<sym>_1d.parquet.
+
+Apre il fronte EQUITY (branch research/equities-ib). Disciplina v2.0.0: PRIMA il dato certificato,
+POI la strategia. IB dà storia daily aggiustata per dividendi+split (ADJUSTED_LAST), profonda
+(SPY dal 1996), sul conto paper. Namespace dedicato 'eq_' (NON tocca i parquet crypto).
+
+UNIVERSO (prima ricerca = momentum cross-sectional settoriale, l'edge robusto plausibile in equity):
+  * 11 SPDR settoriali (XLK..XLC);  * broad/macro SPY QQQ IWM TLT GLD HYG.
+NB: i 9 settori "classici" partono 1998; XLRE 2015, XLC 2018 -> lo start COMUNE a 11 e' 2018.
+Per backtest lunghi usare i 9 classici (1998+) o accettare lo start 2018 per gli 11.
+
+CERTIFICAZIONE (gemello equity di certify_feed.py):
+  (1) integrità: barre, range, date monotone, duplicati, flat bars (close invariato);
+  (2) gap: run di giorni-lavorativi mancanti > 5 (festivi normali, buchi lunghi = sospetti);
+  (3) sanità ritorni: max |daily ret| (un >50% non-evento = errore di adjustment);
+  (4) sanità adjustment: primo close aggiustato << ultimo (i dividendi abbassano lo storico).
+PREREQUISITO: gateway IB paper su 127.0.0.1:4002 (docker compose up -d ib-gateway).
+
+  uv run --with ib_async python scripts/research/fetch_ib_equities.py
+"""
+import sys, time
+from pathlib import Path
+import numpy as np, pandas as pd
+
+ROOT = Path(__file__).resolve().parents[2]
+RAW = ROOT / "data" / "raw"
+RAW.mkdir(parents=True, exist_ok=True)
+
+SECTORS = ["XLK", "XLF", "XLE", "XLV", "XLI", "XLP", "XLY", "XLU", "XLB", "XLRE", "XLC"]
+BROAD = ["SPY", "QQQ", "IWM", "TLT", "GLD", "HYG"]
+# espansione "diversi mercati" (intl / bond / credito / commodity / settori extra) per il lead-lag crypto
+BROAD2 = ["DIA", "EFA", "EEM", "FXI", "EWJ", "AGG", "LQD", "IEF", "USO", "SLV", "DBC", "VNQ"]
+UNIVERSE = SECTORS + BROAD + BROAD2
+
+
+def certify(sym: str, df: pd.DataFrame) -> dict:
+    if df.empty:
+        return {"sym": sym, "n": 0, "status": "VUOTO"}
+    idx = df.index
+    dup = int(idx.duplicated().sum())
+    mono = bool(idx.is_monotonic_increasing)
+    c = df["close"].values.astype(float)
+    ret = np.diff(c) / c[:-1]
+    flat = int((ret == 0).sum())
+    maxret = float(np.max(np.abs(ret))) if len(ret) else 0.0
+    # gap: giorni lavorativi attesi vs presenti, run lunghi mancanti
+    bdays = pd.bdate_range(idx[0], idx[-1])
+    missing = len(bdays) - len(idx.intersection(bdays))
+    gaps = bdays.difference(idx)
+    longgap = 0
+    if len(gaps):
+        g = pd.Series(1, index=gaps).resample("1D").sum().fillna(0)
+        # conta run consecutivi di bday mancanti
+        s = (gaps.to_series().diff().dt.days.fillna(1) > 3).cumsum()
+        longgap = int((gaps.to_series().groupby(s).size() > 5).sum())
+    span_y = (idx[-1] - idx[0]).days / 365.25
+    adj_ratio = round(float(c[0] / c[-1]), 3)  # primo/ultimo: <1 atteso (storico abbassato dai div)
+    status = "OK"
+    if dup or not mono:
+        status = "INTEGRITA'"
+    elif maxret > 0.5:
+        status = "SPIKE?"
+    elif longgap > 0:
+        status = "GAP-LUNGO"
+    elif span_y < 1:
+        status = "corto<1y"
+    return {"sym": sym, "n": len(df), "primo": idx[0].date(), "ultimo": idx[-1].date(),
+            "anni": round(span_y, 1), "dup": dup, "mono": mono, "flat": flat,
+            "maxret%": round(maxret * 100, 1), "miss_bd": missing, "gap_lunghi": longgap,
+            "adj_first/last": adj_ratio, "status": status}
+
+
+def main():
+    try:
+        from ib_async import IB, Stock
+    except Exception:
+        print("ib_async assente. Esegui con: uv run --with ib_async python scripts/research/fetch_ib_equities.py")
+        sys.exit(2)
+    ib = IB()
+    try:
+        ib.connect("127.0.0.1", 4002, clientId=90, timeout=15)
+    except Exception as e:
+        print(f"[CONNESSIONE FALLITA] 127.0.0.1:4002 -> {repr(e)[:120]}\n  Avvia: docker compose up -d ib-gateway")
+        sys.exit(1)
+
+    print("=" * 104)
+    print(f"  FETCH + CERTIFY azioni/ETF (ADJUSTED_LAST) -> data/raw/eq_* | acct {ib.managedAccounts()}")
+    print("=" * 104)
+    rep, ok = [], []
+    force = "--force" in sys.argv[1:]
+    universe = UNIVERSE
+    if "--only" in sys.argv[1:]:                      # refresh mirato (es. solo i 6 ETF GTAA per il cron)
+        universe = sys.argv[sys.argv.index("--only") + 1].upper().split(",")
+        force = True                                  # --only implica refresh dei simboli indicati
+    for sym in universe:
+        out_path = RAW / f"eq_{sym.lower()}_1d.parquet"
+        if out_path.exists() and not force:
+            print(f"  {sym:5} GIA' SU DISCO -> skip (usa --force per riscaricare)")
+            ok.append(sym)
+            continue
+        con = Stock(sym, "SMART", "USD")
+        try:
+            bars = ib.reqHistoricalData(con, endDateTime="", durationStr="30 Y", barSizeSetting="1 day",
+                                        whatToShow="ADJUSTED_LAST", useRTH=True, formatDate=1, timeout=60)
+        except Exception as e:
+            print(f"  {sym:5} ERR {repr(e)[:70]}"); rep.append({"sym": sym, "status": "ERR"}); time.sleep(1.2); continue
+        if not bars:
+            print(f"  {sym:5} 0 barre (subscription?)"); rep.append({"sym": sym, "n": 0, "status": "VUOTO"}); time.sleep(1.2); continue
+        df = pd.DataFrame([(pd.Timestamp(str(b.date)), b.open, b.high, b.low, b.close, b.volume) for b in bars],
+                          columns=["ts", "open", "high", "low", "close", "volume"]).set_index("ts").sort_index()
+        c = certify(sym, df)
+        rep.append(c)
+        if c.get("n", 0) > 0:
+            out = df.copy()
+            # ms epoch (come i parquet crypto), robusto alla risoluzione datetime64 (s/us/ns)
+            out["timestamp"] = out.index.astype("datetime64[ms]").astype("int64")
+            out.reset_index(drop=True).to_parquet(RAW / f"eq_{sym.lower()}_1d.parquet")
+            if c["status"] == "OK":
+                ok.append(sym)
+        print(f"  {sym:5} n={c.get('n',0):>5} {str(c.get('primo','')):>10}->{str(c.get('ultimo',''))} "
+              f"{c.get('anni','?')}y flat={c.get('flat','?')} maxret={c.get('maxret%','?')}% "
+              f"miss_bd={c.get('miss_bd','?')} gapL={c.get('gap_lunghi','?')} adj={c.get('adj_first/last','?')} [{c['status']}]")
+        time.sleep(1.2)  # pacing IB
+
+    print("-" * 104)
+    print(f"  CERTIFICATI OK ({len(ok)}/{len(UNIVERSE)}): {ok}")
+    sec_ok = [s for s in SECTORS if s in ok]
+    print(f"  settori OK: {len(sec_ok)}/11 {sec_ok}")
+    print(f"  -> scritti in data/raw/eq_<sym>_1d.parquet (ADJUSTED_LAST, namespace dedicato).")
+    ib.disconnect()
+
+
+if __name__ == "__main__":
+    main()
@@ -0,0 +1,64 @@
+"""FETCH futures indice ORARI (ES/NQ/RTY) da IB -> data/raw/fut_<sym>_1h.parquet (UTC).
+
+Per il test onesto dell'idea "monitor Deribit / trade IB": serve il path INTRADAY del future indice
+(che si trada di notte) per misurare finestre overnight NON sovrapposte col segnale crypto.
+ContFuture orario, in chunk da 1 anno (IB limita le durate intraday). Convertito in UTC.
+Resumable (salta i parquet gia' scritti). Per RETURNS/lead-lag il back-adjust del ContFuture e' ok
+(i ritorni infra-contratto sono preservati; i gap di roll ~4/anno sono trascurabili).
+
+  uv run --with ib_async python scripts/research/fetch_ib_futures.py
+"""
+import sys, time
+from pathlib import Path
+import numpy as np, pandas as pd
+
+ROOT = Path(__file__).resolve().parents[2]
+RAW = ROOT / "data" / "raw"
+# sym -> exchange (indici US + esteri + commodity + bond per la ricerca cross-mercato oltre SP500)
+SYMS = {"ES": "CME", "NQ": "CME", "RTY": "CME",
+        "GC": "COMEX", "CL": "NYMEX", "HG": "COMEX", "ZN": "CBOT",
+        "ESTX50": "EUREX", "DAX": "EUREX", "NKD": "CME"}
+N_CHUNKS = 5   # (non usato: ContFuture non accetta endDateTime -> chiamata singola)
+
+
+def main():
+    from ib_async import IB, ContFuture
+    ib = IB()
+    try:
+        ib.connect("127.0.0.1", 4002, clientId=144, timeout=15)
+    except Exception as e:
+        print(f"[CONNESSIONE FALLITA] {repr(e)[:100]}"); sys.exit(1)
+    print(f"  acct {ib.managedAccounts()} | fetch futures orari -> data/raw/fut_*")
+    for sym, exc in SYMS.items():
+        out = RAW / f"fut_{sym.lower()}_1h.parquet"
+        if out.exists():
+            print(f"  {sym}: gia' su disco -> skip"); continue
+        cf = ContFuture(sym, exchange=exc)
+        try:
+            ib.qualifyContracts(cf)
+        except Exception as e:
+            print(f"  {sym}: qualify ERR {repr(e)[:60]}"); continue
+        # ContFuture NON accetta endDateTime (Error 10339) -> chiamata singola, durata massima (~3y orari)
+        try:
+            b = ib.reqHistoricalData(cf, endDateTime="", durationStr="4 Y", barSizeSetting="1 hour",
+                                     whatToShow="TRADES", useRTH=False, formatDate=1, timeout=150)
+        except Exception as e:
+            print(f"  {sym}: ERR {repr(e)[:60]}"); continue
+        if not b:
+            print(f"  {sym}: VUOTO"); continue
+        D = pd.DataFrame([(pd.Timestamp(x.date), x.open, x.high, x.low, x.close, x.volume) for x in b],
+                         columns=["ts", "open", "high", "low", "close", "volume"]).drop_duplicates("ts").sort_values("ts").reset_index(drop=True)
+        # -> UTC ms (robusto alla risoluzione us/ns: naive-UTC -> datetime64[ms] -> int64)
+        ts = pd.to_datetime(D["ts"], utc=True).dt.tz_convert("UTC").dt.tz_localize(None)
+        D["timestamp"] = ts.values.astype("datetime64[ms]").astype("int64")
+        D = D.drop(columns=["ts"])
+        D.to_parquet(out)
+        u = pd.to_datetime(D["timestamp"], unit="ms", utc=True)
+        print(f"  {sym}: SCRITTO {len(D)} barre  {u.iloc[0]} .. {u.iloc[-1]}  -> {out.name}")
+        time.sleep(1.5)
+    ib.disconnect()
+    print("  done.")
+
+
+if __name__ == "__main__":
+    main()
@@ -0,0 +1,170 @@
+"""FC01 — Funding-CARRY cross-sectional su Hyperliquid (backtest onesto, STAT-MODE).
+
+IPOTESI. Il funding dei perp e' un CASHFLOW (long pagano short quando f>0). Un book
+dollar-neutral che VENDE i perp ad alto funding e COMPRA quelli a basso funding INCASSA
+il premio di funding (carry). E' una fonte di ritorno DIVERSA dal trend (TP01) e — forse —
+dal momentum cross-sectional (XS01). Domanda chiave: e' un edge reale o solo XS01 travestito?
+(gli asset ad alto funding sono spesso quelli pompati = forti = quelli che XS01 COMPRA; qui li
+SHORTIAMO -> potenziale ANTI-correlazione con XS01, oppure il carry domina).
+
+DATI (certificati). funding orario reale HL (scripts/research/fetch_hl_funding.py, dal 2023-05) +
+prezzi HL 1d (data/raw/hl_*_1d.parquet, gli stessi di XS01). Universo = i 19 major di XS01.
+
+COSTRUZIONE (causale, come XS01). Ogni H giorni: segnale = media causale del funding giornaliero
+realizzato sugli ultimi L giorni (solo dati <= i-1). Rank cross-section; SHORT i k ad alto funding,
+LONG i k a basso (dollar-neutral). Ritorno del perp per un LONG = price_ret - funding (chi e' long
+paga il funding); quindi r_book[i] = sum_a w[i-1,a] * (price_ret[i,a] - funding_realizzato[i,a]),
+meno fee sul turnover (0.05%/lato, come XS01), poi vol-target 20%.
+
+GIUDIZIO (metodologia indurita). Standalone (FULL/in-sample/hold-out, DD, anni) + correlazione a
+TP01/XS01/VRP01 + marginal_vs_tp01 (gate: edge in-sample>=0.5, persistenza multi-cut, hedge-vs-alpha,
+noise-null) + UPLIFT vs XS01 (la domanda di overlap) + plateau su L/k/direzione.
+
+CAVEAT ONESTO PRE-RISULTATO: e' market-neutral a 10 gambe -> NON eseguibile a $600 (STAT-MODE come
+XS01/VRP01). Il deliverable e' "esiste un carry reale e ORTOGONALE a XS01?", non un deploy.
+"""
+import sys
+from pathlib import Path
+import numpy as np, pandas as pd
+
+ROOT = Path(__file__).resolve().parents[2]
+sys.path.insert(0, str(ROOT))
+sys.path.insert(0, str(ROOT / "scripts" / "research" / "alt"))
+
+from src.portfolio.sleeves import XS_UNIVERSE, _xsec_returns, _vrp_combo_returns, _HL_DIR
+import altlib as L
+from altlib import _sh, _dd_ret, _to_daily, _uplift_series, HOLDOUT, marginal_vs_tp01
+
+FEE_SIDE = 0.0005   # 0.10% RT / 2, come XS01
+
+
+def _load_panel():
+    """Ritorna (PX, FUND): due DataFrame daily allineati [date x asset] con prezzo e funding
+    giornaliero realizzato (somma oraria). Solo asset con ENTRAMBI i dati."""
+    px, fund = {}, {}
+    for sym in XS_UNIVERSE:
+        pp = _HL_DIR / f"hl_{sym.lower()}_1d.parquet"
+        fp = _HL_DIR / f"hlfund_{sym.lower()}_1h.parquet"
+        if not (pp.exists() and fp.exists()):
+            continue
+        dp = pd.read_parquet(pp)
+        px[sym] = pd.Series(dp["close"].values.astype(float),
+                            index=pd.to_datetime(dp["timestamp"], unit="ms", utc=True)).resample("1D").last()
+        df = pd.read_parquet(fp)  # index ts (orario, utc), col funding
+        fund[sym] = df["funding"].resample("1D").sum()
+    PX = pd.concat(px, axis=1).sort_index()
+    FUND = pd.concat(fund, axis=1).sort_index().reindex(PX.index)
+    # tieni solo le date con prezzi per tutti + funding noto (0 dove manca un giorno isolato)
+    common = PX.dropna(how="any").index.intersection(FUND.index)
+    return PX.loc[common], FUND.loc[common].fillna(0.0)
+
+
+def carry_returns(L_lb=7, H=10, k=5, direction="carry", target_vol=0.20,
+                  fee_side=FEE_SIDE) -> pd.Series:
+    """Serie daily netta del book funding-carry cross-sectional. direction='carry' shorta l'alto
+    funding (incassa il premio); 'anti' lo compra."""
+    PX, FUND = _load_panel()
+    idx = PX.index
+    px = PX.values; fnd = FUND.values
+    n, A = px.shape
+    dret = np.vstack([np.zeros(A), px[1:] / px[:-1] - 1.0])
+    # segnale = media causale del funding giornaliero sugli ultimi L giorni (shiftato di 1)
+    sig = pd.DataFrame(fnd, index=idx).rolling(L_lb, min_periods=max(3, L_lb // 2)).mean().shift(1).values
+    W = np.zeros((n, A)); w = np.zeros(A)
+    for i in range(n):
+        if i >= L_lb + 1 and i % H == 0 and np.isfinite(sig[i]).sum() >= 2 * k:
+            s = sig[i].copy()
+            order = np.argsort(np.where(np.isfinite(s), s, np.nan))
+            order = order[np.isfinite(s[order])]
+            if len(order) >= 2 * k:
+                w = np.zeros(A)
+                lo, hi = order[:k], order[-k:]   # lo=basso funding, hi=alto funding
+                if direction == "carry":
+                    w[hi] = -0.5 / k; w[lo] = +0.5 / k     # SHORT alto funding (incassa), LONG basso
+                else:
+                    w[hi] = +0.5 / k; w[lo] = -0.5 / k
+        W[i] = w
+    # ritorno del perp per un LONG = price_ret - funding realizzato
+    perp_ret = dret - fnd
+    gross = np.zeros(n); gross[1:] = np.sum(W[:-1] * perp_ret[1:], axis=1)
+    turn = np.zeros(n); turn[0] = np.abs(W[0]).sum(); turn[1:] = np.abs(np.diff(W, axis=0)).sum(axis=1)
+    net = gross - turn * fee_side
+    s = pd.Series(net, index=idx)
+    rv = s.rolling(30, min_periods=15).std().shift(1) * np.sqrt(365.25)
+    scale = np.clip(np.nan_to_num(target_vol / rv.replace(0, np.nan).values, nan=0.0), 0, 3.0)
+    return pd.Series(s.values * scale, index=idx)
+
+
+def _stats(s: pd.Series) -> dict:
+    s = _to_daily(s)
+    h = s[s.index >= HOLDOUT]; isamp = s[s.index < HOLDOUT]
+    yrs = {y: round(_sh(s[s.index.year == y]), 2) for y in sorted(set(s.index.year))}
+    return dict(n=len(s), full=round(_sh(s), 2), insample=round(_sh(isamp), 2) if len(isamp) > 30 else None,
+                hold=round(_sh(h), 2) if len(h) > 30 else None, dd=round(_dd_ret(s), 3),
+                ann_ret=round(float(s.mean() * 365.25), 3), yearly=yrs)
+
+
+def main():
+    print("=" * 96)
+    print("  FC01 — FUNDING-CARRY cross-sectional su Hyperliquid (STAT-MODE)")
+    print("=" * 96)
+    PX, FUND = _load_panel()
+    print(f"  panel: {PX.shape[1]} asset x {len(PX)} giorni  [{PX.index[0].date()} .. {PX.index[-1].date()}]")
+    print(f"  asset: {list(PX.columns)}")
+    # funding medio annualizzato per asset (dispersione = materia prima del carry)
+    fann = (FUND.mean() * 365.25 * 100).round(1).sort_values(ascending=False)
+    print(f"  funding annualizzato% (carry teorico long-pays): "
+          f"max {fann.index[0]} {fann.iloc[0]:+.1f}  min {fann.index[-1]} {fann.iloc[-1]:+.1f}  "
+          f"mediana {fann.median():+.1f}  spread {fann.iloc[0]-fann.iloc[-1]:.1f}")
+
+    base = carry_returns()
+    print("\n  --- STANDALONE (config base L=7 H=10 k=5, direction=carry) ---")
+    st = _stats(base)
+    print(f"    FULL Sh {st['full']}  in-sample {st['insample']}  HOLD {st['hold']}  DD {st['dd']*100:.1f}%  "
+          f"ann.ret {st['ann_ret']*100:+.1f}%  ({st['n']}g)")
+    print(f"    per anno: {st['yearly']}")
+
+    # correlazioni vs gli sleeve attivi
+    print("\n  --- CORRELAZIONE vs sleeve attivi (daily, overlap comune) ---")
+    refs = {"TP01": L.tp01_baseline_daily(), "XS01": _to_daily(_xsec_returns()),
+            "VRP01": _to_daily(_vrp_combo_returns())}
+    bd = _to_daily(base)
+    for nm, r in refs.items():
+        J = pd.concat({"c": bd, "r": r}, axis=1, join="inner").dropna()
+        c = round(float(J["c"].corr(J["r"])), 3) if len(J) > 30 else None
+        print(f"    corr(FC01, {nm}) = {c}   (overlap {len(J)}g)")
+
+    # marginal vs TP01 (verdetto indurito completo)
+    print("\n  --- MARGINAL vs TP01 (scorer indurito) ---")
+    m = marginal_vs_tp01(bd)
+    for key in ("marginal_verdict", "corr_full", "cand_full_sharpe", "cand_insample_sharpe",
+                "has_insample_edge", "multicut_persistent", "is_hedge", "null_pctl_insample"):
+        print(f"    {key:22} = {m.get(key)}")
+    print(f"    blend w25: {m.get('blends', {}).get('w25')}")
+    print(f"    multicut_uplift: {m.get('multicut_uplift')}")
+
+    # UPLIFT vs XS01 (la domanda di overlap): XS01 da solo vs blend(XS01, FC01)
+    print("\n  --- UPLIFT vs XS01 (aggiunge a XS01 o e' ridondante?) ---")
+    xs = refs["XS01"]
+    J = pd.concat({"xs": xs, "fc": bd}, axis=1, join="inner").dropna()
+    JH = J[J.index >= HOLDOUT]
+    for w in (0.25, 0.5):
+        bf = _sh((1 - w) * J["xs"] + w * J["fc"]) - _sh(J["xs"])
+        bh = (_sh((1 - w) * JH["xs"] + w * JH["fc"]) - _sh(JH["xs"])) if len(JH) > 30 else None
+        print(f"    w={w}: uplift FULL {bf:+.3f}  HOLD {bh:+.3f}" if bh is not None
+              else f"    w={w}: uplift FULL {bf:+.3f}")
+    print(f"    XS01 standalone: FULL {_sh(J['xs']):.2f}  | FC01 standalone su overlap: {_sh(J['fc']):.2f}")
+
+    # PLATEAU su L, k, direzione
+    print("\n  --- PLATEAU (FULL / in-sample / HOLD Sharpe) ---")
+    print(f"    {'cfg':22} {'FULL':>6} {'in-s':>6} {'HOLD':>6} {'DD%':>6}")
+    for direction in ("carry", "anti"):
+        for Llb in (3, 7, 14, 30):
+            for k in (3, 5):
+                s = _stats(carry_returns(L_lb=Llb, k=k, direction=direction))
+                tag = f"{direction} L={Llb} k={k}"
+                print(f"    {tag:22} {str(s['full']):>6} {str(s['insample']):>6} {str(s['hold']):>6} {s['dd']*100:>5.1f}")
+
+
+if __name__ == "__main__":
+    main()
@@ -0,0 +1,108 @@
+"""LEAD-LAG GENERICO non-sovrapposto: crypto[T-S -> T] predice future[T -> T+H]? (ogni mercato/fuso).
+
+Market-agnostic. Per ogni giorno, entrata a ora T (UTC): segnale = crypto nella finestra [T-S, T]
+(finisce all'entrata), cattura = future nella finestra SUCCESSIVA [T, T+H] (non sovrapposta).
+Controllo = moto PROPRIO del future [T-S, T] -> isola se il crypto AGGIUNGE (anticipa) oltre il
+momentum del future. Sweep su T (copre apertura Europa ~07h, USA ~13h, Asia ~00h) e H.
+
+TRADE: sign(crypto[T-S,T]) * future[T,T+H] - costo. Sharpe sqrt(252), per-anno, OOS 2024+.
+Dati: data/raw/fut_*_1h.parquet (UTC) + crypto 1h. Solo cache, nessun IB.
+"""
+import sys, glob
+from pathlib import Path
+import numpy as np, pandas as pd
+
+ROOT = Path(__file__).resolve().parents[2]
+RAW = ROOT / "data" / "raw"
+sys.path.insert(0, str(ROOT)); sys.path.insert(0, str(ROOT / "scripts" / "research"))
+from crypto_lead_harness import crypto_hourly, at
+
+OOS = pd.Timestamp("2024-01-01", tz="UTC"); COST = 0.0002
+
+
+def fut_hourly(sym):
+    d = pd.read_parquet(RAW / f"fut_{sym.lower()}_1h.parquet")
+    return pd.Series(d["close"].astype(float).values, index=pd.to_datetime(d["timestamp"], unit="ms", utc=True)).sort_index()
+
+
+def _sh(r):
+    r = np.asarray(r, float); r = r[np.isfinite(r)]
+    return float(np.mean(r) / np.std(r) * np.sqrt(252)) if len(r) > 5 and np.std(r) > 0 else 0.0
+
+
+def run(fut, bc, T, S, H):
+    days = pd.date_range(fut.index[0].normalize(), fut.index[-1].normalize(), freq="D", tz="UTC")
+    rows = []
+    for D in days:
+        te = D + pd.Timedelta(hours=T)
+        ts = te - pd.Timedelta(hours=S)
+        tx = te + pd.Timedelta(hours=H)
+        f0, f1 = at(fut, ts), at(fut, te); f2 = at(fut, tx)
+        c0, c1 = at(bc, ts), at(bc, te)
+        if not all(np.isfinite(v) and v > 0 for v in (f0, f1, f2, c0, c1)):
+            continue
+        rows.append((D, c1/c0 - 1, f1/f0 - 1, f2/f1 - 1))
+    if len(rows) < 120:
+        return None
+    Dd = pd.DataFrame(rows, columns=["d", "csig", "fctrl", "cap"]).set_index("d")
+    # filtra giorni in cui la cattura e' identicamente 0 (mercato chiuso, prezzo stale)
+    Dd = Dd[Dd["cap"].abs() > 1e-9]
+    if len(Dd) < 120:
+        return None
+    x, ctrl, y = Dd["csig"].values, Dd["fctrl"].values, Dd["cap"].values
+
+    def z(a):
+        s = a.std(); return (a - a.mean()) / s if s > 0 else a * 0
+    X = np.column_stack([np.ones(len(y)), z(x), z(ctrl)])
+    beta, *_ = np.linalg.lstsq(X, z(y), rcond=None)
+    resid = z(y) - X @ beta; dof = max(len(y) - 3, 1)
+    se = np.sqrt(np.sum(resid**2) / dof * np.diag(np.linalg.inv(X.T @ X)))
+    t_c = float(beta[1] / se[1]) if se[1] > 0 else 0.0
+    C = np.sign(x) * y - COST
+    m = Dd.index >= OOS
+    yrs = Dd.index.year.values
+    py = {int(v): round(_sh(C[yrs == v]), 2) for v in sorted(set(yrs)) if (yrs == v).sum() >= 30}
+    pos = sum(1 for v in py.values() if v > 0)
+    return dict(T=T, H=H, n=len(Dd), t_crypto=round(t_c, 2), sh_full=round(_sh(C), 2),
+                sh_oos=round(_sh(C[m]), 2), ann=round(float(np.nanmean(C) * 252 * 100), 1),
+                years_pos=pos, years_tot=len(py), per_year=py)
+
+
+def main():
+    syms = sorted(p.name[4:-11].upper() for p in RAW.glob("fut_*_1h.parquet"))
+    print("=" * 98)
+    print(f"  LEAD-LAG GENERICO non-sovrapposto — futures: {syms}")
+    print("=" * 98)
+    print("  crypto[T-8h -> T] -> future[T -> T+6h], controllo=moto proprio future. net 2bps, OOS2024+\n")
+    bcs = {l: crypto_hourly(l) for l in ("BTC", "ETH")}
+    winners = []
+    for sym in syms:
+        fut = fut_hourly(sym)
+        best = None
+        for lead in ("BTC", "ETH"):
+            for T in (0, 4, 8, 12, 16, 20):
+                r = run(fut, bcs[lead], T, 8, 6)
+                if not r:
+                    continue
+                r["sym"] = sym; r["lead"] = lead
+                if best is None or r["sh_oos"] > best["sh_oos"]:
+                    best = r
+                # raccogli i forti (crypto significativo E robusto)
+                if r["t_crypto"] >= 2.5 and r["sh_oos"] > 0.5 and r["years_pos"] == r["years_tot"]:
+                    winners.append(r)
+        if best:
+            print(f"  {sym:7} miglior: {best['lead']}->T{best['T']}h: t_crypto {best['t_crypto']:+.1f} "
+                  f"Sh full {best['sh_full']:+.2f} OOS {best['sh_oos']:+.2f} ann {best['ann']:+.1f}% "
+                  f"{best['years_pos']}/{best['years_tot']}y {best['per_year']}")
+    print("\n  --- CANDIDATI FORTI (t_crypto>=2.5, OOS>0.5, tutti gli anni positivi) ---")
+    if not winners:
+        print("    NESSUNO. -> nessuna anticipazione crypto->future robusta oltre il rumore/beta.")
+    else:
+        winners.sort(key=lambda r: r["sh_oos"], reverse=True)
+        for w in winners[:10]:
+            print(f"    {w['sym']:7} {w['lead']}->T{w['T']}h H{w['H']}: t_crypto {w['t_crypto']} "
+                  f"Sh OOS {w['sh_oos']} full {w['sh_full']} ann {w['ann']}% {w['years_pos']}/{w['years_tot']}y {w['per_year']}")
+
+
+if __name__ == "__main__":
+    main()
@@ -0,0 +1,116 @@
+"""TEST ONESTO finestre NON sovrapposte: crypto[notte presto] -> future indice[notte tardi].
+
+L'idea "monitor Deribit / trade IB" e' valida SOLO se il crypto anticipa il moto SUCCESSIVO del future
+(non lo stesso intervallo = look-ahead). Qui:
+  entrata a T (ora UTC nella notte, equity cash chiuso): osservato crypto fino a T.
+  segnale  = crypto[P 21:00 -> T]            (info nota a T)
+  controllo= future[P 21:00 -> T]            (il moto PROPRIO del future fino a T)
+  cattura  = future[T -> D 13:00]            (cio' che catturi entrando a T, fino a ~apertura cash)
+TEST: il segnale crypto predice la cattura INCREMENTALMENTE al controllo? (crypto vede prima del future?)
+TRADE: long/short future su sign(crypto[P21:00->T]), cattura future[T->open], net ~2bps. Sharpe/anno/OOS.
+Confronto col baseline sign(future[P21:00->T]) (momentum proprio del future) per isolare il valore crypto.
+
+Dati: data/raw/fut_<sym>_1h.parquet (UTC) + crypto 1h. sqrt(252).
+"""
+import sys, argparse, json
+from pathlib import Path
+import numpy as np, pandas as pd
+
+ROOT = Path(__file__).resolve().parents[2]
+RAW = ROOT / "data" / "raw"
+sys.path.insert(0, str(ROOT)); sys.path.insert(0, str(ROOT / "scripts" / "research"))
+from crypto_lead_harness import crypto_hourly, at
+
+OOS = pd.Timestamp("2024-01-01", tz="UTC"); COST = 0.0002
+CLOSE_H = 21; OPEN_H = 13
+
+
+def fut_hourly(sym):
+    d = pd.read_parquet(RAW / f"fut_{sym.lower()}_1h.parquet")
+    return pd.Series(d["close"].astype(float).values, index=pd.to_datetime(d["timestamp"], unit="ms", utc=True)).sort_index()
+
+
+def _sh(r):
+    r = np.asarray(r, float); r = r[np.isfinite(r)]
+    return float(np.mean(r) / np.std(r) * np.sqrt(252)) if len(r) > 5 and np.std(r) > 0 else 0.0
+
+
+def run(sym="ES", lead="BTC", h_entry=6):
+    fut = fut_hourly(sym); bc = crypto_hourly(lead)
+    days = pd.date_range(fut.index[0].normalize(), fut.index[-1].normalize(), freq="B", tz="UTC")
+    rows = []
+    for k in range(1, len(days)):
+        D = days[k]; P = days[k-1]
+        t_pc = P + pd.Timedelta(hours=CLOSE_H)        # P close 21:00
+        t_e = D + pd.Timedelta(hours=h_entry)          # entrata T
+        t_o = D + pd.Timedelta(hours=OPEN_H)           # ~apertura cash 13:00
+        fp, fe, fo = at(fut, t_pc), at(fut, t_e), at(fut, t_o)
+        cp, ce = at(bc, t_pc), at(bc, t_e)
+        if not all(np.isfinite(v) and v > 0 for v in (fp, fe, fo, cp, ce)):
+            continue
+        crypto_sig = ce / cp - 1.0          # crypto P21:00 -> T
+        fut_ctrl = fe / fp - 1.0            # future P21:00 -> T (controllo)
+        capture = fo / fe - 1.0             # future T -> open (cio' che catturi)
+        rows.append((D, crypto_sig, fut_ctrl, capture))
+    if len(rows) < 100:
+        return {"sym": sym, "lead": lead, "h_entry": h_entry, "err": f"n={len(rows)}"}
+    Dd = pd.DataFrame(rows, columns=["d", "csig", "fctrl", "cap"]).set_index("d")
+    x, ctrl, y = Dd["csig"].values, Dd["fctrl"].values, Dd["cap"].values
+
+    def z(a):
+        s = a.std(); return (a - a.mean()) / s if s > 0 else a * 0
+    # incrementale: cap ~ crypto + future_own_move
+    X = np.column_stack([np.ones(len(y)), z(x), z(ctrl)])
+    beta, *_ = np.linalg.lstsq(X, z(y), rcond=None)
+    resid = z(y) - X @ beta; dof = max(len(y) - 3, 1)
+    se = np.sqrt(np.sum(resid**2) / dof * np.diag(np.linalg.inv(X.T @ X)))
+    t_crypto = float(beta[1] / se[1]) if se[1] > 0 else 0.0
+    t_futown = float(beta[2] / se[2]) if se[2] > 0 else 0.0
+    # trade: crypto-signal vs future-own-signal
+    C_crypto = np.sign(x) * y - COST
+    C_futown = np.sign(ctrl) * y - COST
+    m = Dd.index >= OOS
+    yrs = Dd.index.year.values
+    py = {int(yv): round(_sh(C_crypto[yrs == yv]), 2) for yv in sorted(set(yrs)) if (yrs == yv).sum() >= 30}
+    return {"sym": sym, "lead": lead, "h_entry": h_entry, "n": len(Dd),
+            "corr_crypto_cap": round(float(np.corrcoef(x, y)[0, 1]), 3),
+            "t_crypto_incr": round(t_crypto, 2), "t_futown_incr": round(t_futown, 2),
+            "sh_crypto_full": round(_sh(C_crypto), 2), "sh_crypto_oos": round(_sh(C_crypto[m]), 2),
+            "sh_futown_full": round(_sh(C_futown), 2),
+            "ann_crypto_pct": round(float(np.nanmean(C_crypto) * 252 * 100), 1),
+            "per_year": py}
+
+
+def main():
+    ap = argparse.ArgumentParser()
+    ap.add_argument("--syms", default="ES,NQ,RTY")
+    ap.add_argument("--leads", default="BTC,ETH")
+    ap.add_argument("--entries", default="0,3,6,9")
+    args = ap.parse_args()
+    print("=" * 96)
+    print("  FUTURE OVERNIGHT — crypto[P21:00->T] predice future[T->open]? (finestre NON sovrapposte)")
+    print("=" * 96)
+    print("  cattura = future[T->open]; controllo = future[P21:00->T]; t_crypto_incr = crypto AL NETTO del future. net 2bps\n")
+    best = []
+    for sym in args.syms.split(","):
+        for lead in args.leads.split(","):
+            for h in [int(x) for x in args.entries.split(",")]:
+                r = run(sym, lead, h)
+                if "err" in r:
+                    print(f"  {sym}<-{lead} T={h}h: {r['err']}"); continue
+                print(f"  {sym}<-{lead} T={h:>2}h UTC: n={r['n']} corr {r['corr_crypto_cap']:+.3f} | "
+                      f"t_crypto(incr) {r['t_crypto_incr']:+.1f} t_futOwn {r['t_futown_incr']:+.1f} | "
+                      f"trade crypto Sh {r['sh_crypto_full']:+.2f} (OOS {r['sh_crypto_oos']:+.2f}) ann {r['ann_crypto_pct']:+.1f}% | "
+                      f"futOwn Sh {r['sh_futown_full']:+.2f}")
+                best.append(r)
+    best.sort(key=lambda r: r.get("sh_crypto_oos", -9), reverse=True)
+    print("\n  --- migliori per Sharpe OOS (trade su segnale crypto) ---")
+    for r in best[:5]:
+        print(f"    {r['sym']}<-{r['lead']} T={r['h_entry']}h: OOS {r['sh_crypto_oos']} full {r['sh_crypto_full']} "
+              f"t_crypto {r['t_crypto_incr']} per-anno {r['per_year']}")
+    print("\n  NB: t_crypto_incr alto E sh_crypto > sh_futOwn => il crypto anticipa il future (idea valida).")
+    print("      t_crypto ~0 o sh_crypto ~ futOwn => e' solo momentum del future, il crypto non aggiunge.")
+
+
+if __name__ == "__main__":
+    main()
@@ -0,0 +1,95 @@
+"""IB EQUITIES/ETF DATA PROBE — certifica cosa il paper IB dà per la ricerca su azioni/ETF.
+
+Gemello equity di certify_feed.py: PRIMA il dato (cosa c'è, quanto indietro, aggiustato per
+dividendi/split?, cosa costa), POI la strategia. Disciplina v2.0.0.
+
+Universo candidato per la prima ricerca equity (cross-sectional momentum / trend, l'edge "noioso e
+robusto" più plausibile in un mercato efficiente):
+  * 11 SPDR settoriali (XLK..XLC) — universo canonico del momentum cross-section settoriale;
+  * ETF broad / macro (SPY QQQ IWM TLT GLD HYG) — per trend e risk-on/off;
+  * 2 azioni (AAPL MSFT) per tarare profondità/qualità.
+
+Per ogni simbolo: profondità storica daily con whatToShow=ADJUSTED_LAST (split+dividendi, OBBLIGATORIO
+per un backtest equity onesto) e TRADES (raw), + flag se scatta errore di subscription market-data.
+
+  uv run --with ib_async python scripts/research/ib_equities_probe.py
+"""
+import argparse, sys
+
+SECTORS = ["XLK", "XLF", "XLE", "XLV", "XLI", "XLP", "XLY", "XLU", "XLB", "XLRE", "XLC"]
+BROAD = ["SPY", "QQQ", "IWM", "TLT", "GLD", "HYG"]
+STOCKS = ["AAPL", "MSFT"]
+
+
+def main():
+    ap = argparse.ArgumentParser()
+    ap.add_argument("--host", default="127.0.0.1")
+    ap.add_argument("--port", type=int, default=4002)
+    ap.add_argument("--client-id", type=int, default=88)
+    ap.add_argument("--years", default="20 Y", help="durata storica da richiedere")
+    args = ap.parse_args()
+
+    try:
+        from ib_async import IB, Stock
+    except Exception:
+        print("ib_async non importabile. Esegui con:  uv run --with ib_async python ...")
+        sys.exit(2)
+
+    ib = IB()
+    try:
+        ib.connect(args.host, args.port, clientId=args.client_id, timeout=15)
+    except Exception as e:
+        print(f"[CONNESSIONE FALLITA] {args.host}:{args.port} -> {repr(e)[:140]}")
+        sys.exit(1)
+
+    print("=" * 96)
+    print(f"  IB EQUITIES/ETF PROBE — {args.host}:{args.port} | acct {ib.managedAccounts()} | depth req {args.years}")
+    print("=" * 96)
+
+    universe = [("SECTOR", s) for s in SECTORS] + [("BROAD", s) for s in BROAD] + [("STOCK", s) for s in STOCKS]
+    print(f"  {'sym':6} {'tipo':7} {'ADJUSTED_LAST':>26} {'TRADES':>22}  note")
+    rows = []
+    for cat, sym in universe:
+        con = Stock(sym, "SMART", "USD")
+        try:
+            cds = ib.reqContractDetails(con)
+            if not cds:
+                print(f"  {sym:6} {cat:7} {'-- no contract --':>26}")
+                continue
+        except Exception as e:
+            print(f"  {sym:6} {cat:7} ERR resolve {repr(e)[:40]}")
+            continue
+
+        def hist(what):
+            try:
+                b = ib.reqHistoricalData(con, endDateTime="", durationStr=args.years,
+                                         barSizeSetting="1 day", whatToShow=what,
+                                         useRTH=True, formatDate=1, timeout=45)
+                if not b:
+                    return "0 barre", None
+                return f"{len(b)}b {b[0].date}..{b[-1].date}", b
+            except Exception as e:
+                return f"ERR {repr(e)[:30]}", None
+
+        adj_s, adj_b = hist("ADJUSTED_LAST")
+        trd_s, _ = hist("TRADES")
+        note = ""
+        if "ERR" in adj_s or "0 barre" in adj_s:
+            note = "subscription? prova delayed"
+        print(f"  {sym:6} {cat:7} {adj_s:>26} {trd_s:>22}  {note}")
+        if adj_b:
+            rows.append((sym, len(adj_b), str(adj_b[0].date), str(adj_b[-1].date)))
+
+    print("-" * 96)
+    if rows:
+        depth = min(r[1] for r in rows); start = max(r[2] for r in rows)
+        print(f"  CERTIFICABILI (ADJUSTED_LAST): {len(rows)}/{len(universe)} | profondità comune ~{depth}b | start comune {start}")
+        print(f"  -> per un backtest cross-sectional servono date allineate: lo start comune e' il limite.")
+    else:
+        print("  NESSUN simbolo ha reso storia ADJUSTED — probabile mancanza market-data subscription.")
+        print("  Ripiego: whatToShow='TRADES' (raw, non adj) o dati 'delayed' / fonte esterna certificabile.")
+    ib.disconnect()
+
+
+if __name__ == "__main__":
+    main()
@@ -0,0 +1,108 @@
+"""IB DATA PROBE — enumera cosa un conto paper Interactive Brokers espone (dati storici).
+
+NON e' una strategia: e' lo scan di FATTIBILITA' DATI, gemello di certify_feed.py per il mondo IB.
+Disciplina v2.0.0: prima il dato (cosa c'e', quanto indietro, che qualita', cosa costa), poi la
+strategia. "Solo dati, decido dopo".
+
+PREREQUISITO: una sessione IB Gateway/TWS PAPER loggata e raggiungibile (default 127.0.0.1:4002).
+  Tipico: avvii IB Gateway (Paper) sul tuo PC con API abilitata su 4002, poi reverse-tunnel
+  SSH verso questo server:  ssh -R 4002:localhost:4002 utente@server
+ESECUZIONE (senza sporcare le dipendenze del progetto):
+  uv run --with ib_async python scripts/research/ib_probe.py
+  uv run --with ib_async python scripts/research/ib_probe.py --port 7497   # TWS paper
+
+Cosa fa, in ordine, e si ferma con diagnosi chiara al primo errore:
+  (1) connette e stampa server version + account paper;
+  (2) risolve un set di contratti rilevanti per QUESTO progetto:
+        - CME crypto: BTC (5 BTC), MBT (micro 0.1 BTC), ETH, MET (micro);  -> per il BASIS/carry
+        - spot crypto Paxos (se abilitato): BTC, ETH;
+        - 2 azioni/ETF di riferimento (SPY, AAPL) per tarare durate/qualita';
+  (3) per ogni contratto risolto: chiede un piccolo storico (durata breve, 1 day bars) e riporta
+      n barre, range, e se scatta un errore di SUBSCRIPTION mancante (codice 354/10089/10090...);
+  (4) sintesi: cosa e' scaricabile GRATIS su paper vs cosa richiede market-data a pagamento.
+"""
+import argparse, sys
+
+def main():
+    ap = argparse.ArgumentParser()
+    ap.add_argument("--host", default="127.0.0.1")
+    ap.add_argument("--port", type=int, default=7497, help="7497=TWS paper (default), 4002=GW paper, 4001/7496=live")
+    ap.add_argument("--client-id", type=int, default=77)
+    args = ap.parse_args()
+
+    try:
+        from ib_async import IB, Future, Stock, Crypto, util
+    except Exception:
+        print("ib_async non importabile. Esegui con:  uv run --with ib_async python scripts/research/ib_probe.py")
+        sys.exit(2)
+
+    ib = IB()
+    try:
+        ib.connect(args.host, args.port, clientId=args.client_id, timeout=15)
+    except Exception as e:
+        print(f"[CONNESSIONE FALLITA] {args.host}:{args.port} -> {repr(e)[:160]}")
+        print("  Verifica: IB Gateway/TWS Paper acceso, API abilitata, porta giusta, tunnel attivo.")
+        sys.exit(1)
+
+    print("=" * 90)
+    print(f"  IB DATA PROBE — connesso {args.host}:{args.port} | serverVersion={ib.client.serverVersion()}")
+    try:
+        accts = ib.managedAccounts()
+        print(f"  account: {accts}  (paper se inizia per 'D' tipicamente)")
+    except Exception as e:
+        print(f"  account: ? ({repr(e)[:60]})")
+    print("=" * 90)
+
+    # (2) contratti rilevanti
+    candidates = []
+    # CME crypto futures: lasciamo che IB scelga il front-month (no expiry -> reqContractDetails)
+    candidates += [("CME BTC fut", Future("BTC", exchange="CME")),
+                   ("CME MBT micro", Future("MBT", exchange="CME")),
+                   ("CME ETH fut", Future("ETH", exchange="CME")),
+                   ("CME MET micro", Future("MET", exchange="CME"))]
+    # spot crypto Paxos (puo' non essere abilitato su paper)
+    candidates += [("Paxos BTC", Crypto("BTC", exchange="PAXOS", currency="USD")),
+                   ("Paxos ETH", Crypto("ETH", exchange="PAXOS", currency="USD"))]
+    # riferimenti equity
+    candidates += [("SPY ETF", Stock("SPY", "SMART", "USD")),
+                   ("AAPL", Stock("AAPL", "SMART", "USD"))]
+
+    resolved = []
+    print("\n  (A) RISOLUZIONE CONTRATTI")
+    for label, c in candidates:
+        try:
+            cds = ib.reqContractDetails(c)
+            if not cds:
+                print(f"    {label:16} -> NESSUN match")
+                continue
+            # per i futures prendi la scadenza piu' vicina disponibile
+            cd = sorted(cds, key=lambda d: getattr(d.contract, "lastTradeDateOrContractMonth", "") or "")[0]
+            con = cd.contract
+            extra = f" exp={con.lastTradeDateOrContractMonth}" if getattr(con, "lastTradeDateOrContractMonth", "") else ""
+            print(f"    {label:16} -> OK  {con.localSymbol or con.symbol} {con.exchange}{extra}  (n match={len(cds)})")
+            resolved.append((label, con))
+        except Exception as e:
+            print(f"    {label:16} -> ERR {repr(e)[:70]}")
+
+    # (3) prova storico breve
+    print("\n  (B) STORICO DI PROVA (durata 10 D, barre 1 day)")
+    for label, con in resolved:
+        try:
+            bars = ib.reqHistoricalData(con, endDateTime="", durationStr="10 D",
+                                        barSizeSetting="1 day", whatToShow="TRADES",
+                                        useRTH=False, formatDate=1, timeout=30)
+            if not bars:
+                print(f"    {label:16} -> 0 barre (forse serve subscription o whatToShow diverso)")
+            else:
+                print(f"    {label:16} -> {len(bars)} barre  {bars[0].date} .. {bars[-1].date}  close={bars[-1].close}")
+        except Exception as e:
+            print(f"    {label:16} -> ERR {repr(e)[:90]}")
+
+    print("\n  (C) NOTE")
+    print("    - errori 354/10089/10090/10168 = market-data subscription mancante (paper la eredita dal live).")
+    print("    - per il BASIS/carry servono i MULTIPLI futures (front+next) -> poi reqContractDetails senza filtro expiry.")
+    ib.disconnect()
+
+
+if __name__ == "__main__":
+    main()
@@ -0,0 +1,101 @@
+"""STOPS LAB — protezioni CLASSICHE (stop-loss) sul combo vs la guardia-DD morbida.
+
+Confronta su Sharpe/MaxDD/2022/CAGR/NumTrades/time-in-market:
+  - baseline
+  - guardia-DD morbida (de-risk a 0.4x, gia' scelta)
+  - TRAILING STOP duro (uscita TOTALE) a -4/-6/-8% dal picco, re-entry su nuovo massimo
+  - TRAILING STOP con re-entry su RECUPERO (DD < meta' soglia)
+  - STOP MENSILE (flat per il resto del mese se perdita mensile > X%)
+  - VOL STOP (de-risk se vol realizzata 30g > 90 pctl espandente)
+Tesi da verificare: lo stop DURO taglia il DD ma fa whipsaw nel grind 2022 (Sharpe/CAGR peggiori,
+piu' trade). Dati: combo_daily (cache). sqrt(252).
+"""
+import sys
+from pathlib import Path
+import numpy as np, pandas as pd
+ROOT = Path(__file__).resolve().parents[2]
+sys.path.insert(0, str(ROOT)); sys.path.insert(0, str(ROOT / "scripts" / "research"))
+from combo_yearly_report import combo_daily
+ANN = np.sqrt(252.0)
+
+
+def _sh(r): r = np.asarray(pd.Series(r).dropna(), float); return float(np.mean(r)/np.std(r)*ANN) if len(r)>5 and np.std(r)>0 else 0.0
+def _dd(r): eq=np.cumprod(1+np.asarray(r,float)); pk=np.maximum.accumulate(eq); return float(np.max((pk-eq)/pk)) if len(eq) else 0.0
+def _yr(r,y): return float(np.prod(1+r[r.index.year==y].values)-1) if (r.index.year==y).any() else 0.0
+def _cagr(r): r=r.dropna(); return (np.prod(1+r.values))**(252/len(r))-1
+def _ntr(expo): return int((np.abs(np.diff(expo, prepend=expo[0]))>1e-9).sum())   # cambi di esposizione = trade
+
+
+def expo_softguard(r, trig=0.04, lvl=0.4):
+    rv=r.values; eq=np.cumprod(1+rv); pk=np.maximum.accumulate(eq); e=np.ones(len(rv)); on=True
+    for i in range(1,len(rv)):
+        dd=(pk[i-1]-eq[i-1])/pk[i-1] if pk[i-1]>0 else 0
+        if dd>trig: on=False
+        if dd<trig*0.4: on=True
+        e[i]=1.0 if on else lvl
+    return e
+
+
+def expo_trailstop(r, trig=0.06, reentry="newhigh"):
+    """Stop DURO trailing (uscita TOTALE) — test EQUO: trigger/re-entry sul MERCATO (NAV sempre-
+    investito di riferimento, non sull'equity stoppata che si congela). Esci se DD del NAV > trig;
+    re-entry 'newhigh' = NAV torna al picco; 'recover' = DD del NAV < trig/2."""
+    rv=r.values; n=len(rv)
+    nav=np.cumprod(1+rv); pk=np.maximum.accumulate(nav); dd=(pk-nav)/pk
+    e=np.ones(n); on=True
+    for i in range(1,n):
+        d=dd[i-1]
+        if on and d>trig:
+            on=False
+        elif not on:
+            if reentry=="newhigh" and nav[i-1]>=pk[i-1]-1e-12: on=True
+            elif reentry=="recover" and d<trig*0.5: on=True
+        e[i]=1.0 if on else 0.0
+    return e
+
+
+def expo_monthly(r, trig=0.05):
+    e=np.ones(len(r)); idx=r.index; cur=None; mret=1.0; stopped=False
+    for i in range(len(r)):
+        ym=(idx[i].year,idx[i].month)
+        if ym!=cur: cur=ym; mret=1.0; stopped=False
+        if stopped: e[i]=0.0; continue
+        mret*=(1+r.values[i])
+        if mret-1 < -trig: stopped=True
+    return e
+
+
+def expo_volstop(r, win=30, pctl=0.90):
+    rv=pd.Series(r.values,index=r.index); v=rv.rolling(win,min_periods=15).std()*ANN
+    thr=v.expanding(min_periods=60).quantile(pctl).shift(1)
+    e=np.where((v.shift(1)>thr).values, 0.4, 1.0); e=np.nan_to_num(e,nan=1.0)
+    return e
+
+
+def show(name, r, expo):
+    g=pd.Series(expo*r.values,index=r.index)
+    tim=float((expo>1e-9).mean())*100
+    print(f"  {name:30} Sh {_sh(g):>5.2f}  MaxDD {_dd(g.values)*100:>4.1f}%  2022 {_yr(g,2022)*100:>+5.1f}%  "
+          f"CAGR {_cagr(g)*100:>+5.1f}%  trades {_ntr(expo):>4}  inMkt {tim:>3.0f}%")
+
+
+def main():
+    print("="*104); print("  STOPS LAB — protezioni classiche (SL) vs guardia-DD morbida (combo TP01+GTAA, 2019-26)"); print("="*104)
+    r=combo_daily()
+    print(f"\n  {'(esposizione media applicata ai rendimenti del combo)':<30}")
+    show("baseline (nessuna)", r, np.ones(len(r)))
+    print("  --- guardia-DD MORBIDA (de-risk a 0.4x) ---")
+    show("soft-guard -4%", r, expo_softguard(r,0.04))
+    print("  --- STOP-LOSS DURO (uscita totale, trailing dal picco) ---")
+    for t in (0.04,0.06,0.08):
+        show(f"trail-stop -{t*100:.0f}% (re:newhigh)", r, expo_trailstop(r,t,"newhigh"))
+    show("trail-stop -6% (re:recover)", r, expo_trailstop(r,0.06,"recover"))
+    print("  --- altri classici ---")
+    show("stop mensile -5%", r, expo_monthly(r,0.05))
+    show("vol-stop (30g, >90pctl)", r, expo_volstop(r))
+    print("\n  NB: lo stop DURO che taglia molto il DD di solito paga in Sharpe/CAGR e in n.trade (whipsaw")
+    print("      nel grind). Confronta col soft-guard: stessa protezione, meno whipsaw?")
+
+
+if __name__ == "__main__":
+    main()
@@ -0,0 +1,131 @@
+"""TAIL-HEDGE LAB — proteggere il DD del combo (TP01+GTAA) e gli anni tipo 2022. Valuta OPZIONI.
+
+Il DD del combo (8.4%) e' grind-lento (2022), non crash. Le PUT proteggono i CRASH (rischio latente
+gap/overnight + leva), non il grind. Quindi confronto:
+  (A) OPZIONI: put-spread LONG su indice 50/50 BTC/ETH (mirror di VRP01), always-on vs GATED (hold
+      l'hedge solo quando esposti al trend / quando IV economica). Premio BS su DVOL reale, payoff sul
+      path. Misura il BLEED nei calmi + il payoff nei crash (+ stress sintetico -30% overnight).
+  (B) GUARDIA DRAWDOWN: de-risk il combo quando il DD da picco supera X% (o vol spike).
+  (C) VOL-TARGET: cappa la vol del combo a un livello piu' basso.
+Metriche: Sharpe, MaxDD, anno 2022, drag medio nei calmi, e payoff a uno shock -30%.
+"""
+import sys
+from pathlib import Path
+import numpy as np, pandas as pd
+ROOT = Path(__file__).resolve().parents[2]
+sys.path.insert(0, str(ROOT)); sys.path.insert(0, str(ROOT / "scripts" / "research"))
+from combo_yearly_report import combo_daily
+from src.data.downloader import load_data
+from src.strategies.trend_portfolio import resample_1d
+from src.portfolio.sleeves import _bs_put, _strike_from_delta, _HL_DIR, _tp01_returns
+from scipy.stats import norm
+
+ANN = np.sqrt(252.0)
+
+
+def _sh(r): r = np.asarray(pd.Series(r).dropna(), float); return float(np.mean(r)/np.std(r)*ANN) if len(r)>5 and np.std(r)>0 else 0.0
+def _dd(r): eq=np.cumprod(1+np.asarray(r,float)); pk=np.maximum.accumulate(eq); return float(np.max((pk-eq)/pk)) if len(eq) else 0.0
+def _yr(r,y): return float(np.prod(1+r[r.index.year==y].values)-1) if (r.index.year==y).any() else 0.0
+
+
+def crypto_index():
+    """Indice 50/50 BTC/ETH (prezzo daily) + DVOL medio, per il pricing dell'hedge."""
+    px={}; dv={}
+    for a in ("BTC","ETH"):
+        df=resample_1d(load_data(a,"1h")); s=pd.Series(df["close"].values.astype(float),index=pd.to_datetime(df["datetime"]))
+        if s.index.tz is None: s.index=s.index.tz_localize("UTC")
+        px[a]=s
+        d=pd.read_parquet(_HL_DIR/f"dvol_{a.lower()}.parquet")
+        dv[a]=pd.Series(d["close"].values.astype(float),index=pd.to_datetime(d["timestamp"],unit="ms",utc=True))
+    P=pd.concat(px,axis=1,join="inner").dropna(); D=pd.concat(dv,axis=1,join="inner").dropna()
+    idx_ret=0.5*P["BTC"].pct_change()+0.5*P["ETH"].pct_change()
+    dvol=(0.5*D["BTC"]+0.5*D["ETH"]).reindex(P.index).ffill()/100.0
+    return idx_ret.dropna(), dvol
+
+
+def hedge_overlay(idx_ret, dvol, kind="spread", buy_delta=-0.30, sell_delta=-0.10, tenor_d=7, gate_ivr=None):
+    """P&L settimanale per unita' di nozionale hedge di una protezione LONG comprata ogni settimana
+    sull'indice. kind='spread' = put-spread debit (compra strike vicino buy_delta, vende deep-OTM
+    sell_delta); kind='put' = long put nuda (buy_delta). gate_ivr: compra solo se IV-rank < soglia.
+    Ritorna (pnl_daily, premio_annuo_per_unita)."""
+    idx=idx_ret.index; r=idx_ret.values; sig=dvol.reindex(idx).ffill().values
+    S=np.cumprod(1+r); n=len(S)
+    ivr=pd.Series(sig,index=idx).rolling(252,min_periods=60).apply(lambda x:(x[-1]>=x).mean(),raw=True).values
+    out=np.zeros(n); prem_tot=0.0; i=30; T=tenor_d/365.25
+    while i+tenor_d<n:
+        if gate_ivr is not None and (not np.isfinite(ivr[i]) or ivr[i]>gate_ivr):
+            i+=tenor_d; continue
+        S0=S[i]; vol=sig[i]; ST=S[i+tenor_d]
+        Kb=_strike_from_delta(S0,T,vol,buy_delta)
+        if kind=="put":
+            prem=_bs_put(S0,Kb,T,vol); payoff=max(Kb-ST,0)
+        else:
+            Ks=_strike_from_delta(S0,T,vol,sell_delta)               # Kb>Ks (compra vicino, vende lontano)
+            prem=_bs_put(S0,Kb,T,vol)-_bs_put(S0,Ks,T,vol); payoff=max(Kb-ST,0)-max(Ks-ST,0)
+        fee=0.0005*S0
+        out[i+tenor_d]=(payoff-prem-fee)/S0; prem_tot+=(prem+fee)/S0
+        i+=tenor_d
+    yrs=(idx[-1]-idx[0]).days/365.25
+    return pd.Series(out,index=idx), (prem_tot/yrs if yrs>0 else 0.0)
+
+
+def dd_guard(combo, dd_trigger=0.05, look=20):
+    """De-risk: se il DD da picco supera dd_trigger -> esposizione 0.5 finche' non recupera meta'."""
+    r=combo.values; n=len(r); eq=np.cumprod(1+r); pk=np.maximum.accumulate(eq)
+    expo=np.ones(n); on=True
+    for i in range(1,n):
+        ddi=(pk[i-1]-eq[i-1])/pk[i-1]
+        if ddi>dd_trigger: on=False
+        if ddi<dd_trigger*0.4: on=True
+        expo[i]=1.0 if on else 0.4
+    return pd.Series(expo*r,index=combo.index)
+
+
+def voltarget(combo, tv=0.07):
+    rv=combo.rolling(30,min_periods=15).std().shift(1)*ANN
+    sc=np.clip(np.nan_to_num(tv/rv.replace(0,np.nan).values,nan=0.0),0,1.5)
+    return pd.Series(combo.values*sc,index=combo.index)
+
+
+def line(name, r, base=None):
+    r=r.dropna()
+    extra=""
+    if base is not None:
+        b=base.reindex(r.index).dropna(); r2=r.reindex(b.index)
+        extra=f"  Δ2022 {(_yr(r2,2022)-_yr(b,2022))*100:+.1f}pp"
+    print(f"  {name:34} Sh {_sh(r):>5.2f}  MaxDD {_dd(r.values)*100:>4.1f}%  2022 {_yr(r,2022)*100:>+5.1f}%  "
+          f"CAGR {((np.prod(1+r.values))**(252/len(r))-1)*100:>+5.1f}%{extra}")
+
+
+def main():
+    print("="*100); print("  TAIL-HEDGE LAB — proteggere DD/2022 del combo (TP01+GTAA)"); print("="*100)
+    combo=combo_daily()
+    idx_ret,dvol=crypto_index()
+    print("\n  BASELINE")
+    line("combo (1x)", combo)
+
+    print("\n  (A) OPZIONI — protezione LONG su crypto, sovrapposta al combo (size = spendi ~3%/anno)")
+    for kind,gate,lbl in [("spread",None,"put-spread sempre"),("spread",0.4,"put-spread gate IVR<0.4"),
+                          ("put",None,"long put -0.30 sempre"),("put",0.4,"long put gate IVR<0.4")]:
+        ov,annprem=hedge_overlay(idx_ret,dvol,kind=kind,gate_ivr=gate)
+        ov=ov.reindex(combo.index).fillna(0.0)
+        size=0.03/annprem if annprem>0 else 0.0                   # nozionale hedge per ~3%/anno di premio
+        line(f"+{lbl} (~3%/y, size {size:.2f}x)", combo+size*ov, base=combo)
+    print("  (stress -30% overnight dell'indice crypto, per unita' di nozionale hedge):")
+    S0=1.0; vol=float(dvol.iloc[-1]); T=7/365.25
+    for kind in ("spread","put"):
+        Kb=_strike_from_delta(S0,T,vol,-0.30)
+        if kind=="put": prem=_bs_put(S0,Kb,T,vol); pay=max(Kb-0.7,0)
+        else: Ks=_strike_from_delta(S0,T,vol,-0.10); prem=_bs_put(S0,Kb,T,vol)-_bs_put(S0,Ks,T,vol); pay=max(Kb-0.7,0)-max(Ks-0.7,0)
+        print(f"     {kind:7}: premio {prem*100:.2f}% -> payoff a -30% {pay*100:.2f}% (netto {(pay-prem)*100:+.2f}%)")
+
+    print("\n  (B) GUARDIA DRAWDOWN (de-risk a -X% dal picco)")
+    for t in (0.04,0.06):
+        line(f"+dd-guard {t*100:.0f}%", dd_guard(combo,t), base=combo)
+    print("\n  (C) VOL-TARGET del combo")
+    for tv in (0.05,0.07):
+        line(f"+vol-target {tv*100:.0f}%", voltarget(combo,tv), base=combo)
+
+
+if __name__ == "__main__":
+    main()
@@ -0,0 +1,145 @@
+export const meta = {
+  name: 'crypto-lead-sweep',
+  description: 'Sweep multi-agente dell\'anticipazione crypto->mercati IB (mercati x timing x lead), verifica avversariale multi-anno, sintesi della soluzione migliore',
+  phases: [
+    { title: 'Sweep', detail: '~52 agenti: grid (lead x mercato x giorno x predict x finestra) via harness onesto' },
+    { title: 'Verify', detail: 'top candidati: stress costi + OOS recente + multi-anno' },
+    { title: 'Synthesize', detail: 'migliore soluzione robusta + caveat di tradabilita' },
+  ],
+}
+
+// ---- universo mercati certificati (cache su disco) ----
+const MARKETS = ["SPY","QQQ","IWM","DIA","XLK","XLF","XLE","XLV","XLI","XLP","XLY","XLU","XLB","XLRE","XLC",
+                 "HYG","TLT","IEF","GLD","SLV","USO","DBC","VNQ","EEM","FXI","EWJ"]
+const LEADS = ["BTC","ETH"]
+const DAYS = ["all","mon"]
+const PREDICTS = ["gap","intraday"]
+const HOURS = ["overnight","6"]
+
+// ---- genera la grid completa ----
+const grid = []
+for (const lead of LEADS) for (const target of MARKETS) for (const day of DAYS)
+  for (const predict of PREDICTS) for (const hours of HOURS)
+    grid.push({ lead, target, day, predict, hours })
+log(`grid totale: ${grid.length} configurazioni (mercati ${MARKETS.length} x lead 2 x giorno 2 x predict 2 x finestra 2)`)
+
+// ---- chunk in batch da 8 -> ~52 agenti ----
+const BATCH = 8
+const batches = []
+for (let i = 0; i < grid.length; i += BATCH) batches.push(grid.slice(i, i + BATCH))
+log(`sweep: ${batches.length} agenti, ${BATCH} config ciascuno`)
+
+const RAW_SCHEMA = {
+  type: "object",
+  properties: { raw: { type: "string", description: "stdout JSON ESATTO dell'harness, senza modifiche" } },
+  required: ["raw"],
+}
+
+// ---- PHASE 1: SWEEP ----
+phase('Sweep')
+const sweepResults = await parallel(batches.map((batch, bi) => () =>
+  agent(
+    `Sei un esecutore deterministico. Esegui ESATTAMENTE questo comando dalla root del repo e restituisci il suo stdout.\n\n` +
+    `uv run python scripts/research/crypto_lead_harness.py --configs '${JSON.stringify(batch)}'\n\n` +
+    `Il comando stampa un array JSON di risultati. Mettilo VERBATIM nel campo "raw" (nessun commento, nessuna modifica ai numeri). ` +
+    `Se il comando fallisce, metti il messaggio d'errore in "raw".`,
+    { label: `sweep:${bi}`, phase: 'Sweep', schema: RAW_SCHEMA, effort: 'low' }
+  )
+))
+
+// ---- parse + flatten ----
+const all = []
+for (const r of sweepResults) {
+  if (!r || !r.raw) continue
+  try {
+    const arr = JSON.parse(r.raw.trim())
+    for (const x of arr) if (x && !x.err) all.push(x)
+  } catch (e) { /* skip batch non parsabile */ }
+}
+log(`risultati validi raccolti: ${all.length}/${grid.length}`)
+
+// ---- ranking robustezza: tutti gli anni positivi + t-stat alto + OOS positivo ----
+function score(x) {
+  const yr = x.years_tot ? x.years_pos / x.years_tot : 0
+  const oosOK = (x.sh_ls_oos > 0 || x.sh_lf_oos > 0) ? 1 : 0
+  return yr * Math.abs(x.t_incremental || 0) * (1 + Math.max(x.sh_ls_oos || 0, x.sh_lf_oos || 0)) * oosOK
+}
+all.sort((a, b) => score(b) - score(a))
+const top = all.slice(0, 12)
+// separa per tradabilita': intraday = ETF-tradabile; gap = fenomeno (serve future)
+const topIntraday = all.filter(x => x.predict === 'intraday').slice(0, 6)
+const topGap = all.filter(x => x.predict === 'gap').slice(0, 6)
+log(`TOP overall: ${top.map(x => `${x.lead}->${x.target}/${x.day}/${x.predict} t=${x.t_incremental} oos=${Math.max(x.sh_ls_oos,x.sh_lf_oos)} ${x.years_pos}/${x.years_tot}y`).join(' | ')}`)
+
+// ---- PHASE 2: VERIFY (stress costi + OOS recente, multi-anno) ----
+phase('Verify')
+const VERDICT_SCHEMA = {
+  type: "object",
+  properties: {
+    config: { type: "string" },
+    robust: { type: "boolean", description: "regge stress (costi alti + OOS recente) e multi-anno?" },
+    tradeable_via: { type: "string", description: "etf-intraday | futures-gap | none" },
+    sh_oos_4bps: { type: "number" }, sh_oos_10bps: { type: "number" }, sh_oos_recent: { type: "number" },
+    years_pos: { type: "number" }, years_tot: { type: "number" },
+    note: { type: "string", description: "1-2 frasi: cosa regge, cosa no, spiegazione alternativa" },
+  },
+  required: ["config", "robust", "tradeable_via", "note"],
+}
+const cands = [...new Map([...topIntraday, ...topGap, ...top].map(x => [`${x.lead}|${x.target}|${x.day}|${x.predict}|${x.hours}`, x])).values()].slice(0, 12)
+const verified = await parallel(cands.map((c) => () => {
+  const cfg = JSON.stringify([{ lead: c.lead, target: c.target, day: c.day, predict: c.predict, hours: c.hours }])
+  return agent(
+    `Verifica avversariale di UN candidato lead-lag crypto->mercato. Config: ${JSON.stringify(c)}.\n` +
+    `Esegui questi 3 comandi dalla root e leggi i campi t_incremental, sh_ls_oos, sh_lf_oos, years_pos, years_tot:\n` +
+    `1) base 4bps:   uv run python scripts/research/crypto_lead_harness.py --cost 0.0004 --oos 2022-01-01 --configs '${cfg}'\n` +
+    `2) stress 10bps: uv run python scripts/research/crypto_lead_harness.py --cost 0.0010 --oos 2022-01-01 --configs '${cfg}'\n` +
+    `3) OOS recente:  uv run python scripts/research/crypto_lead_harness.py --cost 0.0004 --oos 2024-01-01 --configs '${cfg}'\n\n` +
+    `Giudica: robust=true SOLO se l'edge resta positivo a 10bps E nell'OOS recente (2024+) E years_pos/years_tot>=0.6. ` +
+    `tradeable_via: "etf-intraday" se predict=intraday e regge (eseguibile comprando l'ETF al Monday/giorno open); ` +
+    `"futures-gap" se predict=gap e regge (il gap si cattura solo con i futures indice overnight, NON con l'ETF); "none" se non regge. ` +
+    `note: spiega anche un'alternativa plausibile (e' solo risk-beta? autocorrelazione? multiple-testing su ${grid.length} test?).`,
+    { label: `verify:${c.lead}->${c.target}/${c.predict}`, phase: 'Verify', schema: VERDICT_SCHEMA }
+  )
+}))
+const robust = verified.filter(v => v && v.robust)
+log(`candidati robusti: ${robust.length}/${cands.length}`)
+
+// ---- PHASE 3: SYNTHESIZE ----
+phase('Synthesize')
+const SYNTH_SCHEMA = {
+  type: "object",
+  properties: {
+    best_solution: { type: "string", description: "la migliore soluzione: lead+mercato+timing+predict+come si tradea" },
+    why: { type: "string" },
+    expected_edge: { type: "string", description: "Sharpe OOS onesto (post-stress), hit, anni positivi" },
+    tradeability: { type: "string", description: "ETF intraday vs futures overnight; eseguibile a $0.5-2k?" },
+    multi_year: { type: "string", description: "evidenza su piu' anni (per-anno)" },
+    caveats: { type: "string" },
+    runner_ups: { type: "string" },
+  },
+  required: ["best_solution", "why", "expected_edge", "tradeability", "multi_year", "caveats"],
+}
+const synthesis = await agent(
+  `Sei l'analista quant capo, disciplina ONESTA (questo progetto uccide i falsi positivi: multiple-testing, hold-out-luck, ` +
+  `tradabilita' reale a basso capitale). Obiettivo: dalla ricerca multi-agente sull'anticipazione crypto->mercati IB, ` +
+  `determina la SOLUZIONE MIGLIORE (mercato + timing + lead) verificata su PIU' ANNI.\n\n` +
+  `TOP candidati (sweep, ${grid.length} config testate): ${JSON.stringify(top)}\n\n` +
+  `VERDETTI di verifica avversariale (stress costi 10bps + OOS recente 2024+): ${JSON.stringify(verified)}\n\n` +
+  `Candidati robusti: ${JSON.stringify(robust)}\n\n` +
+  `Fatti noti: (a) il GAP di apertura (predict=gap) ha t-stat altissimi ma NON e' catturabile con l'ETF (serve un future ` +
+  `indice tradato overnight, es. MNQ/MES su IB); (b) l'INTRADAY (predict=intraday) e' debole ma eseguibile comprando l'ETF; ` +
+  `(c) abbiamo testato ${grid.length} configurazioni -> correggi mentalmente per multiple-testing (un t-stat ~2 non basta qui).\n\n` +
+  `Produci la sintesi: la soluzione migliore REALMENTE utile (distingui fenomeno-forte-non-tradabile da edge-tradabile), ` +
+  `il suo edge atteso onesto post-stress, come si tradea a $0.5-2k, l'evidenza multi-anno, i caveat, e i runner-up.`,
+  { label: 'synthesize', phase: 'Synthesize', schema: SYNTH_SCHEMA, effort: 'high' }
+)
+
+return {
+  grid_size: grid.length,
+  sweep_agents: batches.length,
+  results_collected: all.length,
+  top12: top,
+  verified,
+  robust_count: robust.length,
+  synthesis,
+}
@@ -15,11 +15,13 @@ sys.path.insert(0, str(PROJECT_ROOT))
 import numpy as np, pandas as pd
 from src.portfolio.portfolio import StrategyPortfolio, metrics, HOLDOUT
 from src.portfolio.sleeves import active_sleeves
+from src.portfolio.gtaa import gtaa_weights
 from src.live.shadow import shadow_report, tp01_trades
 from src.version import APP_VERSION

 PAPER = PROJECT_ROOT / "data" / "paper_portfolio" / "state.json"
 PREVDAY = PROJECT_ROOT / "data" / "paper_prevday" / "state.json"
+COMBO = PROJECT_ROOT / "data" / "paper_combo" / "state.json"
 _CACHE = {"t": 0.0, "data": None}
 _TTL = 120.0

@@ -35,6 +37,11 @@ def build():
    spark = [(str(idx[i].date()), float(eq[i])) for i in range(0, len(eq), step)]
    paper = json.loads(PAPER.read_text()) if PAPER.exists() else None
    prevday = json.loads(PREVDAY.read_text()) if PREVDAY.exists() else None
+    combo = json.loads(COMBO.read_text()) if COMBO.exists() else None
+    try:
+        gtaa_w = gtaa_weights()                               # pesi ETF correnti azionabili (cache eq_*)
+    except Exception:
+        gtaa_w = None
    try:
        shadow = shadow_report()                              # mainnet sola lettura, best-effort
    except Exception as e:
@@ -49,6 +56,7 @@ def build():
        full=bt["full"], holdout=bt["holdout"], weights=bt["weights"],
        per_sleeve=bt["per_sleeve"], yearly=bt["yearly"],
        positions=pf.current_positions(), spark=spark, paper=paper, prevday=prevday,
+        combo=combo, gtaa_weights=gtaa_w,
        shadow=shadow, trades=trades, bh=None,
    )
    _CACHE.update(t=time.time(), data=data)
@@ -104,6 +112,28 @@ def html():
            f"forward da {pd.Timestamp(pv['start_ts'], unit='ms').date()}")
    else:
        prevday_html = "non inizializzato (gira <code>scripts/live/paper_prevday.py</code>)"
+    cb = d.get("combo")
+    if cb:
+        cdays = (pd.Timestamp(cb["last"]) - pd.Timestamp(cb["start"])).days
+        cret = cb["equity"] / cb["initial"] - 1
+        wc = cb.get("w_crypto", 0.5)
+        head = (f"start {cb['initial']:.0f} · {cb['start'][:10]} → {cb['last'][:10]} ({cdays}g, "
+                f"{cb['n_days']} barre) · blend {wc*100:.0f}/{(1-wc)*100:.0f} TP01/GTAA")
+        combo_html = f"{head}<br><b>NUDO</b> &nbsp; eq <b>{cb['equity']:.2f}</b> &nbsp; ret <b>{cret*100:+.2f}%</b> &nbsp; maxDD {cb['max_dd']*100:.1f}%"
+        if "equity_g" in cb:
+            crg = cb["equity_g"] / cb["initial"] - 1
+            combo_html += (f"<br><b>PROTETTO</b> (guardia-DD −{cb.get('dd_trigger',0.04)*100:.0f}%) &nbsp; "
+                           f"eq <b>{cb['equity_g']:.2f}</b> &nbsp; ret <b>{crg*100:+.2f}%</b> &nbsp; maxDD {cb['max_dd_g']*100:.1f}%")
+    else:
+        combo_html = "non inizializzato (gira <code>scripts/live/paper_combo.py</code>)"
+    gw = d.get("gtaa_weights")
+    if gw:
+        asof = gw.get("_asof", "?"); cash = gw.get("_cash")
+        gw_html = (", ".join(f"{k} <b>{v:.0%}</b>" for k, v in gw.items() if not k.startswith("_") and v)
+                   + (f" · cash <b>{cash:.0%}</b>" if cash is not None else "")
+                   + f" <span style='color:#8a93a0'>(asof {asof})</span>")
+    else:
+        gw_html = "n/d (cache ETF assente — gira fetch_ib_equities.py)"
    sh = d.get("shadow")
    if sh and "error" not in sh:
        bits = " &nbsp;·&nbsp; ".join(
@@ -175,6 +205,10 @@ th{{color:#8a93a0;font-weight:500}}.y{{display:inline-block;background:#161b22;b
 <h3 style="font-size:14px;color:#8a93a0">Trades TP01 — entry/exit (segnale causale, ultimi 15)</h3>
 <table><tr><th>data</th><th>asset</th><th>azione</th><th>posizione</th><th>prezzo</th></tr>{trows}</table>
 <div style="margin-top:10px">{yrs}</div>
+<div class="section">COMBO DEPLOYABLE — cross-venue (paper, forward-only)</div>
+<div class=box><b>TP01 (Deribit) + GTAA (IB)</b> — le DUE gambe ESEGUIBILI a basso capitale, scorrelate (corr ~0.21) → blend Sharpe ~1.5, drawdown dimezzato. <b>Nessuna esecuzione reale</b>:<br>{combo_html}<br>
+<span style="color:#8a93a0;font-size:13px">posizioni azionabili IB (GTAA, peso ETF):</span> {gw_html}</div>
+<p class=warn>⚠️ PAPER cross-venue: valida l'operativita' su due conti (Deribit + IB) a rischio zero. Lo Sharpe ~1.5 e' ottimistico (finestra crypto corta/favorevole); il dato robusto e' la diversificazione (corr 0.21, DD dimezzato), non il livello. XS01/VRP01 esclusi (STAT-MODE): qui solo TP01+GTAA.</p>
 <div class="section">FORWARD-MONITOR — lead paper (non deploy)</div>
 <div class=box><b>PREVDAY range-breakout</b> — lead ORTOGONALE a TP01 (corr ~0.15 full / ~0 hold; marginal ADDS, non-hedge, robusto allo shift del confine-giorno). Forward-only, <b>nessuna esecuzione reale</b>:<br>{prevday_html}</div>
 <p class=warn>⚠️ LEAD in osservazione, NON deployato. Sopravvissuto alla verifica avversariale dell'onda intraday; lo teniamo in paper per validarlo fuori-campione-vero. I due libri (modeled vs real-$600) mostrano l'haircut di fill che lo scettico aveva segnalato.</p>
@@ -0,0 +1,73 @@
+"""GTAA — sleeve EQUITY/ETF: trend difensivo multi-asset (analogo di TP01, su IB).
+
+Validato sul branch research/equities-ib (diari 2026-06-22-equities-*). Trend long-flat TSMOM
+multi-orizzonte su un paniere di classi (azioni US/tech/small + bond + oro + credito), equal-weight
+sugli asset in trend-up, vol-target 12%. Difensivo: Sharpe ~0.64 / maxDD ~15% standalone, e — il punto
+— corr ~0.21 col crypto (TP01) -> diversificatore reale (blend Sharpe ~1.5, DD dimezzato).
+
+Eseguibile su IB a basso capitale (ETF frazionabili, switch mensile/basso turnover). Legge la CACHE
+su disco data/raw/eq_*.parquet (ADJUSTED_LAST, scritta da scripts/research/fetch_ib_equities.py);
+in produzione va rinfrescata giornalmente (gateway IB). Espone rendimenti + PESI CORRENTI (posizioni).
+"""
+from __future__ import annotations
+from functools import lru_cache
+from pathlib import Path
+import numpy as np, pandas as pd
+
+RAW = Path(__file__).resolve().parents[2] / "data" / "raw"
+EQ_UNIVERSE = ("SPY", "QQQ", "IWM", "TLT", "GLD", "HYG")
+HORIZONS = (21, 63, 126, 252)
+TARGET_VOL = 0.12
+FEE_SIDE = 0.0002
+ANN = np.sqrt(252.0)
+
+
+@lru_cache(maxsize=16)
+def _close(sym: str) -> pd.Series:
+    p = RAW / f"eq_{sym.lower()}_1d.parquet"
+    if not p.exists():
+        raise FileNotFoundError(f"{p} assente — gira scripts/research/fetch_ib_equities.py")
+    d = pd.read_parquet(p)
+    return pd.Series(d["close"].astype(float).values,
+                     index=pd.to_datetime(d["timestamp"], unit="ms", utc=True)).sort_index()
+
+
+def _exposure(close: pd.Series) -> pd.Series:
+    """Esposizione long-flat [0,1] su un asset: frazione di orizzonti in trend-up, vol-targeted, cap 1.
+    Causale (solo dati <= i)."""
+    px = close.values; n = len(px); tgt = np.zeros(n); mh = max(HORIZONS)
+    for i in range(mh, n):
+        tgt[i] = np.mean([1.0 if px[i] > px[i - H] else 0.0 for H in HORIZONS])
+    s = pd.Series(tgt, index=close.index)
+    rv = close.pct_change().rolling(63, min_periods=20).std().shift(1) * ANN
+    scale = np.clip(np.nan_to_num(TARGET_VOL / rv.replace(0, np.nan).values, nan=0.0), 0, 10.0)
+    return (s * scale).clip(0, 1.0)
+
+
+def _gated_returns(sym: str) -> pd.Series:
+    close = _close(sym); ex = _exposure(close)
+    ret = close.pct_change().fillna(0.0).values
+    held = np.zeros(len(ex)); held[1:] = ex.values[:-1]      # causale: esposizione decisa a i-1, tenuta in i
+    net = held * ret - FEE_SIDE * np.abs(np.diff(held, prepend=0.0))
+    return pd.Series(net, index=close.index)
+
+
+def gtaa_returns(universe=EQ_UNIVERSE) -> pd.Series:
+    """Rendimenti netti daily del GTAA: EW dei rendimenti trend-gated sugli asset disponibili."""
+    cols = {a: _gated_returns(a) for a in universe}
+    return pd.concat(cols, axis=1).sort_index().mean(axis=1, skipna=True).dropna()
+
+
+def gtaa_weights(universe=EQ_UNIVERSE) -> dict:
+    """Pesi target CORRENTI (ultima barra): quanto allocare a ciascun ETF (e quanto in cash).
+    weight_i = esposizione_i / N_disponibili. Azionabile su IB."""
+    out = {}; n = len(universe)
+    for a in universe:
+        try:
+            ex = _exposure(_close(a))
+            out[a] = round(float(ex.iloc[-1]) / n, 4)
+        except FileNotFoundError:
+            continue
+    out["_cash"] = round(1.0 - sum(out.values()), 4)
+    out["_asof"] = str(_close("SPY").index[-1].date())
+    return out
Author	SHA1	Message	Date
Adriano Dal Pastro	237ca8da13	research(report): resoconto PROTETTO (soft-guard DD -4%) anno-per-anno -> combo + TP01 + GTAA singoli Report che mette combo (TP01+GTAA 50/50), TP01 e GTAA sulla stessa griglia giorni-di-borsa (esposizione 1x, come dentro al combo), applica la guardia-DD -4% a ciascuna serie e tira fuori per anno: NL (net liquidation da $2000), DD intra-anno, rendimento, Sharpe + riga TOT con CAGR. Combo protetto: CAGR +9.1% / DD 5.8% / Sh 1.38 (2022 -1.8%); baseline +11.3% / 8.4% / 1.48. Aggiunto data/paper_combo/ al .gitignore (stato paper runtime, come gli altri paper dir). Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>	2026-06-23 14:16:59 +00:00
Adriano Dal Pastro	856a02fcc5	research(stops): SL classici vs soft-guard -> il soft-guard vince (lo SL duro whippa nel grind) Goal 'prova anche SL'. Test equo (trigger/re-entry sul NAV mercato). soft-guard -4% Sh 1.38/DD 5.8% resta il migliore; trail-stop -6% valido ma inferiore (1.34/6.6%); -4% whipsaw (1.07, inMkt 42%); stop mensile/vol inutili. Per un DD da grind, de-risk parziale > uscita totale. Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>	2026-06-23 13:09:43 +00:00
Adriano Dal Pastro	010d1f0733	feat(combo): paper combo NUDO vs PROTETTO (guardia-DD -4%) affiancati + dashboard paper_combo traccia forward entrambe le versioni; dashboard mostra nudo + protetto. Guardia-DD: de-risk 0.4x a DD>-4%, ri-rischia a -1.6% (backtest MaxDD 8.4->5.8%, 2022 -4.4->-1.8%). Opzioni escluse (non aiutano il grind). Container ricostruito. Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>	2026-06-23 12:59:07 +00:00
Adriano Dal Pastro	1c15c3c1be	research(tail-hedge): protezione DD combo (incl. opzioni) -> vince la guardia-drawdown Goal: sleeve/overlay protettivo per il combo (TP01+GTAA), anni tipo 2022, valutare opzioni. Diagnosi: DD combo 8.4% e' grind-lento (2022 -4.4%), non crash -> il doppio trend gia' taglia i crash. Test (tail_hedge_lab.py): guardia-DD -4% -> MaxDD 8.4->5.8%, 2022 -4.4->-1.8%, Sharpe 1.48->1.38, CAGR 9.2%. Vol-target NON aiuta (2022 non e' vol-spike). OPZIONI (put/put-spread LONG su BTC/ETH, premio BS su DVOL): sempre-on ~50%/anno -> con budget 3%/y effetto ~nullo, e nel grind 2022 sanguinano; pagano solo nei crash secchi (stress -30%: put +25% netto). -> black-swan insurance cara, fuori bersaglio per il 2022. A leva: guard rende il 2x sopportabile (2022 -10.9%), il 3x resta margin-call. RACCOMANDAZIONE: aggiungere guardia-drawdown di portafoglio (no premio); opzioni solo eventuale micro-hedge black-swan. Costo onesto del guard: -2.1pp CAGR per dimezzare il MaxDD. Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>	2026-06-23 12:55:14 +00:00
Adriano Dal Pastro	3a3bdd5c7b	research(report): sim leva 1x/2x/3x combo vs TP01 (DD reale + margin-call), da 2k/5k Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>	2026-06-23 12:44:54 +00:00
Adriano Dal Pastro	f983cc2447	research(report): resoconto anno-per-anno combo/TP01/GTAA da $2k (PnL/MaxDD/NumTrades) Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>	2026-06-23 12:37:23 +00:00
Adriano Dal Pastro	389573e517	feat(dashboard): pannello COMBO cross-venue (TP01 Deribit + GTAA IB) Aggiunge alla dashboard la sezione "COMBO DEPLOYABLE — cross-venue (paper)": equity paper forward del blend 50/50 TP01+GTAA (da data/paper_combo/state.json) + posizioni azionabili IB correnti (gtaa_weights: peso ETF + cash, asof). Nota onesta: paper rischio-zero, Sharpe ~1.5 ottimistico, il robusto e' la diversificazione (corr 0.21, DD dimezzato); XS01/VRP01 esclusi (STAT-MODE). Container ricostruito (codice baked nell'immagine). Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>	2026-06-23 12:32:19 +00:00
Adriano Dal Pastro	3b552a92da	feat(combo): paper-trade cross-venue TP01 (Deribit) + GTAA (IB), forward-only L'unica cosa vera/deployabile della ricerca: diversificazione TP01+GTAA (corr 0.21, blend Sharpe ~1.5, DD dimezzato). Si va in PAPER cross-venue. - src/portfolio/gtaa.py: GTAA sleeve di prima classe (trend difensivo TSMOM vol-target 12% su SPY/QQQ/IWM/TLT/GLD/HYG). gtaa_returns() Sharpe 0.64; gtaa_weights() = pesi ETF correnti azionabili. - scripts/live/paper_combo.py: tracker forward-only blend 50/50 TP01+GTAA (crypto compoundato su grid giorni-di-borsa), mostra posizioni azionabili su entrambi i venue. Solo gambe eseguibili. - fetch_ib_equities.py --only: refresh mirato dei 6 ETF GTAA per il cron. - cron_daily.sh: up gateway IB + refresh ETF GTAA + avanza paper_combo (dipendenza cross-venue gestita). Init 2026-06-23: TP01 flat (risk-off), GTAA SPY13/QQQ8/IWM9/TLT17/GLD2/HYG17/cash34. Catena gateway->refresh->paper testata end-to-end. PAPER (rischio zero), valida l'operativita' cross-venue. Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>	2026-06-23 12:26:51 +00:00
Adriano Dal Pastro	09c8bb7de8	research(cross-market): oltre SP500 (bond/commodity/indici esteri) -> niente, artefatto di confine UTC Esteso il test crypto-lead a ZN(bond), ESTX50/DAX(Europa), NKD(Nikkei) via futures orari IB (commodity GC/CL/HG bloccate da subscription). Test non-sovrapposto crypto[T-8h->T]->future[T->T+6h]. ES/NQ/RTY niente (gia'); ZN negativo; NKD debole (~overnight drift). ESTX50/DAX SEMBRANO fortissimi (t_crypto 7.8, Sharpe 2.5, 3/3 anni) MA e' artefatto di confine UTC: picco a coltello a T=00:00, morto a T=1h; GAP di 1h uccide l'effetto (Sharpe 2.45->-0.52); tutto l'edge nella singola barra 00:00->01:00 (Sh +2.93) vs ora dopo (-1.02). Firma esatta di day_boundary_robust (CLAUDE.md). VERDETTO: nessuna anticipazione crypto->mercato sfruttabile, ne' SP500 ne' altro. Sempre co-movimento contemporaneo (risk-beta) o artefatto di confine. Resta valido solo il diversificatore TP01+GTAA. Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>	2026-06-23 12:12:16 +00:00
Adriano Dal Pastro	c4bc336a53	research(cross-market): futures overnight non-sovrapposto -> edge ~0 su SP500, soffio su small-cap Test ONESTO dell'idea "monitor Deribit/trade IB": entra mid-notte sul future indice, cattura il moto SUCCESSIVO (finestre non sovrapposte, no look-ahead). Dati: ES/NQ/RTY orari da IB (fut_*_1h, ~3y). RISULTATO: ES (S&P500) nessun edge (Sharpe ~0/neg, t_crypto 0-1.5); NQ momentum del future non crypto; RTY (small-cap) unico con t_crypto incrementale 2.0-2.7 e crypto che aggiunge oltre il moto proprio del future, ma Sharpe 0.4-0.5, 24 config (multiple-testing), 2.3y, per-anno incoerente (2026 negativo). VERDETTO: l'idea NON da' edge tradabile, men che meno su SP500. Il forte crypto<->equity e' co-movimento contemporaneo (risk-beta), non anticipazione: imposta una finestra causale non-sovrapposta e svanisce. Il "Sharpe 5" del gap era look-ahead. RTY -> forward-monitor al piu'. Coerente col soffitto del progetto. Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>	2026-06-23 11:51:15 +00:00
Adriano Dal Pastro	55c337144e	research(cross-market): "monitor Deribit/trade IB" gap = LOOK-AHEAD, edge tradabile ~0 L'idea (segnale crypto overnight -> trade indice IB) sembrava Sharpe 3.6-5.9 ma e' look-ahead: la finestra segnale crypto [P21:00->D13:00] e il gap equity [Pclose->Dopen] coprono le stesse ore. All'entrata (D13:00, pre-open) il gap e' gia' avvenuto -> non catturabile con l'ETF. Decomposizione (net 2bps, sqrt252): OVERLAP gap Sh ~3.6-4.0 (artefatto) vs TRADABILE intraday Sh -0.03..0.25 (reale, ~0, muore a costi). Conferma/rafforza "non deployabile" del workflow. Resta possibile solo la versione futures mid-overnight (finestre non sovrapposte) -> serve dato intraday ES/NQ, non in cache. Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>	2026-06-23 11:23:18 +00:00
Adriano Dal Pastro	d916520f2c	research(cross-market): sweep 65-agenti crypto->mercati IB -> fenomeno gap robustissimo ma NON edge Goal: >=50 agenti, migliore soluzione, diversi mercati e timing, su piu' anni. Setup: 26 ETF certificati (IB) + BTC/ETH 1h; harness parametrizzato (lead overnight crypto -> gap/intraday equity, t-incrementale, Sharpe IS/OOS, hit per-anno); workflow 416 config = 52 sweep + 12 verifica avversariale + 1 sintesi = 65 agenti. RISULTATO: cluster fortissimo crypto-overnight -> GAP apertura equity (tutti i target risk-on). Migliori: ETH->IWM/QQQ/XLK gap (Sh OOS 2.4-2.5, t 17), BTC->QQQ gap (Sh OOS 2.31, t 15, 9/9 ANNI). Regge stress 10bps e OOS recente. MA due killer (verificatori concordi): 1. NON tradabile via ETF (gap gia' all'open) -> serve future overnight (MNQ/MES), fuori dal capitale $0.5-2k (margin/liquidazione); 2. e' RISK-BETA non alpha: finestra-lead ~contemporanea al gap (stesso shock macro), forza solo negli anni alta-vol (2022), beta implicito ~37%. Unico ETF-tradabile (ETH->XLE intraday) crolla a 10bps (0.48->0.15), t 2.38 sotto Bonferroni/416. VERDETTO: nessun edge proprietario deployabile a basso capitale. Migliore FENOMENO da forward-monitor = BTC->QQQ gap overnight (9/9 anni). Coerente col soffitto del progetto. Valore: aver classificato il fenomeno (risk-beta overnight) invece di scambiarlo per alpha. Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>	2026-06-22 22:32:28 +00:00
Adriano Dal Pastro	d2d535cf6a	research(cross-market): crypto x mercati IB -> trovata ANTICIPAZIONE weekend-crypto -> lunedi' equity Goal: cercare correlazioni/anticipazioni crypto<->IB. Dati cache (BTC/ETH Deribit 1h->1d; ETF eq_*). (1) Correlazione contemporanea: crypto = risk-on (BTC ~0.32 SPY/QQQ/IWM, 0.25 HYG, 0.13 GLD, ~0 TLT). (2) Lead-lag GIORNALIERO: NIENTE (picco k=0, rumore a \|k\|>=1) -> nessuno anticipa l'altro al daily. (3) EFFETTO WEEKEND (anticipazione pulita): crypto Sab+Dom (equity chiuso) anticipa il lunedi'. GAP lunedi' corr +0.22/0.24 (SPY/QQQ/IWM/HYG), hit 59-62%, si RAFFORZA OOS22+ (+0.30/0.36). Validazione avversariale: (A) INCREMENTALE vs venerdi': beta weekend-crypto significativo (QQQ gap t=+4.7, intr +2.9; SPY +4.4/+2.0; IWM +4.7/+2.7), friday_eq NON signif. -> info crypto-specifica, non momentum equity. (B) TRADABILE (entro Mon open, esco close, net 4bps): QQQ hit 60%, Sharpe 1.46 (OOS 1.33), long-flat OOS 1.91 ~+9%/yr; SPY/IWM piu' deboli ma OOS positivi. VERDETTO: prima anticipazione cross-mercato reale. Crypto = proxy 24/7 risk-sentiment; lunedi' equity recupera la direzione del weekend. Caveat: capacita' bassa (~52 lun/anno), tattico non cornerstone; gap catturabile via futures IB (MNQ domenica sera) da validare. Coerente su 3 ETF (no cherry-pick). Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>	2026-06-22 21:55:01 +00:00
Adriano Dal Pastro	67850b0dd8	research(equities): valida combo DEPLOYABLE TP01+GTAA (le due gambe eseguibili) Combo onesto/eseguibile a basso capitale: TP01 (Deribit, gia' armato) + GTAA vt12 (IB), senza XS01/VRP01 STAT-MODE. Finestra 2019-2026, TP01 compoundato sui giorni di borsa. RISULTATO: corr TP01<->GTAA +0.21; blend 50/50 Sharpe 1.48 (40/60 e risk-parity 1.52) > best solo 1.25, maxDD 14%->8%. DIVERSIFICA anche da deployable. CAVEAT: 2022 negativo (-2.64, trend whipsaw su entrambe), anni boom gonfiano l'assoluto (recenti ~0.95) -> il dato robusto e' il +0.27 di diversificazione, non il livello. Costo deployability: crypto-pieno+GTAA 1.81 vs 1.48 (i ~0.33 persi = XS01/VRP01 non eseguibili). Cross-venue Deribit+IB. Migliore config rischio-aggiustata EFFETTIVAMENTE eseguibile trovata post-reset. Non risolve EUR50/g (capitale). Prossimo: paper-trade GTAA su IB (forward-only) per validare l'esecuzione cross-venue. Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>	2026-06-22 21:48:35 +00:00
Adriano Dal Pastro	437cf11199	research(equities): EQ-GTAA01 trend multi-asset + COMBO cross-mercato (diversifica il crypto) (1) GTAA: trend difensivo long-flat su SPY/QQQ/IWM/TLT/GLD/HYG (EW sugli asset disponibili). GTAA lf vt12%: Sharpe 0.64 (OOS 0.89), maxDD 15% (8% sui 6-asset 2016+), corr SPY 0.64. Migliore sleeve equity: rischio-aggiustato > mono-SPY, DD bassissimo, diversificatore migliore. Difensiva (CAGR basso). Bear DD: GFC 14% vs 55%, COVID 10% vs 34%. (2) COMBO cross-mercato: crypto (TP01+XS01+VRP01) x equity (GTAA vt12), finestra 2019-2026. corr crypto<->equity = +0.17 (bassissima). blend 50/50 Sharpe 1.81 > crypto solo 1.60 > equity 1.12; maxDD dimezzato 14%->7%. DIVERSIFICA: primo miglioramento STRUTTURALE del rischio-aggiustato complessivo della ricerca post-reset (diversificazione vera, non alpha). CAVEAT: finestra crypto corta/favorevole (Sharpe assoluti ottimistici), cross-venue Deribit+IB, XS01/VRP01 STAT-MODE -> il combo deployable reale e' ~TP01+GTAA. Non risolve EUR50/g (capitale). Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>	2026-06-22 21:42:42 +00:00
Adriano Dal Pastro	c9b89739c1	research(equities): EQ-TREND01 trend difensivo su SPY = edge difensivo REALE (analogo TP01) Il cross-section e' morto (EQ-MOM01), ma il trend DIFENSIVO time-series su SPY regge — stesso tipo di TP01 nel crypto. TSMOM multi-orizzonte / SMA-200 long-flat, causale, netto fee, OOS 2015+. RISULTATO: Sharpe 0.54->0.62/0.65, maxDD DIMEZZATO (55%->~27%; nei bear lenti piu': GFC 19% vs 55%, dot-com 26% vs 49%, COVID 17% vs 34%). Plateau robusto (0.56-0.65), fee-robusto (0.48 a 0.10%/lato), basso turnover, eseguibile a $0.5-2k (switch mensile SPY/cash). SMA-200 = piu' semplice E migliore. CAVEAT: e' risk-management non alpha (CAGR -2/3pp); i tagli grossi sono in-sample (OOS 2015-26 quasi tutto toro -> ha seguito SPY a beta minore, ma COVID dimezzato). long-bonds TLT non convince. Lezione cross-mercato confermata: il valore robusto e' ridurre il rischio (trend long-flat), non battere il buy&hold. Prossimo: trend multi-asset/GTAA + diversifica la sleeve crypto? Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>	2026-06-22 21:37:37 +00:00
Adriano Dal Pastro	03267b8fc3	research(equities): EQ-MOM01 momentum settoriale -> NON batte SPY Primo backtest del fronte equity. Momentum cross-sectional settoriale (9 SPDR, 1998-2026), causale, netto fee, OOS 2015+, giudicato marginale vs SPY buy&hold (il baseline equity). VERDETTO: nessun edge. Long-short Sharpe -0.08 (alpha cross-sectional MORTO su 27y, decadimento post-2000 noto). Long-only ~= SPY (corr 0.85, uplift marginale ~0.00) = SPY a beta piu' basso. Plateau stabile ~0.50 vs SPY 0.51; sugli 11 settori (2018+) peggio (0.69 vs 0.82). L'unico beneficio (maxDD 55->39%) e' del vol-target, non del momentum. Coerente col progetto: il relative-value momentum e' morto anche in equity (come ortho wave nel crypto). Prossimo angolo: TS-trend difensivo su SPY (analogo equity di TP01) per tagliare il drawdown, non per battere il CAGR. Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>	2026-06-22 21:33:38 +00:00
Adriano Dal Pastro	1c0b5f1869	research(equities): apre il fronte azioni/ETF via IB — dati certificati + cache su disco Branch dedicato. Disciplina v2.0.0: prima il dato certificato, poi la strategia. IB paper (gnzsnz/ib-gateway) da' storia daily ADJUSTED_LAST (div+split) profonda. - ib_equities_probe.py: sonda fattibilita' dati (profondita', adjusted, subscription). - fetch_ib_equities.py: FETCH+CERTIFY universo -> data/raw/eq_<sym>_1d.parquet (ms epoch, namespace dedicato). RIPARTIBILE (salta i parquet gia' scritti) -> niente refetch da IB. Certifica: integrita', gap lunghi, sanita' ritorni, sanita' adjustment. - eqlib.py: harness ricerca equity. Legge la CACHE su disco (lru_cache) MAI da IB; universi (11 settori SPDR + 9 classici 1998+ + broad), panel allineato, riusa lo scorer indurito altlib. UNIVERSO CERTIFICATO (17, data/raw/eq_* gitignored = cache locale): 9 settori classici dal 1998-12-22 (27.5y) + XLRE(2015)/XLC(2018) + SPY(1996,30y)/QQQ/IWM/ GLD(2004)/HYG(2007)/TLT(2016). Tutti integri (monotoni, no dup, no spike>50%, gap-lunghi 0). Start comune: 9 classici 1998, 11 settori 2018. Prossimo passo: prima ricerca = momentum cross-sectional settoriale, gauntlet onesto. Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>	2026-06-22 21:29:11 +00:00
Adriano Dal Pastro	61180637eb	research(funding-carry): FC01 cross-sectional su HL -> fragile, NON regge + infra IB paper Onda "nuova ricerca mirata". Unico meccanismo non coperto dalle 2 ondate: carry da funding (cashflow perp, delta-neutral). Scan dati: price-clock gia' FAIL (intraday), Deribit ccxt 0 righe, Cerbero solo candele -> fonte = API pubblica Hyperliquid. - fetch_hl_funding.py: 19 major, funding orario reale dal 2023-05, certificato (0 gap, cov 98-100%, ann +1.0% APT .. +21.6% NEAR). backoff anti-429. - funding_carry_hl.py: book dollar-neutral short-alto-funding/long-basso, causale come XS01, vol-target 20%, fee 0.05%/lato. Giudizio: marginal_vs_tp01 indurito + overlap XS01. VERDETTO: il premio esiste (carry >> anti) ma il book NON regge il gauntlet. FULL -0.12, HOLD -0.50, DILUTES vs TP01, in-sample edge <0.5, no multicut. Jackknife universo: FULL oscilla [-0.39,+0.30] togliendo UN asset -> FRAGILE/overfit. (preview a 17 asset era +0.62 ADDS: fortuna, mancavano NEAR/AAVE). corr XS01 -0.19 (ortogonale, non re-skin). Meccanismo: carry-vs-momentum, gli alto-funding pompano. -> NON entra in portafoglio, fetcher NON in cron. Diario completo. Infra IB (thread parallelo): gateway paper gnzsnz/ib-gateway (127.0.0.1:4002, READ_ONLY) in docker-compose + ib_probe.py. Esito dati basis CME micro: backtest NON fattibile (ContFuture back-adjusted, scaduti=1 barra). IB ok per esecuzione/forward, non ricerca. .env.ibgw gitignored (credenziali paper), template in .env.ibgw.example. Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>	2026-06-22 20:56:18 +00:00