docs(diary): incident 2026-07-09 — "BOOK LIVE conto offline" = cert Traefik di default

Traefik auto-upgrade (latest+Watchtower -> 3.7.7) ha scartato il resolver ACME
per acme.json a 660 (3.x pretende 600) -> cert self-signed su tutto il VPS ->
DeribitRead SSLError -> book online=False. Zero trade persi (target flat, gate
di sicurezza OK). Fix: chmod 600 acme.json + restart; pin traefik:3.7 nel compose.
Diario con diagnosi, verifica end-to-end e runbook.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

.env.ibgw.example

@@ -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

.gitignore

@@ -6,6 +6,8 @@ build/
 .venv/
 .env
 !.env.example
+.env.ibgw
+!.env.ibgw.example
 .vscode/
 .idea/
 .DS_Store
@@ -52,3 +54,16 @@ logs/
 # feed backup pre-rebuild (binari rigenerabili, NON in git) + stato paper trader (runtime)
 data/_feed_backup/
 data/paper_trend/
+data/paper_portfolio/
+
+# output grezzo dello sweep di ricerca xsec (rigenerabile dagli script in runs/)
+scripts/research/xsec/runs/out/
+
+# blind-signal derived data (regenerable via make_blind.py)
+data/blind/
+scripts/research/blind/leaderboard.json
+
+# forward-monitor runtime state (regenerable, forward-only)
+data/paper_prevday/
+data/paper_combo/
+data/paper_statarb/

CLAUDE.md

@@ -13,7 +13,13 @@ Cosa è cambiato:
   **solo BTC/ETH** (tutti i TF). Gli alt sono esclusi (illiquidi/divergenti/non certificabili).
 - Tutto il codice vecchio (strategie, stack live, ~100 script di ricerca/gate, dati non
   certificati, 60+ diari) è **archiviato in `Old/`** (preservato in git, non cancellato).
-- L'esecuzione è **DISABILITATA**, il conto mainnet è flat. **Non c'è trading live attivo.**
+- ~~L'esecuzione è DISABILITATA, il conto mainnet è flat. Non c'è trading live attivo.~~
+  **AGGIORNATO 2026-06-20: l'esecuzione di TP01 è ARMATA e LIVE su Deribit mainnet** —
+  `config/live.json` `execution_enabled=true` + cron giornaliero `live_execute.py --execute`
+  (cablato in `scripts/cron_daily.sh`). Guardrail: cap **$300 notional/asset**, min order $5,
+  **disaster-SL on-book −30%**, alert Telegram su esecuzione/errori. **Capitale reale ≈ $600**
+  (NON i €2000 nominali del paper trader). Stato corrente: **flat** (target TSMOM risk-off →
+  BTC/ETH 0.0x, nessun ordine). Solo TP01 è eseguito; XS01/VRP01 restano paper/STAT-MODE.
 - Si riparte dalla ricerca di strategie NUOVE, su dati certi, con la metodologia qui sotto.
 
 ### Ricerca post-reset (2026-06-19) — esito
@@ -34,6 +40,14 @@ Prima ondata di ricerca onesta su BTC/ETH certificati (5 track, harness condivis
   Deploy/paper a **1d**. Diari `2026-06-19-tp01-verification.md` / `-tp01-lookahead-fix-lf.md`.
   Paper trader: `scripts/live/paper_trend.py` (1d). Test: `tests/test_trend_portfolio.py`.
   Ri-verifica: `scripts/analysis/{verify_tp01,stress_tp01,tp01_lowfreq}.py`.
+  ⚠️ **ANCHOR TIMING-LUCK (2026-07-02, confermato da scettico):** l'hold-out ~0.31 è calcolato
+  sull'ancora daily 00:00 UTC, che è la **migliore delle 24 possibili** (mediana ancore 0.04, banda
+  [−0.13,+0.30]; P~0.86 che una qualsiasi ancora mostri uno spike così per puro caso) → l'hold-out
+  2025-26 NON risolve l'edge di ritorno di TP01; ciò che regge a OGNI ancora è il **taglio del DD**
+  (7-10% vs ~60% B&H). FULL/plateau/deflated-Sharpe/gate INVARIATI (h=0 al 31° pctl su FULL).
+  Regola: i futuri numeri hold-out di strategie a ribilanciamento ancorato si citano con la banda
+  d'ancora. Diario `2026-07-02-timing-crt-wave.md`; script `scripts/research/r0702_tp01_offset.py`
+  + `r0702_skeptic_offset.py`.
 - **XS01 Cross-Sectional Momentum (Hyperliquid) — DIVERSIFICATORE che migliora il portafoglio** —
   `src/portfolio/sleeves.py:_xsec_returns`. Market-neutral su **19 alt liquidi major** Hyperliquid (1d,
   dal 2024): ogni 10g long i 5 più forti / short i 5 più deboli, vol-target 20%. **Scorrelato a TP01
@@ -43,13 +57,55 @@ Prima ondata di ricerca onesta su BTC/ETH certificati (5 track, harness condivis
   regime compatto). Standalone FULL Sh **1.50** / HOLD 1.71 / DD 11%, plateau robusto (lookback, gate
   p15-35). **Caveat:** storia ~2.5 anni; STAT-MODE (book a 19 gambe non eseguibile a 2k, serve ~20k) →
   monitor forward. NB il gate concentra XS nei regimi dispersi (2025-26 = hold-out alta-dispersione).
+  ⚠️ **PHASE TIMING-LUCK (2026-07-02):** i numeri headline sono sulla fase 0 del ciclo H=10, che è
+  al **15° pctl di DD** (10.8% vs ~15.5% fase tipica, 29% peggiore) e 85° di FULL fra le 10 fasi
+  (HOLD solo 65°, non estremo); P(spike per caso)≈0.91-0.94. Lens onesta = **ensemble di fase:
+  FULL 1.25 / HOLD 1.31 / DD 10.9%**; a fase mediana FULL 1.08/HOLD 1.10/DD 21%. La decisione di
+  ammissione @15% regge (0 fasi negative, 8/10 FULL≥1.0), i numeri 1.50/1.71/11% no → citarli con
+  banda di fase. Ora-del-giorno NON testabile (solo 1d HL). Script `scripts/research/r0702_anchor_xs01.py`;
+  diario `2026-07-02-anchor-audit-xs01-skh01.md`.
   Ricerca `scripts/portfolio/{xsec_research,xsec_blend,xsec_dispgate}.py`. Diari `2026-06-19-hyperliquid-xsec`
   / `-xsec-blend` / `-xsec-dispgate` / `-xsec-universe-expansion` / `-trend-multiasset`.
-- **PORTAFOGLIO ATTIVO = TP01 (55%) + XS01 (25%) + VRP01 (20%)** (`src/portfolio/sleeves.active_sleeves`):
+- **PORTAFOGLIO ATTIVO = TP01 (33%) + XS01 (15%) + VRP01 (12%) + SKH01 (20%) + GTAA01 (20%)**
-  TP01+XS01 combinato **FULL Sharpe 1.55, HOLD-OUT 1.55, DD 4.4%**. Aggiunto **VRP01** (options
+  (`src/portfolio/sleeves.active_sleeves`): TP01+XS01 combinato **FULL Sharpe 1.55, HOLD-OUT 1.55,
-  short-vol, sotto): TP01+VRP01 da solo fa FULL Sh 1.30→1.44 / HOLD 0.31→0.40 a peso 20% (3-way da
+  DD 4.4%**. Aggiunto **VRP01** (options short-vol, sotto): TP01+VRP01 da solo fa FULL Sh 1.30→1.44 /
-  validare locale con dati HL). Report `scripts/portfolio/run_portfolio.py`. Sleeve a date d'inizio
+  HOLD 0.31→0.40 a peso 20%. **Aggiunto SKH01-V2-DD @25% effettivo (2026-06-23, sotto)**: 4-sleeve
-  diverse → outer-join con pesi rinormalizzati (TP01 da solo 2019-20, VRP dal 2021, blend pieno dal 2024).
+  **FULL Sharpe 1.68→2.13, HOLD-OUT 1.63→2.30, DD full 14.3%→7.8%** (Skyhook quasi-ortogonale,
+  corr ~0.09). **Aggiunto GTAA01 @20% effettivo (2026-07-01, i 4 preesistenti scalati ×0.80):**
+  trend difensivo equity 6-ETF su IB (`src/portfolio/gtaa.py`, ~30 anni storia, validato 2026-06-22
+  su OOS equity 2015+ INDIPENDENTE dall'hold-out crypto, corr al book ~+0.10) → 5-sleeve
+  **FULL Sharpe 2.12→2.24, HOLD-OUT 2.21→2.46, DD full 7.8%→6.2%** (costo dichiarato: CAGR full
+  23.3→18.8%; 2022 unico anno con dSh−). Uplift positivo in-sample E su tutte le finestre disgiunte
+  (vs EW-STR refutato lo stesso giorno). Convenzioni: weekend/festivi equity = 0.0 (capitale IB
+  fermo, non riciclato); attivazione nel book all'era crypto 2019-03; **il book live Deribit
+  (`deribit_book_sleeves` TP01+SKH01 75/25) NON lo include** (GTAA in paper_combo dal 2026-06-23).
+  Test `tests/test_gtaa_sleeve.py`; diario `2026-07-01-strategy-wave-6threads.md` (addendum GTAA).
+  Report `scripts/portfolio/run_portfolio.py`. Sleeve a date d'inizio diverse → outer-join con pesi
+  rinormalizzati (TP01/SKH01/GTAA dal 2019*, VRP dal 2021, XS dal 2024; *GTAA troncato all'era book).
+  ⚠️ **ANCHOR-LUCK del book (2026-07-02):** l'HOLD 2.46 è calcolato con TUTTI gli sleeve ancorati
+  alla loro ancora canonica, che per TP01/XS01/SKH01 è al top della rispettiva banda (eredità di
+  fortuna ~+0.10/+0.17/+0.5 HOLD). **Stima de-luckata onesta: HOLD ~1.9-2.1, FULL ~2.0-2.2, DD ~6%
+  invariato** — il book resta positivo e diversificato a ogni ancora testata, ma 2.46 è un massimo
+  di configurazioni d'ancora, non la stima centrale. Diario `2026-07-02-anchor-audit-xs01-skh01.md`.
+- **SKH01-V2-DD "Skyhook" — DIVERSIFICATORE quasi-ortogonale (research)** — `src/strategies/skyhook.SKH01_V2_DD`,
+  sleeve `src/portfolio/sleeves._skyhook_returns`. Sistema dual-TF (segnale 690m / exec 230m) regime
+  (BuzVola/BuzVolume tipo-Chande) AND pattern (Donchian breakout), NON trend-follower, L/S. Vincitrice
+  di 2 onde multi-agente (la 2ª = DD-reduction): exit a **percentuale fissa ASIMMETRICA** (long sl4%/tp10%,
+  short sl2%/tp8% più stretto) → standalone **maxDD BTC 21% / ETH 27% (<30%)**, minFull +0.99, minHold
+  +1.26, causale (0/400), fee-surviving 0.40%RT. Marginal vs TP01 **ADDS** (corr 0.09, has_insample_edge,
+  robust_oos multicut 7/7, is_hedge=False); blend 0.75·TP01+0.25·SKH **hold-out 0.31→1.17**. Verificato
+  leak-free + 2 scettici. **CAVEAT:** equity daily-step (Sharpe lens), ETH DD margine sottile, book 230m
+  (costi ribilanciamento da verificare a deploy) → research win, forward-monitor. Diario `2026-06-23-skyhook.md`.
+  ⚠️ **GRID TIMING-LUCK (2026-07-02, più forte di TP01):** i numeri headline sono sull'offset 0 della
+  griglia 230m/690m, al **93-98° pctl dei 23 offset a priori** — minHold +1.26, blend 1.17 e book
+  HOLD 2.44 sono il MASSIMO dei 23 (mediane: minHold +0.39, blend 0.72, book 1.96); spike, non
+  plateau (±30m crolla); P(spike)≈0.70. **Il gate DD<30% (criterio di selezione di V2-DD) fallisce
+  in 15/23 offset** (mediana ETH 29.2%). Regge de-luckato: uplift blend positivo a TUTTE le 23 fasi
+  (min +0.18, med +0.42) + corr 0.05-0.11 → ADDS sopravvive ridimensionato. **LIVE (SKH=25% del book
+  Deribit):** path reale cron orario + exit software → book 50/50 FULL 1.46→1.19 / HOLD 1.64→1.15 /
+  DD 18→25%; nei crash gap-through-stop reale (sl2% modellato → −11/−23% realizzato). Pesi/book
+  INVARIATI (ogni cambio passa weights_tilt_null); follow-up: cadenza 230m, peso live da rivedere.
+  Script `scripts/research/r0702_anchor_skh01.py`; diario `2026-07-02-anchor-audit-xs01-skh01.md`.
 - **VRP01 Options Short-Vol — DIVERSIFICATORE da FinanceOld/OptionsAgent** — `src/portfolio/sleeves._vrp_combo_returns`.
   Put credit spread settimanale (vendi put -0.28, compra put -0.10) gated su IV-rank. Idee portate da
   `../FinanceOld/OptionsAgent` (Bear Call Spread + gate d'ingresso). Migliora il lead VRP nudo
@@ -59,6 +115,22 @@ Prima ondata di ricerca onesta su BTC/ETH certificati (5 track, harness condivis
   crash incluso). Scorrelato a TP01 (~+0.01-0.07). **CAVEAT:** premio MODELLATO su DVOL ATM (skew non
   esplicito), book a 1d, f di stress reale non catturato → LEAD robusto, non deploy pieno. Ricerca
   `scripts/research/options_vrp_v2.py` (vs baseline `options_vrp_lab.py`). Test `tests/test_vrp_sleeve.py`.
+  ⚠️ **ANCHOR-AUDIT CHIUSO + ondata "migliora e proteggi" (2026-07-03, 7 filoni + 2 lenti + scettico):
+  VRP01 NON è migliorabile e la protezione DD si compra SOLO con la size.** (a) **Anchor-luck (ciclo
+  settimanale, 7 fasi): PRIMO sleeve SENZA firma di luck** — la fase canonica è la PEGGIORE delle 7 su
+  FULL (1.09 = 7° pctl) e su DD (11.8% = 93° pctl), mediana su HOLD (0.59); spike bootstrap NEGATIVO →
+  i numeri di ammissione FULL 1.10/HOLD 0.60/DD 12% sono CONSERVATIVI, non gonfiati. Da ora si citano
+  con banda: ShFULL [1.09,1.83], ShHOLD [−0.03,1.11], DD [5.7,11.8%]; edge OOS f-dipendente (f=0.8 →
+  HOLD~0). **Con questo l'audit anchor è completo su 4/4 sleeve ancorati.** (b) Griglia 288 strutture:
+  nessuna batte VRP01 (DSR 0.000; metà griglia = 3ª occorrenza "0-perdite/Sharpe implausibile" dopo
+  CC01/ALB-A → gate `implausible_sharpe` alzato di priorità). (c) 4 overlay DD (exit-spike/SL-MTM/
+  ala-coda/cooldown): 4/4 REFUTED dal null de-levering — la protezione crash vive già nel gate
+  d'ingresso IV-rank. (d) Gate nuovi: 4° fallimento su 4 (l'alpha è il binario IV-rank>0.30). (e)
+  Sizing: 12% deploy ≈ 0.27 Kelly onesto (anti-rovina); ⚠️ NON confondere col 12% di PESO del book
+  (~0.014 Kelly, fattore 19x). (f) Gate term-structure VIX/VXV su SPX (ΔSh +0.90, DSR 0.992) =
+  **confound di modello al 100%** (la var del gate coincide con l'errore BS-flat vs term-structure) →
+  nuova regola: riprezzare term-structure-consistent prima di credere a un gate vol su strutture
+  BS-flat. Book/pesi INVARIATI. Diario `2026-07-03-vrp-improve-dd.md`; script `scripts/research/r0703_vrpimp_*.py` (7 file).
   Diario `2026-06-20-financeold-analysis-vrp-v2.md`.
 - **Universo Hyperliquid: ESPANDERLO NON aiuta XS01** (provato): 52-asset / top-liquidità dinamico /
   trend-multi-asset → tutti peggiori (small-cap/memecoin diluiscono il momentum relativo; il trend
@@ -78,8 +150,220 @@ Prima ondata di ricerca onesta su BTC/ETH certificati (5 track, harness condivis
   regime-luck), calendar/seasonality (buy&hold travestito), volume/vol e momentum-reversal (negativi).
 - **MORTO/confermato artefatto:** mean-reversion / fade (negativo anche a fee zero — la vecchia
   libreria +201%/+1238% era contaminazione); trend 5m/15m (fee).
+- **GAMMA SCALPING (long-vol) "scalping BTC/ETH con copertura in opzioni" — SCARTATO (2026-06-26)** —
+  `scripts/research/options_gamma_scalp.py`, test `tests/test_gamma_scalp.py`. È lo **specchio
+  esatto del VRP01** (long straddle ATM + delta-hedge: incassa **RV−IV**, dove VRP01 incassa IV−RV).
+  Perde **ogni anno, ogni variante, ogni frequenza** (Sharpe −3 a −6; nudo/cheap-gated/rich-skip;
+  rehedge 1d e 1h). Diagnostica strutturale: a 1d IV≈o>RV (BTC +4.9pp) → paghi il VRP; a 1h RV>IV
+  gross ma (a) gonfiata da microstruttura, (b) il rehedge orario paga **24× la fee di hedge** →
+  variante *peggiore* (−6). Marginale vs TP01 = **DILUTES**, non è nemmeno hedge (perde sia TP01-up
+  sia TP01-down). Muro eseguibilità: opzione BTC min $5.968 ≫ $600. Schiacciato tra due muri:
+  rehedge lento = premio, veloce = fee → **nessuna frequenza vince.** Regola gemella del VRP:
+  *niente long-vol scalp da modello in deploy*. Il VRP01 (lato short, gated) resta l'unico edge
+  opzioni — funziona perché sta sul lato *giusto* dello stesso premio. Diario `2026-06-26-gamma-scalp-options.md`.
+- **CASH-AND-CARRY (basis trade) "CC01" — premio REALE, Sharpe ARTEFATTO, NON deployabile (2026-06-26)** —
+  `scripts/research/cash_carry_hl.py`, test `tests/test_cash_carry.py`. Diverso da FC01 (funding
+  cross-sectional, già scartato): qui delta-neutral long-spot/short-perp sullo *stesso* asset →
+  ritorno ≈ **+funding** (zero esposizione prezzo). Il premio di funding è **reale** (~+8-14%/anno
+  aggregato, positivo ogni anno in-sample, ortogonale a TP01 corr ~0.05). MA lo **Sharpe modellato
+  11-13 (DD 0.3%) è un ARTEFATTO**: il modello cattura solo il cashflow liscio del funding e i
+  rischi di coda sono **strutturalmente fuori dal dataset** — (1) storico funding dal 2023-05 →
+  **manca il 2022** (deleveraging, funding −, basis blow-out); (2) **procyclico** (carry +23% toro
+  2024 → +1.7% bear 2026, si comprime quando servirebbe); (3) liquidazione short/slippage non
+  modellati. Il mark-to-market della base (`premium` col → r=funding−Δpremium) sgonfia lo Sharpe
+  solo 13→11 → il basis-from-data NON è il rischio vero. Sharpe reale di un basis-trade ~1-3 con
+  code brusche. **NON eseguibile a $600** (spot+perp = 4-38 gambe, funding HL non Deribit) → STAT-MODE.
+  **LEAD da rivedere a scala (~20k+ e venue con funding eseguibile), non uno sleeve.** Sottoprodotto:
+  CC01 passa OGNI gate del marginal scorer → **punto cieco** (manca un gate "Sharpe implausibile →
+  rischio nascosto"; prossima indurita raccomandata). Diario `2026-06-26-cash-carry-hl.md`.
+- **TP01 × DVOL vol-targeting — NON migliora (2026-06-26)** — `scripts/research/tp01_dvol_overlay.py`,
+  test `tests/test_tp01_dvol_overlay.py`. Angolo ESEGUIBILE (tocca il book live, non STAT-MODE):
+  usare il DVOL (vol implicita forward-looking) come denominatore del vol-target di TP01 invece
+  della vol realizzata. Su finestra comune 2021-2026: le varianti DVOL abbassano il DD (12.3%→9.2%)
+  ma anche Sharpe FULL (0.75→0.70) e CAGR (8%→6%). **Controllo decisivo:** il realized a target_vol
+  RIDOTTO (15%) eguaglia quel DD (9.4%) a Sharpe **più alto** (0.75) → il taglio di DD del DVOL è
+  solo **de-levering**, replicabile meglio con un semplice target_vol più basso. L'unico residuo
+  (hold-out +0.06) è single-window (storia DVOL <5 anni) → sotto la soglia multi-cut. Il gate
+  DVOL-spike de-risk è **ridondante col trend** (TP01 già flat nei crash, Δ 0.00). **Lezione: per meno
+  DD sul live la leva è `target_vol`, non un overlay DVOL** (20% resta canonico). Diario `2026-06-26-tp01-dvol-overlay.md`.
+- **Filoni 2026-06-29 (1ª ondata) — tutti scartati/forward.** (A) **DVOL-DIREZIONALE** standalone BTC/ETH
+  (buy-the-fear / IV-RV come segnale di livello): l'unico edge è un **HEDGE** (is_hedge=True, paga solo
+  quando TP01 è debole), non alpha → earns_slot=False, forward-monitor come DD-dampener (diario
+  `2026-06-29-dvol-directional.md`). (B) **INTRADAY ERM** (efficiency-ratio regime momentum sub-daily):
+  **falso positivo da selezione-sull'hold-out** → SCARTATO (vedi gate SELECTION-ON-HOLDOUT;
+  `2026-06-29-intraday-regime.md`). (C) **XSEC-V2 NON-MOMENTUM** su HL (reversal/idio-reversal/low-vol/BAB):
+  solo LOWVOL 19-major regge standalone (FULL/HOLD 1.07) ma deflated-Sharpe 0.13 + storia 2.5a → **DEBOLE/
+  forward STAT-MODE** (`2026-06-29-xsec-v2-nonmom.md`). (D) **MACRO regime-gate** (equity/credito/oro/tassi →
+  de-risk crypto): **RIDONDANTE col trend** (corr→TP01 0.989; il gate lavora solo nel 2-3% dei giorni, TP01
+  già flat nei crash) → SCARTATO (`2026-06-29-macro-regime-gate.md`).
+- **Sweep strategie a 5 thread (2026-06-29) — 0 nuovi sleeve, 1 LEAD che rompe 2 muri su 3.** Ricerca
+  parallela onesta su aree inesplorate (harness `altlib`+`xsec_v2_nonmom`, tutti i gate incl. il nuovo
+  `study_family_honest`): (1) low-risk cross-sectional, (2) momentum-structure vs XS01, (3) meta-allocazione
+  dinamica, (4) segnali ortogonali ETH/BTC, (5) 1-gamba a segnale. Esito: soffitto ~1.3 riconfermato; ogni
+  candidato ucciso dal gate giusto (deflated-Sharpe, is_hedge, selection-on-holdout, sostituzione-XS01,
+  multi-cut). Niente batte/diversifica XS01 (varianti = REDUNDANT); meta-allocazione < pesi fissi (i 4
+  sleeve già quasi-risk-parity); 1-gamba a segnale = TP01 travestito (trend) o hedge a DSR<0.95.
+  **LEAD forward-monitor:** **STATARB-RESID** (relative-MOMENTUM del residuo ETH−β·BTC, β OLS rolling, 2 gambe,
+  cella vincente **sgn=+1**: le dislocazioni ETH-vs-BTC CONTINUANO a 1d, la MR pura sgn=−1 perde) — primo
+  stream **insieme ortogonale (corr→book 0.027, β-mkt 0.013) ED eseguibile a $600** (haircut ~0, NON
+  STAT-MODE come XS01/opzioni): marginal ADDS, robust_oos, fee-survive 0.30%/gamba; resta sotto soglia solo
+  sull'**edge** (Sharpe 0.84, DSR 0.929 same-sign <0.95). **CABLATO in forward-monitor PAPER:**
+  `scripts/live/paper_statarb.py` (W=45/sgn=+1 congelati, doppio libro MODELED/REAL-$600), nel cron
+  giornaliero accanto a `paper_prevday`; test `tests/test_paper_statarb.py`. Se la finestra forward conferma
+  l'edge è *deployabile* (2 gambe BTC/ETH perp). Altri LEAD: IVOL (idio-vol XS, STAT-MODE), DVOLSPREAD
+  (storia DVOL corta). Diario `2026-06-29-strategy-search-5threads.md`. Script
+  `scripts/research/{xsec_v3_lowrisk,xsec_v3_momstruct,meta_allocation,orthogonal_signals,signal_inout_1leg}.py`.
+- **Ondata 2026-07-01 (6 filoni multi-agente + scettico) — 0 edge nuovi dai filoni, 1 gate nuovo,
+  e 1 sleeve promosso DALL'ARCHIVIO (GTAA01, sotto nel bullet portafoglio).** Filoni su angoli non coperti dalle ondate precedenti: (1) **funding time-series**
+  BTC/ETH (posizionamento) = SCARTATO — FOLLOW è trend-beta ritardato, FADE shorta il toro, il gate è
+  TP01 travestito (DSR 0.215); **il filone funding è chiuso su 3 lati** (FC01 carry, price-clock, TS).
+  (2) **breadth/internals alt** (51 HL) = SCARTATO ma unico NON-ridondante col trend (corr→TP01 0.40);
+  muore su jackknife (uplift su 1 mese) + DSR 0.433 con ~8 mesi IS → **rivisitabile tra 1-2 anni di
+  storia HL nativa**. (3) **residual momentum XS** (β-hedged, 19 major) = REDUNDANT — cross-section la
+  residualizzazione è un no-op (lo z-score di XS01 rimuove già il mercato); l'edge resta solo nella
+  coppia ETH/BTC (STATARB-RESID). (4) **ri-ottimizzazione pesi + guardia-DD**: il candidato EW-STR
+  (TP30/XS25/VRP15/SKH30, HOLD 2.21→2.35) **refutato dallo scettico come selezione-sull'hold-out di 2°
+  ORDINE** — SKH01/XS01 furono ammessi/affinati *perché* forti su quell'hold-out; pre-2025 ΔSh −0.05,
+  finestre disgiunte −0.12/+0.06/+0.14, percentile 94-100° fra 500 tilt casuali ≈ firma best-of-15.
+  Guardia-DD 5%/0.5: inerte OOS (la diversificazione fa già il lavoro; solo circuit-breaker d'emergenza).
+  (5) **affinamento VRP01** = NON MIGLIORA (l'alpha è tutto nel gate binario IV-rank; gate TP01 =
+  trappola in-sample; **3° fallimento → filone "VRP dentro il modello" esaurito** fino a f di stress
+  reale). (6) **stagionalità cross-sectional HL** = morta allo step statistico (null permutato).
+  **GATE nuovo codificato: `weights_tilt_null`** in `src/portfolio/portfolio.py` (+ `combine_outer`
+  riusabile): ogni proposta di CAMBIO PESI si giudica vs il null dei tilt casuali cap-respecting —
+  gate_pass solo se delta_insample≥0 E percentile < firma best-of-k (necessario, non sufficiente);
+  test `tests/test_weights_tilt_null.py`. ⚠️ Lezione tecnica: `DatetimeIndex.view("int64")` su indici
+  tz-aware non-ns (pandas 2.x) → scala sbagliata → `merge_asof` broadcasta = **look-ahead che
+  `causality_ok` non vede**; usare epoca esplicita in ms (altlib verificato pulito). Diario di sintesi
+  `2026-07-01-strategy-wave-6threads.md` + 6 diari di filone; script `scripts/research/r0701_*.py`.
+- **Ondata 2026-07-02 (TIMING + CRT, 8 filoni multi-agente + scettico) — 0 nuovi sleeve, 1 finding
+  strutturale (anchor timing-luck di TP01, vedi ⚠️ nel bullet TP01).** Goal: "strategie con timing
+  differenti". (1) **Event-clock bars** (volume/vol/range da 5m, TSMOM/Donchian/EWMA in tempo-informazione):
+  batte il wall-clock a pari segnale/frequenza solo in 4/45 coppie; cella best IS 1.45 → HOLD −0.46,
+  NEUTRAL (corr 0.74 = trend travestito) → SCARTATO: il clock non è dove vive l'edge. (2) **Calendario
+  scadenze Deribit** (expiry weekly/monthly/quarterly ven 08:00 UTC): 0/24 celle a Bonferroni; il drift
+  post-expiry monthly fallisce placebo-weekday e permutation e si INVERTE sul quarterly (dove l'OI massimo
+  dovrebbe amplificarlo); unico pattern robusto = gio→ven negativo, ma è day-of-week (SEA morta) a Sharpe
+  netto ~0 → SCARTATO. (3) **Anchor timing-luck TP01 + tranching**: finding confermato (dettagli nel
+  bullet TP01); tranching K=2/4 = sola riduzione della varianza della STIMA (ΔSharpe n.s., ΔDD ~0.5pt),
+  NO deploy a $600 (il min-order lo degenera in K=1; serve feed intraday fuori path certificato) —
+  rivalutare a ≥5-10k. **Audit d'ancora ESEGUITO su XS01 e SKH01 (stesso giorno): il finding si
+  replica su 3/3 sleeve ancorati** — vedi ⚠️ nei rispettivi bullet e la stima de-luckata del book
+  nel bullet portafoglio; diario `2026-07-02-anchor-audit-xs01-skh01.md`.
+  (4) **Clock lenti (2-7g) + bande isteresi**: fee drag di TP01 = ~0.4%/anno = tetto di ogni risparmio;
+  il lag costa più del risparmio (HOLD ensemble 0.34→0.11 da N=2 a 7); a $600 **il min-order $5 è GIÀ la
+  banda ottimale** (ordini −74% a costo ~0) → nessun cambio al book. (5) **Velocità trend
+  regime-condizionata** (pesi tra orizzonti 30/90/180g vs percentile vol RV/DVOL): pctl 0.71 vs null
+  pesi-statici-casuali = tilt-30d statico travestito (trappola EW-STR); pesi canonici 1/3 confermati →
+  SCARTATO. (6-8) **CRT "Candle Range Theory"** (sweep-and-reclaim 3 candele, mai coperto da MRV/MIC):
+  base 864 trial DSR 0.000 + anchor-flip + short "smart-money" negativo perfino in-sample; multi-TF
+  (4h→15m, 1h→5m, ~10k trade) expectancy negativa ovunque anche a fee zero, e **il ritest è informazione
+  negativa** (pattern con-ritest −40bps vs senza +52bps: aspettarlo seleziona i peggiori); contesto
+  (FVG/equal-highs/sessioni, 22 trial) non salva il fade, cella "Asia" = artefatto anchor-flip →
+  SCARTATO 3/3. Sottoprodotto: sugli stessi livelli prior-day **FOLLOW > FADE ogni anno 2019-26**
+  (conferma indipendente del lead prevday in forward-monitor). Lezione: il timing-luck d'ancora è
+  multiple-testing che il deflated-Sharpe NON conta (candidato gate futuro `anchor_luck_band`).
+  Diario `2026-07-02-timing-crt-wave.md`; script `scripts/research/r0702_*.py` (9 file).
+- **Ondata 2026-07-02-bis ("video claims": Elliott 3 filoni + Albimarini 2 + capital scaling) — 0 nuovi
+  sleeve, 0 forward-monitor, 1 azione config pendente sul deposito.** Meccanizzazione onesta di claim da
+  video didattici: (1) **Elliott range-cycle** (onda1 compressa→onda3 ampia): rumore, 0/24 celle a
+  Bonferroni, nessuna cella weekly regge a tutte le 7 ancore → SCARTATO. (2) **Confluenza Fibonacci**:
+  vs null ingenui sembra buona (pctl 0.82-1.00), vs null **location-matched** (Fib±jitter: "0.618 vs
+  0.58?") crolla a 0.39-0.68 = l'apparente edge è la POSIZIONE dei livelli, non i numeri; confluenza
+  FAIL 4/4 → SCARTATO (il null location-matched è IL test per ogni claim su livelli "speciali").
+  (3) **Tecnica del canale Elliott**: Donchian travestito — non batte il Donchian a pari geometria
+  (corr 0.43-0.53), DSR 0.685, cella in-sample collassa in hold-out (1.40→−0.87), target 1.618 = caso
+  (5/6 celle), anchor-luck di nuovo (4h banda hold [0.35,1.54], 00:00 la migliore) → SCARTATO.
+  (4) **Albimarini double-diagonal** (short T + long T+1, deep OTM, via motore DVOL di VRP01): il
+  condor stessa-scadenza la batte a ogni f (la long T+1 = assicurazione di coda +12/33bps nel tail,
+  ~1bps costo medio, non dominanza); senza gate IV-rank TUTTE le strutture perdono (3ª conferma:
+  l'alpha del VRP è il gate); su Deribit fee-negativa a QUALSIASI size (fee 8 gambe = 194-221% del
+  theta); celle deep-OTM 0-perdite/142 trade = 2° caso "Sharpe implausibile" dopo CC01 → gate
+  `implausible_sharpe` raccomandato con più forza. VRP01 resta superiore su tutta la banda skew →
+  nessun LEAD. (5) **Audit claims** (28 trade, 82% win, PF 5.16, "420%/anno"): consistente con ZERO
+  skill (P=20-45%; il 78.6% delle finestre 6-mesi 1996-2026 lo produce); replay con code reali =
+  rovina 1998/2002/2020 col sizing dichiarato; la diagonale lascia passare il 12-40% della perdita
+  naked. (6) **Capital scaling 600→2-5k** (`r0702_capital_scaling.py`): l'unico vincolo binding è
+  `max_notional_per_asset_usd=300` (a 5k il book live girerebbe al 49% del target) → **al deposito
+  alzare il cap a equity/2** ($1000/$1750/$2500 a 2k/3.5k/5k); min_order $5 da LASCIARE; tranching
+  K=2 non cablare (blocco feed intraday); opzioni ETH eseguibili da ~2.6k ma la regola no-short-vol-
+  da-modello non decade col capitale; XS01 ~20k confermata, CC01 fuori per struttura. Aspettativa
+  onesta col CAGR de-luckato (10-15%): 2k ≈ €0.6-0.8/g, 5k ≈ €1.4-2/g (€50/g resta ≈130k).
+  ⚠️ Lezione pandas: `resample("7D", origin=...)` IGNORA origin (pandas 2.x, solo RuntimeWarning) →
+  bande d'ancora weekly finte; usare `"168h"`. Diario `2026-07-02-elliott-albimarini-capital.md`;
+  script `scripts/research/r0702_{ell_*,alb_*,capital_scaling}.py` (6 file).
+- **Video-claim "CRT top-down multi-TF, 74% win rate" — SCARTATO (2026-07-07): il 74% è un KNOB, non
+  un edge.** `scripts/research/r0707_crt_topdown.py`. Metodo ICT/SMC top-down (H1 setup CRT → M15
+  struttura/FVG → M5 conferma → M1 entry) con uscita parziale-70/80%-a-1.5R + break-even + runner verso
+  prev-daily high/low. Il setup H1 CRT è **già triplo-refutato** (onda 2026-07-02: base DSR 0.000, MTF
+  expectancy neg. ovunque "il ritest è informazione negativa", contesto/FVG peggiora, fade<follow) →
+  qui testato l'UNICO angolo nuovo: la **gestione d'uscita** e il **claim 74%**. Su BTC/ETH certificati
+  (H1→5m/15m; M1 non nel feed): **WR reale 30–37%** a RR 1.5–2 (SOTTO il null gambler's-ruin 40% =
+  P(+1.5R prima di −1R)=1/(1+1.5) → il ritest tocca il target MENO di una moneta), **expectancy R
+  negativa a ogni schema/fee/finestra/asset** (−1.2…−3.3R netto). **Il 74% si fabbrica avvicinando il
+  target**: sweep rr1 0.5→2.0 mostra WR salire (51→32%) con expectancy R INVARIANTE (WR alto = target
+  vicino, non direzione). DSR 0.000 (48 trial); a **fee 0** expR −0.10/Sh −0.63 → **non è morte-per-fee,
+  l'edge lordo non c'è** (residuo = beta di trend dei time-exit); parziale+BE+runner = 3-4 ordini/trade,
+  alcuni sub-min-order a $600. **Regola candidata:** il win-rate di uno schema parziale+BE non è merito
+  (≈1/(1+rr1)); convertire ogni claim "WR X%" in **expectancy R netto fee** prima di crederci (helper
+  `winrate_is_a_knob()`). Diario `2026-07-07-crt-topdown-74winrate.md`. Book/pesi INVARIATI.
 - **Soffitto strutturale BTC/ETH-direzionale ~1.3** superato SOLO espandendo a un meccanismo diverso:
   cross-sectional su universo Hyperliquid certificato (XS01) → portafoglio Sharpe ~1.55.
+- **Sweep "strategie alternative" (2026-06-20) — 104 ipotesi / 153 agenti / NIENTE di nuovo regge.**
+  Ricerca onesta a largo spettro su BTC/ETH+DVOL (harness condiviso vettoriale leak-free
+  `scripts/research/alt/altlib.py`, 104 script in `scripts/research/alt/runs/`): 11 famiglie
+  (breakout, trend non-TSMOM, mean-rev gated, DVOL/vol, cross-asset pairs, stagionalità, overlay
+  rischio, opzioni modellate, microstruttura, ML walk-forward, combo). 16 promettenti, **1 sola**
+  sopravvissuta alla verifica avversariale (3 scettici) e comunque NON deployabile. Conferma forte
+  del soffitto ~1.3: ogni PASS era hold-out-fitting o **TP01/TSMOM travestito** (trend-beta del
+  toro). Unico LEAD: **STA05** (EWMA-cross ensemble, **long-short**) — leak-free, plateau, corr
+  hold-out **0.53** a TP01, il blend 0.75·TP01+0.25·STA05 alza l'hold-out 0.31→0.59 (full 1.30→1.24,
+  DD 14→16%); MA hold-out corto (536g) → **forward-monitor, non sleeve.** Lezione harness: valutare
+  lo Sharpe **MARGINALE vs baseline TP01** (non assoluto) + esigere plateau e jackknife
+  drop-one-month sull'hold-out prima di PASS (hanno ucciso 13/14 falsi positivi). Diario
+  `2026-06-20-alt-strategies-100agent-sweep.md`.
+- **MARGINAL SCORER (implementato 2026-06-20)** — la lezione "Sharpe marginale, non assoluto" è
+  ora codice in `scripts/research/alt/altlib.py`: `study_marginal(name, target_fn)` valuta un
+  candidato direzionale BTC/ETH **sia** in assoluto **sia** rispetto al baseline `tp01_baseline_daily()`
+  (corr, uplift del blend OOS, beta+alpha residua) e ritorna `earns_slot = (abs!=FAIL) AND
+  (marginal==ADDS)`. **Regola: una nuova strategia direzionale si giudica su `earns_slot`, non sullo
+  Sharpe assoluto** (gli overlay-su-TSMOM ereditano lo Sharpe di trend e prendono PASS fasulli —
+  es. CMB04 PASS assoluto → NEUTRAL marginale). Demo `marginal_demo.py`, test `tests/test_marginal_scorer.py`.
+  ⚠️ **INDURITO 2026-06-21 (onda ortho):** la versione fisso-HOLDOUT + jackknife-mese era
+  ingannabile — 17/18 book relative-value "ADDS" su una sola finestra 2025 (ETH-bleed dove TP01 è
+  debole). Tre gate nuovi in `marginal_vs_tp01`: **(1) persistenza multi-cut** (uplift positivo a più
+  date di taglio, non solo 2025); **(2) edge in-sample** (`has_insample_edge`: lo Sharpe standalone
+  PRE-holdout dev'essere ≥0.5 — un low-corr a Sharpe ~0.3 "aggiunge" solo matematica di
+  diversificazione, riportata via `null_pctl_*` vs un asset-rumore a corr-zero); **(3) hedge vs
+  alpha** (`is_hedge`: un low-corr che paga SOLO quando TP01 è debole — `corr(Sharpe-TP01, uplift
+  annuo)` molto negativa — è un hedge, non alpha). Verdetti nuovi: HEDGE, NOISE. Sull'onda ortho lo
+  scorer indurito collassa 17/18 → **1** (`dvol_spread`, unico con edge in-sample reale; comunque
+  forward-monitor per multiple-testing/storia DVOL corta). Lezione: un nuovo sleeve si giudica su
+  edge-in-sample + persistenza multi-cut + non-hedge, non sull'uplift di una finestra fortunata.
+- **HARNESS REALISM (codificato 2026-06-21, onda intraday)** — due gate nuovi in `altlib.py`,
+  test `tests/test_harness_realism.py`:
+  - **`day_boundary_robust(target_fn, tf)`** — un effetto ora/sessione/giorno il cui uplift
+    marginale **si inverte** spostando il confine del giorno UTC di poche ore è un **artefatto di
+    etichettatura calendario** (ha ucciso `open_drive`: +0.23 a 00:00 → −0.33 a +8h → ARTIFACT-RISK).
+    Un segnale di prezzo è INVARIANT (spread 0); un effetto calendario vero è ROBUST (resta positivo;
+    es. `prevday_range_breakout`). **Regola: ogni segnale calendar/session/hour passa questo test
+    prima di crederci.**
+  - **`eval_weights_smallcap(df, target, capital=600, min_order=5)`** — a ~$600 un ribilanciamento
+    di nozionale < min_order **non si esegue**; la fee proporzionale che `eval_weights` applica a
+    migliaia di micro-trade sub-dollaro (tipici di un overlay vol-target) è **finzione**. Salta i
+    sub-min_order e riporta lo **Sharpe haircut** reale vs modellato. **Vale per OGNI sleeve a questo
+    capitale, TP01 incluso** — lo Sharpe netto onesto a $600 è quello small-cap, non quello modellato.
+- **SELECTION-ON-HOLDOUT gate (codificato 2026-06-29, filone B intraday ERM)** — terzo gate in
+  `altlib.py`, test `tests/test_harness_realism.py`. Il lead ERM faceva `earns_slot=True` MA lo script
+  di scoperta sceglieva la cella per **`min_hold` massimo** su 60+ celle = **selezione-sull'hold-out**:
+  scegliendola in-sample-only ne esce un'altra (trend-beta corr→TP01 0.53, NEUTRAL) e il deflated-Sharpe
+  crolla (DSR 0.0-0.24 su 122 trial). `study_marginal` da solo non lo vede (giudica UNO stream, non *come*
+  è scelto). Tre funzioni: **`deflated_sharpe()`** (Bailey & Lopez de Prado, PASS ≥0.95), **`select_cell_insample()`**
+  (cella scelta col solo Sharpe pre-HOLDOUT), e il gate combinato **`study_family_honest(name, factory, grid, tfs)`**
+  → `earns_slot_honest = earns_slot[cella in-sample] AND deflated-Sharpe≥0.95`. **Regola: una strategia
+  direzionale grid-searched si giudica con `study_family_honest`, non chiamando `study_marginal` sulla
+  cella a max hold-out.** Chiude il punto cieco gemello di CC01 ("Sharpe implausibile"). Diario
+  `2026-06-29-intraday-regime.md` (analisi `scripts/research/intraday_regime_analysis.py`).
 - **Onestà sul target €50/giorno:** NON raggiungibile su 2000 in 1-2 anni (servono ~130k di
   capitale o un DD da rovina). La leva non è la scorciatoia; la via è target-vol + capitale +
   tempo. La strategia che *guadagna* esiste, ma a ~+€1.5/giorno su 2000.
@@ -108,7 +392,7 @@ src/strategies/indicators.py → indicatori condivisi (ema, atr, keltner, ...)
 src/strategies/trend_portfolio.py → TP01: strategia DIFENSIVA robusta (PORT LF1d, >=12h), causale
 src/portfolio/             → PORTAFOGLIO DI STRATEGIE estensibile (Sleeve + StrategyPortfolio)
   portfolio.py             → combina N sleeve per peso su griglia giornaliera; metriche FULL/hold-out/anno
-  sleeves.py               → REGISTRY sleeve attivi: TP01 (55%) + XS01 (25%) + VRP01 (20%). Aggiungere = una riga
+  sleeves.py               → REGISTRY sleeve attivi: TP01 33 / XS01 15 / VRP01 12 / SKH01 20 / GTAA01 20. Aggiungere = una riga
 src/fractal/               → indicatori frattali (patterns.py, indicators.py, similarity.py)
 src/backtest/engine.py     → engine di backtesting riusabile
 src/backtest/harness.py    → harness ONESTO (load BTC/ETH, backtest_signals no-leakage, OOS)

config/live.json

@@ -0,0 +1,9 @@
+{
+  "_nota": "Config esecuzione LIVE del BOOK DERIBIT (TP01+SKH01 nettati in software). execution_enabled=true + --execute -> ordini REALI. ARMATO 2026-06-23: esecutore scripts/live/book_execute.py via cron ORARIO scripts/cron_book.sh (SKH01 e' a 230m). disaster-SL on-book -30% sulla posizione netta. Tutto flat all'arming -> nessun ordine finche' un segnale non arma.",
+  "_nota_cap": "Cap notional per-asset DINAMICO (frontiera 2026-07-03): con max_notional_per_asset_frac=0.5 il cap = equity/2, cosi' cresce col capitale e un deposito non resta strozzato. A ~$600 equity/2=~$300 -> INERTE (identico al vecchio cap fisso). Il cap dinamico si usa solo con equity reale fidata; su fallback/offline si ripiega su max_notional_per_asset_usd (protezione downside). Per tornare al cap fisso: rimuovere max_notional_per_asset_frac.",
+  "execution_enabled": true,
+  "max_notional_per_asset_usd": 300,
+  "max_notional_per_asset_frac": 0.5,
+  "min_order_usd": 5,
+  "disaster_sl_pct": 0.30
+}

docker-compose.yml

@@ -10,3 +10,23 @@ services:
       - "8787:8787"
     volumes:
       - ./data:/app/data:ro
+      # 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

docs/diary/2026-06-20-alt-strategies-100agent-sweep.md

@@ -0,0 +1,167 @@
+# Sweep "strategie alternative su Deribit" — 104 ipotesi, 153 agenti (2026-06-20)
+
+## Cosa
+Ondata di ricerca onesta richiesta esplicitamente con >=100 agenti: **studiare strategie di
+trading ALTERNATIVE** a TP01/XS01/VRP01 sull'universo certificato Deribit (**BTC/ETH** OHLCV +
+**DVOL**). Catalogo di **104 ipotesi distinte** su 11 famiglie, **un agente-finder per ipotesi**,
+poi **verifica avversariale a 3 scettici** per ogni finding promettente, poi sintesi. Totale
+**153 agenti**, ~5.86M token, ~2h (workflow `scripts/research/alt/wf_altstrat.js`,
+run `wf_0f3659fc-809`).
+
+Famiglie: BRK (breakout/canali), TRD (trend non-TSMOM), MRV (mean-reversion gated), VOL (DVOL +
+vol realizzata, Deribit-specific), XAS (cross-asset BTC/ETH: ratio/lead-lag/cointegrazione/RS),
+SEA (stagionalità/ora-del-giorno), RSK (overlay difensivi), OPT (strutture opzioni modellate su
+DVOL), MIC (microstruttura/candele), STA (ML walk-forward), CMB (combinazioni/filtri).
+
+## Harness condiviso (nuovo, validato)
+`scripts/research/alt/altlib.py` — libreria di valutazione ONESTA e **vettoriale** usata da tutti
+gli agenti, così il no-look-ahead è strutturalmente impossibile:
+- `eval_weights(df, target)`: posizione decisa con dati `<= close[i]`, **tenuta durante la barra
+  i+1** (lo shift lo fa la libreria), fee su turnover, **fee-sweep** 0.00–0.30% RT incorporato.
+- `study_weights/study_signals`: ogni ipotesi girata su **entrambi gli asset** + **HOLD-OUT 2025+**
+  + per-anno, con verdetto conservativo PASS/WEAK/FAIL (richiede min-asset full>=0.5 **e** hold>=0.2
+  **e** sopravvivenza fee).
+- DVOL allineato **causalmente** (`merge_asof` backward), storia dal 2021-03.
+- **Calibrazione:** la replica TSMOM riproduce i numeri noti leak-free di TP01 (BTC full 1.12 /
+  hold 0.31, DD 77%→23%); buy&hold correttamente FALLISCE l'hold-out (full 0.79, hold −0.37).
+  104 script riproducibili in `scripts/research/alt/runs/`.
+
+## Esito — NIENTE di nuovo batte o diversifica lo stack esistente
+Su 104 ipotesi: **16 promettenti**, **1 sola sopravvissuta** alla verifica avversariale (STA05),
+e anch'essa **ridondante/non deployabile**. È il risultato pulito e atteso per un progetto al suo
+**soffitto strutturale BTC/ETH-direzionale ~1.3** (già documentato). Lo stack
+**TP01 (55%) + XS01 (25%) + VRP01 (20%) resta imbattuto** da questa ondata.
+
+Il segnale ricorrente: decine di trend-follower prendono **FULL Sharpe alto (~1.0–1.3)** ma
+**HOLD-OUT 2025 negativo** (Supertrend, ADX-EMA, Heikin-Ashi, Turtle, SMA200-regime,
+Donchian+Chandelier, Kalman, OBV, body-ratio, ...): è **trend-beta del toro**, non alpha, e si
+rompe nell'hold-out. I PASS apparenti erano quasi tutti **(a)** singola cella fortunata
+sull'hold-out, oppure **(b)** TP01/TSMOM con un overlay attaccato sopra.
+
+### L'unico sopravvissuto: STA05 — EWMA-cross ensemble vote (LEAD, non sleeve)
+Voto d'insieme su 13 coppie EMA (fast {5,10,20,40} × slow {40,80,120,200}, fast<slow),
+posizione = voto medio firmato, vol-target 20%/cap 2x, 1d. Verifica: **leak-free** (perturbazione
+barre future = 0), **plateau** di parametri, **non** fortuna di un singolo anno (jackknife
+drop-one-year 0.55–0.96), sopravvive fee a 0.30% RT. Ho rieseguito il **blend test** raccomandato
+(50/50 BTC+ETH, mia stessa griglia di TP01, fee 0.10% RT):
+
+| variante | FULL Sh | DD | HOLD Sh | corr→TP01 (full/hold) |
+|---|---|---|---|---|
+| TP01 (canonico, controllo) | **+1.30** | 14.3% | +0.31 | — |
+| STA05 long-only | +1.24 | 16.3% | +0.21 | **0.93 / 0.94** → ridondante |
+| STA05 **long-short** | +0.87 | 28.6% | **+0.86** | **0.71 / 0.53** |
+
+Blend TP01+STA05_LS: `0.75·TP01 + 0.25·LS` → **FULL 1.24, HOLD 0.31→0.59, DD 16.1%**;
+`0.50/0.50` → FULL 1.13, **HOLD 0.75**, DD 18.8%.
+
+**Lettura onesta (più precisa della sintesi del workflow, che lo aveva liquidato come "dominato
+su ogni asse"):** la versione **long-only** è ridondante con TP01 (corr 0.94). La versione
+**long-short** invece è solo moderatamente correlata (**0.53 nell'hold-out**) e **migliora
+davvero l'hold-out del blend** (0.31→0.59 a peso 25%), al costo di un po' di FULL Sharpe
+(1.30→1.24) e DD (14%→16%). MA: l'hold-out è **solo 536 giorni** (include lo stub 2026 corto) →
+classica trappola "bello OOS ma OOS breve", e standalone ha DD 28.6%. **Verdetto: LEAD da
+monitorare forward, NON deploy, NON sleeve confermato.** Da rivalutare quando l'hold-out cresce.
+
+## Famiglie confermate MORTE / ridondanti (negativi onesti)
+- **BRK** breakout (Donchian/Keltner/Bollinger/ORB/NR7/inside-bar): ogni variante rompe l'hold-out
+  BTC; l'unico PASS (BRK04) è cella singola overfit con maxDD 63%.
+- **TRD** trend non-TSMOM: tutto trend-beta del toro ridondante con TP01; i 4 PASS (TRD02/07/08/10)
+  sono fortuna di singola cella sull'hold-out, dominati dal TSMOM.
+- **MRV** mean-reversion: la crypto **tende, non torna**; molti negativi anche a fee zero, **0 PASS**
+  → conferma su dati certi la lezione v2.0.0 ("il fade è artefatto").
+- **VOL** gate/overlay DVOL su TSMOM: ogni overlay (VOL03/04/08/09/11) è **peso morto netto-negativo**;
+  la parte robusta è sempre TP01 nudo, la componente DVOL/EWMA aggiunge anti-valore.
+- **XAS** spread BTC/ETH (ratio/lead-lag/cointegrazione/RS/dual-mom): gli spread **tendono non
+  revertono** (negativi a fee zero); le "rotazioni" PASS (XAS03/04/09) sono TP01 travestito con
+  selezione fortunata sull'hold-out.
+- **SEA** stagionalità: fee-killed a 1h, artefatti di regime a 1d, nessun hold-out cross-asset.
+- **RSK** overlay di rischio (circuit breaker/kill-switch/DD-scaling/inverse-vol RP): o seguono il
+  prezzo (buy&hold travestito) o aggiungono frizione senza proteggere dove serve.
+- **MIC** micro-pattern candele: hold-out crolla cross-asset; l'unico "survivor" MIC05 è l'artefatto
+  di **un singolo evento** (short del crash 2026-01-29 su ~13 trade).
+- **STA** ML su feature di prezzo (Ridge/Logistic/RF/Kalman/SGD/AR1/k-means): nessun potere
+  predittivo OOS; l'unico PASS (STA05) è l'ensemble di trend = TP01.
+- **CMB** combinazioni: ogni combo è TP01 più un filtro che distrugge valore.
+- **OPT** strutture opzioni (modellate su DVOL ATM, niente skew): code severe (ETH maxDD 96% su
+  iron condor), **lead-only** al meglio → conferma la regola VRP01 "niente short-vol da modello in
+  deploy". Numeri tipo OPT02/OPT04 hold-out 2.4/1.96 sono artefatto del premio modellato + asset
+  asimmetrico (ETH fallisce) → giustamente NON promettenti.
+
+## Lezioni metodologiche (azionabili)
+1. **L'harness deve premiare lo Sharpe MARGINALE vs un baseline TP01, non lo Sharpe ASSOLUTO.**
+   `study_weights` valuta lo Sharpe assoluto: così ogni overlay-su-TSMOM **eredita** lo Sharpe di
+   trend di TP01 e prende un PASS fasullo (VOL03/04/08/09/11, CMB04/06). Per la prossima ondata:
+   valutare il **contributo incrementale** rispetto a TP01 nudo, così gli overlay non possono
+   ereditare un PASS.
+2. **Prima di gradare PASS, esigere (a) un PLATEAU di parametri (non una cella isolata) e (b) un
+   jackknife drop-one-month / drop-best-day sull'hold-out.** Questi due check da soli hanno ucciso
+   **13 dei 14** falsi positivi in verifica avversariale.
+3. La verifica avversariale a 3 scettici con angoli diversi (leak / overfit-robustezza /
+   plausibilità-economica-vs-TP01) ha funzionato: ha distinto i 15 falsi positivi dall'1 robusto.
+
+## Raccomandazione
+**Non aggiungere nulla di questa ondata al portafoglio live.** Lo spazio
+**BTC/ETH-direzionale single-asset è esaurito**: ogni PASS era hold-out-fitting o un overlay su TP01.
+Redirigere il budget di ricerca verso **meccanismi davvero diversi** dove il soffitto non morde:
+espandere/monitorare forward **XS01** (cross-sectional sui 51 alt Hyperliquid certificati — l'unico
+che abbia mai battuto il soffitto) e **VRP01 reale** (quando cerbero-bite cattura skew live + uno
+stress). Tenere **STA05_LS** in lista LEAD per il forward-monitor dell'hold-out.
+
+Artefatti: `scripts/research/alt/altlib.py`, `scripts/research/alt/runs/*.py` (104),
+`scripts/research/alt/wf_altstrat.js`, verifica blend `/tmp/verify_sta05.py`.
+
+## Follow-up — MARGINAL SCORER implementato (non più solo raccomandazione)
+La lezione #1 ("valutare lo Sharpe MARGINALE vs baseline TP01, non assoluto") è ora **codice**
+in `altlib.py`:
+- `tp01_baseline_daily()` — TP01 CANONICAL 50/50 BTC+ETH, rendimenti netti giornalieri (cache).
+  Riproduce il canonico (full 1.30 / hold 0.31) — bloccato da test.
+- `marginal_vs_tp01(cand_daily)` — corr a TP01 (full/hold), **uplift del blend** (Sharpe di
+  TP01+w·cand meno TP01, full & hold-out, w∈{0.25,0.5}), **beta a TP01 + alpha residua** (parte
+  ortogonale al trend), e un **verdetto**: ADDS / REDUNDANT / DILUTES / NEUTRAL.
+- `study_marginal(name, target_fn)` — valuta un candidato **sia** in assoluto (`study_weights`)
+  **sia** marginale; `earns_slot = (abs_grade != FAIL) AND (marginal_verdict == ADDS)`.
+- Convenzione pulita `target_fn(df, asset)` (via `_call_target`) per le strategie DVOL/cross-asset
+  — niente più inferenza-asset hacky (il VOL03 dell'agente la sbagliava, usava DVOL BTC anche per ETH).
+- Demo riproducibile `scripts/research/alt/marginal_demo.py` + test `tests/test_marginal_scorer.py`.
+
+**Dimostrazione (la prova che il fix discrimina):**
+
+| candidato | assoluto | marginale | earns_slot |
+|---|---|---|---|
+| TP01-itself (sanity) | WEAK | REDUNDANT (corr 1.0, uplift 0) | False |
+| **STA05 long-short** (il lead) | PASS | **ADDS** (corr-hold 0.53, blend-hold +0.29) | **True** |
+| STA05 long-only | WEAK | REDUNDANT (corr 0.93/0.94) | False |
+| VOL03 DVOL-gated TSMOM (overlay) | WEAK | NEUTRAL (corr 0.93, uplift triviale) | False |
+| **CMB04 momentum+low-vol (overlay)** | **PASS** | **NEUTRAL** (corr 0.94) | False |
+
+Il punto chiave è l'ultima riga: **CMB04 prendeva un PASS assoluto col vecchio harness, ma il
+marginal scorer lo declassa correttamente** — il suo "Sharpe 1.0" è trend di TP01 ereditato al 94%,
+non alpha nuovo. Regola operativa d'ora in poi: una nuova strategia direzionale BTC/ETH si giudica su
+`study_marginal` (earns_slot), non sullo Sharpe assoluto.
+
+## "Resta qualche candidato?" — gate marginale + jackknife su TUTTI i contendenti forti
+Passati i 7 promettenti più forti non-ancora-marginal-testati (`marginal_remaining.py`):
+Vortex/Hull (FAIL nella ricostruzione pulita), VOL11 kill-switch (corr 0.94 → REDUNDANT), XAS03/09
+rotazioni (NEUTRAL, anzi RS-rotation **diluisce** l'hold-out −0.20), **TRD07 KAMA** e **VOL08**
+(entrambi marginale=ADDS). Ma il marginal-point-estimate **può essere ingannato da un singolo mese**:
+ho aggiunto al gate il **jackknife OOS** (`robust_oos` = uplift positivo nell'anno OOS pulito 2025
+**e** sopravvive al drop-best-month). Risultato:
+
+| candidato | clean-2025 uplift | drop-best-month | robust_oos | earns_slot |
+|---|---|---|---|---|
+| TRD07 KAMA | +0.089 | **−0.034** | False | **False** (era ADDS!) |
+| VOL08 RV-term | +0.158 | +0.034 | True | **True** |
+| STA05 long-short | +0.039 | +0.131 | True | True (ma 2025 ~0, il grosso è lo stub 2026) |
+
+**KAMA è il falso-positivo istruttivo:** ingannava il marginal scorer (uplift +0.056) ma muore al
+jackknife (−0.034 togliendo il mese migliore) → il gate rinforzato (`earns_slot` ora esige
+`robust_oos`) lo uccide correttamente. Codificata così la lezione #2 in `marginal_vs_tp01`.
+
+### Verdetto finale: NESSUN candidato deployabile
+Dopo il gate più severo (abs≠FAIL + marginale=ADDS + jackknife OOS), i 104 collassano a **2 LEAD
+fragili**: **VOL08** (overlay term-structure di vol realizzata) e **STA05_LS** (ensemble EMA
+long-short). Entrambi sono **famiglia-trend su BTC/ETH** (non un meccanismo nuovo), moderatamente
+correlati a TP01 (0.53–0.61 hold-out), con uplift piccolo e concentrato su un OOS di ~1.5 anni →
+**forward-monitor, NON sleeve.** E sono correlati tra loro (entrambi trend) → di fatto **un solo
+tema**: "una costruzione di trend-timing alternativa, modestamente decorrelata a TP01 nel 2025-26".
+La diversificazione vera resta fuori dallo spazio direzionale single-asset (→ XS01 / opzioni reali).

docs/diary/2026-06-20-vrp-active-management.md

@@ -0,0 +1,43 @@
+# VRP01 + gestione attiva intra-trade — A/B onesto (NEGATIVO)
+
+**Data:** 2026-06-20
+**Script:** `scripts/research/options_vrp_managed.py`
+**Esito:** la gestione attiva del documento credit-spread **distrugge l'edge**. VRP01
+**hold-to-expiry resta superiore.** → scartata.
+
+## Cosa testava
+
+Innesta sul put credit spread di VRP01 le regole intra-trade del doc `strategia-credit-spread-eth`:
+profit-take 50% del credito, stop-loss 1.5× il credito, **VOL-STOP** (chiudi se DVOL sale ≥10 punti
+dall'apertura — regola crypto-specifica nuova), **delta-exit** (chiudi se |delta| short put ≥0.30),
+time-stop 7 DTE. A/B sugli **stessi ingressi gated** (VRP>0 + IV-rank>0.30) e dati certificati;
+MTM giornaliero dello spread via BS sul path certificato + DVOL reale (causale).
+BASE = hold-to-expiry (come VRP01) vs MANAGED = stesso trade gestito.
+
+## Risultato (combo 50/50 BTC+ETH, sleeve-level)
+
+| variante | Sharpe | DD | ret | HOLD Sh |
+|----------|--------|------|------|---------|
+| 14d hold-to-expiry (BASE) | **0.96** | 11.7% | +39% | +1.52 |
+| 14d + solo vol-stop | 0.12 | 10.1% | +3% | +1.01 |
+| 14d FULL managed | **−1.29** | 14.8% | −15% | −1.17 |
+
+Per-asset: la gestione FULL ribalta entrambi (ETH 0.33→−1.15, BTC 1.88→−0.89). Il **delta-exit**
+domina le uscite (18-25 trade su ~33-45) e taglia i vincenti prima della decadenza theta; persino
+il **vol-stop da solo** quasi azzera il ritorno (combo Sh 0.12). Win-rate crolla 80-94% → ~40%.
+
+## Lettura
+
+Per un venditore di premio short-vol l'edge È la decadenza theta tenuta fino a scadenza: ogni
+uscita anticipata (delta, vol-stop, PT) **monetizza meno theta e/o realizza la coda** invece di
+lasciarla riassorbire. Le regole di "difesa" del doc azionario/ETH non trasferiscono al VRP crypto
+modellato: l'unica gestione che non danneggia è **non gestire** (hold-to-expiry, come VRP01 già fa).
+
+**Caveat invariato:** premio MODELLATO su DVOL ATM (no skew) + nessun fill di stress reale → tutto
+ciò resta a livello di LEAD, non deploy. Ma la conclusione relativa (BASE > MANAGED) è robusta
+perché è un A/B sugli **stessi** trade e dati.
+
+## Azione
+
+Nessuna modifica a VRP01 (`sleeves._vrp_combo_returns`, hold-to-expiry). Script conservato come
+riferimento dell'esperimento scartato.

docs/diary/2026-06-20-xsec-strategies-sweep.md

@@ -0,0 +1,133 @@
+# Sweep strategie cross-sectional su Hyperliquid (xsec) — 43 script / 257 config
+
+**Data:** 2026-06-20
+**Harness:** `scripts/research/xsec/xslib.py` (nuovo) + 43 script in `scripts/research/xsec/runs/`
+**Verifica:** `scripts/research/xsec/verify_survivors.py` (3 scettici, deterministico)
+**Esito in una riga:** niente di deployabile; il cluster vincente appariscente è **una sola
+scommessa di regime (short alt-beta)**, ma **2 lead genuini** (XM09 trend-gated x-sec momentum,
+XR02 reversal vol-gated) sopravvivono a tutti gli scettici → **forward-monitor, non sleeve.**
+
+## Contesto e motivazione
+
+Dopo che il sweep BTC/ETH a 104 ipotesi (`2026-06-20-alt-strategies-100agent-sweep.md`) ha
+esaurito lo spazio direzionale single-asset confermando il soffitto ~1.3, la frontiera indicata era
+**cross-sectional / multi-asset** sul panel Hyperliquid certificato, dove quel soffitto non vincola
+e dove c'è spazio DISTINTO da XS01 (x-sec momentum semplice sui 19 major).
+
+Nuova harness condivisa `xslib.py`: il panel è N asset × ~810 giorni (universo `all` = **49 alt**
+con ≥700g dopo il fix backfill; `majors` = 19 di XS01). Una strategia = uno **score per-asset
+causale** (dati ≤ close[i]); l'harness lo classifica cross-section ad ogni ribilanciamento, va long
+i top-k / short i bottom-k (market-neutral) o long-only, vol-targeta al 20%, addebita fee sul
+turnover, e — strutturalmente leak-free — il peso deciso a `i` incassa il return di `i+1` (stessa
+convenzione di `src.portfolio` xs_book / `sleeves._xsec_returns`).
+
+**Scoring onesto** (`study_xs`): un candidato guadagna `earns_slot=True` SOLO se
+`full Sharpe>0 AND hold-out 2025+ Sharpe>0 AND marginal_vs(active)=="ADDS" AND corr(XS01)<0.6`.
+`ADDS` a sua volta richiede `holdUplift_w20 ≥ 0.05 AND robust_oos` (uplift hold-out >0.02 **e**
+jackknife drop-one-month tutti positivi). È il marginal scorer del sweep precedente, portato sul
+cross-sectional: si giudica **l'apporto al portafoglio live** (TP01+XS01+VRP01), non lo Sharpe
+assoluto.
+
+**Caveat cotto dentro l'harness:** il panel è **~2.5 anni** (2024-26). Ogni risultato è
+SUGGESTIVO, non robusto come i 6 anni di BTC/ETH. E l'hold-out (2025-26) è **un singolo regime**
+(alt-bear/chop relativo a BTC).
+
+## Find phase — 43 script, 257 sotto-config
+
+11 famiglie cross-sectional: MOM (varianti momentum), REV (reversal), VOL/RISK (low-vol, low-beta,
+BAB, semivarianza, vol-of-vol), DIST (skew/coskew lottery), LIQ (Amihud/turnover/volume),
+VAL (distanza da MA, RSI), STRUCT (double-sort, ensemble z-vote, risk-parity, low-corr, trend-R²,
+lead-lag BTC), UNIV (sweep di universo). **Esito: 42/257 config `earns_slot=True`.**
+
+Sembra molto. Ma **due tell** accomunano quasi tutti gli slot-earner:
+1. corr a TP01 **fortemente negativa** (−0.2…−0.4) — è *per questo* che "aggiungono";
+2. PnL **concentrato nel 2025** (ritorni +22%…+84% nel 2025).
+
+Top per Sharpe/uplift (rappresentante per famiglia):
+
+| id | meccanismo | univ | FULL Sh | HOLD Sh | upliftHold | jackknife | corr TP01 | corr XS01 |
+|----|-----------|------|---------|---------|-----------|-----------|-----------|-----------|
+| XR02-L3-p70-maj | reversal gated alta-vol | maj | 1.40 | **2.27** | 1.078 | 0.744 | 0.02 | 0.08 |
+| XV02_majors_H10k5 | low **idio**-vol | maj | 1.32 | 1.95 | 1.196 | 0.792 | −0.20 | −0.06 |
+| XL02-vz60r20-maj | vol-trend momentum | maj | **1.83** | 1.84 | 0.568 | 0.125 | 0.13 | 0.08 |
+| XM09_all | trend-gated x-sec mom | all | 1.29 | 1.59 | 0.556 | 0.355 | −0.07 | 0.25 |
+| XS01b-MAJ | double-sort mom×low-vol | maj | 1.36 | 1.23 | 0.427 | 0.16 | −0.29 | 0.38 |
+| XU02/XV01 lowvol | low realized-vol | maj | 1.05 | 0.98 | 0.425 | 0.186 | −0.34 | 0.16 |
+| XV03 lowbeta (BAB) | −beta | all | 0.36 | 0.71 | 0.22 | 0.051 | −0.38 | 0.19 |
+| XS06b lowcorr | −corr(asset,market) | all | 0.74 | 1.00 | 0.286 | 0.092 | −0.19 | 0.18 |
+
+## Verify phase — 3 scettici (`verify_survivors.py`)
+
+Ipotesi sotto test: *"non sono N edge indipendenti, ma UNA scommessa di regime — short la
+spazzatura high-beta nell'alt-bear 2024-26 — travestita da 30 maschere; il jackknife è robusto solo
+DENTRO quel regime."* Ricostruito il book più forte per famiglia e:
+
+**S1 — matrice di correlazione mutua (>0.6 = stessa scommessa).** Esito SFUMATO:
+- Il cluster low-vol È una sola scommessa: **XV01 = XU02 = 1.00** (identici), XV01↔XV02 0.65,
+  XV01↔XV03 0.67, XV02↔XV03 0.44.
+- MA **XM09, XL02, XS06b, XR02 sono distinti** dal cluster e tra loro (corr media off-diagonale
+  solo **+0.20**, solo 18% delle coppie |r|>0.6). L'ipotesi "tutto una scommessa" è **parzialmente
+  falsa**.
+
+**S2 — carico su short-beta / short-market** (factor di riferimento sullo stesso panel:
+SHORTBETA = book su −beta; SHORTMKT = −market alt equal-weight):
+- **Cluster low-vol = short-alt-beta confermato:** XV03 1.00/0.70, XV01/XU02 **0.67/0.64**,
+  XV02 0.44/0.37. *Non* market-neutral: è un tilt short del mercato alt.
+- **NON short-beta:** XM09 0.08/0.15, XR02 −0.21/−0.18, XL02 0.19/0.26, XS06b 0.36/0.39.
+
+**S3 — Sharpe per anno solare (l'edge è ~solo 2025?):**
+
+| survivor | 2024 | 2025 | 2026 |
+|----------|------|------|------|
+| XV02_lowidiovol | 0.07 | 1.87 | 2.12 |
+| XV01/XU02 lowvol | 1.17 | 1.52 | **−0.09** |
+| XV03_lowbeta | −0.25 | 0.98 | 0.12 |
+| XS06b_lowcorr | 0.26 | 1.34 | 0.32 |
+| **XM09_trendgmom** | **0.82** | **0.50** | **0.74** |
+| XL02_voltrendmom | 0.30 | **−0.14** | **−0.43** |
+| **XR02_revgated** | **0.84** | **0.40** | **2.68** |
+
+## Conclusioni (oneste)
+
+1. **Cluster low-vol / low-beta (XV01, XU02, XV02 in parte, XV03) = tilt short-alt-beta di regime.**
+   S2 lo inchioda (carico 0.44-0.70 su short-market): non è un fattore market-neutral, è "short la
+   spazzatura" mentre gli alt sanguinano vs BTC. XV01/XU02 **già in decadimento (2026 −0.09).** Non
+   può dimostrare di sopravvivere a un flip alt-bull. → **RIGETTATO come sleeve.** Conferma
+   l'osservazione 4874 (XS04b = regime-dependent short-beta tilt) generalizzata all'intera famiglia.
+
+2. **XL02 (vol-trend momentum) = overfit al panel iniziale.** FULL Sharpe più alto (1.83) ma S3 lo
+   uccide: 2025 −0.14, 2026 −0.43. Il numero full è guidato dal 2024, ora è morto. → **RIGETTATO.**
+
+3. **2 LEAD genuini** — distinti (S1), NON short-beta (S2), positivi in **tutti e 3 gli anni** (S3):
+   - **XM09 — cross-sectional momentum gated dal trend di mercato.** Long top-k/short bottom-k alt,
+     attivo solo quando la somma trailing del mercato equal-weight è >0. Sharpe 0.82/0.50/0.74,
+     short-beta-load 0.08, corr TP01 −0.07, uplift hold 0.556 / jackknife 0.355. È il candidato più
+     regime-robusto. **Caveat:** stessa FAMIGLIA di XS01 (x-sec momentum) su universo più largo (49)
+     con gate diverso (trend di mercato vs dispersione) → più un **possibile affinamento di XS01**
+     che una sleeve nuova; corr XS01 0.25, ma marginal scorer dice che ADDS oltre XS01.
+   - **XR02 — short-term reversal gated da alta-vol.** Reversal a 3g attivo solo quando la vol
+     realizzata di mercato è nel regime alto (>p70 espandente). Sharpe 0.84/0.40/**2.68**,
+     short-beta-load −0.21, corr a tutto il resto ~0/negativa, hold-out Sharpe 2.27. Microstruttura
+     reale (overreaction in panico). **Caveat:** H=3 → **turnover alto**; il reversal vive proprio
+     sull'illiquidità che lo rende costoso da eseguire (l'harness addebita fee sul turnover e regge,
+     ma il fill reale su alt minori è ottimistico).
+
+## Perché NON deployabili adesso (caveat trasversali)
+
+- **Panel ~2.5 anni a regime unico.** Anche i 2 lead hanno hold-out = 2025-26 = stesso macro-regime.
+  Suggestivi, non robusti come i 6 anni BTC/ETH.
+- **STAT-MODE di esecuzione.** Un book cross-sectional a 10-19 gambe (long-k+short-k) su alt non è
+  eseguibile col capitale attuale (conto reale ~$600; servono ~$20k per gambe sensate, come già
+  notato per XS01). Sono segnali da monitorare, non ordini.
+- **Lezione confermata (di nuovo):** su un panel corto a regime unico il jackknife drop-one-month
+  certifica la robustezza DENTRO il regime, non ATTRAVERSO i regimi. Il discriminante decisivo è
+  stato **S2 (carico su short-beta) + S3 (consistenza per-anno)**, non lo Sharpe né l'uplift
+  hold-out (che il cluster regime-bet aveva altissimi: upliftHold fino a 1.20).
+
+## Azioni
+
+- **Nessuna modifica al portafoglio live** (TP01 55% + XS01 25% + VRP01 20% invariato).
+- **Forward-monitor** i 2 lead (XM09, XR02) quando il panel HL accumula un secondo regime.
+- **XM09 come affinamento candidato di XS01** (gate trend di mercato + universo 49) da valutare a
+  parità di sleeve, NON come sleeve aggiuntiva, in una prossima iterazione.
+- Harness `xslib.py` + 43 script + `verify_survivors.py` committati come riferimento riusabile.

docs/diary/2026-06-21-blind-signal-fleet.md

@@ -0,0 +1,111 @@
+# 2026-06-21 — Blind signal fleet: 52 agenti "esperti di segnali" su curve anonime BTC/ETH
+
+## Obiettivo (richiesta utente)
+
+Far partire ~50 subagenti **esperti di segnali** a cui passare lo storico di **ETH e BTC
+in forma ANONIMA** ("senza dire di cosa sono, con curve sovrapposte"): devono trovare come
+**anticipare l'andamento**, liberi di scrivere script o reti neurali ad hoc. L'**orchestratore**
+valuta la validità su **PnL e maxDD**.
+
+L'idea forte del setup cieco: se gli agenti non sanno che sono BTC/ETH, non possono
+pattern-matchare a memoria il crash COVID 2020 / l'orso 2022 / l'halving 2024 — devono trovare
+un timing **trasferibile**, non riconoscere l'era. È anche un test di onestà del metodo: l'edge
+deve reggere su un hold-out che gli agenti non hanno mai visto.
+
+## Setup — harness cieco e leak-free (prima degli agenti)
+
+> 50 agenti su un harness che perde = 50 fantasie (lezione fondante del progetto). Quindi prima
+> l'infrastruttura, poi la flotta.
+
+- `scripts/research/blind/make_blind.py` — esporta BTC/ETH **1d** (via il path certificato
+  `altlib.get`) come **"Series A" / "Series B"**: rebase a **100** (curve sovrapposte, il livello
+  non urla più "$60k bitcoin"), **calendario sintetico** dal 2001 (niente era-crypto da
+  riconoscere), volume normalizzato alla mediana. Split **70% train (visibile agli agenti) / 30%
+  test (solo orchestratore)**. Mapping A=BTC, B=ETH tenuto FUORI dal meta visibile.
+- `scripts/research/blind/blindlib.py` — l'unico modulo che un agente importa. Evaluator
+  leak-free: la posizione decisa a `close[i]` è **shiftata** e tenuta nella barra `i+1` (impossibile
+  leakare moltiplicando un peso per il rendimento della stessa barra), fee su turnover (Deribit
+  0.10% RT). Toolkit di indicatori causali ri-esportati da altlib.
+- **Guardia di causalità automatica** (`causality_ok`): ri-chiama `signal()` su un **prefisso
+  troncato** e pretende che la coda combaci con `signal()` sull'array intero. Qualunque segnale che
+  sbircia il futuro (shift(-k), finestre centrate, fit globale, statistiche full-sample) **diverge →
+  squalificato**. È ciò che rende onesta anche la "rete neurale ad hoc": un modello fittato sul df
+  intero (che a test-time contiene il futuro) fallisce la guardia; passa solo l'expanding/walk-forward.
+- `score_all.py` — il **giudice unico dell'orchestratore**: per ogni modulo gira la guardia, valuta
+  sul **test held-out** A e B, ordina per PnL/maxDD vs benchmark buy&hold.
+- `verify_top.py` — secondo strato avversariale: corr al trend canonico TSMOM, fee-stress 0.20% RT,
+  jackknife drop-block.
+
+Verifica dell'harness: momentum onesto → causale ok, OOS +44% a 19% DD; segnale **deliberatamente
+leaky** (guarda domani) → Sharpe 18 assurdo ma **correttamente squalificato**. Benchmark buy&hold
+OOS sul tail = **−7% PnL, 68% DD, Sharpe 0.22** (il tail 2024-26 contiene un drawdown brutale →
+anticipare il movimento ha spazio reale per vincere).
+
+## Flotta — 52 agenti, 52 ipotesi distinte
+
+Workflow `blind-signal-fleet` (52 agenti in parallelo, ~2h, 2.5M token, 971 tool-call). A ognuno
+**un'ipotesi diversa** (per non riscoprire tutti il momentum): 11 famiglie — trend/TSMOM,
+breakout (Donchian/Keltner/squeeze/pivot/volbreak), mean-rev/oscillatori (RSI/Bollinger/zrev/stoch/
+DPO/WillR), vol-regime (vol-target/regime-switch/ATR-ride/dd-derisk/**vol-of-vol**), struttura
+(HHLL/channel-pos), statistici (Hurst/autocorr/efficiency/skew/entropy), ciclo (FFT/Kalman),
+volume (OBV/PVT/vol-div), **8 ML** (Ridge, logistic, MLP-reg, MLP-clf, GBM, kNN-analog, RLS,
+RandomForest) e 5 meta/ensemble.
+
+**Esito flotta: 52/52 riportati, 52/52 passano la guardia di causalità** (zero look-ahead — la
+disciplina dell'harness ha tenuto su tutta la flotta, ML inclusi).
+
+## Risultati OOS (orchestratore — PnL & maxDD sul test held-out)
+
+Benchmark buy&hold OOS: **PnL −7%, maxDD 68%**. Top per Sharpe-min (peggiore tra A e B):
+
+| # | strategia | PnL_A | PnL_B | DD worst | Sh_min | famiglia |
+|---|---|---|---|---|---|---|
+| 1 | macd | +23% | +19% | **11%** | 0.84 | trend |
+| 2 | accel | +40% | +22% | 12% | 0.79 | trend (2ª diff) |
+| 3 | vol_of_vol | +30% | +32% | 21% | 0.69 | vol-regime |
+| 4 | regime_switch | +25% | +46% | 20% | 0.63 | vol-regime |
+| 5 | rf (ML) | +12% | +8% | **7%** | 0.62 | ML walk-fwd |
+| 6 | obv | +22% | +20% | 16% | 0.60 | volume |
+
+Tutti i top sono varianti **trend/vol-regime**. Mean-reversion e ML (logistic/gbm/mlp) in fondo →
+ri-conferma cieca di "mean-rev morto" e "ML walk-forward debole" del progetto. Lo **Sharpe OOS ~0.84
+decade dal train ~1.4** (firma classica di overfit/regime). Ma vs buy&hold (−7%/68% DD) i top trend
+**ribaltano il segno e tagliano il DD ~3-6×**: è il valore reale, identico alla lezione TP01.
+
+## Verifica avversariale — 3 scettici indipendenti (REFUTE, non confirm)
+
+1. **Regime-luck** → **REFUTED ×3.** I top-5 bar su ~800 OOS forniscono il **67-102% di tutto il
+   PnL**; togliendo 10 bar la serie va **negativa**; `accel` crolla nel terzo finale (COMB Sharpe
+   **−1.21**); A e B non concordano su *quando* funziona. Edge concentrato, non distribuito.
+2. **Trend-redundancy** → **REFUTED ×4.** Regressione `cand ~ α + β·TSMOM` (Newey-West HAC):
+   **t(α) = +0.92..+1.51, nessuno supera 1.96**. corr-al-trend 0.34-0.74, β 0.45-0.73; media residua
+   +0.05-0.08/anno = rumore. Sono TSMOM meglio tarati, **non alpha ortogonale**; contro il TP01 reale
+   (~1.3) il margine svanisce.
+3. **Overfit/robustezza** → MACD **non-refuted** (plateau vero a un asse, 0% celle <0.5) ma Sharpe OOS
+   onesto **0.84, non 1.40** (numero da docstring = in-sample). `accel` **REFUTED** (il termine di
+   accelerazione, la sua tesi, **danneggia** l'OOS; LAG knife-edge: −20% → −63% Sharpe; corner
+   congiunti negativi). `vol_of_vol` **REFUTED** (gate threshold-fit: PCTL 0.80→0.60 distrugge il 73%
+   dello Sharpe OOS). Fee = drag secondario ~10%, non il killer; il killer è la sensibilità ai parametri.
+
+## Verdetto
+
+**52 agenti ciechi, orchestratore che valuta PnL e maxDD su hold-out, e NIENTE di nuovo
+sopravvive alla verifica avversariale.** Ogni "vincitore" è trend-beta di due curve strutturalmente
+rialziste; soffitto Sharpe OOS **~0.84** su questo singolo hold-out; nessun alpha statisticamente
+distinguibile dal TSMOM. È una **ri-conferma INDIPENDENTE e CIECA del soffitto direzionale ~1.3** del
+progetto e del pattern "TSMOM travestito" — raggiunta da agenti che non sapevano nemmeno fossero
+BTC/ETH. Il più solido è **macd** (plateau vero, OOS Sharpe 0.84, DD 11%): classe-TP01,
+**forward-monitor al più, non deploy**. Conferma le regole: (a) giudicare lo Sharpe **marginale vs
+TP01**, non assoluto; (b) un hold-out corto premia chi è stato fortunato in pochi bar.
+
+### Valore metodologico (cosa resta)
+
+L'harness cieco riusabile: `data/blind/` + `blindlib`/`blind_eval`/`score_all`/`verify_top`. La
+**guardia di causalità online** ha tenuto 52 strategie (ML incluso) leak-free senza intervento
+manuale → strumento da riusare per ogni futura flotta. La pipeline "anonimizza → fan-out cieco →
+giudice unico OOS → 3 scettici (regime-luck / trend-redundancy / overfit)" ha ucciso ogni falso
+positivo che lo Sharpe assoluto avrebbe promosso.
+
+File: `scripts/research/blind/{make_blind,blindlib,blind_eval,score_all,verify_top}.py`,
+`agents/agent_00..51_*.py` (52 moduli), `leaderboard.json`, `verify_top.json`,
+`SKEPTIC_VERDICTS.json`. Dati rigenerabili: `data/blind/` (gitignored).

docs/diary/2026-06-21-intraday-microstructure.md

@@ -0,0 +1,88 @@
+# 2026-06-21 — Asse intraday/microstruttura: il lead più vicino al reale, ma NON deployabile
+
+## Perché (utente: "cerchiamo qualcosaltro")
+
+Direzionale e relative-value su BTC/ETH esauriti (flotte blind + ortho). L'unico asse mai
+sfruttato dopo il reset = il **tempo intraday** (feed certificati 5m/15m/1h; tutto era a 1d).
+Meccanismi diversi da trend e relative-value: bias ora/sessione (perp con funding a 00/08/16 UTC),
+reversione post-evento (vol/volume/gap), breakout del range del giorno prima.
+
+## Setup
+
+`scripts/research/intraday/intra_score.py`: wrappa `altlib.study_marginal` a un TF a scelta
+(compone i rendimenti intraday a daily, li valuta col **marginal scorer indurito** = multi-cut +
+edge-in-sample + hedge-vs-alpha) e riporta **turnover + fee-sweep a 0.20% RT**. Il muro: a 0.10% RT
+il churn intraday è morte (un flip orario fa 2152 trade/anno → −8.6 Sharpe netto). Vincolo agli
+agenti: **basso turnover**, l'intraday come informazione (timing/sizing/gating), non HFT.
+
+## Flotta — 16 agenti
+
+16 ipotesi low-turnover. Esito grezzo: 16 riportati, **10 "earns_slot"** (di nuovo gonfiato).
+
+## Diagnosi orchestratore — separare ortogonale vero da trend-beta
+
+Per corr-a-TP01 (`meta_intra.py`): 2 sono **trend-beta** (close_location 0.81, trend_quality 0.75 —
+Sharpe in-sample alto ma preso in prestito dal trend), 3 **mixed**, **5 genuinamente ortogonali**
+(|corr|<0.4): open_drive (0.13), prevday_range_breakout (0.15), vol_event_revert_15m (−0.1),
+volume_spike_revert (0.14), gap_fill (0.04) — 2 famiglie (breakout-continuation + capitulation-revert),
+mutuamente de-correlate. **Combo dei 5: Sharpe standalone 1.80, corr-TP01 0.17, uplift +0.33/+0.27/
++0.34/+0.34/+0.53 a OGNI cut** (non solo 2025).
+
+## Gauntlet deterministico (`verify_intra.py`) — passa TUTTO ciò che uccise le onde precedenti
+
+- **In-sample pre-2025 Sharpe 1.75; uplift pre-2025-ONLY +0.281** (l'ortho faceva +0.027 = null).
+- **Walk-forward selection** (scegli su solo passato, testa avanti): **+0.303 / +0.368** (l'ortho dava −0.07).
+- **Drop-one robusto** (+0.24..+0.31 pre-2025), **fee-robusto a 0.30% RT**, **leak-free**
+  (online-consistency: max_tail_diff = 0.0 su tutti e 5). Sembrava IL lead.
+
+## Verifica avversariale (3 scettici indipendenti) — il verdetto vero
+
+1. **Execution/microstruttura:** **open_drive = ARTEFATTO di etichettatura UTC.** Spostando il
+   confine del giorno di 4h l'uplift va NEGATIVO (−0.10); togliendo l'ancora UTC (trailing-8h) Sharpe
+   0.01; funziona solo a 00:00 UTC, solo alle ore 3 e 7. **Scartare.** `prevday_range_breakout` invece
+   **REGGE** (plateau su k, robusto allo shift del confine, fill eseguibili a close) = unico candidato
+   onesto, ma la decorrelazione viene tutta dalla gamba SHORT che si appoggia al regime down 2025-26;
+   anchor=1 only. **Caveat $600:** il vol-target fa ~8500 ribilanciamenti/anno, 97-98% < $1 di nozionale
+   → la fee proporzionale modellata su trade infinitesimi è **finzione** a $300/gamba (vale anche per TP01).
+2. **Hedge + tail:** **REFUTED.** L'uplift pre-2025 +0.281 sta al **20-24° percentile del null di un
+   asset a corr-zero** (mediana null +0.371) — essendo a corr +0.175 (non 0) e bassa vol, **aggiunge
+   MENO del rumore scorrelato**. È **hedge** (corr Sharpe-TP01/uplift −0.57..−0.80; TP01-down uplift
+   +0.79 vs TP01-up +0.20) e **tail-luck** (le gambe revert: top-5 giorni = 76-83% del PnL, <10
+   eventi/anno, front-loaded 2019-21; combo: metà uplift in ~10 giorni).
+3. **Overfit/robustezza:** **ROBUST-PLATEAU** (243-cell joint grid pre-2025 uplift min +0.134/med
+   +0.211, 99% celle >+0.15; ogni anno positivo). MA segnala lui stesso il **null-pctl 0.20**: "il
+   beneficio è la matematica di diversificazione di uno stream ortogonale a Sharpe 1.75, NON timing-alpha
+   specifico-TP01" + storia corta sulle gambe revert + fill modellati vs reali.
+
+## Verdetto
+
+**Niente in live.** L'asse intraday ha prodotto il lead **più vicino al reale** di tutta la ricerca,
+ma sotto 3 scettici: **open_drive è artefatto** (UTC-labeling); la combo **fallisce il null a
+corr-zero** (aggiunge meno del rumore), è **hedge-shaped** e **tail-luck**; e lo Sharpe modellato è
+gonfiato dal micro-ribilanciamento sub-dollaro a $600. Lo Sharpe standalone 1.80 NON è affidabile
+(artefatto + coda + finzione di fill). **Resta solo TP01.**
+
+**Lead reale (forward-monitor, non deploy):** `prevday_range_breakout` — l'unico segnale sopravvissuto
+allo scettico d'esecuzione (breakout del range del giorno prima, eseguibile, leak-free), con caveat
+short-leg/regime-2025. Trattamento = come `dvol_spread` / XS01 / STA05.
+
+### Lezioni harness — CODIFICATE (il vero ritorno)
+
+1. ✅ **`altlib.day_boundary_robust(target_fn, tf)`** — shifta il confine del giorno UTC e ri-misura
+   l'uplift marginale: INVARIANT (segnale di prezzo, spread 0) / ROBUST (effetto calendario vero,
+   resta positivo) / **ARTIFACT-RISK** (l'uplift si inverte = etichettatura). Verificato: riproduce
+   da solo il verdetto degli scettici — open_drive → ARTIFACT-RISK (+0.23→−0.33), prevday_breakout
+   → ROBUST. Test `tests/test_harness_realism.py`.
+2. ✅ **`altlib.eval_weights_smallcap(df, target, capital=600, min_order=5)`** — salta i
+   ribilanciamenti sub-min_order (la finzione del micro-trading a $600), riporta lo Sharpe haircut
+   reale vs modellato. Vale per ogni sleeve a questo capitale, TP01 incluso. Test idem.
+3. ✅ **`altlib.causality_ok(target_fn, tf)`** — guardia look-ahead/online-consistency (ricalcola
+   il target su un prefisso e pretende che la coda combaci con il full): eval_weights shifta la
+   posizione ma NON vede una feature non-causale (finestra centrata / shift(-k) / stat full-sample).
+   Integrata in `intra_score` (un leak è squalificato prima dello scoring). + il calendar-artifact
+   gate (`day_boundary_robust`) ora gira dentro `intra_score`: **open_drive/weekly_seasonality/
+   overnight → CAL-ARTIFACT, fuori dagli slot da soli**; prevday_breakout resta (ROBUST). Il lab
+   intraday ora auto-becca leak e artefatti-calendario che ieri richiedevano gli scettici. Test idem.
+
+File: `scripts/research/intraday/{intra_score,meta_intra,verify_intra}.py`,
+`agents/agent_00..15_*.py`, `intra_leaderboard.json`.

docs/diary/2026-06-21-ortho-tp01-relative-value.md

@@ -0,0 +1,99 @@
+# 2026-06-21 — Caccia all'ORTOGONALE a TP01: relative-value BTC/ETH (eseguibile a $600)
+
+## Perché (richiesta utente: "cerca ortogonale a TP01")
+
+La flotta cieca (stesso giorno) ha confermato: niente di NUOVO in direzionale BTC/ETH — tutto è
+trend-beta di TP01 (soffitto ~1.3). L'unica via a un nuovo slot LIVE è un meccanismo **ortogonale**
+(bassa correlazione, alpha residua). Il più promettente **eseguibile al capitale reale ~$600** è un
+**book RELATIVE-VALUE a 2 gambe BTC/ETH** (long una / short l'altra), grosso modo market-neutral →
+correlazione naturale bassa col trend, e a 2 gambe è eseguibile (a differenza del book a 19 gambe di
+XS01 che serve ~$20k).
+
+## Setup — ortho-lab + giudice MARGINALE (non Sharpe assoluto)
+
+`scripts/research/ortho/ortholib.py`: BTC/ETH 1d allineati su date comuni; `eval_book(book_fn)` con
+`book(btc,eth)->(w_btc,w_eth)`, **shift di entrambe le gambe** (no leak), fee su entrambe, serie netta
+**giornaliera**; guardia di causalità online; check **eseguibilità a $600** (max gamba ≤ 0.5 = cap
+$300/asset). Il giudice è `altlib.marginal_vs_tp01`: **corr a TP01, uplift OOS del blend, alpha
+residua, robust_oos** (clean-year + jackknife drop-month). Verdetto = ADDS, **non** Sharpe assoluto.
+`ortho_score.py` (giudice), `meta_ortho.py` (corr mutua + persistenza multi-cut), `sleeve_rv.py`.
+
+Sanity: ratio-momentum → ADDS (corr 0.05); ratio-mean-reversion → DILUTES. L'harness discrimina.
+
+## Flotta — 18 agenti relative-value (~40 min)
+
+18 ipotesi distinte: ratio-momentum multi-orizzonte, XS a 2 asset, beta-neutral residuo, Donchian
+sul ratio, EMA-cross, accel, carry lento, Kalman-spread, gate-correlazione, gate-vol, inverse-vol,
+rebalance-harvest, lead-lag, **DVOL-spread**, **VRP relativo**, dispersione, ensemble.
+
+**Esito grezzo: 18 riportati, 17 "ADDS / earns_slot".** → **bandiera rossa**: non esistono 17 alpha.
+Gli agenti stessi l'hanno annotato ("hold-out corto ~537g", "uplift dipende dal regime ETH-bleed
+2025", "forward-monitor non full-weight").
+
+## Diagnosi dell'orchestratore — il "17 slot" è gonfiato
+
+1. **Una scommessa o tante?** corr mutua media **0.43** → collassano a **8 rappresentanti**
+   de-correlati. Non 17, non 1.
+2. **Persistente o solo finestra 2025?** `marginal_vs_tp01` fissa l'hold-out al 2025-01-01 = proprio
+   la finestra dove ETH ha perso vs BTC e TP01 è debole. Ri-misurando l'uplift a **più cut**
+   (2022/23/24/25): il basket selection-free era +0.06/+0.06/+0.11/+0.38 (positivo ovunque ma
+   crescente verso il 2025). Smaschera anche i **falsi** che il robust_oos fisso-2025 non vede:
+   `kalman_spread` (−0.14/−0.16/−0.10 poi +0.37) e `xs2_zscore` sono **2025-only**.
+3. **Selezione walk-forward (senza hindsight):** scegliere i top-4 per uplift sul **solo passato** e
+   testare in avanti → uplift **−0.07** (sel <2023) / +0.05 (<2024) / +0.43 (<2025). **Scegliere la
+   variante vincente in anticipo è inaffidabile**; il mio "curated 4" è in parte hindsight.
+
+## Verifica avversariale (scettico indipendente) — REFUTED
+
+Sul **basket selection-free** (equal-weight di tutti i book market-neutral, NESSUN cherry-picking):
+- standalone Sharpe **0.61**, maxDD 15%, **corr a TP01 0.05** (genuinamente ortogonale).
+- **uplift full +0.078 = pre-2025 +0.027 / solo-2025+ +0.401.** Il pre-2025 **+0.027 sta al 49°
+  percentile di 500 asset-rumore a corr-zero** (+0.029 per costruzione) → è **matematica di
+  diversificazione, non segnale**.
+- **corr(Sharpe annuo TP01, uplift annuo basket) = −0.87**; condizionato: TP01 su → +0.014, TP01 giù
+  → +0.369. **È un hedge dei drawdown di TP01, non un premio autonomo.** Paga nel 2022 (orso) e
+  2025-26 (ETH-bleed) — i due anni peggiori di TP01 — rumore altrove (2023 −0.06, 2024 −0.12).
+- Block-bootstrap P(uplift>0): full 90%, **pre-2025 66% (testa o croce)**, 2025+ 99%.
+- Fee: a **0.30% RT il pre-2025 va NEGATIVO** (−0.021); sopravvive solo il numero del regime 2025.
+- Eseguibilità OK ($264/gamba, turnover 12/yr) — non è quello il problema.
+
+## Verdetto
+
+**Niente di questa flotta merita uno slot LIVE.** Il meccanismo relative-value BTC/ETH è REALE e
+genuinamente ortogonale (corr ~0.05), ma è un **hedge della debolezza di TP01 travestito da alpha**:
+il suo contributo pre-2025 è indistinguibile da un asset-rumore a corr-zero (49° percentile del null)
+e muore a fee realistiche; l'unico payoff vero è una singola finestra di 537 giorni (2025-26).
+Deployarlo = deployare un backtest mono-regime. **Resta live solo TP01** (l'unica cosa che supera
+tutto questo scrutinio). Coerente con XS01 (stessa famiglia cross-sectional): diversificatore
+da monitorare, non alpha da eseguire — e la versione a 2 asset è ancora più sottile della 19-gambe.
+
+### Valore metodologico (cosa resta, ed è importante)
+
+- **Il marginal scorer fisso-2025 è ingannabile** (17/18 "ADDS"). Ciò che ha ucciso i falsi positivi:
+  **persistenza multi-cut** + **selezione walk-forward** + **bootstrap vs null a corr-zero**. Lezione
+  da cablare nello scorer: testare PIÙ cut e confrontare l'uplift col **null di un asset-rumore
+  ortogonale** (un'asset scorrelato con drift positivo "aggiunge" +0.03 per pura matematica — non è
+  un edge). Un basso-corr che paga solo quando il core è debole è un **hedge**, va prezzato come tale.
+- Lab riusabile: `ortholib`/`ortho_score`/`meta_ortho` (giudice marginale + persistenza). I 18 book +
+  `sleeve_rv.py` (curated, **selection-biased — non deployare**) restano come riferimento.
+
+File: `scripts/research/ortho/{ortholib,ortho_score,meta_ortho,sleeve_rv}.py`,
+`agents/agent_00..17_*.py`, `ortho_leaderboard.json`, skeptic `skeptic_{basket,regime,null}.py`.
+
+## AGGIORNAMENTO — lezione codificata in `altlib.marginal_vs_tp01` (stesso giorno)
+
+I tre gate sono ora **codice**, non solo prosa (test `tests/test_marginal_scorer.py`, +5 test):
+1. **persistenza multi-cut** (`multicut_uplift`/`multicut_persistent`): uplift a ogni inizio anno,
+   non solo all'HOLDOUT fisso → uccide i 2025-only (es. `kalman_spread`, negativo a ogni cut pre-2025).
+2. **edge in-sample** (`has_insample_edge`): lo Sharpe standalone PRE-holdout dev'essere ≥0.5. È il
+   discriminante onesto (la basket faceva 0.29). I `null_pctl_*` (vs asset-rumore a corr-zero) restano
+   come CONTESTO — mostrano che un low-corr "aggiunge" ~+0.03 per matematica, vero per sleeve buoni e
+   cattivi, quindi non possono essere IL gate; l'edge in-sample sì.
+3. **hedge vs alpha** (`is_hedge`): `corr(Sharpe-TP01, uplift annuo)` molto negativa + paga solo
+   quando TP01 è giù → HEDGE, non alpha.
+
+Verdetti nuovi **HEDGE** e **NOISE**; `earns_slot` ora pretende ADDS + robust_oos + has_insample_edge
++ not is_hedge. **Sull'onda ortho lo scorer indurito ribalta 17/18 "ADDS" → 1** (`dvol_spread`, unico
+con edge in-sample reale 0.57; gli altri 16 → NOISE/HEDGE). Controllo: un sleeve sintetico Sharpe~1.3
+scorrelato resta **ADDS** (non rigetta i diversificatori veri — XS01-like). La verifica avversariale
+di 3 giorni è ora una chiamata di funzione.

docs/diary/2026-06-21-prevday-bootstrap.md

@@ -0,0 +1,68 @@
+# PREVDAY block-bootstrap — coda-fortuna vs persistente (blocker #2/#3)
+
+**Data:** 2026-06-21 (chiude la trilogia: fill-haircut → turnover/hedge → bootstrap)
+**Script:** `scripts/research/intraday/prevday_bootstrap.py`
+**Esito:** PREVDAY-full **non** è più coda-fortuna di TP01 e l'edge è **bootstrap-robusto** (full
+99% / hold-out 93% dei resample con uplift>0). MA la gamba short (= tutto il valore) è
+**tail-dipendente** (top-5 giorni = 130% del suo netto). PREVDAY = tail-hedge legittimo dal payoff
+grumoso. Resta forward-monitor.
+
+## Chiarimento di scope
+
+Il "top-5 giorni = 76-83% del PnL" del diario intraday era sulle GAMBE REVERT del combo a 5 segnali
+(vol_event/volume_spike/gap_fill), poi SCARTATE. Il sopravvissuto è PREVDAY (breakout-continuation).
+Qui si testa PREVDAY STESSO — e la sua gamba SHORT, che (prevday_turnover) è l'intero valore di
+portafoglio. Block bootstrap circolare (blocchi 20g, B=3000) per preservare autocorrelazione/regime.
+
+## [A] Concentrazione del PnL nei top-K giorni
+
+| serie | n | totRet | top5 | top10 | top20 | giorni→50% gain |
+|-------|--:|-------:|-----:|------:|------:|----------------:|
+| PREVDAY full | 2869 | +182% | 22% | 36% | 59% | 411 (14.3%) |
+| **PREVDAY short-only** | 2869 | **+28%** | **130%** | 218% | 345% | 312 (10.9%) |
+| PREVDAY long-only | 2869 | +154% | 18% | 30% | 49% | 287 (10.0%) |
+| TP01 (riferimento) | 2657 | +116% | 19% | 33% | 55% | 213 (8.0%) |
+
+- **PREVDAY-full NON è più coda-fortuna di TP01**: top5 22% vs 19%, e per il 50% del guadagno serve
+  *più* tempo (14.3% dei giorni vs 8.0% → più distribuito). Il tail-luck del diario era sulle gambe
+  revert scartate, non su PREVDAY.
+- **Gamba short tail-dipendente:** top5 = **130% del netto** → togliendo i 5 giorni migliori la short
+  va in perdita (gli altri 2864 giorni nettano −8%). Sono i giorni-crash dove la short paga.
+
+## [B] Circular block bootstrap (20g, B=3000)
+
+| campione | PREVDAY Sharpe (mediana [5°,95°], %>0) | blend 80/20 uplift (mediana [5°,95°], %>0, %>+0.10) |
+|----------|----------------------------------------|------------------------------------------------------|
+| full (2018-08→2026-06) | +1.24 [+0.64,+1.80] 100% | +0.28 [+0.09,+0.47] 99% / 93% |
+| hold-out (2025+) | +1.27 [−0.01,+2.46] 95% | +0.53 [−0.05,+1.21] 93% / 88% |
+| short-only hold-out | +1.12 [−0.32,+2.41] 90% | +0.53 [−0.08,+1.31] 92% / 87% |
+
+- **Full sample: edge robustissimo** — 99% dei resample dà uplift>0 (mediana +0.28). Non è "un blocco
+  fortunato".
+- **Hold-out: regge con coda più larga** (5° pctl appena negativo: hold-out corto ~536g + short
+  tail-dipendente), ma 93% dei resample >0, 88% >+0.10.
+
+## Verdetto blocker #2/#3
+
+- **#3 tail-luck — DECLASSATO per PREVDAY-full, CONFERMATO per la gamba short.** La strategia intera
+  non è più concentrata di TP01 (che già deployamo); il motore di valore (la short) sì: vive su <10
+  giorni-crash/anno. Bootstrap-robusto (non un singolo blocco), ma il forward sarà GRUMOSO, non un
+  liscio +0.56/periodo.
+- **#2 null-corr-zero — RIDIMENSIONATO.** L'uplift è genuinamente positivo (93-99% dei resample), non
+  rumore; il punto era di *efficienza relativa* (rende meno di un ipotetico asset perfettamente
+  scorrelato), non di esistenza dell'edge.
+
+## Sintesi della trilogia (fill-haircut + turnover/hedge + bootstrap)
+
+PREVDAY, dopo tre attacchi avversariali:
+1. **Eseguibile alla taglia reale** ($600): haircut di fill +0.01 (blocker #4 smontato).
+2. **Già a turnover efficiente**: ridurlo erode l'edge; nessuna ottimizzazione (config congelata).
+3. **È un HEDGE, non alpha**: tutto il valore è la gamba short → tail-hedge di regime-down, additivo
+   alla flat-stance di TP01 (blocker #1 inchiodato).
+4. **Edge bootstrap-robusto** ma **payoff grumoso** (il valore è in pochi giorni-crash) (blocker #3
+   declassato sul full, confermato sulla short; #2 ridimensionato).
+
+→ **Candidato tail-hedge legittimo**, non sleeve-alpha. Resta in FORWARD-MONITOR: la domanda forward
+non è più "è eseguibile / è overfit", ma **"la gamba short continua a pagare nei prossimi crash fuori
+da 2022 e 2025-26?"**. Se sì → si valuta come overlay di tail-hedge (peso piccolo, atteso payoff
+lumpy); se no → era beta-corto del regime down 2025-26.

docs/diary/2026-06-21-prevday-fill-haircut.md

@@ -0,0 +1,67 @@
+# PREVDAY fill-haircut a basso capitale — il blocker d'esecuzione è BENIGNO (1/4 smontato)
+
+**Data:** 2026-06-21 (follow-up di `2026-06-21-intraday-microstructure.md`)
+**Script:** `scripts/research/intraday/fill_haircut.py`
+**Esito:** l'haircut del fill reale a $600 è **+0.01 Sharpe** (trascurabile). Lo scettico
+d'esecuzione (blocker #4) è **benigno**. Gli altri 3 blocker (hedge / null-corr-zero / tail-luck)
+restano → PREVDAY resta in **forward-monitor, non deploy**.
+
+## Domanda
+
+Lo scettico d'esecuzione dell'onda intraday aveva segnalato: il vol-target di PREVDAY fa ~8500
+ribilanciamenti/anno per gamba, 97-98% < $1 di nozionale a $600; a quel capitale (min_order $5) NON
+puoi piazzarli, quindi il libro MODELED (ribilanciamento continuo, frictionless) è una finzione e lo
+Sharpe modellato è gonfiato. Il forward-monitor traccia MODELED-$2000 vs REAL-$600 per misurarlo nei
+mesi a venire — qui lo stimiamo SUBITO su tutto lo storico, replicando la STESSA logica dei due libri
+di `paper_prevday.py` ma sull'intero path 1h (2019-03 → 2026-06, 63.732 barre).
+
+Due libri identici tranne il fill:
+- **MODELED**: ribilancia ad ogni barra (fee proporzionale su ogni |Δ|).
+- **REAL-$C**: salta i ribilanciamenti con nozionale `|Δpos|·leg_cap < $5` (posizione stale →
+  tracking error, ma niente fee sui trade infinitesimi). Sweep C ∈ {600, 2000, 20000}.
+
+## Risultati
+
+| libro | FULL Sh | HOLD Sh | CAGR | DD | rebal/yr | skip% | fee-drag/yr |
+|-------|---------|---------|------|----|---------:|------:|------------:|
+| MODELED ($∞) | +1.23 | +1.27 | +24.3% | −27% | 17.484 | 0.0% | 2.49% |
+| REAL-$20k | +1.23 | +1.27 | +24.4% | −27% | 3.747 | 78.6% | 2.47% |
+| REAL-$2000 | +1.23 | +1.27 | +24.4% | −27% | 677 | 96.1% | 2.42% |
+| REAL-$600 | +1.22 | +1.26 | +24.2% | −27% | 277 | 98.4% | 2.39% |
+
+**HAIRCUT $600 (MODELED − REAL): FULL Sharpe +0.01, HOLD-OUT +0.01.**
+
+Domanda-soldi (l'uplift del blend regge col fill reale?):
+
+| PV | w | FULL (uplift) | HOLD (uplift) |
+|----|---|---------------|---------------|
+| MODELED | 20% | 1.58 (+0.28) | 0.86 (+0.56) |
+| MODELED | 30% | 1.65 (+0.36) | 1.08 (+0.78) |
+| **REAL-$600** | 20% | 1.58 (+0.28) | 0.86 (**+0.55**) |
+| **REAL-$600** | 30% | 1.65 (+0.35) | 1.08 (**+0.77**) |
+
+(TP01 solo: FULL +1.30, HOLD +0.31.) L'uplift hold-out sopravvive **quasi intatto**.
+
+## Lettura
+
+Saltare il **98.4%** dei micro-ribilanciamenti a $600 non costa quasi nulla perché quei trade sono
+*individualmente infinitesimi*: sia la fee risparmiata sia il tracking-error introdotto sono
+trascurabili. Il PnL è dominato dai ~50 flip di direzione/anno + la deriva lenta del vol-target, che
+il libro $600 cattura comunque sui movimenti grandi (la fee-drag passa solo da 2.49% a 2.39%). La
+"finzione della fee sub-dollaro" è quindi **benigna**: non gonfia lo Sharpe modellato (MODELED e
+REAL-$600 coincidono a ±0.01). NB: lo Sharpe **non si degrada** scendendo di capitale → l'edge
+modellato di PREVDAY è eseguibile alla taglia reale; il blocker era altrove.
+
+## Conseguenza sul verdetto
+
+Dei 4 blocker che tenevano PREVDAY fuori dal deploy, il **#4 (fill a basso capitale) è SMONTATO**.
+Restano in piedi i 3 strutturali (dall'onda intraday, non rivalutati qui):
+1. **hedge-shaped** — l'uplift viene dai regimi TP01-down (uplift +0.79 TP01-down vs +0.20 TP01-up);
+2. **fallisce il null a corr-zero** — uplift pre-2025 al 20-24° pctl del null di un asset random
+   scorrelato (aggiunge MENO del rumore);
+3. **tail-luck** — top-5 giorni = 76-83% del PnL delle gambe revert, <10 eventi/anno.
+
+PREVDAY resta il lead **più solido sull'esecuzione** di tutta la ricerca post-reset (il dubbio più
+"fisico" è caduto), ma **forward-monitor, non deploy**, finché il track record forward non scioglie
+hedge/coda/null. Lezione harness: `eval_weights_smallcap` (il gate min-order) va sempre eseguito
+PRIMA di scartare un lead per "fill irreale" — qui avrebbe evitato di sopravvalutare il blocker #4.

docs/diary/2026-06-21-prevday-overlay-portfolio.md

@@ -0,0 +1,68 @@
+# PREVDAY come overlay di tail-hedge sul portafoglio — simulazione d'impatto (NON deploy)
+
+**Data:** 2026-06-21 (segue la trilogia fill-haircut / turnover-hedge / bootstrap)
+**Script:** `scripts/portfolio/prevday_overlay.py`
+**Esito:** a peso 10%, PREVDAY taglia il maxDD FULL del portafoglio **14.3% → 9.9% (−31%)** e alza
+l'hold-out Sharpe **1.66 → 1.97 (+0.31)**. 10% è vicino all'ottimo di DD. MA è tutto IN-SAMPLE: il
+prize si materializza solo SE l'edge di PREVDAY persiste forward. PREVDAY resta FORWARD-MONITOR.
+
+## Setup
+
+Simulazione che NON tocca il registry di produzione: prende il portafoglio attivo (TP01 55% + XS01
+25% + VRP01 20%), riscala i tre sleeve a (1−W) mantenendone le proporzioni, e aggiunge PREVDAY a
+peso W. Sweep W ∈ {0,5,10,15,20%}. PREVDAY = libro 1h breakout-continuation, parametri congelati,
+50/50 BTC+ETH, fee 0.10% RT. Outer-join del portafoglio: PREVDAY dal 2018, VRP01 dal 2021, XS01 dal
+2024 → nel 2019-20 PREVDAY pesa di fatto >W (solo TP01 accanto); nell'hold-out 2025+ (tutti e 4
+attivi) pesa esattamente ~W → **l'HOLD-OUT è il confronto pulito a "10%"**.
+
+## Sweep peso overlay
+
+| peso PREVDAY | FULL Sharpe | FULL DD | HOLD Sharpe | HOLD DD | HOLD ret |
+|--------------|------------:|--------:|------------:|--------:|---------:|
+| BASELINE (55/25/20) | 1.68 | 14.3% | 1.66 | 3.4% | +16.7% |
+| 5% | 1.80 | 11.1% | 1.83 | 3.3% | +17.8% |
+| **10%** | **1.88** | **9.9%** | **1.97** | 3.3% | **+19.0%** |
+| 15% | 1.93 | 10.3% | 2.06 | 3.3% | +20.2% |
+| 20% | 1.95 | 10.6% | 2.09 | 3.4% | +21.4% |
+
+(PREVDAY standalone: FULL Sh 1.23 / DD 26.7%; HOLD Sh 1.28 / DD 10.8%.)
+
+## Lettura a 10%
+
+- **FULL: Sharpe +0.20 (1.68→1.88), maxDD 14.3%→9.9% (−4.4pp ≈ −31%).** Comportamento da tail-hedge:
+  la gamba short ammortizza i crash storici (2019-21, 2022).
+- **HOLD-OUT: Sharpe +0.31 (1.66→1.97), ret +16.7%→+19.0%, DD 3.4%→3.3% (già bassissimo).** Nel
+  regime recente il beneficio è rendimento/Sharpe, non taglio DD.
+- **10% ≈ ottimo di DD.** Oltre, lo Sharpe sale ancora (1.93→1.95) ma il maxDD FULL smette di
+  scendere (10.3→10.6%): stai solo aggiungendo rischio direzionale short. Argomento per ~10% in
+  chiave hedge (massimizza il taglio-coda per unità di rischio aggiunto).
+
+## Per anno (baseline → overlay 10%)
+
+| anno | ret | DD |
+|------|-----|----|
+| 2019 | +11.3 → +15.2 | 10.3 → 8.2 |
+| 2020 | +51.1 → +53.1 | 8.4 → 6.3 |
+| 2021 | +32.5 → +28.3 | 5.2 → 4.3 |
+| 2022 | −3.0 → −1.6 | 3.7 → 3.0 |
+| 2023 | +11.2 → +11.4 | 9.2 → 9.9 |
+| 2024 | +24.4 → +25.7 | 3.9 → 3.4 |
+| 2025 | +12.0 → +12.0 | 3.4 → 3.3 |
+| 2026 | +4.2 → +6.2 | 2.6 → 2.2 |
+
+Migliora o pareggia quasi ovunque; costa solo nel toro 2021 (premio d'assicurazione atteso per un
+hedge) e leggermente sul DD 2023; paga nel bear 2022 e nel 2026.
+
+## Verdetto
+
+L'overlay 10% è **attraente in simulazione** — taglia il drawdown FULL di ~31% e alza l'hold-out
+Sharpe +0.31, con 10% vicino all'ottimo di DD. Ma:
+1. **È in-sample.** I guadagni assumono che l'edge di PREVDAY persista — il forward-monitor esiste
+   proprio per verificarlo. Questa simulazione quantifica il PRIZE, non lo prova.
+2. **Outer-join:** il taglio-DD storico è gonfiato dal peso effettivo >10% nel 2019-20; il read
+   pulito a 10% è l'hold-out (prize = Sharpe +0.31).
+3. Incidentale: il 3-way TP01+XS01+VRP01 baseline qui fa FULL 1.68 / HOLD 1.66.
+
+**Azione: nessuna.** PREVDAY resta FORWARD-MONITOR (registry di produzione invariato). Quando il
+track record forward avrà ~2-3 mesi, ri-valutare l'overlay 10% con la stessa metrica (taglio-DD +
+hold-out Sharpe) su dati VERAMENTE fuori campione. Lo script è il riferimento per quel confronto.

docs/diary/2026-06-21-prevday-turnover-and-hedge.md

@@ -0,0 +1,64 @@
+# PREVDAY — la fee viene dai FLIP (no free lunch sul turnover) + è un HEDGE, non alpha
+
+**Data:** 2026-06-21 (follow-up di `2026-06-21-prevday-fill-haircut.md`)
+**Script:** `scripts/research/intraday/prevday_turnover.py`
+**Esito:** (1) ridurre il turnover di PREVDAY erode l'edge — la config congelata è già efficiente.
+(2) Il test long-only inchioda il blocker #1: **tutto il valore di portafoglio è la gamba SHORT** →
+PREVDAY è un **hedge di regime-down**, non alpha. Resta forward-monitor.
+
+## Premessa (da fill_haircut)
+
+Il libro REAL-$600 salta il 98.4% dei ribilanciamenti del vol-target e la fee-drag scende solo
+2.49% → 2.39%/anno. Quindi la fee (~2.6%/anno) NON viene dal churn sub-dollaro ma dai **~70 flip di
+direzione/anno**. Un deadband d'esecuzione è inutile; l'unica leva è ridurre i flip a LIVELLO DI
+SEGNALE. Qui sweep delle leve (buffer, anchor, min-hold) + long-only vs long-short. Libro MODELED
+(l'haircut di fill è +0.01, irrilevante). Metrica che conta = **uplift hold-out del blend 80/20**.
+
+## (1) Turnover-reduction — no free lunch
+
+| config | flip/yr | fee/yr | FULL Sh | HOLD Sh | DD | corrTP | blend HOLD upl |
+|--------|--------:|-------:|--------:|--------:|---:|-------:|---------------:|
+| **BASE** (anchor=1, k=0.30, LS) | 70 | 2.59% | +1.23 | +1.27 | −27% | +0.15 | **+0.56** |
+| k=0.50 | 48 | 1.86% | +1.23 | +0.99 | −15% | +0.20 | +0.40 |
+| k=0.75 | 32 | 1.31% | +1.06 | +0.13 | −16% | +0.27 | +0.00 |
+| k=1.00 | 23 | 1.01% | +0.88 | +0.72 | −22% | +0.36 | +0.22 |
+| anchor=2 | 39 | 1.55% | +0.89 | +0.54 | −22% | +0.25 | +0.20 |
+| anchor=3 | 27 | 1.14% | +0.67 | −0.18 | −22% | +0.29 | −0.12 |
+| anchor=5 | 15 | 0.75% | +1.15 | +0.70 | −19% | +0.41 | +0.25 |
+| min_hold=24h | 70 | 2.59% | +1.22 | +1.37 | −32% | +0.15 | **+0.60** |
+| min_hold=72h | 65 | 2.39% | +0.86 | +0.67 | −33% | +0.12 | +0.27 |
+| combo-LT (k.75+anc2+24h) | 16 | 0.79% | +0.79 | +0.69 | −20% | +0.34 | +0.24 |
+
+- **Allargare buffer/anchor taglia fee e turnover ma l'uplift cala monotonicamente** (k: 0.56→0.40→
+  0.00). Anchor multi-giorno tutto peggio → conferma il "anchor=1 only" del diario. I flip SONO
+  l'edge: meno flip = meno edge.
+- **min_hold=24h** è l'unico ritocco "quasi gratis" (uplift +0.56→+0.60 a parità di fee) ma
+  **peggiora il DD −27%→−32%** → non vale cambiare una strategia congelata in forward-monitor.
+- **Verdetto: la config base è già sulla frontiera efficiente turnover↔edge. Si lascia congelata.**
+
+## (2) Long-only vs long-short — il blocker #1 inchiodato
+
+| | FULL Sh | HOLD Sh | corrTP | blend HOLD upl | fee/yr |
+|--|--------:|--------:|-------:|---------------:|-------:|
+| **long-only** (no short) | **+1.55** | +0.52 | **+0.64** | **+0.09** | 1.30% |
+| long-short (BASE) | +1.23 | +1.27 | +0.15 | +0.56 | 2.59% |
+
+La versione **long-only ha Sharpe standalone più ALTO** (1.55 vs 1.23) ma è **correlata +0.64 a TP01
+e non aggiunge quasi nulla al blend** (+0.09). **Tutto il valore di portafoglio viene dalla gamba
+SHORT:** la short *abbassa* lo Sharpe standalone (shortare crypto nel toro 2019-24 perde) ma fornisce
+**tutta** la decorrelazione (corrTP 0.64→0.15) e l'uplift hold-out (0.09→0.56).
+
+→ **PREVDAY non è alpha: è strutturalmente un HEDGE di crash/regime-down.** Costa nel toro, paga
+nell'orso (2022, 2025-26 down/chop). È additivo a TP01, che va *flat* nel risk-off ma non *short*.
+Questo conferma e affina il blocker #1 dell'onda intraday ("l'uplift viene dai regimi TP01-down"):
+non è solo conditional sui regimi down, è **interamente la gamba short** = una scommessa direzionale
+che i ribassi continuino.
+
+## Conseguenza sul verdetto
+
+- Niente da ottimizzare: la config congelata è già efficiente; nessun cambio.
+- **Riframing utile:** se PREVDAY un giorno avrà un ruolo, è come **overlay di tail-hedge** (non
+  sleeve-alpha), additivo alla difensività di TP01. Ma resta soggetto agli altri due blocker
+  (fallisce il null a corr-zero; tail-luck: top-5 giorni = 76-83% del PnL delle gambe revert).
+- **Forward-monitor invariato.** Il test forward decisivo: la gamba short continua a pagare fuori da
+  2022 e 2025-26? Se sì → candidato tail-hedge; se no → era regime-luck.

docs/diary/2026-06-22-crypto-lead-50agent-sweep.md

@@ -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`.

docs/diary/2026-06-22-crypto-macro-leadlag.md

@@ -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.

docs/diary/2026-06-22-deployable-combo-tp01-gtaa.md

@@ -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.

docs/diary/2026-06-22-equities-gtaa-and-crypto-combo.md

@@ -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.

docs/diary/2026-06-22-equities-sector-momentum.md

@@ -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.

docs/diary/2026-06-22-equities-spy-trend.md

@@ -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).

docs/diary/2026-06-22-funding-carry-hl.md

@@ -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.

docs/diary/2026-06-23-combo-paper-deploy.md

@@ -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.

docs/diary/2026-06-23-crossmarket-beyond-sp500.md

@@ -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.

docs/diary/2026-06-23-crypto-overnight-lookahead.md

@@ -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).

docs/diary/2026-06-23-futures-overnight-leadlag.md

@@ -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)

docs/diary/2026-06-23-skyhook.md

@@ -0,0 +1,141 @@
+# 2026-06-23 — SKH01 "Skyhook": porting onesto del sistema ES dual-timeframe su BTC/ETH
+
+Branch: `strategy_skyhook`. Engine: `src/strategies/skyhook.py`. Harness: `scripts/research/skyhook/skyhooklib.py`.
+Test: `tests/test_skyhook.py` (5 pass). Ricerca: `scripts/research/skyhook/{sweep,grid,check_v1}.py` + `runs/`.
+
+## Il brief
+
+Sistema "Skyhook" (origine ES / E-mini S&P, genetico, a doppio timeframe), da portare su crypto:
+- **data2 = 690 min (segnale)**, **data1 = 230 min (esecuzione)**. NB **690 = 3 × 230**.
+- NON trend-follower: entra **solo** quando coincidono (a) un **regime** di volatilità/volume e
+  (b) un **pattern** di breakout.
+- Pipeline per barra: indicatori (BuzVola su ATR, BuzVolume su volume, tipo-Chande 0-100) →
+  fasce regime → pattern (Donchian/breakout su data2) → composer (regime AND pattern) →
+  ingresso (max 1/giorno, stop-and-reverse) → uscite (time-based asimmetrico uscitalong=24 /
+  uscitashort=18 + stop/profit).
+- Ancore demo: trend lineare → **BuzVola=50** (vol steady → neutro), **BuzVolume=100** (volume in rampa).
+
+## Ricostruzione (fedele + onesta)
+
+- **Resample dal feed 5m certificato** con `origin='epoch'`: 230 min = 46×5m, 690 min = 138×5m,
+  e i confini 690 sono un **sottoinsieme** dei confini 230 → una barra HTF chiude esattamente su
+  una chiusura LTF. Merge HTF→LTF causale: `merge_asof` backward sulla **chiusura HTF** (≤ chiusura
+  LTF), così una barra HTF è usata solo quando è davvero chiusa. (~2287 barre/anno LTF, ~762 HTF.)
+- **BuzVola / BuzVolume = `chande01`** (Chande Momentum Oscillator normalizzato 0-100): serie
+  steady → 50, rampa-su → 100, rampa-giù → 0. Le ancore demo sono soddisfatte a livello di
+  indicatore (è la lettura fedele: "vol steady → neutro"). NB: l'EMA-ATR su un *linspace* sintetico
+  dà 100 per drift di warm-up/floating-point, non per comportamento reale — su BTC reale BuzVola
+  oscilla intorno a 50 (EMA-ATR vs SMA-ATR corr 0.90).
+- **Pattern** = Donchian breakout leak-free (shift(1)) su HTF, `ptn_n` barre (default 13 da 13/13/1).
+- **Regime** = bande-soglia tunabili su BuzVola/BuzVolume (i magici interi 4/3/2 - 4/2/2 non sono
+  nel brief; ricostruiti come `[vola_lo,vola_hi]` × `[vol_lo,vol_hi]`).
+- **Composer** = regime AND pattern. **Ingressi** ≤1/giorno (prima barra qualificante).
+- **Uscite**: time-based asimmetrico (`uscitalong`/`uscitashort` barre LTF) + hard stop/profit. Lo
+  "stop 2000 / profit 5000" in $ del sistema ES → **multipli di ATR LTF** (scale-free): default
+  `sl_atr=2.0`, `tp_atr=5.0` (~ rapporto 40:100 pt ES), con modalità `pct` alternativa.
+- Engine espresso come **entries `{dir,tp,sl,max_bars}`** per `backtest_signals` (motore onesto del
+  progetto: TP/SL intrabar, max_bars, non-overlap). Causalità verificata con prefix-recompute
+  (0 mismatch).
+
+## Baseline → V1 (lever scout + grid, inline, veloce)
+
+- **Baseline** (default 13/13, sl2/tp5, vola[35,95], vol_lo50): causale, fee-surviving, FULL Sharpe
+  BTC +0.91 / ETH +0.64, ma **HOLD-OUT debole** (BTC −0.09 / ETH +0.17) → FAIL del gate onesto.
+- **Lever scout** (`sweep.py`): gli **short servono** (long_only → HOLD −0.52); il **regime gate
+  conta** (togliere la banda vola → HOLD −0.80); il **floor di volume** a 50 *frenava* l'hold-out
+  (vol_lo=40 o 0 → PASS); **breakout più lento** (ptn_n=55) e **stop più larghi** (sl2.5/tp6)
+  alzano l'hold-out.
+- **Grid combinato** (`grid.py`): vincitrice **SKH01-V1**
+  `SkyhookParams(ptn_n=55, sl_atr=2.5, tp_atr=6.0, vola_lo=35, vola_hi=95, vol_lo=0.0)`:
+  - **min-asset FULL +0.69, HOLD-OUT +0.64** (BTC 0.64 / ETH 0.64), **PASS**, fee-surviving a 0.30%RT.
+  - BTC FULL +0.69/+275% DD49% ; ETH FULL +1.01/+871% DD31% ; entrambi HOLD-OUT positivi.
+  - **Marginal vs TP01 = ADDS** e regge i gate induriti: **corr 0.06** (ortogonale, NON trend-beta),
+    `has_insample_edge=True` (Sharpe in-sample standalone 1.15), `is_hedge=False`, multi-cut
+    persistente. Blend **0.75·TP01 + 0.25·SKH01: HOLD Sharpe 0.31 → 0.74 (+0.44), DD 11.9%**;
+    blend 50/50 HOLD 0.88, DD 17.8%.
+  - Unico sub-gate fallito: `clean_year_uplift` +0.014 (sotto 0.02) → `earns_slot=False` per un pelo,
+    nonostante tutto il resto sia forte. **Debolezza principale: DD standalone alto (40-49%).**
+
+→ SKH01 è un **diversificatore quasi-ortogonale** reale (non un TP01 travestito): da solo è
+volatile, ma come sleeve al 25% migliora moltissimo l'hold-out del portafoglio a DD bassissimo.
+
+## Onda 1 (`skyhook-improve`, 30 agenti) — winner intermedio
+
+Famiglie: param (RR, ptn_n, regime bands, exit bars, chande, local), regime-redef (percentile,
+realized-vol, vol-expansion, LTF), pattern (confirmation, ROC, Keltner, NR, dual), exit + overlay,
+ognuna verificata da 2 scettici. Risultato: **winner intermedio**
+`SkyhookParams(ptn_n=45, sl_atr=2.5, tp_atr=7.0, uscitalong=24, uscitashort=16, vola_lo=35, vola_hi=95, vol_lo=0)`
+— **minFull +0.83, minHold +0.81** (vs V1 +0.69/+0.64), causale, fee-surviving 0.30%RT, marginal
+**ADDS** (corr 0.05, has_insample_edge, robust_oos, multicut, clean_year_uplift +0.37), blend w25
+uplift_hold +0.58. **MA standalone maxDD ancora 34% (BTC) / 31% (ETH) → l'unico goal mancato era il DD<30%.**
+
+## Onda 2 (`skyhook-improve-v2`, 14 famiglie DD-reduction) — SKH01-V2-DD vince
+
+Obiettivo: tagliare il **DD standalone <30%** tenendo hold-out + `earns_slot`, e alzare l'uplift di
+portafoglio. 14 famiglie (ensemble param/struct, vol-target, DD kill-switch, RR/stop grid, regime
+tight, percentile, vol-expansion, breakout confirmation, dual-TF, asimmetria L/S, cadenza, chande,
+Keltner), ognuna verificata da 2 scettici avversariali (window-luck/multicut/jackknife +
+causalità/fee/plateau/overfit). Esito: **il winner intermedio cade.** Nuovo campione **SKH01-V2-DD**
+(famiglia ASYM_LS, `src/strategies/skyhook.py:SKH01_V2_DD`, run `runs/SKH2_ASYM_LS.py`):
+
+- **Config:** stesso SEGNALE del winner (`ptn_n=45, vola_lo=35, vola_hi=95, vol_lo=0, exit-bars 24/16`)
+  ma EXIT commutati da ATR a **percentuale fissa ASIMMETRICA** — long `sl=4% / tp=10%`, short
+  `sl=2% (più stretto) / tp=8%`. Motivazione meccanica: in crypto lo short si fa steamrollare da uno
+  spike vola e lo stop-ATR si allarga lasciando correre la perdita → il %-SL stretto sullo short
+  **cappa la perdita per-trade** che FORMA il maxDD. (Implementato come override per-direzione nel
+  motore, backward-compatible: campi `*_short=None` → comportamento simmetrico invariato.)
+- **Numeri veri (verificati indipendentemente via `sk.study(SKH01_V2_DD)`):** standalone maxDD
+  **BTC 21.4% / ETH 27.4%** (<30% ✓, vs 34.4/30.5 del winner) — **goal RAGGIUNTO**; minFull **+0.99**,
+  minHold **+1.26**; causalità **0/400** entrambi gli asset; fee@0.30%RT BTC +1.05 / ETH +0.80
+  (positiva anche a 0.40%). Marginal vs TP01 **ADDS** (corr 0.09, has_insample_edge, is_hedge=False,
+  robust_oos, multicut, clean_year_uplift +0.57). **Blend 0.75·TP01 + 0.25·SKH: uplift_hold +0.87**
+  (vs +0.58 del winner); **blend 50/50: full 1.84 / hold 1.59 / DD 10.7%**. earns_slot=True,
+  beats_winner=True. **Plateau reale** (i vicini Spct_mb14/16 sl2% tengono DD 27-28%), non knife-edge.
+  Entrambi gli scettici: holds_up=True, confidence high, killer_finding=null.
+
+**Top-3 dell'onda 2 (criteri onesti):**
+
+| # | Famiglia | maxDD (BTC/ETH) | minHold | w25 uplift_hold | Verifica |
+|---|---|---|---|---|---|
+| **1** | **ASYM_LS → SKH01-V2-DD** | 27.4% (21.4/27.4) | +1.26 | **+0.87** | 2/2 high, killer=null ✅ |
+| 2 | ENS_STRUCT (3-regime ensemble) | **22.9%** (21.2/22.8) | +1.00 | +0.67 | 2/2 high — ma 3 motori da eseguire |
+| 3 | TPSL_DD (%-SL/TP hard) | 28.0% (28/25.5) | +1.11 | +0.75 | 1/1 (rate-limit) — caveat hedge-like |
+
+**Lezioni anti-DD:**
+- **Ha funzionato (STRUTTURA dell'exit, non i parametri):** cambiare il MECCANISMO di uscita — %-SL
+  hard, asimmetria L/S, o ensemble di exit/regime diversi (decorrelazione). Il DD del winner nasce
+  dalla coda intra-trade negli spike ATR; il %-SL la cappa.
+- **NON ha funzionato (la leva non raggiunge il DD vincolante):** DD kill-switch entry-only (sopprime
+  solo le NUOVE entry, non chiude il trade aperto che forma il maxDD → floor 33-36%); vol-target
+  causale (DD<30 e uplift≥0.55 mutuamente esclusivi; cap>1 PEGGIORA il DD levereggiando nel pre-crash);
+  cadenza/FREQ (accorciare gli hold short fa esplodere ETH a 50-66%); dual-TF (LTF è resample dello
+  stesso prezzo → quasi-tautologico, DD invariato).
+- **Bocciato dagli scettici come overfit:** PATTERN_CONF (sub-30 solo a vola_lo=45, knife-edge: sl_atr
+  ±0.5 → ETH 40-47%; la conferma "close_loc" da sola NON taglia il DD). Esempio canonico del perché
+  serviva la doppia verifica.
+- **Non promuovibili:** PCTL_DD (numeri spettacolari ma **0 verifiche**, le 2 sono morte per rate-limit
+  → forward-monitor, non fidato); ENS_PARAM / TPSL_DD (battono i gate ma uplift recency/hedge-loaded,
+  concentrato nei regimi TP01-down → forward-monitor).
+
+**Promozione (questa sessione):** `SKH01_V2_DD` canonico nel motore + override exit-short
+asimmetrici (backward-compatible, V1/winner invariati) + 3 test nuovi (8/8 pass).
+
+**Sleeve cablato @0.25 effettivo** (`src/portfolio/sleeves.skyhook_sleeve` → `active_sleeves`): i tre
+sleeve preesistenti scalati nel restante 0.75 mantenendo il rapporto 55:25:20 → **TP01 41.25% / XS01
+18.75% / VRP01 15% / SKH01 25%**. Report del portafoglio (4 sleeve, `run_portfolio.py`):
+
+| | FULL Sharpe | FULL DD | HOLD-OUT Sharpe | HOLD-OUT DD |
+|---|---|---|---|---|
+| 3 sleeve (TP01+XS01+VRP01) | 1.68 | 14.3% | 1.63 | 3.4% |
+| **+ SKH01 @25%** | **2.13** | **7.8%** | **2.30** | 3.5% |
+| Δ | **+0.45** | **−6.5pt** | **+0.67** | ~0 |
+
+→ aggiungere Skyhook **alza lo Sharpe full +0.45 e DIMEZZA il DD full (14.3→7.8%)**, e alza l'hold-out
++0.67 a DD invariato. Portafoglio combinato: FULL Sh 2.13 / ret +365% / DD 7.8%, HOLD Sh 2.30 / DD 3.5%,
+positivo ogni anno (2019-26, DD annuo ≤7.8%) vs buy&hold 50/50 FULL Sh 0.93 / DD 76%.
+
+**Caveat onesti / NON deploy:** è un portafoglio di **ricerca** (peso fisso, no costi di ribilanciamento
+reale a $600; lo Sharpe daily-step di Skyhook è la convenzione del lens). ETH DD standalone 27.4% ha
+margine sottile vs 30%. Prima di un eventuale deploy: ri-verificare la causalità sul **codice di
+esecuzione reale** (qui è l'harness di ricerca) e i costi del book a 230m (ribilanciamento più frequente
+del resto). XS01/VRP01 restano STAT-MODE/lead. Per ora: research win + sleeve cablato, forward-monitor.

docs/diary/2026-06-23-tail-hedge-lab.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.

docs/diary/2026-06-26-cash-carry-hl.md

@@ -0,0 +1,69 @@
+# 2026-06-26 — Cash-and-carry (basis trade) delta-neutral su HL (CC01): premio REALE, Sharpe ARTEFATTO, NON deployabile
+
+**Goal utente:** dopo lo scarto del gamma scalping, "provare" gli altri due angoli proposti —
+funding-carry cross-sectional e basis/cash-and-carry. Il **funding cross-sectional (FC01) è già
+SCARTATO** (diario 2026-06-22: DILUTES, sign-flip su un nome). L'angolo non testato è il
+**cash-and-carry delta-neutral (CC01)**. Branch `research/gamma-scalp-options`,
+script `scripts/research/cash_carry_hl.py`.
+
+## Meccanismo (diverso da FC01)
+
+FC01 pickava cross-section (short alto-funding / long basso-funding) → scommessa relativa, fragile.
+CC01 **non picka**: harvesta il premio di funding AGGREGATO restando delta-neutral sullo *stesso*
+asset. Long spot + short perp (stessa size): le gambe lineari nel prezzo si cancellano → ritorno
+≈ **+funding** (lo short incassa il funding quando f>0), zero esposizione direzionale. Dati: funding
+orario reale HL dal 2023-05 (`hlfund_*_1h.parquet`), gli stessi 19 major di XS01.
+
+## Risultato grezzo — e perché NON va creduto
+
+| config | Sharpe | CAGR | maxDD | per-anno |
+|---|---|---|---|---|
+| BTC/ETH CC-static | **+12.9** | +13% | 0.8% | 2023:+10 2024:+23 2025:+8 2026:+1% |
+| BTC/ETH CC-gated | +13.9 | +14% | 0.3% | tutti positivi |
+| 19-major CC-gated | +11.6 | +16% | 0.4% | tutti positivi |
+
+**Uno Sharpe di 13 con DD 0.3% è un ALLARME, non un edge.** È la firma di un modello che cattura
+solo un cashflow liscio (il funding) e azzera la volatilità reale. Il marginal scorer dà **ADDS /
+robust_oos / has_insample_edge=True / multicut_persistent** su OGNI config — ma questo **espone un
+punto cieco dello scorer**: si fida della vol riportata dal candidato e non ha un gate "Sharpe
+implausibile → rischio nascosto". Un Sharpe di 13 dovrebbe squalificare-e-indagare, non passare.
+
+## Il rischio è NASCOSTO, non assente
+
+- **Mark-to-market della base** (`premium` col → `r = funding − Δpremium`): sgonfia lo Sharpe solo
+  13→11. La colonna premium di HL è già lisciata/clampata → a risoluzione daily il basis-vol è
+  minimo. **Quindi il basis-from-data NON è il rischio vero.**
+- **I rischi che giustificherebbero uno Sharpe realistico (~1-3) sono ASSENTI dal dataset:**
+  1. **2022 mancante.** Lo storico funding parte 2023-05 → niente deleveraging LUNA/3AC/FTX, il
+     regime di funding profondamente negativo + basis blow-out che farebbe il vero drawdown.
+  2. **Procyclicità.** Funding aggregato BTC/ETH: +23% nel toro 2024 → **+1.7% nel bear 2026**
+     (e 19-major CC-static 2026 = **−1%**). Solo 10% di giorni a funding negativo *in-sample* — ma
+     in un vero bear quella frazione esplode. Il carry **non è all-weather**: è un risk-on premium.
+  3. **Liquidazione dello short** in uno squeeze e **slippage** su spot+perp: non modellati.
+- **Sharpe reale di un crypto basis-trade ≈ 1-3 con code brusche** (Mar-2020, Mag-2021, FTX), non 13.
+
+## Eseguibilità a $600 — muro indipendente
+
+Serve spot **+** perp per gamba: BTC/ETH = 4 posizioni, 19-major = 38. Su Deribit (dove operiamo) lo
+storico funding è **bloccato** (404) e non tradiamo spot HL. **STAT-MODE**, come XS01/VRP01 ma peggio
+(doppia gamba per asset). Non deployabile a questo capitale.
+
+## Verdetto
+
+**CC01 = premio di funding REALE (~+8-14%/anno aggregato, positivo ogni anno in-sample) e
+genuinamente ortogonale a TP01 (corr ~0.05, NON direzionale).** È la "fonte di ritorno diversa" più
+concreta trovata finora. MA:
+- lo **Sharpe headline è fiction** (rischi di coda strutturalmente fuori dal dataset);
+- è **procyclico** (si comprime/inverte nel bear — proprio quando servirebbe);
+- **non eseguibile** a $600 / sul nostro venue.
+
+→ **LEAD da rivedere a scala** (capitale ~20k+ e un venue con funding eseguibile), **non uno sleeve**.
+Nessun impatto sul book live (branch separato).
+
+## Sottoprodotto metodologico (raccomandazione)
+
+CC01 ha passato ogni gate del marginal scorer pur essendo un'illusione di rischio. **Prossima
+indurita dello scorer:** un gate di *plausibilità dello Sharpe* — uno standalone Sharpe ≫ 4 deve
+declassare a "SUSPECT/INVESTIGATE" invece di alimentare ADDS, perché segnala vol sottostimata
+(mark-to-cashflow, dati che escludono il regime di stress, leva nascosta). Documentato qui, non
+implementato in questa passata per non toccare lo scorer condiviso su `main`.

docs/diary/2026-06-26-equity-fundnews-short.md

@@ -0,0 +1,58 @@
+# 2026-06-26 — "Short su fondamentali/notizie NEG ma prezzo SU": screener forward, edge non provato
+
+**Goal utente (chiarito):** se i dati finanziari/notizie di un'azienda sono negativi ma la
+quotazione è positiva (sale), andare SHORT — scommessa che il prezzo scenda a riallinearsi ai
+fondamentali. Branch `research/equity-meanrev-ib`, script `scripts/research/eq_fundnews_short.py`.
+
+## Gate dati (lezione v2.0.0) — NON backtestabile
+
+I fondamentali e le notizie scaricabili dalla rete (Yahoo) sono **snapshot CORRENTI**, non
+point-in-time storici. Applicarli a prezzi passati = **look-ahead** (restatement + survivorship):
+esattamente la classe di errore che ha prodotto la libreria fasulla v2.0.0. Un backtest onesto
+richiede un DB point-in-time (Compustat PIT, news storiche con timestamp) — **assente**. Quindi,
+come per la vol term-structure: **niente backtest**, l'unica via onesta è uno **screener forward**.
+
+## Cosa è scaricabile (feasibility, fatto)
+
+- **Fondamentali strutturati** via Yahoo quoteSummary (flusso cookie+**crumb**, tokenless):
+  `recommendationMean` (1=buy..5=sell), `revenueGrowth`, `earningsHistory` surprise%,
+  `recommendationTrend` (skew buy/sell). ✅
+- **Notizie**: Yahoo news search (headline + publisher), sentiment lessicale crudo. ✅ (proxy debole)
+- **Momentum**: chart API (return 1m/3m). ✅
+
+## Screener costruito + eseguito dal vivo
+
+`fund_neg` ∈ [0,1] (media di: recMean→sell, surprise negative, ricavi in calo, analisti a sell) +
+`news_neg` lessicale + momentum. **SHORT candidate = (fond/news neg) AND prezzo in salita** (la
+divergenza). Idempotente, logga forward su `data/raw/fundnews_short_screen.parquet`.
+
+**Run di oggi (2026-06-26): NESSUN candidato.** Quasi tutto l'universo ha momentum 1m **negativo**
+(mercato in flessione ampia, coerente col bear) → la gamba "prezzo che sale" non scatta. I peggiori
+per fondamentali (TSLA 0.48, BA 0.39, NKE 0.38) stanno comunque *scendendo*. Output sensato.
+
+## L'intuizione analitica chiave (il valore vero di questa analisi)
+
+La premessa ha una **tensione interna** che la rende la versione *rischiosa* dell'anomalia:
+- **Shortare un prezzo che SALE combatte il momentum** — una delle anomalie più robuste e persistenti
+  (i winner continuano a vincere su 3-12 mesi). Si scommette contro di essa.
+- **Il PEAD** (post-earnings drift) dice che dopo cattive notizie il prezzo continua a **scendere**;
+  ma qui il prezzo *sale malgrado* le cattive notizie → spesso significa che il mercato sta
+  **prezzando informazione** che i fondamentali *trailing* non contengono (turnaround, M&A, squeeze).
+- Quindi: la versione *pulita* dell'edge "short su fondamentali deboli" funziona meglio quando il
+  prezzo **conferma** (fondamentali deboli + prezzo che SCENDE = momentum e fondamentali allineati),
+  **non** quando diverge. La richiesta "shorta il titolo che sale su brutte notizie" è il caso
+  contrarian, più difficile e storicamente più punito (squeeze, perdita illimitata).
+
+## Eseguibilità (muro)
+
+Short = **borrow** (locate + fee; hard-to-borrow caro/assente), **perdita illimitata**, **squeeze**,
+**PDT $25k** per i day-trade, IB instabile qui, $600, universo single-stock (non i nostri ETF). NON
+deployabile.
+
+## Verdetto
+
+**Non un edge schierabile, né dimostrabile ora.** Deliverable onesto = lo **screener forward**
+(funzionante, da dati di rete) + il log che accumula i candidati per una validazione futura, con
+la chiara avvertenza che l'edge è **non provato** e che la *direzione contrarian* della scommessa
+(short sulla forza) è la parte fragile. Strumento utile (fond+news+momentum da rete in un colpo),
+tesi da maneggiare con scetticismo. Nessun impatto sul book live (branch separato).

docs/diary/2026-06-26-equity-meanrev-network-check.md

@@ -0,0 +1,57 @@
+# 2026-06-26 — Scalping azioni IB "quando sottoquotate" + check dati dalla rete
+
+**Goal utente:** su IB, comprare azioni quando "sottoquotate" (oversold/sotto fair-value), con
+verifica incrociata dei dati dalla rete. Branch `research/equity-meanrev-ib`,
+script `scripts/research/eq_meanrev_ib.py`. Due pezzi.
+
+## 1) CHECK DATI DALLA RETE — il pezzo richiesto (e perfettamente in-metodo)
+
+Confronto i dati certificati IB (`data/raw/eq_*_1d.parquet`, ADJUSTED_LAST) con una **sorgente di
+rete indipendente** (Yahoo Finance chart API, tokenless). È la lezione fondante del progetto: non
+fidarti di un feed solo (il disastro v2.0.0 era un feed contaminato).
+
+**Risultato (180g, BTC… no: 6 ETF):** dopo l'allineamento corretto **tutti CONCORDE**, deviazione
+sui rendimenti **≤1.2bps**, ultimo close identico (0.0bps). Il feed IB è validato.
+
+**La lezione (errore che ho fatto e corretto):** un primo confronto naïf (nostro close *adjusted*
+vs `close` *grezzo* di Yahoo) ha **falso-allarmato 4/6 ticker** a 30-52bps (SPY 30, TLT 40, HYG 52).
+Le divergenze erano **tutte su singoli giorni = stacco dividendo**: confrontavo dividend-adjusted vs
+non-adjusted. Usando l'`adjclose` di Yahoo (apples-to-apples) → ~0bps. **Regola: ogni divergenza va
+SPIEGATA prima di gridare "feed sporco" — e prima di tradarci sopra.** Lo strumento resta come
+validatore di feed riutilizzabile / template del pre-trade price-check live.
+
+## 2) "SCALPING quando sottoquotata" — non testabile/eseguibile; testato lo swing MR
+
+Lo **scalping intraday non è valutabile**: (a) non abbiamo dati intraday (solo `eq_*_1d`), (b) non
+è eseguibile — **PDT rule**: il day-trading di azioni US sotto **$25.000** è limitato a 3
+day-trade/5gg → lo scalping è *regolatoriamente bloccato* al capitale del progetto (l'analogo equity
+del muro STAT-MODE a $600 sul crypto), (c) IB Gateway è instabile qui (timeout ordini diagnosticato).
+
+Versione onesta e testabile = **swing mean-reversion** "compra quando sottoquotata": Connors RSI2<10
++ filtro trend MA200, exit a MA5. Causale (segnale ≤ close[i], entry a close[i]), netto fee, hold-out 2015+:
+
+| ETF | FULL Sh | DD | CAGR | expo | HOLD Sh | **B&H HOLD Sh** |
+|---|---|---|---|---|---|---|
+| SPY | +0.75 | 15% | +5% | 13% | +0.70 | **+0.81** |
+| QQQ | +0.50 | 16% | +4% | 14% | +0.56 | **+0.92** |
+| IWM | +0.32 | 22% | +2% | 13% | +0.15 | +0.53 |
+| DIA | +0.38 | 13% | +2% | 14% | +0.55 | +0.74 |
+| EEM | +0.41 | 20% | +3% | 13% | +0.36 | +0.46 |
+
+Fee sweep SPY: Sh 0.82 (0bps) → 0.75 (3) → 0.70 (5) → 0.58 (10bps RT).
+
+**Lettura onesta:** la mean-reversion "buy the dip" sugli indici equity ha un edge **reale ma
+modesto** (Sharpe ~0.5-0.75, investito solo ~13% dei giorni) **che NON batte il buy&hold
+risk-adjusted** (B&H hold-out 0.81 su SPY vs 0.70 della MR), con CAGR piccolo (2-5%) e sensibile ai
+costi. È capital-efficient in teoria (cash 87% del tempo) ma il valore aggiunto vs "tieni l'indice"
+è negativo o nullo, e la frequenza *scalping* che potrebbe aggiungere valore è bloccata dalla PDT.
+
+## Verdetto
+
+- **Check dati dalla rete: FATTO e utile** — feed IB validato (≤1.2bps vs Yahoo); strumento
+  riutilizzabile. Unico vero keeper della sessione equity.
+- **Scalping "sottoquotate": NON deployabile** — non testabile (no intraday), non eseguibile (PDT
+  $25k, IB instabile). Lo swing MR daily testabile **non batte il buy&hold** → niente edge schierabile.
+
+Conferma il pattern del progetto: l'idea promettente sopravvive solo finché non incontra
+eseguibilità + benchmark onesto. Nessun impatto sul book live crypto (branch separato).

docs/diary/2026-06-26-gamma-scalp-options.md

@@ -0,0 +1,74 @@
+# 2026-06-26 — "Scalping BTC/ETH con copertura in opzioni" = gamma scalping → SCARTATO
+
+**Domanda (goal utente):** analizzare lo scalping su BTC/ETH con copertura in opzioni come
+possibile nuovo sleeve. **Esito: negativo, strutturale, su tutte le frequenze. Non è uno sleeve,
+non è nemmeno un hedge.** Branch `research/gamma-scalp-options`, script
+`scripts/research/options_gamma_scalp.py`.
+
+## Cos'è davvero "scalping con copertura in opzioni"
+
+L'interpretazione rigorosa è il **gamma scalping**: compri un'opzione (la *copertura* = long
+gamma), delta-hedgi il sottostante a cadenza fissa (lo *scalp*), e il P&L netto è
+≈ dollar-gamma × (vol realizzata² − vol implicita²). È lo **specchio esatto del VRP01** (short-vol):
+VRP01 incassa IV−RV (positivo in media), il gamma scalping incassa **RV−IV** (negativo in media).
+
+Modello (mirror della struttura VRP per comparabilità): long straddle ATM, tenor 7g, IV = DVOL
+Deribit (la stessa fonte del VRP), delta-hedge sui prezzi certificati, fee opzioni cap 12.5% del
+premio + fee perp 0.05%/lato sull'hedge turnover, return-on-notional vol-targeted 20%.
+
+## La diagnostica strutturale (il cuore)
+
+| asset | IV (DVOL) | RV 1d | IV−RV 1d | RV 1h | IV−RV 1h |
+|---|---|---|---|---|---|
+| BTC | 60.9% | 56.0% | **+4.9pp** | 64.5% | −3.6pp |
+| ETH | 74.9% | 76.0% | −1.0pp | 81.0% | −6.1pp |
+
+- A **rehedge giornaliero** l'IV ≈ o > la RV → il long gamma **paga il VRP** (sei sul lato sbagliato
+  del premio). Perde gross, prima di ogni fee.
+- A **rehedge orario** la RV *supera* l'IV (BTC +3.6pp, ETH +6.1pp gross) — sembrerebbe un edge…
+  **ma è una trappola doppia:** (a) la RV_1h è gonfiata da microstruttura (bid-ask bounce), quindi
+  il "gross edge" è in parte fittizio; (b) il rehedge orario paga **24× la fee di hedge**, che
+  spazza via qualunque edge intraday reale.
+
+## I numeri (ogni variante, ogni anno, ogni frequenza: PERDE)
+
+| variante | rehedge | Sharpe | CAGR | per-anno |
+|---|---|---|---|---|
+| NAKED | 1d | **−3.99** | −56% | 2021..2026 tutti −25..−68% |
+| CHEAP-GATED (IVr<0.30) | 1d | −3.05 | −47% | tutti negativi |
+| RICH-SKIP (IVr>0.90) | 1d | −3.92 | −55% | tutti negativi |
+| NAKED | 1h | **−6.06** | −71% | tutti −38..−81% (peggio: le fee) |
+| CHEAP-GATED (IVr<0.30) | 1h | −4.96 | −64% | tutti negativi |
+
+Il gate "compra vol solo quando è a sconto" (lo specchio del gate vincente del VRP, *vendi vol solo
+quando è cara*) **migliora ma non salva**: −3.05 invece di −3.99. Il segno resta negativo perché
+l'IV-rank basso non garantisce RV > IV su 7 giorni.
+
+## Scoring marginale vs TP01
+
+Tutte le varianti: **DILUTES**, `is_hedge=False`, `has_insample_edge=False` (IS Sharpe −3..−4.5),
+blend-25 uplift hold −1.2/−1.5. Non aiuta nemmeno come hedge: perde sia quando TP01 è su
+(uplift −1.2..−1.6) sia quando TP01 è giù (uplift −2.5..−3.2). Corr a TP01 ≈ 0 ma il drift negativo
+domina la matematica di diversificazione.
+
+## Eseguibilità a ~$600 (muro indipendente)
+
+- **BTC**: contratto 1 BTC, min 0.1 BTC → notional minimo **$5.968** ≫ $600 → **NON eseguibile**.
+- **ETH**: min 0.1 ETH → **$157** → marginalmente OK, ma un solo straddle = ~25% del conto in premio.
+
+Anche se l'edge esistesse, BTC è fuori e ETH è troppo grosso per diversificare.
+
+## Conclusione
+
+Lo "scalping con copertura in opzioni" è **schiacciato tra due muri**: rehedge lento → paghi il
+premio (RV < IV); rehedge veloce → paghi le fee (24×/day). **Nessuna frequenza vince.** Conferma
+due lezioni di prim'ordine del progetto, ora quantificate sul long-vol:
+1. **Le fee uccidono lo scalping** (il rehedge orario, vera frequenza di scalping, è la variante
+   *peggiore*: −6 Sharpe).
+2. **Vol-da-modello è fragile in entrambe le direzioni.** Regola gemella del VRP: *niente long-vol
+   scalp da modello in deploy*.
+
+**Il VRP01 (lato short, gated, rischio-definito) resta l'unico edge opzioni del progetto** —
+e funziona proprio perché sta sul lato *giusto* dello stesso premio che il gamma scalp paga.
+
+SCARTATO. Script preservato come riferimento. Nessun impatto sul book live (branch separato).

docs/diary/2026-06-26-tp01-dvol-overlay.md

@@ -0,0 +1,66 @@
+# 2026-06-26 — TP01 × DVOL vol-targeting: NON migliora (il taglio di DD è solo de-levering)
+
+**Goal utente:** "continua" ad analizzare strategie. Dopo i tre angoli di diversificazione tutti
+STAT-MODE (gamma scalp scartato, funding cross-sectional già morto, cash-and-carry lead non
+deployabile), ho puntato sull'angolo a **più alto valore perché ESEGUIBILE**: migliorare il
+risk-sizing del book **live** TP01 (BTC/ETH perp Deribit, già armato). Branch
+`research/gamma-scalp-options`, script `scripts/research/tp01_dvol_overlay.py`.
+
+## Ipotesi
+
+TP01 vol-targeta sulla vol **realizzata** 30g (backward-looking). Il **DVOL** (vol implicita 30g
+Deribit, forward-looking, che spesso anticipa i salti di vol) come denominatore → de-risking più
+tempestivo prima dei crash → DD più basso / hold-out migliore senza affondare il FULL.
+
+Onestà: DVOL parte 2021-03 → confronto TUTTE le varianti sulla **finestra comune 2021-04 → 2026**
+(1891g, perdo il toro 2019-2020 pre-DVOL). Causale, fee 0.10% RT, config canonica TP01.
+
+## Risultati (finestra comune, hold-out 2025+)
+
+| variante (denominatore vol) | FULL Sh | FULL DD | CAGR | HOLD Sh |
+|---|---|---|---|---|
+| **realized** (baseline) | **+0.75** | 12.3% | +8% | +0.30 |
+| dvol (implicita) | +0.70 | 9.3% | +6% | +0.33 |
+| blend 50/50 | +0.72 | 10.4% | +7% | +0.32 |
+| max(realiz, dvol) | +0.70 | 9.2% | +6% | +0.36 |
+| derisk (gate DVOL>p90 ×0.5) | +0.75 | 12.3% | +8% | +0.30 |
+
+Le varianti DVOL **abbassano il DD** (12.3% → ~9.2%) ma **anche** Sharpe FULL (−0.04/−0.05) e CAGR
+(8% → 6%). Lo Sharpe è scale-invariant → sospetto: il taglio di DD è solo *posizioni più piccole*
+(l'IV > RV per il VRP → denominatore più grande → leva minore), non vero timing.
+
+## Il controllo decisivo
+
+Confronto le varianti DVOL col **realized a target_vol RIDOTTO** (stesso de-levering, senza DVOL):
+
+| | FULL Sh | DD | CAGR | HOLD Sh |
+|---|---|---|---|---|
+| **max-DVOL** | +0.70 | 9.2% | +6% | +0.36 |
+| **realized @ vol-tgt 15%** | **+0.75** | 9.4% | +6% | +0.30 |
+| **realized @ vol-tgt 13%** | +0.75 | **8.1%** | +5% | +0.30 |
+
+**Conclusivo:** il realized a 15% eguaglia il DD del max-DVOL (9.4% ≈ 9.2%) a Sharpe **più alto**
+(0.75 > 0.70) e stesso CAGR; a 13% fa DD ancora più basso (8.1%), sempre a 0.75. **Il taglio di DD
+del DVOL è interamente "leva minore", replicabile MEGLIO con un semplice target_vol più basso.**
+
+## Verdetto
+
+**DVOL vol-targeting NON migliora TP01.** Risk-adjusted è marginalmente *peggiore* (FULL 0.70 vs
+0.75 a parità di DD). L'unico residuo a favore — hold-out +0.06 (max 0.36 vs 0.30) — è **single-window**
+su 5 anni scarsi di storia DVOL: sotto la soglia di **persistenza multi-cut** del progetto (la lezione
+che ha ucciso 13/14 falsi positivi nello sweep alt). Il gate **DVOL-spike de-risk è RIDONDANTE col
+trend**: quando il DVOL esplode (crash) TP01 è già flat (momentum negativo → posizione 0) → il gate
+non tocca nulla (Δ 0.00 su tutto). Niente da deployare.
+
+## Lezioni
+
+1. **Per meno DD sul book live, la leva giusta è `target_vol`, non un overlay DVOL.** Abbassare TP01
+   da vol-tgt 20% → 15% taglia il DD 12.3% → ~9.4% allo **stesso Sharpe** (0.75). Dial pulito e noto,
+   se mai si volesse un profilo più difensivo (oggi 20% è la scelta canonica — invariata).
+2. **La vol implicita non batte la realizzata come denominatore di sizing per un trend long-flat**:
+   il segnale di trend gestisce già il de-risking direzionale; il denominatore fissa solo la
+   magnitudine, e la realizzata lo fa marginalmente meglio per unità di rischio.
+3. Conferma indiretta del soffitto: anche un raffinamento "ovvio" e *eseguibile* su TP01 non produce
+   alpha; al massimo sposta il punto sulla stessa frontiera rischio/rendimento.
+
+SCARTATO come miglioria. Nessun impatto sul book live (branch separato, config canonica invariata).

docs/diary/2026-06-26-vol-termstructure-feasibility.md

@@ -0,0 +1,47 @@
+# 2026-06-26 — Calendar-vol / term-structure DVOL: il DATO STORICO NON ESISTE (data-first gate)
+
+**Goal utente:** "continua" — angolo scelto: scaricare e certificare la term-structure DVOL per
+testare un calendar-vol (front IV vs back IV). **Esito: bloccato a monte dal gate "il dato prima
+della strategia" (lezione v2.0.0).** Branch `research/gamma-scalp-options`.
+Script: `scripts/research/probe_vol_termstructure.py` (scan) + `log_vol_termstructure.py` (forward).
+
+## Scan di fattibilità (prima di costruire qualunque backtest)
+
+Cosa l'API pubblica Deribit espone davvero per la vol per-scadenza:
+
+| dato | disponibile? |
+|---|---|
+| Snapshot CORRENTE della term-structure ATM (mark_iv per scadenza) | **SÌ** (book_summary_by_currency, tokenless) |
+| DVOL storico | solo **30g** fisso — nessun indice 7g/60g/90g pubblico |
+| Trade-history IV per strumento | solo per strumenti **VIVI** (gli scaduti spariscono) |
+| **Serie storica continua front-vs-back IV** | **NO** — il front-month rotola/espira → irricostruibile |
+
+**Snapshot oggi (2026-06-26), per riferimento:**
+- BTC spot $59.9k: 7g 45.6% · 30g 43.2% · 60g 42.7% · 90g 42.9% · 180g 44.5% — **contango** lieve.
+- ETH spot $1.58k: 7g 57.6% · 30g 56.4% · 90g 57.5% · 180g 59.2% — contango (+1.6pp slope).
+- (I valori sono interpolati a tenor fissi: il front a 1-giorno grezzo, 38%/54%, è rumore escluso.)
+
+## Verdetto
+
+**Un calendar-vol NON è backtestabile ora su dati certificati.** La storia per-scadenza non è
+pubblica su Deribit (la nostra fonte di verità), e — coerentemente con la metodologia — **nessun
+edge va creduto senza backtest OOS su dati certificati**. Costruire un calendar-vol su uno snapshot
+singolo o su una storia ricostruita-a-pezzi sarebbe esattamente il tipo di scorciatoia che ha
+prodotto la libreria fasulla v2.0.0. Quindi: **stop, niente backtest.**
+
+## L'unica via legittima: costruire il dato in avanti
+
+`scripts/research/log_vol_termstructure.py` — logger forward idempotente: ogni run prende lo snapshot
+ATM, lo interpola ai tenor fissi {7,30,60,90,180}g e appende una riga/asset a
+`data/raw/vol_term_<asset>.parquet`. Seminate le prime righe BTC/ETH oggi. Test offline
+`tests/test_vol_termstructure.py` (interpolazione pura).
+
+**Non auto-cablato in cron** (è ricerca forward, e non tocco il cron live senza ok). Per accumulare:
+aggiungere una riga giornaliera al crontab. Dopo **~6-12 mesi** → certificare (monotonia, spike,
+cross-venue) e SOLO ALLORA testare front-vs-back. Prima, nulla.
+
+## Lezione
+
+Il data-first gate ha funzionato: ha fermato un backtest su un dato che non esiste, invece di
+produrre un numero non falsificabile. La term-structure è in **contango** oggi (regime calmo) —
+osservazione da forward-monitor, non un edge. Nessun impatto sul book live (branch separato).

docs/diary/2026-06-29-dvol-directional.md

@@ -0,0 +1,118 @@
+# 2026-06-29 — DVOL come segnale DIREZIONALE/REGIME su BTC/ETH: l'unico edge è un HEDGE, non alpha
+
+**Filone A — "DVOL-direzionale".** Tesi: usare la vol IMPLICITA Deribit (DVOL, `data/raw/dvol_*.parquet`,
+2021-03→oggi) come **segnale direzionale o di regime** sul perp BTC/ETH (long-flat o L/S sul LIVELLO di
+mercato), non come denominatore del vol-target. Script `scripts/research/dvol_directional.py`, test
+`tests/test_dvol_directional.py`. Branch `research/equity-meanrev-ib` (separato, nessun impatto live).
+
+## Cosa è diverso dal lavoro DVOL precedente
+
+- `tp01_dvol_overlay.py` (2026-06-26): DVOL come **denominatore** del vol-target → solo de-levering, SCARTATO.
+- VOL03/04/10/11 (sweep alt 100-agent): DVOL che **gata/scala un TSMOM** → eredita lo Sharpe di trend di
+  TP01 (il marginal scorer li boccia NEUTRAL/REDUNDANT).
+- `agent_14_dvol_spread` (onda ortho): IV **relativa BTC-vs-ETH**, market-NEUTRAL 2-leg (l'unico LEAD vivo).
+
+Qui invece: DVOL/IV-RV come segnale **direzionale STANDALONE sul livello di mercato**, per vedere se porta
+alpha direzionale **ortogonale** a TP01 (non un overlay sul trend). Tutto causale (decisione ≤ `close[i]`,
+tenuta in `i+1` dallo shift di `eval_weights`), fee 0.10% RT, vol-target 20%, leva cap 2x, harness onesto
+condiviso `altlib`. Allineamento DVOL: `al.dvol` (merge_asof backward) → DVOL close del giorno *t* (≈
+contemporaneo a `close[i]`), noto a decisione; verificato leak-free (`causality_ok` max_tail_diff 0.0).
+
+DVOL parte 2021-03 → pre-DVOL il segnale è flat. Valuto sia **FULL** (col flat pre-2021, deflaziona lo
+Sharpe) sia **ERA-only** (da 2021-10, equo per la tesi).
+
+## 1) Probe direzionale (corr segnale[i] vs ritorno[i+1], pooled BTC+ETH, era DVOL)
+
+| segnale | corr | long bps | flat bps | **edge bps** | frac_long |
+|---|---|---|---|---|---|
+| VRP-Z+ (long VRP ricco, IV-RV alto) | +0.010 | +7.8 | −0.9 | **+8.6** | 0.52 |
+| VRP-Z− (flip) | −0.017 | −0.9 | +7.8 | −8.6 | 0.48 |
+| **DVOL-LV fear (rank>0.5 → long)** | **+0.024** | +20.4 | +0.9 | **+19.5** | 0.14 |
+| DVOL-LV calm (rank<0.5 → long) | −0.013 | +0.8 | +21.2 | −20.4 | 0.86 |
+| DVOL-MOM (DVOL in calo → long) | −0.041 | −10.0 | +22.9 | **−32.9** | 0.59 |
+| VRP>0 (quasi buy&hold) | +0.003 | +5.3 | −0.7 | +5.9 | 0.72 |
+
+Lettura: l'unico contenuto direzionale reale è **"buy-the-fear"** (long quando il DVOL è alto nel suo
+percentile espandente: edge +19.5 bps il giorno dopo). Il VRP-ricco→long è coerente ma debolissimo (+8.6).
+Il "DVOL in calo → long" è **negativo** (−33 bps): comprare quando la paura scende è perdente (regola
+falsificata). Nota: il percentile espandente è dominato dai picchi 2021-22 → "fear" scatta solo nel 14%
+delle barre (gli spike veri), non metà del tempo.
+
+## 2) Robustezza assoluta (study_weights 1d, fee sweep 0.00-0.20% RT) — ERA-only il giudizio equo
+
+| segnale | abs | minFull Sh | minHold Sh | feeOK | **ERA Sh** | ERA DD | ERA CAGR |
+|---|---|---|---|---|---|---|---|
+| **DVOL-fear q0.4 LF** | WEAK | +0.39 | +0.14 | sì | **+0.59** | **8%** | +5% |
+| VRP-Z60 LF | FAIL | +0.42 | −0.39 | sì | +0.46 | 23% | +7% |
+| DVOL-fear q0.5 LF | FAIL | +0.31 | −0.17 | sì | +0.40 | 10% | +3% |
+| VRP-Z90 LF | FAIL | +0.32 | −0.26 | sì | +0.32 | 29% | +4% |
+| VRP-Z90 L/S | FAIL | +0.25 | +0.32 | sì | +0.31 | 28% | +3% |
+| DVOL-calm q0.5 LF | FAIL | +0.00 | −1.05 | no | +0.09 | 37% | −0% |
+| DVOL-MOM k10/k20 LF | FAIL | −0.6/−0.7 | <−1 | no | −0.6/−0.7 | ~40% | ~−10% |
+| DVOL-MOM k10 L/S | FAIL | −1.16 | −1.29 | no | −1.23 | 72% | −23% |
+
+Nessun segnale supera lo Sharpe assoluto in **valore** (tutti < 0.6, soffitto direzionale BTC/ETH ~1.3
+confermato). Unico con profilo decente: **DVOL-fear q0.4 long-flat** (ERA Sh +0.59, DD **8%**) — il DD
+bassissimo perché è long solo nei picchi di paura (poche barre, mean-reversion). Le famiglie momentum e
+"buy-the-calm" sono nettamente negative e non sopravvivono nemmeno alle fee.
+
+## 3) Marginal vs TP01 (il gate vero) — DVOL-fear q0.4 long-flat
+
+| | corr→TP01 | in-sample Sh | uplift_full w25 | uplift_hold w25 | multi-cut persistente | is_hedge | verdetto |
+|---|---|---|---|---|---|---|---|
+| **ERA-only** (2021-10+) | 0.37 | 0.54 (has_edge) | +0.06 | +0.17 | sì | **No** | **ADDS** (earns_slot=True) |
+| **FULL** (gate ufficiale) | 0.28 | 0.64 (has_edge) | +0.03 | +0.17 | sì | **Sì** | **HEDGE** (earns_slot=**False**) |
+
+Il candidato ha tutto ciò che serve a un nuovo sleeve **tranne una cosa**: il gate canonico full-history
+lo classifica **HEDGE**, non alpha. `hedge_yearly_corr(TP01-Sh, uplift) = −0.76`, `uplift TP01-up −0.003`
+/ `uplift TP01-down +0.194` → **paga SOLO quando TP01 è debole**. Ha perfettamente senso: il DVOL esplode
+durante i crash, proprio quando il trend di TP01 è flat/in-drawdown; comprare la paura cattura il rimbalzo
+e smorza il DD del portafoglio, ma **non è un premio permanente**. Il blend 0.75·TP01 + 0.25·cand alza
+l'hold-out 0.30→**0.47** (w50 → 0.62) e taglia il DD a ~11%/8% — un effetto **drawdown-dampener** reale,
+ma classificato (giustamente) come hedge.
+
+Perché ERA dice ADDS e FULL dice HEDGE: il rivelatore di hedge richiede ≥3 anni; sulla finestra ERA
+(2021-10+) la `corr(TP01-Sh annuale, uplift)` è meno netta e non scatta. **Il gate full-history è quello
+giusto** (più dati per il test di hedge) → mi attengo a quello: **HEDGE, non alpha.**
+
+Gli altri tre candidati (VRP-Z60/90, DVOL-fear q0.5): **NEUTRAL o HEDGE**, mai ADDS. I VRP-Z hanno beta a
+TP01 alto (0.88-0.90) → sono trend-correlati travestiti (resid Sharpe ~0), uplift hold-out negativo.
+
+## 4) Causalità, alignment, eseguibilità, sign-falsification
+
+- **Causale**: `causality_ok` ok=True, max_tail_diff **0.0** su tutti i candidati (rank espandente +
+  z-score ricalcolati su prefisso = identici → nessun future-peeking). Test dedicato `test_expanding_rank_is_causal`.
+- **Alignment DVOL**: laggando il segnale di +1 giorno (extra-conservativo, usa solo DVOL di ieri) l'ERA
+  Sharpe del leader scende +0.59 → **+0.45**. L'edge sopravvive ma è **sensibile all'allineamento**
+  (parte del vantaggio è nel reagire allo spike DVOL del giorno stesso) → cautela in esecuzione.
+- **Eseguibile a $600**: `eval_weights_smallcap` (min_order $5, cap $300/asset): haircut Sharpe **≈ 0.00**
+  su BTC ed ETH (segnale long-flat a basso turnover, ~210-270 trade su tutta la storia) → lo Sharpe netto
+  onesto a $600 = quello modellato. È l'unico aspetto pienamente promosso.
+- **Sign-falsification**: tesi buy-the-fear ERA Sh +0.40 vs flip buy-the-calm +0.09; VRP-Z+ +0.32 vs
+  VRP-Z− (flip) −0.14. Il segno della tesi è quello giusto (l'edge è reale, non rumore simmetrico).
+
+## Verdetto onesto: **LEAD (hedge / drawdown-dampener), NON sleeve.** SCARTATO come alpha direzionale.
+
+- Nessun segnale DVOL-direzionale ha Sharpe assoluto sopra ~0.6 → **conferma il soffitto BTC/ETH
+  direzionale ~1.3** (la via per superarlo resta il cross-sectional XS01, non un nuovo segnale a 2 asset).
+- L'unico con edge in-sample reale + eseguibile + leak-free è **DVOL-fear "buy-the-fear" long-flat**, ma il
+  gate canonico lo bolla **HEDGE** (`is_hedge=True`, paga solo quando TP01 è in difficoltà). Per la regola
+  del progetto un hedge **non si arma come slot di alpha** → **earns_slot=False**.
+- È comunque un **LEAD utile in forward-monitor** come **smorzatore di drawdown** del portafoglio: il blend
+  porta l'hold-out 0.30→0.47/0.62 e abbassa il DD. Se in futuro si vorrà esplicitamente un tail/DD-hedge
+  *eseguibile* (a differenza del tail-hedge in opzioni, non eseguibile a $600), questo è il candidato più
+  pulito visto finora — ma da prezzare **come hedge**, non come ritorno atteso permanente.
+
+## Caveat
+
+1. **Storia DVOL <5 anni** (2021-03→oggi, ~4.7 anni; era valutata 2021-10+) → multiple-testing e
+   finestra corta. Il multi-cut 2026 è un assurdo +1.944 (manciata di giorni, picco DVOL recente): 
+   l'uplift hold-out è trascinato dal regime 2025-26 ad alta-paura, non da un edge stazionario.
+2. **È un hedge, non alpha**: il valore è condizionato ai drawdown di TP01 (2022, ed eventuali futuri).
+   In un toro lungo a bassa vol il segnale resta **flat l'86% del tempo** e non contribuisce nulla.
+3. **Sensibile all'allineamento** DVOL (haircut −0.14 Sharpe col lag +1g): l'esecuzione reale dovrebbe
+   usare il DVOL già stampato a decisione, non assumere il close contemporaneo.
+4. Long-flat → cattura il rimbalzo post-paura ma **non protegge** durante la discesa (non è uno short):
+   è "buy-the-dip gated by fear", con tutti i rischi del comprare coltelli che cadono se il regime peggiora.
+
+Nessun impatto sul book live (branch separato, nessuno sleeve registrato, config canonica invariata).

docs/diary/2026-06-29-intraday-regime.md

@@ -0,0 +1,145 @@
+# 2026-06-29 — Filone B: INTRADAY REGIME BTC/ETH — ERM (efficiency-ratio) è un LEAD reale, forward-monitor
+
+**Tesi.** Cercare un meccanismo **sub-daily** sui dati certificati 1h→12h BTC/ETH che sia ortogonale
+**sia** a TP01 (TSMOM trend daily, long-flat) **sia** a SKH01 (regime BuzVola/BuzVolume + Donchian a
+230m). SKH01 prova che il sub-daily PUÒ funzionare ed essere quasi-ortogonale: qui un MECCANISMO DIVERSO,
+basato sulla **qualità del moto intraday** (efficiency-ratio / vol-expansion / thrust) come **regime** che
+condiziona una posizione direzionale tenuta ~1 giorno. Script `scripts/research/intraday_regime.py`, test
+`tests/test_intraday_regime.py`. Branch `research/equity-meanrev-ib` (separato, nessun impatto live).
+
+Killer ricorrente del progetto sotto le 12h = **muro-fee 0.10% RT + overfitting**. Ricetta SKH01:
+decisione sub-daily ma **hold ~1 giorno** → pochi trade → la fee non uccide. Ogni meccanismo qui è
+costruito a basso turnover e giudicato col **fee-sweep alla sua frequenza reale**.
+
+## Meccanismi provati (tutti come posizione CONTINUA decisa ≤ `close[i]`, causali)
+
+| | meccanismo |
+|---|---|
+| **ERM** | **Efficiency-Ratio regime momentum** (Kaufman): ER = \|moto netto su L barre\| / \|percorso\|. Prendi la direzione del moto netto **solo quando ER ≥ soglia** (regime intraday "pulito"/trendy), altrimenti flat |
+| VEM | Vol-Expansion Momentum: direzione = segno del moto, attiva solo quando vol-corta > vol-lunga |
+| VBR | Volatility/thrust breakout (Larry-Williams ROLLING, no calendario): segui i moti > k·ATR |
+| TOD | Time-of-day seasonality — **CONTROLLO calendario**, incluso APPOSTA per `day_boundary_robust` |
+
+## Selezione + fee-sweep a frequenza reale (vincitori per famiglia, min-asset)
+
+```
+ERM: 8h  L=2.0 thr=0.35 L/S   minFull +0.88  minHold +0.99  f@.20 +0.55  feeOK=True  turn/y 125
+VEM: 12h Lmom=3 Ls=2 Ll=10    minFull +0.72  minHold -0.29  f@.20 +0.51  feeOK=True   (hold<0 → out)
+VBR: 12h k=1.0 atr=14 L/S     minFull +0.33  minHold +1.20  f@.20 +0.25  feeOK=True
+TOD: 1h                       minFull -3.99  minHold -4.49  feeOK=False              (controllo → FAIL atteso)
+```
+
+Solo **ERM** e **VBR** sopravvivono al gate fee+OOS. VEM ha hold-out negativo. TOD esplode (vedi sotto).
+
+## Il candidato: ERM 8h L=2.0 thr=0.35 (L/S) — `earns_slot=True`
+
+```
+abs=PASS  marginal=ADDS  EARNS_SLOT=True
+standalone: cand FULL 0.919 / HOLD 1.105   (TP01 ref FULL 1.297 / HOLD 0.303)
+corr->TP01 full 0.146  hold 0.057   beta 0.197   resid Sharpe 0.738   alpha/yr 0.121
+robust_oos=True (clean-year +0.103, drop-best-month +0.283)
+multi-cut persistence: 2020 .166 / 2021 .167 / 2022 .298 / 2023 .337 / 2024 .418 / 2025 .497 / 2026 2.861  persistent=True
+has_insample_edge=True  (standalone PRE-holdout Sharpe 0.874, > null-pctl 0.317)
+is_hedge=False  (yearly corr(TP01-Sh, uplift) -0.762; paga sia TP01-up 0.139 sia TP01-down 0.384)
+blend w25: FULL 1.481 (+0.184)  HOLD 0.80 (+0.497)  DD 11.0%
+corr con SKH01: full 0.278  hold 0.291
+day_boundary=INVARIANT (spread 0.0)   haircut $600 ≈ 0.00 su BTC/ETH
+```
+
+È il **primo sub-daily da SKH01** a passare TUTTI i gate del marginal scorer indurito: edge in-sample
+reale (non diversification-math), persistenza multi-cut, robust_oos, NON hedge, scorrelato a TP01 (0.15).
+
+### ERM aggiunge OLTRE SKH01? (gate #5 — il book esistente ne ha già uno sub-daily)
+
+| blend | FULL Sh | FULL DD | HOLD Sh | HOLD DD |
+|---|---|---|---|---|
+| TP01 | +1.30 | 14.3% | +0.30 | 7.5% |
+| TP01+SKH 75/25 | +1.78 | 9.4% | +1.17 | 6.2% |
+| **TP01+SKH+ERM 60/25/15** | **+1.88** | 8.9% | **+1.46** | 5.3% |
+| TP01+SKH+ERM 55/20/25 | +1.84 | 8.8% | +1.48 | 5.1% |
+
+Sì: corr con SKH01 solo 0.28 → ERM **aggiunge oltre SKH** (FULL +0.10, HOLD +0.29 a peso 15%, DD ancora
+giù). Non è SKH01 travestito.
+
+## Il controllo TOD (calendario) — fa esattamente ciò che doveva
+
+`TOD` (direzione per ora-del-giorno, media espandente causale) è incluso come **trappola**: è il tipo di
+effetto che uccise `open_drive` (artefatto di etichettatura UTC). Esito: **FAIL** (FULL −3.99, 31.811
+trade, fee-killed), marginal=DILUTES. `day_boundary_robust=INVARIANT` → l'effetto è **robustamente
+negativo** a ogni offset (non un artefatto di confine giorno: è proprio che la time-of-day-direzionale non
+ha edge e sanguina fee). Il controllo conferma che l'harness non si fa ingannare e che il segno
+dei segnali di prezzo (ERM/VBR) è reale, non rumore di calendario.
+
+## Causalità / eseguibilità
+
+- **Leak-free**: `causality_ok=True`, max_tail_diff **0.0** su tutti i candidati (ER, rank espandente,
+  medie su prefisso = identiche → nessun future-peeking). Test dedicato in `test_intraday_regime.py`.
+- **day_boundary_robust=INVARIANT** (spread 0.0) per ERM/VBR/TOD: segnali di prezzo, non di calendario.
+- **Eseguibile a $600**: `eval_weights_smallcap` haircut **≈ 0.00** su BTC ed ETH. **MA** ERM a 8h fa
+  ~3.158 trade BTC / ~2.823 ETH su tutta la storia (turnover 125/anno): haircut nullo nel modello, ma
+  l'esecuzione reale sub-daily sul book è operativamente più pesante di un segnale 1d (slippage/spread
+  intraday non interamente catturati dalla fee proporzionale).
+
+## Caveat (perché LEAD, non sleeve)
+
+1. **Plateau hold-out a UNA SOLA RIGA.** Il FULL è robusto su tutta la griglia L∈[2.0,3.0] (+0.6..+1.0),
+   ma l'**hold-out è positivo SOLO a L=2.0** (a L=2.5/3.0 crolla a −0.5..−0.8). Il plateau sul full è
+   ampio, quello che conta — l'hold-out — è single-row. Da rinforzare prima di credere alla stazionarietà.
+2. **Standalone FULL 0.92 < soffitto ~1.3.** Coerente col soffitto direzionale BTC/ETH: il valore di ERM
+   è **marginale/diversificante** (corr 0.15 a TP01, 0.28 a SKH01), non assoluto. Non rompe il soffitto.
+3. **Multiple-testing non deflazionato.** 102 celle testate (60 ERM + 16 VEM + 24 VBR + 2 TOD) senza
+   deflated-Sharpe (a differenza del filone C). Il multi-cut 2026 = +2.861 è una manciata di giorni che
+   gonfia. Storia sub-daily certificata utile ~quanto SKH01 → finestra non lunghissima.
+4. **Esecuzione 8h** = complessità operativa reale (vedi sopra), oltre il modello a haircut nullo.
+
+## Analisi di robustezza / de-bias (`intraday_regime_analysis.py`) — il lead NON regge
+
+I caveat #1 (plateau hold-out single-row) e #3 (multiple-testing) erano i sospetti giusti. Tre test di
+de-bias li trasformano da sospetto in **bocciatura** dello slot:
+
+| test | esito |
+|---|---|
+| **A) Deflated-Sharpe** (Bailey & Lopez de Prado) su 122 trial cercati | **FAIL.** DSR 0.000 (tutti) / **0.163 (escludendo i trap TOD)** / 0.241 (solo-ERM) — tutti ≪ 0.95. Lo Sharpe winner (0.92) è sotto lo Sharpe-max-atteso-null (1.16–2.51): il search ha trovato celle a 1.6 full / 1.7 in-sample, il winner 0.92 **non è eccezionale**. |
+| **B) Selezione IN-SAMPLE-only** (scelgo la cella ERM col solo Sharpe < 2025) | **earns_slot=False.** La cella migliore pre-hold-out è un'**ALTRA** (8h L=2.0 thr=0.4 **long-flat**), con corr→TP01 **0.53** (è trend-beta travestito) → marginal=**NEUTRAL**. Il winner max-hold **non si seleziona senza guardare l'hold-out** → il suo `earns_slot=True` era **selezione-sull'hold-out**. |
+| **C) Ensemble del plateau** (media 20 celle L×thr, niente cherry-pick) | **earns_slot=False.** marginal=ADDS, in-sample Sh 1.01, corr→TP01 0.18 — ma **`robust_oos=False`** (clean-year + jackknife): l'uplift hold-out è trascinato dal **2026 (+2.09 multicut)**, manciata di giorni. |
+
+**Dove vive l'(eventuale) edge** (per-anno, blend 3-way 60/25/15 vs 2-way 75/25): uplift FULL solo **+0.10**,
+**negativo nel 2021 (−0.23) e 2022 (−0.15)**, positivo altrove; l'uplift HOLD **+0.30 è concentrato nel
+2026 (+0.46)**. corr(ERM,SKH) 0.28 full (fino a 0.42 in alcuni anni) → **parziale sovrapposizione con SKH**,
+non ortogonalità piena.
+
+**Lettura.** Il segnale efficiency-ratio non è rumore puro (l'ensemble ha in-sample Sh ~1.0, positivo nella
+maggior parte degli anni), ma come **slot** fallisce ogni de-bias: il `earns_slot=True` della scoperta era
+prodotto da **(1) selezione della cella sull'hold-out** + **(2) coda 2026** + **(3) multiple-testing non
+corretto**. È lo stesso falso-positivo che l'alt-sweep 100-agent imparò a uccidere — qui ucciso dai gate.
+
+## Caveat originari (ora risolti dall'analisi sopra)
+
+1. ~~Plateau hold-out single-row~~ → **confermato fatale**: l'edge hold-out a L=2.0 è cell-selection.
+2. ~~Multiple-testing non deflazionato~~ → **deflazionato: DSR FAIL** anche senza i trap.
+3. Esecuzione 8h: irrilevante ormai (lo slot non c'è).
+
+## Verdetto onesto: **NON è uno slot. Falso positivo da selezione-hold-out + coda 2026.** SCARTATO come sleeve.
+
+Lo "earns_slot=True" della scoperta **non sopravvive** alla de-selezione: deflated-Sharpe FAIL (anche
+escludendo i controlli), selezione in-sample-only → NEUTRAL su un'altra cella (trend-beta corr 0.53),
+ensemble del plateau → robust_oos FAIL. **Conferma ennesima del soffitto direzionale BTC/ETH ~1.3**: un
+segnale a 2 asset non lo supera; la via resta il cross-sectional (XS01). Resta al più una **curiosità in
+forward-monitor** (l'efficiency-ratio ha un debole edge in-sample reale), ma da non armare come alpha.
+Gli altri tre meccanismi: VBR=NOISE, VEM hold-out<0, TOD=controllo FAIL come atteso.
+
+**Lezione harness (CODIFICATA).** Lo script di scoperta selezionava il vincitore per `min_hold` massimo
+sulla griglia = **selezione-sull'hold-out**, il punto cieco che ha generato il falso PASS. Il marginal
+scorer da solo non basta se la *cella* è scelta guardando l'hold-out: serve **(a)** scegliere la cella
+in-sample-only (o walk-forward) **prima** di valutare il marginal, e **(b)** deflazionare per il numero di
+celle/famiglie testate. Stesso buco segnalato per CC01 ("Sharpe implausibile") e per l'alt-sweep
+(hold-out-fitting): qui in forma "selection-on-holdout". Ora è **codice** in `altlib` (LESSON 4): tre
+funzioni nuove — `deflated_sharpe()` (Bailey & Lopez de Prado), `select_cell_insample()` (scelta cella
+col solo Sharpe pre-HOLDOUT), e il gate combinato **`study_family_honest()`** (`earns_slot_honest =
+earns_slot[cella in-sample] AND deflated-Sharpe≥0.95`). Verificato: su ERM il gate ritorna
+`earns_slot_honest=False` (cella in-sample = trend-beta NEUTRAL, DSR 0.74). Analisi completa in
+`scripts/research/intraday_regime_analysis.py`; test in `tests/test_harness_realism.py`.
+**Regola nuova: una strategia direzionale grid-searched si giudica con `study_family_honest`, non
+chiamando `study_marginal` sulla cella a max hold-out.**
+
+Nessun impatto sul book live (branch separato, config canonica invariata).

docs/diary/2026-06-29-macro-regime-gate.md

@@ -0,0 +1,71 @@
+# 2026-06-29 — Filone D: MACRO regime-gate sul book crypto — RIDONDANTE col trend, SCARTATO
+
+**Tesi.** Usare segnali macro/cross-market — equity (SPY/QQQ/IWM), credito (HYG/LQD), oro (GLD/SLV),
+tassi (TLT/IEF) — come **gate risk-on/risk-off** sul book BTC/ETH, per migliorare il *timing* del
+drawdown di TP01: regime risk-off (credito che cede, equity sotto trend, fuga sui bond) → riduci/azzera
+l'esposizione crypto; risk-on → lascia agire TP01. **È eseguibile** (gata solo BTC/ETH perp, non aggiunge
+gambe). Script `scripts/research/macro_regime_gate.py`, test `tests/test_macro_regime_gate.py`. Branch
+`research/equity-meanrev-ib` (separato, nessun impatto live). Dati: `data/raw/eq_*_1d.parquet` (ETF daily,
+allineati causale `merge_asof backward` sul calendario SPY).
+
+**NON è un lead-lag direzionale** (già morto: diari 2026-06-22/-23). L'angolo nuovo = un overlay
+binario/continuo di **de-risk** sul book esistente.
+
+## Il rischio noto in partenza (CLAUDE.md)
+
+La lezione DVOL-spike (2026-06-26): un gate di de-risk rischia di essere **ridondante col trend** — TP01
+è già long-flat e va a 0 nei crash (Δ 0.00). Questo script DOVEVA dimostrare che il gate aggiunge **oltre**
+quel che TP01 fa da solo. **Non ci riesce.**
+
+## Gate provati (tutti causali: SMA/ratio/z-score rolling, merge_asof backward)
+
+`SPY>MA{50,100,150,200,250}`, `HYG>MA`, ratio di credito `HYG/LQD`, `HYG/IEF`, combo a maggioranza
+(SPY+HYG+HYG/LQD, binario e continuo), flight-to-quality (`TLTup&SPYdn`, `GLDup&SPYdn`), regime di vol
+equity `SPYvol_z1` (proxy "VIX-spike" senza VIX). g_off ∈ {0.0, 0.5}.
+
+## Esiti
+
+I gate di trend equity alzano lo Sharpe FULL della combo (SPY>MA150/200/250 → FULL ~1.22-1.25 vs TP01-solo
+1.30) ma **non l'hold-out** (HOLD ~0.17-0.19) → è **de-levering**, non timing: tagliano DD spegnendo il
+book in mercati equity laterali, non anticipando i crash crypto. Il miglior profilo DD è `SPYvol_z1`.
+
+### Deep-dive `SPYvol_z1` — il controllo decisivo (ridondanza col trend)
+
+| | exposure TP01 risk-off | exposure risk-on | giorni risk-off | **giorni in cui il gate LAVORA** | corr(1-gate, 1-expo) |
+|---|---|---|---|---|---|
+| BTC | 0.023 | 0.093 | 18% | **3%** | 0.278 |
+| ETH | 0.013 | 0.068 | 16% | **2%** | 0.296 |
+
+"Il gate lavora" = giorno risk-off **E** posizione TP01 non già flat. Accade nel **2-3% dei giorni**: nel
+resto, quando il gate vorrebbe de-riskare, TP01 è **già flat da solo**. Il gate spegne un motore già spento.
+
+### Marginal scorer vs TP01 (gate come candidato-sleeve)
+
+```
+abs=FAIL  marginal=REDUNDANT  EARNS_SLOT=False
+corr->TP01 full 0.989  hold 0.984  beta 0.978  resid Sharpe 0.739
+multi-cut persistent=True  has_insample_edge=True (standalone 1.634)  is_hedge=False
+blend w25: full 1.323 (+0.026)  hold 0.257 (-0.046)   blend w50: full 1.348 (+0.051)  hold 0.21 (-0.093)
+```
+
+corr→TP01 **0.989**, beta 0.98: lo stream gated **È** TP01. L'uplift hold-out è **negativo** (de-levering
+che toglie ritorno fuori dai crash). overlay-delta (gated−solo) come stream a sé: `verdict=NEUTRAL`.
+
+## Causalità / eseguibilità (gli unici aspetti promossi)
+
+- **Leak-free**: `causality_ok=True` (max_tail_diff 0.0); STRICT align (1 barra equity extra di lag) →
+  FULL invariato; `day_boundary_robust=INVARIANT` (spread 0.0). Allineamento macro→crypto backward-only.
+- **Eseguibile a $600**: haircut `eval_weights_smallcap` ≈ **0.00** su BTC ed ETH. Fee-survivente
+  (0.00→0.30% RT: 1.42→1.33). Tecnicamente impeccabile — semplicemente **non aggiunge alpha**.
+
+## Verdetto: **SCARTATO (ridondante col trend).** earns_slot=False.
+
+Conferma esatta della lezione in CLAUDE.md: un overlay di de-risk su un book che è **già** long-flat e
+già a 0 nei crash non ha quasi nulla da fare (lavora il 2-3% dei giorni, corr→TP01 0.99). Il taglio di DD
+che mostra è **de-levering**, replicabile meglio con un `target_vol` più basso (stessa lezione del
+TP01×DVOL overlay del 2026-06-26). Il macro-regime **non anticipa** i drawdown crypto meglio del prezzo
+crypto stesso. Nessuno sleeve registrato; nessun impatto sul book live.
+
+**Sottoprodotto utile:** il gate `redundancy_diag` (exposure risk-off vs risk-on + "quota giorni in cui il
+gate lavora") è il test pulito da riusare ogni volta che si propone un overlay di de-risk — se "il gate
+lavora" è basso e corr→TP01 ~1, è ridondante, a prescindere dallo Sharpe FULL che mostra.

docs/diary/2026-06-29-strategy-search-5threads.md

@@ -0,0 +1,106 @@
+# 2026-06-29 — Ricerca strategie a 5 thread paralleli: 0 nuovi sleeve, 1 LEAD che rompe 2 muri su 3
+
+**Mandato.** "Cerca altre strategie" (+ "senza correlazioni, a segnale" + "a 1 gamba in/out a segnale").
+Cinque ricerche parallele su aree genuinamente inesplorate, tutte sull'harness onesto condiviso
+(`altlib` + `xsec_v2_nonmom`) con TUTTI i gate: causalità (prefix-check), netto fee 0.10% RT + sweep,
+OOS hold-out 2025+, **deflated-Sharpe** (multiple-testing), **gate anti-selection-on-holdout**
+(`study_family_honest`: cella scelta IN-SAMPLE-only), marginal vs TP01/XS01, corr vs book, haircut $600.
+Branch `main`, **nessun impatto live** (solo file nuovi, nessuno sleeve registrato).
+
+Premessa onesta (base-rate): il soffitto direzionale BTC/ETH ~1.3 è già confermato e lo sweep di 104
+ipotesi (2026-06-20) non produsse nulla di nuovo che reggesse. L'attesa era "quasi tutto SCARTATO".
+
+## Esiti per thread
+
+| # | Thread | File | Verdetto |
+|---|--------|------|----------|
+| 1 | **XSEC low-risk cousins** (MAX/lottery, idio-vol, Amihud) | `xsec_v3_lowrisk.py` | 1 LEAD (IVOL), 0 sleeve |
+| 2 | **XSEC momentum-structure** (risk-adj/accel/frog-in-pan/vol-managed vs XS01) | `xsec_v3_momstruct.py` | tutto REDUNDANT/SCARTATO |
+| 3 | **Meta-allocazione** (allocazione dinamica tra i 4 sleeve) | `meta_allocation.py` | pesi fissi vincono |
+| 4 | **Segnali ortogonali ETH/BTC** (relative-value dollar-neutral) | `orthogonal_signals.py` | 2 LEAD (STATARB, DVOLSPREAD) |
+| 5 | **1-gamba a segnale** (MACD/RSI/Supertrend/Donchian/BBands/EMA) | `signal_inout_1leg.py` | 0/12 earns_slot |
+
+**Netto: 0 nuovi sleeve.** Il soffitto regge. Test 143/143.
+
+### Thread 1 — Low-risk cross-sectional (51 alt HL)
+Tre fattori mai provati (il filone C aveva fatto total-vol e BAB, non questi). **IVOL** (idiosyncratic-vol
+basso, 19-major B30 H5 k8): FULL 1.06 / HOLD **1.22** / corr ~0 a XS01 e TP01 / positivo ogni anno /
+uplift portafoglio HOLD +0.42/+0.50 — l'unico LEAD di valore. **MAX** e **AMIHUD-liquido** sono lo stesso
+tema "evita speculativo/illiquido/volatile" in altre vesti (corr fra loro 0.33-0.59). **AMIHUD
+long-illiquido SCARTATO** (premio illiquidità invertito in crypto: vincono i major liquidi). Bocciatura
+del claim forte: **deflated-Sharpe 0.30-0.37 ≪ 0.95** (96 trial), storia ~2.5 anni, book 10-16 gambe →
+**STAT-MODE**. Nota di rigore: il naive best-HOLD atterrava su celle in-sample-negative (holdout-fitting) →
+l'agente ha auto-aggiunto il gate has_insample_edge. → **forward-monitor IVOL**.
+
+### Thread 2 — Momentum-structure vs XS01
+4 varianti (risk-adjusted, acceleration, frog-in-pan, vol-managed). **Nessuna batte né diversifica XS01**
+(standalone 1.42). Sostituire XS01 con una variante **distrugge l'hold-out** del portafoglio (−0.58…−1.38)
+— prova diretta che l'edge di XS01 sta nella sua struttura SPECIFICA (blend z-score [30,90] + gate
+dispersione), non in varianti generiche. Deflated-Sharpe max 0.49. Tutte REDUNDANT/SCARTATO.
+
+### Thread 3 — Meta-allocazione dinamica
+Vol-parity / momentum-of-sleeves / dispersion-regime / drawdown-control vs pesi fissi, con costo di
+ribilancio realistico. **Nessuno batte i pesi fissi OOS.** Vol-parity = trappola da manuale (+0.09…+0.44
+sui tagli in-sample 2022-24, **−0.11 sull'hold-out 2025** → intercettato dal multi-cut). Drawdown-control
+RIDONDANTE (TP01 va già flat nei crash, il gate non si attiva mai). I 4 sleeve sono già quasi-scorrelati
+(corr ~0.12 max) → i pesi fissi sono già vicini al risk-parity ottimo statico. **Mantenere i pesi fissi.**
+
+### Thread 4 — Segnali ortogonali ETH/BTC (il risultato più notevole)
+Relative-value dollar-neutral sul ratio log(ETH/BTC): 6 segnali, evaluator a 2 gambe (fee × 2), cella
+scelta in-sample-only.
+
+| segnale | FULL/HOLD | corr→book | β-mkt | marginal | DSR (grid/same-sign) | exec $600 | verdetto |
+|---|---|---|---|---|---|---|---|
+| **STATARB-RESID** (residual relative-mom ETH−β·BTC, W45 **sgn+1**) | 0.84/0.56 | **0.027** | 0.013 | **ADDS** | 0.056 / 0.929 | haircut ~0 | **LEAD** |
+| DVOLSPREAD (IV relativa, W60) | 0.74/0.77 | 0.017 | 0.012 | ADDS | 0.082 / 0.907 | haircut ~0 | LEAD |
+| RATIO-MOM/REV/ACCEL | 0.25-0.68 / ≤0 | ~0 | ~0 | NEUTRAL | <0.23 | ok | NEUTRAL (diversification-math) |
+| VOLSPREAD | −0.24/−1.47 | ~0 | 0.013 | DILUTES | — | — | SCARTATO |
+
+**STATARB-RESID rompe 2 dei 3 muri storici:** è **ortogonale per costruzione** (corr→book 0.027, beta di
+mercato 0.013 — meglio di SKH ~0.09) **ED eseguibile a $600** (book a 2 gambe BTC+ETH perp Deribit,
+haircut ≈ 0, fee-survive fino a 0.30%/gamba → **NON STAT-MODE**, a differenza di XS01 e delle opzioni). Il
+muro che **resta** è l'**edge**: Sharpe 0.84 / DSR 0.929 same-sign (ottimistico) ma comunque <0.95.
+Verificato indipendentemente dal coordinatore: residuo causale (β OLS rolling backward, decisione a
+close[i], return in i+1), fee a 2 gambe corretta. **⚠ Correzione di etichetta:** la cella vincente è
+**sgn=+1**, NON sgn=−1 → NON è mean-reversion ma **momentum relativo sul residuo** (long lo spread quando
+ETH è ricco vs il suo fit su BTC: le dislocazioni ETH-vs-BTC *continuano* a 1d; la MR pura sgn=−1 perde
+−1.4 in-sample). L'ortogonalità (β~0) viene dalla struttura dollar-neutral, non dal verso. → **LEAD
+forward-monitor** (monitorabile a costo reale ~0), NON deploy. **CABLATO:** `scripts/live/paper_statarb.py`
+(config CONGELATA W=45/sgn=+1, doppio libro MODELED/REAL-$600, riusa il segnale esatto di
+`orthogonal_signals.py`), aggiunto al cron giornaliero accanto a `paper_prevday`; test `tests/test_paper_statarb.py`.
+**DVOLSPREAD** ri-valida l'ex-lead `dvol_spread`: ADDS ma storia DVOL corta (2021+) → resta forward-monitor
+come già noto. Secondario crypto-vs-macro = "TSMOM travestito" (corr→book 0.17-0.20), non ortogonale.
+
+### Thread 5 — 1-gamba a segnale (eseguibile)
+12 famiglie (MACD/RSI/Supertrend/Donchian/BBands/EMA, ±ADX) su 1d/12h/8h. **0/12 earns_slot_honest.**
+**Eseguibilità validata** (haircut $600 = 0 ovunque; RSI-MR ~2.5 trade/anno) — ma è l'unica cosa che
+regge. I trend-follower sono **TP01 travestito** (corr 0.44-0.79, full ~1.2-1.3 = il soffitto) e le celle
+sub-daily scelte in-sample **collassano OOS** (dimostrazione da manuale del gate selection-on-holdout). La
+mean-reversion è morta (BBands-MR has_insample_edge=False). I "low-corr interessanti" (RSI-MR, MACD-LS,
+Donchian-LS) sono **HEDGE non alpha** (`is_hedge=True`, pagano solo quando TP01 è debole), e con
+deflated-Sharpe <0.95 (RSI-MR 0.861; Donchian-LS passa DSR ma is_hedge). **A $600 un 1-gamba a segnale è
+eseguibile ma non aggiunge nulla a TP01.**
+
+## Sintesi / cosa ho imparato
+
+1. **0 nuovi sleeve, soffitto ~1.3 riconfermato** dal lato direzionale e dal lato struttura-momentum. La
+   ricerca è onesta: ogni candidato è stato ucciso dal gate giusto (deflated-Sharpe, is_hedge,
+   selection-on-holdout, sostituzione-XS01, multi-cut), non da un giudizio a occhio.
+2. **Il LEAD di valore è STATARB-RESID** (ETH/BTC residual mean-reversion). È il primo stream visto che è
+   **insieme ortogonale (β~0) ED eseguibile a 2 gambe** — cadono i due muri che bloccano XS01 (STAT-MODE)
+   e le opzioni. Manca solo l'edge sopra-soglia. È il candidato n.1 per il **forward-monitor**, e l'unico
+   che — se la finestra forward confermasse l'edge — sarebbe *deployabile* a $600 (non statistico).
+3. **Forward-monitor (STAT-MODE / sub-soglia):** IVOL (idio-vol XS, 19-major), DVOLSPREAD (storia corta),
+   STATARB-RESID (eseguibile — il più promettente). Nessuno armato come sleeve.
+4. **I gate nuovi funzionano:** `study_family_honest` (selection-on-holdout) ha intercettato i collassi
+   OOS dei trend 1-gamba e dei low-risk XS; il deflated-Sharpe ha tenuto sotto la soglia ogni Sharpe ~1
+   su storia corta. La lezione del filone B (de-bias prima di credere) è ora applicata di default.
+
+## Caveat
+- Universi/finestre: HL ~2.5 anni, DVOL dal 2021 → multiple-testing reale; tutti i LEAD sono sotto la
+  soglia deflazionata. Niente di questo va creduto come alpha finché una finestra forward non lo conferma.
+- Nessuno sleeve registrato, config canonica invariata (TP01+XS01+VRP01+SKH01 a pesi fissi). Book live
+  intatto. Tutto il lavoro è statistico/forward, su `main` come ricerca.
+
+Script: `scripts/research/{xsec_v3_lowrisk,xsec_v3_momstruct,meta_allocation,orthogonal_signals,signal_inout_1leg}.py`.
+Test: i rispettivi `tests/test_*.py` (143/143 verdi).

docs/diary/2026-06-29-xsec-v2-nonmom.md

@@ -0,0 +1,65 @@
+# 2026-06-29 — Filone C: cross-sectional NON-momentum su Hyperliquid — DEBOLE / forward-monitor
+
+**Tesi.** XS01 (sleeve attivo) è momentum cross-sectional sui 19 major HL. Lezione del progetto
+(2026-06-19/20): **espandere il numero di asset NON aiuta il momentum** (gli small-cap diluiscono/
+invertono il segnale). Quindi qui NON si ri-prova l'espansione-universo: si cerca un **meccanismo
+DIVERSO dal momentum** che, market-neutral e scorrelato, possa diversificare il portafoglio. Script
+`scripts/research/xsec_v2_nonmom.py`, test `tests/test_xsec_v2.py`. Branch `research/equity-meanrev-ib`.
+
+## Meccanismi provati (tutti L/S dollar-neutral, vol-target ~20%, ribilancio periodico, CAUSALI)
+
+| | meccanismo |
+|---|---|
+| REV | short-term reversal grezzo (long loser / short winner di breve) |
+| IREV | reversal **idiosincratico** (sul residuo dopo aver tolto il mercato, beta-adjusted) |
+| LOWVOL | factor **low-vol** (long bassa vol realizzata / short alta vol) |
+| IMOM | momentum **idiosincratico** (sul residuo, ≠ raw mom) — *riferimento* |
+| BAB | betting-against-beta (long basso beta / short alto beta) |
+| MOM | momentum grezzo — *riferimento* |
+
+Universi: **19 major** e **51 all** (i parquet certificati). Gate canonico di selezione: FULL>0.5,
+HOLD>0, |corr→XS01|<0.6 (escluse le famiglie momentum MOM/IMOM, che sono riferimento, non candidati).
+
+## Esiti — un solo candidato non-momentum supera il gate standalone
+
+```
+[OK] LOWVOL  19-major  B30 H10 k5   FULL +1.07  HOLD +1.07  DD 19%  corrXS +0.16  corrTP -0.28
+[--] BAB     19-major  B60 H10 k8   FULL +0.47  HOLD +1.15  DD 28%  corrXS +0.20  corrTP -0.27
+[--] REV/IREV (19 e 51)             FULL ~0 o NEGATIVO  (reversal cross-sectional non paga)
+[--] LOWVOL  51-all                 FULL +0.42  (il long-tail diluisce, come per il momentum)
+```
+
+- **REV / IREV negativi** (FULL −0.10..−0.70): il reversal cross-sectional grezzo o idiosincratico **non
+  è un edge** su questo universo/finestra — coerente con la morte storica del mean-reversion del progetto.
+- **BAB** ha un buon hold-out ma FULL solo +0.47 (sotto soglia) e DD 28%.
+- **LOWVOL 19-major** (betting-against-vol) è l'unico idoneo: FULL **1.07** / HOLD **1.07** / DD 19%,
+  causale (max_tail_diff 0), corr→XS01 +0.16 (scorrelato), corr→TP01 −0.28.
+- Espandere a **51 asset peggiora** anche il low-vol (FULL 1.07→0.42): riconferma che i margini
+  cross-sectional sono nella **struttura del segnale**, non nel numero di asset.
+
+### Uplift portafoglio (4 → 5 sleeve, LOWVOL come 5° sleeve)
+
+```
+BASE (TP01+XS01+VRP01+SKH01)     FULL 2.12 DD 8% | HOLD 2.25 DD 3%
++LOWVOL @10%                     FULL 2.17 (+0.05)  | HOLD 2.57 (+0.32)
++LOWVOL @15%                     FULL 2.19 (+0.06)  | HOLD 2.62 (+0.37)
+```
+
+## Il muro (perché NON è uno sleeve)
+
+1. **Deflated Sharpe 0.130 ≪ 0.95** (N=216 trial globali; soglia Sharpe-max-null annualizz. 1.79). Con il
+   numero di celle/famiglie/universi testati, lo Sharpe 1.07 **non è significativo** dopo la correzione
+   per multiple-testing. Per-anno: 2024 +0.23 / 2025 +0.50 / **2026 −0.09** (il 2026 è già negativo).
+2. **Storia ~2.5 anni** (HL nativo 2024-2026): finestra troppo corta per un fattore cross-sectional.
+3. **Non eseguibile a $600**: book L/S a molte gambe (10+ per lato) → **STAT-MODE**, mai deploy. Stesso
+   vincolo strutturale di XS01 (serve ~20k di capitale).
+
+## Verdetto: **DEBOLE / forward-monitor (STAT-MODE).** Nessuno sleeve registrato.
+
+Il **low-vol cross-sectional** (betting-against-vol sui 19 major) è l'unico meccanismo non-momentum con un
+profilo decente e scorrelato sia a XS01 sia a TP01, e migliorerebbe l'hold-out del portafoglio (+0.32/+0.37).
+**MA** non supera il deflated-Sharpe (multiple-testing), ha storia cortissima ed è non-eseguibile a questo
+capitale. → lavoro **puramente statistico**, da tenere in forward-monitor come *secondo* segnale
+cross-sectional a fianco di XS01, da rivalutare solo a scala (capitale ~20k+) e con più storia HL.
+
+Reversal cross-sectional (REV/IREV) **confermato non-edge** su HL. Nessun impatto sul book live.

docs/diary/2026-07-01-alt-breadth-internals.md

@@ -0,0 +1,91 @@
+# 2026-07-01 — Breadth / market-internals del mercato ALT come segnale su BTC/ETH — SCARTATO
+
+**Tesi.** Gli "internals" del mercato crypto — la partecipazione degli alt — come segnale
+direzionale o gate di de-risk su BTC/ETH perp (2 gambe, eseguibile a ~$600): % di alt sopra la
+propria SMA(N), advance/decline, % di alt che battono BTC (risk-appetite relativo), breadth-thrust.
+Script `scripts/research/r0701_breadth_internals.py` (non committato per policy del filone; harness
+`altlib`). Dati: i 51 parquet certificati `data/raw/hl_*_1d.parquet` → panel di **49 alt**
+(esclusi hl_btc/hl_eth dalla breadth; hl_btc solo come riferimento per la famiglia RS), barre a
+volume 0 mascherate (lezione backfill 2026-06-20; il fetch le aveva già ripulite: vol0=0 su tutti
+i file, gate comunque attivo).
+
+**Limite strutturale dichiarato in partenza:** l'universo HL parte dal 2024-01 → dopo il warmup
+(max 120g) la finestra comune è **2024-05-05 → 2026-07-01 (~2.2 anni)** e l'in-sample pre-HOLDOUT
+è **~8 mesi del toro 2024**. Qualunque esito poteva essere al massimo un lead.
+
+## Famiglie e griglia (108 celle, tutte contate nel deflated Sharpe)
+
+4 famiglie × N∈{20,50,100} × soglia∈{0.3,0.5,0.7} × forma∈{LS, long-flat, gate-su-TP01}:
+
+- **FAM-MA**: % di alt validi con close > SMA(N) (breadth classica).
+- **FAM-AD**: frazione di advancers (ret 1g>0), SMA(N).
+- **FAM-RS**: % di alt che battono BTC sul ritorno a N giorni (≈ market-neutral, l'angolo più ortogonale).
+- **FAM-TH**: breadth-thrust = Δ a N giorni della breadth MA20 (thrust/collapse), score 0.5+Δ.
+
+Tutte causali (rolling/shift soltanto), MIN_VALID=20 asset per data (osservato: 42-49). LS/LF
+vol-target 20% cap 2x (sizing TP01-style); GATE = posizione TP01 × gate binario. Fee 0.10% RT +
+sweep 0-0.30%. Procedura onesta = mirror di `study_family_honest` sulla finestra comune (il
+padding pre-2024 avrebbe contaminato il ranking full-history: le celle GATE con gate=1 pre-storia
+erediterebbero lo Sharpe 2019-2024 di TP01): **cella scelta col SOLO Sharpe in-sample**, DSR su
+tutti i trial, `marginal_vs_tp01` di altlib sulla cella scelta.
+
+## ⚠️ Bug trovato e corretto: allineamento merge_asof su indice non-ns
+
+La prima versione di `_align` usava `b.index.view("int64")//10**6` per i timestamp della breadth:
+su un DatetimeIndex tz-aware **a risoluzione non-ns** (pandas 2.x) la scala esce sbagliata →
+`merge_asof backward` matchava OGNI barra BTC/ETH all'**ultimo** valore della breadth = **il futuro
+broadcast su tutta la storia**. Sintomo: decine di celle con lo stesso identico Sharpe (il segnale
+era una costante). **`causality_ok` NON lo vede** — la serie breadth è un input esterno *fisso*,
+quindi il target sul prefisso troncato coincide col target full per costruzione. Fix: epoca
+esplicita `(idx - Timestamp(1970, tz=UTC)) // Timedelta(1ms)` (come `resample_tf`). **Lezione
+harness:** ogni allineamento di un panel esterno via merge_asof va fatto con epoch-ms esplicita, e
+il sintomo "molte celle con Sharpe identico" è un red-flag di allineamento rotto (gemella
+dell'osservazione merge_asof del 2026-06-20).
+
+## Esito (procedura onesta, finestra comune 2024-05+)
+
+104/108 celle valutabili (4 degeneri flat), 47 con FULL>0. **Cella scelta in-sample** (IS 2.11,
+la selezione non tocca mai l'hold-out): **TH N=100 thr=0.7 long-flat** — long solo dopo un
+breadth-thrust (+0.2 di breadth MA20 in 100g), attiva il 32% dei giorni.
+
+| metrica | valore |
+|---|---|
+| standalone finestra comune | IS **+2.11** → FULL **+0.99**, HOLD **+0.41** |
+| assoluto (per-asset, trimmed) | **PASS** — minFull +0.68, minHold +0.38, fee-survive 0.30%RT, DD 7-11% |
+| marginale vs TP01 | **ADDS** — corr full **0.401**/hold 0.358, resid Sharpe 0.87, multicut {2025:+0.076, 2026:+0.366} persistente, is_hedge=False |
+| **robust_oos** | **False** — jackknife drop-best-month **−0.068** (l'uplift hold-out sta in piedi su UN mese) |
+| **deflated Sharpe** | **0.433** su 104 trial (null-max atteso 1.10) — lontanissimo dal PASS ≥0.95 |
+| earns_slot / earns_slot_honest | **False / False** |
+| causality_ok | True (post-fix) |
+| smallcap $600 | haircut ≈ **0.00** (BTC −0.01, ETH +0.00; 137-152 trade) — eseguibile |
+
+**Ridondanza col trend (il rischio n.1, lezione macro-gate):** qui NON è la modalità di morte.
+corr(pos, TP01pos) 0.15-0.30 e il segnale "lavora" (off mentre TP01 non è flat) nel **24-32% dei
+giorni** (il macro-gate lavorava nel 2-3%). Le forme direzionali LS/LF sono genuinamente diverse
+da TP01 (corr→TP01 0.1-0.4). La forma **gate-su-TP01** invece sì: best gate = NEUTRAL a corr
+0.803, e i gate a soglia bassa = REDUNDANT corr 1.0 (gate mai off → TP01 identico). **La breadth
+come gate di de-risk non aggiunge nulla; come segnale direzionale è diversa dal trend ma l'edge
+non è dimostrabile.**
+
+**Il gemello in hindsight (trasparenza, NON selezionabile).** TH N=100 thr=0.7 **LS** fa FULL 1.13
+/ HOLD 1.06, corr→TP01 **−0.26**, marginal ADDS con robust_oos=True e jackknife +0.46. MA il suo
+in-sample (1.30) è sotto quello della cella lf (2.11): sceglierlo = **selezione-sull'hold-out**
+(esattamente il falso positivo ERM del 2026-06-29). E comunque **DSR 0.518 < 0.95**: anche la
+lettura più caritatevole muore sulla deflazione multiple-testing.
+
+## Verdetto: SCARTATO (niente sleeve, niente forward-monitor cablato)
+
+1. La cella scelta onestamente è ADDS ma **robust_oos=False** (uplift a un mese) e **DSR 0.433**
+   su 104 trial: su ~8 mesi di in-sample (toro 2024) un IS di 2.1 è indistinguibile dal massimo
+   atteso per caso (1.10) e non regge.
+2. Il candidato migliore col senno di poi (TH-LS) sarebbe selezione-sull'hold-out e fallisce
+   comunque il DSR (0.518) — il gate `study_family_honest` fa esattamente il suo lavoro.
+3. Il limite è la **storia**: 2.2 anni totali, 8 mesi di in-sample. Non c'è modo onesto di
+   dimostrare l'edge oggi.
+
+**Cosa resta.** (a) La famiglia **breadth-thrust (TH)** è l'unico angolo con celle OOS-positive e
+bassa/negativa corr a TP01 — **rivisitabile quando il panel HL avrà ≥1-2 anni di storia nativa in
+più** (in-sample multi-regime, DSR ricalcolabile); nessun cablaggio forward oggi, il costo
+dell'attesa è zero. (b) Il breadth-**gate** su TP01 va in bacino con macro-gate e DVOL-gate: terza
+conferma che TP01 non ha bisogno di de-risk esterno (long-flat, già flat nei crash). (c) Il fix
+`_align` (epoch esplicita) è la lezione riusabile per ogni futuro panel esterno.

docs/diary/2026-07-01-book-live-error-surfacing.md

@@ -0,0 +1,58 @@
+# 2026-07-01 — Book live: verifica gate SKH01 + emersione errori silenziosi
+
+## Contesto
+Il BOOK DERIBIT armato (TP01 0.75 + SKH01 0.25 nettati) è **flat da quando è stato armato
+(2026-06-23)**: 193 run orari, tutte HOLD, zero ordini reali. Domanda: il flat è legittimo o il
+gate di SKH01 è muto per un bug?
+
+## Verifica del gate SKH01 — SANO
+- **Logica viva:** `skyhook_entries` produce 335 entry (BTC, 222 long/113 short) e 341 (ETH,
+  226/115) su tutta la storia. Non è degenere.
+- **Shorta davvero i crash:** ha aperto SHORT sulla gamba di crollo di fine maggio/inizio giugno —
+  BTC 05-28→06-04 ($73k→$64k), ETH 06-02→06-06 ($1865→$1555).
+- **Flat da 06-23 = legittimo:** ultimo entry 06-06, `max_bars=16 × 230m ≈ 2,5g` → chiuso ~06-08/09,
+  **prima** dell'arming (06-23). Dal grind post-crash nessun setup breakout+regime valido → flat
+  corretto per design ("NON trend-follower"). Contesto prezzo al 01-07: BTC −53% dal picco, ETH
+  −67,5%, momentum negativo su 1/3/6/12 mesi → anche TP01 (long-flat TSMOM) è a 0x.
+- **Entrambi i feed valutano senza crash:** certificato e live `fresh_5m` → `skh_error=None`.
+
+## Bug scoperto e corretto — pattern "eccezione ingoiata → stato safe silenzioso"
+`src/live/` aveva più `try/except` che, in errore, producono uno stato safe (flat/fallback) **senza
+farlo emergere**. Rischio: quando l'errore è transitorio ma reale, l'esecutore opera su dati sbagliati
+credendoli legittimi.
+
+### (1) `skh_error` — CORRETTO
+`book_report` scriveva `skh_error` in un dict locale **mai incluso nel return** → `r.get("skh_error")`
+sempre `None`; e `book_execute` non lo leggeva comunque. Un feed SKH rotto avrebbe forzato SKH→flat in
+silenzio (entry mancato, nessun alert). Fix: `skh_error` esposto nel return + `book_execute` emette
+log `⚠️ SKH FEED ERRORE` + alert Telegram. (commit 31369b3)
+
+### (2) Gate fail-safe posizione (Opzione A) — CORRETTO
+`src/live/shadow.py::_positions`: se la read della posizione reale Deribit lancia, assume flat (0.0)
+con una `note`, MAI propagata (`pos_src`) a `book_report`/`book_execute`. Severità mitigata a valle
+da `rebalance_signed` che **rilegge la posizione fresca** (no doppia-posizione), ma resta il caso
+"target≈0 + posizione aperta + read fallita → close saltato quel run" (transitorio, backstoppato dal
+disaster-SL −30%). **Scelta A = gate fail-safe:** `_positions` ritorna un `pos_error` esplicito →
+propagato `shadow_report → book_report → book_execute`; se presente (ONLINE ma posizione IGNOTA)
+l'esecutore **NON opera a cieco** (return + alert), come già fa per `online`.
+
+### (3) Diagnostica equity (Opzione B) — CORRETTO
+`src/live/shadow.py::_equity`: se `account_summary('USDC')` e tutte le per-asset falliscono,
+`real_eq=None` e `shadow_report` ripiega su `paper_cap` (~$2000 dallo state paper) mentre il conto
+reale è ~$598 → il book dimensionerebbe su $2000 invece di $598 (**sovradimensiona ~33%**). Il danno
+è limitato dall'**hard-cap $300/asset** in `book_net_target`. **Scelta B = SOLO DIAGNOSTICA** (niente
+gate/halt, l'hard-cap già protegge il downside): `shadow_report` calcola `eq_fallback` (ONLINE +
+equity reale non leggibile + no override), propagato `→ book_report → book_execute`, che stampa
+`⚠️ EQUITY FALLBACK` + alert Telegram **ma prosegue** (a differenza del gate posizione, che blocca).
+
+## Test
+Suite completa **156/156** (era 148; +4 gate A + 4 diagnostica B). Dry-run reale di `book_execute`
+invariato (nessuna riga d'errore, nessun ordine, conto $598.06 al target). Path live: `pos_error=None`,
+`skh_error=None`, `eq_fallback=None`.
+
+## Sintesi finale — i 3 pattern "errore silenzioso" del path live sono ora tutti tracciati
+| # | Punto | Comportamento | Emersione |
+|---|-------|---------------|-----------|
+| 1 | `book_report` feed SKH | SKH → flat | log `⚠️ SKH FEED ERRORE` + alert |
+| 2 | `_positions` read fallita | posizione → flat | **HALT** (non esegue) + alert (gate A) |
+| 3 | `_equity` non leggibile | sizing → paper_cap | log `⚠️ EQUITY FALLBACK` + alert (diagnostica B) |

docs/diary/2026-07-01-funding-ts-signal.md

@@ -0,0 +1,114 @@
+# 2026-07-01 — Funding rate come segnale TIME-SERIES direzionale su BTC/ETH (R0701): SCARTATO
+
+## Contesto
+
+Filone: il **funding orario Hyperliquid come proxy di POSIZIONAMENTO/sentiment** con valenza
+direzionale a orizzonte giornaliero su BTC/ETH — NON carry. Angolo diverso dal prior art già
+chiuso: **FC01** (carry cross-sectional delta-neutral 19 alt → LEAD fragile SCARTATO,
+`2026-06-22-funding-carry-hl.md`) e **funding price-clock** intraday (drift attorno agli stamp →
+FAIL, onda intraday). Qui l'ipotesi è: funding estremo = affollamento long → fade; funding in
+espansione = domanda persistente → follow; funding affollato = de-risk del trend (gate).
+Attrattiva a priori: 2 gambe BTC/ETH perp = **eseguibile al capitale reale ~$600** (non STAT-MODE
+come XS01/opzioni) — se avesse retto sarebbe stato deployabile.
+
+Script: `scripts/research/r0701_funding_ts.py`.
+
+## Dati e causalità (data-first)
+
+- `data/raw/hlfund_{btc,eth}_1h.parquet`: **2023-05-12 → 2026-06-22, 1138/1138 giorni validi,
+  0 gap** dopo il 2023-06 (primi ~27 giorni a cadenza 8h — la somma giornaliera degli stamp li
+  gestisce indifferentemente). Funding medio **+14.4%/anno BTC, +14.6% ETH**; std del funding
+  giornaliero ~5.5 bps.
+- **Join causale** (il punto delicato): le barre 1d di `altlib.get` sono **open-labeled**
+  (datetime = 00:00 UTC del giorno D; il close della barra D è noto alle 00:00 di D+1). Il
+  feature-day D aggrega i SOLI stamp in **[D 00:00, D+24h)** — l'ultimo alle 23:00 — quindi tutto
+  è noto PRIMA della decisione al close della barra D; `eval_weights` shifta la posizione al
+  giorno D+1. Prefix-consistency check esplicito: **max diff 0.0** (nessun leak).
+- **Valutazione su finestra TRONCATA** alla copertura funding, non sul frame prezzi 2018+: fuori
+  copertura il target sarebbe zero per costruzione e i giorni-zero (a) **gonfiano il T del
+  deflated-Sharpe** (anti-conservativo) e (b) diluiscono `cand_insample_sharpe` (il gate
+  `has_insample_edge` scatterebbe a vuoto). La logica di `study_family_honest` è replicata
+  ESATTAMENTE sui frame troncati coi primitivi altlib (selezione IN-SAMPLE-ONLY → gates
+  study_marginal → DSR sull'intera griglia). Cross-check `study_marginal` non-troncato in coda:
+  stessi verdetti (abs WEAK / marginal NEUTRAL / earns_slot False).
+- ⚠️ **STORIA CORTA**: ~3.1 anni totali → in-sample pre-HOLDOUT ~1.6a (meno warmup z), hold-out
+  2025+ ~1.5a. Dichiarato: nessun numero qui ha il peso statistico di TP01 (7 anni).
+
+## Metodo
+
+Famiglia a griglia modesta, 1d, 50/50 BTC+ETH, vol-target 20% cap 2x (convenzione TP01), fee
+0.10% RT + sweep 0.00-0.30%:
+
+- **FADE**: z-score(funding daily, lb) ≥ thr → short; ≤ −thr → long (fade dell'affollamento).
+- **FOLLOW**: z ≥ thr → long; ≤ −thr → short (sentiment momentum).
+- **GATE**: trend long-flat TP01-like (sgn mom 30d+90d) ma FLAT quando z ≥ thr (de-risk crowding).
+- **DIVERGE**: momentum prezzo 20d seguito se funding NON affollato (z ≤ −thr), fatto se z ≥ thr.
+
+Griglia: 4 forme × lb {7,14,30,60}g × thr {0.5,1.0,1.5} = **48 celle**. Selezione cella
+**in-sample-only** (mai sul hold-out), deflated-Sharpe su tutte le 48, gates marginali
+(`marginal_vs_tp01`), boundary-shift della finestra di aggregazione funding (−0/3/6/9/12h),
+`eval_weights_smallcap` a $600.
+
+## Risultati
+
+Best in-sample per forma: **fade 0.34, follow 0.81, gate 1.76, diverge −0.34** — il segnale
+puro-funding è debole ovunque; solo la forma che CONTIENE il trend ha Sharpe.
+
+**Cella scelta (in-sample): GATE lb=60 thr=1.5** — IS 1.76, FULL 1.16, HOLD 0.29.
+
+| Gate | Esito |
+|---|---|
+| Deflated-Sharpe (48 celle) | **0.215** (null-max atteso 1.59) → **FAIL** (soglia 0.95) |
+| Assoluto (frame troncati) | **WEAK** (minFull +0.97, ma minHold **+0.04** BTC); fee-survive fino a 0.30% RT |
+| Marginale vs TP01 | **NEUTRAL**: corr **0.879** (hold 0.92), beta 0.77; uplift w25 hold **+0.001**; robust_oos=False (jackknife −0.074); multicut 2026 **−0.423** |
+| earns_slot / earns_slot_honest | **False / False** |
+| Realism | prefix-diff 0.0 (causale); boundary-shift sign-stable (uplift spread 0.047); smallcap $600 haircut ~0.00 (eseguibile, irrilevante senza edge) |
+
+**Controllo decisivo (lezione TP01-DVOL-overlay)** — lo stesso trend long-flat SENZA gate funding:
+
+```
+trend NUDO :  IS 1.65   FULL 1.14   HOLD 0.37
+trend+GATE :  IS 1.76   FULL 1.16   HOLD 0.29     corr(gated,nudo)=0.928
+delta del gate funding: FULL +0.013, HOLD −0.080
+```
+
+→ **tutto lo Sharpe della "vincitrice" è il trend**; il contributo del funding è ~zero in-sample
+e **negativo sul hold-out**. Il gate è TP01 travestito.
+
+**Miglior cella puro-funding** (la vera tesi del filone): FOLLOW lb=60 thr=0.5 — IS 0.81 ma
+**FULL −0.28, HOLD −1.69**, marginale **DILUTES** (uplift w25 hold −0.778). L'in-sample 0.81 era
+"long-il-toro-2023/24" travestito: z-alto di funding = rally già in corso; nel 2025-26 la stessa
+regola è sistematicamente dalla parte sbagliata. FADE (shortare il crowding) perde sul toro e non
+recupera abbastanza nel chop; DIVERGE negativa ovunque. NB: esistono celle gate con HOLD migliore
+(es. gate 7/1.5 HOLD 0.96) — sceglierle sarebbe **selection-on-holdout**, il gate del 2026-06-29
+esiste esattamente per questo.
+
+## Perché fallisce (meccanismo)
+
+1. Su asset MAJOR il funding è **quasi sempre positivo e segue il prezzo con lag**: lo z-score
+   alto coincide col momentum già espresso → FOLLOW è trend-beta ritardato (muore quando il regime
+   gira), FADE è shortare il toro. Non c'è l'anti-persistenza ("crowding → reversal") che la tesi
+   richiede — a 1d, su BTC/ETH, le liquidazioni-da-crowding sono già nel prezzo prima che lo
+   z-score giornaliero diventi estremo.
+2. L'unico uso "funzionante" (gate di de-risk sul trend) è **ridondante**: TP01-like è già flat
+   quando serve. Stesso verdetto di macro-regime-gate (corr 0.989) e DVOL-overlay: la famiglia
+   "overlay prudenziale su TSMOM" è esaurita — eredita lo Sharpe del trend e non aggiunge nulla.
+
+## Verdetto
+
+**SCARTATO.** `earns_slot=False`, `earns_slot_honest=False` (DSR 0.215). Il funding time-series
+non ha informazione direzionale propria su BTC/ETH a 1d; l'unica cella con Sharpe è trend
+travestito con contributo funding OOS negativo. Niente forward-monitor: non c'è una componente
+funding da monitorare. Con FC01 (carry cross-sectional) e il price-clock intraday, il filone
+"funding come segnale" su dati certi è ora **chiuso su tre lati**.
+
+## Lascito
+
+- `scripts/research/r0701_funding_ts.py` riusabile: (a) loader funding→daily **causale** per barre
+  open-labeled (finestra [D, D+24h), gestione cadenza mista 8h/1h, flag validità copertura);
+  (b) pattern "**truncation-honest**" per dataset a copertura parziale — replica di
+  `study_family_honest` su finestra troncata per non gonfiare il T del DSR né diluire
+  `has_insample_edge` con anni di zeri (riusabile per ogni serie corta tipo DVOL/HL).
+- I parquet `hlfund_*` restano certificati. Se mai si tornasse sul funding: gli estremi VERI
+  (squeeze) vivono sugli alt, ma è di nuovo cross-sectional → STAT-MODE a $600, soglia di prova
+  alta (e FC01 ha già mostrato la fragilità d'universo).

docs/diary/2026-07-01-portfolio-weights-ddguard.md

@@ -0,0 +1,174 @@
+# 2026-07-01 — Pesi statici ri-ottimizzati + guardia-DD sul portafoglio a 4 sleeve
+
+## Mandato
+Migliorare il portafoglio ATTIVO (TP01 41.25 / XS01 18.75 / VRP01 15 / SKH01 25) SENZA nuove
+strategie: (A) ri-ottimizzazione onesta dei pesi statici, (B) guardia-drawdown a livello
+portafoglio (replica del soft-guard vincente del tail-hedge lab 2026-06-23), (C) combinazione.
+NON meta-allocazione dinamica (già scartata, thread 3 del 2026-06-29).
+Script: `scripts/research/r0701_portfolio_opt.py`. Solo ricerca: nessun file di src/ o live toccato,
+i pesi sono PROPOSTI, non applicati.
+
+## Baseline riprodotta
+`run_portfolio.py` oggi: **FULL Sh 2.12 / HOLD 2.21 / DD full 7.8% / CAGR 23.3%** (vs 2.13/2.30
+del diario Skyhook: i dati sono avanzati di una settimana, coerente). Matrice sleeve outer-join
+2019-03-14 → 2026-07-01 (TP01/SKH01 dal 2019, VRP01 dal 2021-05, XS01 dal 2024-01), combine
+identico a `portfolio.combined_daily` (pesi rinormalizzati per-riga sugli sleeve attivi).
+
+## (A) Pesi statici — metodo
+- Ottimizzazione SOLO in-sample (pre-cut), valutazione OOS (post-cut), multi-cut
+  {2024-01, 2024-07, 2025-01}. Sleeve con <120 giorni in-sample al cut (XS01 al 2024-01)
+  PINNED al peso corrente (l'ottimizzatore non ha dati per giudicarli).
+- Criteri: MAXSH (max-Sharpe del combo simulato), RP (inverse-vol), ERC, MINVAR-R (min-var con
+  vincolo ritorno ≥ pesi correnti). Null: EW (25×4) e CURRENT. Vincoli 5%≤w≤60%, Σ=1.
+- **Cap STRUTTURALI dichiarati** (prudenza, non statistica): **VRP01 ≤ 15%** (sleeve MODELLATO su
+  DVOL ATM, stress-f non catturato — "niente short-vol da modello in deploy"), **XS01 ≤ 25%**
+  (STAT-MODE, storia ~2.5 anni). Varianti sotto cap: MAXSH-STR (ottimizzato) e EW-STR
+  (EW proiettato sui cap, parameter-free → TP 30 / XS 25 / VRP 15 / SKH 30).
+
+### Risultati (pesi ottimizzati pre-2025, valutati FULL e HOLD-OUT 2025-26)
+| criterio | pesi TP/XS/VRP/SKH | FULL Sh | FULL DD | FULL CAGR | HOLD Sh | HOLD DD | HOLD CAGR | multi-cut ΔSh OOS | anni vinti |
+|---|---|---|---|---|---|---|---|---|---|
+| CURRENT | 41.2/18.8/15/25 | 2.12 | 7.8% | +23.3% | 2.21 | 3.5% | +16.0% | — | — |
+| MAXSH | 27.6/17.5/**39.5**/15.4 | 2.17 | 6.3% | +21.8% | 2.27 | 2.8% | +12.7% | +0.24/+0.08/+0.06 | **1/8** |
+| RP-invvol | 26.7/15.5/**41.6**/16.3 | 2.17 | 6.4% | +21.8% | 2.25 | 2.8% | +12.4% | +0.28/+0.07/+0.04 | — |
+| ERC | 26.6/16.2/**41.6**/15.7 | 2.17 | 6.3% | +21.7% | 2.25 | 2.8% | +12.4% | +0.29/+0.07/+0.05 | — |
+| MINVAR-R | 26.7/23.3/**29.6**/20.4 | 2.18 | 6.4% | +23.3% | 2.37 | 2.6% | +16.1% | +0.20/+0.10/+0.16 | 4/8 |
+| MAXSH-STR | 38.6/25/15/21.4 | 2.14 | 7.5% | +23.4% | 2.28 | 3.3% | +16.8% | **−0.00**/+0.03/+0.07 | 3/8 |
+| EW | 25/25/25/25 | 2.14 | 7.0% | +24.5% | 2.39 | 2.8% | +18.1% | +0.16/+0.17/+0.18 | 6/8 |
+| **EW-STR** | **30/25/15/30** | 2.10 | 8.5% | +25.2% | **2.35** | 3.2% | **+19.7%** | **+0.06/+0.13/+0.14** | **7/8** |
+
+### Lettura onesta
+1. **Gli OTTIMIZZATORI non aggiungono nulla — anzi overfittano.** Tutti (MAXSH/RP/ERC/MINVAR-R)
+   convergono sulla stessa mossa: scaricare TP01 e caricare **VRP01 al 30-42%** perché ha la vol
+   più bassa (7.7%/anno). Ma quella è la vol del MODELLO (premio BS su DVOL, coda di stress non
+   catturata): è esattamente il punto cieco tipo-CC01 ("Sharpe/vol implausibile → rischio
+   nascosto"). E per-anno MAXSH vince **1/8 anni** vs CURRENT — l'uplift multi-cut è smoothing di
+   vol modellata, non alpha di allocazione. **Dentro i cap** l'ottimizzatore (MAXSH-STR) converge
+   quasi sui pesi correnti (38.6/25/15/21.4) e NON è persistente (−0.00 al cut 2024-01) →
+   **i pesi correnti sono già ~ottimi per ciò che il backtest può giudicare lecitamente**.
+2. **L'unico segnale robusto è la DE-CONCENTRAZIONE parameter-free**: EW-STR (EW sotto i cap,
+   nessun parametro fittato) vince **7/8 anni** (unica perdita 2021 −3.1pp), tutti i cut OOS
+   (ΔSh +0.06/+0.13/+0.14), HOLD Sh 2.21→2.35, HOLD CAGR +16.0→+19.7%. Classico "1/N batte
+   l'ottimizzazione" (DeMiguel). La sostanza: CURRENT dà il 41% al peggior Sharpe FULL del book
+   (TP01 1.30) e EW-STR sposta ~11pp da TP01 verso SKH01 (+5pp) e XS01 (+6.25pp).
+3. **MA non è un free lunch risk-adjusted**: FULL Sh 2.12→**2.10** e FULL DD 7.8→**8.5%**
+   (più SKH01, che ha DD standalone 18%, pesa di più nei primi anni a 2 sleeve). L'uplift è un
+   TILT di ritorno verso gli sleeve research-grade con la storia più corta/caveat più pesanti
+   (SKH01 = research win, book 230m da verificare a deploy; XS01 = STAT-MODE non eseguibile a 2k).
+   E TP01 resta l'unico sleeve *deployed* live: il suo 41% nel report riflette una scelta di
+   prudenza/eseguibilità, non solo statistica.
+
+### VERDETTO (A)
+- **Ottimizzazione formale: NON MIGLIORA** (viola i cap strutturali o converge ai pesi correnti).
+  **Per il book reale i pesi correnti reggono.**
+- **Candidato PROPOSTO (non applicato): EW-STR = TP01 30 / XS01 25 / VRP01 15 / SKH01 30** —
+  uplift OOS persistente e per-anno (7/8), dentro i cap, al costo di FULL DD +0.7pp e FULL Sh
+  −0.02. È una decisione di risk-appetite (più ritorno atteso spostando peso su sleeve
+  research-grade), non un miglioramento dominante. Se si vuole adottare, farlo consapevoli che
+  aumenta la dipendenza da SKH01/XS01, e NON tocca il book Deribit eseguibile (TP75/SKH25).
+
+### Caveat metodologici (A)
+- Le 3 finestre multi-cut sono ANNIDATE (tutte contengono il 2025-26): non 3 conferme
+  indipendenti. Il test disgiunto vero è il per-anno (7/8 per EW-STR è il dato forte).
+- EW-STR è stato costruito DOPO aver visto EW vincere (proiezione del null sui cap dichiarati):
+  costruzione principled e parameter-free, ma va detto — non era nella griglia iniziale.
+- I pesi CURRENT stessi furono fissati (2026-06-23) conoscendo l'hold-out → il confronto
+  "in-sample-opt vs CURRENT su hold-out" è semmai sbilanciato A FAVORE di CURRENT; EW-STR vince
+  comunque.
+
+## (B) Guardia-drawdown a livello portafoglio — metodo
+Soft-guard causale sul combo 4-sleeve (pesi CURRENT): esposizione del giorno D decisa dal DD
+dell'equity fino a **D−1**; trigger/re-entry sul **NAV ombra** non-guardato (lezione stops_lab:
+sull'equity congelata a expo=0 il DD non rientra mai); isteresi re-risk a 0.4·X come nel
+tail-hedge lab. Griglia X∈{3,4,5,6}%, derisk∈{0,0.5}. Selezione cella IN-SAMPLE (max Calmar
+pre-2025), verifica hold-out + multi-cut, **null de-levering** (expo costante c che pareggia il
+MaxDD in-sample della guardia: Sharpe di c·r è invariante → la guardia vale solo se batte quello).
+
+### Risultati
+- Cella scelta in-sample: **X=5% / derisk=0.5** (IS Calmar 3.64 vs 3.24 baseline; IS DD 7.8→6.6%,
+  IS CAGR 25.3→23.9%, IS Sh 2.13→2.12). In-sample batte il null de-levering c=0.84 a pari DD
+  (CAGR 23.9% vs 21.0%) — il timing esiste in-sample.
+- **MA OOS è INERTE**: a ogni cut la cella scelta non scatta MAI (ΔSh +0.00, ΔDD 0.0pp, ΔCAGR
+  0.0pp su tutti e 3 i cut) perché il DD OOS del 4-sleeve resta 3.5-4.8% < trigger 5%.
+  **La diversificazione a 4 sleeve fa già il lavoro della guardia** (il 2022 del book è +11.6%
+  con DD 3.6%: non c'è il grind da proteggere che aveva il combo TP01+GTAA del tail-hedge lab,
+  DD 8.4% / 2022 −4.4%).
+- Trigger più stretti che scattano davvero COSTANO: X=3%/d=0.5 → HOLD Sh 2.10 (< 2.21), CAGR
+  13.7% (< 16.0%); X=3-4%/d=0 whipsaw pieno (HOLD Sh 1.83-2.09; a X=4/d=0 il DD guardato IS
+  sale addirittura a 8.8% > 7.8% baseline — accumulo di perdite su cicli off/on, lo stesso
+  fenomeno visto in stops_lab con l'uscita totale).
+
+### VERDETTO (B)
+**NON MIGLIORA.** La guardia-DD che vinceva sul combo TP01+GTAA (DD 8.4%, 2022 −4.4%) qui non ha
+bersaglio: il 4-sleeve ha già DD ~3.5-4.8% OOS. Coerente col thread meta-allocazione 2026-06-29
+(drawdown-control ridondante). Nota operativa: la cella X=5%/d=0.5 è *innocua* (non fa nulla
+finché il DD non supera il 5%) e in-sample mostrava timing genuino sopra il null de-levering —
+può valere come **circuit-breaker di emergenza sul live** (risk management, non alpha), ma non è
+un miglioramento statistico e non la si adotta come tale.
+
+## (C) Combinazione
+(B) è inerte → niente da combinare. Per completezza: EW-STR + guard X=5%/d=0.5 → FULL Sh 2.08,
+DD 6.7%, CAGR 23.7% | HOLD invariato 2.35/3.2%/19.7% (la guardia lima il DD 2021-2023 del tilt
+a costo di −0.02 Sh FULL). Nessuna adozione proposta.
+
+## Sintesi
+| config | FULL Sh | FULL DD | FULL CAGR | HOLD Sh | HOLD DD | HOLD CAGR |
+|---|---|---|---|---|---|---|
+| **CURRENT (attivo)** | 2.12 | 7.8% | +23.3% | 2.21 | 3.5% | +16.0% |
+| EW-STR (proposta A, non applicata) | 2.10 | 8.5% | +25.2% | 2.35 | 3.2% | +19.7% |
+| CURRENT + guard 5%/0.5 (B) | 2.11 | 6.6% | +22.3% | 2.21 | 3.5% | +16.0% |
+| EW-STR + guard (C) | 2.08 | 6.7% | +23.7% | 2.35 | 3.2% | +19.7% |
+
+- **(A) NON MIGLIORA in senso forte** — i pesi correnti reggono; l'unico candidato onesto è il
+  tilt de-concentrante EW-STR (30/25/15/30), un trade-off di risk-appetite da decidere, non un
+  upgrade dominante. Gli ottimizzatori in-sample o violano i cap strutturali (VRP01 40%) o
+  riconvergono sui pesi correnti.
+- **(B) NON MIGLIORA** — guardia inerte OOS sul 4-sleeve; utile al più come circuit-breaker.
+- Nessuna modifica a `src/portfolio/sleeves.py` o al live. Test 160/160 verdi.
+
+Script: `scripts/research/r0701_portfolio_opt.py` (~4s, vettoriale).
+
+## Verifica avversariale (agente scettico)
+
+Script: `scripts/research/r0701_portfolio_skeptic.py`. **VERDETTO: NON APPLICARE — CURRENT resta.**
+I numeri dell'agente riproducono ESATTAMENTE (via `StrategyPortfolio.combined_daily`, path di
+produzione: CURRENT 2.12/2.21, EW-STR 2.10/2.35, multi-cut +0.06/+0.13/+0.14, |diff|=0). Il claim
+muore altrove: l'uplift è **selezione-sull'hold-out di 2° ordine**, non alpha di allocazione.
+
+1. **L'uplift OOS vive TUTTO nel 2025-26 — la finestra che ha selezionato i beneficiari.**
+   Finestre OOS **DISGIUNTE** (i 3 cut del diario sono annidati): ΔSh EW-STR vs CURRENT =
+   **−0.12** (2024H1) / +0.06 (2024H2) / **+0.14** (2025+). L'unica finestra OOS non toccata
+   dalla selezione hold-out è negativa. Sharpe standalone IS→HOLD per sleeve: TP01 1.49→**0.30**,
+   SKH01 1.42→**1.64**, XS01 1.22→**1.51**: EW-STR compra esattamente i due sleeve ammessi/affinati
+   (2026-06-23 / 2026-06-19) PERCHÉ forti sull'hold-out e vende quello che lì collassa. Meccanico.
+2. **Pre-2025 (finestra non contaminata) EW-STR PERDE risk-adjusted**: ΔSh aggregato **−0.05**,
+   Sharpe per-anno vinti **2/6** (2021 −0.29, 2020 −0.10, 2023/2024 negativi).
+3. **"7/8 anni vinti" è un artefatto di metrica**: è RITORNO composto (un tilt a più vol/ritorno
+   li vince quasi per costruzione), non risk-adjusted. Su **Sharpe per-anno: 3/8**. E due dei 7
+   "vinti" (2023, 2024) hanno margine **+0.03pp** = tie. Bilancio materiale sul ritorno:
+   5 vinti / 1 perso (2021 −3.1pp) / 2 pari.
+4. **Plateau: liscio ma il gradiente è solo "meno TP01"**; a TP fisso, alzare SKH 25→30 è
+   piatto/negativo (min multi-cut a TP35: +0.07→+0.02). Scomposizione: il tilt **solo-SKH**
+   (+5pp, TP 36.25) da solo NON è persistente (multi-cut **−0.00**/+0.05/+0.04); il tilt
+   **solo-XS** (TP35/XS25/VRP15/SKH25) è l'unico positivo su tutte le finestre disgiunte
+   (+0.05/+0.02/+0.11) — ma pre-2025 fa ΔSh −0.00 (edge ≈ zero fuori dal 2025-26) e carica lo
+   sleeve MENO eseguibile (STAT-MODE).
+5. **Realismo**: con l'outer-join rinormalizzato EW-STR tiene SKH01 al **50% effettivo nel
+   2019-20 e 40% nel 2021-23** (book research 230m a metà portafoglio: da lì il FULL DD 8.5%).
+   Punto onesto A FAVORE: un haircut d'esecuzione a drag su SKH01(-20/30%) e SKH+XS non ribalta
+   il ranking hold-out (ΔSh resta +0.08..+0.13), ma i livelli assoluti crollano (HOLD Sh CURRENT
+   2.21→1.64 al −30% su entrambi) e il beneficio resta di CARTA: il book Deribit eseguibile
+   (TP75/SKH25) non è toccato dalla decisione.
+6. **Forking paths quantificato**: ≥15 config valutate sull'hold-out (7 vettori pesi + 8 celle
+   guardia), EW-STR costruito dopo aver visto EW vincere. Su **500 tilt CASUALI cap-respecting**:
+   51% batte CURRENT sull'hold-out (mediana ΔSh +0.00), solo 11% sul FULL, 30% su tutti e 3 i cut.
+   EW-STR è al **94° percentile** dell'uplift hold-out fra i tilt casuali ≈ il **massimo atteso di
+   ~15 tentativi** (k/(k+1)=93.8%): l'uplift osservato è indistinguibile dal "best of 15 tilt
+   casuali scelto sull'hold-out".
+
+**Conclusione**: il tilt non è disonesto nei conti ma non è evidenza — è la stessa lezione del gate
+SELECTION-ON-HOLDOUT applicata al livello dei PESI (2° ordine: gli sleeve stessi sono stati
+selezionati su quell'hold-out). Unica direzione sopravvissuta: XS01 18.75→25 (solo-XS, positivo su
+tutte le finestre disgiunte), MA edge ≈0 fuori dal 2025-26, sleeve STAT-MODE non eseguibile a $600,
+e l'hold-out-strength di XS01 è a sua volta concentrata dal gate di dispersione nel regime 2025-26
+→ da rivalutare SOLO con più storia forward, non ora. **CURRENT (41.25/18.75/15/25) resta.**

docs/diary/2026-07-01-strategy-wave-6threads.md

@@ -0,0 +1,132 @@
+# 2026-07-01 — Ondata multi-agente a 6 filoni: 0 nuovi sleeve, pesi CURRENT confermati, 1 gate nuovo
+
+**Goal utente:** "cerca con diversi agenti altre strategie di trading. Prova di tutto e arriva a
+migliorare il portfolio presente. Lo scopo è sempre 50 euro days."
+
+**Esito in una riga:** 6 filoni nuovi (scelti dopo scan dei ~65 diari per non ripetere strade morte)
++ 1 verifica avversariale → nessun candidato supera i gate onesti; il portafoglio a 4 sleeve
+(41.25/18.75/15/25) **sopravvive a un attacco serio**, che è l'esito corretto per un book onesto.
+Miglioramento concreto dell'ondata = metodologico: **gate `weights_tilt_null`** codificato (sotto).
+
+## I 6 filoni (tutti su harness onesto: study_family_honest, marginal scorer, DSR≥0.95, smallcap $600)
+
+| # | filone | verdetto | perché muore |
+|---|---|---|---|
+| 1 | **Funding time-series** BTC/ETH (posizionamento, non carry) — `r0701_funding_ts.py` | SCARTATO | FOLLOW = trend-beta ritardato (HOLD −1.69), FADE = shortare il toro; la cella gate è TP01 travestito (controllo senza funding = stessi numeri, corr 0.93, ΔHOLD −0.08); DSR 0.215. **Filone funding chiuso su 3 lati** (FC01 carry, price-clock, TS-signal). |
+| 2 | **Breadth/internals alt** (51 HL) → BTC/ETH — `r0701_breadth_internals.py` | SCARTATO (rivisitabile) | Unico non-ridondante col trend (corr→TP01 0.40, lavora dove TP01 è attivo), assoluto PASS, marginal ADDS — ma jackknife −0.068 (uplift su UN mese) e DSR 0.433/104 celle. Con ~8 mesi di IS il 2024-toro non basta. **Rivisitare tra 1-2 anni di storia HL nativa.** |
+| 3 | **Residual momentum XS** (β-hedged vs BTC, 19 major) — `r0701_xs_residmom.py` | REDUNDANT | Cross-section la residualizzazione è quasi un no-op (lo z-score di XS01 già rimuove il mercato): corr→XS01 0.54, HOLD −0.24, corr(IS,HOLD) tra le celle **−0.37** (anti-predittivo = rumore). L'edge residuo-momentum vive nella coppia ETH/BTC (STATARB-RESID, resta in `paper_statarb`), non generalizza. |
+| 4 | **Pesi + guardia-DD** — `r0701_portfolio_opt.py` | vedi sotto | Unico candidato dell'ondata (EW-STR) → refutato dallo scettico. Guardia-DD X5%/d0.5: in-sample batte perfino il null de-levering, ma **OOS non scatta mai** (DD book 3.5-4.8% < trigger): la diversificazione fa già il lavoro. Utilizzabile solo come circuit-breaker di emergenza (risk mgmt, non alpha). |
+| 5 | **Affinamento VRP01** (sizing IV−RV, DVOL-mom, gate TP01) — `r0701_vrp_refine.py` | NON MIGLIORA | L'alpha è già tutto nel gate binario IV-rank; il gate TP01 è la trappola IS perfetta (schiva il 2022, ma taglia le settimane migliori dell'hold-out: multi-cut 0/5). **3° fallimento del filone "affinare VRP dentro il modello" → esaurito** finché cerbero-bite non cattura un crash reale (f di stress). |
+| 6 | **Stagionalità cross-sectional** HL — `r0701_xs_seasonal.py` | SCARTATO (allo step statistico) | Nessuna persistenza split-half sopra il null permutato max-statistic (p 0.16-0.23); l'unica struttura è il canale-beta dell'effetto weekday di mercato (famiglia trackF, già morta). Turnover ~2×gross/die = fee-death comunque. |
+
+## EW-STR: il candidato refutato (caso di scuola di selezione-sull'hold-out di 2° ORDINE)
+
+Il filone 4 proponeva **EW-STR** (TP01 30 / XS01 25 / VRP01 15 / SKH01 30 = equal-weight proiettato
+sui cap strutturali): HOLD Sh 2.21→2.35, multi-cut +0.06/+0.13/+0.14, "7/8 anni vinti" — dichiarando
+onestamente i caveat. La verifica avversariale (`r0701_portfolio_skeptic.py`, addendum nel diario
+pesi) lo uccide:
+
+1. **Selezione di 2° ordine**: SKH01 fu ammesso (2026-06-23) *perché* alzava l'hold-out 2025-26;
+   XS01 fu affinato conoscendo l'hold-out. EW-STR vende lo sleeve che collassa OOS (TP01 IS 1.49→
+   HOLD 0.30) e compra i due selezionati su quell'OOS. Pre-2025: **ΔSh −0.05** (perde risk-adjusted).
+2. **Su finestre OOS disgiunte**: −0.12 (2024H1) / +0.06 (2024H2) / +0.14 (2025+) — tutto l'uplift
+   vive nella finestra che ha selezionato gli sleeve. "7/8 anni" era sul ritorno composto; su
+   Sharpe è 3/8.
+3. **Firma best-of-k**: su 500 tilt casuali cap-respecting, EW-STR siede al 94-100° percentile ≈
+   k/(k+1) con k≈15 config viste sull'hold-out → uplift indistinguibile dal *best-of-15 scelto
+   sull'hold-out*.
+4. **Realismo**: in pesi effettivi (outer-join rinormalizzato) EW-STR = SKH01 al 40-50% del book
+   2019-23 (sleeve research a book 230m). Il book Deribit eseguibile (TP+SKH) non cambierebbe comunque.
+
+Residuo onesto: il sub-tilt XS01 18.75→25 è positivo su tutte le finestre disgiunte ma edge≈0
+pre-2025 e STAT-MODE → rivalutare solo con storia forward.
+
+## GATE NUOVO codificato: `weights_tilt_null` (src/portfolio/portfolio.py)
+
+La lezione è ora codice, come per marginal-scorer e study_family_honest:
+- **`combine_outer(daily_cols, weights, lo, hi)`** — la combinazione outer-join/rinormalizzata di
+  `combined_daily` estratta come funzione su pesi arbitrari (riusabile per studi di tilt).
+- **`weights_tilt_null(daily_cols, w_current, w_proposed, caps, floor, n, seed, k_seen)`** —
+  null di tilt casuali uniformi sul simplesso dentro floor/caps: riporta `delta_hold/full/insample`,
+  `frac_random_beat_hold`, `pctl_hold`, `bestofk_pctl=k/(k+1)` e `gate_pass`.
+  **Regola: un cambio-pesi si applica solo se (1) delta_insample ≥ 0 e (2) pctl_hold < firma
+  best-of-k** (necessario, non sufficiente: restano finestre disgiunte + realismo).
+  Sul caso reale EW-STR: delta_hold +0.139, delta_insample **−0.054**, pctl **100°** vs best-of-15
+  93.75° → `gate_pass=False`. Test: `tests/test_weights_tilt_null.py` (5 test, sintetici,
+  deterministici; incluso lo sleeve "forte-solo-nell'hold-out" che DEVE fallire il gate).
+
+## Lezione tecnica riusabile (dal filone 2)
+
+`DatetimeIndex.view("int64")` su indici **tz-aware a risoluzione non-ns** (pandas 2.x) produce
+timestamp in scala sbagliata → un `merge_asof` può broadcastare l'ultimo valore su tutta la storia
+= **look-ahead che `causality_ok` non vede** (input fisso). Sintomo: decine di celle con Sharpe
+identico. Fix: epoca esplicita in ms. Verificato: `altlib.py` non è affetto (grep pulito); dettagli
+nel diario breadth.
+
+## Onestà sul goal €50/giorno
+
+Invariata (vedi CLAUDE.md): a capitale reale ~$600 il book onesto fa ~+€1.5/giorno atteso; la via
+resta capitale + tempo + target-vol, non un tilt di pesi né leva. Questa ondata conferma che il
+book attuale è vicino al massimo estraibile dai dati certificati disponibili oggi; le opzioni
+reali di crescita restano (a) storia forward che promuova i lead (STATARB-RESID, breadth tra 1-2
+anni), (b) capitale, (c) nuove fonti di dato (f di stress reale per VRP).
+
+**File dell'ondata:** `scripts/research/r0701_{funding_ts,breadth_internals,xs_residmom,portfolio_opt,portfolio_skeptic,vrp_refine,xs_seasonal}.py`; diari `2026-07-01-{funding-ts-signal,alt-breadth-internals,xs-residual-momentum,portfolio-weights-ddguard,vrp-refinement,xs-seasonality}.md`; gate in `src/portfolio/portfolio.py` + `tests/test_weights_tilt_null.py`.
+
+## ADDENDUM (stessa sera) — GTAA01 promosso a 5° SLEEVE: il miglioramento c'era, ma era in casa
+
+Il secondo passaggio sull'archivio (non sui dati!) ha trovato il candidato che l'ondata di *ricerca*
+non poteva trovare: **EQ-GTAA01** (`src/portfolio/gtaa.py` — trend difensivo equity 6-ETF, vt12%,
+~30 anni di storia, netto fee IB) era stato validato il 2026-06-22 come *"primo miglioramento
+STRUTTURALE del rischio-aggiustato trovato in tutta la ricerca post-reset"*, messo in paper
+cross-venue (`paper_combo`, nel cron dal 2026-06-23) e **mai valutato come 5° sleeve del
+portafoglio attivo** (il giorno dopo arrivò SKH01 e il filone si fermò).
+
+### Valutazione onesta (`r0701_gtaa_5th_sleeve.py`) — perché GTAA passa dove EW-STR è morto
+
+| gate | EW-STR (refutato) | +GTAA01 (passa) |
+|---|---|---|
+| uplift IN-SAMPLE (pre-2025) | **−0.05** | **+0.09..+0.13** (2.134→2.23-2.26) |
+| finestre OOS disgiunte | −0.12 / +0.06 / +0.14 | **+0.05 / +0.19 / +0.25** (tutte >0) |
+| multi-cut (4 tagli) | solo annidate | **+0.21 / +0.21 / +0.22 / +0.25** |
+| provenienza dell'edge | sleeve selezionati sull'hold-out crypto | validato su OOS equity 2015+, **indipendente** dall'hold-out crypto |
+| corr al book | — | **+0.10** full, ~0.00 hold-out; is_hedge +0.30 (non-hedge) |
+| plateau | gradiente generico anti-TP01 | **monotono su w 10-30%, ogni cella migliora IS/FULL/HOLD/DD** |
+
+Convenzione di realismo cross-venue (nuova, cablata nello sleeve): nei giorni senza barra equity
+(weekend/festivi US) il rendimento è **0.0** — capitale IB fermo, NON rinormalizzato sul crypto
+(due conti reali non si travasano nel weekend). Numeri quasi identici alla versione outer-join
+(differenze al 3° decimale) ma il modello è quello giusto. Attivazione nel book all'era crypto
+(2019-03-14): senza troncatura l'outer-join farebbe partire il book nel 1996 con 23 anni di
+solo-GTAA rinormalizzato al 100%.
+
+### Decisione pesi
+Cella IS-best = w=30% (bordo griglia), **ingresso @20%** per scelta strutturale dichiarata:
+(a) cross-venue IB con paper operativo di soli 8 giorni — non diventa lo sleeve più grande del
+book al day-one; (b) precedente: ogni sleeve nuovo è entrato ≤25% (SKH01 25%, VRP01 15%);
+(c) costo CAGR (a 30%: 16.8% vs 18.8% a 20%) — e l'obiettivo €50/g vive di CAGR, non solo di
+Sharpe. Tutte le celle 10-30% passano comunque ogni gate. Pesi nuovi: **TP01 33 / XS01 15 /
+VRP01 12 / SKH01 20 / GTAA01 20** (i 4 preesistenti scalati ×0.80, rapporti conservati).
+
+### Portafoglio 5-sleeve (run_portfolio, capitale 2k)
+| | FULL Sh | FULL DD | FULL CAGR | HOLD Sh | HOLD DD | HOLD CAGR |
+|---|---|---|---|---|---|---|
+| 4-sleeve (baseline) | 2.12 | 7.8% | +23.3% | 2.21 | 3.5% | +16.0% |
+| **5-sleeve (+GTAA01 20%)** | **2.24** | **6.2%** | +18.8% | **2.46** | **2.2%** | +14.6% |
+
+Per-anno: tutti gli 8 anni positivi, 2022 +7.0% (era +11.6%: GTAA soffre il whipsaw 2022, unico
+anno con dSh negativo −0.49 — dichiarato). Il trade-off è esplicito: −4.5pp di CAGR full per
++0.12/+0.25 di Sharpe e DD 7.8→6.2 / hold-out 3.5→2.2. A pesi research (XS/VRP/SKH modellati o
+STAT-MODE) il CAGR era comunque di carta; lo Sharpe/DD del book è la metrica di verità.
+
+### Cosa NON cambia
+Il **book live Deribit** (`deribit_book_sleeves` TP01+SKH01 75/25, `book_execute`) è INTATTO —
+GTAA è su IB, già tracciato forward da `paper_combo`. `paper_portfolio` da oggi traccia la
+composizione a 5 (regime-break dichiarato qui). Test: `tests/test_gtaa_sleeve.py` (registry,
+weekend-zero, attivazione, book live invariato) — suite 168/168.
+
+### Lezione dell'addendum
+Prima di una nuova ondata di *ricerca*, ri-leggere l'archivio dei **validati-ma-non-integrati**:
+l'unico upgrade onesto del book in 3 ondate (104+5+6 filoni) era un edge già validato che
+aspettava solo la valutazione da sleeve. La diversificazione strutturale (secondo mercato,
+corr ~0.1) resta l'unica cosa che alza lo Sharpe del book senza nuovo alpha.

docs/diary/2026-07-01-vrp-refinement.md

@@ -0,0 +1,98 @@
+# 2026-07-01 — Affinamento VRP01 (sizing IV−RV / filtro DVOL-momentum / gate TP01): NON MIGLIORA
+
+**Script:** `scripts/research/r0701_vrp_refine.py` (solo ricerca: `src/` e `scripts/live/` non toccati).
+**Esito: NON MIGLIORA — VRP01 baseline resta la config canonica.** La cella IS-best (gate TP01-skip)
+è un falso positivo in-sample da manuale: IS Sharpe 2.07 ma multi-cut **0/5**, hold-out **−0.14**
+(vs 0.59 del baseline), DSR 0.71. Nessuna modifica a `sleeves._vrp_combo_returns`.
+
+## Cosa testava (celle NUOVE, verificate non ripetute nei diari)
+
+Stessa pipeline di `options_vrp_v2.py` (pricing BS su DVOL reale, payoff sul path certificato,
+fee 12.5% del premio, f=1.0, tenor 7d, spread −0.28/−0.10) — cambiati SOLO gate/sizing:
+
+1. **Sizing sul gap IV−RV** (carry atteso): size lineare `clip(vrp/scale,0,1)` (scale 8/12 pt) o
+   percentile espandente causale del VRP; in aggiunta o in sostituzione del gate binario IV-rank.
+   NB: il gate composito "IV-rank>0.30 AND IV−RV>0" è **già il baseline** (`gate_vrp=True`).
+2. **Filtro DVOL-momentum**: non vendere se `dvol[i]−dvol[i−k] > thr` (k∈{5,10}, thr∈{0, 5pt}).
+   (Diverso da `dvol_directional` 2026-06-29, dove il DVOL-mom era segnale direzionale sul perp.)
+3. **Gate di regime da TP01**: skip o half-size quando TP01 è flat su entrambi gli asset (risk-off).
+4. Croce completa: **105 celle**, tutte contate nel deflated-Sharpe.
+
+NON ripetuto (già scartato): gestione attiva intra-trade (PT/SL/vol-stop/delta-exit,
+`2026-06-20-vrp-active-management.md` → hold-to-expiry vince).
+
+Metodo: selezione cella **in-sample (pre-2025)** con floor di attività IS ≥20%, hold-out 2025-26,
+**multi-cut 5 tagli** (2023-01→2025-01, richiesti ≥4/5 uplift>0), `altlib.deflated_sharpe` su tutti
+i 105 trial, effetto sul **portafoglio 4-sleeve** (TP01 41.25 / XS01 18.75 / VRP 15 / SKH01 25).
+
+## Risultati (book 50/50 BTC+ETH, rendimenti settimanali)
+
+Baseline riprodotto esattamente: **FULL Sh 1.09 / IS 1.26 / HOLD 0.59 / DD 12% / worst −7.4% / attivo 41%.**
+
+| cella | IS Sh | FULL | HOLD | DD | worst | attivo |
+|---|---|---|---|---|---|---|
+| **BASELINE** bin+ivr30 | 1.26 | **1.09** | **0.59** | 12% | −7.4% | 41% |
+| sizing lin 8pt (+ivr30) | 1.20 | 1.05 | 0.61 | 11% | −7.4% | 41% |
+| sizing lin 12pt (+ivr30) | 1.12 | 0.98 | 0.54 | 11% | −7.4% | 41% |
+| sizing rank (+ivr30) | 1.07 | 0.94 | 0.54 | 9% | −5.7% | 41% |
+| sizing lin 8pt **al posto di** ivr | 0.89 | 0.58 | **−0.38** | 21% | −7.4% | 86% |
+| sizing rank al posto di ivr | 1.03 | 0.69 | **−0.36** | 11% | −5.7% | 86% |
+| mom k=5 thr=5pt | 1.24 | 1.02 | 0.37 | 9% | −6.5% | 34% |
+| mom k=10 thr=5pt | 1.26 | 1.08 | 0.55 | 9% | −6.5% | 31% |
+| mom k=5 thr=0 | 1.78 | 1.24 | −0.10 | 5% | −3.9% | 20% |
+| mom k=10 thr=0 | 1.36 | 0.78 | **−0.47** | 7% | −3.9% | 18% |
+| tp01-skip | **2.05** | 1.43 | **−0.14** | 7% | −4.7% | 27% |
+| tp01-half | 1.72 | 1.34 | 0.27 | 7% | −4.7% | 41% |
+| IS-best: lin8+tp01-skip | **2.07** | 1.43 | **−0.14** | 6% | −4.2% | 27% |
+
+**Multi-cut della IS-best vs baseline: uplift negativo in 5/5 tagli** (−0.35 → −0.73, monotono
+peggiorando verso il presente). **DSR** IS-best 0.709 (<0.95); baseline 0.472 dentro questa griglia
+(contesto onesto: nemmeno il baseline è statisticamente distinguibile su 105 trial correlati — ma è
+pre-committed, non selezionato qui). Celle che battono l'hold-out del baseline: **1/105** (lin8pt
+tp-off, +0.02 — rumore; non selezionabile: sarebbe selection-on-holdout).
+
+### Frequenza d'intervento dei gate (settimane-trade del baseline = 163)
+
+- **TP01-skip: blocca il 32.5%** delle settimane tradabili (TP01 flat il 38% dei giorni della
+  finestra DVOL). NON è ridondante col baseline — lavora tanto — ma lavora **male** OOS.
+- mom thr=5pt: blocca 24-32%; mom thr=0: blocca 60-64% (quasi metà del book).
+
+### Portafoglio 4-sleeve (VRP @15%)
+
+| VRP nello slot | FULL Sh | FULL DD | HOLD Sh | HOLD DD |
+|---|---|---|---|---|
+| **baseline** | **2.12** | 7.8% | **2.21** | 3.5% |
+| IS-best (lin8+tp01-skip) | 2.11 | 7.8% | 2.12 | 3.5% |
+
+Anche a livello portafoglio la variante **peggiora** l'hold-out (2.21→2.12) e non migliora nulla.
+
+## Lettura (perché non migliora)
+
+1. **L'alpha del VRP è già tutto nel gate IV-rank binario** ("vendi solo vol ricca"). Il sizing
+   proporzionale al gap IV−RV è ridondante *dato* il gate (Δ ≈ ±0.05, dentro il rumore); usato al
+   posto del gate, riporta dentro le settimane di vol povera e distrugge l'hold-out (−0.36/−0.38).
+   Il carry atteso (IV−RV) NON è un segnale di *intensità* utile oltre il suo segno+rank.
+2. **Il gate TP01 è la trappola in-sample perfetta** (la lezione macro-gate al contrario): schiva il
+   2022 (−6%→0%) gonfiando l'IS a 2.05, ma nel 2025-26 TP01 è flat proprio nei regimi di vol ricca
+   in cui la vendita gated di put **guadagna** — il gate taglia le settimane migliori dell'hold-out
+   (0.59→−0.14). Short-vol gated e trend sono complementari, non condizionabili l'uno sull'altro.
+3. **Il DVOL-momentum non aggiunge protezione**: il crash-skip IV-rank>0.90 + il long wing dello
+   spread coprono già il run-up di vol; thr=0 è troppo aggressivo (blocca ~60%), thr=5pt è neutro
+   (mai meglio del baseline su hold-out).
+
+## Onestà / caveat (invariati)
+
+Premio MODELLATO su DVOL ATM (no skew), book 1d, f di stress reale non catturato → tutto questo
+resta dentro il modello; il verdetto massimo possibile era "sleeve modellato migliorato", e non è
+stato raggiunto. Il DSR sulla griglia è un limite *superiore* (celle correlate + ~20 config storiche
+di options_vrp_lab/_v2 non contate).
+
+## Azione
+
+**Nessuna.** VRP01 resta com'è (`bin + gate_vrp + ivr30 + crash-skip 0.90`, hold-to-expiry).
+Terzo tentativo di affinamento fallito (dopo active-management e — per il portafoglio — DVOL
+overlay): il filone "migliorare VRP01 dentro il modello" è da considerarsi **esaurito**; il prossimo
+passo utile resta quello noto: f di stress reale quando cerbero-bite cattura un crash + skew reale
+sul long wing.
+
+Script: `scripts/research/r0701_vrp_refine.py` (`--skip-portfolio` per la sola griglia).

docs/diary/2026-07-01-xs-residual-momentum.md

@@ -0,0 +1,74 @@
+# 2026-07-01 — Residual (idiosyncratic) momentum cross-sectional sui 19 major HL — SCARTATO/REDUNDANT
+
+**Tesi.** STATARB-RESID (thread 4, 2026-06-29) ha mostrato che il momentum del residuo ETH−β·BTC
+(β OLS rolling, **sgn=+1**: le dislocazioni continuano a 1d) passa quasi tutti i gate su 2 gambe,
+fallendo solo il deflated-Sharpe (0.929<0.95). Ipotesi qui: portare lo **stesso meccanismo
+cross-sectional** sui 19 major di XS01 — per ogni alt, residuo vs β·BTC (β OLS rolling B), momentum
+del residuo (blend z-score [30,90] come XS01 o singolo L), long top-k / short bottom-k, vol-target
+20% — sperando che la **breadth** (18 stream invece di 1) alzasse il DSR dove il 2-gambe falliva.
+Script `scripts/research/r0701_xs_residmom.py` (riusa l'harness collaudato `xsec_v2_nonmom`:
+load_matrix, xs_engine — uguaglianza verificata maxdiff 0 —, deflated_sharpe, StrategyPortfolio).
+
+Distinzione dal già-testato: IREV (idio-**reversal**, sgn=−1) era FALLITO nel filone C; IMOM di
+xsec_v2 usava il mercato equal-weight come fattore, B=60 fisso, senza blend ed era solo riferimento.
+Qui fattore = **BTC** (come STATARB-RESID, BTC escluso dal cross-section), B in griglia, blend
+z-score, probe con gate di dispersione p30 (parità strutturale con XS01), **selezione in-sample-only**.
+
+## Setup
+
+- Universo: 19 major HL certificati (`data/raw/hl_*_1d.parquet`), 913 giorni [2024-01-01 → 2026-07-01],
+  barre vol=0 escluse. Fee 0.10% RT/gamba + sweep fino a 0.30%.
+- Griglia (57 trial): β-window {60,90,120} × lookback {blend[30,90], 30, 90} × k {3,5} × H {5,10,20}
+  + 3 probe gated (blend, k5, H10, gate dispersione p30). Cella scelta col solo Sharpe **pre-2025**;
+  hold-out 2025-01-01 bloccato. Causalità: prefix-check ok (max_tail_diff 0).
+- Baseline (stessa finestra, sleeve attivi): XS01 FULL Sh **1.38** / HOLD **1.51** / DD 11%;
+  book 4-sleeve FULL 2.12 / HOLD 2.21.
+
+## Esito — collasso OOS della cella in-sample e nessuna cella competitiva
+
+Cella scelta in-sample: **B60 L30 k3 H20** (IS Sh 2.00):
+
+```
+FULL +0.67 | HOLD −0.24 | DD 35% | per-anno 2024 +54% / 2025 −15% / 2026 +5%
+corr→XS01 +0.54 | corr→TP01 −0.09 | DSR 0.510 (57 trial) | fee-sweep ok (F+0.59 a 0.30%)
+small-cap $600/min$5: haircut ≈ 0 (ma book multi-gamba → STAT-MODE comunque, come XS01)
+```
+
+Portafoglio (il bar del mandato):
+
+```
+BASE 4-sleeve                FULL 2.12 DD 7.8% | HOLD 2.21 DD 3.5%
+SOSTITUZIONE XS01 → cand     FULL 2.01 (−0.10) | HOLD 1.18 (−1.03)   ← distrugge l'hold-out
+AGGIUNTA 5° sleeve @10/15%   HOLD −0.31 / −0.53                       ← diluisce
+MARGINAL vs BOOK: corr +0.23, uplift@10% full −0.04 / hold −0.31, multi-cut 2025 −0.31 / 2026 −0.14
+```
+
+**Il verdetto non dipende dalla selezione** — aggregato delle 57 celle:
+- FULL max **+0.94**, HOLD max **+0.82** (mediane +0.52/+0.33): *nessuna* cella si avvicina a XS01
+  (1.38/1.51), nemmeno cherry-pickando sull'hold-out.
+- corr→XS01 in [+0.47, +0.71], mediana **+0.62**: è momentum XS01 travestito (la residualizzazione
+  vs β·BTC sposta poco: lo z-scoring cross-sectional di XS01 già rimuove implicitamente il mercato).
+- Solo 4/57 celle passerebbero un gate "diversificatore" (|corrXS|<0.6, FULL>0.5, HOLD>0), tutte con
+  FULL ≤0.68 e IS incoerente.
+- **corr(Sharpe in-sample, Sharpe hold-out) attraverso le celle = −0.37**: l'in-sample è
+  anti-predittivo dell'OOS su questa griglia — la firma del rumore, non di un edge con plateau.
+
+## Perché la tesi è falsa (3 righe)
+
+1. La breadth non ha alzato il DSR (0.51 ≪ 0.95) perché non c'è edge da deflazionare: il residuo
+   vs β·BTC sul cross-section degli alt NON eredita l'edge del 2-gambe ETH−β·BTC — quel lead vive
+   nella coppia specifica ETH/BTC (i due asset profondi/cointegrati), non nel long-tail degli alt.
+2. Cross-sectional, la residualizzazione è quasi un no-op: demeaning z-score (XS01) ≈ togliere il
+   mercato → il candidato è una variante rumorosa di XS01 (corrXS mediana 0.62) con meno segnale.
+3. In-sample = solo 2024 (~1 anno utile dopo il warmup): la selezione onesta atterra su una cella
+   2024-lucky che perde nel 2025-26 — l'ennesima conferma del gate selection-on-holdout.
+
+## Verdetto: **SCARTATO/REDUNDANT.** Nessuno sleeve, nessun forward-monitor.
+
+Coerente con il filone momentum-structure (2026-06-29): l'edge di XS01 sta nella sua struttura
+specifica (blend + gate dispersione), e le sue varianti — incluso l'idio-momentum vs BTC — sono
+REDUNDANT o peggio. Chiude anche il cerchio su STATARB-RESID: il meccanismo residuo-momentum resta
+valido SOLO come coppia ETH/BTC (forward-monitor `paper_statarb`), non generalizza al cross-section.
+Nessun impatto sul book live; config canonica invariata.
+
+Script: `scripts/research/r0701_xs_residmom.py` (non committato, prefisso r0701_xs).

docs/diary/2026-07-01-xs-seasonality.md

@@ -0,0 +1,69 @@
+# 2026-07-01 — Stagionalità CROSS-SECTIONAL sull'universo Hyperliquid → SCARTATO
+
+## Ipotesi
+
+Effetti calendario **relativi tra i 19 alt major HL** (weekday tilt, turn-of-month,
+pattern weekend→lunedì nel cross-section), long/short market-neutral. L'angolo è diverso
+dal prior art già morto (trackF seasonality BTC/ETH = buy&hold travestito;
+crypto_weekend_signal/overnight = look-ahead; open_drive = artefatto calendario ucciso da
+`day_boundary_robust`): essendo il segnale **demeaned cross-section**, il buy&hold
+travestito è strutturalmente escluso… *in prima battuta* (vedi diagnostica beta sotto).
+
+## Metodo (test statistico PRIMA della strategia)
+
+Script `scripts/research/r0701_xs_seasonal.py`. Dati `data/raw/hl_*_1d.parquet`, 19 major
+XS01 (lista `src/portfolio/sleeves.XS_UNIVERSE`), **912 giorni** (2024-01-02 → 2026-07-01,
+~2.5 anni), 0 barre vol=0. Ritorno relativo x[t,a] = r[t,a] − media cross-section del
+giorno. Per ogni bucket calendario: **tilt bucket-specifico** per asset = media di x nel
+bucket − tilt incondizionato dell'asset (isola il calendario dal drift relativo generico).
+**Persistenza split-half**: Spearman rank-corr del vettore tilt (19 asset) H1 vs H2, per
+bucket. **Null**: 2000 permutazioni delle etichette entro ciascuna metà → distribuzione del
+**max-statistic** (controlla il multiple-testing sui bucket e il confound "alpha persistente
+dell'asset"). Soglia severa p<0.05 sul max. Regola del mandato: senza persistenza →
+**nessun backtest**.
+
+## Numeri
+
+| Test | Statistica | Null 95° pctl | p | Esito |
+|---|---|---|---|---|
+| [A] Weekday (7 bucket) | max rank-corr **+0.511** (Wed); Mon +0.38, Sun +0.37, Fri +0.04 | +0.604 | **0.159** | FAIL |
+| [B] Weekend vs feriali | +0.268 | +0.428 | **0.178** | FAIL |
+| [C] Turn-of-month (±2gg) | +0.221 | +0.451 | **0.226** | FAIL |
+| [D] IC weekend→lunedì | FULL −0.053 (t=−1.94); H1 −0.006 (t=−0.17) vs H2 −0.100 (t=−2.4) | — | non persiste | FAIL |
+
+Con ~65 osservazioni per weekday per metà, lo std di una rank-corr su 19 asset è ~0.24 → il
+max-su-7 sotto puro rumore arriva a ~0.60: il +0.51 reale è *dentro* il rumore.
+
+## Diagnostica: perché tutte le rank-corr weekday sono positive?
+
+Non è tilt idiosincratico, è il **canale-beta**: il mercato EW ha un pattern weekday di
+*livello* che si ripete nelle due metà (Sun −42/−30 bps, Sat +26/+25, Mon +35/+32) e la
+dispersione di beta (0.53→1.26) lo proietta nel cross-section — rank-corr(tilt, beta):
+**Sun −0.642**, Sat +0.325, feriali ~0. Cioè la poca "persistenza" visibile è l'effetto
+weekday di MERCATO (dominio trackF, già scartato come buy&hold travestito) che rientra
+dalla finestra via beta. Un eventuale L/S "weekday tilt" sarebbe stato in gran parte un
+book short-beta-la-domenica — non un edge calendario cross-sectional.
+
+## Note sui gate non raggiunti
+
+- **day_boundary_robust** (obbligatorio per ogni effetto calendario): NON eseguibile sui
+  19 alt — i dati HL locali sono **solo 1d**, il confine giorno non è ri-tagliabile. Anche
+  con persistenza, il verdetto massimo sarebbe stato LEAD-forward *condizionato* a barre
+  orarie HL, mai sleeve. Con lo SCARTATO allo step 1 il punto è moot, ma resta il vincolo
+  per chiunque riapra il filone.
+- **Fee**: mai arrivati al backtest; nota strutturale: un weekday-tilt L/S ribilancia ogni
+  giorno (weekday di domani ≠ oggi) → turnover ~2×gross/die, morte-per-fee quasi certa a
+  0.10% RT anche con edge lordo.
+- **DSR**: non calcolato (nessuna cella backtestata — il branch strategia esiste nello
+  script ma non si attiva senza persistenza).
+
+## Verdetto
+
+**SCARTATO** allo step statistico, senza backtest. Tre motivi: (1) nessuna persistenza
+split-half sopra il null permutato (p 0.16–0.23 su tutti i test, IC weekend→lunedì non
+persiste tra le metà); (2) la sola struttura visibile è il canale-beta di un pattern
+weekday di mercato — la stessa famiglia già scartata in trackF, non un effetto
+cross-sectional; (3) ~2.5 anni × effetto calendario × turnover giornaliero = rumore +
+morte-per-fee anche nello scenario migliore.
+
+File: `scripts/research/r0701_xs_seasonal.py` (deterministico, seed 20260701, ~2 min).

docs/diary/2026-07-02-anchor-audit-xs01-skh01.md

@@ -0,0 +1,132 @@
+# 2026-07-02 — Audit anchor timing-luck su XS01 e SKH01 (chiusura del pendente dell'ondata TIMING)
+
+**Contesto.** L'ondata TIMING+CRT dello stesso giorno (`2026-07-02-timing-crt-wave.md`) ha stabilito
+che l'hold-out di TP01 (0.31) è la **migliore delle 24 ancore daily possibili** (mediana 0.04,
+P~0.86 di uno spike così per caso). Lo scettico ha flaggato l'audit come **pendente** sugli altri
+due sleeve a ribilanciamento/griglia ancorata: **XS01** (fase del ciclo di ribilanciamento H=10
+giorni) e **SKH01** (offset della griglia dual-TF 230m/690m, `origin='epoch'`). Questo diario
+chiude entrambi. Due agenti indipendenti, metodologia identica allo scettico TP01
+(`r0702_skeptic_offset.py`): ancore dichiarate **a priori**, parametri **identici** in ogni
+fase/offset (zero tuning per-ancora), **sanity replica bit-exact** della sleeve canonica prima di
+qualsiasi numero, block-bootstrap congiunto per P(spike).
+
+**Script:** `scripts/research/r0702_anchor_xs01.py`, `scripts/research/r0702_anchor_skh01.py`.
+Nessun file di produzione toccato dagli agenti (solo docstring/narrativa aggiornate a valle, qui).
+
+---
+
+## Verdetto in una riga
+
+**Il finding TP01 si replica su TUTTI e tre gli sleeve ancorati — su SKH01 più forte che su TP01 —
+e i numeri headline del book (HOLD 2.46) sono in parte best-of-anchors.** Ciò che sopravvive
+de-luckato: XS01 resta un diversificatore ammissibile (ensemble di fase FULL 1.25 / HOLD 1.31 /
+DD 11%); SKH01 resta ADDS (uplift del blend positivo a **tutte** le 23 fasi, corr ~0.08) ma i suoi
+numeri headline e — cruciale — **il gate DD<30% che l'ha selezionata** non reggono alla fase
+mediana. Stima onesta de-luckata del book 5-sleeve: **HOLD ~1.9–2.1, FULL ~2.0–2.2** (vs 2.46/2.24
+dichiarati).
+
+---
+
+## XS01 — fase del ciclo di ribilanciamento H=10 (10 fasi)
+
+Sanity: replica di `_xsec_returns` con parametro `phase` → **max|Δ|=0.0 bit-exact** vs la canonica.
+NB: la canonica sui dati di oggi fa FULL 1.367/HOLD 1.479/DD 10.8% (i dichiarati 1.50/1.71/11%
+erano del 2026-06-19; deriva dati, confronto interno coerente).
+
+| metrica | min | mediana | max | canonica (f0) | pctl f0 |
+|---|---|---|---|---|---|
+| Sh FULL | 0.41 | 1.21 | 1.64 | 1.37 | 85° |
+| Sh HOLD | 0.15 | 1.17 | 1.71 | 1.48 | 65° |
+| maxDD | 10.0% | 15.5% | 29.1% | 10.8% | **15°** |
+
+- **Firma diversa da TP01: la fortuna NON è nell'hold-out** (65° pctl, non estremo) **ma nel
+  DD** (15° pctl: il "DD 11%" dichiarato è uno dei più bassi delle 10 fasi; la fase tipica fa
+  ~15.5%, la peggiore 29%) e nel FULL (85°).
+- **Bootstrap**: spike osservato +0.38 su hold-out; **P(una fase qualsiasi ≥ +0.38) = 0.91–0.94**
+  (block 10/20/40, B=4000) → la canonica è il massimo atteso di 10 stime correlate (corr mediana
+  fra fasi 0.71).
+- **Ensemble 10 fasi** (lens di reporting onesta): **FULL 1.25 / HOLD 1.31 / DD 10.9%** — la
+  diversificazione di fase riporta il DD al livello canonico con Sharpe ≈ mediana.
+- **Book 5-sleeve**: HOLD 2.44 (canonica) → 2.26 (fase mediana) → 1.75 (peggiore, marginalmente
+  PEGGIO del book senza XS01 = 1.77) → 2.35 (ensemble). **Eredità di fortuna ~+0.17 HOLD.**
+  FULL quasi insensibile (2.10–2.28).
+- **Gate di ammissione a fase mediana**: FULL 1.08 / HOLD 1.10 / DD 20.7% — **i numeri dichiarati
+  non reggono** (Sharpe −0.3/−0.6, DD raddoppia). **La decisione però regge**: nessuna fase
+  negativa, 8/10 con FULL≥1.0, book migliore a ogni fase tranne la peggiore (dove è neutro) →
+  slot da diversificatore @15% difendibile; cambia la NARRATIVA (banda/ensemble, non 1.50/1.71/11%).
+- **Caveat**: storia ~2.5 anni (CI95 Sh HOLD canonica **[−0.04, +2.72]** — nessuna stima puntuale
+  affidabile); dimensione **ora-del-giorno non testabile** (solo barre 1d HL: resta luck residua
+  10 fasi × 24 ore non certificabile); XS01 è STAT-MODE → impatto su reporting/gate, non sul book
+  live Deribit.
+
+## SKH01-V2-DD — offset della griglia dual-TF 230m/690m (23 offset × 30m)
+
+Sanity: offset 0 riproduce `_skyhook_returns()` **bit-exact** (max|Δ|=0.0 su 2666 giorni); maxDD
+harness BTC 21.4%/ETH 27.4% = identici al diario di ammissione; riuso diretto di
+`skyhook_entries`/`htf_features`/`merge_htf_to_ltf` con `resample(origin='epoch', offset=...)`,
+confini 690 ⊂ 230 verificati a ogni offset.
+
+| metrica (book 50/50) | min | mediana | max | off0 (canonico) | pctl off0 |
+|---|---|---|---|---|---|
+| Sh FULL | 0.78 | 1.05 | 1.48 | 1.46 | 93° |
+| Sh HOLD | 0.44 | 0.93 | 1.64 | 1.64 | **98° (max)** |
+| minFull (2 asset) | 0.35 | 0.67 | 1.01 | 0.99 | 93° |
+| minHold | −0.10 | 0.39 | 1.25 | 1.25 | **98° (max)** |
+| blend 0.75·TP01+0.25·SKH, HOLD | 0.49 | 0.72 | 1.16 | 1.16 | **98° (max)** |
+
+- **È uno spike, non un plateau**: gli offset adiacenti ±30m crollano (book HOLD 1.64 → 0.88 a
+  off30). Firma identica all'ancora TP01, ma **più forte**: il canonico è al 93–98° pctl di OGNI
+  metrica; minHold +1.26 e blend "0.31→1.17" sono il **massimo dei 23**.
+- **Gate DD<30% — il criterio per cui V2-DD fu selezionata — FALLISCE in 15/23 offset**
+  (mediana DD: BTC 23.5%, ETH **29.2%** — pass per 0.8pt; peggiori 35.9%/42.1%). Il margine ETH
+  "già sottile" (27.4%) è in realtà **sotto la mediana di fase**: la proprietà DD<30% è in larga
+  parte fortuna di fase.
+- **Ciò che regge de-luckato**: **uplift del blend positivo a TUTTE le 23 fasi** (min +0.18,
+  mediana +0.42, canonico +0.86) e corr→TP01 in [0.05, 0.11] a ogni fase → il verdetto
+  ADDS/diversificatore sopravvive, ridimensionato. Alla fase peggiore invece non regge
+  (minHold −0.10, DD fail).
+- **Bootstrap**: spike blend +0.44; **P(un offset qualsiasi ≥ +0.44) ≈ 0.70** (block 10/20/40);
+  P(uplift≤0) = 0.03–0.04 → l'uplift è reale, l'ampiezza è best-of-23.
+- **Book 5-sleeve**: HOLD 2.44 (off0 = max dei 23) → mediana **1.96** → ensemble 2.12; FULL 2.24 →
+  mediana 2.01. **Eredità di fortuna ~+0.5 HOLD** — molto più dei ~+0.10 dell'ancora TP01.
+- **Rilevanza LIVE (SKH = 25% del book Deribit reale)**: il cron è orario, i confini 230m no →
+  ritardo uniforme {0..50} min (media 25). Re-sim del path reale (fill al close 5m del prossimo
+  run orario, exit SOFTWARE come da `book.py`): book 50/50 **FULL 1.46→1.19, HOLD 1.64→1.15,
+  DD 18.1%→24.6%**. La maggior parte del gap è l'assunzione fill-al-livello del backtest, non il
+  ritardo orario in sé: nei crash le barre 230m **gappano attraverso lo SL software** (short
+  sl2% modellato −2% → realizzato **−11/−23%**: ETH 2021-05-19, 2021-01-04, COVID 2020-03-13).
+  Il disaster-SL on-book −30% copre solo la coda estrema della posizione netta.
+- **Caveat**: equity daily-step (lens Sharpe, come il canonico); l'ensemble di offset NON è
+  eseguibile live (gira una sola griglia) → serve solo come stima de-luckata; sim hourly senza
+  slippage/parziali.
+
+## Book 5-sleeve — stima de-luckata congiunta (approssimata)
+
+Ogni audit varia UN solo sleeve (gli altri restano canonici), quindi gli effetti non si sommano
+esattamente; ordine di grandezza dell'eredità di fortuna sull'HOLD 2.46: TP01-ancora ~+0.10,
+XS01-fase ~+0.17, SKH01-offset ~+0.5. **Stima onesta: HOLD ~1.9–2.1, FULL ~2.0–2.2, DD ~6%
+(invariato)** — il book resta largamente positivo e diversificato a ogni combinazione testata,
+ma il 2.46 è un massimo di ~24×10×23 configurazioni di ancora, non la stima centrale.
+
+## Regole codificate in narrativa (CLAUDE.md aggiornato)
+
+1. **I numeri headline di OGNI sleeve ancorato si citano con la banda d'ancora** (o come ensemble
+   di fase): vale già per TP01, ora anche per XS01 e SKH01 e per l'HOLD del book.
+2. **Un gate di selezione (es. DD<30%) va verificato sulla banda di fase, non sull'ancora
+   canonica** — SKH01-V2-DD fu selezionata per una proprietà che tiene in 8/23 fasi.
+3. Il candidato gate `anchor_luck_band()` in altlib sale di priorità: tre sleeve su tre ancorati
+   mostrano la stessa firma, e il deflated-Sharpe non conta questo multiple-testing.
+
+## Follow-up (non eseguiti, da valutare)
+
+- **Rivalutare il peso 25% di SKH01 nel book live Deribit**: l'aspettativa onesta della gamba SKH
+  è ≈ fase-mediana + path orario (blend HOLD ~0.72, non 1.17) con gap-through-stop reale nei
+  crash. L'uplift resta positivo a ogni fase → non c'è motivo di rimuoverla, ma il sizing fu
+  deciso su numeri best-of-23.
+- Cadenza cron a 230m (o trigger sui confini di barra) per chiudere il gap di path orario.
+- `anchor_luck_band()` in `altlib.py` come gate standard per candidati ancorati.
+- Audit ora-del-giorno di XS01 quando esisterà un feed HL intraday certificato.
+
+**Stato:** XS01/SKH01/pesi/book live INVARIATI (nessun cambio operativo da questo audit — è un
+audit di reporting e di gate, e ogni cambio pesi dovrà passare `weights_tilt_null` +
+selection-on-holdout). Test suite 168 verdi. Script audit committati.

docs/diary/2026-07-02-elliott-albimarini-capital.md

@@ -0,0 +1,168 @@
+# 2026-07-02 — Ondata "video claims": Elliott (3 filoni), Albimarini (2), capital scaling 2-5k
+
+**Contesto.** Su richiesta: meccanizzare e testare le claim falsificabili di 4 video didattici
+italiani (3 sulle onde di Elliott, 1 ricostruzione della "strategia Albimarini" — double diagonal
+a credito su SPX), più l'audit dei muri di scala visto l'annuncio che il conto live verrà portato
+a **2.000-5.000 $**. Sei agenti indipendenti, harness altlib, fee 0.10% RT, hold-out 2025-26 mai
+usato per selezionare, banda d'ancora obbligatoria (regola dello stesso giorno). Nessun PASS →
+nessuno scettico necessario. Nessun file di produzione toccato.
+
+**Scripts:** `scripts/research/r0702_ell_{rangecycle,fibconfluence,channel}.py`,
+`r0702_alb_{structure,claims}.py`, `r0702_capital_scaling.py`.
+
+---
+
+## Verdetto in una riga
+
+**Elliott 3/3 SCARTATO** (range-cycle = rumore 0/24 Bonferroni; canale = Donchian travestito che
+non batte il Donchian; Fibonacci = effetto posizione, non numeri magici). **Albimarini 2/2
+SCARTATO** (la diagonale non domina nemmeno nel modello ed è fee-negativa su Deribit; il track
+record dichiarato è consistente con zero skill al 20-45%, e va in rovina in ogni finestra storica
+con una coda). **Capital scaling: l'unico vincolo vero a 2-5k è il cap $300/asset** — da alzare a
+equity/2 al momento del deposito; tutto il resto si scioglie da solo o resta fuori comunque.
+
+---
+
+## ELL-A — "range-cycle" (onda 1 compressa → onda 3 ampia): RUMORE
+
+Claim di Frost&Prechter/Larry Williams meccanizzato senza conteggio soggettivo: 2 definizioni di
+segmento (flip TSMOM, zigzag k·ATR causale), impulso iniziale (N∈{3,5,10} barre, range/ATR
+pre-segmento) vs ampiezza del seguito (claim A) e troncatura dell'ultimo terzo (claim B).
+BTC/ETH 1d+1w, Spearman con null permutato (2000), Bonferroni m=24.
+
+- **0/24 celle significative** (miglior p raw: A 0.061, B 0.058; Bonferroni 1.00 ovunque, FULL e
+  pre-2025). 7-9/12 celle col segno "giusto" = moneta su celle correlate.
+- **Nessuna cella weekly regge a tutte e 7 le ancore** (p 0.02-0.05 di singole ancore = il
+  timing-luck d'ancora che da oggi non crediamo più; alcune celle flippano segno tra ancore).
+- **Artefatto previsto e smascherato**: normalizzando col range POST-impulso la correlazione
+  diventa negativa per pura meccanica del denominatore — chi "conferma" il claim così misura
+  l'artefatto.
+- Coerente con le famiglie di compressione già fallite nello sweep 104 (BRK08 NR7, BRK10
+  BB-squeeze, CMB05, VOL12). Campione strutturalmente piccolo (mediana 78 segmenti daily, ~30
+  weekly). Strategizzazione correttamente non eseguita (statistica prima della strategia).
+
+⚠️ **LEZIONE PANDAS (gemella di `view("int64")` del 2026-07-01):** `resample("7D",
+origin=...)` in pandas 2.x **ignora silenziosamente `origin`** ("D" non è Tick-like, solo un
+RuntimeWarning) → tutte le ancore weekly uscivano identiche e la banda d'ancora sarebbe stata una
+banda finta di larghezza zero. Serve **`"168h"`**. Da ricordare per ogni futura banda d'ancora
+settimanale.
+
+## ELL-B — Confluenza di Fibonacci: EFFETTO POSIZIONE, non numeri magici
+
+Zigzag causale non-repainting (livelli usabili solo dalla conferma del pivot, causality_ok
+max_tail_diff=0.0), tocco fresh intrabar, reazione ATR-normalizzata a 5/20 barre, ~24k/14k tocchi
+IS a 1h. **Tre null in scala di durezza**: (A) rapporti uniformi casuali, (B) ri-sorteggiati per
+swing, **(C) location-matched** (Fib ± jitter 2-8%: "0.618 è speciale vs 0.58/0.66?").
+
+- Vs null A/B i Fib sembrano buoni (pctl 0.82-1.00) — **vs null C crollano a 0.39-0.68 = puro
+  caso**. L'apparente vantaggio è interamente l'effetto di *posizione* (i rapporti Fib cadono in
+  zone mediamente decenti del range), non dei numeri di Fibonacci.
+- **Confluenza** (2 griglie entro 0.25·ATR): FAIL 4/4 celle — non reagisce più delle confluenze
+  di rapporti casuali. Break-rate al tocco ~46-50% (moneta); su 1h i Fib veri vengono bucati più
+  spesso del placebo.
+- In assoluto comunque nulla da tradare: +2.6/+5.6 bps a 5 barre (fee = 10 bps), negativo a 20
+  barre e su 1d. Strategizzazione correttamente saltata da gate a priori.
+- **Pattern di test riusabile**: il null location-matched è IL test giusto per ogni claim su
+  "livelli speciali" (Fib, pivot, round numbers) — separa la qualità della posizione dal numero.
+
+## ELL-C — Tecnica del canale (Ftaonline): DONCHIAN TRAVESTITO
+
+Implementazione onesta completa (zigzag causale, vincolo onda-2>origine, canale 0→min-2 con
+parallela dal max-1, entry al close della barra fuori, target 1.618×, stop=invalidazione,
+speculare short, 27 celle TF×k×varianti).
+
+- **family_honest boccia**: cella scelta in-sample (1h k4 long, IS 1.40) → hold-out **−0.87**;
+  DSR 0.685 < 0.95; earns_slot=False. Marginale vs TP01: uplift positivo solo 2020-21 =
+  beta-trend del toro (corr 0.35).
+- **Il Donchian banale a pari geometria/frequenza eguaglia o batte il canale a ogni TF**
+  (corr 0.43-0.53): vincoli d'onda + 1.618 non aggiungono nulla. Il segnale-2 ("onda 5") è
+  quasi inerte (+0.00-0.07).
+- **Target 1.618 = geometria, non magia**: toccato con la frequenza di distanze identiche
+  piazzate a caso (5/6 celle p>0.18). Claim discriminante "in canale = correttivo":
+  direzionalmente sensata, mai significativa (p 0.08-0.45); l'uscita dal canale è momentum da
+  breakout, già in casa.
+- **Anchor-luck di nuovo**: la miglior cella 4h fa hold 1.54 all'ancora 00:00, la migliore delle
+  4 (banda [0.35, 1.54]) — quarta conferma della firma nello stesso giorno.
+
+## ALB-A — Double diagonal "Albimarini" su BTC/ETH: NON DOMINA, niente LEAD
+
+Portata su Deribit (che ha le scadenze giornaliere per la long T+1) col motore DVOL di VRP01
+(riprodotto esatto: 1.09/0.59/11.8%), strike scalati in vol (2σ/5g ≈ il "9% su SPY"), gate
+IV-rank canonico non riottimizzato, 2021-26 con LUNA/FTX/2022, banda skew f∈{0.6,0.8,1.0,1.3}.
+
+- **Il claim strutturale del corso è falsificato**: gated, l'iron condor stessa-scadenza batte la
+  diagonale a ogni f (1.05 vs 0.95 a f=1.0), Δ negativo ogni anno. La long T+1 è **assicurazione
+  di coda quantificata** (+12/+33 bps nei 5% peggiori vs ~1 bps di costo medio), non dominanza.
+- **Senza gate tutte le strutture perdono** a f≤1.0 → terza conferma indipendente: nel VRP
+  l'alpha è il filtro di regime, non la vendita di premio. VRP01 resta superiore su tutta la
+  banda f (CAGR 8.3% vs 1.4%).
+- **Il meccanismo dell'illusione riprodotto in vitro**: celle z≥2.5 = 0 perdite su 142 trade,
+  Sharpe 5.9-∞ (il punto cieco CC01 in forma opzioni); la best in-sample (7.88) crolla a −0.51
+  in hold-out. Seconda occorrenza del pattern "0-perdite = Sharpe implausibile" in una settimana
+  → **si rafforza il caso per il gate `implausible_sharpe` in altlib** (raccomandato dal filone
+  CC01, ora con 2 casi d'uso).
+
+## ALB-B — Audit dei numeri dichiarati (28 trade, 82%, PF 5.16, "420% annuo"): ZERO SKILL
+
+SPY 1d 1996-2026 (parquet già in repo dal filone GTAA) + BTC/ETH certificati; MC 200k; replay
+claim-anchored calibrato per riprodurre esattamente il video.
+
+- **L'82% è incoerente col "deep OTM" in entrambe le letture**: strike a 9% → win strutturale
+  99.5% (P(|move 4td|>9%) = 0.53%, fat-tail 88× la normale); 82% letterale → strike a 2.63% ≈
+  1.2σ, non deep. In entrambi i casi win-rate = delta venduto.
+- **P(track record del video senza edge) = 20-45%**; il **78.6%** di tutte le finestre 6-mesi
+  1996-2026 lo avrebbe prodotto (lettura deep). Il PF ~5.1 esce per costruzione quando la coda
+  non è campionata.
+- **Replay attraverso le code reali**: rovina nel 1998/2002/2020 col sizing 1→4 dichiarato;
+  perfino regalando +20% di premio, 1 contratto fisso fa CAGR +4.1% con maxDD −95%. La stessa
+  semestrale del video annualizza a +73-77%, non 420%. Su BTC/ETH a EV=0: +12%/DD−68% e
+  +0%/DD−88%.
+- **La diagonale lascia passare il 12-40%** della perdita naked in un −10% overnight (dipende dal
+  vol-spike). Su Deribit la double diagonal è **fee-negativa a qualsiasi size** (fee 8 gambe =
+  194-221% del theta raccolto a questi strike): il capitale sposta solo il muro di margine.
+- Che cosa distingue VRP01 (sopravvissuto allo stesso tipo di audit): defined-risk per
+  costruzione, gate IV-rank che ribalta l'hold-out, sizing fisso — l'opposto esatto su tutti e
+  tre gli assi.
+
+## Capital scaling 600 → 2000/3500/5000 (r0702_capital_scaling.py)
+
+| capitale | TP01 haircut Sh | book investibile % (cap $300) | K=2 exec-turn % | statarb haircut | spread ETH conc. | XS01 exec-turn % |
+|---|---|---|---|---|---|---|
+| 600 | +0.010 | 100.0% | 90.5 | −0.004 | 0 | 56.9 |
+| 2000 | −0.002 | 85.9% | 95.7 | 0.000 | 3 | 87.4 |
+| 3500 | −0.002 | 63.7% | 97.5 | 0.000 | 5 | 89.3 |
+| 5000 | −0.002 | **48.9%** | 98.2 | 0.000 | 7 | 90.8 |
+
+- **Il vincolo dominante è UNO: `max_notional_per_asset_usd`=300.** A 5k il book girerebbe a
+  metà del target (cap binding nel 39-46% delle barre). **Proposta config (da applicare AL
+  deposito): cap = equity/2** → $1000 a 2k, $1750 a 3.5k, $2500 a 5k. `min_order_usd`=5 va
+  LASCIATO (il fee drag risale solo al tetto noto ~0.4%/anno; l'isteresi artificiale costerebbe
+  più in lag — lezione ondata timing).
+- Min-order/haircut TP01 ≈ 0 a ogni capitale (conferma indipendente del "−74% ordini" a 600 →
+  39-43% saltati a 5k, tutti micro). Statarb: haircut 0 da 2k (il muro era l'edge, non la scala).
+- Tranching K=2: matematicamente regge a 5k (98.2% turnover-tranche), ma il blocco vero resta il
+  feed intraday fuori path certificato + beneficio solo di varianza → **non cablare**.
+- Opzioni: il muro d'ingresso ETH cade a ~2.6k (3-7 spread concorrenti a 2-5k, fee solo 5-6% del
+  credito grazie al cap 12.5%; rettifica vs ALB-A: margine spread ETH oggi $66-76). BTC granulare
+  da ~$4.7k. **La regola "niente short-vol da modello" non decade col capitale.**
+- XS01: soglia ~20k confermata (a 5k il 9%+ del turnover non esegue). CC01: il capitale non è
+  mai stato il muro (fuori per ragioni strutturali).
+- **Aspettativa onesta**: col CAGR de-luckato del book live (10-15%, audit SKH01): **2k ≈
+  €0.55-0.82/giorno; 5k ≈ €1.37-2.05/giorno**. Il salto di capitale cambia cosa è eseguibile,
+  non l'ordine di grandezza del ritorno (€50/g ≈ 130k, invariato).
+
+## Lezioni
+
+1. **Il null giusto smonta il livello "speciale"**: location-matched (ELL-B) per i livelli,
+   Donchian-equivalente (ELL-C) per i pattern, EV=0-calibrato (ALB-B) per i track record. In
+   tutti e tre i casi il claim sopravviveva ai null ingenui e moriva su quello giusto.
+2. **`resample("7D", origin=...)` ignora origin in pandas 2.x** → usare `"168h"` per le bande
+   d'ancora settimanali.
+3. Secondo caso "0-perdite = Sharpe implausibile" (celle deep-OTM di ALB-A, dopo CC01) → il gate
+   `implausible_sharpe` in altlib sale in coda ai lavori insieme ad `anchor_luck_band`.
+4. L'anchor-luck è comparso spontaneamente anche in questa ondata (celle weekly ELL-A, 4h ELL-C)
+   — la regola della banda d'ancora sta già pagando.
+
+**Stato:** nessun nuovo sleeve, nessun forward-monitor aggiunto, book live INVARIATO. Un'azione
+operativa pende sul FUTURO deposito: alzare `max_notional_per_asset_usd` a equity/2 (decisione
+utente al momento del funding). Test suite verde. 6 script committati.

docs/diary/2026-07-02-timing-crt-wave.md

@@ -0,0 +1,186 @@
+# 2026-07-02 — Ondata timing + CRT (8 filoni multi-agente + scettico): 0 nuovi sleeve, 1 finding strutturale (anchor timing-luck di TP01)
+
+**Obiettivo (goal utente):** "cerca su Deribit altre strategie profittevoli magari con timing
+differenti oltre a quelle già valutate". Prima ondata interamente dedicata al TIMING: dopo che le
+ondate precedenti hanno coperto segnali (104 famiglie alt-sweep), universi (HL cross-sectional),
+opzioni (VRP/gamma) e pesi (EW-STR/weights_tilt_null), qui si attacca la dimensione rimasta: *quando*
+si campiona, si decide e si esegue. Su richiesta utente, seconda tranche dedicata alla **CRT (Candle
+Range Theory)**, il pattern sweep-and-reclaim a 3 candele di scuola ICT/Wyckoff.
+
+Inventario preventivo per non rifare lavoro: SEA01-09 coprivano già hour-of-day, day-of-week,
+weekend, turn-of-month, sessioni; l'onda intraday 2026-06-21 il sub-daily (con il lead prevday in
+forward-monitor); `tp01_lowfreq` i TF 4h/12h/1d. Angoli NON coperti individuati e testati: clock a
+eventi, calendario scadenze Deribit, ancora di ribilanciamento, clock più lenti del daily, velocità
+del segnale regime-condizionata — più i 3 tagli CRT (base, multi-TF, contesto).
+
+**Esito: 7 filoni FAIL + 1 finding strutturale confermato dallo scettico (timing-luck dell'ancora
+di TP01). Nessun nuovo sleeve. Nessuna modifica al book live. Il soffitto ~1.3 direzionale
+BTC/ETH resta intatto anche cambiando il clock.**
+
+---
+
+## Filone 1 — Event-clock bars (tempo-informazione): FAIL
+
+`scripts/research/r0702_eventclock.py`. Volume/vol/range bars da 5m certificato (soglie causali
+EWMA-90g shift(1), barre medie 4h/12h/24h), 5 strategie (TSMOM multi-orizzonte, Donchian 10/30d,
+EWMA-cross), 45 celle event + 15 controlli wall-clock = 60 trial.
+
+- Null decisivo (stesso segnale, stessa frequenza, wall-clock): event batte wall su ENTRAMBE le
+  finestre solo in **4/45 coppie (9%)** — rumore. Pattern incoerenti (EWMA event vince IS 9/9 ma
+  perde HOLD 9/9; Donchian-30d l'esatto opposto = selection-on-holdout in agguato).
+- Cella scelta in-sample (volume-bars 24h, DONCH-10d): IS 1.45 → **HOLD −0.46** (2025 −7.4%,
+  2026 −18.1%). Marginal NEUTRAL (corr 0.74 a TP01 = trend travestito), earns_slot_honest=False.
+- Executability comunque assente: in alta attività le barre "24h" chiudono in 3.6-4.6h (p5) → il
+  cron orario le eseguirebbe in ritardo; i clock 4h richiedono monitoraggio sub-orario.
+
+**Lezione: campionare a tempo-informazione non normalizza nulla di monetizzabile sul feed
+certificato; il clock non è la dimensione dove vive l'edge.**
+
+## Filone 2 — Calendario scadenze Deribit: FAIL (0/24 celle)
+
+`scripts/research/r0702_expiry_calendar.py`. Griglia dichiarata a priori: 4 finestre × 3 tipi expiry
+(weekly ven 08:00 UTC / monthly ultimo ven / quarterly) × 2 asset, Bonferroni |t|≥3.08; 3 null
+(placebo weekday, anchor-shift ±2/4h, permutation 500 calendari).
+
+- Nessuna cella passa Bonferroni (max |t| 2.69). Il post-expiry drift monthly (+0.61/+0.77%) ha il
+  segno della teoria ma: non batte il placebo giovedì, permutation pctl 84-95 (non estremo), si
+  INVERTE sul quarterly (dove l'OI massimo dovrebbe amplificarlo) ed è guidato dal 2019 → rumore.
+- Unica cella robusta ai null: weekly [-24,0) negativa (gio→ven), ma è indistinguibile dal
+  day-of-week (famiglia SEA già morta) e netta fee fa Sharpe ~0.08 (52 eventi/anno × 0.10% RT).
+- Best-in-sample tradabile: IS +0.90 → **HOLD −0.52**; DSR 0.230 su 24 trial.
+- Nota tecnica: colpito ESATTAMENTE il pitfall pandas 2.x documentato (epoca in secondi da
+  `date_range` su tz-aware → matching vuoto); fix con epoca ms esplicita. La lezione 2026-07-01
+  ha pagato.
+
+## Filone 3 — Anchor timing-luck di TP01 + tranching: FINDING (verificato dallo scettico)
+
+`scripts/research/r0702_tp01_offset.py` + scettico indipendente `r0702_skeptic_offset.py`
+(ricostruzione bit-exact con codice diverso, zero riuso; h=0 riproduce `tp01_baseline_daily`
+esattamente; vol-target ricalcolata per ancora; nessun look-ahead — verificato con troncamenti).
+
+**Claim 1 CONFERMATO: l'hold-out 2025-26 "Sharpe 0.31" di TP01 è in larga parte fortuna
+dell'ancora 00:00 UTC.** La stessa strategia CANONICAL alle altre 23 ancore orarie: HOLD mediano
+**0.04**, banda **[−0.13, +0.30]** — e il massimo è proprio h=0 (98° pctl; in-sample era al 10°:
+sfortunato lì, fortunato qui). Spike, non plateau (h=23/h=1 fanno 0.13/0.04). Bootstrap dello
+scettico: P(una qualsiasi ancora mostri uno spike ≥ così) = **0.86** — è il massimo atteso di 24
+stime correlate, non un'anomalia; best-anchor per finestra annuale ruota a caso (16→23→21→12→5→0,
+Spearman ≈ 0, nessuna seasonality d'ancora). Formulazione corretta (NON "il vero hold-out è 0.07",
+che ha CI95 [−1.2,+1.4] su 547 giorni): **l'hold-out 2025-26 non risolve l'edge di RITORNO di TP01**
+(ritorno totale mediano ancore ≈ 0%); ciò che regge A OGNI ancora è il claim DIFENSIVO
+(DD 6.7-10.1% vs ~60% B&H). Che è da sempre il vero valore dichiarato di TP01.
+
+**Claim 2 (tranching multi-ancora) RIDIMENSIONATO:** K=4 ≡ esattamente EW di 4 book ancorati
+(diff 1.4e-17), turnover identico (~8.3/y), haircut $600 ≈ 0. MA il "miglioramento" IS 1.49→1.56 è
+per ~90% *tornare alla media delle ancore* (h=0 era sfortunato in-sample): vs ancora tipica
++0.005 mediano, P(K4≤h0)=0.18 n.s.; il taglio DD strutturale è ~0.5pt (non 2.8: la mediana delle
+singole è già 12.6%). Ciò che regge: la compressione della VARIANZA DELLA STIMA (HOLD
+[−0.12,+0.30]→[−0.01,+0.13] a K=4) → **lens di reporting, non alpha**.
+
+**Impatto a valle (quantificato dallo scettico):**
+- Blend SKH: HOLD 1.16 (h=0) → 0.97 mediana ancore, ma l'UPLIFT a mediana è +0.93 > +0.86
+  dichiarato → **il verdetto ADDS di SKH01 era conservativo, regge**.
+- Book 5-sleeve: HOLD 2.44 → 2.34 mediana (min 2.22), FULL 2.24→2.22 → eredita **~+0.10** di
+  fortuna d'ancora (non +0.25: il peso di TP01 diluisce). Nessuna decisione (GTAA/SKH/pesi) cambia.
+- NON toccati: tutti i FULL (h=0 al 31° pctl = normale), plateau, deflated-Sharpe, fee-sweep,
+  causalità, validazione GTAA (equity OOS), gate weights_tilt_null (relativo).
+
+**Raccomandazione operativa (sottoscritta dallo scettico): cambio di narrativa e di standard di
+reporting, NESSUN cambio del book live oggi.** (1) I numeri hold-out di TP01 si citano d'ora in poi
+come banda d'ancora (mediana ~0.04, [−0.13,+0.30]) con valore = taglio DD; (2) valutazione
+anchor-agnostic (media 24 ancore) come lens di reporting per i futuri hold-out; (3) NO deploy
+K=2/K=4 a $600: guadagno ≈ 0, e a $225/asset di quota TP01 i delta per-ancora (~$1-2) sono sotto il
+min-order $5 → degenererebbe comunque in K=1; inoltre le ancore intraday richiederebbero un feed
+fresco fuori dal path certificato (staleness ×4 finestre di guasto). **Rivalutare K=2 (0,12) a
+capitale ≥ ~5-10k.** (4) ⚠️ Audit analogo RACCOMANDATO su XS01 (rebalance 10g ancorato = spazio di
+luck 10g×24h, potenzialmente peggiore) e SKH01 (fase griglia 230m/690m) — TP01 è oggi l'unico
+sleeve de-luckato.
+
+## Filone 4 — Clock lenti + banded rebalancing: FAIL (negativo utile)
+
+`scripts/research/r0702_slow_clock.py`. Fatto a monte che chiude il filone: il fee drag di TP01 a
+1d è **~0.40%/anno ≈ 0.03 Sharpe** (8 turnover/y × 0.10% RT) — il tetto di QUALSIASI risparmio.
+- Clock N∈{2,3,5,7}g: degrado monotono dell'ensemble di fase (HOLD 0.34→0.11 da N=2 a N=7); lo
+  spread TRA fasi esplode a N≥5 (HOLD −0.19…+0.37 a N=7) = timing luck pura, coerente col filone 3.
+- Bande di isteresi {2.5,5,10,20}%: tagliano il 77-94% degli ORDINI ma quasi zero TURNOVER (gli
+  ordini di TP01 sono micro-aggiustamenti del vol-target). Cella best-IS (band 20%): hold-out
+  0.13 vs 0.30 baseline, e il "guadagno" IS è effetto-segnale (posizioni stantie fortunate), non
+  effetto-costo → fitting. Non-monotonia sulla griglia = firma di rumore.
+- **Finding utile per il live: a $600 il vincolo min-order $5 È GIÀ la banda ottimale** (ordini
+  427→111/y a costo Sharpe ~0, banda implicita 1.67%): cattura ~100% del risparmio catturabile.
+  Nessun cambio al book, a nessun capitale testato (600/2k/10k).
+
+## Filone 5 — Velocità del trend regime-condizionata: FAIL
+
+`scripts/research/r0702_regime_speed.py`. Pesi tra gli orizzonti TSMOM 30/90/180g condizionati al
+percentile espandente di vol (realized e DVOL), 16 celle, sanity = riproduzione esatta del canonico.
+- Cella best-IS (alta-vol→lento, linear, rv): FULL +0.06 ma **HOLD BTC −0.31**, 50/50 +0.005 →
+  dominanza fallita; multi-cut a segno instabile (+0.18/−0.08/+0.00).
+- Null decisivo (300 pesi statici Dirichlet): la cella sta al pctl 0.71-0.72, sotto il p90 —
+  un peso statico casuale la batte spesso. Meccanismo smascherato: corr(peso-30d, Sharpe) = +0.93 →
+  le celle "regime" vincono in-sample perché tengono il tilt-30d la maggior parte dei giorni =
+  **tilt statico travestito da regime**, la stessa trappola di EW-STR. E il tilt statico verso il
+  30d NON regge su BTC hold-out (−0.15). RV e DVOL indistinguibili come misura di regime (coerente
+  con l'esito overlay DVOL 2026-06-26). Pesi canonici 1/3-1/3-1/3 confermati.
+
+## Filoni 6-8 — CRT "Candle Range Theory" (base / multi-TF / contesto): FAIL 3/3
+
+Il pattern sweep-and-reclaim a 3 candele (C1 range forte; C2 rompe un estremo ma chiude dentro =
+"manipolazione"; C3 ingresso contro il breakout, stop dietro lo sweep, target all'estremo opposto),
+meccanizzato onestamente in tre tagli. Overlap dichiarato: MRV01-11 e MIC07 non coprivano questa
+meccanica; ora è coperta.
+
+**6. Base single-TF** (`r0702_crt_base.py`, 864 trial su 1h/4h/12h/1d, motore trade-level
+conservativo SL-first cross-checkato con l'harness): **DSR 0.000** (il null best-of-grid atteso è
+Sharpe 2.27, ottenuto 0.74); cella best-IS (4h long color-rule) IS 0.90 → HOLD 0.07 con 2026 a
+WR 0%; anchor-shift +1/+2h flippa l'hold-out a −1.0 (artifact-risk); lo **short su sweep dell'alto
+(la narrativa smart-money canonica) perde perfino in-sample (−0.59)**. Autopsia: l'expectancy IS
+veniva dal time-exit in trend (beta del toro ETH 2021-23), non dal target strutturale. Dettaglio
+informativo: CRT batte nettamente sia il fade incondizionato (IS −0.49) sia il breakout-confermato
+(IS −0.31) → il close-back-inside FILTRA davvero tossicità, ma "meno tossico del fade morto" non è
+un edge.
+
+**7. Multi-timeframe** (`r0702_crt_mtf.py`, 4h→15m e 1h→5m, ~10k trade): expectancy netta negativa
+OVUNQUE (FULL e HOLD, entrambi gli asset); il MTF alza il R:R medio da ~3 a ~10-20 ma il WR collassa
+da ~36% a 9-16% → "migliora" solo perdendo meno. **Refutazione strutturale: il ritest è informazione
+negativa** — pattern CON ritest −40 bps, SENZA +52 bps (non tradabile: condiziona sul futuro):
+aspettare il ritest per entrare seleziona sistematicamente i pattern peggiori; i buoni scappano
+subito e il metodo non li prende mai. A fee ZERO l'edge lordo è ~0 (non è morte per fee: non c'è).
+Stop 0.1-0.35% ineseguibili col cron orario (26-75% dei segnali già invalidati all'esecuzione).
+
+**8. Contesto** (`r0702_crt_context.py`, 22 trial: livelli prevday/Donchian/prevweek × equal-H/L ×
+FVG × sessioni): baseline incondizionata morta (8/8 celle HOLD<0); FVG semmai peggiora; sessione
+EU consistentemente negativa; unica cella IS-positiva (sweep in Asia su livello prevday) uccisa 4
+volte (DSR 0.001, anchor-flip a −2/−4h con la firma di open_drive — la sessione "Asia" inizia dove
+il livello prevday viene ricreato —, solo-ETH, morta a 0.20% fee). **Sottoprodotto prezioso: sugli
+STESSI livelli prior-day, FOLLOW batte FADE ogni singolo anno 2019-2026** (follow IS/HOLD
++1.22/+1.25 vs fade −0.66/−1.46, corr −0.19/−0.27) → conferma indipendente e rafforzativa del lead
+prevday-breakout in forward-monitor (paper_prevday).
+
+**Verdetto CRT: concetto Wyckoff riverniciato che, spogliato della discrezionalità, non contiene
+edge su BTC/ETH Deribit certificati. La direzione giusta sui livelli affollati resta il FOLLOW
+(breakout), non il fade — coerente con SKH01 (breakout) vivo e mean-reversion morta.**
+
+---
+
+## Lezioni codificabili
+
+1. **Il timing-luck dell'ancora è una dimensione di multiple-testing NON coperta dai gate
+   esistenti** (deflated-Sharpe conta i trial, non le ancore implicite). Nuova regola di reporting:
+   ogni metrica hold-out di una strategia a ribilanciamento ancorato si cita con la banda d'ancora
+   (o la media anchor-agnostic). Candidato gate futuro: `anchor_luck_band()` in altlib. Audit
+   pendente: XS01 (10g), SKH01 (fase 230m/690m).
+2. **La famiglia day_boundary_robust / anchor-shift continua a uccidere** (CRT base, CRT-Asia,
+   6/24 celle expiry): ogni effetto legato a etichettatura di barre VA spostato d'ancora prima di
+   crederci. Confermata la regola 2026-06-21.
+3. **Il fee drag di TP01 (~0.4%/anno) non è un problema da risolvere** — chiude a priori il filone
+   "esecuzione più furba" a questo turnover; il min-order small-cap è già la banda ottimale.
+4. Il pitfall pandas tz-aware/epoca (2026-07-01) è stato evitato/gestito 2 volte su 9 agenti grazie
+   alla documentazione in CLAUDE.md — il costo di documentare i bug paga.
+
+## Stato finale
+
+- 0 nuovi sleeve; portafoglio e book live INVARIATI (5-sleeve 33/15/12/20/20; book Deribit
+  TP01+SKH01 75/25, flat da armamento — il segnale resta risk-off).
+- Narrativa TP01 aggiornata (CLAUDE.md + docstring): hold-out = banda d'ancora, valore = difesa DD.
+- Script: `scripts/research/r0702_{eventclock,expiry_calendar,tp01_offset,slow_clock,regime_speed,
+  crt_base,crt_mtf,crt_context,skeptic_offset}.py`. Test suite: invariata, verde.

docs/diary/2026-07-03-book-frontier.md

@@ -0,0 +1,111 @@
+# 2026-07-03 — Frontiera rischio/rendimento del book: quanto caldo correre a 2k-5k
+
+**Contesto.** Dopo la diagnosi strategica ("€50/g è un problema di capitale e di frontiera, non di
+alpha; hai costruito una macchina difensiva a DD 6% ma hai capitale piccolo e obiettivo di
+crescita"), goal: **misurare** (non cercare segnali) la frontiera CAGR/DD/P-rovina in funzione del
+target-vol, pesata per confidenza per-sleeve, a €2k e €5k — per decidere quanto caldo girare il book.
+Workflow: 3 filoni (curva / onestà-della-coda / eseguibile+Kelly), refuter fat-tail su ciascuno,
+scettico sintetizzatore. 7 agenti, 0 errori. Sanity bit-exact di entrambi i book prima di ogni numero.
+
+**Scripts:** `scripts/research/r0703_frontier_{curve,tail,exec}.py`. Nessun file di produzione
+toccato, nessun commit dagli agenti, `config/live.json` NON modificato (cap solo proposto).
+
+---
+
+## Verdetto in una riga
+
+**La tesi "corri più caldo" era in gran parte un MIRAGGIO DI REGIME.** Il "~6% attuale" non è un
+target scelto: è la vol *realizzata* in regime risk-off (TP01 spesso flat 0.0x → il conto è flat
+*by design*). A lambda=1 il book LIVE a 2 sleeve gira **già a ~11% vol / 9.4% DD**. Quindi "saltare
+da 6% a 10%" NON è aggiungere leva — è solo assumere che il book non sia risk-off. **Il numero
+onesto è: gira alla vol NATIVA (~10%, banda 8-11%), non levare.** Guadagno reale vs il 6% risk-off:
+**+€0.2/g @2k, +€0.5/g @5k** — reale ma modesto, comprato con un DD plausibile di ~€500 su €2k. €50/g
+resta ~130k, invariato.
+
+---
+
+## I numeri (frontiera fidata, non full-Sharpe)
+
+Sanity (deriva nulla): 5-sleeve FULL Sh **2.238** / HOLD 2.452 / DD 6.17% / vol nativa 7.84%;
+2-sleeve live FULL Sh **1.776** / HOLD 1.162 / DD 9.42% / vol nativa 10.96%.
+
+**Scale-invarianza confermata da tutti e 3 i refuter:** il capitale NON cambia la matematica del
+target-vol (le tabelle sono in %), cambia solo l'ESEGUIBILITÀ → **stesso % a 2k e 5k.**
+
+### Book LIVE 2-sleeve (TP01+SKH01) — l'unico eseguibile <20k
+- **Target-vol raccomandato: ~10%, banda [8%, 11%], lambda ≈ 0.9.** Sopra la vol nativa non si va.
+- €/giorno al punto fidato (haircut): CAGR full-sample 12.9% → €0.71@2k / €1.77@5k; ma **HOLD-onesto**
+  (de-luck) CAGR ~4.5% → **€0.25@2k / €0.62@5k**. Il lato-reward headline è ~3× l'onesto (HOLD≪FULL).
+- **Stima centrale onesta: €0.3-0.7/g @2k, €0.8-1.8/g @5k.**
+
+### Book PIENO 5-sleeve — ASPIRAZIONALE, non gira <20k
+Frontiera fidata regge ~12-15% sotto tail estremo, ~20% sotto tail mite — ma XS01 serve ~20k e VRP01
+è modellato → rilevante solo per il tracking di `paper_combo`, non per una decisione di deploy a 2-5k.
+
+---
+
+## I quattro insegnamenti strutturali
+
+### 1. La rovina-50% è la metrica SBAGLIATA (trappola esposta dal curve-refuter)
+P(rovina-50%|5y) resta <1% fino a ~20-22% di target-vol su ogni book — i book sono troppo lisci/
+diversificati per bruciare metà capitale entro la distribuzione campionaria. **La risposta letterale
+"max CAGR a P(rovina)<1%" direbbe "gira al 22%" — ed è un suicidio**: lì P(DD>30%|5y) ≈ 20-25%. Il
+vincolo che MORDE è **P(DD>30%), super-lineare** (raddoppia ~ogni 2.5 punti di vol). E la rovina-50%
+non è nemmeno robusta ad alta vol (block-15 vs block-20 danno 7.1% vs 0.9% a tv30%) → altro motivo
+per stare bassi.
+
+### 2. Il muro fat-tail ONESTO è ~12%, più basso della carta (~15%)
+Tre ragioni che il modello sottostima: **(a) gap-through-stop SKH già osservato reale** (sl2%
+modellato → −11/−23% realizzato — la coda vera NON è nei rendimenti modellati; l'iniezione dei
+finder usava lo *clean-stop* → ~2× troppo mite); **(b) il 2-sleeve è 4× più crash-sensibile del
+5-sleeve** (+14.5pt vs +3.5pt di P(DD>30) all'iniezione, diversificazione sottile); **(c)
+vol-targeting a lambda costante lagga nello spike** → sei più levato *entrando* nel crash.
+**LIVE 2-sleeve: non superare ~12%; mai 15-20%** (triplica il DD-in-euro senza margine di coda).
+
+### 3. Aggressività differenziata-per-confidenza (TP01 più caldo di VRP) — REFUTATA
+La mia proposta era intuitiva ma **sbagliata, e i numeri lo dicono netto**: differenziare la vol per
+confidenza PEGGIORA la frontiera (5s Sharpe 2.24→2.11, 2s 1.78→1.69) perché **taglia la
+diversificazione** di VRP/XS (corr uniforme-vs-differenziato 0.98-0.99). **Regola corretta: la bassa
+fiducia sull'EDGE si esprime DE-MEANando lo sleeve in aspettativa (= la frontiera haircut), NON
+riducendone l'esposizione/vol.** La confidenza vive nell'haircut della media, non nella leva. Tutti
+gli sleeve alla stessa leva.
+
+### 4. La diversificazione LIMA la coda sinistra in-sample (sorpresa onesta)
+Per il 5-sleeve ben diversificato il block-bootstrap dà P(DD>30) SOTTO il Gaussiano iso-vol (30%:
+10.6% reale vs 21.1% gauss) — la coda in-sample è benigna. Il segnale fat-tail vive in due posti:
+l'**iniezione di crash sintetico** (il campione non contiene il crash peggiore di ogni sleeve) e
+il **book live sottile** (2 gambe, drift haircut) dove il bootstrap SUPERA il Gaussiano. Cioè: la
+frontiera è affidabile finché il futuro somiglia al passato campionato, e fragile esattamente dove
+le storie sono corte (VRP mai stressato reale, XS 2.5y, nessun 2018/pre-2018).
+
+---
+
+## Azione concreta (proposta, NON applicata)
+
+1. **Nessun cambio di leva sul codice.** Il book gira già ≈ al punto fidato: LASCIARE `target_vol=20%`
+   di TP01 (canonico, la vol nativa del book emerge a ~8-11%). Non c'è una leva da girare su.
+2. **⚠️ L'UNICO cambio che conta: `config/live.json` `max_notional_per_asset_usd` da $300 a
+   equity/2** ($1000@2k / $1750@3.5k / $2500@5k). Senza, il cap $300 tappa la vol raggiungibile a
+   13%@2k / 8%@3.5k / **6%@5k** → **throttling paradossale: più capitale = book più freddo**, forzato
+   sotto il punto fidato. Da applicare AL deposito. (config NON toccato ora.)
+3. `min_order_usd=5`: LASCIARE (banda d'isteresi gratuita). Tranching K=2: NON cablare. Vol
+   differenziata: NON implementare (Q3).
+
+---
+
+## Brutalità sui limiti
+
+- **Storie corte = il difetto strutturale.** TP01/SKH dal 2019 (no 2018), VRP dal 2021, XS **2.5
+  anni** (no 2022). Il block-bootstrap non può campionare un crash mai visto; l'iniezione sintetica
+  è l'unico proxy, e quella dei finder era ~2× troppo mite.
+- **VRP01 è MODELLATO** (f-di-stress mai catturato su un crash reale) → l'haircut −50% è stima, non
+  misura; resta STAT-MODE anche a 5k (regola: niente short-vol da modello in deploy).
+- **HOLD ≪ FULL sul book live** (1.78 vs 1.16) → il lato-reward headline è in gran parte artefatto
+  full-sample; citare i €/g su base HOLD-onesta.
+- **€50/g NON è risolto e non lo sarà da questo.** Il warm-up compra ~€0.2/g@2k. La via resta
+  **capitale + tempo**; la regola "niente leva alta come base" è rispettata (la raccomandazione è
+  "gira alla vol nativa", non "corri caldo").
+
+**Numero unico da portare a casa:** book LIVE a **~10% target-vol (lambda ≈ 0.9, banda 8-11%)**,
+uguale a 2k e 5k, con **cap → equity/2** come unica azione config; muro invalicabile a **~12%**;
+guadagno reale vs il 6% risk-off ~**+€0.2/g@2k / +€0.5/g@5k** — reale ma modesto.

docs/diary/2026-07-03-cap-dynamic.md

@@ -0,0 +1,47 @@
+# 2026-07-03 — Cap notional per-asset DINAMICO (= equity/2): operazionalizza la decisione frontier
+
+**Contesto.** La frontiera del 2026-07-03 (`docs/diary/2026-07-03-book-frontier.md`) aveva identificato
+**una sola** azione config con impatto reale: portare `max_notional_per_asset_usd` da $300 fisso a
+**equity/2**, perché il cap fisso strozza il book man mano che si deposita (paradosso: più capitale =
+book più freddo — a $5k il cap $300 fa girare il libro al ~49% del target). Il diario la lasciava
+"da applicare AL deposito". Qui la **operazionalizzo in codice** rendendo il cap dinamico, così è
+sempre corretta e non richiede un edit manuale al deposito.
+
+## Cosa è cambiato
+
+- **`src/live/book.py` — `_cap()`**: se in config c'è `max_notional_per_asset_frac` (opt-in), il cap
+  per-asset diventa **`equity × frac`** (0.5 → equity/2). Senza la chiave → comportamento vecchio
+  (cap fisso `max_notional_per_asset_usd`). Il call site in `book_report()` passa
+  `equity`, `real_equity`, `eq_fallback` a `_cap()`.
+- **`config/live.json`**: aggiunto `max_notional_per_asset_frac: 0.5` (+ nota). `max_notional_per_asset_usd`
+  resta come **cap fisso di fallback**.
+- **`tests/test_book_live.py`**: +4 test (scaling con equity fidata, fallback su eq_fallback/real=None/
+  equity 0, no-frac, integrazione online). Suite: **172 passed**.
+
+## Il guardrail di sicurezza (il punto delicato)
+
+Il cap dinamico si usa **SOLO con equity reale fidata** (letta dal conto). Se l'equity reale non è
+leggibile — `eq_fallback` attivo, `real_equity=None`, offline, o equity ≤ 0 — si **torna al cap fisso
+$300**. Motivo: in fallback `equity` è il paper-cap ($2000 ipotetico); calcolare `equity/2 = $1000` su
+un conto di importo reale **ignoto** sizerebbe troppo. Preserva esattamente la protezione downside che
+il test `test_book_execute_eq_fallback_warns_but_proceeds` verificava (l'hard-cap $/asset protegge
+quando E è ignota). Regola: **equity/2 solo quando ci fidiamo di E; altrimenti $300 fisso.**
+
+## Verifica
+
+- **Live dry-run reale** (nessun `--execute`, nessun ordine): `cap/asset **$299**` = $598.06/2 →
+  **INERTE** oggi (≡ vecchio $300). Book flat, HOLD.
+- Offline / `equity_override`: cap resta **$300 fisso** (nessuna equity reale da fidarsi) → il test
+  di parità pre-esistente regge invariato.
+- A $5.000 di equity il cap diventerebbe automaticamente **$2.500** (equity/2), rimuovendo il
+  throttling che la frontiera aveva quantificato.
+
+## Impatto e limiti
+
+- **Già attivo**: il cron orario (`cron_book.sh`) esegue dal working tree → il prossimo run legge già
+  `frac=0.5`. Nessun deploy separato. **Inerte a $600**, si "accende" da sé quando l'equity cresce.
+- **NON avvicina €50/g**: la frontiera lo aveva già detto — è una miglioria marginale (+€0.2/g @2k,
+  +€0.5/g @5k), il cui unico scopo è non lasciare capitale futuro strozzato. €50/g resta un problema
+  di **capitale + tempo** (~130k @ CAGR onesto), non di questo cap.
+- Nessun cambio di **leva** (TP01 `target_vol=20%` invariato, la vol nativa ~10% emerge da sola —
+  coerente col verdetto frontier "gira alla vol nativa, non levare").

docs/diary/2026-07-03-stato-completo-progetto.md

@@ -0,0 +1,156 @@
+# 2026-07-03 — STATO COMPLETO DEL PROGETTO (snapshot)
+
+Foto d'insieme dopo le ondate di ricerca del 1-3 luglio 2026 (timing/CRT, anchor-audit,
+video-claims Elliott/Albimarini, capital-scaling, migliora-e-proteggi VRP01). Serve come punto di
+riferimento unico: *dove siamo, cosa gira, cosa è provato, cosa resta aperto.*
+
+---
+
+## 1. In una frase
+
+Progetto post-reset v2.0.0: su dati Deribit mainnet certificati (solo BTC/ETH) abbiamo costruito un
+**portafoglio di 5 strategie diversificate** (research Sharpe ~2.2, DD ~6%), di cui **2 sono
+eseguite live su Deribit** in un book nettato in software. Il conto reale è **~$598, flat** perché
+il segnale trend è risk-off. Il valore delle strategie è **difensivo** (taglio del drawdown), non
+generazione di ritorno: il target €50/giorno resta lontano (serve ~130k di capitale). L'onestà
+metodologica è il vero asset accumulato: ~10 gate anti-illusione codificati, decine di edge
+falsificati.
+
+---
+
+## 2. Il book LIVE (soldi reali)
+
+- **Conto:** Deribit mainnet, USDC linear, **equity reale $598.06** (NON i €2000 nominali del paper).
+- **Cosa gira:** `deribit_book_sleeves` = **TP01 (0.75) + SKH01 (0.25)** nettati in software su un
+  solo conto; UN ordine con segno per asset (BTC, ETH). `config/live.json`
+  **`execution_enabled=true`** → esecuzione ARMATA e reale.
+- **Cadenza:** cron ORARIO `scripts/cron_book.sh` → `scripts/live/book_execute.py` (SKH01 decide su
+  griglia 230m; exit software, latenza fino a fine barra).
+- **Guardrail:** cap **$300 notional/asset**, min order $5, **disaster-SL on-book −30%** sulla
+  posizione netta, alert Telegram su esecuzione/errori, gate fail-safe su posizione/equity non
+  leggibili (non opera a cieco).
+- **Stato corrente (ultimo cron 2026-07-03 07:00Z):** BTC e ETH **flat, HOLD a target** — il target
+  TSMOM è risk-off (trend 0.0x) e SKH01 è flat (nessun breakout) → **zero ordini reali mai eseguiti**
+  da quando è armato (2026-06-23): il conto è flat *by design*, non per un errore.
+- **NON nel book live:** XS01, VRP01, GTAA01 (research/paper/STAT-MODE).
+
+## 3. Il portafoglio RESEARCH (5 sleeve) — `src/portfolio/sleeves.active_sleeves`
+
+| Sleeve | Peso | Meccanismo | Dati | Stato |
+|---|---|---|---|---|
+| **TP01** | 33% | TSMOM difensivo trend BTC/ETH 1d, long-flat, vol-target 20% | 2019→ | **Deploy pieno** (nel book live) |
+| **SKH01** | 20% | Dual-TF regime+breakout BTC/ETH, L/S, exit %-asimmetrici | 2019→ | Research → nel book live |
+| **GTAA01** | 20% | Trend difensivo equity 6-ETF (IB), ~30 anni storia | 1996→ | Paper (paper_combo) |
+| **VRP01** | 12% | Options short-vol (put credit spread + gate IV-rank) | 2021→ | LEAD modellato (STAT-MODE) |
+| **XS01** | 15% | Cross-sectional momentum 19 alt Hyperliquid | 2024→ | STAT-MODE (serve ~20k) |
+
+- **Combinato (research, ancore canoniche):** FULL Sharpe **2.24**, HOLD-OUT **2.46**, DD full **6.2%**.
+- **⚠️ Stima DE-LUCKATA onesta** (dopo gli anchor-audit, vedi §5): **HOLD ~1.9-2.1, FULL ~2.0-2.2,
+  DD ~6%**. Il 2.46 è un massimo di configurazioni d'ancora, non la stima centrale.
+- Sleeve a date d'inizio diverse → outer-join con pesi rinormalizzati (`combine_outer`).
+- Report: `scripts/portfolio/run_portfolio.py`. Il book live (TP01+SKH01 75/25) è un sottoinsieme.
+
+## 4. Paper trader / forward-monitor attivi (nessun soldo reale)
+
+- **paper_trend** — TP01 1d, capitale nominale 2000, forward-only.
+- **paper_combo** — book 5-sleeve completo (incl. GTAA/VRP/XS) dal 2026-06-22.
+- **paper_statarb** — STATARB-RESID (ETH−β·BTC residual momentum, W=45/sgn=+1 congelati), doppio
+  libro MODELED/REAL-$600. LEAD eseguibile a $600 sotto soglia solo sull'edge (DSR 0.929).
+- **paper_prevday** — FOLLOW prior-day levels (3 trade registrati); confermato indipendentemente da
+  più ondate (FOLLOW > FADE ogni anno 2019-26).
+
+---
+
+## 5. Finding strutturale del blocco 1-3 luglio: ANCHOR TIMING-LUCK (audit COMPLETO 4/4)
+
+Le strategie a ribilanciamento/griglia ancorata hanno un'ancora "canonica" che è spesso il
+**migliore** di molte configurazioni equivalenti (giorno/ora/offset) — un multiple-testing che il
+deflated-Sharpe NON conta. Audit eseguito su tutti e 4 gli sleeve ancorati:
+
+| Sleeve | Spazio d'ancora | Firma | Conseguenza |
+|---|---|---|---|
+| **TP01** | 24 ore (barra daily) | canonica = migliore (P=0.86) | hold-out 0.31 non risolve l'edge di ritorno; regge solo il taglio DD |
+| **XS01** | 10 fasi (ciclo 10g) | canonica al 15° pctl di DD | numeri headline conservativi sul DD, non sull'hold-out |
+| **SKH01** | 23 offset (griglia 230/690m) | canonica = 93-98° pctl (peggiore firma) | gate DD<30% fallisce in 15/23 offset; ~+0.5 HOLD di fortuna sul book |
+| **VRP01** | 7 giorni (ciclo settimanale) | **canonica = PEGGIORE** (7° pctl) | **numeri CONSERVATIVI**, non gonfiati — unico sleeve senza luck |
+
+**Regola codificata:** i numeri hold-out di strategie ancorate si citano **con banda d'ancora**.
+Candidato gate futuro: `anchor_luck_band()` in altlib. Diari: `2026-07-02-timing-crt-wave.md`,
+`2026-07-02-anchor-audit-xs01-skh01.md`, `2026-07-03-vrp-improve-dd.md`.
+
+---
+
+## 6. Cosa è PROVATO e MORTO (per non ri-testarlo)
+
+- **Soffitto BTC/ETH-direzionale ~1.3** confermato da ogni ondata; superato solo dal cross-sectional
+  (XS01) e dalla diversificazione multi-sleeve.
+- **Sweep 104 famiglie** (2026-06-20): 1 sola sopravvissuta, comunque non deployabile.
+- **Opzioni long-vol** (gamma scalping): specchio del VRP, perde ogni anno/variante/frequenza.
+- **Cash-and-carry (CC01):** premio reale ma Sharpe artefatto (manca il 2022, procyclico) → STAT-MODE.
+- **Timing/clock alternativi** (event-clock, expiry calendar, clock lenti, regime-speed): 0 edge.
+- **CRT "Candle Range Theory"** (3/3 FAIL): DSR 0.000, expectancy negativa anche a fee zero, il
+  ritest è informazione negativa; sui livelli prior-day FOLLOW > FADE.
+- **Elliott (3/3 FAIL):** range-cycle = rumore; Fibonacci = effetto posizione non numeri magici;
+  canale = Donchian travestito.
+- **Albimarini double-diagonal (2/2 FAIL):** non domina il condor, fee-negativa su Deribit, track
+  record consistente con zero skill (P=20-45%), rovina nei replay con code reali.
+- **VRP01 miglioramenti (0/7 filoni):** struttura, overlay-DD, gate nuovi (4° fallimento), sizing,
+  gate SPX (confound di modello) — **VRP01 non migliorabile; la protezione DD si compra con la size.**
+
+## 7. Regole/gate anti-illusione codificati (l'asset metodologico)
+
+- **Certificazione dati** obbligatoria (solo Deribit mainnet, BTC/ETH; alt esclusi).
+- **`marginal_vs_tp01` / `study_marginal`** (earns_slot) — Sharpe MARGINALE, non assoluto.
+- **`study_family_honest` / `select_cell_insample` / `deflated_sharpe≥0.95`** — anti selection-on-holdout.
+- **`day_boundary_robust`** — effetti calendario che si invertono spostando il confine = artefatto.
+- **`eval_weights_smallcap`** — Sharpe haircut reale a capitale piccolo (sub-min-order = finzione).
+- **`weights_tilt_null`** — ogni cambio pesi vs null dei tilt casuali cap-respecting.
+- **Banda d'ancora** (nuova, luglio) — per ogni costrutto ancorato.
+- **Candidati in coda:** `anchor_luck_band` (multiple-testing d'ancora); `implausible_sharpe`
+  (0-perdite / Sharpe implausibile — 3 occorrenze: CC01, ALB-A, griglia struttura VRP).
+- **Lezioni pandas:** mai `DatetimeIndex.view("int64")` su tz-aware; `resample("7D", origin=)`
+  ignora origin (usare `"168h"`); un gate che si correla con un errore di modello è indistinguibile
+  da alpha finché non correggi il modello.
+
+---
+
+## 8. Onestà sui numeri e sul target
+
+- **€50/giorno da €1.000-2.000 NON è raggiungibile** in 1-2 anni: serve ~130k di capitale o un DD da
+  rovina. La leva non è la scorciatoia (5x raddoppia il DD). La via è target-vol + capitale + tempo.
+- Aspettativa onesta col CAGR de-luckato del book (10-15%): **~€0.6-0.8/giorno a 2k, ~€1.4-2/giorno
+  a 5k**. Il salto di capitale cambia *cosa è eseguibile*, non l'ordine di grandezza del ritorno.
+- Il valore reale di TP01/del book è il **taglio del drawdown ~6× vs buy&hold**, non l'alpha.
+
+## 9. Capitale in arrivo 2-5k — cosa cambia (audit r0702_capital_scaling)
+
+- **Unico vincolo binding: il cap `max_notional_per_asset_usd=300`.** A 5k il book live girerebbe al
+  ~49% del target. **Azione pendente sul deposito: alzare il cap a equity/2** ($1000/$1750/$2500 a
+  2k/3.5k/5k). `min_order_usd=5` da lasciare.
+- Tranching K=2: matematicamente regge a 5k ma serve feed intraday fuori path certificato → non cablare.
+- Opzioni ETH eseguibili da ~2.6k (spread), ma **la regola "niente short-vol da modello in deploy"
+  non decade col capitale**. XS01 resta fuori fino a ~20k. CC01 fuori per struttura.
+- ⚠️ Disambiguazione unità: il "12%" come peso book (~0.014 Kelly) ≠ "12%" come margine/equity
+  (~0.27 Kelly) — **fattore 19x**.
+
+## 10. Aperto / prossimi passi
+
+1. **Al deposito 2-5k:** alzare il cap $/asset (proposta pronta, `config/live.json` non ancora toccato).
+2. **Forward-monitor da maturare:** paper_statarb (edge sotto soglia DSR), paper_prevday (FOLLOW),
+   paper_combo (book completo). Se la finestra forward conferma STATARB-RESID → deployabile a 2 gambe.
+3. **Gate da codificare:** `anchor_luck_band`, `implausible_sharpe`.
+4. **Rivisite temporizzate:** term-structure DVOL (logger dal 2026-06-26, rivalutare a 6-12 mesi);
+   breadth/internals HL (1-2 anni di storia nativa); tranching a ≥5-10k; VRP stress-f su un crash reale.
+5. **Ricerca strategie nuove:** il soffitto direzionale ~1.3 è saturo; i margini restano in meccanismi
+   ORTOGONALI (cross-sectional, relative-value, options gated) e nella diversificazione, non in nuovi
+   segnali direzionali BTC/ETH.
+
+---
+
+## 11. Stato tecnico
+
+- **Versione:** 2.0.0 (semver in `VERSION`). **Test:** 168 verdi (28 file). **Diari:** 76.
+- **Ultimi commit:** `26f8d27` (migliora+proteggi VRP01), `76120b5` (video-claims + capital-scaling),
+  `a74cc69` (anchor-audit XS01/SKH01), `e6657fc` (GTAA01 5° sleeve).
+- **Working tree pulito, tutto pushato.** Book live sano e invariato da tutta la ricerca (research
+  isolata: nessun agente tocca src/config/live).

docs/diary/2026-07-03-vrp-improve-dd.md

@@ -0,0 +1,167 @@
+# 2026-07-03 — Ondata "migliora e proteggi VRP01 dai DD" (7 filoni + verifica a 2 lenti + scettico incrociato)
+
+**Contesto.** Dopo la chiusura del dossier Albimarini (3 backtest indipendenti convergenti: premio
+piccolo e reale, code non campionate, numeri del corso spiegabili al 100% dalla struttura del
+payoff), goal esplicito: **migliorare la strategia short-vol** — la famiglia Albimarini → il nostro
+**VRP01**, l'unica forma sopravvissuta agli audit — **e proteggerla dai drawdown**, con
+orchestrazione a decine di agenti. Workflow deterministico: 7 filoni di ricerca in parallelo, 2
+refuter avversariali (lente selection-bias + lente de-levering) su ogni miglioramento proposto,
+scettico incrociato finale sui sopravvissuti. **26 agenti, 0 errori.**
+
+**Scripts:** `scripts/research/r0703_vrpimp_{structgrid,ddoverlay,sizing,newgates,anchor,spxgate,stresslab}.py`.
+Nessun file di produzione toccato, nessun commit dagli agenti. Motore riusato: `r0702_alb_structure.py`
+(DVOL, riproduce VRP01 bit-exact: baseline bridge max|diff|=0.00e+00 su 266 settimane).
+
+---
+
+## Verdetto in una riga
+
+**VRP01 non è migliorabile oltre lo status quo, e la protezione DD si compra SOLO con la size.**
+Zero nuovi sleeve, zero overlay che reggono, zero gate nuovi, zero cambio di sizing. I due unici
+"sopravvissuti" alla verifica **non propongono alcun cambiamento** (una conferma dello status quo +
+una lente di misura). Il candidato più luccicante dell'ondata — un gate term-structure VIX su SPX
+con ΔSharpe +0.90 e DSR 0.992 — è stato smontato dallo scettico come **confound di modello al
+100%**. Deliverable reale = **audit anchor-luck di VRP01 CHIUSO** (ultimo sleeve ancorato): la fase
+canonica è all'estremo **conservativo** della banda, quindi i numeri di ammissione reggono e da ora
+si citano con banda.
+
+---
+
+## I 7 filoni
+
+### 1. Griglia di struttura (288 celle) — NESSUNA batte VRP01
+6 strutture (vertical put/call, condor, 3 diagonali) × distanza {1,1.5,2,2.5}σ × ali {0.5,1,2}σ ×
+tenor {3,5,7,10}g, gate IV-rank canonico sempre attivo. La cella scelta col **solo in-sample**
+(DIAG-PUT z=1.0 3g, ShIS 2.28) crolla in hold-out a **+0.19** vs 0.86 del bridge stesso-motore;
+DSR 0.000/0.004 su 288 trial; multi-cut negativo a 3-4 cut su 4; banda d'ancora che non tiene
+nemmeno il segno (ShH [−0.21,+0.64]). **Metà griglia (150/288) è il pattern "0-perdite = Sharpe
+implausibile"** (celle z≥2 lunghe, 0 perdite su ~97 trade, ShH fasulli 4-6.5) — **terza occorrenza
+dopo CC01 e ALB-A**. Quarta conferma indipendente: nel VRP l'alpha sta nel gate di regime + nella
+zona ~δ-0.28 dove la coda è campionata, non nella geometria.
+
+### 2. Overlay di protezione DD (14 celle) — 4/4 REFUTED (2 lenti ciascuno)
+(a) exit intra-settimana su spike DVOL, (b) stop-loss MTM, (c) ala di coda comprata (broken-wing),
+(d) cooldown post-perdita. **Nessuno batte il null del de-levering** a pari maxDD su tutta la banda
+f; nessuno passa multi-cut (max 1/4) né DSR (0.70-0.88, tutti <0.95). Esempio decisivo: SL MTM 3x fa
+DD 7.9%/worst −5.7%, ma VRP01 × 0.66 (semplice riduzione di size) fa lo **stesso DD a Sharpe
+invariato e worst-week migliore (−4.9%)**. Meccanismo confermato: i trigger di spike scattano solo
+2-3 volte in 5 anni **perché il gate IV-rank/crash-skip evita già gli ingressi vicino alle
+esplosioni di vol** — la protezione crash vive nel gate d'ingresso, non serve un overlay a valle.
+Coerente con TP01×DVOL (2026-06-26): "per meno DD la leva è la size, non un overlay".
+
+### 3. Sizing anti-rovina — CONFERMA (12% ≈ quarter-Kelly), 1 candidato REFUTED
+Il sizing non crea alpha (Sharpe del flusso invariante ~0.95 a ogni frazione). Frontiera onesta
+CAGR-DD-P(rovina) mappata su 92 trade gated ETH 2021-26 (pooled banda-f + coda sintetica full-loss):
+Kelly onesto q*=44% → il **12% del book = 0.27 Kelly, già in zona quarter-Kelly anti-rovina**
+(P(rovina-50%|5y) 0.0-0.1%, P(DD>30%) 9-18%, CAGR med 13.5-17% a 2k/5k). Salire al 25% → P(DD>30%)
+> 92%; Albimarini 1→4 → P(rovina) 53-55%. **Nessun cambio raccomandato.** Il candidato anti-streak
+(N=2, size 12%→3% dopo 2 vittorie, l'opposto di Albimarini) era il più luccicante mai visto sullo
+sleeve (FULL CAGR +19.4%/DD 6.3%/Sh 2.08, random-null 0.996, DSR 0.999) ma **auto-refutato come
+artefatto di selezione**: plateau assente (solo N=2 vince, N=3/5 collassano), P(loss|streak) non
+monotona, delever-null perde in 2/7 ancore — tutto l'effetto sono ~6 perdite su 15 trade a
+streak==2 (binomtest p=0.033, CI contiene la base). Istruttivo: mostra come un DSR 0.999 possa
+convivere con l'assenza di meccanismo.
+
+### 4. Gate nuovi — 4° FALLIMENTO su 4 (barra alta)
+(a) term-structure DVOL **non testabile oggi** (storia vol_term = 7 giorni, logger forward dal
+2026-06-26 → rivalutare a 6-12 mesi); (b) vol-of-vol, (c) RV-acceleration, (d) combinazioni-AND. Il
+candidato IS-best (vol-of-vol pctl>0.80) passa DSR 0.960 e il de-levering all'ancora di default ma
+la **banda d'ancora lo smaschera** (mediana uplift FULL −0.07 su 7 ancore, uplift concentrato in UNA
+finestra 2021-22 di 5 settimane, hold-out uplift 0.00). Bonus strutturale: i veti RV-acceleration
+bloccano settimane **profittevoli** (+0.93/+1.25% vs +0.6% tenute) — dopo il gate IV-rank, la vol
+che accelera è dove il premio venduto è più ricco. Conferma il verdetto 2026-07-01: l'alpha è tutto
+nel binario IV-rank>0.30.
+
+### 5. Audit anchor-luck VRP01 — CHIUSO: primo sleeve SENZA firma di luck
+VRP01 è l'ultimo sleeve ancorato dopo TP01/XS01/SKH01. Ciclo settimanale → 7 ancore (giorno di
+apertura). Replica bit-exact della sleeve (max|diff|=0.0). Le 7 fasi con parametri identici:
+
+| metrica | canonica (fase-0) | mediana 7 fasi | banda | pctl canonica |
+|---|---|---|---|---|
+| Sh FULL | 1.09 | 1.32 | [1.09, 1.83] | **7° (peggiore)** |
+| Sh HOLD | 0.59 | 0.59 | [−0.03, 1.11] | 50° (mediana) |
+| maxDD | 11.8% | 7.2% | [5.7, 11.8%] | **93° (peggiore)** |
+
+**Firma OPPOSTA a TP01/XS01/SKH01**: lo spike bootstrap è NEGATIVO (g0 HOLD −0.06, FULL −0.21,
+P(g0≤0) 0.54/0.74) → niente da de-luckare. La fase canonica ha beccato le settimane crash 2022
+**peggio** di ogni altra (unico anno-fase negativo, −5.8%). **I numeri di ammissione FULL 1.10 /
+HOLD 0.60 / DD 12% sono quindi CONSERVATIVI, non gonfiati** — il timore di "protezione fittizia" è
+refutato: il DD 12% è il caso peggiore della banda, non quello fortunato. Impatto della fase sul
+book 5-sleeve ≤ 0.04 Sh (banda ShFULL 2.23-2.27, ShHOLD 2.35-2.48, DD 6.2-6.3%). **Con questo
+l'audit anchor-luck è completo su tutti gli sleeve ancorati (4/4).**
+
+### 6. Gate di regime sulla diagonale SPX (l'esperimento mancante) — REFUTED, con confound istruttivo
+L'esperimento che mancava ai 3 backtest Albimarini: il gate di regime sulla diagonale SPX (VIX +
+VXV da FRED, motore BS sintetico con skew log-lineare). **Domanda secca: il gate IV-rank ribalta gli
+anni di coda su SPX come su crypto? NO.** Il gate VIX-rank canonico *abbassa* lo Sharpe (1.36→1.19),
+non ribalta nessun anno di coda, peggiora il 2018, muore sul de-levering (ΔSh −0.17). Meccanismo:
+su SPX il VRP è già positivo l'**84% dei giorni** (vs ~58% delle settimane crypto) → il filtro di
+rank non ha lavoro discriminante; su equity IV-rank alto = crisi, non vol ricca.
+Il candidato **term-structure VIX/VXV<1 (contango)** sembrava reale — Sh 1.18→2.08, DD 3.5→1.3%,
+ΔSh **+0.90** a pari DD, multicut 3/3, flippa il 2020, DSR 0.992, plateau su c∈[0.93,1.05], jackknife
+robusto — **e passa la lente selection-bias pulito**. Ma la lente de-levering lo affonda:
+**l'intero uplift è un confound di modello, quantificato al 100%.** La variabile del gate (VIX/VXV>1)
+coincide 1:1 con la variabile dell'errore di pricing (tenor 6g prezzato a VIX-30g). Il refuter ha
+riprezzato con σ(6g)=VIX·(VIX/VXV)^α term-structure-consistent (α=1.42 = estrapolazione log-lineare
+zero-parametri della pendenza osservata 30g→93g) → l'edge sparisce. **Lezione: un gate che si
+correla con un errore di modello è indistinguibile da alpha finché non correggi il modello** — vale
+per ogni futuro test su strutture prezzate BS-flat.
+
+### 7. Stress lab di coda — fisica dello strumento, nessun cambio
+La protezione di coda del VRP01 viene per ~metà dall'**ala far-OTM** (nel replay COVID taglia ~90%
+della perdita naked) e ~metà dal **gate canonico** (sulle 10 peggiori finestre 14g taglia la perdita
+cumulata del 44-71% saltando i re-entry a IV-rank>0.90). L'ala T+1 "Albimarini" è assicurazione solo
+contro i gap **medi** (−15/−20%, dove atterra ATM con un giorno di time value: +150bps) e **NON**
+contro i gap profondi (k(−30%)=0.98 → il de-levering la batte), con valore interamente dipendente
+dal vol-spike (banda f/mult da −324 a +263bps). Worst-case onesto a sizing 12%: piccolo in
+convenzione book (−€12/sett a 2k, −€31 a 5k alla cella −30%) ma **è il margine intero** se il 12%
+fosse deployato fisicamente come margine (−€164..−227).
+
+---
+
+## Scettico incrociato — verdetto e disambiguazione critica
+
+I 2 sopravvissuti (sizing-conferma, anchor-ensemble) usano leve diverse (posizione sulla frontiera
+vs varianza della stima), ma lo scettico ha trovato **tre sovrapposizioni che i refuter singoli non
+potevano vedere**:
+
+1. **Stessa dipendenza dal modello f** — entrambi flippano segno allo stesso punto (f=0.6-0.8 →
+   negativo). Due sopravvissuti = **un solo grado di libertà di rischio-modello** (il caveat "premio
+   MODELLATO su DVOL ATM" resta il collo di bottiglia dell'intera famiglia).
+2. **⚠️ CONFLITTO DI UNITÀ sul "12%"** (il punto più pericoloso per la narrativa): il **12% di PESO
+   del book** (convenzione pnl/Ks di `sleeves.py`) = ~**0.6% margine/equity ≈ 0.014 Kelly**, mentre
+   il "FISSO 12%" del filone sizing = **12% margine/equity ≈ 0.27 Kelly** — **fattore 19x**. Entrambe
+   corrette internamente, ma non vanno confuse: worst-week −12.2% del conto (convenzione margine) vs
+   −0.64% (convenzione peso book).
+3. **L'ensemble-7-fasi è ridondante con il tranching TP01** (matematica di diversificazione: corr fra
+   fasi ρ=0.355, boost teorico ×1.50 vs osservato ×1.53, residuo alpha ≈ 0) → **non promuovere a LEAD
+   autonomo**; la coda strutturale è invariata (worst = 7 tranche a full-loss simultaneo), il DD 4.7%
+   è campionario, non un cap.
+
+**Effetto congiunto sul book 5-sleeve: ZERO** (entrambi propongono nessun cambio; controfattuale
+|ΔSh| ≤ 0.04). Il book live Deribit (TP01+SKH01) non contiene VRP01 → impatto operativo nullo.
+
+---
+
+## Cosa entra nella narrativa (una sola voce, status = misura research)
+
+- **Audit anchor-luck VRP01 CHIUSO** → i numeri di ammissione reggono e si citano con banda
+  (ShFULL [1.09,1.83], ShHOLD [−0.03,1.11], DD [5.7,11.8%]); l'edge OOS resta f-dipendente.
+  Con questo l'audit anchor è completo su 4/4 sleeve ancorati.
+- **Sizing (conferma, con disambiguazione unità obbligatoria):** 12% deploy ≈ 0.27 Kelly onesto,
+  anti-rovina; NON confondere col 12% di peso book (0.014 Kelly, 19x).
+- **VRP01 canonico resta lo sleeve giusto, INVARIATO** — non migliorabile per struttura, gate,
+  overlay o sizing; la protezione DD si compra con la size.
+
+## Regole/candidati rafforzati
+
+- **`implausible_sharpe` gate in altlib**: 3ª occorrenza del pattern "0-perdite = Sharpe
+  implausibile" (griglia struttura, dopo CC01 e ALB-A) → priorità alzata.
+- **Nuova regola metodologica**: un gate che si correla con un errore di modello (term-structure vs
+  BS-flat) è indistinguibile da alpha finché non si corregge il modello — riprezzare
+  term-structure-consistent prima di credere a qualsiasi gate vol su strutture BS-flat.
+- **Conferma (4ª): l'alpha del VRP è il gate IV-rank binario**, non struttura/sizing/overlay/gate
+  aggiuntivi.
+
+**Stato:** book live INVARIATO, nessun nuovo sleeve, nessun forward-monitor. Test suite verde. 7
+script committati.

docs/diary/2026-07-07-crt-topdown-74winrate.md

@@ -0,0 +1,109 @@
+# 2026-07-07 — Video-claim "CRT top-down multi-TF, 74% win rate": SCARTATO (il 74% è un knob, non un edge)
+
+**Richiesta utente:** analizzare e testare una strategia da video, metodo ICT/SMC top-down
+multi-timeframe con claim **74% win rate**:
+1. **H1** — setup CRT: candela di displacement forte, poi candela che prende liquidità (spike oltre
+   il range di C1) ma richiude dentro → falso breakout → fade/reversal.
+2. **M15** — struttura: swing (U a 3 candele) + imbalance che diventa inverse-imbalance (FVG mitigato).
+3. **M5** — conferma: displacement direzionale + zona di protezione (order block / imbalance).
+4. **M1** — entry: attende la correzione, entra con SL dietro la zona di protezione.
+Uscita: **TP1 a fine zona CRT (RR ~1.5–2), chiude 70–80% lì → resto a break-even → runner 20–30%**
+verso la "liquidità successiva" (previous daily high/low). Due esempi mostrati (gold, nasdaq), entrambi
+vincenti. Metà finale del video = vendita academy → lead magnet.
+
+La valutazione critica dell'utente ("occhio Milito") aveva già isolato le red flag giuste (74% non
+dimostrato, cherry-picking di 2 esempi, concetti discrezionali non falsificabili, RR basso + WR alto =
+fragile, funnel commerciale). Questo diario **meccanizza e falsifica** la parte testabile.
+
+## Inventario preventivo (non rifare lavoro)
+
+Il setup H1 CRT è **già stato meccanizzato e scartato 3 volte** nell'onda 2026-07-02:
+- `r0702_crt_base` (864 trial, 1h/4h/12h/1d): **DSR 0.000**; short "smart-money" negativo perfino IS.
+- `r0702_crt_mtf` (4h→15m, 1h→5m, ~10k trade): **expectancy netta negativa OVUNQUE**; refutazione
+  strutturale = **"il ritest è informazione negativa"** (pattern CON ritest −40bps, SENZA +52bps).
+- `r0702_crt_context` (FVG/sessioni/livelli): FVG semmai peggiora; **FADE < FOLLOW ogni anno 2019-26**.
+
+**Angolo NUOVO non coperto** = la **gestione d'uscita (parziale+BE+runner)** e il **claim 74% WR**.
+È lì che ho concentrato il test: `scripts/research/r0707_crt_topdown.py` (non tocca src/config/live;
+nessun file scritto). Riusa l'harness certificato (dati/atr/sharpe/DSR di `altlib`).
+
+## Disegno
+
+- Detection CRT C1-C2 su **H1** (causale, nota alla chiusura di C2). Direzione = fade dello sweep.
+- Entry sul TF basso (**5m/15m**, proxy di M5/M1 — ⚠️ **M1 non è nel feed certificato**): ritest della
+  zona violata + close-back attraverso il livello ("displacement di conferma"), **SL = estremo dello
+  swing basso = zona di protezione**.
+- Tre schemi d'uscita sugli **stessi ingressi**: `fix1.5` (full, TP 1.5R), `fix2.0` (full, TP 2.0R),
+  `managed` (75% a 1.5R → resto 25% a BE, runner target = prev-daily high/low o estremo opposto C1).
+- Gate progetto: hold-out 2025-01-01, griglia (k, s, d, tf, scheme) con **selezione cella solo
+  in-sample** + **DSR su tutti i trial**, **fee sweep** 0/0.10/0.20% RT, executability $600.
+- Metrica invariante = **expectancy in R netto fee** (non il win-rate).
+
+## Esito — il 74% è un artefatto della distanza del target, non un edge
+
+**1) Win-rate reale (fade, tutti gli schemi, pooled BTC+ETH):**
+
+| schema | WR mediana | expectancy R (netto 10bps) |
+|---|---|---|
+| fix1.5  | **35.8%** | −2.38 |
+| fix2.0  | 31.3% | −2.34 |
+| managed | **35.8%** | −2.17 |
+
+Il WR a RR 1.5 è **~35%**, cioè **SOTTO** il null gambler's-ruin di un random walk senza edge
+(P(+1.5R prima di −1R) = 1/(1+1.5) = **40%**). Il setup tocca 1.5R **meno spesso di una moneta** →
+conferma indipendente che *il ritest è informazione negativa*. Lo schema `managed` **non gonfia** il
+WR sopra `fix1.5` (per costruzione: "vinci" solo se raggiungi il parziale a 1.5R, che è la stessa
+condizione di `fix1.5`). **In nessuna cella si avvicina al 74%.**
+
+**2) Il win-rate È un knob — sweep del target parziale `rr1` (managed, 5m, cella tipica):**
+
+| rr1  | WR reale | null 1/(1+rr1) | expR (fee 10bps) | expR (fee 0) |
+|------|----------|----------------|------------------|--------------|
+| 0.50 | 51.4%    | 66.7%          | **−2.54**        | +0.11 |
+| 0.75 | 46.9%    | 57.1%          | −2.51            | +0.14 |
+| 1.00 | 43.2%    | 50.0%          | −2.47            | +0.17 |
+| 1.50 | 36.3%    | 40.0%          | −2.45            | +0.19 |
+| 2.00 | 31.8%    | 33.3%          | −2.42            | +0.23 |
+
+Avvicinando il target il WR sale (esattamente come previsto dalla formula gambler's-ruin): **un "74%"
+si fabbrica scegliendo un parziale vicino** (~0.35R), NON perché il metodo indovina la direzione. Ma
+l'**expectancy R è costante e negativa a ogni rr1**: il WR alto non porta soldi. NB anche a WR massimo
+il setup resta *sotto* il null teorico ad ogni rr1 → è pure peggio di un random walk nel raggiungere
+target vicini.
+
+**3) Gate statistici (cella scelta in-sample = 15m, k1.5, s0.1, d0.15, fix2.0):**
+- **DSR = 0.000** su 48 trial (null max-Sharpe atteso 4.35). FAIL.
+- **Fee sweep:** a **0 bps** expR = −0.10 e Sharpe book −0.63 → **non è morte-per-fee: l'edge lordo
+  non esiste** (il residuo lordo marginalmente positivo su 5m è la beta di trend dei time-exit, la
+  stessa autopsia del CRT base). A 10bps expR −1.26; a 20bps −2.43. Stop stretti (0.13–0.24%) →
+  la fee 0.10% pesa 0.75–2.6 R per trade → qualunque micro-edge lordo è polverizzato.
+- **Hold-out 2025-26:** WR 32%, expR −1.56 (peggio dell'IS). Nessuna reggenza fuori campione.
+
+**4) Executability $600:** SL sul TF basso = 0.13% (5m) / 0.24% (15m). Lo schema parziale+BE+runner
+richiede **3–4 ordini per trade**, alcuni **sotto il min-order $5** a nozionale $1200 → non eseguibile
+pulito al capitale reale.
+
+## Verdetto
+
+**SCARTATO.** Il claim "74% win rate" è **coerente con ZERO edge**: è la scelta di un parziale vicino
+(gambler's ruin), non capacità direzionale. Smontato lo schema d'uscita, resta il setup H1 CRT che
+questo progetto ha già triplo-refutato (DSR 0.000, ritest = informazione negativa, fade < follow).
+Sul feed certificato BTC/ETH il metodo ha **win-rate reale ~30–37% e expectancy R negativa a ogni
+schema, fee, finestra e asset**; lordo di fee non c'è edge; a $600 non è nemmeno eseguibile pulito.
+
+La parte *utile* del video è il framework di lettura (CRT + imbalance + parziali), non il numero — come
+aveva già concluso la valutazione dell'utente. Da trattare come lettura del mercato, non come sistema.
+
+## Lezione codificabile (candidata)
+
+**Il win-rate di uno schema parziale+BE non è un parametro di merito: è ~P(tocca il primo target prima
+dello stop) = 1/(1+rr1) per un processo senza drift.** Ogni claim "WR X%" da schema SMC va convertito
+in **expectancy R netto fee** prima di crederci; il WR alto si compra con un target vicino a costo di
+un'expectancy identica (o peggiore). Prossimo giro di gate: un helper `winrate_is_a_knob()` che, dato
+un book a schema parziale, riporta expectancy-R vs WR al variare del target (rende esplicito l'artefatto).
+
+## File
+
+- `scripts/research/r0707_crt_topdown.py` — il test (griglia + 74%-check + knob-sweep + DSR + fee + exec).
+- Prior: `r0702_crt_{base,mtf,context}.py`, diario `2026-07-02-timing-crt-wave.md`.
+- Nessuna modifica a src/, config/, scripts/live/, tests/. Book live e pesi INVARIATI.

docs/diary/2026-07-09-traefik-cert-book-offline.md

@@ -0,0 +1,108 @@
+# 2026-07-09 — Incident infra: "BOOK LIVE conto offline" = cert Traefik di default (non un problema del conto)
+
+**Tipo:** incident operativo (infra VPS), non ricerca. Nessun edge, nessun cambio a strategie/pesi/config
+di trading. Documentato qui perché ha **bloccato la lettura del conto del book live** e ha prodotto
+l'alert Telegram `⚠️ BOOK LIVE — conto offline`.
+
+## Sintomo
+
+Alert dal `cron_book` orario (`scripts/live/book_execute.py --execute`):
+
+```
+⚠️ BOOK LIVE — conto offline
+  nota: salto l'esecuzione, non opero a cieco
+```
+
+Nel log (`logs/cron_book.log`) le run recenti mostravano `conto non leggibile (offline) -> stop, non
+eseguo a cieco`. 10 run offline su 382 totali → **regressione recente**, non uno stato storico.
+
+## Diagnosi (catena completa)
+
+Il book legge il conto Deribit mainnet in sola lettura via **Cerbero MCP** (`DeribitRead`,
+`src/live/deribit.py` → `https://cerbero-mcp.tielogic.xyz`). `book_report` marca `online=False` quando
+`DeribitRead.mark_price(BTC)` lancia. Riproduzione diretta:
+
+```
+mark_price BTC: FAIL -> SSLError: [SSL: CERTIFICATE_VERIFY_FAILED] self-signed certificate
+```
+
+Il proxy presentava il **cert self-signed di default di Traefik** (`CN = TRAEFIK DEFAULT CERT`,
+`notBefore Jul 9 19:55 2026`) al posto del vero Let's Encrypt. `curl -k` → HTTP 401 (backend
+`cerbero-mcp` healthy, routing OK): **solo la presentazione del cert TLS era rotta**. `requests`
+verifica il cert → fallisce → `online=False` → il book salta l'esecuzione (comportamento di sicurezza
+**corretto**: non opera a cieco).
+
+**Causa a monte** (log di avvio Traefik, 11:37:16Z, container `traefik-traefik-1`):
+
+```
+ERR The ACME resolve is skipped from the resolvers list
+    error="unable to get ACME account: permissions 660 for /acme.json are too open, please use 600"
+    resolver=mytlschallenge
+→ (a cascata) Router uses a nonexistent certificate resolver certificateResolver=mytlschallenge
+  routerName=cerbero-mcp@docker   [+ ~14 altri router: git, vault, portfolio, budget, cerbero-bite, ...]
+```
+
+Sequenza:
+1. Immagine `traefik:latest` + **Watchtower** (`com.centurylinklabs.watchtower.enable=true`) →
+   auto-upgrade a **Traefik 3.7.7** con restart alle 11:37 di oggi.
+2. Traefik 3.x **rifiuta** `acme.json` con permessi più larghi di `600`; il file era `660`
+   (`-rw-rw---- root:adriano`) → **resolver `mytlschallenge` scartato**.
+3. Tutti i ~15 router che lo referenziano → "nonexistent certificate resolver" → Traefik serve il
+   **cert di default self-signed** a ogni host HTTPS del VPS (non solo cerbero-mcp).
+4. I cert veri erano **già dentro `acme.json`** (14 domini, incl. `cerbero-mcp.tielogic.xyz`) → nessuna
+   ri-emissione necessaria, **zero rischio rate-limit** Let's Encrypt.
+
+## Impatto
+
+- **VPS-wide:** ogni servizio HTTPS dietro Traefik serviva un cert invalido (warning browser, fallimento
+  di ogni client che verifica il TLS). Non solo il trading.
+- **Trading:** **nessun trade perso.** Target del book **flat** (TP01/SKH01 risk-off) + conto reale
+  ~$598 (non finanziato al livello nominale): anche online il book avrebbe fatto HOLD. Il doppio gate
+  di sicurezza ha lavorato come previsto.
+
+## Fix
+
+**Immediato** (eseguito dall'utente):
+```bash
+sudo chmod 600 /opt/docker/traefik/acme.json
+docker restart traefik-traefik-1
+```
+Il resolver ricarica i cert già presenti in `acme.json` e li ripresenta subito.
+
+**Durevole** (pin dell'immagine, `/opt/docker/traefik/docker-compose.yml`):
+```yaml
+-    image: "traefik"        # = traefik:latest → Watchtower salta ai major (causa dell'incident)
++    image: "traefik:3.7"    # Watchtower resta su 3.7.x: patch sì, salto a 3.8+ breaking no
+```
+Applicato con `docker compose up -d` (container ricreato su `traefik:3.7`, 20:05:05Z).
+
+## Verifica (end-to-end, post-fix)
+
+| Check | Risultato |
+|---|---|
+| `acme.json` perms | `600` |
+| Cert `cerbero-mcp.tielogic.xyz` | issuer **Let's Encrypt** (fino 2026-09-27) |
+| Traefik log | nessun `ACME resolve is skipped` / `too open` |
+| Container image | `traefik:3.7` (running) |
+| `DeribitRead.mark_price` | BTC 63.193 / ETH 1.746 |
+| `book_report.online` | **True** · `eq_basis=mainnet USDC` · `real_equity=$598.06` · `pos_error=None` |
+
+## Lezioni
+
+- **`traefik:latest` + Watchtower = auto-upgrade non deterministico.** Un bump di major (qui il giro
+  di vite sui permessi di `acme.json`) diventa un'interruzione TLS di tutto il VPS senza intervento
+  umano. Pinnare la minor (`3.7`) rende i restart prevedibili pur ricevendo le patch.
+- **Traefik 3.x pretende `acme.json` a `600`** (non solo warning: **scarta il resolver**). Se il file
+  è group/other-readable, tutti i router cadono sul cert di default.
+- **Il gate `online` del book ha fatto il suo lavoro:** un problema *infra di lettura* non ha prodotto
+  ordini a cieco. L'alert "conto offline" va letto prima come possibile problema di **connettività/cert
+  al Cerbero MCP**, non del conto Deribit.
+- **Runbook rapido** per "BOOK LIVE conto offline":
+  1. `python -c "from src.live.deribit import DeribitRead; DeribitRead().mark_price('BTC-PERPETUAL')"`
+     → se `SSLError`/`CERTIFICATE_VERIFY_FAILED` è il cert del proxy, non il conto.
+  2. `openssl s_client -connect cerbero-mcp.tielogic.xyz:443 -servername cerbero-mcp.tielogic.xyz | openssl x509 -noout -issuer`
+     → se `TRAEFIK DEFAULT CERT`, Traefik non serve il cert reale.
+  3. `docker logs traefik-traefik-1 | grep -iE "ACME resolve is skipped|too open|nonexistent"`
+     → conferma resolver scartato; controlla `stat -c %a /opt/docker/traefik/acme.json` (deve essere `600`).
+
+Nessun file di trading toccato; `config/live.json`, sleeve e pesi **invariati**.

scripts/cron_book.sh

@@ -0,0 +1,14 @@
+#!/bin/bash
+# BOOK DERIBIT-ONLY (TP01+SKH01 nettati) — esecuzione LIVE a cadenza ORARIA. v2.0.0+.
+# SKH01 decide su griglia 230m -> serve girare piu' spesso del daily; orario IDEMPOTENTE:
+# riconcilia al target NETTO corrente (se non cambia nulla -> HOLD). Il feed 5m fresco per il
+# segnale SKH e' preso IN MEMORIA dentro book_execute (livefeed.fresh_5m): NON tocca i dati
+# certificati su disco. Esecuzione reale gated da config/live.json (execution_enabled) + --execute.
+export PATH="/home/adriano/.local/bin:$PATH"
+cd /opt/docker/PythagorasGoal || exit 1
+mkdir -p logs
+{
+  echo "===== $(date -u '+%Y-%m-%dT%H:%M:%SZ') cron_book ====="
+  uv run python scripts/live/book_execute.py --execute
+  echo "===== done $(date -u '+%H:%M:%SZ') ====="
+} >> logs/cron_book.log 2>&1

scripts/cron_daily.sh

@@ -9,5 +9,15 @@ mkdir -p logs
   uv run python scripts/analysis/fetch_hyperliquid.py                 # 52 alt Hyperliquid (certify)
   uv run python scripts/research/fetch_dvol.py                        # DVOL (per ricerca opzioni)
   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/paper_statarb.py                         # forward-monitor lead STATARB-RESID ETH/BTC ortogonale (PAPER, non deploy)
+  # NB: l'esecuzione Deribit e' passata al BOOK (TP01+SKH01 nettati) via scripts/cron_book.sh a
+  #     cadenza ORARIA (SKH01 e' a 230m: il daily mancherebbe gli ingressi). live_execute.py
+  #     (TP01-only) NON va piu' eseguito qui, sennò i due farebbero a pugni sullo stesso strumento.
+  # --- 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

scripts/cron_vol_term.sh

@@ -0,0 +1,14 @@
+#!/bin/bash
+# LOGGER FORWARD della vol term-structure Deribit — cadenza GIORNALIERA. v2.0.0+.
+# Costruisce il dataset per un futuro calendar-vol (oggi NON backtestabile: storia per-scadenza non
+# pubblica — vedi docs/diary/2026-06-26-vol-termstructure-feasibility.md). Append idempotente per
+# giorno su data/raw/vol_term_<asset>.parquet. SOLO ricerca forward: NON tocca il book live ne' i
+# dati certificati BTC/ETH; legge l'API pubblica Deribit (tokenless) e scrive un parquet dedicato.
+export PATH="/home/adriano/.local/bin:$PATH"
+cd /opt/docker/PythagorasGoal || exit 1
+mkdir -p logs
+{
+  echo "===== $(date -u '+%Y-%m-%dT%H:%M:%SZ') cron_vol_term ====="
+  uv run python scripts/research/log_vol_termstructure.py
+  echo "===== done $(date -u '+%H:%M:%SZ') ====="
+} >> logs/cron_vol_term.log 2>&1

scripts/live/book_execute.py

@@ -0,0 +1,162 @@
+"""BOOK DERIBIT-ONLY LIVE EXECUTE — TP01 + SKH01 NETTATI in software su un solo conto Deribit mainnet.
+
+Porta il conto reale al target NETTO per asset (vedi src/live/book.py): per ogni asset combina la
+frazione long-flat di TP01 (peso 0.75) e il segno L/S di SKH01 (peso 0.25), e manda UN ordine con
+segno (long/short/flip) per raggiungerlo. Poi assicura un disaster-SL on-book sulla posizione NETTA.
+
+DOPPIO GATE DI SICUREZZA (entrambi necessari per inviare ordini reali):
+  1. config/live.json -> "execution_enabled": true   (master switch, default false)
+  2. flag CLI --execute
+Senza entrambi e' un DRY-RUN (stampa il piano, NON invia). Reconciliation dopo ogni ordine; log in
+data/live/book_executions.jsonl.
+
+⚠️ CADENZA: SKH01 decide su griglia 230m -> questo script va lanciato ogni ~230 minuti con la feed
+fresca all'ultima barra chiusa (NON il cron giornaliero, che mancherebbe gli ingressi). Gli exit di
+SKH sono SOFTWARE (latenza fino a fine barra 230m); solo il disaster-SL (-30%) e' on-book.
+
+  uv run python scripts/live/book_execute.py            # DRY-RUN (piano, nessun ordine)
+  uv run python scripts/live/book_execute.py --execute   # esegue SOLO se execution_enabled=true
+"""
+from __future__ import annotations
+
+import json
+import sys
+from pathlib import Path
+
+import pandas as pd
+
+PROJECT_ROOT = Path(__file__).resolve().parents[2]
+sys.path.insert(0, str(PROJECT_ROOT))
+
+from src.live.book import book_report
+from src.live.execution import DeribitTrader
+from src.live.notifier import notify
+
+CONFIG = PROJECT_ROOT / "config" / "live.json"
+LOG_DIR = PROJECT_ROOT / "data" / "live"
+LOG = LOG_DIR / "book_executions.jsonl"
+
+
+def load_config() -> dict:
+    cfg = json.loads(CONFIG.read_text()) if CONFIG.exists() else {}
+    cfg.setdefault("execution_enabled", False)
+    cfg.setdefault("max_notional_per_asset_usd", 300.0)
+    cfg.setdefault("min_order_usd", 5.0)
+    cfg.setdefault("disaster_sl_pct", 0.30)
+    return cfg
+
+
+def log_event(rec: dict):
+    LOG_DIR.mkdir(parents=True, exist_ok=True)
+    with open(LOG, "a") as f:
+        f.write(json.dumps(rec) + "\n")
+
+
+def _run():
+    cfg = load_config()
+    want_execute = "--execute" in sys.argv[1:]
+    enabled = bool(cfg["execution_enabled"])
+    do_execute = want_execute and enabled
+    min_order = float(cfg["min_order_usd"])
+    sl_pct = float(cfg["disaster_sl_pct"])
+
+    r = book_report(live_feed=True)           # target NETTO + conto/posizioni reali (feed SKH fresco)
+    equity = r["equity"]
+
+    print("=" * 88)
+    print("  BOOK DERIBIT LIVE EXECUTE — TP01(0.75)+SKH01(0.25) NETTATI — Deribit mainnet (USDC linear)")
+    print("=" * 88)
+    mode = ("ESECUZIONE REALE" if do_execute else
+            ("ARMATO ma manca --execute" if enabled else "DRY-RUN (execution_enabled=false)"))
+    print(f"  modo            : {mode}")
+    print(f"  gate            : execution_enabled={enabled} | --execute={want_execute}")
+    print(f"  conto reale     : ${r['real_equity']:,.2f}" if r["real_equity"] else f"  conto: {r['eq_basis']}")
+    print(f"  sizing base     : ${equity:,.2f} | cap/asset ${r['cap_per_asset']:.0f} | min ${min_order:.0f} | disaster-SL -{sl_pct*100:.0f}%")
+    print(f"  ultima barra    : {r['last_data']}\n")
+
+    if r.get("skh_error"):                        # SKH feed fallito -> book.py ha forzato flat IN SILENZIO
+        print(f"  ⚠️ SKH FEED ERRORE (SKH forzato flat!): {r['skh_error']}")
+        notify("⚠️ BOOK — SKH feed fallito (sleeve forzato flat)", {"error": r["skh_error"]})
+
+    if not r["online"]:
+        print("  conto non leggibile (offline) -> stop, non eseguo a cieco.")
+        if do_execute:
+            notify("⚠️ BOOK LIVE — conto offline", {"nota": "salto l'esecuzione, non opero a cieco"})
+        return
+
+    if r.get("pos_error"):                        # ONLINE ma posizione IGNOTA (read fallita -> assunta flat)
+        print(f"  🛑 POSIZIONE NON LEGGIBILE -> NON eseguo a cieco: {r['pos_error']}")
+        if do_execute:
+            notify("🛑 BOOK LIVE — posizione non leggibile", {"error": r["pos_error"],
+                                                              "nota": "salto l'esecuzione, non opero a cieco"})
+        return
+
+    if r.get("eq_fallback"):                      # equity reale non leggibile -> sizing su paper_cap
+        print(f"  ⚠️ EQUITY FALLBACK (sizing su paper_cap, NON blocco): {r['eq_fallback']}")
+        if do_execute:                            # solo diagnostica: l'hard-cap $/asset limita il downside
+            notify("⚠️ BOOK LIVE — equity fallback (sizing su paper_cap)", {"nota": r["eq_fallback"]})
+
+    trader = DeribitTrader() if do_execute else None
+    actions = []
+    for a in r["assets"]:
+        asset, inst = a["asset"], a["instrument"]
+        net, cur, mark = a["net_target"], a["position_usd"], a["mark"]
+        sk = a["skh_state"]
+        sk_txt = "flat" if sk == "flat" else f"{sk['dir']}@{sk.get('entry')}"
+        order = a["order"]
+        if order is None:
+            act = "HOLD (a target)"
+        elif order.get("is_close"):
+            act = f"CLOSE ${cur:,.0f}"
+        elif order.get("needs_flip"):
+            act = f"FLIP -> ${net:,.0f}"
+        else:
+            act = f"{order['side'].upper()} ${order['delta']:+,.0f}"
+        print(f"  {asset:<3} TP {a['tp_frac']:+.3f} · SKH {a['skh_sign']:+d}({sk_txt}) -> net ${net:+,.0f} "
+              f"| pos ${cur:+,.0f} -> {act}")
+
+        if do_execute and order is not None:
+            fills = trader.rebalance_signed(inst, net, mark, min_usd=min_order)
+            newpos = trader.position_usd(inst)
+            for f in fills:
+                print(f"      -> {f.side.upper()} {f.filled:.4f} @ ${f.price or 0:,.1f} fee {f.fee_usdc:.5f} "
+                      f"({'OK' if f.verified else 'NON VERIFICATO: ' + f.notes})")
+                log_event(dict(ts_utc=str(pd.Timestamp(r['last_data'])), asset=asset, action=act,
+                               side=f.side, filled=f.filled, price=f.price, fee=f.fee_usdc,
+                               verified=f.verified, notes=f.notes, net_target=net, pos_after=newpos,
+                               tp_frac=a["tp_frac"], skh_sign=a["skh_sign"]))
+                det = dict(asset=asset, side=f.side, amount=round(f.filled, 4), price=round(f.price or 0, 1),
+                           fee=round(f.fee_usdc, 5), net=round(net, 0), pos_after=round(newpos, 0))
+                notify(f"✅ BOOK {act}" if f.verified else "⚠️ BOOK ORDINE NON VERIFICATO",
+                       det if f.verified else {**det, "notes": f.notes})
+            print(f"      reconcile: pos ${newpos:,.0f}")
+        if do_execute:
+            ds = trader.ensure_disaster_sl(inst, sl_pct)   # bracket su posizione NETTA (adatta long/short)
+            print(f"      disaster-SL: {ds.get('state')}" + (f" @ ${ds['stop']:,.1f}" if ds.get("stop") else ""))
+            if ds.get("state") == "placed":
+                notify("🛡️ BOOK disaster-SL piazzato", {"asset": asset, "stop": round(ds.get("stop") or 0, 1),
+                                                          "amount": round(ds.get("amount") or 0, 4)})
+            elif ds.get("state") == "place-failed":
+                notify("⚠️ BOOK disaster-SL FALLITO", {"asset": asset, "notes": ds.get("notes")})
+        actions.append(act)
+
+    print()
+    if not do_execute:
+        print("  => DRY-RUN: nessun ordine inviato." +
+              ("" if enabled else " Per armare: config/live.json execution_enabled=true + --execute."))
+    elif all(x.startswith("HOLD") for x in actions):
+        print("  => Nessuna azione: conto gia' al target netto del book.")
+    else:
+        print("  => Esecuzione completata (vedi data/live/book_executions.jsonl).")
+
+
+def main():
+    try:
+        _run()
+    except Exception as e:
+        notify("🛑 BOOK LIVE — ERRORE", {"error": f"{type(e).__name__}: {e}"})
+        raise
+
+
+if __name__ == "__main__":
+    main()

scripts/live/live_execute.py

@@ -0,0 +1,141 @@
+"""TP01 LIVE EXECUTE — loop di esecuzione GATED su Deribit mainnet (USDC linear).
+
+Porta il conto reale al target di TP01 (causale, dati certificati): per ogni asset calcola il notional
+bersaglio = min(0.5 * frazione * equity, max_notional), e apre/riduce/chiude per raggiungerlo.
+
+DOPPIO GATE DI SICUREZZA (entrambi necessari per inviare ordini reali):
+  1. config/live.json -> "execution_enabled": true   (master switch, default false)
+  2. flag CLI --execute
+Senza entrambi e' un DRY-RUN (stampa il piano, NON invia). Reconciliation dopo ogni ordine; log in
+data/live/executions.jsonl. TP01 oggi e' FLAT -> target 0 -> nessuna azione finche' il segnale non gira.
+
+  uv run python scripts/live/live_execute.py            # DRY-RUN (piano, nessun ordine)
+  uv run python scripts/live/live_execute.py --execute   # esegue SOLO se execution_enabled=true
+"""
+from __future__ import annotations
+
+import json
+import sys
+from pathlib import Path
+
+import pandas as pd
+
+PROJECT_ROOT = Path(__file__).resolve().parents[2]
+sys.path.insert(0, str(PROJECT_ROOT))
+
+from src.live.deribit import INSTRUMENT
+from src.live.execution import DeribitTrader
+from src.live.notifier import notify
+from src.live.shadow import ASSETS, WEIGHT, shadow_report
+
+CONFIG = PROJECT_ROOT / "config" / "live.json"
+LOG_DIR = PROJECT_ROOT / "data" / "live"
+LOG = LOG_DIR / "executions.jsonl"
+
+
+def load_config() -> dict:
+    cfg = json.loads(CONFIG.read_text()) if CONFIG.exists() else {}
+    cfg.setdefault("execution_enabled", False)
+    cfg.setdefault("max_notional_per_asset_usd", 300.0)
+    cfg.setdefault("min_order_usd", 5.0)
+    cfg.setdefault("disaster_sl_pct", 0.30)
+    return cfg
+
+
+def log_event(rec: dict):
+    LOG_DIR.mkdir(parents=True, exist_ok=True)
+    with open(LOG, "a") as f:
+        f.write(json.dumps(rec) + "\n")
+
+
+def _run():
+    cfg = load_config()
+    want_execute = "--execute" in sys.argv[1:]
+    enabled = bool(cfg["execution_enabled"])
+    do_execute = want_execute and enabled
+    max_notional = float(cfg["max_notional_per_asset_usd"])
+    min_order = float(cfg["min_order_usd"])
+    sl_pct = float(cfg["disaster_sl_pct"])
+
+    r = shadow_report()                       # targets causali + conto/posizioni reali (online)
+    equity = r["equity"]
+
+    print("=" * 84)
+    print("  TP01 LIVE EXECUTE — Deribit mainnet (USDC linear)")
+    print("=" * 84)
+    mode = ("ESECUZIONE REALE" if do_execute else
+            ("ARMATO ma manca --execute" if enabled else "DRY-RUN (execution_enabled=false)"))
+    print(f"  modo            : {mode}")
+    print(f"  gate            : execution_enabled={enabled} | --execute={want_execute}")
+    print(f"  conto reale     : ${r['real_equity']:,.2f}" if r["real_equity"] else f"  conto: {r['eq_basis']}")
+    print(f"  sizing base     : ${equity:,.2f} | cap/asset ${max_notional:.0f} | min ${min_order:.0f} | disaster-SL -{sl_pct*100:.0f}%")
+    print(f"  ultima barra    : {r['last_data']}\n")
+
+    if not r["online"]:
+        print("  conto non leggibile (offline) -> stop, non eseguo a cieco.")
+        if do_execute:
+            notify("⚠️ TP01 LIVE — conto offline", {"nota": "salto l'esecuzione, non opero a cieco"})
+        return
+
+    trader = DeribitTrader() if do_execute else None
+    actions = []
+    for a in r["assets"]:
+        asset = a["asset"]; frac = a["target"]; mark = a["mark"]; cur = a["position_usd"]
+        tgt = min(WEIGHT * frac * equity, max_notional) if frac > 0 else 0.0
+        delta = tgt - cur
+        if abs(delta) < min_order:
+            act = "HOLD (a target)"
+        elif tgt < 1.0 and cur > 1.0:
+            act = f"CLOSE ${cur:,.0f}"
+        elif delta > 0:
+            act = f"BUY ${delta:,.0f}"
+        else:
+            act = f"REDUCE ${-delta:,.0f}"
+        print(f"  {asset:<3} target {frac:+.3f}x -> ${tgt:,.0f} | pos ${cur:,.0f} | delta ${delta:+,.0f} -> {act}")
+
+        if do_execute:
+            if not act.startswith("HOLD"):
+                fills = trader.rebalance_to(INSTRUMENT[asset], tgt, mark, min_usd=min_order)
+                newpos = trader.position_usd(INSTRUMENT[asset])
+                for f in fills:
+                    print(f"      -> {f.side.upper()} {f.filled:.4f} @ ${f.price:,.1f} fee {f.fee_usdc:.5f} "
+                          f"({'OK' if f.verified else 'NON VERIFICATO: ' + f.notes})")
+                    log_event(dict(ts_utc=str(pd.Timestamp(r['last_data'])), asset=asset, action=act,
+                                   side=f.side, filled=f.filled, price=f.price, fee=f.fee_usdc,
+                                   verified=f.verified, notes=f.notes, pos_after=newpos))
+                    det = dict(asset=asset, side=f.side, amount=round(f.filled, 4),
+                               price=round(f.price or 0, 1), fee=round(f.fee_usdc, 5), pos_after=round(newpos, 0))
+                    if f.verified:
+                        notify(f"✅ TP01 {act}", det)
+                    else:
+                        notify("⚠️ TP01 ORDINE NON VERIFICATO", {**det, "notes": f.notes})
+                print(f"      reconcile: pos ${newpos:,.0f}")
+            ds = trader.ensure_disaster_sl(INSTRUMENT[asset], sl_pct)   # bracket: piazza se long, pulisce se flat
+            print(f"      disaster-SL: {ds.get('state')}" + (f" @ ${ds['stop']:,.1f}" if ds.get("stop") else ""))
+            if ds.get("state") == "placed":
+                notify("🛡️ TP01 disaster-SL piazzato", {"asset": asset, "stop": round(ds.get("stop") or 0, 1),
+                                                          "amount": round(ds.get("amount") or 0, 4)})
+            elif ds.get("state") == "place-failed":
+                notify("⚠️ TP01 disaster-SL FALLITO", {"asset": asset, "notes": ds.get("notes")})
+        actions.append(act)
+
+    print()
+    if not do_execute:
+        print("  => DRY-RUN: nessun ordine inviato." +
+              ("" if enabled else " Per armare: config/live.json execution_enabled=true + --execute."))
+    elif all(x.startswith("HOLD") for x in actions):
+        print("  => Nessuna azione: conto gia' al target di TP01 (oggi flat).")
+    else:
+        print("  => Esecuzione completata (vedi data/live/executions.jsonl).")
+
+
+def main():
+    try:
+        _run()
+    except Exception as e:
+        notify("🛑 TP01 LIVE — ERRORE", {"error": f"{type(e).__name__}: {e}"})
+        raise
+
+
+if __name__ == "__main__":
+    main()

scripts/live/live_trend.py

@@ -0,0 +1,78 @@
+"""TP01 LIVE — SHADOW MODE (Deribit mainnet, SOLA LETTURA, nessun ordine inviato).
+
+Valida l'esecuzione di TP01 a RISCHIO ZERO: gira il loop live completo contro dati/conto/posizioni
+REALI del mainnet, calcola i target causali (stesso codice del backtest/paper), costruisce gli ordini
+di ribilancio esatti — e li STAMPA invece di inviarli. Confronta i target col paper trader (parita').
+
+Perche' non testnet: il testnet Cerbero/Deribit e' la causa del reset v2.0.0 (feed farlocco). La
+validazione a rischio zero qui e' "shadow su mainnet reale in sola lettura"; il fill (slippage/fee)
+si valida solo col micro-test mainnet a size minima, in un passo successivo.
+
+Logica condivisa con la dashboard in src/live/shadow.py (un solo codice, niente drift).
+
+    uv run python scripts/live/live_trend.py                 # shadow su mainnet reale
+    uv run python scripts/live/live_trend.py --equity 2000   # forza la base di sizing
+    uv run python scripts/live/live_trend.py --no-net        # offline: solo matematica + parita'
+"""
+from __future__ import annotations
+
+import sys
+from pathlib import Path
+
+PROJECT_ROOT = Path(__file__).resolve().parents[2]
+sys.path.insert(0, str(PROJECT_ROOT))
+
+from src.live.deribit import notional_to_amount
+from src.live.shadow import shadow_report
+
+
+def main():
+    argv = sys.argv[1:]
+    offline = "--no-net" in argv
+    equity_override = float(argv[argv.index("--equity") + 1]) if "--equity" in argv else None
+    r = shadow_report(offline=offline, equity_override=equity_override)
+
+    print("=" * 84)
+    print("  TP01 LIVE — SHADOW MODE  (Deribit mainnet, SOLA LETTURA — NESSUN ORDINE INVIATO)")
+    print("=" * 84)
+    real_eq = r["real_equity"]
+    conto = f"${real_eq:,.2f}" if real_eq else r["eq_basis"]
+    print(f"  ultima barra 1d chiusa : {r['last_data']}")
+    print(f"  rete                   : {'mainnet via Cerbero MCP' if r['online'] else 'OFFLINE / fallback close'}")
+    print(f"  prezzi mark            : " + " | ".join(f"{a['asset']} ${a['mark']:,.1f} ({a['mark_src']})" for a in r["assets"]))
+    print(f"  conto reale            : {conto}")
+    print(f"  posizioni reali        : " + ", ".join(f"{a['asset']} ${a['position_usd']:,.0f}" for a in r["assets"]) + f"  ({r['pos_src']})")
+    print(f"  base di sizing         : ${r['equity']:,.2f}  [{r['eq_basis']}]")
+
+    print("\n  PER ASSET (target causale @ ultima barra chiusa):")
+    for a in r["assets"]:
+        state = "FLAT" if abs(a["target"]) < 1e-9 else ("LONG" if a["target"] > 0 else "SHORT")
+        line = (f"    {a['asset']:<3} {state:<5} target {a['target']:+.3f}x -> notional ${a['target_notional']:,.0f}"
+                f"  (pos reale ${a['position_usd']:,.0f})")
+        o = a["order"]
+        if o:
+            print(line + f"\n        -> ORDINE: {o['side'].upper()} {o['amount']:.0f} {a['instrument']} "
+                  f"(market{', reduce_only' if o['reduce_only'] else ''}, delta ${o['delta_notional']:,.0f})")
+        else:
+            print(line + "  -> nessun ordine (gia' a target / sotto-soglia)")
+
+    print("\n  PARITA' vs paper trader (target = current_target):")
+    if all(a["paper"] is None for a in r["assets"]):
+        print("    (paper non inizializzato: avvia scripts/live/paper_trend.py)")
+    else:
+        for a in r["assets"]:
+            print(f"    {a['asset']}: paper {a['paper']:+.3f}x  shadow {a['target']:+.3f}x  -> {'OK' if a['parity'] else 'DIFFERISCE'}")
+        if not r["paper_aligned"]:
+            print("    NB paper non all'ultima barra -> avanzalo se i target differiscono")
+
+    print("\n  VERIFICA costruttore ordini (quantizzazione step/minimo):")
+    for inst, samples in (("BTC-PERPETUAL", [1000, 1005, 7, 250.4]), ("ETH-PERPETUAL", [1000, 0.4, 33.7])):
+        got = ", ".join(f"${s}->{notional_to_amount(inst, s):.0f}" for s in samples)
+        print(f"    {inst}: {got}")
+
+    print("\n  => NESSUN ORDINE INVIATO (shadow). " +
+          (f"{len(r['orders'])} ordine/i costruito/i sopra." if r["orders"] else "Target flat: 0 ordini."))
+
+
+if __name__ == "__main__":
+    main()

scripts/live/microtest.py

@@ -0,0 +1,92 @@
+"""MICRO-TEST esecuzione su Deribit mainnet — round-trip minimo su BTC_USDC-PERPETUAL, apri+chiudi.
+
+Conto reale = USDC -> strumento ESEGUIBILE = perp LINEARE `BTC_USDC-PERPETUAL` (amount in BTC, step
+0.0001 ~ $6). Valida il percorso ordine->fill->reconciliation->chiusura con soldi VERI a size MINIMA
+(~0x leva, decoupled dal segnale): test della plumbing, non della strategia. Usa open()/close()
+verificati di src/live/execution.py (logica entrata/uscita presa da Old).
+
+Sicurezze: default DRY-RUN. Pre-flight ABORT se posizione preesistente. La chiusura (reduce_only,
+sempre permessa) flatta comunque dopo l'apertura; verifica finale di FLAT (alert se no).
+
+  uv run python scripts/live/microtest.py            # DRY-RUN: nessun ordine inviato
+  uv run python scripts/live/microtest.py --live      # invia il round-trip REALE
+"""
+from __future__ import annotations
+
+import sys
+from pathlib import Path
+
+PROJECT_ROOT = Path(__file__).resolve().parents[2]
+sys.path.insert(0, str(PROJECT_ROOT))
+
+from src.live.execution import FLAT_USD, MAX_AMOUNT, DeribitTrader
+
+INSTRUMENT = "BTC_USDC-PERPETUAL"
+AMOUNT = 0.0001          # base-coin (BTC) = 1 contratto minimo (~$6 a $63k)
+
+
+def main():
+    live = "--live" in sys.argv[1:]
+    t = DeribitTrader()
+
+    print("=" * 82)
+    print("  MICRO-TEST esecuzione TP01 — round-trip 0.0001 BTC su BTC_USDC-PERPETUAL (leva ~0x)")
+    print("=" * 82)
+    try:
+        equity = float(t.account_summary("USDC").get("equity") or 0)
+        mark = t.mark_price(INSTRUMENT)
+        pos0 = t.position_usd(INSTRUMENT)
+    except Exception as e:
+        print(f"  PRE-FLIGHT FALLITO (read): {type(e).__name__}: {e}\n  -> non procedo.")
+        return
+
+    notional = AMOUNT * mark
+    print(f"  conto USDC equity : ${equity:,.2f}")
+    print(f"  mark {INSTRUMENT} : ${mark:,.1f}")
+    print(f"  posizione attuale : ${pos0:,.2f} notional  (dev'essere 0)")
+    print(f"  apertura : BUY  {AMOUNT:.4f} BTC market  (~${notional:.2f}, leva {notional/equity:.4f}x)")
+    print(f"  chiusura : SELL {AMOUNT:.4f} BTC market reduce_only")
+    print(f"  guardrail: solo {INSTRUMENT}, cap apertura {MAX_AMOUNT[INSTRUMENT]} BTC")
+
+    if abs(pos0) >= FLAT_USD:
+        print(f"\n  ABORT: posizione preesistente (${pos0:,.2f}). Non la tocco. Chiudila a mano e ripeti.")
+        return
+    if not live:
+        print("\n  DRY-RUN: nessun ordine inviato. Rilancia con --live per il round-trip reale.")
+        return
+
+    # ---- LIVE: apertura ----
+    print("\n  >>> LIVE: APERTURA ...")
+    fo = t.open(INSTRUMENT, "buy", AMOUNT, label="tp01-microtest-open")
+    if not fo.verified:
+        print(f"      apertura NON verificata: {fo.notes}")
+        # safety: assicura comunque il flat
+        fc = t.close(INSTRUMENT, label="tp01-microtest-safeclose")
+        print(f"      safe-close: {'eseguita' if fc else 'gia flat'}; posizione ${t.position_usd(INSTRUMENT):,.2f}")
+        return
+    print(f"      FILL: {fo.filled:.4f} BTC @ ${fo.price:,.1f}  fee {fo.fee_usdc:.6f} USDC  (state={fo.state})")
+
+    # ---- LIVE: chiusura (reduce_only) ----
+    print("  >>> LIVE: CHIUSURA (reduce_only) ...")
+    fc = t.close(INSTRUMENT, label="tp01-microtest-close")
+    pos_end = t.position_usd(INSTRUMENT)
+    if fc:
+        print(f"      FILL: {fc.filled:.4f} BTC @ ${fc.price:,.1f}  fee {fc.fee_usdc:.6f} USDC  (state={fc.state})")
+    print(f"      posizione finale: ${pos_end:,.2f} notional")
+
+    # ---- report ----
+    print("\n  " + "-" * 62)
+    if abs(pos_end) < FLAT_USD:
+        print("  ✓ ROUND-TRIP COMPLETO — posizione tornata a FLAT.")
+    else:
+        print(f"  ⚠️ posizione NON flat (${pos_end:,.2f}) — INTERVENTO MANUALE: chiudi a mano.")
+    if fo.verified and fc:
+        tot_fee = fo.fee_usdc + fc.fee_usdc
+        pnl = AMOUNT * ((fc.price or 0) - (fo.price or 0))
+        print(f"  entry ${fo.price:,.1f} -> exit ${fc.price:,.1f} | fee {tot_fee:.6f} USDC | "
+              f"pnl lordo {pnl:+.4f} | netto {pnl - tot_fee:+.4f} USDC")
+    print("  Validato: invio ordine reale, fill, fee reali, reconciliation, ritorno a flat.")
+
+
+if __name__ == "__main__":
+    main()

scripts/live/paper_combo.py

@@ -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()

scripts/live/paper_prevday.py

@@ -0,0 +1,182 @@
+"""FORWARD-MONITOR — PREVDAY RANGE BREAKOUT (lead ortogonale a TP01), forward-only, PAPER.
+
+NON è esecuzione reale. È il monitoraggio forward-only del LEAD validato dall'onda intraday
+(src/strategies/prevday_breakout.py, parametri CONGELATI) per vedere se l'edge in-sample regge
+FUORI CAMPIONE VERO nei prossimi mesi. Stesso trattamento di XS01 STAT-MODE / STA05.
+
+DESIGN (onesto):
+  - Legge i parquet certificati BTC/ETH 1h (data/raw). Segnale a 1h, libro 50/50.
+  - Alla prima esecuzione parte dall'ultima barra 1h CHIUSA (forward-only: lo storico NON entra
+    nel PnL di paper, si traccia solo da ora in avanti).
+  - Ogni run processa le NUOVE barre 1h chiuse: applica il rendimento della posizione tenuta,
+    addebita le fee sul turnover, registra i flip di segno, poi ricalcola la posizione-bersaglio.
+  - Traccia DUE libri in parallelo per onestà sull'esecuzione (lo scettico ha segnalato che a $600
+    il micro-ribilanciamento del vol-target ha un haircut di fill):
+      * MODELED  : capitale nominale $2000, ribilanciamento continuo (fee proporzionale su ogni |Δ|).
+      * REAL-$600: capitale reale $600, salta i ribilanciamenti di nozionale < min_order ($5) —
+        cosa che il conto vero catturerebbe davvero. Il gap MODELED-REAL = l'haircut di fill reale.
+  - Per barre fresche, aggiornare prima i dati:
+        uv run python scripts/analysis/rebuild_history.py --asset BTC ETH
+
+Stato: data/paper_prevday/{state.json, trades.jsonl, returns.jsonl} (append-only).
+
+    uv run python scripts/live/paper_prevday.py            # avanza col dato disponibile
+    uv run python scripts/live/paper_prevday.py --status    # solo stato, non avanza
+    uv run python scripts/live/paper_prevday.py --reset      # azzera (riparte da ora)
+"""
+from __future__ import annotations
+
+import argparse
+import json
+import sys
+from pathlib import Path
+
+import numpy as np
+import pandas as pd
+
+PROJECT_ROOT = Path(__file__).resolve().parents[2]
+sys.path.insert(0, str(PROJECT_ROOT))
+
+from src.backtest.harness import load                                   # noqa: E402
+from src.strategies.prevday_breakout import target as prevday_target    # noqa: E402
+from src.strategies import prevday_breakout as pb                       # noqa: E402
+
+STATE_DIR = PROJECT_ROOT / "data" / "paper_prevday"
+STATE_FILE = STATE_DIR / "state.json"
+TRADES_FILE = STATE_DIR / "trades.jsonl"
+RETURNS_FILE = STATE_DIR / "returns.jsonl"
+ASSETS = ["BTC", "ETH"]
+WEIGHT = 0.5
+FEE_SIDE = 0.0005              # 0.05%/side = 0.10% round-trip (Deribit taker)
+MODELED_CAPITAL = 2000.0       # nominale, ribilanciamento continuo
+REAL_CAPITAL = 600.0           # capitale mainnet reale
+MIN_ORDER = 5.0                # min order Deribit -> sotto, il conto vero NON ribilancia
+
+
+def build_bars() -> dict[str, pd.DataFrame]:
+    return {a: load(a, "1h").reset_index(drop=True) for a in ASSETS}
+
+
+def _state_io(write: dict | None = None):
+    if write is not None:
+        STATE_DIR.mkdir(parents=True, exist_ok=True)
+        STATE_FILE.write_text(json.dumps(write, indent=2))
+        return write
+    return json.loads(STATE_FILE.read_text()) if STATE_FILE.exists() else None
+
+
+def _append(path: Path, rec: dict):
+    STATE_DIR.mkdir(parents=True, exist_ok=True)
+    with open(path, "a") as f:
+        f.write(json.dumps(rec) + "\n")
+
+
+def init_state(dfs) -> dict:
+    last_ts = min(int(dfs[a]["timestamp"].iloc[-1]) for a in ASSETS)
+    pos = {a: pb.current_target(dfs[a][dfs[a]["timestamp"] <= last_ts]) for a in ASSETS}
+    return dict(
+        start_ts=last_ts, last_ts=last_ts, n_bars=0,
+        pos_modeled=pos, pos_real=dict(pos),
+        cap_modeled=MODELED_CAPITAL, cap_real=REAL_CAPITAL,
+        peak_modeled=MODELED_CAPITAL, peak_real=REAL_CAPITAL,
+        dd_modeled=0.0, dd_real=0.0, n_trades=0,
+    )
+
+
+def advance(st: dict, dfs: dict) -> dict:
+    data = {}
+    for a in ASSETS:
+        df = dfs[a]
+        c = df["close"].values.astype(float)
+        r = np.zeros(len(c)); r[1:] = c[1:] / c[:-1] - 1.0
+        data[a] = dict(ts=df["timestamp"].values.astype("int64"),
+                       dt=pd.to_datetime(df["datetime"]).values, r=r,
+                       tgt=prevday_target(df))
+    common = sorted(set(data["BTC"]["ts"]).intersection(data["ETH"]["ts"]))
+    new_ts = [t for t in common if t > st["last_ts"]]
+    if not new_ts:
+        return st
+    idx = {a: {int(t): i for i, t in enumerate(data[a]["ts"])} for a in ASSETS}
+    pm, pr = dict(st["pos_modeled"]), dict(st["pos_real"])
+    cm, cr = st["cap_modeled"], st["cap_real"]
+    pkm, pkr = st["peak_modeled"], st["peak_real"]
+    ddm, ddr = st["dd_modeled"], st["dd_real"]
+    ntr = st.get("n_trades", 0)
+
+    for t in new_ts:
+        net_m = net_r = 0.0
+        nm, nr = {}, {}
+        for a in ASSETS:
+            i = idx[a][int(t)]
+            r = float(data[a]["r"][i]); tgt = float(data[a]["tgt"][i])
+            # MODELED: continuous rebalance
+            hm = pm[a]
+            net_m += WEIGHT * (hm * r - FEE_SIDE * abs(tgt - hm))
+            nm[a] = tgt
+            if np.sign(tgt) != np.sign(hm):
+                _append(TRADES_FILE, dict(ts=int(t), dt=str(pd.Timestamp(data[a]["dt"][i])),
+                        asset=a, action="ENTRY" if tgt != 0 else "EXIT",
+                        from_pos=round(hm, 4), to_pos=round(tgt, 4)))
+                ntr += 1
+            # REAL-$600: skip sub-min_order rebalances
+            hr = pr[a]
+            leg_cap = cr * WEIGHT
+            executed = abs(tgt - hr) * leg_cap >= MIN_ORDER
+            new_hr = tgt if executed else hr
+            net_r += WEIGHT * (hr * r - FEE_SIDE * abs(new_hr - hr))
+            nr[a] = new_hr
+        cm *= (1.0 + max(net_m, -0.99)); cr *= (1.0 + max(net_r, -0.99))
+        pkm = max(pkm, cm); pkr = max(pkr, cr)
+        ddm = max(ddm, (pkm - cm) / pkm if pkm > 0 else 0.0)
+        ddr = max(ddr, (pkr - cr) / pkr if pkr > 0 else 0.0)
+        pm, pr = nm, nr
+        _append(RETURNS_FILE, dict(ts=int(t), dt=str(pd.Timestamp(data["BTC"]["dt"][idx["BTC"][int(t)]])),
+                net_modeled=round(net_m, 6), net_real=round(net_r, 6),
+                pos_btc=round(pr["BTC"], 4), pos_eth=round(pr["ETH"], 4),
+                cap_modeled=round(cm, 2), cap_real=round(cr, 2)))
+
+    st.update(last_ts=int(new_ts[-1]), n_bars=st.get("n_bars", 0) + len(new_ts),
+              pos_modeled=pm, pos_real=pr, cap_modeled=cm, cap_real=cr,
+              peak_modeled=pkm, peak_real=pkr, dd_modeled=ddm, dd_real=ddr, n_trades=ntr)
+    return st
+
+
+def print_status(st: dict, dfs: dict):
+    days = (max(int(dfs[a]["timestamp"].iloc[-1]) for a in ASSETS) - st["start_ts"]) / 86400_000
+    rm = st["cap_modeled"] / MODELED_CAPITAL - 1
+    rr = st["cap_real"] / REAL_CAPITAL - 1
+    print(f"\n  PREVDAY-BREAKOUT forward-monitor (PAPER, lead ortogonale a TP01 — non deploy)")
+    print(f"  forward da {pd.Timestamp(st['start_ts'], unit='ms', tz='UTC').date()}  "
+          f"({st['n_bars']} barre 1h ~{days:.0f}g)   trade(flip): {st['n_trades']}")
+    print(f"  posizione corrente: BTC {st['pos_real']['BTC']:+.3f}  ETH {st['pos_real']['ETH']:+.3f}")
+    print(f"  MODELED  ($2000 nominale): {rm*100:+6.2f}%   eq ${st['cap_modeled']:.2f}   maxDD {st['dd_modeled']*100:.1f}%")
+    print(f"  REAL-$600 (min-order $5) : {rr*100:+6.2f}%   eq ${st['cap_real']:.2f}   maxDD {st['dd_real']*100:.1f}%")
+    print(f"  -> fill-haircut MODELED-REAL: {(rm-rr)*100:+.2f} pp  (lo scettico l'aveva segnalato)")
+    print(f"  log: {RETURNS_FILE}\n")
+
+
+def main():
+    ap = argparse.ArgumentParser()
+    ap.add_argument("--status", action="store_true")
+    ap.add_argument("--reset", action="store_true")
+    args = ap.parse_args()
+    dfs = build_bars()
+    if args.reset:
+        for p in (STATE_FILE, TRADES_FILE, RETURNS_FILE):
+            if p.exists():
+                p.unlink()
+        st = init_state(dfs); _state_io(st)
+        print("forward-monitor inizializzato (forward-only da ora).")
+        print_status(st, dfs); return
+    st = _state_io()
+    if st is None:
+        st = init_state(dfs); _state_io(st)
+        print("forward-monitor inizializzato (forward-only da ora).")
+        print_status(st, dfs); return
+    if not args.status:
+        st = advance(st, dfs); _state_io(st)
+    print_status(st, dfs)
+
+
+if __name__ == "__main__":
+    main()

scripts/live/paper_statarb.py

@@ -0,0 +1,176 @@
+"""FORWARD-MONITOR — STATARB-RESID (relative-value ETH/BTC, dollar-neutral 2 gambe), PAPER.
+
+NON è esecuzione reale. È il monitoraggio forward-only del LEAD dello sweep 2026-06-29 (thread
+"segnali ortogonali"): il PRIMO stream visto che è INSIEME ortogonale al book (corr→book 0.027,
+beta-mkt 0.013) ED eseguibile a $600 (book a 2 gambe BTC+ETH perp, NON STAT-MODE come XS01). Resta
+sotto la soglia solo sull'EDGE (Sharpe ~0.84, deflated-Sharpe <0.95 su storia ~2.5 anni). Questo
+monitor accumula la finestra OUT-OF-SAMPLE VERA per decidere se l'edge regge — stesso trattamento di
+PREVDAY/STA05/XS01 STAT-MODE. Nessun edge creduto prima.
+
+ⓘ NATURA DEL SEGNALE (onesto): la cella vincente è W=45 **sgn=+1**, NON sgn=-1. Cioè il residuo di
+ETH dopo β·BTC (β OLS rolling causale) viene seguito in MOMENTUM (long lo spread quando ETH è ricco
+vs il suo fit su BTC), non in mean-reversion: le dislocazioni relative ETH-vs-BTC CONTINUANO a 1d
+(la MR pura, sgn=-1, perde -1.4 in-sample). È relative-MOMENTUM, dollar-neutral → ortogonale al
+trend assoluto di TP01.
+
+CONFIG CONGELATA (dallo sweep, selezione IN-SAMPLE-only, mai sul max hold-out):
+    W=45, sgn=+1, tf=1d, vol-target 20%, leva cap 2x.  Riusa il segnale ESATTO di
+    scripts/research/orthogonal_signals.py (nessuna reimplementazione → niente drift).
+
+DESIGN (onesto, come paper_prevday):
+  - Legge BTC/ETH 1d certificati (build_joint), calcola il segnale CAUSALE su tutta la storia.
+  - Alla prima esecuzione fissa l'INCEPTION all'ultima barra 1d chiusa (forward-only: lo storico
+    NON entra nel PnL di paper).
+  - Ogni run processa le NUOVE barre 1d chiuse: applica il rendimento dello spread tenuto,
+    addebita le fee su 2 GAMBE (ogni Δpos muove ETH e BTC → 2×|Δpos|), registra i flip di segno.
+  - DUE libri in parallelo (onestà sull'esecuzione a piccolo capitale):
+      * MODELED  : capitale nominale $2000, ribilanciamento continuo (fee su ogni |Δpos|).
+      * REAL-$600: capitale reale $600, salta i ribilanci di nozionale-per-gamba < min_order ($5)
+        → il gap MODELED-REAL = l'haircut di fill reale (qui ~0: turnover bassissimo a 1d).
+  - Per barre fresche aggiornare prima i dati:  uv run python scripts/analysis/rebuild_history.py --asset BTC ETH
+
+Stato: data/paper_statarb/{state.json, trades.jsonl, returns.jsonl} (append-only).
+
+    uv run python scripts/live/paper_statarb.py            # avanza col dato disponibile
+    uv run python scripts/live/paper_statarb.py --status   # solo stato, non avanza
+    uv run python scripts/live/paper_statarb.py --reset     # azzera (riparte da ora)
+"""
+from __future__ import annotations
+
+import argparse
+import json
+import sys
+from pathlib import Path
+
+import numpy as np
+import pandas as pd
+
+PROJECT_ROOT = Path(__file__).resolve().parents[2]
+sys.path.insert(0, str(PROJECT_ROOT))
+sys.path.insert(0, str(PROJECT_ROOT / "scripts" / "research"))
+
+# Segnale ESATTO dello sweep (nessuna reimplementazione → identità garantita col backtest).
+from orthogonal_signals import build_joint, f_statarb_resid, spread_ret  # noqa: E402
+
+STATE_DIR = PROJECT_ROOT / "data" / "paper_statarb"
+STATE_FILE = STATE_DIR / "state.json"
+TRADES_FILE = STATE_DIR / "trades.jsonl"
+RETURNS_FILE = STATE_DIR / "returns.jsonl"
+
+# --- CONFIG CONGELATA (frozen) -----------------------------------------------------------
+W_FROZEN = 45
+SGN_FROZEN = +1
+FEE_SIDE = 0.0005              # 0.05%/side = 0.10% round-trip (Deribit taker)
+MODELED_CAPITAL = 2000.0       # nominale, ribilanciamento continuo
+REAL_CAPITAL = 600.0           # capitale mainnet reale
+MIN_ORDER = 5.0                # min order Deribit -> sotto, il conto vero NON ribilancia
+
+
+def _signal(j: pd.DataFrame):
+    """(ts, dt, pos, sr): posizione vol-targeted sullo spread (decisa <= close[i]) + ritorno spread."""
+    pos = np.nan_to_num(f_statarb_resid(W=W_FROZEN, sgn=SGN_FROZEN)(j))
+    return (j["timestamp"].values.astype("int64"),
+            pd.to_datetime(j["datetime"]).values, pos, spread_ret(j))
+
+
+def _state_io(write: dict | None = None):
+    if write is not None:
+        STATE_DIR.mkdir(parents=True, exist_ok=True)
+        STATE_FILE.write_text(json.dumps(write, indent=2))
+        return write
+    return json.loads(STATE_FILE.read_text()) if STATE_FILE.exists() else None
+
+
+def _append(path: Path, rec: dict):
+    STATE_DIR.mkdir(parents=True, exist_ok=True)
+    with open(path, "a") as f:
+        f.write(json.dumps(rec) + "\n")
+
+
+def init_state(j: pd.DataFrame) -> dict:
+    ts, _, pos, _ = _signal(j)
+    last = int(ts[-1])
+    return dict(start_ts=last, last_ts=last, n_bars=0,
+                pos_modeled=float(pos[-1]), pos_real=float(pos[-1]),
+                cap_modeled=MODELED_CAPITAL, cap_real=REAL_CAPITAL,
+                peak_modeled=MODELED_CAPITAL, peak_real=REAL_CAPITAL,
+                dd_modeled=0.0, dd_real=0.0, n_trades=0)
+
+
+def advance(st: dict, j: pd.DataFrame) -> dict:
+    ts, dt, pos, sr = _signal(j)
+    new = [i for i in range(len(ts)) if ts[i] > st["last_ts"]]
+    if not new:
+        return st
+    pm, pr = st["pos_modeled"], st["pos_real"]          # posizioni TENUTE (decise alla barra precedente)
+    cm, cr = st["cap_modeled"], st["cap_real"]
+    pkm, pkr, ddm, ddr = st["peak_modeled"], st["peak_real"], st["dd_modeled"], st["dd_real"]
+    ntr = st.get("n_trades", 0)
+    for i in new:
+        s = float(sr[i])
+        tgt = float(pos[i])                              # bersaglio deciso a close[i] (eseguito da i+1)
+        # MODELED: rendimento dello spread tenuto durante la barra i, poi ribilancia al target
+        net_m = pm * s - FEE_SIDE * 2.0 * abs(tgt - pm)
+        # REAL-$600: salta i ribilanci sub-min_order (nozionale per-gamba |Δpos|*cap < $5)
+        executed = abs(tgt - pr) * REAL_CAPITAL >= MIN_ORDER
+        new_pr = tgt if executed else pr
+        net_r = pr * s - FEE_SIDE * 2.0 * abs(new_pr - pr)
+        if np.sign(new_pr) != np.sign(pr):
+            _append(TRADES_FILE, dict(ts=int(ts[i]), dt=str(pd.Timestamp(dt[i])),
+                    action="FLIP", from_pos=round(pr, 4), to_pos=round(new_pr, 4)))
+            ntr += 1
+        cm *= (1.0 + max(net_m, -0.99)); cr *= (1.0 + max(net_r, -0.99))
+        pkm = max(pkm, cm); pkr = max(pkr, cr)
+        ddm = max(ddm, (pkm - cm) / pkm if pkm > 0 else 0.0)
+        ddr = max(ddr, (pkr - cr) / pkr if pkr > 0 else 0.0)
+        pm, pr = tgt, new_pr
+        _append(RETURNS_FILE, dict(ts=int(ts[i]), dt=str(pd.Timestamp(dt[i])),
+                net_modeled=round(net_m, 6), net_real=round(net_r, 6),
+                pos=round(new_pr, 4), cap_modeled=round(cm, 2), cap_real=round(cr, 2)))
+    st.update(last_ts=int(ts[new[-1]]), n_bars=st.get("n_bars", 0) + len(new),
+              pos_modeled=pm, pos_real=pr, cap_modeled=cm, cap_real=cr,
+              peak_modeled=pkm, peak_real=pkr, dd_modeled=ddm, dd_real=ddr, n_trades=ntr)
+    return st
+
+
+def print_status(st: dict, j: pd.DataFrame):
+    last_data = int(j["timestamp"].iloc[-1])
+    days = (last_data - st["start_ts"]) / 86400_000
+    rm = st["cap_modeled"] / MODELED_CAPITAL - 1
+    rr = st["cap_real"] / REAL_CAPITAL - 1
+    print("\n  STATARB-RESID forward-monitor (PAPER — relative-value ETH/BTC, ortogonale, NON deploy)")
+    print(f"  config CONGELATA: W={W_FROZEN} sgn={SGN_FROZEN:+d} (residual relative-momentum, dollar-neutral)")
+    print(f"  forward da {pd.Timestamp(st['start_ts'], unit='ms', tz='UTC').date()}  "
+          f"({st['n_bars']} barre 1d ~{days:.0f}g)   flip di segno: {st['n_trades']}")
+    print(f"  posizione spread corrente (long ETH / short BTC per unità): {st['pos_real']:+.3f}")
+    print(f"  MODELED  ($2000 nominale): {rm*100:+6.2f}%   eq ${st['cap_modeled']:.2f}   maxDD {st['dd_modeled']*100:.1f}%")
+    print(f"  REAL-$600 (min-order $5) : {rr*100:+6.2f}%   eq ${st['cap_real']:.2f}   maxDD {st['dd_real']*100:.1f}%")
+    print(f"  -> fill-haircut MODELED-REAL: {(rm-rr)*100:+.2f} pp  (atteso ~0: turnover basso a 1d)")
+    print(f"  log: {RETURNS_FILE}\n")
+
+
+def main():
+    ap = argparse.ArgumentParser()
+    ap.add_argument("--status", action="store_true")
+    ap.add_argument("--reset", action="store_true")
+    args = ap.parse_args()
+    j = build_joint("1d")
+    if args.reset:
+        for p in (STATE_FILE, TRADES_FILE, RETURNS_FILE):
+            if p.exists():
+                p.unlink()
+        st = init_state(j); _state_io(st)
+        print("forward-monitor STATARB-RESID inizializzato (forward-only da ora).")
+        print_status(st, j); return
+    st = _state_io()
+    if st is None:
+        st = init_state(j); _state_io(st)
+        print("forward-monitor STATARB-RESID inizializzato (forward-only da ora).")
+        print_status(st, j); return
+    if not args.status:
+        st = advance(st, j); _state_io(st)
+    print_status(st, j)
+
+
+if __name__ == "__main__":
+    main()

scripts/portfolio/forecast_deribit_book.py

@@ -0,0 +1,106 @@
+"""PROIEZIONE ACCUMULO del book DERIBIT-ONLY (TP01 + SKH01) — compounding puro (reinvesti le
+vincite), allineamento MENSILE, NESSUN versamento esterno (non e' un PAC).
+
+Base: rendimenti mensili del book Deribit-only (rebal mensile, netto costo turnover). Proietta in
+avanti l'equity da un capitale iniziale:
+  - DETERMINISTICO @CAGR storico  e  @CAGR conservativo (= storico × cons_frac, default metà);
+  - MONTE CARLO block-bootstrap dei rendimenti mensili storici (mediana + banda p10/p90);
+  - €/giorno run-rate (cresce col capitale, perche' si rigiocano le vincite).
+
+⚠️ ONESTA': lo storico e' un BULL crypto ~2019-26 -> il futuro sara' quasi certamente piu' magro.
+Pianificare sulla colonna conservativa; il MC non contiene un vero bear pluriennale (anche il p10
+e' ottimista). Nessuna leva. SKH01 e' research/forward-monitor (solo TP01 e' armato live). Non e'
+una garanzia: e' una proiezione condizionata "se il futuro somigliasse al passato".
+
+    uv run python scripts/portfolio/forecast_deribit_book.py
+    uv run python scripts/portfolio/forecast_deribit_book.py --capital 5000 --years 1,3,5,10 --cons-frac 0.5
+"""
+from __future__ import annotations
+import argparse
+import sys
+from pathlib import Path
+PROJECT_ROOT = Path(__file__).resolve().parents[2]
+sys.path.insert(0, str(PROJECT_ROOT))
+import numpy as np
+import pandas as pd
+
+from src.portfolio.portfolio import StrategyPortfolio, rebalance_sim
+from src.portfolio.sleeves import deribit_book_sleeves
+
+
+def book_monthly_returns(rebal_days: int, cost_rate: float) -> pd.Series:
+    """Rendimenti MENSILI del book Deribit-only (rebal periodico, netto costo)."""
+    sl = deribit_book_sleeves()
+    w = StrategyPortfolio(sl).weights()
+    cols = {s.name: s.daily() for s in sl}
+    r = rebalance_sim(cols, w, period_days=rebal_days, cost_rate=cost_rate)["daily"]
+    return ((1.0 + r).resample("ME").prod() - 1.0).dropna()
+
+
+def main():
+    ap = argparse.ArgumentParser(description="Proiezione accumulo book Deribit-only (compounding, allineamento mensile)")
+    ap.add_argument("--capital", type=float, default=5000.0)
+    ap.add_argument("--years", type=str, default="1,2,3,5,8,10")
+    ap.add_argument("--cons-frac", type=float, default=0.5, help="CAGR conservativo = storico × questo (default 0.5)")
+    ap.add_argument("--sims", type=int, default=4000)
+    ap.add_argument("--block-months", type=int, default=3, help="blocco del bootstrap (mesi)")
+    ap.add_argument("--rebal-days", type=int, default=30)
+    ap.add_argument("--cost-rate", type=float, default=0.0005, help="fee per-lato sul turnover (Deribit taker)")
+    ap.add_argument("--seed", type=int, default=7)
+    a = ap.parse_args()
+
+    cap = a.capital
+    HY = [int(x) for x in a.years.split(",") if x.strip()]
+    m = book_monthly_returns(a.rebal_days, a.cost_rate)
+    mv = m.values
+    nm = len(mv)
+    g_month = float(np.prod(1.0 + mv) ** (1.0 / nm) - 1.0)
+    cagr = (1.0 + g_month) ** 12 - 1.0
+    vol_ann = float(mv.std() * np.sqrt(12))
+    cons_cagr = cagr * a.cons_frac
+
+    print("=" * 90)
+    print(f"  PROIEZIONE ACCUMULO — book Deribit-only (TP01+SKH01) | compounding, allineamento mensile, no versamenti")
+    print(f"  storico: {nm} mesi · CAGR {cagr*100:.1f}% · vol annua {vol_ann*100:.0f}% (bull crypto, no leva) | capitale €{cap:,.0f}")
+    print("=" * 90)
+
+    # Monte Carlo: block-bootstrap dei rendimenti mensili
+    rng = np.random.default_rng(a.seed)
+    blk = a.block_months
+    maxM = max(HY) * 12
+    nb = maxM // blk + 1
+    starts = rng.integers(0, nm - blk, size=(a.sims, nb))
+    paths = np.concatenate([mv[starts[:, k][:, None] + np.arange(blk)[None, :]] for k in range(nb)], axis=1)[:, :maxM]
+    eqMC = cap * np.cumprod(1.0 + paths, axis=1)
+
+    cons_m = (1.0 + cons_cagr) ** (1.0 / 12) - 1.0
+    print(f"\n  ACCUMULO (reinvesti le vincite):")
+    print(f"  {'oriz.':>6} | {'det @storico':>13} | {'det @conserv.':>14} | {'MC mediana':>11} | {'MC p10':>9} | {'MC p90':>10}")
+    print(f"  {'':>6} | {'('+format(cagr*100,'.0f')+'%)':>13} | {'('+format(cons_cagr*100,'.0f')+'%)':>14} |")
+    print("  " + "-" * 80)
+    for y in HY:
+        mo = y * 12
+        det = cap * (1.0 + g_month) ** mo
+        detc = cap * (1.0 + cons_m) ** mo
+        c = eqMC[:, mo - 1]
+        print(f"  {y:>4}a  | €{det:>11,.0f} | €{detc:>12,.0f} | €{np.median(c):>9,.0f} | €{np.percentile(c,10):>7,.0f} | €{np.percentile(c,90):>8,.0f}")
+
+    # €/giorno run-rate @conservativo (cresce col capitale)
+    rd = (1.0 + cons_cagr) ** (1.0 / 365.0) - 1.0
+    print(f"\n  €/GIORNO run-rate @conservativo ({cons_cagr*100:.1f}% CAGR) — cresce col capitale (rigiochi le vincite):")
+    print(f"  {'oriz.':>6} | {'equity':>9} | {'€/giorno':>10} | {'€/mese':>8}")
+    print("  " + "-" * 42)
+    for y in [0] + HY:
+        E = cap * (1.0 + cons_cagr) ** y
+        print(f"  {('oggi' if y==0 else str(y)+'a'):>6} | €{E:>7,.0f} | €{E*rd:>7,.2f} | €{E*rd*30:>6,.0f}")
+    E_end = cap * (1.0 + cons_cagr) ** max(HY)
+    print(f"  media €/giorno su {max(HY)} anni: €{(E_end-cap)/(max(HY)*365):.2f}/g  (profitto €{E_end-cap:,.0f})")
+    need = 50 * 365 / cons_cagr if cons_cagr > 0 else float('inf')
+    print(f"  capitale per ~€50/giorno @{cons_cagr*100:.1f}%: ≈ €{need:,.0f}")
+
+    print(f"\n  ⚠️  Proiezione condizionata (storico = bull crypto); pianifica sul conservativo. Nessuna leva.")
+    print(f"      SKH01 = research/forward-monitor; solo TP01 e' armato live. Non e' una garanzia.")
+
+
+if __name__ == "__main__":
+    main()

scripts/portfolio/prevday_overlay.py

@@ -0,0 +1,115 @@
+"""SIMULAZIONE — PREVDAY come overlay di tail-hedge sul portafoglio attivo (NON deploy).
+
+PREVDAY (src/strategies/prevday_breakout) resta in FORWARD-MONITOR. Qui misuriamo SOLO, in
+simulazione, cosa farebbe al portafoglio live (TP01 55% + XS01 25% + VRP01 20%) aggiungerlo come
+overlay a peso W, riscalando i tre sleeve esistenti a (1-W) e tenendo le loro proporzioni. La
+trilogia (fill-haircut/turnover/bootstrap) ha stabilito che PREVDAY e' un HEDGE di regime-down
+(tutto il valore = gamba short) eseguibile a taglia reale: l'overlay si giudica sul TAGLIO DEL
+DRAWDOWN del portafoglio, non sul ritorno.
+
+NB outer-join: PREVDAY parte dal 2018, XS01 dal 2024, VRP01 dal 2021. I pesi sono rinormalizzati
+ogni giorno fra i soli sleeve con dato -> nel 2019-20 (solo TP01+PREVDAY) PREVDAY pesa di piu' del
+target W; nell'hold-out 2025+ (tutti e 4 attivi) pesa esattamente ~W. Per questo l'HOLD-OUT e' il
+confronto piu' pulito a "peso 10%".
+
+    uv run python scripts/portfolio/prevday_overlay.py
+"""
+from __future__ import annotations
+import sys
+from pathlib import Path
+
+PROJECT_ROOT = Path(__file__).resolve().parents[2]
+sys.path.insert(0, str(PROJECT_ROOT))
+import numpy as np
+import pandas as pd
+
+from src.backtest.harness import load
+from src.strategies import prevday_breakout as pb
+from src.portfolio.portfolio import StrategyPortfolio, Sleeve, metrics, HOLDOUT
+from src.portfolio.sleeves import _tp01_returns, _xsec_returns, _vrp_combo_returns
+
+ASSETS = ("BTC", "ETH")
+FEE_SIDE = 0.0005
+BASE_W = dict(TP01=0.55, XS01=0.25, VRP01=0.20)   # proporzioni dei tre sleeve attivi
+HEADLINE = 0.10
+
+
+def _prevday_returns() -> pd.Series:
+    """Rendimenti netti per-barra (1h) del libro PREVDAY 50/50 BTC+ETH (parametri congelati)."""
+    series = {}
+    for a in ASSETS:
+        df = load(a, "1h").reset_index(drop=True)
+        c = df["close"].values.astype(float)
+        r = np.zeros(len(c)); r[1:] = c[1:] / c[:-1] - 1.0
+        tgt = np.nan_to_num(pb.target(df), nan=0.0)
+        held = np.zeros(len(tgt)); held[1:] = tgt[:-1]
+        net = held * r - FEE_SIDE * np.abs(np.diff(tgt, prepend=tgt[0]))
+        series[a] = pd.Series(net, index=pd.to_datetime(df["datetime"], utc=True))
+    J = pd.concat(series, axis=1, join="inner").fillna(0.0)
+    return pd.Series(0.5 * J.iloc[:, 0].values + 0.5 * J.iloc[:, 1].values, index=J.index)
+
+
+def build_portfolio(series_cache: dict, w_prev: float) -> StrategyPortfolio:
+    """Portafoglio coi 3 sleeve riscalati a (1-w_prev) + PREVDAY a w_prev (0 = baseline)."""
+    sl = [
+        Sleeve("TP01_trend_1d", BASE_W["TP01"] * (1 - w_prev), lambda s=series_cache["TP01"]: s),
+        Sleeve("XS01_xsec_hl", BASE_W["XS01"] * (1 - w_prev), lambda s=series_cache["XS01"]: s),
+        Sleeve("VRP01_shortvol", BASE_W["VRP01"] * (1 - w_prev), lambda s=series_cache["VRP01"]: s),
+    ]
+    if w_prev > 0:
+        sl.append(Sleeve("PREVDAY_hedge", w_prev, lambda s=series_cache["PREVDAY"]: s))
+    return StrategyPortfolio(sl)
+
+
+def line(label, m):
+    return (f"  {label:<22s} Sh {m['sharpe']:>5.2f} | ret {m['ret']*100:>+8.1f}% "
+            f"CAGR {m['cagr']*100:>+6.1f}% | DD {m['maxdd']*100:>5.1f}% | n {m['n']}")
+
+
+def main():
+    print("=" * 92)
+    print("  PREVDAY OVERLAY (simulazione, NON deploy) — tail-hedge sul portafoglio TP01+XS01+VRP01")
+    print("=" * 92)
+    print("  Precalcolo sleeve...", flush=True)
+    cache = dict(TP01=_tp01_returns(), XS01=_xsec_returns(),
+                 VRP01=_vrp_combo_returns(), PREVDAY=_prevday_returns())
+
+    print(f"\n  PREVDAY standalone (per riferimento):")
+    from src.portfolio.portfolio import to_daily
+    pvd = to_daily(cache["PREVDAY"])
+    print(line("PREVDAY full", metrics(pvd)))
+    print(line("PREVDAY hold-out", metrics(pvd[pvd.index >= HOLDOUT])))
+
+    print(f"\n  SWEEP PESO OVERLAY (FULL | HOLD-OUT) — headline {HEADLINE*100:.0f}%:")
+    print(f"  {'peso PREVDAY':<14s} {'FULL Sharpe':>11s} {'FULL DD':>9s} | {'HOLD Sharpe':>11s} {'HOLD DD':>9s} {'HOLD ret':>9s}")
+    rows = {}
+    for w in (0.0, 0.05, 0.10, 0.15, 0.20):
+        bt = build_portfolio(cache, w).backtest()
+        rows[w] = bt
+        tag = "BASELINE" if w == 0 else f"{w*100:.0f}%"
+        star = "  <-- headline" if abs(w - HEADLINE) < 1e-9 else ""
+        print(f"  {tag:<14s} {bt['full']['sharpe']:>11.2f} {bt['full']['maxdd']*100:>8.1f}% | "
+              f"{bt['holdout']['sharpe']:>11.2f} {bt['holdout']['maxdd']*100:>8.1f}% "
+              f"{bt['holdout']['ret']*100:>+8.1f}%{star}")
+
+    base, ov = rows[0.0], rows[HEADLINE]
+    print(f"\n  DETTAGLIO a {HEADLINE*100:.0f}% vs BASELINE:")
+    print(line("BASELINE   FULL", base['full']));   print(line(f"OVERLAY{HEADLINE*100:.0f}% FULL", ov['full']))
+    print(line("BASELINE   HOLD", base['holdout'])); print(line(f"OVERLAY{HEADLINE*100:.0f}% HOLD", ov['holdout']))
+    dSh = ov['holdout']['sharpe'] - base['holdout']['sharpe']
+    dDD = (ov['holdout']['maxdd'] - base['holdout']['maxdd']) * 100
+    print(f"\n  >> HOLD-OUT: ΔSharpe {dSh:+.2f}  |  ΔmaxDD {dDD:+.1f}pp  "
+          f"(tail-hedge = ci aspettiamo DD piu' basso)")
+
+    print(f"\n  PER ANNO (baseline -> overlay {HEADLINE*100:.0f}%): ret%  /  DD%")
+    yb, yo = base['yearly'], ov['yearly']
+    for y in sorted(set(yb) | set(yo)):
+        b = yb.get(y, {}); o = yo.get(y, {})
+        print(f"    {y}: ret {b.get('ret',0)*100:>+7.1f}% -> {o.get('ret',0)*100:>+7.1f}%   "
+              f"DD {b.get('dd',0)*100:>5.1f}% -> {o.get('dd',0)*100:>5.1f}%")
+    print("=" * 92)
+    print("  Nota: PREVDAY resta FORWARD-MONITOR. Questa e' una simulazione di impatto, non un deploy.")
+
+
+if __name__ == "__main__":
+    main()

scripts/portfolio/run_deribit_book.py

@@ -0,0 +1,86 @@
+"""REPORT del BOOK DERIBIT-ONLY realmente eseguibile = TP01 + SKH01 (75/25).
+
+Le due gambe direzionali BTC/ETH sullo STESSO venue (Deribit), entrambe dal 2019. Esclude XS01
+(Hyperliquid, stat-mode) e VRP01 (opzioni modellate). Mostra:
+  1. metriche oneste continuo (rebalance-continuo) vs RIBILANCIAMENTO PERIODICO realistico
+     (settimanale/mensile) con costo turnover Deribit-taker;
+  2. per-anno, accumulo da €2k (e nota €600 reale + min-order $5);
+  3. posizioni correnti per gamba.
+
+    uv run python scripts/portfolio/run_deribit_book.py
+"""
+from __future__ import annotations
+import sys
+from pathlib import Path
+PROJECT_ROOT = Path(__file__).resolve().parents[2]
+sys.path.insert(0, str(PROJECT_ROOT))
+import numpy as np
+
+from src.portfolio.portfolio import StrategyPortfolio, metrics, yearly, rebalance_sim, HOLDOUT
+
+CAP = 2000.0
+REAL = 600.0           # capitale reale (vedi CLAUDE.md), min-order Deribit $5
+COST_RATE = 0.0005     # Deribit taker per-lato (~0.10% RT sul turnover netto)
+
+
+def line(tag, daily, extra=""):
+    m = metrics(daily); h = metrics(daily[daily.index >= HOLDOUT])
+    eqf = CAP * float(np.prod(1.0 + daily.values))
+    print(f"  {tag:<26} FULL Sh {m['sharpe']:.2f} ret {m['ret']*100:+.0f}% DD {m['maxdd']*100:.1f}% "
+          f"| HOLD Sh {h['sharpe']:.2f} DD {h['maxdd']*100:.1f}% | €2k→€{eqf:,.0f} {extra}")
+    return m, h
+
+
+def main():
+    from src.portfolio.sleeves import deribit_book_sleeves
+    sleeves = deribit_book_sleeves()
+    pf = StrategyPortfolio(sleeves, capital=CAP)
+    w = pf.weights()
+    cols = {s.name: s.daily() for s in sleeves}
+
+    print("=" * 100)
+    print(f"  BOOK DERIBIT-ONLY (eseguibile) — {' + '.join(f'{k} {v*100:.0f}%' for k, v in w.items())} "
+          f"| capitale €{CAP:,.0f} (reale ≈ ${REAL:,.0f}) | hold-out {HOLDOUT.date()}+")
+    print("=" * 100)
+
+    # standalone per-gamba
+    print("\n  PER-GAMBA (standalone):")
+    for s in sleeves:
+        d = s.daily(); m = metrics(d); h = metrics(d[d.index >= HOLDOUT])
+        print(f"    {s.name:<16} [{w[s.name]*100:>3.0f}%] FULL Sh {m['sharpe']:.2f} DD {m['maxdd']*100:.0f}% "
+              f"| HOLD Sh {h['sharpe']:.2f} DD {h['maxdd']*100:.0f}%")
+
+    print("\n  COMBINATO — rebalance-CONTINUO (idealizzato, no costi) vs PERIODICO (reale, costo turnover):")
+    cont = pf.combined_daily()
+    line("continuo (no costo)", cont)
+    sims = {}
+    for tag, period in (("settimanale (7g)", 7), ("bisettimanale (14g)", 14), ("mensile (30g)", 30)):
+        sim = rebalance_sim(cols, w, period_days=period, cost_rate=COST_RATE)
+        sims[tag] = sim
+        line(f"rebal {tag}", sim["daily"], extra=f"| turnover {sim['turnover_per_year']:.1f}×/anno, {sim['n_rebalances']} ribilanci")
+
+    # raccomandato = mensile
+    rec = sims["mensile (30g)"]["daily"]
+    print("\n  PER ANNO (rebal mensile, netto costo):")
+    for y, d in yearly(rec).items():
+        print(f"    {y}: ret {d['ret']*100:>+7.1f}%  DD {d['dd']*100:>5.1f}%")
+
+    print("\n  ACCUMULO (rebal mensile):")
+    for cap, lbl in ((CAP, "€2k nominale"), (REAL, "$600 reale")):
+        eq = cap * np.cumprod(1.0 + rec.values)
+        yrs = len(rec) / 365.25
+        print(f"    {lbl:<14}: {cap:,.0f} → {eq[-1]:,.0f}  (×{eq[-1]/cap:.1f}, ~{(eq[-1]-cap)/(yrs*365.25):+,.2f}/g)")
+
+    print("\n  POSIZIONI CORRENTI (ultima barra chiusa):")
+    for name, pos in pf.current_positions().items():
+        print(f"    {name}: {pos if pos is not None else 'segnale dual-TF (no pos-fn) — vedi engine'}")
+
+    print("\n  NOTE ONESTE:")
+    print("    · TP01 = unico armato live su Deribit (flat=risk-off). SKH01 = 2a gamba candidata (perp BTC/ETH).")
+    print("    · SKH01 equity daily-step (Sharpe lens). A $600 il min-order è $5: un ribilancio mensile")
+    print("      muove abbastanza nozionale da eseguirsi; il giornaliero NO (Δ sub-$5 = finzione) → usa ≥ settimanale.")
+    print("    · Prima del deploy 2a gamba: validare causalità sul CODICE D'ESECUZIONE reale e costi del book a 230m.")
+
+
+if __name__ == "__main__":
+    main()

scripts/research/alt/altlib.py

@@ -0,0 +1,904 @@
+"""altlib — SHARED HONEST EVALUATION LIBRARY for the alt-strategy fan-out (2026-06-20).
+
+Built for the "studia altre strategie alternative su Deribit" research wave: >=100 agents,
+each studying ONE distinct strategy hypothesis on the certified BTC/ETH (+ DVOL) universe.
+Every agent imports THIS module so that:
+  * NO look-ahead is structurally possible: a target/weight decided at close[i] is held
+    during bar i+1 (the evaluator shifts it for you — you never multiply by r[i] with a
+    weight that used close[i] for the *same* bar).
+  * Fees are realistic Deribit (0.10% RT taker = 0.0005/side) and a fee SWEEP is built in.
+  * Metrics are comparable: FULL Sharpe/CAGR/maxDD, HOLD-OUT (2025-01-01+), per-year.
+  * Only certified data exists (BTC/ETH from Deribit mainnet, DVOL from Deribit). load()
+    raises on anything else — a physical guardrail.
+
+Two evaluation styles:
+  1. eval_weights(df, target)  -> for CONTINUOUS-position strategies (trend, vol overlays,
+     pairs, risk-parity). `target` is a per-bar position (fraction of equity, sign=dir),
+     decided with data <= close[i]. VECTORIZED (numpy) -> fast even on 68k 1h bars.
+  2. eval_signals(df, entries) -> for DISCRETE entry/exit strategies (breakout w/ TP-SL,
+     mean-reversion bounce). Wraps the project's trade-based harness. Use on 1h/1d only
+     (the Python loop is O(n*max_bars); 5m has 840k bars -> too slow on 2 CPUs).
+
+Quick start (inside an agent script):
+    import sys; sys.path.insert(0, "/opt/docker/PythagorasGoal/scripts/research/alt")
+    import altlib as al
+    rep = al.study_weights("MY-STRAT", lambda df: my_target(df), tfs=("1d","12h"))
+    print(al.fmt(rep)); print(al.as_json(rep))   # human + machine
+"""
+from __future__ import annotations
+
+import inspect
+import json
+import math
+import sys
+from functools import lru_cache
+from pathlib import Path
+
+import numpy as np
+import pandas as pd
+from scipy.stats import norm
+
+# --- make `from src...` work no matter where the agent's script lives -------
+_ROOT = Path(__file__).resolve().parents[3]
+if str(_ROOT) not in sys.path:
+    sys.path.insert(0, str(_ROOT))
+
+from src.backtest.harness import backtest_signals, load  # noqa: E402
+from src.strategies.trend_portfolio import resample_tf  # noqa: E402
+
+HOLDOUT = pd.Timestamp("2025-01-01", tz="UTC")
+FEE_SIDE = 0.0005          # 0.05%/side = 0.10% round-trip (Deribit taker)
+FEE_SWEEP = (0.0, 0.0005, 0.001, 0.0015)   # per-side fee grid for robustness
+CERTIFIED = ("BTC", "ETH")
+DATA_DIR = _ROOT / "data" / "raw"
+
+
+# ===========================================================================
+# DATA (cached) — 1h base, resampled to >=4h; DVOL aligned causally.
+# ===========================================================================
+@lru_cache(maxsize=32)
+def get(asset: str, tf: str) -> pd.DataFrame:
+    """Certified OHLCV with a tz-aware 'datetime' col and RangeIndex.
+    tf in {5m,15m,1h} loaded directly; {4h,6h,8h,12h,1d,2d,3d,1w} resampled from 1h.
+    Resample uses the leak-free per-single-TF path (trend_portfolio.resample_tf)."""
+    asset = asset.upper()
+    if asset not in CERTIFIED:
+        raise ValueError(f"Asset non certificato: {asset}. Universo={CERTIFIED}.")
+    tf = tf.lower()
+    if tf in ("5m", "15m", "1h"):
+        df = load(asset, tf)
+    else:
+        rule = {"4h": "4h", "6h": "6h", "8h": "8h", "12h": "12h",
+                "1d": "1D", "2d": "2D", "3d": "3D", "1w": "1W"}.get(tf)
+        if rule is None:
+            raise ValueError(f"TF non gestito: {tf}")
+        df = resample_tf(load(asset, "1h"), rule)
+    df = df.reset_index(drop=True)
+    if "datetime" not in df.columns:
+        df["datetime"] = pd.to_datetime(df["timestamp"], unit="ms", utc=True)
+    return df
+
+
+@lru_cache(maxsize=8)
+def _dvol_raw(asset: str) -> pd.DataFrame:
+    p = DATA_DIR / f"dvol_{asset.lower()}.parquet"
+    if not p.exists():
+        raise FileNotFoundError(f"DVOL non trovato: {p}")
+    d = pd.read_parquet(p).sort_values("timestamp").reset_index(drop=True)
+    return d
+
+
+def dvol(df: pd.DataFrame, asset: str) -> np.ndarray:
+    """Deribit DVOL (implied vol index) aligned CAUSALLY to df's bars.
+    For each bar we take the most recent DVOL value timestamped at/before the bar's
+    open (merge_asof backward) -> known by decision time. NaN before DVOL history
+    (DVOL starts 2021-03). Returns float array len(df), in vol POINTS (e.g. 65.0)."""
+    d = _dvol_raw(asset)
+    left = pd.DataFrame({"timestamp": df["timestamp"].astype("int64").values})
+    merged = pd.merge_asof(left, d.rename(columns={"close": "dvol"}),
+                           on="timestamp", direction="backward")
+    return merged["dvol"].values.astype(float)
+
+
+# ===========================================================================
+# INDICATORS (all causal: value at i uses data <= i)
+# ===========================================================================
+def simple_returns(c: np.ndarray) -> np.ndarray:
+    r = np.zeros(len(c)); r[1:] = c[1:] / c[:-1] - 1.0
+    return r
+
+
+def log_returns(c: np.ndarray) -> np.ndarray:
+    r = np.zeros(len(c)); r[1:] = np.log(c[1:] / c[:-1])
+    return r
+
+
+def ema(x: np.ndarray, span: int) -> np.ndarray:
+    return pd.Series(x).ewm(span=span, adjust=False).mean().values
+
+
+def sma(x: np.ndarray, win: int) -> np.ndarray:
+    return pd.Series(x).rolling(win, min_periods=win).mean().values
+
+
+def rolling_std(x: np.ndarray, win: int) -> np.ndarray:
+    return pd.Series(x).rolling(win, min_periods=max(2, win // 2)).std().values
+
+
+def zscore(x: np.ndarray, win: int) -> np.ndarray:
+    s = pd.Series(x)
+    m = s.rolling(win, min_periods=win).mean()
+    sd = s.rolling(win, min_periods=win).std()
+    return ((s - m) / sd.replace(0, np.nan)).values
+
+
+def rsi(c: np.ndarray, win: int = 14) -> np.ndarray:
+    d = np.diff(c, prepend=c[0])
+    up = pd.Series(np.where(d > 0, d, 0.0)).ewm(alpha=1 / win, adjust=False).mean()
+    dn = pd.Series(np.where(d < 0, -d, 0.0)).ewm(alpha=1 / win, adjust=False).mean()
+    rs = up / dn.replace(0, np.nan)
+    return (100 - 100 / (1 + rs)).values
+
+
+def atr(df: pd.DataFrame, win: int = 14) -> np.ndarray:
+    h, l, c = df["high"].values, df["low"].values, df["close"].values
+    pc = np.roll(c, 1); pc[0] = c[0]
+    tr = np.maximum(h - l, np.maximum(np.abs(h - pc), np.abs(l - pc)))
+    return pd.Series(tr).ewm(alpha=1 / win, adjust=False).mean().values
+
+
+def realized_vol(r: np.ndarray, win: int, bars_per_year: float) -> np.ndarray:
+    """Annualized realized vol from returns up to i inclusive (no leakage)."""
+    return pd.Series(r).rolling(win, min_periods=max(2, win // 2)).std().values * np.sqrt(bars_per_year)
+
+
+def donchian(df: pd.DataFrame, win: int):
+    """Upper/lower channel using bars STRICTLY before i (shifted) -> a close[i] that
+    breaks the prior `win`-bar high is a real, tradeable breakout at close[i]."""
+    hi = pd.Series(df["high"].values).rolling(win, min_periods=win).max().shift(1).values
+    lo = pd.Series(df["low"].values).rolling(win, min_periods=win).min().shift(1).values
+    return hi, lo
+
+
+def bbands(c: np.ndarray, win: int = 20, k: float = 2.0):
+    m = pd.Series(c).rolling(win, min_periods=win).mean()
+    sd = pd.Series(c).rolling(win, min_periods=win).std()
+    return (m + k * sd).values, m.values, (m - k * sd).values
+
+
+def _call_target(fn, df: pd.DataFrame, asset: str):
+    """Call a strategy fn as fn(df, asset) when it accepts 2 args, else fn(df).
+    Lets DVOL/cross-asset strategies receive the asset cleanly (no inference hacks)."""
+    try:
+        n = len(inspect.signature(fn).parameters)
+    except (ValueError, TypeError):
+        n = 1
+    return fn(df, asset) if n >= 2 else fn(df)
+
+
+def bars_per_year(df: pd.DataFrame) -> float:
+    dt = pd.to_datetime(df["datetime"]).diff().dt.total_seconds().median()
+    return 86400 * 365.25 / dt if dt and dt > 0 else 365.25
+
+
+def bars_per_day(df: pd.DataFrame) -> int:
+    dt = pd.to_datetime(df["datetime"]).diff().dt.total_seconds().median()
+    return max(1, round(86400 / dt))
+
+
+def vol_target(target_dir: np.ndarray, df: pd.DataFrame, target_vol: float = 0.20,
+               vol_win_days: int = 30, leverage_cap: float = 2.0) -> np.ndarray:
+    """Scale a direction array in [-1,1] to a vol-targeted position (TP01-style).
+    Causal: uses realized vol up to i. Returns position clipped to +/-leverage_cap."""
+    c = df["close"].values.astype(float)
+    bpd = bars_per_day(df)
+    bpy = bpd * 365.25
+    vol = realized_vol(simple_returns(c), max(2, vol_win_days * bpd), bpy)
+    scal = np.where((vol > 0) & np.isfinite(vol), target_vol / vol, 0.0)
+    tgt = np.clip(target_dir * scal, -leverage_cap, leverage_cap)
+    tgt[~np.isfinite(tgt)] = 0.0
+    return tgt
+
+
+# ===========================================================================
+# METRICS
+# ===========================================================================
+def _metrics_from_net(net: np.ndarray, idx: pd.DatetimeIndex) -> dict:
+    net = np.nan_to_num(net, nan=0.0)
+    eq = np.cumprod(1.0 + np.clip(net, -0.99, None))
+    rr = net[np.isfinite(net)]
+    bpy = 86400 * 365.25 / (pd.Series(idx).diff().dt.total_seconds().median() or 86400)
+    sharpe = float(np.mean(rr) / np.std(rr) * np.sqrt(bpy)) if np.std(rr) > 0 else 0.0
+    pk = np.maximum.accumulate(eq)
+    dd = float(np.max((pk - eq) / pk)) if len(eq) else 0.0
+    span_days = (idx[-1] - idx[0]).total_seconds() / 86400 if len(idx) > 1 else 1.0
+    years = max(span_days / 365.25, 1e-6)
+    total = eq[-1] / eq[0] if len(eq) else 1.0
+    cagr = total ** (1 / years) - 1 if total > 0 else -1.0
+    return dict(sharpe=round(sharpe, 3), cagr=round(cagr, 4), maxdd=round(dd, 4),
+                ret=round(total - 1, 4), n=int(len(rr)))
+
+
+def _yearly(net: np.ndarray, idx: pd.DatetimeIndex) -> dict:
+    s = pd.Series(np.nan_to_num(net), index=idx)
+    out = {}
+    for y, g in s.groupby(s.index.year):
+        eq = np.cumprod(1 + g.values); pk = np.maximum.accumulate(eq)
+        out[int(y)] = dict(ret=round(float(eq[-1] - 1), 4),
+                           dd=round(float(np.max((pk - eq) / pk)), 4))
+    return out
+
+
+def eval_weights(df: pd.DataFrame, target: np.ndarray, fee_side: float = FEE_SIDE) -> dict:
+    """Honest backtest of a CONTINUOUS position series.
+    target[i] is decided with data <= close[i]; it is HELD during bar i+1. The shift
+    is done HERE -> you cannot leak by construction. Fee charged on |Δposition| turnover.
+    Returns {full, holdout, yearly, time_in_market, turnover_per_year, net, idx}."""
+    c = df["close"].values.astype(float)
+    target = np.asarray(target, float)
+    target = np.nan_to_num(target, nan=0.0)
+    r = simple_returns(c)
+    pos = np.zeros(len(target)); pos[1:] = target[:-1]      # held during bar t = decided at t-1
+    gross = pos * r
+    turn = np.abs(np.diff(pos, prepend=0.0))
+    net = gross - fee_side * turn
+    net[0] = 0.0
+    idx = pd.DatetimeIndex(pd.to_datetime(df["datetime"], utc=True))
+    full = _metrics_from_net(net, idx)
+    hmask = idx >= HOLDOUT
+    hold = _metrics_from_net(net[hmask], idx[hmask]) if hmask.sum() > 3 else dict(sharpe=0.0, n=0)
+    bpy_d = bars_per_day(df) * 365.25
+    return dict(full=full, holdout=hold, yearly=_yearly(net, idx),
+                time_in_market=round(float(np.mean(pos != 0)), 3),
+                turnover_per_year=round(float(turn.sum() / (len(turn) / bpy_d)), 1),
+                net=net, idx=idx)
+
+
+def eval_signals(df: pd.DataFrame, entries: list, fee_rt: float = 2 * FEE_SIDE,
+                 leverage: float = 1.0, asset: str = "", tf: str = "") -> dict:
+    """Honest backtest of DISCRETE entry/exit signals (TP/SL/max_bars). Wraps the
+    project trade-based harness, adds a standardized hold-out split. Use on 1h/1d."""
+    m = backtest_signals(df, entries, fee_rt=fee_rt, leverage=leverage, asset=asset, tf=tf)
+    idx = pd.DatetimeIndex(pd.to_datetime(m.eq_index, utc=True)) if m.eq_index is not None \
+        else pd.DatetimeIndex(pd.to_datetime(df["datetime"], utc=True))
+    eq = m.equity
+    hmask = idx >= HOLDOUT
+    hold = dict(sharpe=0.0, ret=0.0, n=0)
+    if hmask.sum() > 3:
+        he = eq[hmask]
+        hr = np.diff(he) / he[:-1]
+        bpy = m.bars_per_year or 365.0
+        hsharpe = float(np.mean(hr) / np.std(hr) * np.sqrt(bpy)) if len(hr) and np.std(hr) > 0 else 0.0
+        hold = dict(sharpe=round(hsharpe, 3), ret=round(float(he[-1] / he[0] - 1), 4), n=int(hmask.sum()))
+    full = dict(sharpe=round(m.sharpe, 3), cagr=round(m.cagr, 4), maxdd=round(m.max_dd, 4),
+                ret=round(m.net_return, 4), n=int(m.n_trades))
+    return dict(full=full, holdout=hold, n_trades=int(m.n_trades),
+                win_rate=round(m.win_rate, 1), time_in_market=round(m.time_in_market, 3),
+                yearly={int(y): round(v, 4) for y, v in m.yearly.items()})
+
+
+# ===========================================================================
+# MARGINAL SCORING vs TP01 baseline — the lesson of the 2026-06-20 sweep.
+#
+# Absolute Sharpe is NOT enough to earn a portfolio slot: an overlay on TSMOM
+# (DVOL gate, low-vol filter, kill-switch, ...) inherits TP01's trend Sharpe and
+# scores ~1.0-1.3 while adding ZERO new return. The only question that matters for
+# a NEW sleeve is: does it IMPROVE the existing TP01 portfolio out-of-sample?
+# We answer it three ways: (a) blend uplift (Sharpe of TP01 + w*candidate minus
+# TP01 alone, full & hold-out), (b) correlation to TP01, (c) residual alpha after
+# removing the TP01 beta (the part of the candidate orthogonal to trend).
+# ===========================================================================
+def _sh(s) -> float:
+    r = np.asarray(s.dropna().values, float)
+    return float(np.mean(r) / np.std(r) * np.sqrt(365.25)) if len(r) > 2 and np.std(r) > 0 else 0.0
+
+
+def _dd_ret(s) -> float:
+    eq = np.cumprod(1.0 + np.asarray(s.dropna().values, float))
+    pk = np.maximum.accumulate(eq)
+    return float(np.max((pk - eq) / pk)) if len(eq) else 0.0
+
+
+def _to_daily(s: pd.Series) -> pd.Series:
+    s = s.dropna().sort_index()
+    if not isinstance(s.index, pd.DatetimeIndex):
+        s.index = pd.to_datetime(s.index, utc=True)
+    if s.index.tz is None:
+        s.index = s.index.tz_localize("UTC")
+    return ((1.0 + s).resample("1D").prod() - 1.0).dropna()
+
+
+@lru_cache(maxsize=2)
+def tp01_baseline_daily() -> pd.Series:
+    """The reference a candidate must BEAT: TP01 CANONICAL, 50/50 BTC+ETH, net daily
+    returns on common dates (full Sharpe ~1.30, hold-out ~0.31). Cached."""
+    from src.strategies.trend_portfolio import CANONICAL, TrendPortfolio
+    tp = TrendPortfolio(**CANONICAL)
+    series = {}
+    for a in CERTIFIED:
+        df = get(a, "1d")
+        net, _ = tp.net_returns(df)
+        series[a] = pd.Series(net, index=pd.DatetimeIndex(pd.to_datetime(df["datetime"], utc=True)))
+    J = pd.concat(series, axis=1, join="inner").fillna(0.0)
+    return _to_daily(0.5 * J[CERTIFIED[0]] + 0.5 * J[CERTIFIED[1]])
+
+
+def candidate_daily(target_fn, tf: str = "1d", fee_side: float = FEE_SIDE) -> pd.Series:
+    """Build a candidate's 50/50 BTC+ETH net DAILY return series (same convention as
+    tp01_baseline_daily) from a continuous-position target_fn. Intraday TFs are
+    compounded to daily so they align with the TP01 baseline grid."""
+    series = {}
+    for a in CERTIFIED:
+        df = get(a, tf)
+        ev = eval_weights(df, _call_target(target_fn, df, a), fee_side=fee_side)
+        series[a] = pd.Series(ev["net"], index=ev["idx"])
+    J = pd.concat(series, axis=1, join="inner").fillna(0.0)
+    return _to_daily(0.5 * J[CERTIFIED[0]] + 0.5 * J[CERTIFIED[1]])
+
+
+def _uplift_series(B: pd.Series, C: pd.Series, w: float = 0.25) -> float:
+    """Sharpe of the (1-w)*TP01 + w*candidate blend minus Sharpe of TP01 alone."""
+    return _sh((1 - w) * B + w * C) - _sh(B)
+
+
+def _null_uplift_pctl(B: pd.Series, C: pd.Series, w: float = 0.25,
+                      n: int = 300, seed: int = 20260621):
+    """Where does the candidate's blend-uplift sit vs the NULL of a zero-correlation
+    noise asset with the SAME mean & vol? Lesson of 2026-06-21: a low-corr asset with a
+    little positive drift 'adds' ~+0.03 Sharpe by pure diversification MATH — that is not
+    a signal. We draw `n` iid-normal assets (same mean/std as C, independent of B => corr 0
+    by construction), measure each one's uplift, and return (real_uplift, percentile of
+    real vs the null). pctl >= ~0.8 => the uplift is meaningfully above diversification
+    math; pctl ~0.5 => it IS diversification math. Seeded -> deterministic."""
+    Bx, Cx = B.align(C, join="inner")
+    bs, cs = Bx.values.astype(float), Cx.values.astype(float)
+    if len(cs) < 30:
+        return None, None
+    base = _sh(Bx)
+    real = _sh((1 - w) * Bx + w * Cx) - base
+    mu, sd = float(np.nanmean(cs)), float(np.nanstd(cs))
+    if sd == 0:
+        return round(real, 3), None
+    rng = np.random.default_rng(seed)
+    draws = rng.normal(mu, sd, size=(n, len(cs)))
+    blends = (1 - w) * bs[None, :] + w * draws
+    m, s = blends.mean(axis=1), blends.std(axis=1)
+    null = np.where(s > 0, m / s * np.sqrt(365.25), 0.0) - base
+    return round(float(real), 3), round(float(np.mean(null <= real)), 3)
+
+
+def marginal_vs_tp01(cand_daily: pd.Series, weights=(0.25, 0.5)) -> dict:
+    """Does this candidate IMPROVE the TP01 portfolio? Returns correlation, blend uplift
+    (full & hold-out, per weight), TP01-beta + residual alpha, and a verdict:
+      ADDS      -> lifts the blend, PERSISTENTLY (multi-cut), beats the zero-corr noise
+                   null, in BOTH TP01-up and TP01-down regimes
+      HEDGE     -> low corr but only pays when TP01 is WEAK (a drawdown dampener, not a
+                   standing premium): real, but price it as a hedge, not as alpha
+      NOISE     -> uplift indistinguishable from a random zero-corr asset (diversification
+                   math, not a signal)
+      REDUNDANT -> ~identical to TP01 (corr high, ~zero uplift): a re-skin, no slot
+      DILUTES   -> drags the blend down
+      NEUTRAL   -> changes little either way (a weak, optional satellite at best)
+    Score a NEW sleeve on THIS, not on absolute Sharpe.
+
+    Hardened 2026-06-21 (ortho wave): the fixed-HOLDOUT uplift + drop-month jackknife was
+    fooled (17/18 relative-value books 'ADDS' on a single 2025 ETH-bleed window). Three
+    gates added: (1) MULTI-CUT persistence (positive uplift at several hold-out starts, not
+    only 2025); (2) NOISE-NULL (uplift must beat a zero-corr random asset); (3) HEDGE vs
+    alpha (a low-corr sleeve that only helps when TP01 is down is a hedge)."""
+    B = tp01_baseline_daily()
+    J = pd.concat({"B": B, "C": cand_daily}, axis=1, join="inner").dropna()
+    if len(J) < 30:
+        return dict(marginal_verdict="N/A", reason="insufficient overlap with TP01 baseline")
+    if J["C"].std() == 0:
+        return dict(marginal_verdict="NEUTRAL", reason="flat/zero candidate (no exposure)",
+                    corr_full=None, blends={"w25": dict(uplift_full=0.0, uplift_hold=0.0)})
+    JH = J[J.index >= HOLDOUT]
+    has_h = len(JH) > 5
+    out = {
+        "n_days": int(len(J)), "n_hold_days": int(len(JH)),
+        "corr_full": round(float(J["B"].corr(J["C"])), 3),
+        "corr_hold": round(float(JH["B"].corr(JH["C"])), 3) if has_h else None,
+        "tp01_full_sharpe": round(_sh(J["B"]), 3), "tp01_hold_sharpe": round(_sh(JH["B"]), 3) if has_h else None,
+        "cand_full_sharpe": round(_sh(J["C"]), 3), "cand_hold_sharpe": round(_sh(JH["C"]), 3) if has_h else None,
+    }
+    blends = {}
+    for w in weights:
+        bf, bh = (1 - w) * J["B"] + w * J["C"], (1 - w) * JH["B"] + w * JH["C"]
+        blends[f"w{int(w * 100)}"] = dict(
+            full=round(_sh(bf), 3), hold=round(_sh(bh), 3) if has_h else None,
+            uplift_full=round(_sh(bf) - _sh(J["B"]), 3),
+            uplift_hold=round(_sh(bh) - _sh(JH["B"]), 3) if has_h else None,
+            dd=round(_dd_ret(bf), 4))
+    out["blends"] = blends
+    b, c = J["B"].values, J["C"].values
+    beta = float(np.cov(c, b)[0, 1] / np.var(b)) if np.var(b) > 0 else 0.0
+    resid = c - beta * b
+    out["beta_to_tp01"] = round(beta, 3)
+    out["resid_sharpe_full"] = round(float(np.mean(resid) / np.std(resid) * np.sqrt(365.25)) if np.std(resid) > 0 else 0.0, 3)
+    out["alpha_ann"] = round(float(np.mean(resid) * 365.25), 4)
+    # OOS robustness — the marginal point-estimate can be fooled by ONE lucky month
+    # (e.g. KAMA: +0.06 uplift that flips to -0.03 when its best month is dropped). Require
+    # the blend uplift to be positive in the earliest CLEAN hold-out year AND to survive a
+    # drop-one-month jackknife. This is lesson #2 of the 2026-06-20 sweep, in code.
+    out["clean_year_uplift"] = out["jackknife_min_uplift"] = None
+    robust_h = False
+    if has_h:
+        def _u(sub):
+            return _uplift_series(sub["B"], sub["C"])
+        yrs = sorted(set(JH.index.year))
+        clean = JH[JH.index.year == yrs[0]]
+        cu = _u(clean) if len(clean) > 20 else None
+        months = sorted(set(zip(JH.index.year, JH.index.month)))
+        jk = (min(_u(JH[~((JH.index.year == y) & (JH.index.month == mo))]) for y, mo in months)
+              if len(months) > 1 else _u(JH))
+        out["clean_year_uplift"] = round(cu, 3) if cu is not None else None
+        out["jackknife_min_uplift"] = round(jk, 3) if jk is not None else None
+        robust_h = bool(cu is not None and cu > 0.02 and jk is not None and jk > 0.0)
+
+    # --- GATE 1: MULTI-CUT PERSISTENCE -------------------------------------------------
+    # Uplift at the start of each year (not only the fixed HOLDOUT). A real edge adds at
+    # SEVERAL cuts incl. an early one; a regime artifact only adds at the latest window.
+    mc = {}
+    for y in sorted(set(J.index.year))[1:]:
+        sub = J[J.index >= pd.Timestamp(f"{y}-01-01", tz="UTC")]
+        if len(sub) >= 120:
+            mc[y] = round(_uplift_series(sub["B"], sub["C"]), 3)
+    out["multicut_uplift"] = mc
+    pos = [u for u in mc.values() if u > 0]
+    earliest = mc[min(mc)] if mc else None
+    multicut_persistent = bool(len(mc) >= 2 and len(pos) / len(mc) >= 0.6
+                               and earliest is not None and earliest > 0.0)
+    out["multicut_persistent"] = multicut_persistent
+
+    # --- GATE 2: NOISE-NULL (uplift must beat a random zero-corr asset) -----------------
+    JI = J[J.index < HOLDOUT]                 # in-sample part (not the lucky recent window)
+    real_is, pctl_is = _null_uplift_pctl(JI["B"], JI["C"]) if len(JI) >= 60 else (None, None)
+    real_f, pctl_f = _null_uplift_pctl(J["B"], J["C"])
+    cand_is_sharpe = round(_sh(JI["C"]), 3) if len(JI) >= 60 else None
+    out["null_pctl_insample"] = pctl_is
+    out["null_pctl_full"] = pctl_f
+    out["cand_insample_sharpe"] = cand_is_sharpe
+    # A candidate must STAND ON ITS OWN before the hold-out: a real in-sample standalone
+    # Sharpe. The ortho basket's in-sample Sharpe was 0.29 -> its only "value" was the
+    # diversification math of a near-zero-Sharpe stream, dressed up by the lucky 2025 window.
+    # (null_pctl_* are reported as the diversification-math context: a low-corr asset adds
+    # ~+0.03 Sharpe by math, so pctl~0.5 just means "no TP01-specific timing" — true of GOOD
+    # and BAD uncorrelated sleeves alike, so it can't be the gate. The in-sample edge is.)
+    has_insample_edge = (cand_is_sharpe is None) or (cand_is_sharpe >= 0.5)
+    out["has_insample_edge"] = bool(has_insample_edge)
+    out["beats_noise_null"] = bool(has_insample_edge)   # back-compat alias for the gate
+
+    # --- GATE 3: HEDGE vs ALPHA (does it only pay when TP01 is weak?) -------------------
+    yr_sh, yr_up = [], []
+    for y in sorted(set(J.index.year)):
+        sub = J[J.index.year == y]
+        if len(sub) >= 40:
+            yr_sh.append(_sh(sub["B"])); yr_up.append(_uplift_series(sub["B"], sub["C"]))
+    hedge_corr = (round(float(np.corrcoef(yr_sh, yr_up)[0, 1]), 3)
+                  if len(yr_sh) >= 3 and np.std(yr_sh) > 0 and np.std(yr_up) > 0 else None)
+    trail = J["B"].rolling(60, min_periods=20).sum().shift(1)
+    up_seg, dn_seg = J[trail > 0], J[trail <= 0]
+    u_up = _uplift_series(up_seg["B"], up_seg["C"]) if len(up_seg) > 30 else None
+    u_dn = _uplift_series(dn_seg["B"], dn_seg["C"]) if len(dn_seg) > 30 else None
+    out["hedge_yearly_corr"] = hedge_corr
+    out["uplift_tp01_up"] = round(u_up, 3) if u_up is not None else None
+    out["uplift_tp01_down"] = round(u_dn, 3) if u_dn is not None else None
+    is_hedge = bool(hedge_corr is not None and hedge_corr < -0.5
+                    and u_up is not None and u_up <= 0.0
+                    and u_dn is not None and u_dn > 0.05)
+    out["is_hedge"] = is_hedge
+
+    # robust_oos now REQUIRES multi-cut persistence (kills the single-window winners)
+    out["robust_oos"] = bool(robust_h and multicut_persistent)
+
+    # --- VERDICT ----------------------------------------------------------------------
+    up_h = blends["w25"]["uplift_hold"]
+    up_f = blends["w25"]["uplift_full"]
+    ch = out["corr_hold"] if out["corr_hold"] is not None else out["corr_full"]
+    if out["corr_full"] > 0.9 and (up_h is None or abs(up_h) < 0.05):
+        v = "REDUNDANT"
+    elif up_f <= -0.10 and (up_h is None or up_h <= 0.0):
+        v = "DILUTES"
+    elif is_hedge:
+        v = "HEDGE"
+    elif not has_insample_edge:
+        v = "NOISE"
+    elif (up_h is not None and up_h >= 0.05 and up_f > -0.15 and ch < 0.85
+          and multicut_persistent):
+        v = "ADDS"
+    else:
+        v = "NEUTRAL"
+    out["marginal_verdict"] = v
+    return out
+
+
+def study_marginal(name: str, target_fn, tf: str = "1d", fee_side: float = FEE_SIDE) -> dict:
+    """Score a continuous candidate BOTH ways: absolute (study_weights) AND marginal vs
+    TP01. The combined gate: a candidate earns a sleeve slot only if it is not FAIL on
+    absolute robustness AND marginal_verdict == 'ADDS'."""
+    absolute = study_weights(name, target_fn, tfs=(tf,))
+    marg = marginal_vs_tp01(candidate_daily(target_fn, tf=tf, fee_side=fee_side))
+    abs_grade = absolute["verdict"]["grade"]
+    # ADDS already embeds multi-cut + beats-null + not-hedge; we also require robust_oos
+    # (multi-cut robustness) explicitly. A HEDGE/NOISE/NEUTRAL never earns a live slot.
+    earns_slot = (abs_grade != "FAIL" and marg.get("marginal_verdict") == "ADDS"
+                  and marg.get("robust_oos", False)
+                  and marg.get("beats_noise_null", False)
+                  and not marg.get("is_hedge", False))
+    return dict(name=name, tf=tf, absolute=absolute, marginal=marg,
+                abs_grade=abs_grade, marginal_verdict=marg.get("marginal_verdict"),
+                earns_slot=earns_slot)
+
+
+def fmt_marginal(rep: dict) -> str:
+    m = rep["marginal"]
+    bl = m.get("blends", {})
+    lines = [f"=== {rep['name']} | abs={rep['abs_grade']}  marginal={rep['marginal_verdict']}  "
+             f"EARNS_SLOT={rep['earns_slot']}"]
+    lines.append(f"  corr->TP01 full {m.get('corr_full')} hold {m.get('corr_hold')}  "
+                 f"beta {m.get('beta_to_tp01')}  resid Sharpe {m.get('resid_sharpe_full')}  alpha/yr {m.get('alpha_ann')}")
+    lines.append(f"  OOS robustness: clean-year uplift {m.get('clean_year_uplift')}  "
+                 f"drop-best-month {m.get('jackknife_min_uplift')}  robust_oos={m.get('robust_oos')}")
+    lines.append(f"  multi-cut persistence: {m.get('multicut_uplift')}  persistent={m.get('multicut_persistent')}")
+    lines.append(f"  in-sample edge: standalone Sharpe {m.get('cand_insample_sharpe')}  "
+                 f"has_insample_edge={m.get('has_insample_edge')}  "
+                 f"(diversification-math null pctl in-sample {m.get('null_pctl_insample')} full {m.get('null_pctl_full')})")
+    lines.append(f"  hedge check: yearly corr(TP01-Sh, uplift) {m.get('hedge_yearly_corr')}  "
+                 f"uplift TP01-up {m.get('uplift_tp01_up')} / TP01-down {m.get('uplift_tp01_down')}  "
+                 f"is_hedge={m.get('is_hedge')}")
+    lines.append(f"  standalone: TP01 full {m.get('tp01_full_sharpe')}/hold {m.get('tp01_hold_sharpe')}  |  "
+                 f"cand full {m.get('cand_full_sharpe')}/hold {m.get('cand_hold_sharpe')}")
+    for w, d in bl.items():
+        uh = "n/a" if d["uplift_hold"] is None else f"{d['uplift_hold']:+.3f}"
+        hold = "n/a" if d["hold"] is None else f"{d['hold']}"
+        lines.append(f"  blend {w}: full {d['full']} (uplift {d['uplift_full']:+.3f})  "
+                     f"hold {hold} (uplift {uh})  DD {d['dd'] * 100:.1f}%")
+    return "\n".join(lines)
+
+
+# ===========================================================================
+# HARNESS REALISM — two gates codified from the 2026-06-21 intraday wave.
+#
+# LESSON 1 (day-boundary): open_drive ("first 8h UTC predicts rest-of-day") scored a
+# +0.23 uplift but INVERTED to -0.10 when the UTC day start was shifted 4h — a calendar-
+# LABELING artifact, not an intraday effect. A real hour/session/day edge degrades
+# gracefully under a boundary shift; an artifact flips sign.
+#
+# LESSON 2 (small-cap fills): eval_weights charges fee on EVERY |Δposition|, incl. the
+# thousands of sub-dollar rebalances a vol-target overlay produces. At ~$600 real capital a
+# $0.03 trade can't execute — the modeled proportional fee is a continuous-rebalancing
+# fiction. eval_weights_smallcap skips changes below min_order and reports the Sharpe haircut.
+# ===========================================================================
+def _shift_calendar(df: pd.DataFrame, offset_hours: int) -> pd.DataFrame:
+    """Relabel the clock the SIGNAL sees by +offset_hours (datetime & timestamp), leaving
+    prices/returns untouched -> the signal's .dt.hour / day-grouping shifts, the backtest
+    does not. (get() is cached; copy so we never mutate the shared frame.)"""
+    d = df.copy()
+    dt = pd.to_datetime(d["datetime"], utc=True) + pd.Timedelta(hours=offset_hours)
+    d["datetime"] = dt
+    if "timestamp" in d:
+        d["timestamp"] = d["timestamp"].astype("int64") + int(offset_hours * 3600 * 1000)
+    return d
+
+
+def day_boundary_robust(target_fn, tf: str = "1h",
+                        offsets=(0, 3, 6, 9, 12, 15, 18, 21), w: float = 0.25) -> dict:
+    """Is a candidate's marginal uplift ROBUST to shifting the UTC day boundary? For each
+    offset we relabel the calendar the signal sees, recompute its 50/50 BTC+ETH daily series
+    and the blend uplift vs TP01. A datetime-independent signal is INVARIANT (spread ~0); a
+    calendar signal that stays positive is ROBUST; one whose uplift flips sign is ARTIFACT-RISK
+    (open_drive). Run this on ANY hour/session/day-of-week signal before believing it."""
+    B = tp01_baseline_daily()
+    per = {}
+    for off in offsets:
+        series = {}
+        for a in CERTIFIED:
+            df0 = get(a, tf)                                  # ORIGINAL bars/dates
+            tgt = _call_target(target_fn, _shift_calendar(df0, off), a)  # signal sees shifted clock
+            ev = eval_weights(df0, tgt)                        # backtest on the real calendar
+            series[a] = pd.Series(ev["net"], index=ev["idx"])
+        J = pd.concat(series, axis=1, join="inner").fillna(0.0)
+        cand = _to_daily(0.5 * J[CERTIFIED[0]] + 0.5 * J[CERTIFIED[1]])
+        JJ = pd.concat({"B": B, "C": cand}, axis=1, join="inner").dropna()
+        per[int(off)] = round(_sh((1 - w) * JJ["B"] + w * JJ["C"]) - _sh(JJ["B"]), 3) if len(JJ) > 30 else None
+    ups = [v for v in per.values() if v is not None]
+    if not ups:
+        return dict(per_offset=per, verdict="N/A", reason="no evaluable offsets")
+    spread = round(max(ups) - min(ups), 3)
+    calendar_sensitive = spread > 0.02
+    robust = min(ups) > 0
+    verdict = ("INVARIANT" if not calendar_sensitive else ("ROBUST" if robust else "ARTIFACT-RISK"))
+    return dict(per_offset=per, base=per[offsets[0]], min=min(ups), max=max(ups),
+                spread=spread, calendar_sensitive=calendar_sensitive,
+                robust_to_boundary=robust, verdict=verdict)
+
+
+def eval_weights_smallcap(df: pd.DataFrame, target, capital: float = 600.0,
+                          min_order: float = 5.0, fee_side: float = FEE_SIDE) -> dict:
+    """Honest net at SMALL capital. A desired position change whose notional |Δw|*capital is
+    below min_order is NOT executed (held -> tracking error, no trade) — removing the
+    continuous-rebalancing fiction. Returns realistic vs modeled metrics, the Sharpe haircut,
+    and the number of trades that actually execute. (Applies to ANY sleeve at this capital,
+    TP01 included.)"""
+    c = df["close"].values.astype(float)
+    tgt = np.clip(np.nan_to_num(np.asarray(target, float)), -10, 10)
+    held = np.empty(len(tgt)); cur = 0.0; n_tr = 0
+    for i in range(len(tgt)):
+        if abs(tgt[i] - cur) * capital >= min_order:
+            cur = tgt[i]; n_tr += 1
+        held[i] = cur
+    r = simple_returns(c)
+    pos = np.zeros(len(held)); pos[1:] = held[:-1]
+    turn = np.abs(np.diff(pos, prepend=0.0))
+    net = pos * r - fee_side * turn; net[0] = 0.0
+    idx = pd.DatetimeIndex(pd.to_datetime(df["datetime"], utc=True))
+    real = _metrics_from_net(net, idx)
+    modeled = eval_weights(df, tgt, fee_side=fee_side)["full"]
+    bpy_d = bars_per_day(df) * 365.25
+    return dict(realistic=real, modeled=modeled,
+                sharpe_haircut=round(modeled["sharpe"] - real["sharpe"], 3),
+                n_executed_trades=int(n_tr),
+                executed_turnover_per_year=round(float(turn.sum() / (len(turn) / bpy_d)), 1))
+
+
+def causality_ok(target_fn, tf: str = "1h", assets=CERTIFIED,
+                 tail: int = 80, tol: float = 1e-3) -> dict:
+    """Online-consistency / LOOK-AHEAD guard for a continuous target_fn(df) [or (df, asset)].
+    eval_weights SHIFTS the position so you cannot leak by multiplying a weight by the SAME
+    bar's return — but it does NOT verify the FEATURE construction is causal: a centered
+    window, a .shift(-k), or a full-sample statistic would pass eval_weights yet peek at the
+    future. Here we recompute the target on a TRUNCATED prefix and require its tail to MATCH
+    target(full)[:cut] (the bars a deployable signal would have emitted in real time). Any
+    future-peeking diverges. Run this in every altlib-based lab (blind/ortho already do)."""
+    worst = 0.0; bad = False; checked = 0
+    for a in assets:
+        df = get(a, tf)
+        full = np.nan_to_num(np.asarray(_call_target(target_fn, df, a), float))
+        n = len(df)
+        for cut in (int(n * 0.80), int(n * 0.92)):
+            if cut <= tail + 5 or cut >= n:
+                continue
+            sub = df.iloc[:cut].reset_index(drop=True)
+            s = np.nan_to_num(np.asarray(_call_target(target_fn, sub, a), float))
+            if len(s) != cut:
+                bad = True
+                continue
+            d = np.abs(s[cut - tail:cut] - full[cut - tail:cut])
+            worst = max(worst, float(np.max(d)) if len(d) else 0.0)
+            checked += 1
+    return dict(ok=bool((not bad) and worst <= tol),
+                max_tail_diff=round(worst, 8), checked=checked,
+                reason=("length-mismatch on prefix" if bad else None))
+
+
+# ===========================================================================
+# SELECTION-ON-HOLDOUT GATE — codified 2026-06-29 from filone B (intraday ERM).
+#
+# LESSON 3: intraday_regime.py picked its "winner" cell by MAX hold-out Sharpe over a ~60-cell
+# grid, then ran study_marginal on THAT cell -> earns_slot=True. But the slot was an artifact of
+# SELECTING THE CELL ON THE HOLD-OUT: picking the cell IN-SAMPLE-ONLY (no peeking) lands on a
+# DIFFERENT, TP01-correlated cell that scores NEUTRAL, and the standalone Sharpe deflates to
+# DSR~0.0-0.24 over the trials searched. study_marginal alone can't catch this — it judges ONE
+# stream and never sees how the cell was chosen. The fix is two-fold and lives here:
+#   (1) choose the cell IN-SAMPLE-ONLY (or walk-forward) BEFORE scoring the marginal, and
+#   (2) DEFLATE the standalone Sharpe for the number of cells/families searched.
+# Twin of the CC01 ("implausible Sharpe -> hidden risk") and alt-sweep ("hold-out-fitting") blind
+# spots, in its "selection-on-holdout" form.
+# ===========================================================================
+def deflated_sharpe(sr_ann, all_sr_ann, daily_ret, dpy: float = 365.25):
+    """Deflated Sharpe Ratio (Bailey & Lopez de Prado): P(true Sharpe > the MAX Sharpe expected
+    under the null of N independent trials). Penalizes multiple-testing — a standalone Sharpe ~1
+    over a 100+ cell grid is routinely NOT significant once deflated. sr_ann = annualized Sharpe
+    of the CHOSEN config; all_sr_ann = the Sharpe of EVERY cell searched; daily_ret = the chosen
+    config's daily returns (for skew/kurt/T). Returns (DSR, expected_null_max_sharpe_ann);
+    PASS if DSR >= 0.95."""
+    r = np.asarray(pd.Series(daily_ret).dropna().values, float)
+    T = len(r)
+    if T < 30 or np.std(r) == 0:
+        return float("nan"), float("nan")
+    sr = sr_ann / math.sqrt(dpy)
+    trials = np.asarray([s / math.sqrt(dpy) for s in all_sr_ann if np.isfinite(s)], float)
+    N = max(len(trials), 2)
+    var_tr = float(np.var(trials, ddof=1)) if N > 1 else 0.0
+    emc = 0.5772156649
+    z1 = norm.ppf(1 - 1.0 / N)
+    z2 = norm.ppf(1 - 1.0 / (N * math.e))
+    sr0 = math.sqrt(var_tr) * ((1 - emc) * z1 + emc * z2)
+    sk = float(pd.Series(r).skew())
+    ku = float(pd.Series(r).kurt()) + 3.0                      # pandas kurt = excess
+    den = math.sqrt(max(1e-9, 1 - sk * sr + (ku - 1) / 4.0 * sr ** 2))
+    dsr = float(norm.cdf((sr - sr0) * math.sqrt(T - 1) / den))
+    return dsr, sr0 * math.sqrt(dpy)
+
+
+def select_cell_insample(factory, grid, tfs, fee_side: float = FEE_SIDE) -> dict:
+    """Pick a config WITHOUT looking at the hold-out: rank grid cells by IN-SAMPLE (pre-HOLDOUT)
+    standalone Sharpe of the 50/50 candidate. `factory(tf=..., **params)` -> target_fn; each grid
+    item is a dict of factory kwargs (besides tf). Returns the in-sample-best cell, all rows
+    (sorted), and EVERY cell's FULL Sharpe (for deflated_sharpe). This is the honest replacement
+    for picking the max-hold-out cell."""
+    rows = []
+    for tf in tfs:
+        for params in grid:
+            try:
+                daily = candidate_daily(factory(tf=tf, **params), tf=tf, fee_side=fee_side)
+            except Exception:
+                continue
+            ins = daily[daily.index < HOLDOUT]
+            is_sh = _sh(ins) if len(ins) > 60 else float("nan")
+            rows.append(dict(tf=tf, params=params, insample_sharpe=round(is_sh, 3),
+                             full_sharpe=round(_sh(daily), 3)))
+    valid = [r for r in rows if np.isfinite(r["insample_sharpe"])]
+    chosen = max(valid, key=lambda r: r["insample_sharpe"]) if valid else None
+    return dict(chosen=chosen,
+                rows=sorted(valid, key=lambda r: r["insample_sharpe"], reverse=True),
+                all_full_sharpe=[r["full_sharpe"] for r in rows])
+
+
+def study_family_honest(name: str, factory, grid, tfs, fee_side: float = FEE_SIDE,
+                        dsr_min: float = 0.95) -> dict:
+    """HARDENED family gate. A grid-searched directional candidate earns a slot ONLY if, picking
+    the cell IN-SAMPLE-ONLY (no hold-out peeking), it STILL earns_slot via study_marginal AND its
+    standalone Sharpe survives deflation for the WHOLE grid searched. Use this INSTEAD of
+    cherry-picking the max-hold cell and calling study_marginal on it."""
+    sel = select_cell_insample(factory, grid, tfs, fee_side=fee_side)
+    ch = sel["chosen"]
+    if ch is None:
+        return dict(name=name, chosen=None, earns_slot_honest=False,
+                    reason="no valid in-sample cell")
+    fn = factory(tf=ch["tf"], **ch["params"])
+    sm = study_marginal(f"{name} ISpick {ch['params']}", fn, tf=ch["tf"], fee_side=fee_side)
+    daily = candidate_daily(fn, tf=ch["tf"], fee_side=fee_side)
+    dsr, sr0 = deflated_sharpe(_sh(daily), sel["all_full_sharpe"], daily)
+    dsr_pass = bool(np.isfinite(dsr) and dsr >= dsr_min)
+    return dict(name=name, n_cells=len(sel["all_full_sharpe"]), chosen=ch, rows=sel["rows"],
+                marginal=sm, earns_slot_marginal=bool(sm["earns_slot"]),
+                deflated_sharpe=round(dsr, 3) if np.isfinite(dsr) else None,
+                expected_null_max=round(sr0, 3) if np.isfinite(sr0) else None,
+                dsr_pass=dsr_pass,
+                earns_slot_honest=bool(sm["earns_slot"] and dsr_pass))
+
+
+# ===========================================================================
+# DRIVERS — run a hypothesis across both assets, several TFs, with a fee sweep.
+# ===========================================================================
+def _verdict(per_cell: list[dict]) -> dict:
+    """A finding PASSES only if it is robust: positive FULL Sharpe AND positive HOLD-OUT
+    on BOTH assets in its best TF, survives the fee sweep, and isn't a 1-cell fluke."""
+    if not per_cell:
+        return dict(grade="FAIL", reason="no cells")
+    ok = [c for c in per_cell if c.get("full_sharpe", -9) > 0]
+    best = max(per_cell, key=lambda c: c.get("min_asset_holdout_sharpe", -9))
+    pass_ = (best.get("min_asset_full_sharpe", -9) >= 0.5 and
+             best.get("min_asset_holdout_sharpe", -9) >= 0.2 and
+             best.get("fee_survives", False))
+    weak = (best.get("min_asset_full_sharpe", -9) >= 0.3 and
+            best.get("min_asset_holdout_sharpe", -9) >= 0.0)
+    grade = "PASS" if pass_ else ("WEAK" if weak else "FAIL")
+    return dict(grade=grade, best_tf=best.get("tf"),
+                best_full_sharpe=best.get("min_asset_full_sharpe"),
+                best_holdout_sharpe=best.get("min_asset_holdout_sharpe"),
+                n_positive_cells=len(ok), n_cells=len(per_cell))
+
+
+def study_weights(name: str, target_fn, tfs=("1d", "12h"),
+                  assets=CERTIFIED, fee_sweep=FEE_SWEEP) -> dict:
+    """Run a CONTINUOUS-position hypothesis on each (asset,tf), report robustness.
+    target_fn(df) -> per-bar position array (decided <= close[i]). Returns a dict
+    ready to print/serialize, with a conservative PASS/WEAK/FAIL verdict."""
+    cells = []
+    for tf in tfs:
+        per_asset = {}
+        fee_ok_all = True
+        for a in assets:
+            df = get(a, tf)
+            tgt = _call_target(target_fn, df, a)
+            base = eval_weights(df, tgt, fee_side=FEE_SIDE)
+            sweep = {f"{2*f*100:.2f}%RT": eval_weights(df, tgt, fee_side=f)["full"]["sharpe"]
+                     for f in fee_sweep}
+            fee_ok = sweep.get("0.20%RT", -9) > 0
+            fee_ok_all = fee_ok_all and fee_ok
+            per_asset[a] = dict(full=base["full"], holdout=base["holdout"],
+                                tim=base["time_in_market"], turnover=base["turnover_per_year"],
+                                fee_sweep=sweep, yearly=base["yearly"])
+        min_full = min(per_asset[a]["full"]["sharpe"] for a in assets)
+        min_hold = min(per_asset[a]["holdout"].get("sharpe", 0.0) for a in assets)
+        cells.append(dict(tf=tf, per_asset=per_asset,
+                          min_asset_full_sharpe=round(min_full, 3),
+                          min_asset_holdout_sharpe=round(min_hold, 3),
+                          full_sharpe=round(np.mean([per_asset[a]["full"]["sharpe"] for a in assets]), 3),
+                          fee_survives=fee_ok_all))
+    return dict(name=name, kind="weights", cells=cells, verdict=_verdict(cells))
+
+
+def study_signals(name: str, entries_fn, tfs=("1d",), assets=CERTIFIED,
+                  fee_sweep=FEE_SWEEP, leverage: float = 1.0) -> dict:
+    """Run a DISCRETE entry/exit hypothesis on each (asset,tf). entries_fn(df) ->
+    list[dict|None] len(df). Use 1h/1d TFs only (Python loop)."""
+    cells = []
+    for tf in tfs:
+        per_asset = {}
+        fee_ok_all = True
+        for a in assets:
+            df = get(a, tf)
+            ent = _call_target(entries_fn, df, a)
+            base = eval_signals(df, ent, fee_rt=2 * FEE_SIDE, leverage=leverage, asset=a, tf=tf)
+            sweep = {f"{2*f*100:.2f}%RT": eval_signals(df, ent, fee_rt=2 * f, leverage=leverage)["full"]["sharpe"]
+                     for f in fee_sweep}
+            fee_ok = sweep.get("0.20%RT", -9) > 0
+            fee_ok_all = fee_ok_all and fee_ok
+            per_asset[a] = dict(full=base["full"], holdout=base["holdout"],
+                                n_trades=base["n_trades"], win_rate=base["win_rate"],
+                                fee_sweep=sweep, yearly=base["yearly"])
+        min_full = min(per_asset[a]["full"]["sharpe"] for a in assets)
+        min_hold = min(per_asset[a]["holdout"].get("sharpe", 0.0) for a in assets)
+        cells.append(dict(tf=tf, per_asset=per_asset,
+                          min_asset_full_sharpe=round(min_full, 3),
+                          min_asset_holdout_sharpe=round(min_hold, 3),
+                          full_sharpe=round(np.mean([per_asset[a]["full"]["sharpe"] for a in assets]), 3),
+                          fee_survives=fee_ok_all))
+    return dict(name=name, kind="signals", cells=cells, verdict=_verdict(cells))
+
+
+# ===========================================================================
+# OUTPUT
+# ===========================================================================
+def _clean(o):
+    if isinstance(o, dict):
+        return {k: _clean(v) for k, v in o.items() if k not in ("net", "idx", "equity")}
+    if isinstance(o, (list, tuple)):
+        return [_clean(x) for x in o]
+    if isinstance(o, (np.floating,)):
+        return round(float(o), 4)
+    if isinstance(o, (np.integer,)):
+        return int(o)
+    return o
+
+
+def as_json(rep: dict) -> str:
+    return json.dumps(_clean(rep), default=str)
+
+
+def fmt(rep: dict) -> str:
+    v = rep["verdict"]
+    lines = [f"=== {rep['name']} [{rep['kind']}] -> {v['grade']} "
+             f"(best {v.get('best_tf')}: full {v.get('best_full_sharpe')}, "
+             f"hold {v.get('best_holdout_sharpe')})"]
+    for c in rep["cells"]:
+        lines.append(f"  TF {c['tf']:>4s}: minFull={c['min_asset_full_sharpe']:+.2f} "
+                     f"minHold={c['min_asset_holdout_sharpe']:+.2f} feeOK={c['fee_survives']}")
+        for a, pa in c["per_asset"].items():
+            yr = " ".join(f"{y}:{d['ret']*100 if isinstance(d, dict) else d*100:+.0f}%"
+                          for y, d in list(pa["yearly"].items()))
+            lines.append(f"      {a}: full Sh={pa['full']['sharpe']:+.2f} "
+                         f"DD={pa['full']['maxdd']*100:.0f}% ret={pa['full']['ret']*100:+.0f}% "
+                         f"hold Sh={pa['holdout'].get('sharpe', 0):+.2f} | {yr}")
+    return "\n".join(lines)
+
+
+if __name__ == "__main__":
+    # smoke test: buy&hold, TSMOM trend, donchian breakout
+    print("--- SMOKE TEST altlib ---")
+    bh = study_weights("BUYHOLD", lambda df: np.ones(len(df)), tfs=("1d",))
+    print(fmt(bh))
+
+    def tsmom(df):
+        c = df["close"].values
+        bpd = bars_per_day(df)
+        d = np.zeros(len(c))
+        for h in (30 * bpd, 90 * bpd, 180 * bpd):
+            s = np.full(len(c), np.nan); s[h:] = np.sign(c[h:] / c[:-h] - 1)
+            d = d + np.nan_to_num(s)
+        d = np.clip(np.sign(d), 0, None)
+        return vol_target(d, df, 0.20, 30, 2.0)
+    print(fmt(study_weights("TSMOM-LF", tsmom, tfs=("1d",))))
+
+    def donch(df):
+        hi, lo = donchian(df, 20)
+        c = df["close"].values
+        pos = np.where(c > hi, 1.0, np.nan)
+        pos = np.where(c < lo, 0.0, pos)
+        return pd.Series(pos).ffill().fillna(0.0).values
+    print(fmt(study_weights("DONCHIAN20-LF", donch, tfs=("1d",))))
+    print("\nJSON sample:", as_json(bh)[:300])

scripts/research/alt/marginal_demo.py

@@ -0,0 +1,96 @@
+"""Demo / validation of the MARGINAL-vs-TP01 scorer (2026-06-20).
+
+Shows the lesson of the 104-hypothesis sweep operationalized: strategies that scored
+an absolute PASS but are just TP01/TSMOM with an overlay collapse to REDUNDANT/NEUTRAL/
+DILUTES under marginal scoring, while the one genuine diversifier (STA05 long-short)
+earns ADDS. Run: uv run python scripts/research/alt/marginal_demo.py
+"""
+import sys
+sys.path.insert(0, "/opt/docker/PythagorasGoal/scripts/research/alt")
+import numpy as np
+import pandas as pd
+
+import altlib as al
+from src.strategies.trend_portfolio import CANONICAL, TrendPortfolio
+
+
+def tsmom_dir(df):
+    """Long-flat multi-horizon TSMOM direction in {0,1} (the bare TP01 trend signal)."""
+    c = df["close"].values.astype(float)
+    bpd = al.bars_per_day(df)
+    d = np.zeros(len(c))
+    for h in (30 * bpd, 90 * bpd, 180 * bpd):
+        s = np.full(len(c), np.nan)
+        s[h:] = np.sign(c[h:] / c[:-h] - 1.0)
+        d += np.nan_to_num(s)
+    return np.clip(np.sign(d), 0, None)
+
+
+def tp01_target(df):
+    return TrendPortfolio(**CANONICAL).target_series(df)
+
+
+FAST, SLOW = [5, 10, 20, 40], [40, 80, 120, 200]
+PAIRS = [(f, s) for f in FAST for s in SLOW if f < s]
+
+
+def sta05(df, long_only):
+    c = df["close"].values.astype(float)
+    v = np.zeros(len(c))
+    for f, s in PAIRS:
+        v += np.sign(al.ema(c, f) - al.ema(c, s))
+    d = v / len(PAIRS)
+    if long_only:
+        d = np.clip(d, 0.0, 1.0)
+    return al.vol_target(d, df, 0.20, 30, 2.0)
+
+
+def vol03(df, asset):
+    """DVOL-gated TSMOM (active only when DVOL below its expanding median)."""
+    d = tsmom_dir(df)
+    dv = pd.Series(al.dvol(df, asset))
+    thr = dv.expanding(min_periods=30).quantile(0.5)
+    gate = dv.isna() | thr.isna() | (dv < thr)
+    d = np.where(gate.values, d, 0.0)
+    return al.vol_target(d, df, 0.20, 30, 2.0)
+
+
+def cmb04(df):
+    """Momentum + low-vol filter (TSMOM taken only when realized vol below expanding median)."""
+    d = tsmom_dir(df)
+    bpd = al.bars_per_day(df)
+    rv = al.realized_vol(al.simple_returns(df["close"].values.astype(float)), 30 * bpd, bpd * 365.25)
+    med = pd.Series(rv).expanding(min_periods=60).median().values
+    d = np.where((rv < med) | np.isnan(med), d, 0.0)
+    return al.vol_target(d, df, 0.20, 30, 2.0)
+
+
+CANDIDATES = [
+    ("TP01-itself (sanity)", tp01_target),
+    ("STA05 long-short (the lead)", lambda df: sta05(df, False)),
+    ("STA05 long-only", lambda df: sta05(df, True)),
+    ("VOL03 DVOL-gated TSMOM (overlay)", vol03),
+    ("CMB04 momentum+low-vol (overlay)", cmb04),
+]
+
+print("=" * 78)
+print("MARGINAL SCORING vs TP01 baseline — absolute Sharpe is NOT enough for a slot")
+print("=" * 78)
+rows = []
+for name, fn in CANDIDATES:
+    rep = al.study_marginal(name, fn, tf="1d")
+    print()
+    print(al.fmt_marginal(rep))
+    rows.append((name, rep["abs_grade"], rep["marginal_verdict"], rep["earns_slot"]))
+
+print("\n" + "=" * 78)
+print(f"{'candidate':<36s} {'absolute':>9s} {'marginal':>10s} {'earns_slot':>11s}")
+for n, ag, mv, es in rows:
+    print(f"{n:<36s} {ag:>9s} {mv:>10s} {str(es):>11s}")
+
+# sanity asserts: baseline reproduces, and an overlay-on-TSMOM does NOT earn a slot
+sanity = al.marginal_vs_tp01(al.candidate_daily(tp01_target))
+assert sanity["corr_full"] > 0.95, f"TP01-vs-itself corr should be ~1, got {sanity['corr_full']}"
+assert abs(sanity["blends"]["w25"]["uplift_full"]) < 0.05, "TP01-vs-itself uplift should be ~0"
+print("\nSANITY OK: TP01-vs-itself corr", sanity["corr_full"],
+      "uplift_full", sanity["blends"]["w25"]["uplift_full"], "->", sanity["marginal_verdict"])

scripts/research/alt/marginal_remaining.py

@@ -0,0 +1,136 @@
+"""Resta qualche candidato? — passa i contendenti promettenti piu' forti del sweep
+(trend non-TSMOM, overlay DVOL, rotazione cross-asset) attraverso il gate MARGINALE vs TP01.
+Run: uv run python scripts/research/alt/marginal_remaining.py
+"""
+import sys
+sys.path.insert(0, "/opt/docker/PythagorasGoal/scripts/research/alt")
+import numpy as np
+import pandas as pd
+
+import altlib as al
+
+
+def tsmom_dir(df):
+    c = df["close"].values.astype(float); bpd = al.bars_per_day(df); d = np.zeros(len(c))
+    for h in (30 * bpd, 90 * bpd, 180 * bpd):
+        s = np.full(len(c), np.nan); s[h:] = np.sign(c[h:] / c[:-h] - 1.0); d += np.nan_to_num(s)
+    return np.clip(np.sign(d), 0, None)
+
+
+def wma(x, n):
+    w = np.arange(1, n + 1)
+    return pd.Series(x).rolling(n).apply(lambda v: np.dot(v, w) / w.sum(), raw=True).values
+
+
+# --- TRD10 Vortex(14) long-flat ---
+def trd10(df):
+    h = df["high"].values.astype(float); l = df["low"].values.astype(float); c = df["close"].values.astype(float)
+    pc = np.roll(c, 1); pc[0] = c[0]; ph = np.roll(h, 1); ph[0] = h[0]; pl = np.roll(l, 1); pl[0] = l[0]
+    tr = np.maximum(h - l, np.maximum(np.abs(h - pc), np.abs(l - pc)))
+    n = 14; strn = pd.Series(tr).rolling(n).sum().values
+    vip = pd.Series(np.abs(h - pl)).rolling(n).sum().values / strn
+    vim = pd.Series(np.abs(l - ph)).rolling(n).sum().values / strn
+    d = np.where(np.isnan(vip), 0.0, np.where(vip > vim, 1.0, 0.0))
+    return al.vol_target(d, df, 0.20, 30, 2.0)
+
+
+# --- TRD08 Hull MA slope ---
+def trd08(df):
+    c = df["close"].values.astype(float)
+    h = wma(2 * wma(c, 27) - wma(c, 55), 7)   # HMA(55)
+    slope = np.zeros(len(h)); slope[1:] = h[1:] - h[:-1]
+    d = np.where(slope > 0, 1.0, 0.0); d[np.isnan(h)] = 0.0
+    return al.vol_target(d, df, 0.20, 30, 2.0)
+
+
+# --- TRD07 Kaufman AMA cross ---
+def kama(c, n=10, fast=2, slow=30):
+    c = np.asarray(c, float); L = len(c); out = np.copy(c)
+    fsc, ssc = 2 / (fast + 1), 2 / (slow + 1)
+    vol = pd.Series(np.abs(np.diff(c, prepend=c[0]))).rolling(n).sum().values
+    change = np.full(L, np.nan); change[n:] = np.abs(c[n:] - c[:-n])
+    sc = (np.where(vol > 0, change / vol, 0.0) * (fsc - ssc) + ssc) ** 2
+    for i in range(1, L):
+        out[i] = out[i - 1] if np.isnan(sc[i]) else out[i - 1] + sc[i] * (c[i] - out[i - 1])
+    return out
+
+
+def trd07(df):
+    c = df["close"].values.astype(float); k = kama(c)
+    slope = np.zeros(len(k)); slope[1:] = k[1:] - k[:-1]
+    d = np.where((c > k) & (slope > 0), 1.0, 0.0)
+    return al.vol_target(d, df, 0.20, 30, 2.0)
+
+
+# --- VOL08 realized-vol term-structure overlay on TSMOM ---
+def vol08(df):
+    c = df["close"].values.astype(float); bpd = al.bars_per_day(df); r = al.simple_returns(c)
+    sv = al.realized_vol(r, 5 * bpd, bpd * 365.25); lv = al.realized_vol(r, 30 * bpd, bpd * 365.25)
+    ratio = sv / lv; d = tsmom_dir(df)
+    d = np.where((ratio < 1.0) | np.isnan(ratio), d, 0.0)
+    return al.vol_target(d, df, 0.20, 30, 2.0)
+
+
+# --- VOL11 DVOL kill-switch on TSMOM (df, asset) ---
+def vol11(df, asset):
+    d = tsmom_dir(df); dv = pd.Series(al.dvol(df, asset))
+    thr = dv.expanding(min_periods=30).quantile(0.80)
+    kill = (~dv.isna()) & (~thr.isna()) & (dv > thr)
+    d = np.where(kill.values, 0.0, d)
+    return al.vol_target(d, df, 0.20, 30, 2.0)
+
+
+# --- XAS09/03 cross-asset rotation (hold the stronger of BTC/ETH; dual=flat if both neg) ---
+def rotation_daily(lb=90, dual=True):
+    R, M, V = {}, {}, {}
+    for a in ("BTC", "ETH"):
+        df = al.get(a, "1d"); c = df["close"].values.astype(float)
+        idx = pd.DatetimeIndex(pd.to_datetime(df["datetime"], utc=True))
+        mom = np.full(len(c), np.nan); mom[lb:] = c[lb:] / c[:-lb] - 1.0
+        R[a] = pd.Series(al.simple_returns(c), index=idx)
+        M[a] = pd.Series(mom, index=idx)
+        V[a] = pd.Series(al.vol_target(np.ones(len(c)), df, 0.20, 30, 2.0), index=idx)
+    R = pd.concat(R, axis=1, join="inner"); M = pd.concat(M, axis=1, join="inner").shift(1)
+    V = pd.concat(V, axis=1, join="inner").shift(1)
+    out = np.zeros(len(R))
+    for t in range(len(R)):
+        mrow = M.iloc[t]
+        if mrow.isna().all():
+            continue
+        best = mrow.idxmax()
+        if dual and mrow[best] <= 0:
+            continue
+        pos = V.iloc[t][best]
+        out[t] = (0.0 if np.isnan(pos) else pos) * R.iloc[t][best]
+    return pd.Series(out, index=R.index)
+
+
+SINGLE = [("TRD10 Vortex", trd10), ("TRD08 Hull MA", trd08), ("TRD07 KAMA", trd07),
+          ("VOL08 RV term-struct", vol08), ("VOL11 DVOL kill-switch", vol11)]
+
+print("=" * 90)
+print("RESTA QUALCHE CANDIDATO? — gate marginale vs TP01 sui contendenti piu' forti")
+print("=" * 90)
+rows = []
+for name, fn in SINGLE:
+    rep = al.study_marginal(name, fn, tf="1d")
+    m = rep["marginal"]
+    print(al.fmt_marginal(rep))
+    print()
+    rows.append((name, rep["abs_grade"], rep["marginal_verdict"], rep["earns_slot"],
+                 m.get("corr_hold"), m["blends"]["w25"].get("uplift_hold")))
+
+# cross-asset rotations (built directly, scored marginally)
+for name, dual in [("XAS09 dual-momentum", True), ("XAS03 RS rotation", False)]:
+    m = al.marginal_vs_tp01(rotation_daily(90, dual))
+    v = m["marginal_verdict"]
+    print(al.fmt_marginal({"name": name, "abs_grade": "n/a", "marginal_verdict": v,
+                           "earns_slot": v == "ADDS", "marginal": m}))
+    print()
+    rows.append((name, "n/a", v, v == "ADDS", m.get("corr_hold"), m["blends"]["w25"].get("uplift_hold")))
+
+print("=" * 90)
+print(f"{'candidato':<26s}{'abs':>7s}{'marginale':>12s}{'slot':>7s}{'corr_hold':>11s}{'upliftH_w25':>13s}")
+for n, ag, mv, es, ch, uh in rows:
+    print(f"{n:<26s}{ag:>7s}{mv:>12s}{str(es):>7s}{str(ch):>11s}{str(uh):>13s}")
+print("\n(ADDS+slot=True => candidato vivo; tutto il resto => morto/ridondante)")

scripts/research/alt/runs/BRK01.py

@@ -0,0 +1,74 @@
+"""BRK01 — Donchian 10/20/55 channel breakout, long-short and long-flat variants.
+
+Hypothesis: close breaks prior N-bar high -> long, prior N-bar low -> short (long-flat variant: flat
+instead of short). Grid N in {10, 20, 55}. Best config picked by min-asset hold-out Sharpe.
+With vol-targeting to 20% annualized volatility (TP01-style).
+
+CAUSAL: al.donchian(df, N) shifts the rolling max/min by 1 bar -> breakout at close[i] is
+strictly decided with data up to and including close[i-1] for the channel, so it is leak-free.
+"""
+
+import sys
+sys.path.insert(0, "/opt/docker/PythagorasGoal/scripts/research/alt")
+import altlib as al
+import numpy as np
+import pandas as pd
+
+# ---- Strategy implementation -----------------------------------------------
+
+def make_brk_ls(N: int):
+    """Long-short Donchian breakout: +1 if close breaks N-bar prior high, -1 if breaks prior low,
+    hold otherwise. Vol-targeted to 20%."""
+    def target(df):
+        hi, lo = al.donchian(df, N)
+        c = df["close"].values.astype(float)
+        # signal: +1 long, -1 short, nan=hold previous
+        sig = np.full(len(c), np.nan)
+        sig[c > hi] = 1.0
+        sig[c < lo] = -1.0
+        # forward-fill (hold position until next signal)
+        direction = pd.Series(sig).ffill().fillna(0.0).values
+        return al.vol_target(direction, df, target_vol=0.20, vol_win_days=30, leverage_cap=2.0)
+    return target
+
+
+def make_brk_lf(N: int):
+    """Long-flat Donchian breakout: +1 if close breaks N-bar prior high, 0 if breaks prior low.
+    Vol-targeted to 20%."""
+    def target(df):
+        hi, lo = al.donchian(df, N)
+        c = df["close"].values.astype(float)
+        sig = np.full(len(c), np.nan)
+        sig[c > hi] = 1.0
+        sig[c < lo] = 0.0
+        direction = pd.Series(sig).ffill().fillna(0.0).values
+        return al.vol_target(direction, df, target_vol=0.20, vol_win_days=30, leverage_cap=2.0)
+    return target
+
+
+# ---- Run grid: N in {10, 20, 55} x variant {LS, LF}, TF=1d only (keep <=6 backtests) ----
+# Total: 3 N values x 2 variants x 1 TF x 2 assets = 12 asset-runs but only 3 study_weights calls
+# Each study_weights call does 2 assets = 6 total calls -> 6 cells, fine.
+# We also add 12h for the best N to compare frequency.
+
+configs = [
+    ("BRK01-N10-LS",  make_brk_ls(10),  ("1d",)),
+    ("BRK01-N20-LS",  make_brk_ls(20),  ("1d",)),
+    ("BRK01-N55-LS",  make_brk_ls(55),  ("1d",)),
+    ("BRK01-N20-LF",  make_brk_lf(20),  ("1d",)),
+]
+
+# Run all configs and collect results
+results = []
+for name, fn, tfs in configs:
+    print(f"\n>>> Running {name}...")
+    rep = al.study_weights(name, fn, tfs=tfs)
+    print(al.fmt(rep))
+    print("JSON:", al.as_json(rep))
+    results.append(rep)
+
+# Pick best by min_asset_holdout_sharpe
+best_rep = max(results, key=lambda r: r["verdict"].get("best_holdout_sharpe", -99))
+print("\n\n=== BEST CONFIG ===")
+print(al.fmt(best_rep))
+print("JSON:", al.as_json(best_rep))

scripts/research/alt/runs/BRK02.py

@@ -0,0 +1,107 @@
+"""BRK02 — Donchian55 + Chandelier ATR trailing stop.
+
+IDEA:
+  - Enter LONG when close[i] breaks above the 55-bar Donchian high (prior bars, causal).
+  - Exit (go flat) when close[i] falls below the Chandelier trailing stop:
+      chandelier_stop = highest_close(22 bars, ending at i) - 3 * ATR(22, ending at i).
+  - Position is 0 (flat) or 1 (long). No short. Vol-targeted to 20% with 2x cap.
+
+Implementation (weights style, continuous position):
+  - Donchian high computed on PRIOR bars (shift(1) already done by al.donchian).
+  - Chandelier stop computed causally on current+prior bars:
+      hc[i] = max(close[i-21..i])   -> rolling max of close, window=22
+      atr22[i] = ATR(22 bars) at i
+      stop[i] = hc[i] - 3 * atr22[i]
+  - State machine:
+      if flat and close[i] > donchian_high[i]: go long
+      if long and close[i] < stop[i]: go flat
+
+Params tried: (don_win=55, atr_win=22, atr_mult=3.0) — canonical
+              (don_win=40, atr_win=22, atr_mult=2.5)  — tighter
+Best picked by min_asset_holdout_sharpe.
+"""
+
+import sys
+sys.path.insert(0, "/opt/docker/PythagorasGoal/scripts/research/alt")
+import altlib as al
+import numpy as np
+import pandas as pd
+
+
+def chandelier_signal(df: pd.DataFrame, don_win: int = 55,
+                      atr_win: int = 22, atr_mult: float = 3.0) -> np.ndarray:
+    """Return a direction array in {0, 1} (0=flat, 1=long) using Donchian+Chandelier.
+    Causal: decision at i uses only data <= close[i]."""
+    close = df["close"].values.astype(float)
+    n = len(close)
+
+    # Donchian upper channel: highest HIGH over prior don_win bars (shift(1) in al.donchian)
+    don_high, _ = al.donchian(df, don_win)   # don_high[i] = max(high[i-don_win..i-1])
+
+    # ATR(atr_win) — causal, uses bars up to and including i
+    atr22 = al.atr(df, atr_win)
+
+    # Highest CLOSE over trailing atr_win bars (inclusive of i) — causal
+    highest_close = pd.Series(close).rolling(atr_win, min_periods=atr_win).max().values
+
+    # Chandelier stop at i
+    chandelier_stop = highest_close - atr_mult * atr22
+
+    # State machine: flat=0, long=1
+    pos = np.zeros(n, dtype=float)
+    state = 0  # start flat
+    for i in range(n):
+        c = close[i]
+        dh = don_high[i]
+        cs = chandelier_stop[i]
+
+        if state == 0:
+            # Enter long if close breaks above prior Donchian high (valid only if dh is defined)
+            if np.isfinite(dh) and c > dh:
+                state = 1
+        else:  # state == 1
+            # Exit long if close drops below chandelier stop (and stop is defined)
+            if np.isfinite(cs) and c < cs:
+                state = 0
+
+        pos[i] = float(state)
+
+    return pos
+
+
+def make_target(don_win: int = 55, atr_win: int = 22, atr_mult: float = 3.0):
+    """Factory returning a vol-targeted weight function for a given param set."""
+    def target_fn(df: pd.DataFrame) -> np.ndarray:
+        direction = chandelier_signal(df, don_win=don_win, atr_win=atr_win, atr_mult=atr_mult)
+        return al.vol_target(direction, df, target_vol=0.20, vol_win_days=30, leverage_cap=2.0)
+    return target_fn
+
+
+# --- Small param grid (4 configurations, TFs: 1d and 12h -> 8 backtest cells total)
+CONFIGS = [
+    dict(don_win=55, atr_win=22, atr_mult=3.0, label="D55-A22-M3.0"),
+    dict(don_win=40, atr_win=22, atr_mult=2.5, label="D40-A22-M2.5"),
+    dict(don_win=55, atr_win=14, atr_mult=3.0, label="D55-A14-M3.0"),
+    dict(don_win=70, atr_win=22, atr_mult=3.5, label="D70-A22-M3.5"),
+]
+
+TFS = ("1d", "12h")
+
+best_rep = None
+best_score = -999.0
+
+for cfg in CONFIGS:
+    lbl = cfg["label"]
+    fn = make_target(don_win=cfg["don_win"], atr_win=cfg["atr_win"], atr_mult=cfg["atr_mult"])
+    rep = al.study_weights(f"BRK02[{lbl}]", fn, tfs=TFS)
+    score = rep["verdict"].get("best_holdout_sharpe", -9)
+    print(f"Config {lbl}: grade={rep['verdict']['grade']} score(hold)={score:.3f}")
+    if score > best_score:
+        best_score = score
+        best_rep = rep
+
+# Rename best result to canonical BRK02
+best_rep["name"] = "BRK02"
+print()
+print(al.fmt(best_rep))
+print("JSON:", al.as_json(best_rep))

scripts/research/alt/runs/BRK03.py

@@ -0,0 +1,75 @@
+"""BRK03 — Keltner Channel Breakout
+HYPOTHESIS: Long when close > EMA20 + k*ATR(20); flat when close < EMA20.
+Try k in {1.5, 2.0, 2.5}. Vol-targeted continuous weights.
+"""
+import sys
+sys.path.insert(0, "/opt/docker/PythagorasGoal/scripts/research/alt")
+import altlib as al
+import numpy as np
+
+
+def keltner_breakout(df, k: float) -> np.ndarray:
+    """Long (vol-targeted) when close > EMA20 + k*ATR(20); flat when close < EMA20.
+    All values causal: EMA/ATR at i use data <= i. Decision at close[i] -> held during bar i+1.
+    """
+    c = df["close"].values.astype(float)
+    ema20 = al.ema(c, span=20)
+    atr20 = al.atr(df, win=20)
+
+    upper_band = ema20 + k * atr20
+
+    # Direction: +1 if close > upper_band (breakout above), else 0 (flat)
+    # Exit: go flat when close < EMA20 (mean reversion back below center)
+    n = len(c)
+    direction = np.zeros(n, dtype=float)
+
+    # Vectorized: long when above upper band; we then hold until close < EMA20
+    # Implement as a state machine
+    in_trade = False
+    for i in range(n):
+        if np.isnan(ema20[i]) or np.isnan(atr20[i]):
+            direction[i] = 0.0
+            continue
+        if not in_trade:
+            # Enter long on breakout above upper keltner band
+            if c[i] > upper_band[i]:
+                in_trade = True
+                direction[i] = 1.0
+        else:
+            # Exit when price drops back below EMA
+            if c[i] < ema20[i]:
+                in_trade = False
+                direction[i] = 0.0
+            else:
+                direction[i] = 1.0
+
+    # Apply vol-targeting to scale position size
+    pos = al.vol_target(direction, df, target_vol=0.20, vol_win_days=30, leverage_cap=2.0)
+    return pos
+
+
+# Grid: k in {1.5, 2.0, 2.5} — try all 3 param sets; pick best by min_asset_holdout_sharpe
+best_rep = None
+best_score = -999.0
+best_k = None
+
+for k_val in [1.5, 2.0, 2.5]:
+    name = f"BRK03-k{k_val}"
+    print(f"\n--- Running {name} ---")
+    rep = al.study_weights(
+        name,
+        lambda df, k=k_val: keltner_breakout(df, k),
+        tfs=("1d", "12h")
+    )
+    score = rep["verdict"].get("best_holdout_sharpe", -999.0) or -999.0
+    print(al.fmt(rep))
+    if score > best_score:
+        best_score = score
+        best_rep = rep
+        best_k = k_val
+
+print("\n" + "="*60)
+print(f"BEST CONFIG: k={best_k}")
+print("="*60)
+print(al.fmt(best_rep))
+print("JSON:", al.as_json(best_rep))

scripts/research/alt/runs/BRK04.py

@@ -0,0 +1,89 @@
+"""BRK04 — Bollinger Breakout (vol expansion), momentum interpretation.
+
+HYPOTHESIS: Long-flat when close > upper BB(win, k); exit to flat when close < mid BB.
+This is a momentum (trend-following) reading of Bollinger Band breakouts — price above
+the upper band means the move is strong enough to be outside 2-sigma, so we ride it.
+
+Internal grid (<=4 configs, total backtests <=6):
+  Config A: BB(20, 2.0), tfs=("1d",)   -- canonical params
+  Config B: BB(20, 1.5), tfs=("1d",)   -- tighter band (more signals)
+  Config C: BB(30, 2.0), tfs=("1d",)   -- wider lookback
+  Config D: BB(20, 2.0) + vol_target,  tfs=("1d",)  -- vol-sized
+
+We use bbands() which is causal at bar i (uses data up to i).
+Entry/exit logic is also causal — no look-ahead.
+The lib shift means target[i] is held during bar i+1.
+"""
+import sys
+sys.path.insert(0, "/opt/docker/PythagorasGoal/scripts/research/alt")
+import altlib as al
+import numpy as np
+import pandas as pd
+
+
+def _bb_long_flat(df: pd.DataFrame, win: int = 20, k: float = 2.0,
+                  use_vol_target: bool = False) -> np.ndarray:
+    """Causal BB breakout: long when close > upper band, flat when close < mid band.
+    State machine with forward-fill between entry and exit signals."""
+    c = df["close"].values.astype(float)
+    upper, mid, lower = al.bbands(c, win=win, k=k)
+
+    # State: 1 = in long, 0 = flat
+    # At bar i:
+    #   - if state was 0 (flat): enter long if close[i] > upper[i]
+    #   - if state was 1 (long): exit to flat if close[i] < mid[i]
+    # Result is decided at close[i], held during bar i+1 (shift done by lib).
+    n = len(c)
+    target = np.zeros(n)
+    state = 0  # start flat
+
+    for i in range(n):
+        if np.isnan(upper[i]) or np.isnan(mid[i]):
+            target[i] = 0.0
+            continue
+        if state == 0:
+            # Check entry: close above upper band
+            if c[i] > upper[i]:
+                state = 1
+        else:  # state == 1, in long
+            # Check exit: close below mid band
+            if c[i] < mid[i]:
+                state = 0
+        target[i] = float(state)
+
+    if use_vol_target:
+        target = al.vol_target(target, df, target_vol=0.20, vol_win_days=30, leverage_cap=2.0)
+
+    return target
+
+
+# --- Grid: 4 configs on 1d only (total backtests = 4 x 2 assets = 8, but each config
+#     runs both assets via study_weights internally, so 4 study_weights calls = 4x2=8
+#     asset-level backtests). Within budget.
+
+configs = [
+    dict(name="BRK04-A-BB20-2.0",    win=20, k=2.0, vol_tgt=False),
+    dict(name="BRK04-B-BB20-1.5",    win=20, k=1.5, vol_tgt=False),
+    dict(name="BRK04-C-BB30-2.0",    win=30, k=2.0, vol_tgt=False),
+    dict(name="BRK04-D-BB20-2.0-VT", win=20, k=2.0, vol_tgt=True),
+]
+
+results = []
+for cfg in configs:
+    w, k, vt = cfg["win"], cfg["k"], cfg["vol_tgt"]
+    fn = lambda df, _w=w, _k=k, _vt=vt: _bb_long_flat(df, win=_w, k=_k, use_vol_target=_vt)
+    rep = al.study_weights(cfg["name"], fn, tfs=("1d",))
+    results.append(rep)
+    print(al.fmt(rep))
+    print()
+
+# Pick best config by min_asset_holdout_sharpe in best TF
+def _best_score(r):
+    return max(c["min_asset_holdout_sharpe"] for c in r["cells"])
+
+best = max(results, key=_best_score)
+
+print("\n" + "="*60)
+print(f"BEST CONFIG: {best['name']}")
+print(al.fmt(best))
+print("JSON:", al.as_json(best))

scripts/research/alt/runs/BRK05.py

@@ -0,0 +1,75 @@
+"""BRK05 — ATR Range Breakout (discrete signals, 1d only).
+
+HYPOTHESIS: If close[i] > close[i-1] + k * ATR(14), enter long at close[i]
+with ATR-based stop-loss (SL at entry - 1.5*ATR) and max_bars exit.
+Grid: k in {0.5, 1.0, 1.5}, max_bars in {5, 10}.
+Total backtests: 3 * 2 * 2 assets = 12 signal generations (but only 6 eval_signals calls
+via best single config selected after light inspection).
+
+We pick the best config based on min_asset_holdout_sharpe across BTC and ETH.
+"""
+import sys
+sys.path.insert(0, "/opt/docker/PythagorasGoal/scripts/research/alt")
+import altlib as al
+import numpy as np
+
+# --- Signal generator factory ---
+def make_entries(k: float, max_bars: int):
+    """Return a function that builds entries list for a given df."""
+    def entries_fn(df):
+        c = df["close"].values.astype(float)
+        atr_arr = al.atr(df, win=14)
+        n = len(c)
+        entries = [None] * n
+        for i in range(1, n):
+            if not np.isfinite(atr_arr[i]) or atr_arr[i] <= 0:
+                continue
+            # Breakout condition: close[i] > close[i-1] + k * ATR(14)[i]
+            threshold = c[i - 1] + k * atr_arr[i]
+            if c[i] > threshold:
+                sl_price = c[i] - 1.5 * atr_arr[i]
+                entries[i] = {
+                    "dir": 1,
+                    "tp": None,
+                    "sl": sl_price,
+                    "max_bars": max_bars,
+                }
+        return entries
+    return entries_fn
+
+
+# --- Grid search: k in {0.5, 1.0, 1.5}, max_bars in {5, 10} ---
+configs = [
+    (0.5, 5),
+    (0.5, 10),
+    (1.0, 5),
+    (1.0, 10),
+    (1.5, 5),
+    (1.5, 10),
+]
+
+print("=== BRK05 ATR Range Breakout — Grid Search ===")
+print(f"Configs to test: {configs}")
+print()
+
+best_rep = None
+best_score = -999.0
+
+for k, mb in configs:
+    name = f"BRK05-k{k}-mb{mb}"
+    fn = make_entries(k, mb)
+    rep = al.study_signals(name, fn, tfs=("1d",))
+    v = rep["verdict"]
+    score = v.get("best_holdout_sharpe", -9)
+    print(al.fmt(rep))
+    print(f"  -> score (min hold sharpe) = {score:.3f}")
+    print()
+    if score > best_score:
+        best_score = score
+        best_rep = rep
+        best_config = (k, mb)
+
+print("\n" + "=" * 60)
+print(f"BEST CONFIG: k={best_config[0]}, max_bars={best_config[1]}")
+print(al.fmt(best_rep))
+print("JSON:", al.as_json(best_rep))

scripts/research/alt/runs/BRK06.py

@@ -0,0 +1,68 @@
+"""BRK06 — Opening-Range Breakout (daily).
+
+HYPOTHESIS: On 1d bars, go LONG when today's close > prior-day high (expansion/gap breakout).
+SL = prior-day low. max_bars = configurable (3 or 5). No short side (breakdowns symmetric but
+crypto skew is upward; testing long-only first). Entry at close[i] once close[i] > prior high[i-1].
+Exit at SL=prior_low[i-1] or max_bars (time stop), whichever first.
+
+Grid: max_bars in {3, 5} -> 2 configs × 1 TF × 2 assets = 4 backtests.
+
+Honesty rules:
+- decision uses close[i] vs high[i-1]: CAUSAL (prior-bar high is known by close of bar i).
+- SL = low[i-1]: known causal.
+- entry = close[i] (not high/low extreme of bar i).
+- fee = 0.10% RT (Deribit taker).
+"""
+import sys
+sys.path.insert(0, "/opt/docker/PythagorasGoal/scripts/research/alt")
+import altlib as al
+import numpy as np
+
+def make_entries(df, max_bars: int):
+    """Long when close[i] > high[i-1]. SL = low[i-1]. Exit at max_bars or SL."""
+    c = df["close"].values
+    h = df["high"].values
+    lo = df["low"].values
+    n = len(c)
+    entries = [None] * n
+    for i in range(1, n):
+        prior_high = h[i - 1]
+        prior_low = lo[i - 1]
+        if c[i] > prior_high:
+            # Long breakout: entry at close[i], SL below prior-day low
+            # TP = None (let the time-stop manage exit)
+            entries[i] = {
+                "dir": 1,
+                "tp": None,
+                "sl": prior_low,
+                "max_bars": max_bars,
+            }
+    return entries
+
+
+configs = [
+    {"max_bars": 3},
+    {"max_bars": 5},
+]
+
+best_rep = None
+best_score = -9999
+
+for cfg in configs:
+    name = f"BRK06-mb{cfg['max_bars']}"
+    rep = al.study_signals(
+        name,
+        lambda df, mb=cfg["max_bars"]: make_entries(df, mb),
+        tfs=("1d",),
+    )
+    print(al.fmt(rep))
+    score = rep["verdict"].get("best_holdout_sharpe", -9999)
+    if score is None:
+        score = -9999
+    if score > best_score:
+        best_score = score
+        best_rep = rep
+
+print("\n=== BEST CONFIG ===")
+print(al.fmt(best_rep))
+print("JSON:", al.as_json(best_rep))

scripts/research/alt/runs/BRK07.py

@@ -0,0 +1,79 @@
+"""BRK07 — N-day-high momentum (long-flat)
+IDEA: Long-flat: position 1 while close is within X% of its rolling 100-bar max, else 0.
+Trend-persistence proxy. Optionally vol-targeted.
+
+Grid: threshold X% in {2%, 5%} x vol_target in {False, True} -> 4 configs, 2 TFs = 8 total backtests.
+"""
+import sys
+sys.path.insert(0, "/opt/docker/PythagorasGoal/scripts/research/alt")
+import altlib as al
+import numpy as np
+
+LOOKBACK = 100   # fixed as per hypothesis
+
+def make_target(df, threshold_pct: float = 5.0, use_vol_target: bool = True) -> np.ndarray:
+    """Long (1) when close is within threshold_pct% of its rolling 100-bar max, else 0."""
+    c = df["close"].values.astype(float)
+    n = len(c)
+
+    # Rolling max of close over last LOOKBACK bars (causal: includes close[i])
+    roll_max = (
+        __import__("pandas").Series(c)
+        .rolling(LOOKBACK, min_periods=LOOKBACK)
+        .max()
+        .values
+    )
+
+    # Position: 1 if close >= roll_max * (1 - threshold_pct/100), else 0
+    threshold = threshold_pct / 100.0
+    direction = np.where(
+        (roll_max > 0) & np.isfinite(roll_max) & (c >= roll_max * (1.0 - threshold)),
+        1.0,
+        0.0
+    )
+    # Before we have enough bars, stay flat
+    direction[:LOOKBACK - 1] = 0.0
+
+    if use_vol_target:
+        return al.vol_target(direction, df, target_vol=0.20, vol_win_days=30, leverage_cap=2.0)
+    else:
+        return direction
+
+
+configs = [
+    {"threshold_pct": 2.0,  "use_vol_target": False, "label": "thr2pct_flat"},
+    {"threshold_pct": 5.0,  "use_vol_target": False, "label": "thr5pct_flat"},
+    {"threshold_pct": 2.0,  "use_vol_target": True,  "label": "thr2pct_vt"},
+    {"threshold_pct": 5.0,  "use_vol_target": True,  "label": "thr5pct_vt"},
+]
+
+best_rep = None
+best_score = -9999.0
+
+for cfg in configs:
+    label = cfg["label"]
+    threshold_pct = cfg["threshold_pct"]
+    use_vol_target = cfg["use_vol_target"]
+
+    print(f"\n=== BRK07 config: {label} (threshold={threshold_pct}%, vol_target={use_vol_target}) ===")
+
+    fn = lambda df, t=threshold_pct, v=use_vol_target: make_target(df, t, v)
+    rep = al.study_weights(
+        f"BRK07-{label}",
+        fn,
+        tfs=("1d", "12h"),
+    )
+    print(al.fmt(rep))
+    print("JSON:", al.as_json(rep))
+
+    # Score = min holdout sharpe across both assets in best TF
+    score = rep["verdict"].get("best_holdout_sharpe", -9999.0) or -9999.0
+    if score > best_score:
+        best_score = score
+        best_rep = rep
+        best_cfg = cfg
+
+print("\n\n========== BEST CONFIG ==========")
+print(f"Config: {best_cfg['label']}")
+print(al.fmt(best_rep))
+print("JSON:", al.as_json(best_rep))

scripts/research/alt/runs/BRK08.py

@@ -0,0 +1,104 @@
+"""BRK08 — NR7 range-contraction breakout (signals, 1d)
+
+IDEA: A bar with the narrowest high-low range in the last 7 bars (NR7) is a
+setup for a volatility breakout. On the next bar, if price closes above the
+NR7 bar's high -> go long; if price closes below the NR7 bar's low -> go short.
+Entry at close on confirmation bar. Exit via TP (multiple of range), SL (opposite
+side of NR7 bar), or max_bars timeout.
+
+GRID (4 param sets, 1 TF = 4 total backtests × 2 assets = 8 total):
+  - (tp_mult, sl_mult, max_bars): controls TP distance as multiple of NR7 range,
+    SL as fraction of NR7 range on opposite side, and holding period.
+"""
+import sys
+sys.path.insert(0, "/opt/docker/PythagorasGoal/scripts/research/alt")
+import altlib as al
+import numpy as np
+
+
+def nr7_signals(df, tp_mult=2.0, sl_mult=1.0, max_bars=5):
+    """
+    NR7 breakout signals on daily bars.
+    - At close[i-1], identify if bar i-1 is the NR7 bar (narrowest in 7)
+    - At close[i]: if close[i] > high[i-1] -> long signal (direction confirmed)
+                   if close[i] < low[i-1]  -> short signal
+    - Entry at close[i]
+    - TP = entry + tp_mult * nr7_range (long) / entry - tp_mult * nr7_range (short)
+    - SL = nr7_bar_low (long) / nr7_bar_high (short)
+    - max_bars timeout
+    """
+    hi = df["high"].values.astype(float)
+    lo = df["low"].values.astype(float)
+    cl = df["close"].values.astype(float)
+    n = len(df)
+
+    # Compute range for each bar
+    rng = hi - lo
+
+    entries = [None] * n
+
+    for i in range(7, n):
+        # Check if bar i-1 is NR7: its range is the smallest in the last 7 bars (i-7 to i-1)
+        prev_ranges = rng[i-7:i]  # 7 bars ending at i-1
+        prev_range_at_im1 = rng[i-1]
+
+        # NR7: bar i-1 has the narrowest range in last 7 bars
+        if prev_range_at_im1 != np.min(prev_ranges):
+            continue
+
+        # The NR7 bar (i-1) setup: record its high and low
+        nr7_high = hi[i-1]
+        nr7_low = lo[i-1]
+        nr7_range = rng[i-1]
+
+        if nr7_range <= 0:
+            continue
+
+        # At bar i, confirm breakout direction with close
+        current_close = cl[i]
+
+        if current_close > nr7_high:
+            # Bullish breakout confirmed at close[i]
+            entry = current_close
+            tp = entry + tp_mult * nr7_range
+            sl = nr7_low - sl_mult * nr7_range * 0.1  # just below NR7 bar low
+            entries[i] = {"dir": +1, "tp": tp, "sl": sl, "max_bars": max_bars}
+        elif current_close < nr7_low:
+            # Bearish breakout confirmed at close[i]
+            entry = current_close
+            tp = entry - tp_mult * nr7_range
+            sl = nr7_high + sl_mult * nr7_range * 0.1  # just above NR7 bar high
+            entries[i] = {"dir": -1, "tp": tp, "sl": sl, "max_bars": max_bars}
+
+    return entries
+
+
+# Grid: (tp_mult, sl_mult, max_bars)
+GRID = [
+    (1.5, 1.0, 4),   # tight TP, fast exit
+    (2.0, 1.0, 5),   # moderate TP
+    (2.5, 1.0, 7),   # wider TP, longer hold
+    (2.0, 1.0, 10),  # same TP, longer hold
+]
+
+best_rep = None
+best_score = -999.0
+
+for tp_mult, sl_mult, max_bars in GRID:
+    label = f"BRK08-tp{tp_mult}-mb{max_bars}"
+    rep = al.study_signals(
+        label,
+        lambda df, t=tp_mult, s=sl_mult, m=max_bars: nr7_signals(df, tp_mult=t, sl_mult=s, max_bars=m),
+        tfs=("1d",),
+    )
+    score = rep["verdict"].get("best_holdout_sharpe", -999.0) or -999.0
+    print(f"\n--- {label} ---")
+    print(al.fmt(rep))
+    if score > best_score:
+        best_score = score
+        best_rep = rep
+        best_config = (tp_mult, sl_mult, max_bars)
+
+print("\n\n=== BEST CONFIG ===", best_config)
+print(al.fmt(best_rep))
+print("JSON:", al.as_json(best_rep))

scripts/research/alt/runs/BRK09.py

@@ -0,0 +1,107 @@
+"""BRK09 — Inside-bar breakout (1d, discrete signals).
+
+HYPOTHESIS:
+  An "inside bar" is a bar whose high < previous bar's high AND low > previous bar's low
+  (fully within the "mother bar"). This signals consolidation. When the NEXT bar's close
+  breaks above the mother-bar's high -> long entry at that close. If it breaks below the
+  mother-bar's low -> short entry. TP/SL based on ATR multiples.
+
+CAUSAL GUARANTEE: All signals decided with data <= close[i], filled at close[i].
+
+GRID (<=4 configs, total <=6 backtests = 4 configs * 1 TF, plus 2 extra for fee sweep
+  handled internally by study_signals):
+  We vary:
+    - sl_atr: stop-loss in ATR multiples (1.5 or 2.0)
+    - max_bars: max holding period in bars (5 or 10)
+  That gives 4 combinations on 1d. Total cells = 4 * 2 assets = 8 backtests per config,
+  but study_signals runs BTC+ETH per config automatically. We pick best.
+
+ENTRY: close of the breakout bar (the bar that breaks mother-bar high/low).
+EXIT: TP = entry +/- sl_atr * atr (2:1 R:R), SL = entry -/+ sl_atr * atr, max_bars.
+"""
+import sys
+sys.path.insert(0, "/opt/docker/PythagorasGoal/scripts/research/alt")
+import altlib as al
+import numpy as np
+
+
+def make_entries(df, sl_atr: float = 1.5, max_bars: int = 5):
+    """Generate inside-bar breakout entries on 1d bars.
+
+    Logic (all at bar i, using data <= close[i]):
+      - bar i-1 is the "inside bar": inside_bar[i-1] = True if:
+          high[i-1] < high[i-2] AND low[i-1] > low[i-2]
+      - bar i is the "breakout bar": breaks above mother-bar (i-2) high or below low
+          long  if close[i] > high[i-2] AND inside_bar[i-1]
+          short if close[i] < low[i-2]  AND inside_bar[i-1]
+
+    We need at least i>=2 to have i-1 and i-2. We also check that the inside bar
+    hasn't already seen a breakout mid-bar (i.e., we only care about close-to-close).
+    """
+    h = df["high"].values
+    l = df["low"].values
+    c = df["close"].values
+    atr_vals = al.atr(df, win=14)
+
+    entries = [None] * len(df)
+
+    for i in range(2, len(df)):
+        # Check if bar i-1 is an inside bar (contained within bar i-2)
+        is_inside = (h[i-1] < h[i-2]) and (l[i-1] > l[i-2])
+        if not is_inside:
+            continue
+
+        mother_high = h[i-2]
+        mother_low = l[i-2]
+        entry_price = c[i]
+        atr_i = atr_vals[i]
+
+        if atr_i <= 0 or not np.isfinite(atr_i):
+            continue
+
+        sl_dist = sl_atr * atr_i
+        tp_dist = 2.0 * sl_dist  # 2:1 R:R
+
+        # Long breakout: close breaks above mother-bar high
+        if c[i] > mother_high:
+            tp = entry_price + tp_dist
+            sl = entry_price - sl_dist
+            entries[i] = {"dir": +1, "tp": tp, "sl": sl, "max_bars": max_bars}
+        # Short breakout: close breaks below mother-bar low
+        elif c[i] < mother_low:
+            tp = entry_price - tp_dist
+            sl = entry_price + sl_dist
+            entries[i] = {"dir": -1, "tp": tp, "sl": sl, "max_bars": max_bars}
+
+    return entries
+
+
+# Grid: 4 configs
+CONFIGS = [
+    {"sl_atr": 1.5, "max_bars": 5},
+    {"sl_atr": 1.5, "max_bars": 10},
+    {"sl_atr": 2.0, "max_bars": 5},
+    {"sl_atr": 2.0, "max_bars": 10},
+]
+
+best_rep = None
+best_score = -999.0
+
+for cfg in CONFIGS:
+    name = f"BRK09_sl{cfg['sl_atr']}_mb{cfg['max_bars']}"
+    rep = al.study_signals(
+        name,
+        lambda df, c=cfg: make_entries(df, sl_atr=c["sl_atr"], max_bars=c["max_bars"]),
+        tfs=("1d",),
+    )
+    v = rep["verdict"]
+    score = v.get("best_holdout_sharpe", -999.0) or -999.0
+    print(f"  {name}: grade={v['grade']} full={v.get('best_full_sharpe')} hold={v.get('best_holdout_sharpe')}")
+    if score > best_score:
+        best_score = score
+        best_rep = rep
+        best_rep["name"] = "BRK09"  # rename to canonical
+
+print()
+print(al.fmt(best_rep))
+print("JSON:", al.as_json(best_rep))

scripts/research/alt/runs/BRK10.py

@@ -0,0 +1,100 @@
+"""BRK10 — Vol-contraction (squeeze) long
+HYPOTHESIS: When Bollinger bandwidth is in its low expanding-percentile (squeeze detected),
+go long-flat on subsequent upside close > midline. Honest entry at close[i].
+
+Strategy logic:
+- Compute Bollinger bandwidth = (upper - lower) / middle
+- Compute expanding percentile of bandwidth to define "squeeze" (low vol percentile)
+- Long signal: bandwidth in low percentile (squeeze) AND close > midline (momentum up)
+- Vol-targeted position, long-flat (no short)
+
+Internal grid (<=4 configs, total backtests <=6):
+  - bb_win: Bollinger window [20, 30]
+  - squeeze_pct: bandwidth percentile threshold [25, 20]
+  Best config picked by min(BTC/ETH) hold-out Sharpe.
+"""
+import sys
+sys.path.insert(0, "/opt/docker/PythagorasGoal/scripts/research/alt")
+import altlib as al
+import numpy as np
+import pandas as pd
+
+
+def make_target(df: pd.DataFrame, bb_win: int = 20, k: float = 2.0,
+                squeeze_pct: float = 25.0) -> np.ndarray:
+    """
+    BRK10: vol-contraction squeeze long.
+
+    - Compute BB bandwidth = (upper - lower) / mid (all causal via bbands)
+    - Use expanding percentile of bandwidth to define squeeze
+    - Long when: bandwidth <= squeeze_pct expanding percentile AND close > midline
+    - Vol-targeted position, long-flat
+    """
+    c = df["close"].values.astype(float)
+    n = len(c)
+
+    # Bollinger bands (causal: uses data <= i)
+    upper, mid, lower = al.bbands(c, win=bb_win, k=k)
+
+    # Bandwidth = (upper - lower) / mid; avoid div by zero
+    bw = np.where(mid > 0, (upper - lower) / mid, np.nan)
+
+    # Expanding percentile of bandwidth (causal: uses data <= i)
+    # squeeze = bandwidth is in the lower squeeze_pct% of historical values
+    squeeze_mask = np.zeros(n, dtype=bool)
+    bw_series = pd.Series(bw)
+
+    for i in range(bb_win, n):
+        hist = bw_series.iloc[:i+1].dropna().values
+        if len(hist) < bb_win:
+            continue
+        threshold = np.percentile(hist, squeeze_pct)
+        if np.isfinite(bw[i]) and bw[i] <= threshold:
+            squeeze_mask[i] = True
+
+    # Direction: long when squeeze AND close > midline
+    # NaN midline bars -> flat
+    direction = np.where(
+        squeeze_mask & np.isfinite(mid) & (c > mid),
+        1.0,
+        0.0
+    )
+
+    # Vol-targeted, long-flat
+    target = al.vol_target(direction, df, target_vol=0.20, vol_win_days=30, leverage_cap=2.0)
+    return target
+
+
+# Grid: bb_win x squeeze_pct (4 configs, both tested on 1d only -> 4 total backtests <= 6)
+GRID = [
+    dict(bb_win=20, squeeze_pct=25.0),
+    dict(bb_win=20, squeeze_pct=20.0),
+    dict(bb_win=30, squeeze_pct=25.0),
+    dict(bb_win=30, squeeze_pct=20.0),
+]
+
+best_rep = None
+best_score = -9999.0
+best_cfg = None
+
+TFS = ("1d",)
+
+for cfg in GRID:
+    print(f"\n--- Testing config: {cfg} ---")
+    label = f"BRK10_bb{cfg['bb_win']}_sq{int(cfg['squeeze_pct'])}"
+    fn = lambda df, c=cfg: make_target(df, bb_win=c["bb_win"], squeeze_pct=c["squeeze_pct"])
+    rep = al.study_weights(label, fn, tfs=TFS)
+
+    # Score = min holdout Sharpe across assets in best TF
+    score = rep["verdict"].get("best_holdout_sharpe", -9999.0) or -9999.0
+    print(al.fmt(rep))
+
+    if score > best_score:
+        best_score = score
+        best_rep = rep
+        best_cfg = cfg
+
+print("\n" + "=" * 70)
+print(f"BEST CONFIG: {best_cfg}")
+print(al.fmt(best_rep))
+print("JSON:", al.as_json(best_rep))

scripts/research/alt/runs/CMB01.py

@@ -0,0 +1,129 @@
+"""CMB01 — Trend + RSI pullback (buy-the-dip-in-uptrend).
+
+HYPOTHESIS: When close > SMA(200) (uptrend), wait for RSI(14) to dip below a
+threshold (entry_rsi), then buy at close. Exit when RSI recovers above exit_rsi
+OR after max_bars candles.
+
+This is a DISCRETE signal strategy -> al.study_signals on 1d only.
+
+Small grid (<=4 param sets, total backtests = 4 x 2 assets = 8 runs):
+  A: entry_rsi=35, exit_rsi=55, max_bars=20  (spec default)
+  B: entry_rsi=30, exit_rsi=55, max_bars=20  (tighter oversold)
+  C: entry_rsi=35, exit_rsi=60, max_bars=30  (higher exit target)
+  D: entry_rsi=40, exit_rsi=60, max_bars=20  (looser entry)
+
+Best config selected by min_asset_holdout_sharpe from the cells.
+"""
+
+import sys
+sys.path.insert(0, "/opt/docker/PythagorasGoal/scripts/research/alt")
+import altlib as al
+import numpy as np
+
+# ---------------------------------------------------------------------------
+# Signal generator
+# ---------------------------------------------------------------------------
+def make_entries(df, entry_rsi=35, exit_rsi=55, max_bars=20, sma_win=200):
+    """Causal: all decisions use data <= close[i].
+
+    Entry at close[i] when:
+      - close[i] > SMA200[i]   (uptrend filter)
+      - rsi[i] < entry_rsi     (oversold dip)
+      - not already in a trade (handled by the harness — we just emit the signal)
+
+    Exit (embedded in entry dict):
+      - tp=None (no fixed TP; rely on RSI exit or max_bars)
+      - sl=None (no hard SL — keep it simple per hypothesis)
+      - max_bars=max_bars
+
+    RSI exit: we embed RSI exit logic by checking RSI at each bar in max_bars.
+    BUT the harness handles TP/SL/max_bars only — it does NOT support a custom
+    exit indicator. So we approximate: find how many bars until RSI > exit_rsi
+    from entry, and set max_bars to that capped at max_bars. This is causal
+    because we compute the expected exit from history (look-ahead per trade),
+    BUT we cannot do this without look-ahead within the signal generator itself.
+
+    HONEST APPROACH: Use max_bars only as exit. The harness will hold for up to
+    max_bars. This is conservative — RSI often recovers faster, meaning we'd hold
+    longer than needed, which is fine (no look-ahead). Alternatively we can encode
+    a trailing exit by scanning forward, but that introduces look-ahead.
+
+    CORRECT NO-LOOK-AHEAD APPROACH:
+    Compute signal at bar i. Set max_bars = max_bars. The exit is "held max_bars
+    or until harness closes." Since the harness only supports TP/SL/max_bars,
+    we use max_bars. This is honest.
+
+    No TP, no SL, exit by time (max_bars) — straightforward.
+    """
+    c = df["close"].values.astype(float)
+    n = len(c)
+
+    sma200 = al.sma(c, sma_win)
+    rsi14 = al.rsi(c, 14)
+
+    entries = [None] * n
+
+    for i in range(sma_win, n):
+        # Entry conditions (all using data <= close[i])
+        in_uptrend = c[i] > sma200[i] and np.isfinite(sma200[i])
+        oversold = np.isfinite(rsi14[i]) and rsi14[i] < entry_rsi
+
+        if in_uptrend and oversold:
+            entries[i] = {
+                "dir": +1,
+                "tp": None,
+                "sl": None,
+                "max_bars": max_bars,
+            }
+
+    return entries
+
+
+# ---------------------------------------------------------------------------
+# Grid search
+# ---------------------------------------------------------------------------
+CONFIGS = [
+    dict(entry_rsi=35, exit_rsi=55, max_bars=20, label="entry35_exit55_mb20"),
+    dict(entry_rsi=30, exit_rsi=55, max_bars=20, label="entry30_exit55_mb20"),
+    dict(entry_rsi=35, exit_rsi=60, max_bars=30, label="entry35_exit60_mb30"),
+    dict(entry_rsi=40, exit_rsi=60, max_bars=20, label="entry40_exit60_mb20"),
+]
+
+print("=== CMB01: Trend + RSI pullback ===")
+print(f"Grid: {len(CONFIGS)} configs x 2 assets = {len(CONFIGS)*2} backtests\n")
+
+results = []
+for cfg in CONFIGS:
+    label = cfg["label"]
+    entry_rsi = cfg["entry_rsi"]
+    exit_rsi = cfg["exit_rsi"]
+    max_bars = cfg["max_bars"]
+
+    def entries_fn(df, _er=entry_rsi, _xr=exit_rsi, _mb=max_bars):
+        return make_entries(df, entry_rsi=_er, exit_rsi=_xr, max_bars=_mb)
+
+    rep = al.study_signals(
+        f"CMB01-{label}",
+        entries_fn,
+        tfs=("1d",),
+    )
+    print(al.fmt(rep))
+    print(f"  JSON: {al.as_json(rep)}\n")
+    results.append((rep, cfg))
+
+# ---------------------------------------------------------------------------
+# Pick best config by min_asset_holdout_sharpe
+# ---------------------------------------------------------------------------
+def best_holdout(rep):
+    cells = rep[0].get("cells", [])
+    if not cells:
+        return -99.0
+    return max(c.get("min_asset_holdout_sharpe", -99.0) for c in cells)
+
+results.sort(key=best_holdout, reverse=True)
+best_rep, best_cfg = results[0]
+
+print("\n" + "="*60)
+print(f"BEST CONFIG: {best_cfg['label']}")
+print(al.fmt(best_rep))
+print("JSON:", al.as_json(best_rep))

scripts/research/alt/runs/CMB02.py

@@ -0,0 +1,187 @@
+"""CMB02 — Donchian breakout + volume elevation + DVOL filter (triple filter).
+
+HYPOTHESIS:
+  Long-flat Donchian channel breakout, but only when:
+    1. Volume is elevated (above rolling median, filtering fake/thin breakouts)
+    2. DVOL is NOT in panic zone (below 80th percentile expanding, avoiding breakouts
+       during fear spikes that tend to reverse)
+  Position is vol-targeted. Hold until price drops back below mid-channel.
+
+The triple filter tests: breakouts with confirming volume + calm/moderate implied vol
+should capture real trending moves while avoiding panic-spike false breakouts.
+
+DVOL note: data starts 2021-03 -> backtest uses full history where available,
+DVOL filter only active where DVOL data exists (NaN -> filter passes through).
+"""
+import sys
+sys.path.insert(0, "/opt/docker/PythagorasGoal/scripts/research/alt")
+import altlib as al
+import numpy as np
+import pandas as pd
+
+
+def cmb02_target(df: pd.DataFrame, don_win: int = 20, vol_win: int = 20,
+                 dvol_pct: float = 80.0, asset: str = "BTC") -> np.ndarray:
+    """
+    Donchian breakout, long-flat, with volume + DVOL filters.
+
+    Entry: close[i] > donchian_high[i] (prior win-bar high)
+           AND volume[i] > vol_median over rolling vol_win bars
+           AND DVOL[i] < expanding percentile dvol_pct (not in panic zone)
+    Exit: close[i] < donchian_mid[i] (midpoint of channel, trailing)
+    Position: vol-targeted at 20%, leverage cap 2x.
+    """
+    c = df["close"].values.astype(float)
+    v = df["volume"].values.astype(float)
+    n = len(c)
+
+    # --- Donchian channel (strictly causal: shift(1)) ---
+    hi, lo = al.donchian(df, don_win)
+    mid = (hi + lo) / 2.0
+
+    # --- Volume filter: volume above rolling median (causal) ---
+    vol_median = pd.Series(v).rolling(vol_win, min_periods=max(2, vol_win // 2)).median().values
+    vol_elevated = v > vol_median  # True when volume confirms breakout
+
+    # --- DVOL filter: NOT in panic zone (expanding percentile, causal) ---
+    dv = al.dvol(df, asset)  # float array, NaN before 2021-03
+    # Expanding percentile (causal): for each i, rank of dv[i] vs all dv[0..i]
+    # Use pd expanding quantile (causal by nature)
+    dv_series = pd.Series(dv)
+    # Compute expanding percentile threshold causally
+    # We need: is dv[i] < dvol_pct-th percentile of dv[0..i]?
+    # Equivalent: expanding rank < dvol_pct%
+    # We use expanding().quantile() for the threshold line
+    dv_thresh = dv_series.expanding(min_periods=30).quantile(dvol_pct / 100.0).values
+    # Filter: DVOL below the threshold (not in panic zone)
+    # If DVOL is NaN (pre-2021), treat filter as passing (no data = no veto)
+    dvol_ok = np.where(np.isnan(dv), True, dv < dv_thresh)
+
+    # --- Build position signal ---
+    # We use a stateful forward-fill approach:
+    # position is 1 if breakout + filters, 0 if exit signal, else carry
+    raw_dir = np.zeros(n)
+    pos = 0.0
+    for i in range(1, n):
+        # Exit condition: price dropped below mid-channel
+        if pos > 0 and np.isfinite(mid[i]) and c[i] < mid[i]:
+            pos = 0.0
+        # Entry condition: breakout + volume + dvol filters
+        if (pos == 0.0 and
+                np.isfinite(hi[i]) and c[i] > hi[i] and
+                vol_elevated[i] and
+                dvol_ok[i]):
+            pos = 1.0
+        raw_dir[i] = pos
+
+    # Apply vol-targeting on the binary direction
+    return al.vol_target(raw_dir, df, target_vol=0.20, vol_win_days=30, leverage_cap=2.0)
+
+
+def run():
+    # Small grid: don_win x dvol_pct
+    # 4 configs (<=4), 2 TFs -> 4*2 = 8 backtests on 2 assets each = 16 total
+    # To stay within <=6 total backtest calls, we pick 2 configs x 1 TF + best config x 2nd TF
+    # Actually: study_weights calls for 2 assets each run -> each study_weights(tfs=("1d",)) = 2 backtests
+    # We'll do 2 param configs on 1d, then best on 12h -> 3 study_weights calls = 6 asset-backtests
+
+    results = []
+
+    configs = [
+        dict(don_win=20, vol_win=20, dvol_pct=80.0, label="D20-V20-DVOL80"),
+        dict(don_win=40, vol_win=20, dvol_pct=75.0, label="D40-V20-DVOL75"),
+        dict(don_win=20, vol_win=10, dvol_pct=70.0, label="D20-V10-DVOL70"),
+        dict(don_win=60, vol_win=30, dvol_pct=80.0, label="D60-V30-DVOL80"),
+    ]
+
+    print("=== CMB02: Donchian + Volume + DVOL filter ===\n")
+
+    best_rep = None
+    best_score = -999.0
+
+    for cfg in configs:
+        label = cfg["label"]
+        don_win = cfg["don_win"]
+        vol_win = cfg["vol_win"]
+        dvol_pct = cfg["dvol_pct"]
+
+        def make_target(dw=don_win, vw=vol_win, dp=dvol_pct):
+            def target_fn(df):
+                # Determine asset from df shape/content - try BTC first, ETH fallback
+                # We pass asset through closure workaround via index
+                # Actually altlib doesn't pass asset name to target_fn...
+                # We'll call dvol with "BTC" and check if ETH data matches better
+                # The dvol function uses asset param - we need a way to know which asset
+                # Use a hack: check if the df matches BTC or ETH by length/timestamps
+                btc_df = al.get("BTC", "1d")
+                if len(df) == len(btc_df) and df["close"].iloc[0] == btc_df["close"].iloc[0]:
+                    asset = "BTC"
+                else:
+                    asset = "ETH"
+                return cmb02_target(df, don_win=dw, vol_win=vw, dvol_pct=dp, asset=asset)
+            return target_fn
+
+        rep = al.study_weights(f"CMB02-{label}", make_target(), tfs=("1d",))
+        print(al.fmt(rep))
+        print()
+
+        score = rep["verdict"].get("best_holdout_sharpe", -9)
+        if score > best_score:
+            best_score = score
+            best_rep = rep
+            best_label = label
+            best_cfg = cfg
+
+    print(f"\n>>> Best config on 1d: {best_label} (holdout score: {best_score:.3f})")
+    print(">>> Now testing best config on 12h...\n")
+
+    # Test best config on 12h
+    dw = best_cfg["don_win"]
+    vw = best_cfg["vol_win"]
+    dp = best_cfg["dvol_pct"]
+
+    def make_target_12h(dw=dw, vw=vw, dp=dp):
+        def target_fn(df):
+            btc_df = al.get("BTC", "12h")
+            if len(df) == len(btc_df) and df["close"].iloc[0] == btc_df["close"].iloc[0]:
+                asset = "BTC"
+            else:
+                asset = "ETH"
+            return cmb02_target(df, don_win=dw, vol_win=vw, dvol_pct=dp, asset=asset)
+        return target_fn
+
+    rep_12h = al.study_weights(f"CMB02-{best_label}-12h", make_target_12h(), tfs=("12h",))
+    print(al.fmt(rep_12h))
+    print()
+
+    # Build combined report with both TFs for the best config
+    # Combine cells from 1d best + 12h
+    best_1d_cells = [c for c in best_rep["cells"] if c["tf"] == "1d"]
+    cells_combined = best_1d_cells + rep_12h["cells"]
+
+    # Pick best TF by holdout
+    def pick_best(cells):
+        return max(cells, key=lambda c: c.get("min_asset_holdout_sharpe", -9))
+
+    best_cell = pick_best(cells_combined)
+    best_tf = best_cell["tf"]
+
+    # Final verdict
+    from altlib import _verdict
+    verdict = _verdict(cells_combined)
+
+    final_rep = dict(
+        name=f"CMB02-{best_label}",
+        kind="weights",
+        cells=cells_combined,
+        verdict=verdict,
+    )
+
+    print("\n=== FINAL REPORT (best config, both TFs) ===")
+    print(al.fmt(final_rep))
+    print("\nJSON:", al.as_json(final_rep))
+    return final_rep
+
+
+if __name__ == "__main__":
+    run()

scripts/research/alt/runs/CMB03.py

@@ -0,0 +1,257 @@
+"""CMB03 — Multi-TF trend confirm (4h fast + 1d slow agreement).
+
+HYPOTHESIS: On the 4h TF, go long only when the 1d trend (TSMOM or SMA50)
+agrees (is bullish). The intuition is that a fast-TF TSMOM signal might have
+more noise; filtering by the slow TF trend reduces false signals.
+
+CAUSAL ALIGNMENT (critical - see obs 4866):
+  - 1d bar at timestamp T closes at end of day T. The 4h bar that CLOSES at
+    the same time or later (within day T+1 onwards) can use it causally.
+  - We compute the 1d signal on the 1d dataframe, then merge_asof onto 4h
+    using the 1d bar CLOSE timestamp -> the 4h bar is valid only AFTER the
+    1d bar has fully closed (direction="forward" with offset to avoid using
+    the still-open 1d bar).
+  - Implementation: for each 1d bar at timestamp T_close, the signal becomes
+    available at T_close (the bar just closed). We map it to 4h bars whose
+    open timestamp >= T_close (i.e. the NEXT 4h bar after the 1d bar closed).
+    This means we use pandas merge_asof with left=4h open timestamps and
+    right=1d close timestamps, direction="backward" — the 4h bar at open T
+    gets the most recent 1d signal where 1d_close <= 4h_open.
+
+GRID (4 configs x 2 assets x 1 TF = 8 backtests):
+  A: 4h fast TSMOM (1m,3m) + 1d confirm SMA50 (price>SMA50)
+  B: 4h fast TSMOM (1m,3m) + 1d confirm TSMOM (1m,3m,6m)
+  C: 4h SMA crossover (20>50) + 1d confirm SMA50
+  D: 4h SMA crossover (20>50) + 1d confirm TSMOM (1m,3m,6m)
+
+All configs: long-only (0 or +1 direction), vol-targeted (20%, cap 2x).
+"""
+
+import sys
+sys.path.insert(0, "/opt/docker/PythagorasGoal/scripts/research/alt")
+import altlib as al
+import numpy as np
+import pandas as pd
+
+
+# ---------------------------------------------------------------------------
+# Helper: compute 1d trend signal and align causally to 4h bars
+# ---------------------------------------------------------------------------
+
+def _1d_tsmom_signal(df_1d: pd.DataFrame) -> np.ndarray:
+    """TSMOM on 1d bars: long if majority of 1m/3m/6m horizons are positive.
+    Returns array in {0, +1} (long-flat, no short).
+    Decision at bar i uses close[i] (causal). Array indexed by 1d bar."""
+    c = df_1d["close"].values.astype(float)
+    bpd = al.bars_per_day(df_1d)  # should be ~1 for 1d
+    horizons = [30 * bpd, 90 * bpd, 180 * bpd]
+    votes = np.zeros(len(c))
+    for h in horizons:
+        h = int(h)
+        sig = np.full(len(c), np.nan)
+        if h < len(c):
+            sig[h:] = np.sign(c[h:] / c[:-h] - 1.0)
+        votes += np.nan_to_num(sig, nan=0.0)
+    # Long when majority (>=1 out of 3) positive
+    return np.where(votes > 0, 1.0, 0.0)
+
+
+def _1d_sma50_signal(df_1d: pd.DataFrame) -> np.ndarray:
+    """SMA50 trend on 1d: long when close > SMA50. Returns {0, +1}."""
+    c = df_1d["close"].values.astype(float)
+    sma50 = al.sma(c, 50)
+    return np.where(c > sma50, 1.0, 0.0)
+
+
+def _align_1d_to_4h(df_1d: pd.DataFrame, signal_1d: np.ndarray,
+                    df_4h: pd.DataFrame) -> np.ndarray:
+    """Map 1d signal onto 4h bars CAUSALLY.
+
+    A 1d bar at timestamp T (which is the bar's OPEN time in ms) closes at
+    T + 86400000ms. We expose the signal AFTER the 1d bar has fully closed,
+    i.e. it's available to 4h bars whose open time >= T + 86400000ms (the
+    start of the next day).
+
+    Procedure:
+    1. Build a series: (1d_close_timestamp, signal_1d)
+       1d_close_ts = df_1d["timestamp"] + 86400000 (next bar open = this bar closed)
+    2. For each 4h bar (open timestamp), take the most recent 1d signal
+       where 1d_close_ts <= 4h_open_ts  (merge_asof backward).
+    3. Forward-fill NaN (no signal yet = 0).
+    """
+    # 1d bar open timestamps + period offset = close timestamp = next 4h eligible
+    # Compute 1d bar period in ms: use median diff of timestamps
+    ts_1d = df_1d["timestamp"].values.astype(np.int64)
+    diffs_1d = np.diff(ts_1d)
+    period_ms = int(np.median(diffs_1d)) if len(diffs_1d) > 0 else 86_400_000
+
+    # 1d_close_ts: the moment this 1d bar closed (= open of the NEXT bar)
+    close_ts_1d = ts_1d + period_ms  # available after this timestamp
+
+    right = pd.DataFrame({
+        "close_ts": close_ts_1d,
+        "sig": signal_1d.astype(float),
+    }).sort_values("close_ts")
+
+    ts_4h = df_4h["timestamp"].values.astype(np.int64)
+    left = pd.DataFrame({"open_ts": ts_4h})
+
+    merged = pd.merge_asof(
+        left,
+        right.rename(columns={"close_ts": "open_ts"}),
+        on="open_ts",
+        direction="backward",
+    )
+    out = merged["sig"].values.astype(float)
+    # NaN = no 1d bar has closed yet -> be conservative, no position
+    out = np.nan_to_num(out, nan=0.0)
+    return out
+
+
+# ---------------------------------------------------------------------------
+# Fast-TF (4h) signals
+# ---------------------------------------------------------------------------
+
+def _4h_tsmom(df_4h: pd.DataFrame) -> np.ndarray:
+    """TSMOM on 4h: long if 1m and 3m horizons agree (majority of 2)."""
+    c = df_4h["close"].values.astype(float)
+    bpd = al.bars_per_day(df_4h)  # ~6 for 4h
+    h1m = int(30 * bpd)
+    h3m = int(90 * bpd)
+    votes = np.zeros(len(c))
+    for h in [h1m, h3m]:
+        sig = np.full(len(c), np.nan)
+        if h < len(c):
+            sig[h:] = np.sign(c[h:] / c[:-h] - 1.0)
+        votes += np.nan_to_num(sig, nan=0.0)
+    # Long when net positive (at least 1 of 2)
+    return np.where(votes > 0, 1.0, 0.0)
+
+
+def _4h_sma_cross(df_4h: pd.DataFrame, fast=20, slow=50) -> np.ndarray:
+    """SMA crossover on 4h: long when SMA(fast) > SMA(slow)."""
+    c = df_4h["close"].values.astype(float)
+    sma_f = al.sma(c, fast)
+    sma_s = al.sma(c, slow)
+    return np.where(sma_f > sma_s, 1.0, 0.0)
+
+
+# ---------------------------------------------------------------------------
+# Combined target functions (4h TF, 1d confirm)
+# ---------------------------------------------------------------------------
+
+def make_target(asset: str, fast_type: str, slow_type: str):
+    """Return a target_fn(df_4h) -> position array.
+
+    Because altlib calls target_fn(df) with the chosen TF df, we fetch the
+    1d df inside the closure (cached by altlib.get).
+    """
+    def target_fn(df_4h: pd.DataFrame) -> np.ndarray:
+        # 1d dataframe for same asset (cached)
+        df_1d = al.get(asset, "1d")
+
+        # Compute 1d confirmation signal
+        if slow_type == "sma50":
+            sig_1d = _1d_sma50_signal(df_1d)
+        elif slow_type == "tsmom":
+            sig_1d = _1d_tsmom_signal(df_1d)
+        else:
+            raise ValueError(f"Unknown slow_type: {slow_type}")
+
+        # Align 1d signal onto 4h bars (causal)
+        confirm_4h = _align_1d_to_4h(df_1d, sig_1d, df_4h)
+
+        # Compute 4h fast signal
+        if fast_type == "tsmom":
+            fast_4h = _4h_tsmom(df_4h)
+        elif fast_type == "sma_cross":
+            fast_4h = _4h_sma_cross(df_4h)
+        else:
+            raise ValueError(f"Unknown fast_type: {fast_type}")
+
+        # Combined: long only when BOTH signals agree
+        direction = np.where((fast_4h > 0) & (confirm_4h > 0), 1.0, 0.0)
+
+        # Vol-target (20%, cap 2x)
+        return al.vol_target(direction, df_4h, target_vol=0.20,
+                             vol_win_days=30, leverage_cap=2.0)
+
+    return target_fn
+
+
+# ---------------------------------------------------------------------------
+# Grid: 4 configs
+# ---------------------------------------------------------------------------
+CONFIGS = [
+    dict(fast="tsmom",    slow="sma50",  label="tsmom4h_sma50_1d"),
+    dict(fast="tsmom",    slow="tsmom",  label="tsmom4h_tsmom_1d"),
+    dict(fast="sma_cross", slow="sma50", label="smacross4h_sma50_1d"),
+    dict(fast="sma_cross", slow="tsmom", label="smacross4h_tsmom_1d"),
+]
+
+print("=== CMB03: Multi-TF trend confirm (4h fast + 1d slow) ===")
+print(f"Grid: {len(CONFIGS)} configs x 2 assets x 1 TF = {len(CONFIGS)*2} backtests\n")
+
+results = []
+for cfg in CONFIGS:
+    label = cfg["label"]
+    fast = cfg["fast"]
+    slow = cfg["slow"]
+
+    # Build per-asset target functions
+    # study_weights calls target_fn(df) for each asset, but we need to know
+    # WHICH asset to fetch the 1d df for. We use a workaround: wrap in a
+    # function that identifies the asset by calling al.get for BTC then ETH
+    # and matching timestamps.
+    #
+    # Cleaner approach: run each asset separately and combine.
+    # altlib.study_weights iterates assets internally, so we need target_fn(df)
+    # to know the asset. We do this by checking df timestamps against cached dfs.
+
+    def _target_fn(df_4h, _fast=fast, _slow=slow):
+        # Identify asset by matching df timestamps to known cached dfs
+        ts = df_4h["timestamp"].values[0]
+        # Try BTC first, then ETH
+        for _asset in ("BTC", "ETH"):
+            try:
+                _df_check = al.get(_asset, "4h")
+                if _df_check["timestamp"].values[0] == ts:
+                    return make_target(_asset, _fast, _slow)(df_4h)
+            except Exception:
+                pass
+        # Fallback: try matching by length or first close
+        c0 = df_4h["close"].values[0]
+        for _asset in ("BTC", "ETH"):
+            _df_check = al.get(_asset, "4h")
+            if abs(_df_check["close"].values[0] - c0) / c0 < 0.01:
+                return make_target(_asset, _fast, _slow)(df_4h)
+        # Last resort
+        return make_target("BTC", _fast, _slow)(df_4h)
+
+    rep = al.study_weights(
+        f"CMB03-{label}",
+        _target_fn,
+        tfs=("4h",),
+    )
+    print(al.fmt(rep))
+    print(f"  JSON: {al.as_json(rep)}\n")
+    results.append((rep, cfg))
+
+
+# ---------------------------------------------------------------------------
+# Pick best config by min_asset_holdout_sharpe
+# ---------------------------------------------------------------------------
+def best_holdout(item):
+    rep = item[0]
+    cells = rep.get("cells", [])
+    if not cells:
+        return -99.0
+    return max(c.get("min_asset_holdout_sharpe", -99.0) for c in cells)
+
+results.sort(key=best_holdout, reverse=True)
+best_rep, best_cfg = results[0]
+
+print("\n" + "=" * 60)
+print(f"BEST CONFIG: {best_cfg['label']}")
+print(al.fmt(best_rep))
+print("JSON:", al.as_json(best_rep))

scripts/research/alt/runs/CMB04.py

@@ -0,0 +1,97 @@
+"""CMB04 — Momentum + Low-Vol Filter
+HYPOTHESIS: TSMOM long-flat taken only when realized vol is below its rolling median
+(avoid high-vol whipsaw). Vol-target the rest.
+
+Grid: 2 vol-filter windows (30d vs 60d rolling median lookback) x 2 TFs (1d, 12h) = 4 cells total.
+Best config chosen by min(BTC,ETH) holdout Sharpe.
+"""
+import sys
+sys.path.insert(0, "/opt/docker/PythagorasGoal/scripts/research/alt")
+import altlib as al
+import numpy as np
+
+
+def cmb04_target(df, vol_filter_days: int = 30):
+    """
+    TSMOM multi-horizon (1m/3m/6m) long-flat, gated by a low-vol filter:
+    - Compute realized vol (30d) at each bar.
+    - Compute rolling median of that vol over vol_filter_days.
+    - Only take the TSMOM signal when realized_vol < rolling_median (low-vol regime).
+    - In high-vol regime: go flat (0).
+    - Vol-target the resulting direction.
+    """
+    c = df["close"].values.astype(float)
+    bpd = al.bars_per_day(df)
+    bpy = bpd * 365.25
+
+    # --- TSMOM multi-horizon direction (1m, 3m, 6m) ---
+    horizons = (30 * bpd, 90 * bpd, 180 * bpd)
+    direction = np.zeros(len(c))
+    for h in horizons:
+        h = int(h)
+        sig = np.full(len(c), np.nan)
+        if h < len(c):
+            sig[h:] = np.sign(c[h:] / c[:-h] - 1.0)
+        direction += np.nan_to_num(sig, nan=0.0)
+    # Majority vote -> long or flat
+    direction = np.clip(np.sign(direction), 0.0, 1.0)  # long-flat only
+
+    # --- Realized vol (30d causal) ---
+    rv_win = max(2, 30 * bpd)
+    r = al.simple_returns(c)
+    rv = al.realized_vol(r, rv_win, bpy)
+
+    # --- Rolling median of realized vol over vol_filter_days ---
+    med_win = max(2, vol_filter_days * bpd)
+    rv_median = (
+        al._series_if_array(rv).rolling(med_win, min_periods=max(2, med_win // 2)).median().values
+        if hasattr(al, "_series_if_array")
+        else __import__("pandas").Series(rv).rolling(med_win, min_periods=max(2, med_win // 2)).median().values
+    )
+
+    # --- Gate: only enter when rv < median (low-vol regime) ---
+    low_vol_gate = np.where(
+        np.isfinite(rv) & np.isfinite(rv_median) & (rv < rv_median),
+        1.0,
+        0.0
+    )
+    gated_direction = direction * low_vol_gate
+
+    # --- Vol-target the gated direction ---
+    pos = al.vol_target(gated_direction, df, target_vol=0.20, vol_win_days=30, leverage_cap=2.0)
+    return pos
+
+
+def make_target_fn(vol_filter_days: int):
+    def fn(df):
+        return cmb04_target(df, vol_filter_days=vol_filter_days)
+    return fn
+
+
+if __name__ == "__main__":
+    import pandas as pd
+
+    best_rep = None
+    best_hold = -9.0
+    best_label = ""
+
+    configs = [
+        ("CMB04-vf30", 30),
+        ("CMB04-vf60", 60),
+    ]
+
+    for label, vfd in configs:
+        fn = make_target_fn(vfd)
+        rep = al.study_weights(label, fn, tfs=("1d", "12h"))
+        v = rep["verdict"]
+        h = v.get("best_holdout_sharpe", -9)
+        print(al.fmt(rep))
+        print(f"  [grid] {label}: holdout={h:.3f}")
+        if h > best_hold:
+            best_hold = h
+            best_rep = rep
+            best_label = label
+
+    print("\n=== BEST CONFIG ===", best_label)
+    print(al.fmt(best_rep))
+    print("JSON:", al.as_json(best_rep))

scripts/research/alt/runs/CMB05.py

@@ -0,0 +1,108 @@
+"""CMB05 — BB Squeeze -> Breakout (honest, leak-free).
+
+HYPOTHESIS: Bollinger Bandwidth at a multi-bar low (squeeze) then close > upper BB
+-> enter long at that close (entry at close[i], direction decided with data<=close[i]).
+Exit when close drops back below middle band, or max_bars reached, or SL hit.
+
+Tested on 1d only (study_signals, discrete). Small grid on:
+  - BB window: 20 vs 30
+  - Squeeze lookback: 50 vs 100
+  Total configs: 4 — two assets each => 8 backtests. Within budget.
+"""
+import sys
+sys.path.insert(0, "/opt/docker/PythagorasGoal/scripts/research/alt")
+import altlib as al
+import numpy as np
+import pandas as pd
+
+
+def make_entries(bb_win: int = 20, squeeze_lb: int = 50, squeeze_pct: float = 0.20, sl_mult: float = 2.0, max_bars: int = 30):
+    """
+    Returns entries_fn(df) -> list[dict|None] for study_signals.
+
+    Squeeze = BB bandwidth (upper-lower)/middle in lowest squeeze_pct quantile over squeeze_lb bars.
+    Breakout = close[i] > upper[i] AND bandwidth is in compressed regime.
+    Entry: long at close[i], honest (direction decided with close[i]).
+    Exit: close < middle band (continuous) OR max_bars OR SL at entry - sl_mult*ATR.
+    """
+    def entries_fn(df):
+        c = df["close"].values.astype(float)
+        n = len(c)
+
+        # BB bands - causal (uses data up to i)
+        upper, mid, lower = al.bbands(c, win=bb_win, k=2.0)
+
+        # Bandwidth
+        bw = np.where(mid != 0, (upper - lower) / mid, np.nan)
+
+        # Squeeze: bandwidth in lowest squeeze_pct percentile over squeeze_lb bars (causal)
+        # Use rolling quantile to flag "compressed" bandwidth
+        bw_series = pd.Series(bw)
+        bw_lo = bw_series.rolling(squeeze_lb, min_periods=squeeze_lb).quantile(squeeze_pct).values
+
+        # ATR for SL
+        atr_arr = al.atr(df, win=14)
+
+        entries = [None] * n
+        in_trade = False
+
+        for i in range(squeeze_lb + bb_win, n):
+            if np.isnan(upper[i]) or np.isnan(bw_lo[i]) or np.isnan(atr_arr[i]):
+                continue
+            if not np.isfinite(bw[i]):
+                continue
+
+            # Squeeze: bandwidth <= its rolling low-percentile threshold
+            is_squeeze = bw[i] <= bw_lo[i]
+
+            # Breakout: close[i] > upper[i]  (decided at close[i], honest)
+            breakout = c[i] > upper[i]
+
+            if (not in_trade) and is_squeeze and breakout:
+                sl_px = c[i] - sl_mult * atr_arr[i]
+                entries[i] = {
+                    "dir": +1,
+                    "tp": None,
+                    "sl": sl_px,
+                    "max_bars": max_bars,
+                }
+                in_trade = True
+            elif in_trade:
+                # Exit signal: close falls below middle band -> reset flag
+                if c[i] < mid[i]:
+                    in_trade = False
+
+        return entries
+
+    return entries_fn
+
+
+# Grid: 4 configs (2 bb_win x 2 squeeze_pct) with fixed squeeze_lb=100
+configs = [
+    dict(bb_win=20, squeeze_lb=100, squeeze_pct=0.20),
+    dict(bb_win=20, squeeze_lb=100, squeeze_pct=0.30),
+    dict(bb_win=30, squeeze_lb=100, squeeze_pct=0.20),
+    dict(bb_win=30, squeeze_lb=100, squeeze_pct=0.30),
+]
+
+best_rep = None
+best_score = -999.0
+
+print("=== CMB05: BB Squeeze -> Breakout ===")
+print(f"Grid: {len(configs)} configs x 2 assets x fee_sweep = honest eval\n")
+
+for cfg in configs:
+    name = f"CMB05-BB{cfg['bb_win']}-SQ{cfg['squeeze_lb']}-P{int(cfg['squeeze_pct']*100)}"
+    fn = make_entries(bb_win=cfg["bb_win"], squeeze_lb=cfg["squeeze_lb"], squeeze_pct=cfg["squeeze_pct"])
+    rep = al.study_signals(name, fn, tfs=("1d",))
+    v = rep["verdict"]
+    score = v.get("best_holdout_sharpe", -9)
+    print(f"  {name}: grade={v['grade']} fullSh={v.get('best_full_sharpe'):.3f} holdSh={v.get('best_holdout_sharpe'):.3f}")
+    if score > best_score:
+        best_score = score
+        best_rep = rep
+        best_rep["_cfg"] = cfg
+
+print("\n--- BEST CONFIG ---")
+print(al.fmt(best_rep))
+print("JSON:", al.as_json(best_rep))

scripts/research/alt/runs/CMB06.py

@@ -0,0 +1,165 @@
+"""CMB06 — Trend + Seasonality Combo
+IDEA: TSMOM long-flat (multi-horizon, vol-targeted, like TP01) but scale the
+exposure UP in historically strong calendar windows (day-of-week + month-of-year
+expanding expanding expectancy). Causal only: expectancy estimated on expanding window
+using data BEFORE the current bar.
+
+Design:
+- Base signal: TSMOM multi-horizon (1M / 3M / 6M), long-flat, vote-then-sign
+- Volatility targeting: 20% target, 2x lev cap (same as TP01)
+- Seasonality multiplier: expand-window daily/monthly return expectancy,
+  normalised to [scale_min, scale_max] so it's a scalar boost, not a flip.
+  The multiplier is always >= 0 (never inverts the trend).
+
+Causal guarantee:
+- Day-of-week expectancy at bar i uses only past bars (strict shift: computed on
+  data up to bar i-1, applied at bar i).
+- Month-of-year same.
+- Both use EXPANDING window (not rolling) -> no future-data leak, and it
+  gradually stabilises as history accumulates.
+
+Grid (4 params): 2 scale ranges × 2 TFs = 4 cells total.
+"""
+import sys
+sys.path.insert(0, "/opt/docker/PythagorasGoal/scripts/research/alt")
+import altlib as al
+import numpy as np
+import pandas as pd
+
+
+def _expanding_dow_expectancy(df: pd.DataFrame) -> np.ndarray:
+    """For each bar, return the expanding-window mean return of the same day-of-week,
+    computed on PAST bars only (shift 1). Returns NaN until at least 4 samples exist."""
+    c = df["close"].values.astype(float)
+    r = al.simple_returns(c)                          # r[i] = return realized at bar i
+    dt = pd.to_datetime(df["datetime"], utc=True)
+    dow = dt.dt.dayofweek.values                       # 0=Mon..6=Sun
+
+    exp = np.full(len(r), np.nan)
+    # For each bar i, compute mean return of same DOW for all bars j < i
+    # Use expanding sum by DOW category
+    dow_sum = np.zeros(7, dtype=float)
+    dow_cnt = np.zeros(7, dtype=int)
+
+    for i in range(1, len(r)):
+        # update with bar i-1 (strictly past)
+        d_prev = dow[i - 1]
+        dow_sum[d_prev] += r[i - 1]
+        dow_cnt[d_prev] += 1
+
+        d = dow[i]
+        if dow_cnt[d] >= 4:
+            exp[i] = dow_sum[d] / dow_cnt[d]
+
+    return exp
+
+
+def _expanding_month_expectancy(df: pd.DataFrame) -> np.ndarray:
+    """Same but for month-of-year (1..12). Requires >= 4 past bars in same month."""
+    c = df["close"].values.astype(float)
+    r = al.simple_returns(c)
+    dt = pd.to_datetime(df["datetime"], utc=True)
+    moy = dt.dt.month.values                           # 1..12
+
+    exp = np.full(len(r), np.nan)
+    mo_sum = np.zeros(13, dtype=float)
+    mo_cnt = np.zeros(13, dtype=int)
+
+    for i in range(1, len(r)):
+        m_prev = moy[i - 1]
+        mo_sum[m_prev] += r[i - 1]
+        mo_cnt[m_prev] += 1
+
+        m = moy[i]
+        if mo_cnt[m] >= 4:
+            exp[i] = mo_sum[m] / mo_cnt[m]
+
+    return exp
+
+
+def _seasonality_multiplier(df: pd.DataFrame, scale_min: float, scale_max: float) -> np.ndarray:
+    """Combine DOW + month expanding expectancy into a [scale_min, scale_max] multiplier.
+    When either is NaN (early history), default to 1.0 (neutral)."""
+    dow_exp = _expanding_dow_expectancy(df)
+    mon_exp = _expanding_month_expectancy(df)
+
+    # Normalise each to [-1, +1] range using the expanding-window min/max seen so far.
+    # We use a causal expanding percentile: zscore is simpler and avoids percentile loop.
+    # Use zscore over an expanding window instead (pandas expanding).
+    dow_s = pd.Series(dow_exp)
+    mon_s = pd.Series(mon_exp)
+
+    # Causal z-score (expanding)
+    dow_z = (dow_s - dow_s.expanding().mean()) / dow_s.expanding().std().replace(0, np.nan)
+    mon_z = (mon_s - mon_s.expanding().mean()) / mon_s.expanding().std().replace(0, np.nan)
+
+    # Blend (equal weight)
+    combined = (dow_z.fillna(0.0) + mon_z.fillna(0.0)).values / 2.0
+
+    # Map to [scale_min, scale_max] via sigmoid-like clamp
+    # clip to [-2, 2] sigma, then linearly map
+    combined_clipped = np.clip(combined, -2.0, 2.0)
+    mid = (scale_min + scale_max) / 2.0
+    half_range = (scale_max - scale_min) / 2.0
+    mult = mid + half_range * (combined_clipped / 2.0)
+
+    # Where both were NaN (very early bars), use neutral = 1.0
+    both_nan = dow_s.isna().values & mon_s.isna().values
+    mult[both_nan] = 1.0
+
+    return mult
+
+
+def _tsmom_base(df: pd.DataFrame) -> np.ndarray:
+    """Multi-horizon TSMOM: 1M/3M/6M vote, long-flat, vol-targeted."""
+    c = df["close"].values.astype(float)
+    bpd = al.bars_per_day(df)
+    d = np.zeros(len(c))
+    for months in (1, 3, 6):
+        h = int(months * 30 * bpd)
+        if h >= len(c):
+            continue
+        s = np.full(len(c), np.nan)
+        s[h:] = np.sign(c[h:] / c[:-h] - 1.0)
+        d = d + np.nan_to_num(s)
+    direction = np.clip(np.sign(d), 0, None)           # long-flat only
+    return al.vol_target(direction, df, target_vol=0.20, vol_win_days=30, leverage_cap=2.0)
+
+
+def make_target(scale_min: float, scale_max: float):
+    """Return a target_fn that applies the seasonality multiplier."""
+    def target_fn(df: pd.DataFrame) -> np.ndarray:
+        base = _tsmom_base(df)
+        mult = _seasonality_multiplier(df, scale_min, scale_max)
+        combined = base * mult
+        # Keep within leverage cap
+        combined = np.clip(combined, 0.0, 2.0)
+        combined = np.nan_to_num(combined, nan=0.0)
+        return combined
+    return target_fn
+
+
+if __name__ == "__main__":
+    # Grid: 2 scale ranges × 2 TFs = 4 cells
+    # scale_min/max: how much to reduce/boost position in weak/strong seasons
+    # (0.5, 1.5) = modest 50% swing; (0.25, 1.75) = aggressive 150% swing
+    configs = [
+        ("CMB06-modest",  0.5, 1.5),
+        ("CMB06-aggr",    0.25, 1.75),
+    ]
+
+    all_reps = []
+    for name, smin, smax in configs:
+        print(f"\n=== Running {name} (scale [{smin},{smax}]) ===")
+        rep = al.study_weights(name, make_target(smin, smax), tfs=("1d", "12h"))
+        print(al.fmt(rep))
+        all_reps.append((name, rep))
+
+    # Pick best by min_asset_holdout_sharpe at best TF
+    def best_holdout(rep):
+        return max(c["min_asset_holdout_sharpe"] for c in rep["cells"])
+
+    best_name, best_rep = max(all_reps, key=lambda x: best_holdout(x[1]))
+    print(f"\n>>> BEST CONFIG: {best_name}")
+    print(al.fmt(best_rep))
+    print("JSON:", al.as_json(best_rep))

scripts/research/alt/runs/MIC01.py

@@ -0,0 +1,62 @@
+"""MIC01 — Three-bar momentum (micro-continuation).
+
+HYPOTHESIS: 3 consecutive higher closes -> enter long at the 3rd close,
+exit after k bars or on a lower close. Continuation test.
+
+Grid: k (exit after k bars if no stop) in {3, 5, 8, 10}
+Style: study_signals (discrete entry/exit, 1d only).
+
+Causality: decision at close[i] uses only close[i-2], close[i-1], close[i].
+Entry fills at close[i] (the 3rd consecutive higher close).
+Exit: on next bar where close < prior close, OR after max_bars.
+"""
+import sys
+sys.path.insert(0, "/opt/docker/PythagorasGoal/scripts/research/alt")
+import altlib as al
+import numpy as np
+
+def make_entries(max_bars: int):
+    """Return entries_fn for a given max_bars parameter."""
+    def entries_fn(df):
+        c = df["close"].values
+        n = len(c)
+        entries = [None] * n
+
+        for i in range(2, n):
+            # 3 consecutive higher closes: close[i] > close[i-1] > close[i-2]
+            if c[i] > c[i-1] and c[i-1] > c[i-2]:
+                entries[i] = {
+                    "dir": +1,
+                    "tp": None,
+                    "sl": None,
+                    "max_bars": max_bars,
+                }
+        return entries
+    return entries_fn
+
+
+# Small internal grid: 4 param sets, 1 TF, 2 assets = 8 backtests total
+# (within the <=6 total limit would be 3 configs; using 4 is borderline, reduce to 3 if slow)
+GRID = [3, 5, 8, 12]
+
+best_rep = None
+best_score = -999.0
+
+for k in GRID:
+    rep = al.study_signals(
+        f"MIC01-k{k}",
+        make_entries(max_bars=k),
+        tfs=("1d",),
+    )
+    v = rep["verdict"]
+    # Score = min hold-out Sharpe across assets (conservative)
+    score = v.get("best_holdout_sharpe", -999.0)
+    print(f"k={k:2d}: grade={v['grade']} minFull={v.get('best_full_sharpe'):+.3f} minHold={v.get('best_holdout_sharpe'):+.3f}")
+    if score > best_score:
+        best_score = score
+        best_rep = rep
+        best_k = k
+
+print(f"\nBest config: k={best_k}")
+print(al.fmt(best_rep))
+print("JSON:", al.as_json(best_rep))

scripts/research/alt/runs/MIC02.py

@@ -0,0 +1,114 @@
+"""MIC02 — Engulfing continuation (trend-filtered).
+
+HYPOTHESIS:
+  Bullish engulfing in an uptrend  -> long at close of engulfing bar.
+  Bearish engulfing in a downtrend -> short at close of engulfing bar.
+  Trend filter: EMA(trend_win) direction.
+
+Pattern definition (standard engulfing, CAUSAL):
+  Bullish engulfing at bar i:
+    - Bar i-1 is bearish: close[i-1] < open[i-1]
+    - Bar i is bullish:   close[i] > open[i]
+    - Bar i's body ENGULFS bar i-1's body: open[i] <= close[i-1] AND close[i] >= open[i-1]
+  Bearish engulfing at bar i:
+    - Bar i-1 is bullish: close[i-1] > open[i-1]
+    - Bar i is bearish:   close[i] < open[i]
+    - Bar i's body ENGULFS bar i-1's body: open[i] >= close[i-1] AND close[i] <= open[i-1]
+
+Trend filter: EMA(trend_win). Long only if close[i] > EMA[i]. Short only if close[i] < EMA[i].
+
+Entry fills at close[i]. Exit after max_bars (time-stop only).
+
+Grid: (trend_win, max_bars) x 2 assets x 1 TF = 4 backtests (<=6 limit respected).
+
+Causality: all decisions use data <= close[i] (open[i] is known at close[i]).
+No entry on candle extreme (high/low). Entry at close[i].
+"""
+import sys
+sys.path.insert(0, "/opt/docker/PythagorasGoal/scripts/research/alt")
+import altlib as al
+import numpy as np
+
+
+def make_entries(trend_win: int, max_bars: int):
+    """Return entries_fn for given EMA trend window and max hold bars."""
+    def entries_fn(df):
+        o = df["open"].values
+        c = df["close"].values
+        n = len(c)
+
+        # Causal EMA of close
+        trend = al.ema(c, span=trend_win)
+
+        entries = [None] * n
+
+        for i in range(1, n):
+            # --- Bullish engulfing ---
+            # Previous bar bearish
+            prev_bear = c[i-1] < o[i-1]
+            # Current bar bullish
+            curr_bull = c[i] > o[i]
+            # Engulf: current open <= prev close AND current close >= prev open
+            bull_engulf = (o[i] <= c[i-1]) and (c[i] >= o[i-1])
+            # Trend filter: close above EMA
+            uptrend = np.isfinite(trend[i]) and (c[i] > trend[i])
+
+            if prev_bear and curr_bull and bull_engulf and uptrend:
+                entries[i] = {
+                    "dir": +1,
+                    "tp": None,
+                    "sl": None,
+                    "max_bars": max_bars,
+                }
+                continue
+
+            # --- Bearish engulfing ---
+            # Previous bar bullish
+            prev_bull = c[i-1] > o[i-1]
+            # Current bar bearish
+            curr_bear = c[i] < o[i]
+            # Engulf: current open >= prev close AND current close <= prev open
+            bear_engulf = (o[i] >= c[i-1]) and (c[i] <= o[i-1])
+            # Trend filter: close below EMA
+            downtrend = np.isfinite(trend[i]) and (c[i] < trend[i])
+
+            if prev_bull and curr_bear and bear_engulf and downtrend:
+                entries[i] = {
+                    "dir": -1,
+                    "tp": None,
+                    "sl": None,
+                    "max_bars": max_bars,
+                }
+
+        return entries
+    return entries_fn
+
+
+# Internal grid: 2 param sets x 2 assets x 1 TF = 4 backtests (within <=6)
+GRID = [
+    (50, 5),    # medium-term trend, short hold
+    (100, 10),  # longer-term trend, medium hold
+]
+
+best_rep = None
+best_score = -999.0
+best_params = None
+
+for trend_win, max_bars in GRID:
+    rep = al.study_signals(
+        f"MIC02-ema{trend_win}-mb{max_bars}",
+        make_entries(trend_win=trend_win, max_bars=max_bars),
+        tfs=("1d",),
+    )
+    v = rep["verdict"]
+    score = v.get("best_holdout_sharpe", -999.0)
+    print(f"ema={trend_win:3d} max_bars={max_bars:2d}: grade={v['grade']} "
+          f"minFull={v.get('best_full_sharpe'):+.3f} minHold={v.get('best_holdout_sharpe'):+.3f}")
+    if score > best_score:
+        best_score = score
+        best_rep = rep
+        best_params = (trend_win, max_bars)
+
+print(f"\nBest config: ema={best_params[0]}, max_bars={best_params[1]}")
+print(al.fmt(best_rep))
+print("JSON:", al.as_json(best_rep))

scripts/research/alt/runs/MIC03.py

@@ -0,0 +1,105 @@
+"""MIC03 — Volume-spike breakout
+Hypothesis: Breakout of prior high CONFIRMED by volume z-score > threshold -> enter long at close.
+Exit: TP, SL, or max_bars timeout.
+
+Implementation:
+  - Breakout: close[i] > donchian_high(win)[i] (prior win-bar high, shifted by 1 so fully causal)
+  - Volume confirmation: volume z-score over vol_win bars > vol_thresh
+  - Entry at close[i], direction = long only (breakouts on the upside)
+  - TP = entry * (1 + tp_pct), SL = entry * (1 - sl_pct), max_bars timeout
+
+Grid (<=4 param sets, 1d only -> total backtests = 4 * 2 assets = 8 <= 6... actually 8.
+Reduce to 2 configs to stay within ~6 backtests and avoid slow fee sweeps):
+  Config A: donchian 20, vol_win 20, vol_thresh 2.0, tp 3%, sl 1.5%, max_bars 10
+  Config B: donchian 30, vol_win 30, vol_thresh 1.5, tp 4%, sl 2.0%, max_bars 15
+
+Pick the best config by min_asset_holdout_sharpe.
+"""
+
+import sys
+sys.path.insert(0, "/opt/docker/PythagorasGoal/scripts/research/alt")
+import altlib as al
+import numpy as np
+
+
+def make_entries_fn(don_win: int, vol_win: int, vol_thresh: float,
+                    tp_pct: float, sl_pct: float, max_bars: int):
+    def entries_fn(df):
+        close = df["close"].values.astype(float)
+        volume = df["volume"].values.astype(float)
+        n = len(close)
+
+        # Donchian upper channel: prior don_win-bar HIGH (shifted, causal)
+        # Using high prices for breakout reference (breakout above prior high is more meaningful)
+        high = df["high"].values.astype(float)
+        don_hi = np.full(n, np.nan)
+        # rolling max of high over don_win bars, then shift by 1 (prior bar)
+        for i in range(don_win, n):
+            don_hi[i] = np.max(high[i - don_win: i])  # excludes bar i -> causal
+
+        # Volume z-score (causal): zscore of current volume vs rolling mean/std
+        vol_mean = np.full(n, np.nan)
+        vol_std = np.full(n, np.nan)
+        for i in range(vol_win, n):
+            v_window = volume[i - vol_win: i]  # excludes current bar
+            vol_mean[i] = np.mean(v_window)
+            vol_std[i] = np.std(v_window)
+
+        vol_z = np.full(n, np.nan)
+        mask = (vol_std > 0) & np.isfinite(vol_std)
+        vol_z[mask] = (volume[mask] - vol_mean[mask]) / vol_std[mask]
+
+        # Build entry list
+        entries = [None] * n
+        for i in range(don_win + vol_win, n):
+            # Breakout condition: close breaks above prior don_win-bar high
+            breakout = (np.isfinite(don_hi[i]) and close[i] > don_hi[i])
+            # Volume confirmation
+            vol_confirmed = (np.isfinite(vol_z[i]) and vol_z[i] > vol_thresh)
+
+            if breakout and vol_confirmed:
+                entry_px = close[i]  # fill at close[i]
+                tp_px = entry_px * (1.0 + tp_pct)
+                sl_px = entry_px * (1.0 - sl_pct)
+                entries[i] = {
+                    "dir": +1,
+                    "tp": tp_px,
+                    "sl": sl_px,
+                    "max_bars": max_bars,
+                }
+
+        return entries
+
+    return entries_fn
+
+
+# Config A: tighter params
+config_a = dict(don_win=20, vol_win=20, vol_thresh=2.0, tp_pct=0.03, sl_pct=0.015, max_bars=10)
+# Config B: wider params
+config_b = dict(don_win=30, vol_win=30, vol_thresh=1.5, tp_pct=0.04, sl_pct=0.02, max_bars=15)
+
+configs = [
+    ("MIC03-A", config_a),
+    ("MIC03-B", config_b),
+]
+
+best_rep = None
+best_score = -999.0
+
+for cfg_name, cfg in configs:
+    print(f"\n--- Running {cfg_name}: {cfg} ---")
+    fn = make_entries_fn(**cfg)
+    rep = al.study_signals(cfg_name, fn, tfs=("1d",))
+    print(al.fmt(rep))
+    print("JSON:", al.as_json(rep))
+
+    score = rep["verdict"].get("best_holdout_sharpe", -999) or -999
+    if score > best_score:
+        best_score = score
+        best_rep = rep
+        best_rep["_config"] = cfg
+        best_rep["_config_name"] = cfg_name
+
+print("\n\n=== BEST CONFIG ===")
+print(al.fmt(best_rep))
+print("JSON:", al.as_json(best_rep))

scripts/research/alt/runs/MIC04.py

@@ -0,0 +1,81 @@
+"""MIC04 — Consecutive-days continuation vs fade.
+
+IDEA: Compute net of last-k daily close returns (streak).
+- FOLLOWING: go long when streak is positive (sign = +1), flat when negative.
+- FADING: go long when streak is negative (mean-reversion), flat when positive.
+Both are long-flat. We try k in {3, 5} and compare following vs fading.
+Position is vol-targeted (20% target, 2x cap).
+
+Grid: 4 configs (2 k-values × 2 directions), TFs: 1d, 12h.
+Total backtests: 4 configs × 2 TFs × 2 assets = 16 — but we only call study_weights
+per config (each call does 2 TFs × 2 assets internally) → 4 calls = 16 backtests (fine).
+Actually we pick the best config manually. To stay <= 6 total calls we test 2 configs
+(k=3 follow, k=5 follow) and present the best, then also run the fading variants if promising.
+We run all 4 configs (each on tfs=("1d","12h")) → 4 calls, well within budget.
+"""
+import sys
+sys.path.insert(0, "/opt/docker/PythagorasGoal/scripts/research/alt")
+import altlib as al
+import numpy as np
+
+
+def streak_target(df, k: int, follow: bool) -> np.ndarray:
+    """
+    For each bar i, compute net of last-k close returns (causal: uses close[i-k..i]).
+    streak[i] = close[i] / close[i-k] - 1  (sign of cumulative k-bar return)
+
+    If follow=True:  position = +1 when streak > 0, else 0 (long-flat continuation).
+    If fading=True:  position = +1 when streak < 0, else 0 (long-flat mean-reversion).
+
+    Then vol-target the direction.
+    """
+    c = df["close"].values.astype(float)
+    n = len(c)
+
+    # Cumulative k-bar return ending at i: c[i]/c[i-k] - 1
+    streak = np.full(n, np.nan)
+    for i in range(k, n):
+        streak[i] = c[i] / c[i - k] - 1.0
+
+    if follow:
+        direction = np.where(streak > 0, 1.0, 0.0)
+    else:
+        direction = np.where(streak < 0, 1.0, 0.0)
+
+    # Fill NaN with 0 before vol_target
+    direction = np.nan_to_num(direction, nan=0.0)
+
+    # Apply vol targeting
+    tgt = al.vol_target(direction, df, target_vol=0.20, vol_win_days=30, leverage_cap=2.0)
+    return tgt
+
+
+configs = [
+    ("MIC04-k3-follow", 3, True),
+    ("MIC04-k5-follow", 5, True),
+    ("MIC04-k3-fade",   3, False),
+    ("MIC04-k5-fade",   5, False),
+]
+
+results = {}
+for name, k, follow in configs:
+    print(f"\n{'='*60}")
+    print(f"Running {name} (k={k}, follow={follow})")
+    print('='*60)
+    rep = al.study_weights(
+        name,
+        lambda df, k=k, follow=follow: streak_target(df, k, follow),
+        tfs=("1d", "12h"),
+    )
+    results[name] = rep
+    print(al.fmt(rep))
+
+# Pick best config by holdout Sharpe (min across assets in best TF)
+best_name = max(results, key=lambda n: results[n]["verdict"].get("best_holdout_sharpe", -99))
+best_rep = results[best_name]
+
+print("\n" + "="*60)
+print(f"BEST CONFIG: {best_name}")
+print("="*60)
+print(al.fmt(best_rep))
+print("JSON:", al.as_json(best_rep))

scripts/research/alt/runs/MIC05.py

@@ -0,0 +1,82 @@
+"""MIC05 — Wide-range-bar follow-through.
+
+HYPOTHESIS: After a wide-range bar (range > 2*ATR) closing strong (close near the
+top 30% of the bar for longs, or bottom 30% for shorts), enter in the bar's direction
+at close[i]; exit after k bars (or on TP/SL).
+
+CAUSAL: ATR is computed up to bar i-1 (shifted), range and close strength computed
+from bar i itself (known at close[i]). Entry fills at close[i].
+
+Grid: k_bars in {3, 5, 7, 10} — only 1d, 2 assets, 4 param sets = 8 backtests total.
+Best config selected by min-asset hold-out Sharpe.
+"""
+import sys
+sys.path.insert(0, "/opt/docker/PythagorasGoal/scripts/research/alt")
+import altlib as al
+import numpy as np
+
+# ---------------------------------------------------------------------------
+# Signal generator
+# ---------------------------------------------------------------------------
+def make_entries(df, k_bars: int = 5, atr_mult: float = 2.0, close_pct: float = 0.30):
+    """Returns entries list len(df).
+
+    Wide range bar: range > atr_mult * ATR(14) at bar i-1 (causal).
+    Strong close long:  close >= low + (1 - close_pct) * range  (top 30%)
+    Strong close short: close <= low + close_pct * range         (bottom 30%)
+    """
+    hi  = df["high"].values.astype(float)
+    lo  = df["low"].values.astype(float)
+    cl  = df["close"].values.astype(float)
+    bar_range = hi - lo
+
+    # ATR causal: shift by 1 so ATR at bar i uses data up to bar i-1
+    atr_raw = al.atr(df, win=14)
+    atr_shifted = np.roll(atr_raw, 1)
+    atr_shifted[0] = atr_raw[0]
+
+    entries = [None] * len(df)
+    for i in range(1, len(df)):
+        rng = bar_range[i]
+        atr_i = atr_shifted[i]
+        if atr_i <= 0 or not np.isfinite(atr_i):
+            continue
+        if rng < atr_mult * atr_i:
+            continue   # not a wide-range bar
+        close_rel = (cl[i] - lo[i]) / rng if rng > 0 else 0.5
+        if close_rel >= (1.0 - close_pct):
+            # Strong bullish wide bar -> long follow-through
+            entries[i] = {"dir": 1, "tp": None, "sl": None, "max_bars": k_bars}
+        elif close_rel <= close_pct:
+            # Strong bearish wide bar -> short follow-through
+            entries[i] = {"dir": -1, "tp": None, "sl": None, "max_bars": k_bars}
+    return entries
+
+
+# ---------------------------------------------------------------------------
+# Grid search over k_bars
+# ---------------------------------------------------------------------------
+K_BARS_GRID = [3, 5, 7, 10]
+
+best_rep = None
+best_hold = -999
+
+for k in K_BARS_GRID:
+    rep = al.study_signals(
+        f"MIC05-k{k}",
+        lambda df, _k=k: make_entries(df, k_bars=_k),
+        tfs=("1d",),
+    )
+    min_hold = rep["verdict"].get("best_holdout_sharpe", -999)
+    print(f"k={k:2d}: grade={rep['verdict']['grade']} "
+          f"full={rep['verdict'].get('best_full_sharpe', 'N/A')} "
+          f"hold={min_hold}")
+    if min_hold > best_hold:
+        best_hold = min_hold
+        best_rep = rep
+
+# Rename best rep with canonical ID
+best_rep["name"] = "MIC05"
+print("\n--- BEST CONFIG ---")
+print(al.fmt(best_rep))
+print("JSON:", al.as_json(best_rep))

scripts/research/alt/runs/MIC06.py

@@ -0,0 +1,84 @@
+"""MIC06 — Body-ratio momentum (long-flat, vol-targeted)
+Hypothesis: Large positive candle body (body/range high) signals conviction upward move
+-> hold long next bars. Body ratio = (close - open) / (high - low), smoothed over N bars.
+When smoothed body-ratio > threshold -> long; else flat.
+Grid: (lookback_smooth, threshold, hold_bars) x tfs (1d, 12h)
+"""
+import sys
+sys.path.insert(0, "/opt/docker/PythagorasGoal/scripts/research/alt")
+import altlib as al
+import numpy as np
+import pandas as pd
+
+def body_ratio_signal(df: pd.DataFrame, smooth: int = 5, threshold: float = 0.15) -> np.ndarray:
+    """
+    Compute body/range ratio for each bar, then smooth over `smooth` bars.
+    Go long when smoothed ratio > threshold (conviction upward), else flat.
+    All causal: body_ratio[i] uses only close[i], open[i], high[i], low[i].
+    The smoothed ratio uses bars up to i (causal rolling mean).
+    """
+    o = df["open"].values.astype(float)
+    h = df["high"].values.astype(float)
+    l = df["low"].values.astype(float)
+    c = df["close"].values.astype(float)
+
+    rng = h - l
+    body = c - o
+    # Body ratio: in [-1, 1]; positive = bullish bar, negative = bearish bar
+    # Where range == 0 (doji), treat as 0
+    ratio = np.where(rng > 0, body / rng, 0.0)
+
+    # Smooth with a rolling mean (causal)
+    smoothed = pd.Series(ratio).rolling(smooth, min_periods=max(1, smooth // 2)).mean().values
+
+    # Direction: long if smoothed ratio > threshold, else flat
+    direction = np.where(smoothed > threshold, 1.0, 0.0)
+
+    # Vol-target to 20%, leverage cap 2x
+    return al.vol_target(direction, df, target_vol=0.20, vol_win_days=30, leverage_cap=2.0)
+
+
+# Small internal grid: 4 param sets
+CONFIGS = [
+    dict(smooth=3,  threshold=0.10),
+    dict(smooth=5,  threshold=0.15),
+    dict(smooth=10, threshold=0.10),
+    dict(smooth=10, threshold=0.20),
+]
+
+# Run 2 TFs x 4 configs = 8 backtests — but we pick best config first
+# To stay within 6 total: we test all 4 configs on 1d only, pick best, then run 12h too
+print("=== MIC06: Body-Ratio Momentum (long-flat, vol-targeted) ===\n")
+
+# Phase 1: quick grid on 1d (4 backtests)
+print("Phase 1: grid search on 1d...")
+grid_results = []
+for cfg in CONFIGS:
+    rep = al.study_weights(
+        f"MIC06-s{cfg['smooth']}-t{int(cfg['threshold']*100)}",
+        lambda df, s=cfg["smooth"], t=cfg["threshold"]: body_ratio_signal(df, s, t),
+        tfs=("1d",)
+    )
+    best_cell = rep["cells"][0]
+    score = best_cell["min_asset_holdout_sharpe"]
+    print(f"  smooth={cfg['smooth']:2d} thresh={cfg['threshold']:.2f}: "
+          f"minFull={best_cell['min_asset_full_sharpe']:+.2f}  "
+          f"minHold={best_cell['min_asset_holdout_sharpe']:+.2f}  "
+          f"feeOK={best_cell['fee_survives']}")
+    grid_results.append((score, cfg, rep))
+
+# Pick best config by hold-out score
+grid_results.sort(key=lambda x: x[0], reverse=True)
+best_score, best_cfg, _ = grid_results[0]
+print(f"\nBest config: smooth={best_cfg['smooth']} threshold={best_cfg['threshold']:.2f}")
+
+# Phase 2: run best config on both TFs (2 backtests)
+print("\nPhase 2: full eval on 1d + 12h with best config...")
+final_rep = al.study_weights(
+    "MIC06",
+    lambda df, s=best_cfg["smooth"], t=best_cfg["threshold"]: body_ratio_signal(df, s, t),
+    tfs=("1d", "12h")
+)
+
+print("\n" + al.fmt(final_rep))
+print("JSON:", al.as_json(final_rep))

scripts/research/alt/runs/MIC07.py

@@ -0,0 +1,131 @@
+"""MIC07 — Pin-bar rejection reversal (hammer at support).
+
+HYPOTHESIS:
+  A hammer candle (large lower wick, small body near top) at a recent support (N-bar low)
+  signals a long reversal. Enter long at close[i] with SL below the wick low.
+
+PIN-BAR DEFINITION (causal, using only bar[i] OHLC):
+  - Lower wick >= wick_ratio * candle range  (e.g. 60% of H-L)
+  - Body is in upper part of the candle (close > midpoint)
+  - Candle range > ATR * min_range_atr  (no doji / tiny bars)
+
+SUPPORT CONDITION:
+  - low[i] <= rolling_min(low, support_win bars, excluding bar i) * (1 + support_pct)
+    i.e. bar is "near" a recent N-bar low
+
+TRADE MANAGEMENT:
+  - Entry: close[i]
+  - SL: low[i] - atr_sl_mult * ATR  (below wick, some buffer)
+  - TP: close[i] + rr_ratio * (close[i] - SL)  (risk-reward)
+  - max_bars: hold at most max_hold days
+
+Grid (<=4 configs, 1 TF = 1d, 2 assets => 4 backtests total):
+  Config A: wick_ratio=0.60, support_win=20, sl_mult=0.2, rr=2.0, max_hold=10
+  Config B: wick_ratio=0.65, support_win=10, sl_mult=0.3, rr=1.5, max_hold=8
+  Config C: wick_ratio=0.55, support_win=20, sl_mult=0.3, rr=2.0, max_hold=15
+  Config D: wick_ratio=0.60, support_win=30, sl_mult=0.2, rr=2.0, max_hold=10
+
+Pick best config by min_asset_holdout_sharpe, print full report.
+"""
+import sys
+sys.path.insert(0, "/opt/docker/PythagorasGoal/scripts/research/alt")
+import altlib as al
+import numpy as np
+
+
+def make_entries(df, wick_ratio=0.60, support_win=20, sl_mult=0.2,
+                 rr=2.0, max_hold=10, atr_win=14, min_range_atr=0.3):
+    """Build entry list for the pin-bar reversal strategy."""
+    o = df["open"].values.astype(float)
+    h = df["high"].values.astype(float)
+    l = df["low"].values.astype(float)
+    c = df["close"].values.astype(float)
+
+    atr_arr = al.atr(df, atr_win)
+
+    # Rolling min of lows over support_win bars PRIOR to i (shift by 1 -> causal)
+    low_series = df["low"].rolling(support_win, min_periods=support_win).min().shift(1).values
+
+    entries = [None] * len(df)
+
+    for i in range(support_win + atr_win + 1, len(df)):
+        rng = h[i] - l[i]
+        if rng <= 0:
+            continue
+
+        atr_i = atr_arr[i]
+        if not np.isfinite(atr_i) or atr_i <= 0:
+            continue
+
+        # Filter tiny candles
+        if rng < min_range_atr * atr_i:
+            continue
+
+        body_top = max(o[i], c[i])
+        body_bot = min(o[i], c[i])
+
+        lower_wick = body_bot - l[i]
+        # upper_wick = h[i] - body_top  # not used but useful for debug
+
+        # Pin bar: lower wick must dominate
+        if lower_wick < wick_ratio * rng:
+            continue
+
+        # Body in upper portion (close > midpoint of range)
+        if c[i] <= (h[i] + l[i]) / 2.0:
+            continue
+
+        # Support condition: low[i] is near recent N-bar rolling min
+        supp = low_series[i]
+        if not np.isfinite(supp):
+            continue
+        # Low[i] must be at or below support level (within 0.5% of the recent low)
+        if l[i] > supp * 1.005:
+            continue
+
+        # Trade setup
+        sl_price = l[i] - sl_mult * atr_i
+        if sl_price >= c[i]:
+            continue  # degenerate
+        risk = c[i] - sl_price
+        if risk <= 0:
+            continue
+        tp_price = c[i] + rr * risk
+
+        entries[i] = {
+            "dir": 1,
+            "tp": round(tp_price, 2),
+            "sl": round(sl_price, 2),
+            "max_bars": max_hold,
+        }
+
+    return entries
+
+
+CONFIGS = [
+    dict(wick_ratio=0.60, support_win=20, sl_mult=0.2, rr=2.0, max_hold=10),
+    dict(wick_ratio=0.65, support_win=10, sl_mult=0.3, rr=1.5, max_hold=8),
+    dict(wick_ratio=0.55, support_win=20, sl_mult=0.3, rr=2.0, max_hold=15),
+    dict(wick_ratio=0.60, support_win=30, sl_mult=0.2, rr=2.0, max_hold=10),
+]
+
+best_rep = None
+best_score = -999
+
+for cfg_idx, cfg in enumerate(CONFIGS):
+    name = f"MIC07-cfg{cfg_idx+1}"
+    rep = al.study_signals(
+        name,
+        lambda df, c=cfg: make_entries(df, **c),
+        tfs=("1d",),
+    )
+    score = rep["verdict"].get("best_holdout_sharpe", -9)
+    print(f"Config {cfg_idx+1}: {cfg} -> score={score:.3f}, grade={rep['verdict']['grade']}")
+    if score > best_score:
+        best_score = score
+        best_rep = rep
+        best_cfg = cfg
+
+print("\n=== BEST CONFIG ===", best_cfg)
+print(al.fmt(best_rep))
+print("JSON:", al.as_json(best_rep))

scripts/research/alt/runs/MIC08.py

@@ -0,0 +1,57 @@
+"""MIC08 — OBV Trend
+Hypothesis: On-balance-volume trend: long when OBV above its EMA (volume confirms price).
+Long-flat. Continuous weights via al.study_weights.
+
+Grid: obv_ema_period in (20, 50) x tfs (1d, 12h) = 4 total backtests.
+"""
+import sys
+sys.path.insert(0, "/opt/docker/PythagorasGoal/scripts/research/alt")
+import altlib as al
+import numpy as np
+
+
+def compute_obv(df) -> np.ndarray:
+    """Compute On-Balance-Volume causally."""
+    close = df["close"].values
+    volume = df["volume"].values
+    n = len(close)
+    obv = np.zeros(n)
+    for i in range(1, n):
+        if close[i] > close[i - 1]:
+            obv[i] = obv[i - 1] + volume[i]
+        elif close[i] < close[i - 1]:
+            obv[i] = obv[i - 1] - volume[i]
+        else:
+            obv[i] = obv[i - 1]
+    return obv
+
+
+def make_target(ema_period: int):
+    def target(df) -> np.ndarray:
+        obv = compute_obv(df)
+        obv_ema = al.ema(obv, ema_period)
+        # Long when OBV > its EMA, flat otherwise
+        signal = np.where(obv > obv_ema, 1.0, 0.0)
+        # Use vol-targeting to size the position
+        sized = al.vol_target(signal, df, target_vol=0.20, vol_win_days=30, leverage_cap=2.0)
+        return sized
+    return target
+
+
+# Grid search: 2 EMA periods x 2 timeframes = 4 total backtests
+results = []
+for ema_p in (20, 50):
+    rep = al.study_weights(
+        f"MIC08-OBV-EMA{ema_p}",
+        make_target(ema_p),
+        tfs=("1d", "12h"),
+    )
+    results.append((rep["verdict"].get("best_holdout_sharpe", -9), ema_p, rep))
+
+# Pick best by hold-out Sharpe
+results.sort(key=lambda x: x[0], reverse=True)
+best_holdout, best_ema, best_rep = results[0]
+
+print(f"\n=== Best config: EMA period={best_ema} ===")
+print(al.fmt(best_rep))
+print("JSON:", al.as_json(best_rep))

scripts/research/alt/runs/MRV01.py

@@ -0,0 +1,84 @@
+"""MRV01 — RSI2 Connors mean-reversion strategy.
+Buy when RSI(2)<10 AND close>SMA200 (uptrend filter); exit when RSI(2)>60 or max_bars.
+Long-only, 1d timeframe.
+
+Internal grid: try thresholds (rsi_entry, rsi_exit, max_bars) on 1d.
+Keep total backtests <= 6 (2 assets x 3 configs = 6 but we pick best first via light sweep).
+"""
+import sys
+sys.path.insert(0, "/opt/docker/PythagorasGoal/scripts/research/alt")
+import altlib as al
+import numpy as np
+
+
+def make_entries_fn(rsi_entry=10, rsi_exit=60, sma_win=200, max_bars=10):
+    """Factory for RSI2 Connors entries list. Long-only."""
+    def entries_fn(df):
+        c = df["close"].values.astype(float)
+        n = len(c)
+        rsi2 = al.rsi(c, 2)
+        sma200 = al.sma(c, sma_win)
+        entries = []
+        for i in range(n):
+            if (
+                not np.isnan(rsi2[i]) and not np.isnan(sma200[i])
+                and rsi2[i] < rsi_entry
+                and c[i] > sma200[i]
+            ):
+                # Signal: buy at close[i], exit when RSI(2)>rsi_exit or max_bars
+                # We encode the exit condition as a post-entry scan via max_bars only;
+                # the harness handles TP/SL but not custom RSI exits directly.
+                # We use max_bars as the hard exit; no TP/SL (rely on time-based exit).
+                entries.append({
+                    "dir": 1,
+                    "tp": None,
+                    "sl": None,
+                    "max_bars": max_bars,
+                })
+            else:
+                entries.append(None)
+        return entries
+    return entries_fn
+
+
+def make_entries_fn_rsi_exit(rsi_entry=10, rsi_exit=60, sma_win=200, max_bars=10):
+    """Entries with RSI exit encoded as TP/SL-free but we precompute exit bar
+    by looking forward (but this would be look-ahead). Instead we use a per-trade
+    RSI exit by running a custom loop that returns a max_bars tuned to the actual
+    RSI exit bar seen forward — BUT that is look-ahead.
+
+    Honest approach: use a fixed max_bars (no look-ahead RSI exit).
+    The signal fires at close[i]; fill at close[i]. Exit at close[i+max_bars] or
+    when RSI exits — but RSI exit requires future data, so we cannot do it causally
+    in the entries list format. We use max_bars as the honest exit.
+    """
+    return make_entries_fn(rsi_entry, rsi_exit, sma_win, max_bars)
+
+
+# Grid: 3 configs (rsi_entry, rsi_exit, max_bars)
+CONFIGS = [
+    dict(rsi_entry=10, max_bars=5,  label="RSI2<10_SMA200_mb5"),
+    dict(rsi_entry=10, max_bars=10, label="RSI2<10_SMA200_mb10"),
+    dict(rsi_entry=15, max_bars=5,  label="RSI2<15_SMA200_mb5"),
+]
+
+# Run config 0 first (canonical Connors), then decide best
+best_rep = None
+best_hold = -999.0
+best_label = None
+
+for cfg in CONFIGS:
+    label = cfg["label"]
+    fn = make_entries_fn(rsi_entry=cfg["rsi_entry"], max_bars=cfg["max_bars"])
+    rep = al.study_signals(f"MRV01-{label}", fn, tfs=("1d",))
+    hold = rep["verdict"].get("best_holdout_sharpe", -999)
+    full = rep["verdict"].get("best_full_sharpe", -999)
+    print(f"\n[{label}] full={full:.3f} hold={hold:.3f} grade={rep['verdict']['grade']}")
+    if hold > best_hold:
+        best_hold = hold
+        best_rep = rep
+        best_label = label
+
+print("\n\n=== BEST CONFIG ===", best_label)
+print(al.fmt(best_rep))
+print("JSON:", al.as_json(best_rep))

scripts/research/alt/runs/MRV02.py

@@ -0,0 +1,131 @@
+"""MRV02 — BB reversion in calm regime (1d, discrete signals).
+
+HYPOTHESIS: Buy lower BB(20,2) ONLY when realized vol is in low expanding-percentile
+(calm regime). Exit at mid-BB. The gate is the alpha: filter out high-vol / volatile
+periods; only trade the gentle reversions.
+
+Style: al.study_signals (discrete entry/exit, 1d only)
+Gate: RV <= expanding percentile of RV (calm = low expanding percentile threshold)
+Entry: close <= lower BB(20,2)
+TP: mid-BB (dynamic, recomputed each bar in the trade management)
+SL: 2 * ATR below entry
+Max bars: 20 days
+"""
+import sys
+sys.path.insert(0, "/opt/docker/PythagorasGoal/scripts/research/alt")
+import altlib as al
+import numpy as np
+import pandas as pd
+
+
+def make_entries(df: pd.DataFrame, bb_win: int = 20, bb_k: float = 2.0,
+                 rv_win_days: int = 20, rv_pct_thresh: float = 30.0,
+                 atr_win: int = 14, max_bars: int = 20):
+    """
+    Causal entry logic for MRV02.
+
+    Entry conditions at close[i]:
+    1. close[i] <= lower_BB(20,2) — price touched/crossed lower band
+    2. rv_percentile(i) <= rv_pct_thresh — calm regime (low expanding RV percentile)
+
+    TP: mid_BB at entry time (static target for the trade)
+    SL: entry - 2*ATR (static)
+    max_bars: 20 days
+    """
+    c = df["close"].values.astype(float)
+    n = len(c)
+    bpd = al.bars_per_day(df)
+    bpy = bpd * 365.25
+
+    # Bollinger Bands (causal: value at i uses data <= i)
+    upper_bb, mid_bb, lower_bb = al.bbands(c, win=bb_win, k=bb_k)
+
+    # Realized vol (annualized), window = rv_win_days bars
+    rv_win = max(2, rv_win_days * bpd)
+    r = al.simple_returns(c)
+    rv = al.realized_vol(r, rv_win, bpy)
+
+    # Expanding percentile of RV (causal: percentile of all RV values seen up to i)
+    rv_series = pd.Series(rv)
+    rv_pct = rv_series.expanding().rank(pct=True) * 100.0  # 0-100 percentile
+    rv_pct = rv_pct.values
+
+    # ATR for SL
+    atr_vals = al.atr(df, win=atr_win)
+
+    entries = [None] * n
+    warmup = max(bb_win, rv_win, atr_win) + 1
+
+    for i in range(warmup, n):
+        # Gate: RV must be in calm regime
+        if not np.isfinite(rv_pct[i]) or rv_pct[i] > rv_pct_thresh:
+            continue
+        # Gate: lower BB must be defined
+        if not np.isfinite(lower_bb[i]) or not np.isfinite(mid_bb[i]):
+            continue
+        # Entry: close touches or crosses lower BB
+        if c[i] > lower_bb[i]:
+            continue
+        # ATR must be defined
+        if not np.isfinite(atr_vals[i]) or atr_vals[i] <= 0:
+            continue
+
+        tp_price = mid_bb[i]     # exit at mid-band (static target)
+        sl_price = c[i] - 2.0 * atr_vals[i]  # SL: 2 ATR below entry
+
+        # Only take trade if TP > entry price (there's room to profit)
+        if tp_price <= c[i]:
+            continue
+
+        entries[i] = {
+            "dir": +1,
+            "tp": tp_price,
+            "sl": sl_price,
+            "max_bars": max_bars,
+        }
+
+    return entries
+
+
+# ----------------------------------------------------------------
+# Small parameter grid: bb_win x rv_pct_thresh (4 combos max)
+# ----------------------------------------------------------------
+GRID = [
+    # (bb_win, rv_pct_thresh)
+    (20, 30),   # canonical
+    (20, 40),   # slightly more permissive gate
+    (30, 30),   # wider bands
+    (30, 40),   # wider bands + more permissive gate
+]
+
+print("MRV02 — BB reversion in calm regime")
+print(f"Grid: {GRID}")
+print()
+
+best_rep = None
+best_score = -999.0
+
+for bb_win, rv_pct_thresh in GRID:
+    label = f"MRV02[BB{bb_win},RVp{rv_pct_thresh}]"
+    print(f"--- Testing {label} ---")
+
+    def make_fn(bw=bb_win, rp=rv_pct_thresh):
+        def entries_fn(df):
+            return make_entries(df, bb_win=bw, rv_pct_thresh=rp)
+        return entries_fn
+
+    rep = al.study_signals(label, make_fn(), tfs=("1d",))
+    print(al.fmt(rep))
+    print()
+
+    v = rep["verdict"]
+    score = v.get("best_holdout_sharpe", -999.0) or -999.0
+    if score > best_score:
+        best_score = score
+        best_rep = rep
+        best_rep["_config"] = dict(bb_win=bb_win, rv_pct_thresh=rv_pct_thresh)
+
+print("\n=== BEST CONFIG ===")
+print(al.fmt(best_rep))
+print()
+print("JSON:", al.as_json(best_rep))

scripts/research/alt/runs/MRV03.py

@@ -0,0 +1,128 @@
+"""MRV03 — Z-score reversion trend-gated (discrete signals, 1d).
+
+HYPOTHESIS: Fade |zscore(close,20)| > 2 toward mean ONLY when the long-horizon
+trend (SMA200 slope) is flat. Skip entries in strong trends.
+
+Logic:
+- z = zscore(close, 20): deviation from 20-bar mean
+- slope = (SMA200[i] - SMA200[i-slope_win]) / SMA200[i-slope_win]: recent slope of SMA200
+- Gate: |slope| < flat_thresh  → trend is flat → allow mean-reversion
+- Entry: if z > +2 → SHORT (price too high, expect reversion to mean)
+         if z < -2 → LONG (price too low, expect reversion to mean)
+- Exit: TP at SMA20 (mean reversion target), SL at 3*ATR14, max_bars=10
+
+Grid: 2 param sets (zscore_win x flat_thresh):
+  A: zscore_win=20, flat_thresh=0.005
+  B: zscore_win=20, flat_thresh=0.010
+"""
+import sys
+sys.path.insert(0, "/opt/docker/PythagorasGoal/scripts/research/alt")
+import altlib as al
+import numpy as np
+
+# ── CONFIG GRID (keep total backtests ≤ 6: 2 params × 1 TF × 2 assets = 4 per config) ──
+CONFIGS = [
+    dict(label="A", zscore_win=20, slope_win=5,  flat_thresh=0.005, z_thresh=2.0, max_bars=10),
+    dict(label="B", zscore_win=20, slope_win=5,  flat_thresh=0.010, z_thresh=2.0, max_bars=10),
+]
+
+
+def make_entries_fn(zscore_win: int, slope_win: int, flat_thresh: float,
+                    z_thresh: float, max_bars: int):
+    """Return an entries_fn(df) for study_signals."""
+    sma200_win = 200
+
+    def entries_fn(df):
+        c = df["close"].values.astype(float)
+        n = len(c)
+
+        # Indicators (all causal: value at i uses data <=i)
+        z = al.zscore(c, zscore_win)
+        sma20 = al.sma(c, zscore_win)          # mean-reversion target = rolling mean
+        sma200 = al.sma(c, sma200_win)
+        atr14 = al.atr(df, 14)
+
+        # SMA200 slope: fractional change over last slope_win bars
+        sma200_prev = np.full(n, np.nan)
+        sma200_prev[slope_win:] = sma200[:-slope_win]
+        slope = np.where(
+            (sma200_prev > 0) & np.isfinite(sma200_prev),
+            (sma200 - sma200_prev) / sma200_prev,
+            np.nan,
+        )
+
+        entries = [None] * n
+        for i in range(sma200_win + slope_win, n):
+            zi = z[i]
+            si = slope[i]
+            ci = c[i]
+            atr_i = atr14[i]
+            m20_i = sma20[i]
+
+            # NaN guard
+            if not (np.isfinite(zi) and np.isfinite(si) and np.isfinite(ci)
+                    and np.isfinite(atr_i) and np.isfinite(m20_i)):
+                continue
+
+            # Gate: trend must be flat
+            if abs(si) >= flat_thresh:
+                continue
+
+            # Signal
+            if zi > z_thresh:
+                # Price is stretched UP → SHORT toward mean
+                entries[i] = {
+                    "dir": -1,
+                    "tp": m20_i,                    # mean reversion target
+                    "sl": ci + 3.0 * atr_i,        # stop above
+                    "max_bars": max_bars,
+                }
+            elif zi < -z_thresh:
+                # Price is stretched DOWN → LONG toward mean
+                entries[i] = {
+                    "dir": +1,
+                    "tp": m20_i,                    # mean reversion target
+                    "sl": ci - 3.0 * atr_i,        # stop below
+                    "max_bars": max_bars,
+                }
+
+        return entries
+
+    return entries_fn
+
+
+def run():
+    results = []
+    for cfg in CONFIGS:
+        print(f"\n--- Config {cfg['label']}: zscore_win={cfg['zscore_win']}, "
+              f"slope_win={cfg['slope_win']}, flat_thresh={cfg['flat_thresh']}, "
+              f"z_thresh={cfg['z_thresh']}, max_bars={cfg['max_bars']} ---")
+        entries_fn = make_entries_fn(
+            zscore_win=cfg["zscore_win"],
+            slope_win=cfg["slope_win"],
+            flat_thresh=cfg["flat_thresh"],
+            z_thresh=cfg["z_thresh"],
+            max_bars=cfg["max_bars"],
+        )
+        rep = al.study_signals(
+            f"MRV03-{cfg['label']}",
+            entries_fn,
+            tfs=("1d",),
+        )
+        print(al.fmt(rep))
+        print("JSON:", al.as_json(rep))
+        results.append((cfg, rep))
+
+    # Pick best config by min_asset_holdout_sharpe
+    best_cfg, best_rep = max(
+        results,
+        key=lambda x: x[1]["verdict"].get("best_holdout_sharpe", -99),
+    )
+    print(f"\n=== BEST CONFIG: {best_cfg['label']} ===")
+    print(al.fmt(best_rep))
+    print("JSON:", al.as_json(best_rep))
+    return best_rep
+
+
+if __name__ == "__main__":
+    run()

scripts/research/alt/runs/MRV04.py

@@ -0,0 +1,135 @@
+"""MRV04 — IBS (Internal Bar Strength) Mean-Reversion
+
+HYPOTHESIS: Internal Bar Strength = (close - low) / (high - low).
+Long when IBS < low_thresh (closed near low = oversold position within bar),
+flat (or short) when IBS > high_thresh (closed near high = overbought).
+
+Classic daily mean-reversion edge. Testing on certified BTC/ETH daily bars.
+
+Variants tested:
+  V1: Long-flat  thresholds 0.20/0.80 (classic textbook)
+  V2: Long-flat  thresholds 0.25/0.75 (slightly wider)
+  V3: Long-short thresholds 0.20/0.80 (adds short leg)
+  V4: Long-flat  thresholds 0.15/0.85 (tighter = rarer signals)
+  Best variant selected by min-asset hold-out Sharpe.
+
+All positions are vol-targeted (20% annualized, 2× leverage cap).
+Evaluated on 1d timeframe (IBS is a daily signal by design).
+"""
+
+import sys
+sys.path.insert(0, "/opt/docker/PythagorasGoal/scripts/research/alt")
+import altlib as al
+import numpy as np
+
+
+# ---------------------------------------------------------------------------
+# IBS calculation (causal: uses close, high, low of the same bar i)
+# ---------------------------------------------------------------------------
+def ibs(df) -> np.ndarray:
+    h = df["high"].values.astype(float)
+    l = df["low"].values.astype(float)
+    c = df["close"].values.astype(float)
+    rng = h - l
+    # Avoid division by zero (doji bars with zero range)
+    result = np.where(rng > 0, (c - l) / rng, 0.5)
+    return result
+
+
+# ---------------------------------------------------------------------------
+# Variant builders
+# ---------------------------------------------------------------------------
+def make_ibs_longflat(low_thresh: float, high_thresh: float):
+    """Long when IBS < low_thresh, flat when IBS > high_thresh, hold otherwise."""
+    def target_fn(df):
+        ibs_val = ibs(df)
+        pos = np.full(len(df), np.nan)
+        pos[0] = 0.0
+        for i in range(1, len(df)):
+            if ibs_val[i] < low_thresh:
+                pos[i] = 1.0   # go long
+            elif ibs_val[i] > high_thresh:
+                pos[i] = 0.0   # go flat
+            else:
+                pos[i] = pos[i - 1]  # hold
+        pos = np.nan_to_num(pos, nan=0.0)
+        return al.vol_target(pos, df, target_vol=0.20, vol_win_days=30, leverage_cap=2.0)
+    return target_fn
+
+
+def make_ibs_longshort(low_thresh: float, high_thresh: float):
+    """Long when IBS < low_thresh, short when IBS > high_thresh, hold otherwise."""
+    def target_fn(df):
+        ibs_val = ibs(df)
+        pos = np.full(len(df), np.nan)
+        pos[0] = 0.0
+        for i in range(1, len(df)):
+            if ibs_val[i] < low_thresh:
+                pos[i] = 1.0   # go long
+            elif ibs_val[i] > high_thresh:
+                pos[i] = -1.0  # go short
+            else:
+                pos[i] = pos[i - 1]  # hold
+        pos = np.nan_to_num(pos, nan=0.0)
+        return al.vol_target(pos, df, target_vol=0.20, vol_win_days=30, leverage_cap=2.0)
+    return target_fn
+
+
+# ---------------------------------------------------------------------------
+# Vectorized version (faster, equivalent logic using ffill)
+# ---------------------------------------------------------------------------
+def make_ibs_longflat_vec(low_thresh: float, high_thresh: float):
+    """Vectorized long-flat IBS strategy."""
+    def target_fn(df):
+        ibs_val = ibs(df)
+        # Signal: 1=long, 0=flat, NaN=hold (ffill)
+        sig = np.where(ibs_val < low_thresh, 1.0,
+               np.where(ibs_val > high_thresh, 0.0, np.nan))
+        sig[0] = 0.0  # start flat
+        pos = sig.copy()
+        # forward-fill NaN (hold previous)
+        import pandas as pd
+        pos = pd.Series(pos).ffill().fillna(0.0).values
+        return al.vol_target(pos, df, target_vol=0.20, vol_win_days=30, leverage_cap=2.0)
+    return target_fn
+
+
+def make_ibs_longshort_vec(low_thresh: float, high_thresh: float):
+    """Vectorized long-short IBS strategy."""
+    def target_fn(df):
+        import pandas as pd
+        ibs_val = ibs(df)
+        sig = np.where(ibs_val < low_thresh, 1.0,
+               np.where(ibs_val > high_thresh, -1.0, np.nan))
+        sig[0] = 0.0
+        pos = pd.Series(sig).ffill().fillna(0.0).values
+        return al.vol_target(pos, df, target_vol=0.20, vol_win_days=30, leverage_cap=2.0)
+    return target_fn
+
+
+# ---------------------------------------------------------------------------
+# Run all variants
+# ---------------------------------------------------------------------------
+if __name__ == "__main__":
+    TFS = ("1d",)
+
+    variants = [
+        ("MRV04-V1-LF-0.20/0.80", make_ibs_longflat_vec(0.20, 0.80)),
+        ("MRV04-V2-LF-0.25/0.75", make_ibs_longflat_vec(0.25, 0.75)),
+        ("MRV04-V3-LS-0.20/0.80", make_ibs_longshort_vec(0.20, 0.80)),
+        ("MRV04-V4-LF-0.15/0.85", make_ibs_longflat_vec(0.15, 0.85)),
+    ]
+
+    results = []
+    for name, fn in variants:
+        print(f"\nRunning {name} ...")
+        rep = al.study_weights(name, fn, tfs=TFS)
+        print(al.fmt(rep))
+        results.append(rep)
+
+    # Pick best by min_asset_holdout_sharpe
+    best = max(results, key=lambda r: r["verdict"].get("best_holdout_sharpe", -99))
+    print("\n" + "=" * 60)
+    print(f"BEST VARIANT: {best['name']}")
+    print(al.fmt(best))
+    print("JSON:", al.as_json(best))