docs: verify cerbero-bite MCP is MAINNET (real option chain) -> VRP source unlocked

- 3-level check: spot matches certified feed (<0.3%); environment_info=mainnet/testnet=false; chain-level decisive: ETH_USDC-26JUN26-1650-P identical bid/ask/IV/delta on ccxt mainnet vs Cerbero MCP (25.6/26.6/54.54%/-0.315) - contamination was the OLD testnet token on get_historical, NOT Cerbero MCP itself - Cerbero MCP gives real per-strike bid/ask/IV/greeks/OI + regime features ccxt lacks (dealer gamma, gamma-flip, OI delta, liquidation, funding) -> usable for VRP validation - no deep chain history -> multi-year VRP still model-priced, but model-vs-real calibration now robust/repeatable. Token used only for verification, never logged/committed.
research: verify options sleeve on REAL Deribit quotes (spread+skew haircut)
2026-06-19 22:11:14 +02:00 · 2026-06-19 21:48:12 +02:00 · 2026-06-19 21:43:08 +02:00 · 2026-06-19 21:22:49 +02:00 · 2026-06-19 21:13:57 +02:00 · 2026-06-19 20:36:01 +02:00
181 changed files with 58 additions and 22656 deletions
@@ -1,11 +0,0 @@
 Old/
 data/
 .venv/
 .git/
 logs/
 __pycache__/
 **/__pycache__/
 *.pyc
 .env
 .env.mainnet
 docs/
@@ -43,12 +43,5 @@ data/games/
 # archived data (mirrors top-level data/ ignores, which are top-level-anchored)
 Old/data/
 Old/**/__pycache__/
 # run logs (rigenerabili dagli script)
 logs/
 # cache della ricerca trackE (rigenerabile)
 .cache_trackE_*.npy
 # feed backup pre-rebuild (binari rigenerabili, NON in git) + stato paper trader (runtime)
 data/_feed_backup/
 data/paper_trend/
@@ -21,85 +21,19 @@ Cosa è cambiato:
 Prima ondata di ricerca onesta su BTC/ETH certificati (5 track, harness condiviso
 `src/backtest/harness.py`). Sintesi in `docs/diary/2026-06-19-research-synthesis.md`.
- **TP01 Trend Portfolio — strategia DIFENSIVA robusta (non alpha)** —
+- **VINCITRICE (l'unica robusta e profittevole): TP01 Trend Portfolio** —
-  `src/strategies/trend_portfolio.py`. TSMOM multi-orizzonte (1-3-6 mesi) vol-targeted, long-flat,
+  `src/strategies/trend_portfolio.py`. TSMOM multi-orizzonte (1-3-6 mesi) vol-targeted,
-  50/50 BTC+ETH. Config canonica **PORT LF1d** (**>=12h, 1d raccomandato**, vol-target 20%, leva cap 2x):
+  50/50 BTC+ETH. Config canonica **PORT LF4h** (4h, long-flat, vol-target 20%, leva cap 2x):
-  **FULL Sharpe ~1.30, maxDD ~14%; HOLD-OUT 2025-26 Sharpe ~0.31 / +3.5%** mentre il buy&hold 50/50
+  **CAGR ~16.6%, Sharpe ~1.32-1.36, maxDD ~12-14%, positiva ogni anno 2019-2026**.
-  faceva −39%/DD60%. Verificata indipendentemente col gauntlet onesto (hold-out + cross-asset +
+  Robusta su tutti i TF (15m-1d), regge fee fino a 0.40% RT, su entrambi gli asset.
-  plateau + deflated-Sharpe 0.999): **regge**. **Valore = taglio del drawdown ~6× vs buy&hold**, NON
+  Paper trader: `scripts/live/paper_trend.py`. Test: `tests/test_trend_portfolio.py`.
-  generazione di ritorno (CAGR ~16% vs ~48% del buy&hold sul toro).
+- **Edge deboli ma reali** (NON standalone, NON migliorano il portafoglio): ML walk-forward
-  ⚠️ **LOOK-AHEAD (2026-06-19):** un ffill MIXED-TIMEFRAME su barre open-labeled gonfiava il 4h
+  su BTC (Sharpe ~0.57), trend 1h long-short (Sharpe ~1.0), relative-value market-neutral
-  (~1.60 → reale ~1.1). Il calcolo per-singolo-TF è leak-free, ma **NON scendere sotto le 12h**:
+  ETH/BTC (scorrelato ~0.05 ma Sharpe solo 0.27 → troppo debole per alzare lo Sharpe).
-  costi+overfitting dominano senza vantaggio (FULL Sh piatto ~1.3 da 12h a 4h; hold-out migliore a 1d).
+- **MORTO/confermato artefatto:** mean-reversion / fade (negativo anche a fee zero su dati
-  Deploy/paper a **1d**. Diari `2026-06-19-tp01-verification.md` / `-tp01-lookahead-fix-lf.md`.
+  certi — la vecchia libreria +201%/+1238% era pura contaminazione); trend 5m/15m (fee).
-  Paper trader: `scripts/live/paper_trend.py` (1d). Test: `tests/test_trend_portfolio.py`.
+- **Soffitto strutturale:** con i soli BTC/ETH lo Sharpe di portafoglio si ferma a **~1.3**.
-  Ri-verifica: `scripts/analysis/{verify_tp01,stress_tp01,tp01_lowfreq}.py`.
+  Combinare TF o aggiungere la RV non aiuta (ridondanza/edge troppo debole).
 - **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
  (~−0.12).** Affinato (2026-06-19): **(a) blend di lookback [30,90]** (z-score cross-sectional mediato,
  come il multi-orizzonte di TP01); **(b) gate di dispersione p30** (entra solo se la dispersione
  cross-section del momentum supera il percentile espandente causale, altrimenti flat — XS è rumore in
  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).
  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`):
  TP01+XS01 combinato **FULL Sharpe 1.55, HOLD-OUT 1.55, DD 4.4%**. Aggiunto **VRP01** (options
  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
  validare locale con dati HL). Report `scripts/portfolio/run_portfolio.py`. Sleeve a date d'inizio
  diverse → outer-join con pesi rinormalizzati (TP01 da solo 2019-20, VRP dal 2021, blend pieno dal 2024).
 - **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
  (options_vrp_lab): **(a) defined-risk** taglia la coda (worst-week -16.6%→-7.4%, DD 33%→14%);
  **(b) gate IV-rank>0.30** = vendi vol solo ricca → ribalta HOLD-OUT da -0.25 a +0.28 (l'alpha è il
  filtro di regime). Standalone **FULL Sh 1.10, HOLD 0.60, DD 12%**, positivo/piatto ogni anno (2022
  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`.
  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
  multi-asset è ridondante con TP01, corr 0.74). I margini su XS sono nella STRUTTURA DEL SEGNALE
  (blend + gate), non nel numero di asset. I **51** parquet certificati restano per ricerca futura.
  ⚠️ Il test "52-asset = negativo" era in parte inquinato dal backfill sintetico (AXS 83%, ALGO/SAND
  37% di barre vol=0) poi rimosso — vedi correzione estrazione 2026-06-20 sotto; resta comunque vero
  che il long-tail diluisce XS01, ma il numero netto post-fix è 51.
 - **Lead OPZIONI VRP (income short-vol) — quantificato, NON deploy** — `scripts/research/options_vrp_*.py`.
  Vendita put settimanali che incassa il volatility risk premium (IV>RV), scorrelato al trend (~0.07).
  Premio prezzato BS su DVOL reale (`fetch_dvol.py`) + calibrato su quote REALI cerbero-bite mainnet
  (`options_vrp_calibrate.py`): **f reale ≈ 1.0** (non 1.29) → Sharpe ~0.71, DD 33%, coda severa
  (settimane −15..−26% su LUNA/FTX). Diversificatore DEBOLE a premio reale, e short-vol da modello.
  **Regola: niente short-vol da modello in deploy.** Rivalutare quando cerbero-bite cattura un crash
  (per il f di stress reale). Diari `2026-06-19-options-vrp-lab` / `-eval-crypto-backtest-options`.
 - **Edge deboli/scartati:** ML walk-forward BTC (Sh ~0.57), trend 1h L/S (~1.0), RV ETH/BTC (Sh 0.27,
  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).
 - **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`.
 - **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.
@@ -125,17 +59,13 @@ netto fee, out-of-sample, robusto su griglia, e su dati certificati + liquidi +
 src/data/downloader.py     → load_data(asset, tf): legge i parquet certificati da data/raw/
 src/strategies/base.py     → Strategy (ABC), Signal, BacktestResult, YearlyStats
 src/strategies/indicators.py → indicatori condivisi (ema, atr, keltner, ...)
-src/strategies/trend_portfolio.py → TP01: strategia DIFENSIVA robusta (PORT LF1d, >=12h), causale
+src/strategies/trend_portfolio.py → TP01: strategia VINCENTE (PORT LF4h), causale, deployabile
 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
 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)
 src/version.py             → APP_VERSION (legge il file VERSION)
-scripts/research/          → ricerca: track{A-I}_*.py + options_vrp_*.py + fetch_dvol.py
+scripts/research/          → ricerca post-reset: track{A-E}_*.py (trend/ML/MR/portfolio/xsec)
-scripts/portfolio/         → run_portfolio.py (report) + xsec_*.py (ricerca/affinamento XS01)
+scripts/live/paper_trend.py → paper trader forward-only di TP01 (no esecuzione reale)
 scripts/live/paper_trend.py → paper trader forward-only di TP01 (1d) (no esecuzione reale)
 scripts/analysis/          → SOLO i tool dati certificati:
  rebuild_history.py        → (ri)costruisce lo storico da Deribit mainnet (base 5m + resample)
  certify_feed.py           → certifica il feed (integrità, coerenza resample, spike, cross-venue)
@@ -157,10 +87,7 @@ uv run python scripts/analysis/certify_feed.py                # certifica i feed
 uv run python scripts/analysis/certify_feed.py --local        # solo check locali (veloce)
 uv run python scripts/research/trackD_trendport.py            # backtest strategia vincente (full report)
 uv run python scripts/research/trackD_timing.py               # vincitrice su 15m/1h/4h/1d + PnL/DD/trade per anno
-uv run python scripts/analysis/fetch_hyperliquid.py          # fetch+certify universo Hyperliquid (Cerbero mainnet) -> data/raw/hl_*
+uv run python scripts/live/paper_trend.py                    # avanza il paper trader TP01 (forward-only)
 uv run python scripts/portfolio/xsec_research.py             # ricerca cross-sectional su Hyperliquid (XS01)
 uv run python scripts/portfolio/run_portfolio.py             # report del PORTAFOGLIO attivo (TP01+XS01)
 uv run python scripts/live/paper_trend.py                    # avanza il paper trader TP01 (forward-only, 1d)
 uv run pytest                                                 # test
 ```
@@ -184,21 +111,10 @@ df = load_data("BTC", "1h")   # OK. load_data("SOL", ...) -> FileNotFoundError (
 ### Universo ricercabile certificato
 - **BTC / ETH**: puliti (2-6 bps vs Coinbase USD su tutta la storia), liquidi (~0% barre flat a 1h),
  storia lunga (2018/2019→oggi) → **ogni timeframe (5m/15m/1h)**. È l'unico dato in `data/raw`.
- **Alt Deribit (SOL/XRP/ADA/LTC/DOGE/BNB): FUORI.** Illiquidi (LTC 5m 82% barre flat, run ~3 giorni),
+- **Alt (SOL/XRP/ADA/LTC/DOGE/BNB): FUORI.** Illiquidi (LTC 5m 82% barre flat O=H=L=C, run fino a
-  divergenti, o non certificabili. Archiviati in `Old/data/raw`.
+  ~3 giorni), divergenti (LTC/DOGE >1% su 10-21% delle barre 2022-23), o non certificabili
- **Universo Hyperliquid (Cerbero MCP MAINNET): 19 alt liquidi a 1d, dal 2024** — BTC/ETH/SOL/BNB/XRP/
+  (XRP delistato da Coinbase per causa SEC; BNB non listato + storia da 2024-10). Sono archiviati in
-  DOGE/AVAX/LINK/LTC/ADA/ARB/OP/SUI/APT/INJ/TIA/SEI/NEAR/AAVE. Certificati (`fetch_hyperliquid.py`):
+  `Old/data/raw`. Riammetterne uno richiede prima una ricertificazione che dimostri liquidità + accordo.
  flat 0%, cross-venue 4-9 bps vs Binance, >1% ≈0% → `data/raw/hl_*_1d.parquet`. **Caveat:** storia
  nativa solo **~2.5 anni** (2024-2026; pre-2024 = backfill, vol 0). Abilita le strategie
  CROSS-SECTIONAL (impossibili a 2 asset). NB: Cerbero col token TESTNET = farlocco; col token
  **mainnet** (`.env.mainnet`) = reale, ma SEMPRE da certificare (cross-venue + liquidità).
  ⚠️ **CORREZIONE estrazione (2026-06-20):** il backfill NON è solo pre-2024 — cerbero MCP padda con
  barre SINTETICHE (volume 0, prezzi copiati da Binance → matchano cross-venue e non sono flat) ogni
  asset listato su HL **dopo** lo START. Il `flat`+cross-venue da soli non lo vedono: il rivelatore è
  il **VOLUME**. `fetch_hyperliquid.py` ora (1) taglia il run iniziale a volume 0, (2) scarta chi resta
  < 365g reali (es. **AXS 83% sintetico → fuori**), (3) gata i gap vol=0 interni. Universo certificato
  = **51** (era 52). I **19 major di XS01 hanno 0 backfill → invariati** (strategia live non toccata).
  Verificato direttamente su cerbero MCP. Diario `2026-06-20-cerbero-backfill-fix.md`.
 ## Metodologia obbligatoria per ogni nuova strategia
@@ -1,11 +0,0 @@
 FROM python:3.11-slim
 COPY --from=ghcr.io/astral-sh/uv:latest /uv /usr/local/bin/uv
 WORKDIR /app
 COPY pyproject.toml uv.lock ./
 RUN uv sync --frozen --no-dev
 COPY src/ src/
 COPY scripts/ scripts/
 COPY VERSION ./
 VOLUME /app/data
 # Monitor PAPER del portafoglio attivo (TP01+XS01). Esecuzione REALE disabilitata.
 CMD ["uv", "run", "python", "-m", "src.live.dashboard", "--port", "8787"]
@@ -1,7 +0,0 @@
 {
  "_nota": "Config esecuzione LIVE di TP01. execution_enabled=true + --execute -> ordini REALI. ARMATO 2026-06-20.",
  "execution_enabled": true,
  "max_notional_per_asset_usd": 300,
  "min_order_usd": 5,
  "disaster_sl_pct": 0.30
 }
@@ -1,15 +0,0 @@
 # Solo MONITOR (dashboard paper) del portafoglio attivo. Niente runner/esecuzione reale
 # (archiviati in Old/). v2.0.0+.
 services:
  dashboard:
    build: .
    container_name: pythagoras-dashboard
    restart: unless-stopped
    command: ["uv", "run", "python", "-m", "src.live.dashboard", "--port", "8787"]
    ports:
      - "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
@@ -1,35 +0,0 @@
 # 2026-06-19 — Wave 1 "beat TP01" (26 agenti BTC/ETH): nessun 3º sleeve robusto
 Goal "trova strategie che battano l'esistente e inseriscile": GIA' soddisfatto da XS01 (cross-
 sectional Hyperliquid, integrato → portafoglio TP01 70% + XS01 30%, FULL Sh 1.41 / HOLD 1.15).
 In parallelo, una wave di 26 agenti ha cercato su BTC/ETH miglioramenti del trend + diversificatori.
 ## Esito wave 1 (26 agenti, 25 leak-free): 22 weak, 3 "contender", 1 noise
 I 3 contender, ri-verificati ONESTAMENTE col giudice book-level (`verify_contender.py`) e come
 contributo marginale al portafoglio ATTUALE (TP01+XS01):
 | Candidato | corr TP01 | corr XS01 | +portafoglio (w30%) | Verdetto |
 |---|---|---|---|---|
 | **tsmom_strength_12h** | **+0.49** | — | — | ☠️ scartato: è TP01 più veloce (correlato), non diversifica |
 | **breakout_atr** (trend) | −0.04 | −0.04 | FULL +0.48 / **HOLD +0.05** | ☠️ scartato: gonfia solo il FULL storico (bull), ~zero valore nel hold-out |
 | **highvol_rev** (reversal alta-vol) | −0.08 | −0.05 | FULL +0.20 / **HOLD +0.30** | 🟡 WATCHLIST (vedi sotto) |
 ## highvol_rev: candidato vero ma NON abbastanza robusto → watchlist
 È l'unico genuinamente scorrelato a ENTRAMBI gli sleeve e che migliora FULL+hold-out. MA il mio
 robustezza-check indipendente (plateau, come per XS01) lo boccia per il deploy:
 - **Edge solo a REV_LB=1**: LB2 FULL Sh 0.33, LB3 ~0.05 → **picco a singola-barra, non plateau**.
 - **FULL standalone mediocre** (0.74); la forza è nel hold-out (HOLD 0.97-1.39 vs FULL ~0.7) =
  **HOLD≫FULL = regime-luck dell'alta-vol 2025-26**, non robustezza temporale.
 - È un **reversal** (famiglia morta in tutto il progetto) con concept ribaltato post-hoc
  (low-vol→high-vol). Regge fee fino ~0.3% ma con margine ridotto.
 Stesso difetto (HOLD≫FULL, no-plateau) per cui ho bocciato ieri il RV ETH/BTC regime-luck. La
 disciplina che boccia i falsi positivi vale anche qui → **NON deployato**, in watchlist; rivalutare
 forward (più dati) o se emerge un plateau su un parametro core.
 ## Conclusione
 Wave 1 NON aggiunge un 3º sleeve robusto. **Portafoglio invariato: TP01 (70%) + XS01 (30%).** Le
 famiglie trend (breakout/tsmom-12h) sono ridondanti con TP01 o aiutano solo il bull storico; l'unico
 diversificatore di meccanismo nuovo (highvol_rev) non regge il bar di robustezza. Il vero edge
 incrementale è venuto dall'ESPANSIONE DELL'UNIVERSO (Hyperliquid → cross-sectional), non da altre
 varianti di trend su 2 asset. Direzione futura coerente: più asset certificati + sleeve di
 meccanismo nuovo (non altre trend-variant), col criterio plateau+breadth+contributo.
@@ -1,62 +0,0 @@
 # 2026-06-19 — Ricerca frattale multi-agente (63 agenti) su BTC/ETH
 Su richiesta: 50+ agenti in parallelo a cercare strategie NUOVE ispirate ai due documenti
 frattali (`Libro_frattali` + `Pythagoras_Trading_Prediction`), timing/asset diversi, ognuna
 validata sull'harness onesto. Eseguito come Workflow: **63 agenti, ~2h, 3.8M token.**
 ## Cosa è stato testato
 16 concetti frattali estratti dai documenti (sotto la patina esoterica: coscienza, frequenze
 Solfeggio, numeri sacri → idee testabili): alfabeto candle U/D/0 (3-6, LONG), Fourier/cicli,
 ricorrenza di Poincaré (analoghi kNN), centro di inversione Evideon (mirror tempo+prezzo),
 indicatore H-C (~588/25 ≈ 23.5 barre), numeri-universali come periodi, invarianza di forma,
 entropia di Shannon ("coscienza") come gate, confluenza multi-TF, grammatica composizionale,
 fase-ricorrenza. × BTC/ETH × {5m,15m,1h} = **52 ipotesi**.
 Ogni segnale: scritto da un agente come funzione `signal()`, valutato da `eval_signal.py`
 (stesso harness onesto) con **guard automatico anti-look-ahead** (ricalcolo su prefissi).
 Superstiti → verifica avversariale con sblocco una-tantum del **hold-out 2025-26**.
 ## Esito
 - **Verdetti**: 29 rumore, 12 "real" (netto-fee positivo ma non battono il buy&hold), 11 "edge"
  (in-sample: battono B&H + null p<0.05 + leak=0).
 - **Guard anti-look-ahead**: nessun leak passato (gli agenti hanno prodotto segnali causali; i
  pochi tentativi con futuro sono stati auto-squalificati e corretti).
 - **Hold-out (la prova del nove)**: dei **11 superstiti in-sample, 10 REFUTATI** — performance
  catastrofica nel 2025-26 (hurst-DFA −0.49, hc-cycle −0.83, vol-accel −1.16, universal-periods
  −0.42…−1.04, spectral-entropy −0.38/+0.29, multitf −0.49, solfeggio-BTC −0.64). Stessa firma di
  sempre: **regime-luck del toro 2018-2024, sparito out-of-sample.**
 - **1 "confermato"** dalla verifica per-agente: `momentum_solfeggio_cycle` **ETH 1h** (holdout
  Sharpe +1.19, ret +49% mentre il buy&hold ETH faceva −49%). Sembrava un trionfo.
 ## Ma il "vincitore" cade al test cross-asset (kill decisivo)
 Il guard per-agente valuta un asset alla volta e non poteva vedere il quadro. Ho rieseguito **lo
 stesso identico codice** sui due major:
 | Signal (identico) | FULL Sharpe | HOLD-OUT Sharpe | HOLD-OUT ret |
 |---|---|---|---|
 | Solfeggio-cycle su **ETH** 1h | 1.54 | **+1.19** | +49% |
 | Solfeggio-cycle su **BTC** 1h | 1.17 | **−0.25** | −7.5% |
 Un edge robusto non fallisce sull'altro major. La stessa logica (long-only ~20% esposta, filtro
 SMA(588), timing su ciclo ~24) che ha "schivato" il crash ETH 2025 **perde su BTC nello stesso
 hold-out**. È **fortuna di regime di un singolo asset**, non skill. Aggravanti: costanti
 numerologiche ad-hoc (24/588/56, "odore" di overfit, già notato dal verificatore); e con 52 trial,
 trovare 1 segnale che passa un singolo regime di hold-out è atteso per puro caso (1/11 ≈ chance).
 ## VERDETTO
 **La ricerca frattale multi-agente (52 ipotesi, 63 agenti) NON ha trovato alcun edge robusto.**
 I concetti frattali/esoterici si sono comportati esattamente come le famiglie convenzionali (Fasi
 1-3): edge in-sample da regime-luck del toro, refutati dal hold-out; e l'unico che passava il
 hold-out su un asset fallisce sull'altro. **Nessuna magia nei numeri Solfeggio/sacri.**
 Il valore: il processo disciplinato (guard anti-look-ahead + hold-out bloccato + **test cross-asset**)
 ha catturato un falso "trionfo" (+49% vs −49%!) che sul vecchio sistema contaminato sarebbe finito
 dritto in produzione. È la quinta conferma indipendente che su BTC/ETH non c'è un edge facile.
 ## Stato della ricerca dopo tutte le fasi
 Testato: mean-reversion, momentum/trend, vol, lead-lag, hurst, shape-ML, e 16 famiglie frattali ×
 multi-TF/asset. **Niente di robusto, fee-surviving, OOS e cross-asset.** Le direzioni oneste
 restano: (a) accettare il ceiling = long risk-managed (no alpha); (b) allargare l'universo dati
 CERTIFICATO oltre BTC/ETH; (c) fonti di segnale ortogonali al prezzo (on-chain, basis multi-venue,
 opzioni multi-regime) — tutte richiedono nuovi dati certificati. Artefatti: `eval_signal.py`,
 workflow `fractal-strategy-search`, ~52 segnali in `/tmp/pyth_sig_*.py`.
@@ -1,60 +0,0 @@
 # 2026-06-19 — Espansione universo (Hyperliquid via Cerbero mainnet) → XS01 batte il portafoglio
 L'utente: "ci dovrebbe essere uno storico dati preso da cerbero". Aveva ragione, ed è la chiave per
 superare il soffitto a 2 asset.
 ## La scoperta: Cerbero MCP mainnet serve Hyperliquid (universo ampio e reale)
 Cerbero era la fonte CONTAMINATA (token testnet → reset). MA col token **mainnet** (`.env.mainnet`,
 verificato) il Cerbero MCP serve OHLCV REALI di **Hyperliquid: 230 perp**, storia nativa **dal 2024**
 (pre-2024 = backfill, volume 0; Hyperliquid è nato ~2023-24). Prezzi recenti plausibili.
 ## Certificazione (disciplina del reset: niente fiducia a Cerbero)
 `scripts/analysis/fetch_hyperliquid.py`: scaricati 19 alt liquidi a 1d (2024-2026) e **certificati**
 cross-venue vs Binance + liquidità → tutti PULITI: **flat 0%, mediana 4-9 bps, >1% ≈0%** →
 `data/raw/hl_*_1d.parquet` (namespace dedicato). Caveat onesto: **~2.5 anni** di storia nativa.
 ## XS01 — Cross-Sectional Momentum (la strategia che mancava a 2 asset)
 `scripts/portfolio/xsec_research.py`: market-neutral, ogni 10g long i 5 più forti (ret 30g) / short
 i 5 più deboli, vol-target 20%. Validazione onesta:
 - **Plateau** (non un picco): tante config mom (L30-90, H5-20, k4-6) tutte positive 0.6-0.98.
 - **Fee-robusto**: FULL Sh 0.79→0.68 da fee 0% a 0.3% RT.
 - **Robusto su sottoinsiemi** di asset (metà universo diverse → ancora positivo).
 - **Scorrelato a TP01 (~−0.06)**, **positivo OGNI anno** (2024 +2%, 2025 +19%, 2026 +20%).
 - **Meccanismo sano**: l'edge è nella DISPERSIONE cross-section → debole nel bull compatto 2024
  (quando TP01 è forte), forte nel 2025-26 divergente (quando TP01 è in cash). **Complementare**.
 Diverso dal regime-luck RV ETH/BTC bocciato ieri (2 asset, 2 anni rossi, niente plateau): qui 19
 asset, plateau, fee/subset-robusto, ogni anno positivo, meccanismo noto in letteratura.
 ## Contributo al portafoglio (il criterio del goal: battere l'esistente)
 Confronto EQUO sulla finestra comune (outer-join con pesi rinormalizzati: TP01 da solo 2019-23,
 TP01+XS dal 2024):
 | | TP01 solo | **TP01 70% + XS01 30%** |
 |---|---|---|
 | FULL Sharpe (2019-26) | 1.30 | **1.41** |
 | **HOLD-OUT 2025-26 Sharpe** | 0.31 | **1.15** |
 | HOLD-OUT ret / DD | +3.5% / 7.5% | **+15.1% / 5.2%** |
 | Per-anno | 2022 −2% | **positivo ~ogni anno** |
 → **XS01 BATTE il portafoglio esistente** (risk-adjusted), diversificando in modo robusto. Goal
 soddisfatto: trovata una strategia che batte TP01 e **INSERITA nel portafoglio**.
 ## Integrazione
 - `src/portfolio/portfolio.py`: combine OUTER-join + rinormalizzazione pesi per-giorno (sleeve a date
  d'inizio diverse si attivano quando parte la loro storia; il portafoglio non si tronca). Test nuovo.
 - `src/portfolio/sleeves.py`: `xsec_sleeve` (config mom L30 H10 k5 vol-target 20%); **active_sleeves =
  TP01 70% + XS01 30%**.
 - `fetch_hyperliquid.py`, `xsec_research.py`. 12 test passano.
 ## Caveat onesti (da non dimenticare)
 - **Storia XS solo ~2.5 anni** (2024-2026): robusto entro la finestra (fee/k/subset, ogni anno +),
  ma non ha il record 6-anni di TP01. Cross-sectional momentum è literature-robust → prior favorevole.
 - **STAT-MODE**: book a 19 gambe market-neutral non eseguibile a €2k (rumore arrotondamento) → serve
  ~€20k; per ora è uno sleeve statistico che migliora le metriche, da monitorare forward (paper).
 - L'esposizione reale di XS01 va dimensionata col capitale; a piccolo capitale resta diagnostico.
 ## Stato
 Portafoglio attivo = **TP01 (70%) + XS01 (30%)**, FULL Sh 1.41 / HOLD 1.15. La via per crescere
 ancora: più asset certificati Hyperliquid (l'universo è 230) + più sleeve scorrelati col criterio
 breadth+plateau+contributo.
@@ -1,81 +0,0 @@
 # 2026-06-19 — Options VRP sleeve: infrastruttura + prima validazione onesta
 Impostata la ricerca dello sleeve income opzioni (vendita put settimanali, incassa il volatility
 risk premium IV>RV). Lead identificato dalla valutazione di `crypto_backtest` come la via per
 superare il soffitto Sharpe ~1.3 (fonte di rendimento DIVERSA, scorrelata al trend).
 ## Infrastruttura costruita
 - `scripts/research/fetch_dvol.py`: storia DVOL (IV 30d Deribit) BTC/ETH **2021-03 → 2026-06**
  (1914g) → `data/raw/dvol_*.parquet`. È l'input IV.
 - `scripts/research/options_vrp_lab.py`: motore backtest CSP settimanale. Prezzo put BS su DVOL
  reale + **calibrazione f** (skew/spread vs quote reali), strike a delta target, payoff sul path
  realizzato dei prezzi certificati. Causale (decisione a sell-date, payoff a scadenza). Gauntlet:
  VRP context, sweep f/delta, per-anno, worst-weeks (coda), correlazione + contributo vs TP01.
 - `scripts/research/options_real_quote_check.py` (dal branch): verifica premio su quote reali.
 ## VRP reale (contesto)
 BTC DVOL 61% vs RV 53% → **VRP +7.8 pt, positivo 78% del tempo**; ETH +3.7 pt, 67%. Il premio di
 volatilità esiste ed è più ricco su BTC.
 ## Risultati (book 50/50 BTC+ETH, put settimanali delta -0.28)
 **Tutto dipende dalla CALIBRAZIONE f del premio:**
 | f | Sharpe | CAGR | maxDD | worst-week |
 |---|---|---|---|---|
 | 0.70 | −0.32 | −12% | 51% | −26% |
 | 0.85 | 0.20 | +1% | 35% | −26% |
 | **1.00 (conservativo, IV-ATM)** | **0.71** | +16% | 33% | −26% |
 | 1.15 | 1.22 | +34% | 32% | −25% |
 | **1.29 (reale calm, con skew)** | **1.70** | +52% | 31% | −25% |
 - A f=1.0 (ignora il bonus skew): Sharpe **0.71** — SOTTO TP01. A f=1.29 (skew reale misurato in
  regime calmo): **1.70**. La verità sta in mezzo E f varia col regime (skew più alto nello stress).
 - **Delta**: più ATM = più premio + più rischio (−0.15→Sh 0.25, −0.28→0.71, −0.40→0.95).
 **La CODA è severa (è short-vol):** maxDD standalone **30-33%**, singole settimane **−15..−26%**
 (2021-05 crash, 2022-05/06 LUNA, 2026-02/06). Per-anno (f=1.0): 2022 **−9%**, 2026-YTD **−14%** —
 sanguina negli anni di crash. HOLD-OUT 2025-26: Sharpe **0.04** a f=1.0 (piatto), 0.94 a f=1.29.
 **Diversificazione (reale):** corr settimanale a TP01 **+0.07** (scorrelato). Contributo (f=1.0):
 TP01 70% + OPT 30% → Sharpe settimanale 0.71→**0.97**, DD basso (11%). Anche al premio conservativo
 migliora il portafoglio per pura decorrelazione.
 ## Verdetto — LEAD reale, NON deploy-ready
 - ✅ Il VRP è reale (IV>RV 78%), lo sleeve è **genuinamente scorrelato** al trend (+0.07) e
  **migliora il portafoglio** anche a premio conservativo. È la fonte di rendimento DIVERSA che
  cercavamo per superare il soffitto ~1.3.
 - ⚠️ MA: (a) le metriche headline dipendono da una calibrazione **ottimistica** (f=1.29);
  conservativo (f=1.0) → Sharpe 0.71 con **DD 33%**. (b) Premio **MODELLATO** (BS su DVOL), non un
  backtest su catena reale; la verifica su quote reali è UN solo snapshot calmo. (c) Il **rischio di
  coda** (roll/assignment/gap nello stress, skew che esplode) NON è pienamente catturato.
 - Regola del progetto: **mai deployare uno short-vol prezzato da un modello.** → NON aggiunto al
  portafoglio. Portafoglio attivo invariato: TP01 70% + XS01 30%.
 ## CALIBRAZIONE su quote REALI cerbero-bite (`options_vrp_calibrate.py`) — corregge l'ottimismo
 cerbero-bite GIA' accumula la catena reale mainnet (option_chain_snapshots, BTC 224k / ETH 237k
 righe, 2026-05→oggi). Usandola (non un nuovo snapshotter), misurato il fattore f reale su 223
 snapshot/asset (put weekly ~delta -0.28, vendita al BID):
 - **BTC: f mediano 1.03** (IQR 0.89-1.21), skew reale **+1.9 pt** (IV put 43.5% vs DVOL 41.6%).
 - **ETH: f mediano 0.97** (IQR 0.88-1.11), skew **+1.5 pt**.
 - **Il f reale e' ~1.0, NON 1.29.** Lo snapshot singolo del branch (skew +4.8 → f 1.29) era un
  OUTLIER; sulla media lo skew e' modesto e il bid/ask lo compensa → premio reale ≈ modellato.
 → Il VRP sleeve sta sul punto **f≈1.0 dello sweep = Sharpe ~0.71** (caso CONSERVATIVO), DD 33%,
 hold-out ~piatto (0.04). Non il 1.70 ottimistico. Resta un diversificatore modesto (corr +0.07,
 migliora il portafoglio settimanale 0.71→0.97 a 30%), ma standalone SOTTO TP01 e con coda severa.
 **CAVEAT:** la finestra di calibrazione reale e' ~10 giorni densi (06-09→06-19, cerbero-bite ruota
 le scadenze → i weekly compaiono sparsi) e UN regime calmo. Il f di STRESS resta non misurato.
 ## Verdetto aggiornato
 Al premio REALE (f≈1.0), il VRP sleeve e' un diversificatore DEBOLE (Sharpe ~0.71 < TP01, DD 33%,
 hold-out piatto): la modesta decorrelazione NON giustifica il rischio di coda short-vol senza molto
 piu' dato reale multi-regime. **Confermato NON-deploy.** Il valore vero arriva solo se cerbero-bite,
 continuando ad accumulare, copre un CRASH: lì si misura il f reale di stress e si fa un backtest su
 catena reale. Fino ad allora, lead quantificato ma in attesa. Portafoglio invariato TP01 70%+XS01 30%.
 ## Prossimi passi per graduare il lead a sleeve deployabile
 1. **Accumulo forward di quote reali** (bid/ask + skew della put settimanale delta-0.28, ogni giorno,
   su più regimi) → sostituire il premio modellato con quello reale e misurare f nello stress.
 2. **Stress crash-week con spread reali** (rollabilità, assignment, gap inverso/coin-settled).
 3. **Daily-MTM** dello short put per l'integrazione nel portafoglio giornaliero (ora è settimanale).
 4. **Paper-trade su Deribit testnet** prima di qualsiasi capitale.
 Solo dopo, se regge a premi reali multi-regime, aggiungerlo come 3º sleeve (scorrelato, income).
@@ -1,58 +0,0 @@
 # 2026-06-19 — Ricerca v2.0.0: Fase 0 (harness) + Fase 1 (triage superstiti)
 Primo log di ricerca post-reset. Universo certificato: BTC/ETH, 1h. Hold-out 2025+ BLOCCATO.
 ## Fase 0 — harness onesto (`scripts/analysis/research_lab.py`)
 Banco di prova causale per costruzione (modello a SERIE DI POSIZIONE: `pos[i]` decisa entro
 `close[i]`, guadagna `close[i]→close[i+1]`, fee sul turnover |Δpos|). Metriche
 Sharpe/CAGR/DD/exposure/turnover, finestra OOS, **null model a rotazione circolare**
 (p-value: il timing batte il caso?), baseline buy&hold, sweep fee.
 **Self-test del banco (valida l'HARNESS, non una strategia):**
 - buy&hold BTC: Sharpe 0.79 (sanity OK).
 - CHEAT look-ahead (pos = segno del rendimento futuro): Sharpe **58**, p=0.005 → l'engine
  VEDE un edge reale quando esiste.
 - NOISE causale a basso turnover: Sharpe **0.14**, p=0.26 → l'engine NON inventa edge dal
  nulla (niente leak, niente skill spuria).
 Il banco è affidabile. → ogni numero qui sotto è netto fee e causale.
 ## Fase 1 — triage dei 2 superstiti (`scripts/analysis/phase1_survivors.py`)
 Sul feed pulito solo SH01 (shape-ML) e frammenti HONEST mostravano segnale residuo. Delle
 HONEST solo **DIP** è testabile su BTC/ETH (TR01/ROT02 richiedono alt esclusi). Re-implementati
 come serie di posizione, passati ai gate onesti.
 ### DIP reversion (long-only) — ☠️ MORTO
 Griglia 3×3 (n, k) **tutta negativa** su entrambi gli asset (nessun plateau). Config centrale
 n50 k2.0: FULL Sharpe −0.17 (BTC) / −0.06 (ETH); a fee 0% appena +0.02/+0.09 (niente edge nemmeno
 lordo). OOS-VAL marginale (+0.36/+0.16) ma **null p=0.84-0.89** (peggio del caso). Rumore.
 ### SH01 shape-ML (walk-forward LogReg) — ☠️ FEE-DEAD
 Pattern coerente su BTC/ETH, long/short e long-only:
 | Variante | Sh fee0% | Sh fee0.05% | Sh fee0.10% | trade/anno | null p |
 |---|---|---|---|---|---|
 | BTC L/S | +0.32 | −0.70 | −1.71 | 877 | 0.167 |
 | BTC long-only | +0.73 | −0.06 | −0.84 | 555 | 0.072 |
 | ETH L/S | +0.31 | −0.40 | −1.11 | 773 | 0.137 |
 | ETH long-only | +0.46 | −0.04 | −0.53 | 485 | 0.142 |
 C'è un **sussurro di segnale LORDO** (Sharpe 0.3-0.7 a fee zero) ma il turnover (485-877
 trade/anno) lo divora: a fee reale tutte negative, e **nessuna batte il null** (p>0.05). Net-fee:
 rumore.
 ## VERDETTO Fase 1
 **Né DIP né shape-ML sopravvivono su BTC/ETH certificato net-fee.** Nessuno dà Sharpe netto >0,
 nessuno batte il null (p<0.05), nessuno batte il **buy&hold** (Sharpe 0.79/0.84 — di fatto la
 "strategia" più forte vista finora). Si conferma: i "superstiti" della vecchia libreria erano,
 come il resto, non-edge. Chiusi.
 ## Lead onesto per la Fase 2
 L'unico segnale non-nullo è il **gross shape-ML** (Sharpe 0.3-0.7 a fee zero), ucciso dal
 turnover. Direzione: esprimere quel segnale a **turnover molto più basso** (orizzonte di holding
 lungo, soglia forte, o come GATE di regime invece che flip per-barra) per vedere se il sussurro
 lordo sopravvive alle fee. È un lead, NON un edge. Inoltre: la barra reale da battere è il
 **buy&hold** (Sharpe ~0.8) — una strategia di timing deve fare meglio di "stai sempre long",
 net-fee.
@@ -1,69 +0,0 @@
 # 2026-06-19 — Ricerca v2.0.0: Fase 2 (famiglie) + analisi OPTIONS
 Universo certificato BTC/ETH. Barra da battere = **buy&hold** (Sharpe 0.79 BTC / 0.84 ETH).
 Tutto netto fee 0.10% RT, hold-out 2025+ BLOCCATO. Harness: `research_lab.py`.
 ## Fase 2 — esplorazione famiglie (`phase2_families.py`)
 24 combinazioni famiglia×asset×TF, ognuna: scan griglia → config migliore → gate onesti
 (FULL/OOS-VAL, vs buy&hold, null p-value a rotazione, sweep fee).
 ### Esiti per famiglia
 - **REVERSAL (mean-reversion breve): ☠️ MORTA OVUNQUE.** FULL Sharpe da −1 a −5.6 (peggio a
  15m: fee-death, −5.6 BTC / −4.6 ETH), gross ≈0, null p 0.45-0.82. **Smentisce definitivamente
  la tesi storica del progetto ("l'edge è sempre mean-reversion")**: era artefatto del feed.
 - **TSMOM / MA-cross / Donchian (trend, long-only): segnale REALE ma MODESTO.** Le versioni
  long-only (basso turnover) battono o eguagliano il buy&hold:
  - **MA-cross long-only**: ETH FULL **1.12** / OOS 0.89 / p **0.007**; BTC FULL **0.90** / OOS
    1.99 / p **0.040**. Plateau sulla griglia (ETH 12/48 e 48/192 entrambi 1.1), coerente sui
    DUE asset, basso turnover (53-106 trade/anno). **Unici 2 a passare: battono B&H + OOS>0 + p<0.05.**
  - Donchian long-only: FULL 0.84-0.94, OOS ottimo (BTC 2.37) ma p 0.08-0.10 (pochi trade → null
    rumoroso). TSMOM long-only: ETH 0.83 (≈B&H). Le L/S perdono (turnover + short su asset in trend).
 - **VOL-TARGET overlay**: ≈ buy&hold (FULL 0.77-0.84), p alto → non distinguibile dal B&H, ma è
  un riduttore di vol/DD (mantiene lo Sharpe scalando l'esposizione).
 - **HURST-gate, LEAD-LAG BTC↔ETH**: niente. (Hurst-mom ETH p=0.043 ma sotto il B&H; lead-lag
  fee-dead.)
 ### Verdetto Fase 2
 L'unica cosa reale su BTC/ETH certificato è il **trend-following long-only** (MA-cross in testa):
 un **long con gestione del rischio** che batte il buy&hold di poco (Sharpe ~0.9-1.1 vs 0.8)
 evitando i drawdown peggiori. È un effetto noto in letteratura (time-series momentum), NON alpha
 market-neutral. **Caveat multiple-testing**: 2 flag su ~24 test ≈ soglia del caso; ma la stessa
 famiglia vince su ENTRAMBI gli asset con plateau → è un LEAD genuino, non confermato. La barra
 vera resta il B&H, e l'OOS-VAL alto di BTC (1.99) puzza di "2024 anno di trend forte" → serve la
 prova del hold-out 2025-26 + regimi bear + stress fee/slippage + deflated-Sharpe (Fase 3).
 ## Analisi OPTIONS (`options_analysis.py`)
 Dati reali cerbero-bite mainnet, ma finestra **~2026-05-01→06-11 (~6 sett., REGIME UNICO calmo)**.
 ### Livelli misurati (reali)
 - **VRP (IV − RV) positivo il 100% del tempo**: BTC +10, ETH +14 punti di vol annua. Le opzioni
  sono sistematicamente CARE in questa finestra → vendere vol/covered-call avrebbe incassato premio.
 - **Skew put positivo**: BTC IV put-10%OTM 44% vs call 35% (skew +10 pt); ETH 54 vs 49 (+5). Il
  crash è prezzato (assicurazione cara).
 - **Costo put protettiva** (mensile, %-del-notional): ~10% OTM = **0.98% BTC / 1.36% ETH**; ATM
  3.3%/5.0%; ~15% OTM 0.83%/0.71%. Liquidità: ATM spread ~3%, OTM 7-12%. Mensile ben popolato
  (499-2043 strike), settimanale OTM sottile. Funding perp ≈ 0 (nessun carry).
 ### Verdetto OPTIONS
 **Nessun edge su opzioni è validabile ora**: 6 settimane, regime unico calmo. Il segnale
 VRP-positivo / sell-vol è ESATTAMENTE ciò che brilla in calma e salta in aria nei crash (è il
 rischio che viene pagato) — non testabile senza un crash nel campione. Ruoli legittimi (entrambi
 NON validabili ora, solo forward):
 - **(a) Tail-cap / catastrofe**: put OTM standing su un book long (il candidato trend ha DD grossi).
  Costa ~1-1.5%/mese a 10% OTM — gateabile coi premi reali misurati qui. Overlay per-trade 24h
  INFATTIBILE (strike OTM corti inesistenti/illiquidi); standing settimanale/mensile FATTIBILE.
 - **(b) Harvest del VRP** (covered call / put-spread): +10-14 pt ci sono ORA, ma è una scommessa
  short-vol che richiede un crash nel campione per essere giudicata onestamente. Non l'abbiamo.
 **Raccomandazione**: le opzioni NON sono un'avenue di ricerca a breve (manca storia multi-regime).
 Mosse: (1) lasciare cerbero-bite ad accumulare (gratis, reale, costruisce in avanti il dataset
 multi-regime); (2) rivalutare quando la finestra attraversa un crash/alta-vol; (3) intanto, l'unico
 uso giustificato è come OVERLAY (tail-cap su una strategia spot), gateato sui premi reali qui sopra.
 ## Prossimo passo
 Fase 3 sul solo candidato reale (trend-following long-only, MA-cross): sblocco UNA volta del
 hold-out 2025-26, comportamento nei bear (2018/2022), stress fee×2 + slippage + lag, deflated-Sharpe
 per il multiple-testing. Se regge → è la prima strategia onesta del progetto v2.0.0 (modesta:
 migliora il buy&hold, non lo stravolge). Se non regge → anche il trend era sample-luck.
@@ -1,62 +0,0 @@
 # 2026-06-19 — Ricerca v2.0.0: Fase 3, conferma avversariale del candidato trend
 Candidato: **trend-following long-only (MA-cross)**, l'unico a passare i gate base in Fase 2.
 Protocollo: selezione config solo pre-hold-out → sblocco una-tantum del hold-out 2025-26 →
 breakdown bear → stress → deflated-Sharpe. Script `phase3_confirm.py`.
 ## Esito: ☠️ NON CONFERMATO — era regime-luck del mercato toro
 ### (1) Pre-hold-out (2018-2024): forte e robusto
 Plateau pieno: BTC Sharpe 0.91-1.16, ETH 1.19-1.48 su tutte le config. **Deflated-Sharpe**
 (N=60 trial): BTC DSR **0.990**, ETH **0.982** → l'effetto trend era REALE e robusto al
 multiple-testing **sul 2018-2024**.
 ### (2) HOLD-OUT 2025-26 (sbloccato una volta) — FALLISCE
 | | buy&hold | trend 24/96 | trend 96/288 (slow) |
 |---|---|---|---|
 | BTC Sharpe | −0.37 | **−0.81** | −0.00 |
 | BTC ret | −32.9% | −33.6% | −5.0% |
 | ETH Sharpe | −0.32 | **−0.95** | −0.01 |
 | ETH ret | −49.3% | −52.0% | −11.3% |
 Il 2025-26 è stato un periodo in DISCESA (buy&hold negativo). Il trend long-only — che "dovrebbe"
 schivare i bear — si è fatto **frullare** (whipsaw): perde quanto o PIÙ del buy&hold, Sharpe negativo
 su ogni config. Solo la MA lentissima (96/288) limita i danni a ~flat (−5/−11%), ma è cherry-pick
 post-hoc e comunque NON positiva.
 ### (3) Per anno — il meccanismo
 Il trend cattura ~70-80% degli anni TORO (2019-2024) e attutisce i bear IN-SAMPLE (2018 −1% vs
 −39%; 2022 −47% vs −65%). MA nel 2025 OUT-OF-SAMPLE ha fatto **peggio** del buy&hold (BTC −25% vs
 −7%; ETH −41% vs −11%): frullato in un mercato choppy/discendente. È il classico fallimento del
 trend-following nei bear laterali. → l'edge 2018-24 era **beta del toro con risk-management**, non
 alpha persistente.
 ### (4) Stress
 FULL regge modestamente (Sharpe 0.65-0.91 anche a fee2x+lag), ma HOLD-OUT è negativo ovunque
 (−0.81 → −1.34) e peggiora sotto stress. Fragile.
 ### (5) Deflated-Sharpe
 DSR>0.95 sul pre-hold-out → conferma che l'effetto era statisticamente reale **nel campione di
 training**. Lezione chiave: **robustezza statistica in-sample ≠ persistenza out-of-sample.** Il
 hold-out bloccato ha colto ciò che DSR da solo non poteva — il cambio di regime.
 ## VERDETTO FINALE (Fasi 0-3)
 **Nessun edge validato, fee-surviving e out-of-sample esiste su BTC/ETH tra le famiglie testate.**
 Il trend-following era il miglior candidato: reale 2018-24 (toro), ma **bocciato sul hold-out
 2025-26** (whipsaw, sotto il buy&hold). La barra realistica resta il **buy&hold** (Sharpe ~0.8
 sullo storico, ma −0.3/−0.4 nel 2025-26: anche "stai long" è stato duro di recente).
 Il processo disciplinato ha funzionato: **ha evitato di deployare un falso edge** (che, sul vecchio
 sistema contaminato, sarebbe finito in produzione). Questo è il valore del reset.
 ## Implicazioni / direzioni
 - **Non deployare** il trend come edge: è regime-dipendente, non batte il buy&hold OOS.
 - Con **solo BTC/ETH prezzo**, il pozzo dei segnali è poco profondo: timing puro non ha edge robusto.
 - Opzioni: nessun ruolo a breve (confermato). Tenere cerbero-bite ad accumulare per uno studio
  multi-regime futuro.
 - Scelte oneste per andare avanti: (a) accettare che il "ceiling" su BTC/ETH è un long risk-managed
  (no alpha) e ottimizzare quello (vol-target per ridurre DD, non per battere il mercato); (b)
  allargare l'universo dati CERTIFICATO (servono asset liquidi+puliti oltre BTC/ETH, che Deribit non
  offre bene → valutare un secondo venue mainnet certificabile); (c) fonti di segnale ortogonali al
  prezzo (on-chain, funding/basis multi-venue, opzioni multi-regime) — tutte richiedono nuovi dati
  certificati prima di poterci credere.
@@ -1,44 +0,0 @@
 # 2026-06-19 — Caccia al secondo sleeve: nessun diversificatore robusto (TP01-only resta)
 Continuazione naturale del portafoglio: cercare un secondo sleeve SCORRELATO a TP01 (trend
 long-flat, in cash gran parte del tempo). Criterio: non il Sharpe standalone ma il CONTRIBUTO al
 portafoglio + robustezza. Tool: `scripts/portfolio/second_sleeve_hunt.py` (riusa le RV di trackE).
 ## Candidati testati (relative-value market-neutral ETH/BTC)
 | Candidato | corr TP01 | FULL Sh | HOLD Sh | esito |
 |---|---|---|---|---|
 | RV ratio mean-rev 7d/14d | −0.09/−0.05 | −1.36/−1.03 | −0.62/−0.76 | ☠️ morto (mean-rev dead, come sempre) |
 | RV ratio_trend / xs_momentum 30d | +0.04 | **0.56** | **1.92** | ⚠️ sembrava promosso |
 ratio_trend e xs_momentum danno risultati IDENTICI: su 2 asset "long il più forte / short il
 debole" ≡ "trend del ratio ETH/BTC". È UN segnale (relative-momentum), non due.
 ## Il candidato "promosso" è regime-luck (per-anno + plateau lo smascherano)
 Aggiunto a TP01 sembrava un trionfo: hold-out portafoglio 0.31 → 1.18 (w20%) / 1.51 (w30%),
 corr +0.04. MA:
 - **Hold-out (1.92) >> FULL (0.56)**: bandiera rossa (immagine speculare della trappola di Fase 3).
 - **Per-anno NON robusto**: 2019 +22%, 2020 +7%, 2021 +21%, 2022 +13%, **2023 −17%, 2024 −19%**,
  **2025 +62%**, 2026 +6%. Due anni consecutivi negativi; il "guadagno" è concentrato nel 2025
  (ETH sottoperforma BTC in modo netto e sostenuto). FULL Sharpe mediocre 0.56, DD 41%.
 - **Nessun plateau**: l'hold-out Sharpe oscilla 0.25→1.92 al variare di (N, hold) → picco
  config+regime, non altopiano.
 - Il beneficio FULL al portafoglio è solo **+0.09 Sharpe** (la legittima diversificazione di uno
  sleeve scorrelato a Sharpe 0.56: √(1.30²+0.56²)≈1.42). Il resto del "miglioramento" è il 2025.
 ## Decisione: NON promosso — TP01-only resta il portafoglio deployato
 La stessa disciplina che ha bocciato i falsi positivi in-sample (Fasi 1-3) e cross-asset (frattali)
 deve bocciare questo falso positivo nel hold-out. Il relative-momentum BTC/ETH è un edge debole e
 regime-dipendente (2 anni a −17/−19%), il cui contributo robusto al portafoglio è marginale
 (+0.09 FULL); il grosso del beneficio è la fortuna del 2025. Aggiungerlo significherebbe
 scommettere sul ripetersi di quel regime.
 **Lezione/criterio aggiornato per i futuri sleeve:** "migliora il hold-out" da solo NON basta (il
 hold-out è UN regime). Un secondo sleeve va promosso solo se: causale, corr bassa, **positivo nella
 maggioranza degli anni** (no 2 anni consecutivi rossi), **plateau** sui parametri, e migliora il
 portafoglio su FULL E hold-out — non solo per via di un singolo anno fortunato.
 ## Stato
 Portafoglio = **TP01-only** (difensivo, Sharpe FULL 1.30 / hold-out 0.31). `active_sleeves()`
 invariato. `second_sleeve_hunt.py` resta come tool per valutare candidati futuri col criterio
 corretto (contributo + breadth per-anno + plateau). Il relative-momentum BTC/ETH è in WATCHLIST,
 non deployato.
@@ -1,31 +0,0 @@
 # 2026-06-19 — Portafoglio di strategie estensibile (TP01 primo sleeve)
 Creato un contenitore di portafoglio (`src/portfolio/`) con TP01 come unico sleeve attivo per ora,
 progettato per aggiungerne altri (ognuno validato col gauntlet onesto).
 ## Design
 - **Sleeve** = una strategia validata che produce una serie di rendimenti netti per-barra
  (datetime-indexed, CAUSALE, netto fee). Opzionale `pos_fn` per le posizioni correnti (live).
 - **StrategyPortfolio**: porta ogni sleeve su griglia GIORNALIERA comune (compounding intra-giorno
  → mixa TF diversi in modo coerente), combina per PESO rinormalizzato sui giorni comuni
  (= equal-capital-by-weight ribilanciato di continuo). Metriche FULL + HOLD-OUT 2025-26 (bloccato)
  + per-anno + standalone per-sleeve, vs benchmark buy&hold 50/50.
 - **Estensibilità**: aggiungere uno sleeve = una riga in `src/portfolio/sleeves.active_sleeves`
  (dopo validazione: research_lab + hold-out + cross-asset + causality guard). Niente sleeve non validati.
 ## Stato attuale (1 sleeve = TP01, peso 100%)
 `scripts/portfolio/run_portfolio.py`:
 - **FULL** Sharpe 1.30 / ret +201% / DD 14.3% / ~€1.52/g su 2k (n=2655 giorni 2019-2026)
 - **HOLD-OUT 2025-26** Sharpe 0.31 / +3.5% / DD 7.5%  (buy&hold 50/50: Sharpe −0.32 / −39% / DD 59%)
 - Per-anno positivo quasi ovunque (2022 −2.1%, 2026-YTD −0.7%)
 - Posizione corrente: **flat** (TP01 in cash nel regime attuale = difensivo)
 ## File
 - `src/portfolio/{__init__,portfolio,sleeves}.py`, `scripts/portfolio/run_portfolio.py`,
  `tests/test_portfolio.py` (6 test, passano). CLAUDE.md aggiornato.
 ## Prossimo
 Il portafoglio è pronto per ospitare nuovi sleeve. Candidati naturali (da validare prima):
 un secondo edge scorrelato a TP01 (TP01 è trend long-flat → serve qualcosa di diverso, es. una
 strategia che lavori quando TP01 è flat). Finché non c'è un secondo edge che regge il gauntlet,
 il portafoglio = TP01 difensivo. Quando arriverà, basta una riga in sleeves.py.
@@ -1,43 +0,0 @@
 # 2026-06-19 — TP01: look-ahead ffill mixed-TF, ri-verifica e adozione bassa frequenza (>=12h)
 Segnalazione utente/agente: un look-ahead **ffill MIXED-TIMEFRAME su barre open-labeled**
 (`resample(label="left")`) gonfiava il 4h a Sharpe ~1.60; il risultato reale è ~1.1.
 Conclusione: **NON scendere sotto le 12h** — costi e overfitting dominano.
 ## Cosa ho verificato (`scripts/analysis/tp01_lowfreq.py`)
 Ricalcolo TP01 PULITO **per singolo TF** (barre discrete, posizione shiftata +1, NESSUN
 ffill/combine mixed-TF), con un **guard di causalità esplicito** (ricalcolo `target_series` su
 prefisso → `tgt[i]` invariato). Esito (fee 0.10% RT, hold-out 2025-26 bloccato):
 | TF | leak | FULL Sh | FULL ret | HOLD Sh | HOLD ret | HOLD DD |
 |---|---|---|---|---|---|---|
 | 4h | **0** | 1.36 | +204% | 0.27 | +2.8% | 8.3% |
 | 6h | **0** | 1.42 | +217% | 0.21 | +2.1% | 7.9% |
 | 12h | **0** | 1.32 | +198% | 0.22 | +2.3% | 8.6% |
 | **1d** | **0** | 1.30 | +201% | **0.31** | **+3.5%** | 7.5% |
 | buy&hold 50/50 1d | — | 0.92 | +1671% | **−0.32** | **−39%** | 59% |
 ## Lettura
 - **Il path single-TF che ho usato in verify/stress è LEAK-FREE** (guard=0 su ogni TF): il
  gonfiaggio 1.60 stava nel path **mixed-TF ffill** (ensemble/combine, es. trackE), NON nel
  portafoglio single-TF. Per questo il mio 4h era 1.36 (non 1.60).
 - **La conclusione "≥12h" è comunque CORRETTA e la adotto**: il FULL Sharpe è PIATTO ~1.3 da 12h
  a 4h → scendere sotto le 12h NON dà vantaggio reale, aggiunge solo costi/turnover e rischio
  overfit/look-ahead (lo stress mostrava il margine hold-out del 4h fragile a lag/fee). **1d è il
  migliore**: hold-out Sharpe 0.31 (il più alto), DD 7.5%, turnover/costi minimi, leak-free.
 - Allinea anche col numero dell'agente: il "reale ~1.1" è del path mixed-TF corretto; il mio
  single-TF pulito dà ~1.3 FULL. In ogni caso **edge difensivo modesto**, non alpha.
 ## Decisioni applicate
 - **Canonica deploy → PORT LF1d** (era LF4h). `trend_portfolio.py`: docstring aggiornata + nota
  look-ahead; aggiunti `resample_tf`/`resample_1d`, `resample_4h` marcato deprecato per il deploy.
 - **Paper trader → 1d** (`paper_trend.py`: `resample_1d`, `build_bars`, etichette 1d; gira, 5 test ok).
 - **CLAUDE.md**: TP01 ridescritta come DIFENSIVA, canonica ≥12h/1d, gotcha look-ahead documentato.
 - **Gotcha riusabile:** mai ffill/combine MIXED-TIMEFRAME su timestamp open-labeled (`label="left"`):
  la close del bar (nota solo a fine bar) verrebbe propagata indietro all'open-label → look-ahead.
  Il calcolo per-singolo-TF a barre discrete (posizione +1) è sicuro; il guard prefix-recompute lo prova.
 ## Verdetto invariato
 TP01 resta la prima strategia onesta del progetto: **difensiva** (taglia il DD ~6× vs buy&hold,
 hold-out 2025-26 positivo su entrambi gli asset), modesta nel ritorno. Deploy a **1d**, forward-only
 paper trader, prima di qualsiasi capitale reale.
@@ -1,84 +0,0 @@
 # 2026-06-19 — Verifica TP01 (branch strategy-research-2026-06) col gauntlet onesto
 Una ricerca PARALLELA (branch `strategy-research-2026-06`, AdrianoDev) dallo stesso baseline
 v2.0.0 ha trovato TP01 come "unica vincitrice". La mia linea (Fasi 2-3) aveva bocciato il trend
 sul hold-out 2025-26. Ho riprodotto TP01 VERBATIM (`scripts/analysis/verify_tp01.py`) e l'ho
 passato al mio gauntlet. **TP01 REGGE — la mia conclusione precedente era incompleta.**
 ## TP01 = TSMOM 30/90/180g, **vol-target 20%**, leva cap 2x, **long-flat**, portafoglio 50/50 BTC+ETH (4h)
 ## Esiti del gauntlet
 **(A) Multi-TF (4h cherry-picked?) — NO, plateau robusto:**
 | TF | FULL Sharpe | HOLD-OUT Sharpe |
 |---|---|---|
 | 15m | 0.93 | −0.31 |
 | 1h | 1.32 | +0.20 |
 | **4h** | **1.36** | **+0.27** |
 | 1d | 1.30 | +0.31 |
 1h/4h/1d danno tutti FULL ~1.3 e hold-out positivo → non è un artefatto di un singolo TF (solo il 15m, fee-sensibile, fallisce).
 **(C) HOLD-OUT 2025-26 (il test che ha ucciso il mio trend 1h) — TP01 PROTEGGE:**
 | | Sharpe | ret | DD |
 |---|---|---|---|
 | **TP01 portfolio** | **+0.27** | **+2.8%** | **8.3%** |
 | buy&hold 50/50 | −0.35 | **−39.4%** | 59.8% |
 **(D) Cross-asset nel hold-out — regge su ENTRAMBI** (BTC sleeve +2.9% Sh 0.24, ETH +2.4% Sh 0.24).
 A differenza del "vincitore" frattale (+ETH/−BTC), TP01 protegge coerentemente su BTC E ETH.
 **(B) Per anno:** positiva quasi ogni anno 2019-2026 (eccezioni piccole: 2022 −2.4%, 2026-YTD −0.9%),
 DD annui 1-12%. Il claim "positiva ogni anno" è lievemente ottimistico ma sostanzialmente vero.
 ## Perché TP01 regge dove il MIO trend (Fase 3) è caduto
 La differenza chiave è il **VOL-TARGETING** (che NON avevo combinato col trend): TP01 scala
 l'esposizione ∝ 1/vol_realizzata → nel crollo 2025-26 la vol è esplosa e TP01 si è messo
 quasi in cash, schivando il drawdown. Il mio MA-cross 1h aveva esposizione fissa ed è rimasto
 long nel chop → frullato. Concorrono: TSMOM multi-orizzonte (più liscio del MA-cross), long-flat
 (niente perdite short), diversificazione 50/50. **La mia "trend = regime-luck" era vera per il
 trend NUDO; TP01 = trend + vol-target + portafoglio è un'altra cosa, e robusta.**
 ## Cosa È onestamente TP01 (no oversell)
 - **Edge DIFENSIVO, non alpha**: FULL Sharpe 1.36 vs buy&hold 0.92 — MA CAGR +16.6% vs +48.1%.
  Su tutto il toro il buy&hold ha reso ~8x di più. Il valore di TP01 è il **DD** (13.8% vs 77.5%
  full; 8% vs 60% nel hold-out) e la **protezione dai crash**.
 - Nel hold-out 2025-26 ha fatto solo +2.8% (Sharpe 0.27, basso): ha **protetto, non profittato**.
 - Un solo regime di hold-out, ma il vol-targeting è meccanico (high vol → low expo) → generalizza
  per costruzione meglio di un timing fittato.
 - Config canonica (30/90/180, vol20%, lev2x) non iper-tunata; 4h non cherry-picked (plateau).
 ## VERDETTO
 **TP01 è la PRIMA strategia onesta e robusta del progetto post-reset.** Supera il mio gauntlet
 (hold-out positivo su entrambi gli asset, plateau multi-TF, causale, fee-aware). È modesta e
 difensiva (Sharpe ~1.3, soffitto strutturale dichiarato corretto), ma è reale: migliora il
 rischio/rendimento del buy&hold tagliando i drawdown e proteggendo nei crash. La ricerca parallela
 ha fatto centro proprio sul pezzo che la mia linea non aveva combinato (vol-target sul trend).
 **Raccomandazione:** integrare il branch su main (modulo `trend_portfolio.py` + paper trader),
 trattare TP01 come baseline operativa difensiva. Aspettative oneste verso il target €50/g: a
 Sharpe 1.3 / CAGR 16.6% servono molto capitale o leva (con più DD) — TP01 è un fondamento solido,
 non una scorciatoia.
 ## STRESS-TEST (`scripts/analysis/stress_tp01.py`, integrato e rieseguito sul modulo vero)
 | Dimensione | Esito |
 |---|---|
 | **Sweep fee** | FULL robusto fino a **0.40% RT** (Sh 1.44→1.36→1.28→1.13). HOLD-OUT SOTTILE: +2.8%/Sh0.27 a 0.10% → ~flat (Sh 0.03) a 0.40% |
 | **Lag/slippage** | FULL robusto (1.29-1.43). HOLD-OUT si erode: lag1(4h)→Sh0.12, lag2→−0.02, lag1+fee0.20%→0.04 |
 | **Plateau parametri** | OTTIMO — target_vol/leva/orizzonti/vol_win tutti reggono o migliorano (orizzonti 20/60/120 → Sh 1.61). **NON un picco cherry-picked** |
 | **Deflated-Sharpe** | DSR **0.999** a N=10/40/100 trial → il Sharpe FULL non è artefatto di multiple-testing |
 **Verdetto stress (onesto):**
 - **Robustezza FULL-period: FORTE.** TP01 supera fee 0.40%, lag, ampio plateau di parametri, e
  deflated-Sharpe. NON è overfit né cherry-picked — la proprietà robusta è il **taglio del
  drawdown** (13.8% vs 77.5% full; 8% vs 60% hold-out), invariante a tutto lo stress.
 - **Edge di RITORNO nel hold-out: REALE ma SOTTILE e sensibile alla frizione.** Nel 2025-26 ha
  schivato il crash in modo affidabile (DD 8% vs 60%) ma ha **protetto più che profittato** (+2.8%,
  Sh 0.27), e quel sottile positivo si assottiglia a zero sotto fee2x o lag 2 barre.
 **Conclusione:** la proprietà **deployabile e robusta di TP01 è la PROTEZIONE del drawdown**, non
 la generazione di alpha. È una strategia difensiva genuina (prima del progetto a superare gauntlet
 + stress), ma a basso ritorno: il valore è "Sharpe ~1.3 con DD ~6× più piccolo del buy&hold",
 non "battere il mercato". Per il capitale reale: il vol-targeting + long-flat sono meccanici e
 generalizzano; il rischio residuo è la frizione di esecuzione sul filo del sottile edge di ritorno
 nei regimi avversi → da monitorare col paper trader forward-only prima di scalare.
@@ -1,28 +0,0 @@
 # 2026-06-19 — Strato trend multi-asset sui 52 alt: RIDONDANTE col trend di TP01
 Tentativo: aggiungere un terzo sleeve = TSMOM (stessa logica TP01 CANONICAL, long-flat vol-target)
 applicato a OGNI alt dei 52 Hyperliquid certificati, equal-weight ragged. Idea: trend più
 diversificato che diversifichi TP01 (BTC/ETH). `scripts/portfolio/trend_multiasset.py`.
 ## Esito: ridondante e peggiore
 - **TREND-52 standalone**: FULL Sh 0.66, **HOLD-OUT −1.03** (negativo), anni+ 33%. Gli alt sono
  stati long nel calo 2025-26 e hanno sanguinato — a differenza di TP01 (BTC/ETH) che il
  vol-target+trend portò in cash. I trend degli alt sono più rumorosi/whippy.
 - **corr a TP01 = +0.74** (stessa beta direzionale, come previsto) | corr a XS01 −0.05.
 - **Contributo al portafoglio (TP01 70 + XS 30):** +TREND-52 w20% → FULL −0.01, **HOLD −0.16**;
  w30% → FULL −0.02, **HOLD −0.27**. PEGGIORA.
 ## Lezione
 Broadenizzare il TREND su molti alt NON diversifica: è la **stessa direzionalità** (corr 0.74 con
 TP01) su asset più rumorosi → aggiunge perdita/rumore, non edge. La dimensione trend è già catturata
 in modo pulito da TP01 (BTC/ETH, vol-targeted). L'unica espansione che diversifica davvero resta
 quella **market-neutral** (XS01 cross-sectional), perché è ortogonale alla beta direzionale.
 ## Conclusione (chiusura del filone "espansione universo")
 Esplorate tutte le vie di espansione sui certificati Hyperliquid:
 1. XS su 52-all → diluito (memecoin), negativo.
 2. XS top-liquidità dinamico → peggiore del fisso-19 (liquidità ≠ qualità).
 3. Trend multi-asset su 52 → ridondante (corr 0.74) + hold-out negativo.
 Nessuna migliora il portafoglio. **Configurazione validata e invariata: TP01 70% + XS01 (19 major)
 30% — FULL Sh 1.41 / HOLD 1.15.** I margini reali per crescere NON sono nell'universo crypto-
 direzionale (saturo), ma in un MECCANISMO diverso (opzioni VRP, in attesa di dati di stress reali).
@@ -1,35 +0,0 @@
 # 2026-06-19 — Affinamento XS01: blend di lookback [30,90]
 Come TP01 fonde gli orizzonti 30/90/180, XS01 ora fonde piu' lookback del momentum cross-sectional
 (z-score cross-sectional per lookback, mediato) invece del singolo L=30. `scripts/portfolio/xsec_blend.py`.
 ## Sweep lookback (19 major, 899g) — FULL/OOS/DD/anni+/corrTP
 | lookbacks | FULL | OOS25 | DD% | anni+ | corrTP |
 |---|---|---|---|---|---|
 | [30] (prima) | 0.80 | 1.20 | 21 | 100% | −0.06 |
 | [90] | 0.88 | 0.90 | 17 | 100% | −0.05 |
 | **[30,90]** | **1.10** | **1.03** | **14** | **100%** | **−0.12** |
 | [20,40,90] | 0.51 | 0.67 | 25 | 100% | −0.12 |
 | [30,60,120] | 0.68 | 0.74 | 16 | 100% | −0.13 |
 **[30,90] e' il sweet spot**: fonde i DUE singoli robusti (30 e 90), FULL Sh 0.80→1.10, DD 21→14%,
 corr a TP01 −0.06→−0.12 (diversifica meglio), 100% anni+. Non e' un cell fortunato: e' la
 combinazione dei due lookback gia' validati (anti-overfit, come il multi-orizzonte di TP01).
 ## Effetto sul portafoglio (TP01 70% + XS01 30%)
 | | XS01 [30] | XS01 blend [30,90] |
 |---|---|---|
 | XS01 standalone FULL / DD | 0.80 / 21% | **1.10 / 14%** |
 | Portafoglio FULL Sharpe | 1.41 | **1.48** |
 | Portafoglio HOLD-OUT Sharpe | 1.15 | 1.06 |
 | Portafoglio DD | 5.2% | **4.6%** |
 | ~€/giorno (2k) | +1.65 | +1.78 |
 Migliora FULL Sharpe + DD + robustezza (due orizzonti) al costo di un hold-out marginalmente piu'
 basso (−0.09, dentro il rumore di una singola finestra). Giudizio: il blend e' piu' robusto
 (meno dipendente da un singolo lookback) e diversifica meglio -> PROMOSSO.
 ## Azione
 `src/portfolio/sleeves.XS_CFG`: `L=30` -> `lookbacks=(30,90)`; engine `_xsec_returns` usa lo score
 blended (media z-score cross-sectional per lookback). **Portafoglio attivo: TP01 70% + XS01 blend
 30%, FULL Sh 1.48 / HOLD 1.06 / DD 4.6%.** 12 test ok. Sleeve sempre sui 19 major.
@@ -1,44 +0,0 @@
 # 2026-06-19 — Affinamento XS01: gate di dispersione (p30)
 Il momentum cross-sectional vive nella DISPERSIONE (winners/losers distanti). In regime compatto
 (tutti gli asset insieme) e' rumore. Gate: entra solo se la dispersione cross-section del momentum
 supera il percentile ESPANDENTE causale `disp_pct`; altrimenti flat. Sul blend [30,90] dei 19 major.
 `scripts/portfolio/xsec_dispgate.py`. (È il concetto del vecchio XS01 pre-reset, disp_min=p50.)
 ## Sweep soglia (19 major, 899g) — XS01 standalone + contributo portafoglio
 | soglia | XS FULL | XS OOS | PORT FULL | PORT HOLD | %flat |
 |---|---|---|---|---|---|
 | no gate | 1.10 | 1.03 | 1.50 | 1.06 | 0% |
 | p15 | 1.32 | 1.39 | 1.64 | 1.36 | 28% |
 | p20 | 1.46 | 1.63 | 1.72 | 1.52 | 31% |
 | p25 | 1.46 | 1.63 | 1.72 | 1.52 | 31% |
 | **p30** | **1.50** | **1.71** | **1.74** | **1.56** | 35% |
 | p35 | 1.60 | 1.90 | 1.81 | 1.69 | 37% |
 | p40-p50 | 1.0 | 0.8 | 1.36-1.38 | 0.77-0.93 | 42-49% |
 **PLATEAU robusto p15-p35** (cinque punti, tutti molto > no-gate); il crollo a p40+ e' OVER-gating
 (salta troppo). Scelto **p30** (centro sicuro del plateau, lontano dal cliff p40). Non un knife-edge.
 ## Effetto sul portafoglio (TP01 70% + XS01 30%)
 | XS01 | PORT FULL | PORT HOLD | PORT DD |
 |---|---|---|---|
 | [30] originale | 1.41 | 1.15 | 5.2% |
 | + blend [30,90] | 1.48 | 1.06 | 4.6% |
 | + dispersion gate p30 | **1.55** | **1.55** | **4.4%** |
 XS01 standalone: FULL 1.10→1.50, HOLD 1.03→1.71, DD 14%→10.8%, ~€/g 1.64→2.36. Il gate alza SIA
 FULL SIA hold-out (a differenza del solo blend, che barattava un po' di hold-out).
 ## Meccanismo + caveat onesti
 - **Causale**: soglia = percentile espandente della dispersione PASSATA; nessun look-ahead.
 - **Perche' funziona**: tiene XS attivo nei regimi DISPERSI (2025-26, dove gli alt divergono) e flat
  nei bull compatti (2024). L'hold-out 2025-26 e' ad alta dispersione -> il gate concentra
  l'attivita' di XS proprio li' -> hold-out forte. E' il comportamento voluto, ma NB che il salto
  del hold-out riflette anche che il 2025-26 e' stato un regime ad alta dispersione.
 - Caveat XS01 invariati: storia ~2.5 anni; STAT-MODE (book 19 gambe non eseguibile a 2k).
 ## Azione
 `src/portfolio/sleeves.XS_CFG`: aggiunto `disp_pct=30`; engine `_xsec_returns` gatea su dispersione.
 **Portafoglio attivo: TP01 70% + XS01 (blend [30,90] + gate disp p30) 30% — FULL Sh 1.55 / HOLD 1.55
 / DD 4.4%.** 12 test ok. Affinamenti del SEGNALE (blend + gate) hanno funzionato dove l'espansione
 universo no: i margini su XS sono nella struttura del segnale, non nel numero di asset.
@@ -1,62 +0,0 @@
 # 2026-06-19 — Espandere l'universo XS01: PIÙ asset DILUISCONO (i 19 major sono il sweet spot)
 Richiesta: aggiungere altri asset Hyperliquid certificati per rafforzare XS01 (cross-sectional
 momentum). Fatto il lavoro, esito ONESTO: **non rafforza — diluisce.**
 ## Cosa ho fatto
 - Esteso `fetch_hyperliquid.py` a ~54 candidati alt maggiori (mappa Binance auto SYM/USDT, k-prefissi
  esclusi). **52 certificati** (cross-venue 4-11 bps vs Binance, flat 0%, storia 2024+): aggiunti
  ATOM DYDX APE CRV LDO STX GMX SNX BCH COMP WLD UNI TRX FIL RUNE ENA ORDI JUP WIF PYTH FET AR ETC
  ALGO GALA SAND AXS DOT BLUR JTO PENDLE ONDO TAO. Esclusi MKR (delistato HL 2025-09) e FXS
  (migrazione Frax 2026-01) via nuovo gate "ultima barra recente".
 ## Il finding: il cross-section dei 52 è NEGATIVO; i 19 major sono positivi
 Stessa finestra (2024-04 → 2026-06, 807g), mom L*/H10:
 | Universo | k | FULL Sharpe (L30/L60/L90) |
 |---|---|---|
 | **52 asset** | 5 | −0.13 / −0.21 / −0.35 |
 | **52 asset** | 8-12 | tutti negativi (k grande non aiuta) |
 | **19 major** | 5 | +0.30 / +0.36 / **+0.67** (OOS 0.91) |
 I ~33 small/new-cap aggiunti (WIF, JUP, ORDI, PYTH, TAO, GALA, AR, BLUR…) sono idiosincratici/
 mean-reverting: il loro rumore **rovescia** il momentum relativo. Cross-sectional momentum su crypto
 funziona fra i MAJOR liquidi, non sul long tail. Allargare l'universo NON è gratis.
 ## Azione
 - **XS01 resta sui 19 major** (sweet spot già validato: plateau/fee/subset). Lo sleeve
  `_xsec_returns` ora usa una **lista esplicita `XS_UNIVERSE` (19)**, non più glob-all (così
  aggiungere parquet certificati non lo cambia/rompe — avevo inavvertitamente fatto vedere allo
  sleeve 52 asset = negativo).
 - I 52 parquet certificati restano su disco: dato valido per ricerca futura (uno strato diverso —
  es. trend-following multi-asset, o un XS ristretto ai top-liquidità — potrebbe usarli), ma NON XS01.
 - Portafoglio invariato e ripristinato: **TP01 70% + XS01 30%, FULL Sh 1.41 / HOLD 1.15.**
 ## Lezione
 "Più asset = più robusto" è FALSO per il cross-sectional momentum: il long tail di alt piccoli
 diluisce/inverte l'edge. La breadth utile è quella dei major liquidi (corr-strutturata), non il
 numero grezzo.
 ## Tentativo 2: UNIVERSO TOP-LIQUIDITÀ DINAMICO (`xsec_dynuniverse.py`) — anch'esso PEGGIORE
 Provato a selezionare a ogni ribilancio i top-N per dollar-volume 30g (causale) dai 52, poi XS
 momentum fra quelli (adattivo, ragged-aware). Esito:
 | Universo | FULL Sh | OOS25 | anni+ |
 |---|---|---|---|
 | top12 dinamico (L30H10k5) | 0.65 | 0.54 | 67% (2026 −4%) |
 | top15/20/25 dinamico | 0.14-0.38 | ≤0.30 | 33-67% |
 | **fisso-19 major (L30H10k5)** | **0.80** | **1.20** | **100%** |
 | fisso-19 major (L90H10k5) | 0.88 | 0.90 | 100% |
 Contributo: TP01+DYN 70/30 = FULL 1.10 / HOLD 0.60 vs **TP01+XS19 = FULL 1.25 / HOLD 1.15**.
 **Perché fallisce:** la classifica per dollar-volume ammette comunque i MEMECOIN ad alto volume
 (WIF, ORDI, JUP, PEPE...) che hanno volumi enormi ma momentum erratico/mean-reverting →
 diluiscono. **Liquidità ≠ qualità** nelle crypto. I 19 major *curati* (established, corr-strutturati,
 non solo alto volume) restano il sweet spot.
 ## Conclusione
 Né più nomi (52) né top-liquidità dinamico migliorano XS01. **XS01 resta sui 19 major curati**
 (FULL 0.80 / OOS 1.20, 100% anni+). Portafoglio invariato: TP01 70% + XS01 30% (FULL 1.41/HOLD 1.15).
 Per rafforzarlo davvero servirebbe una curatela di QUALITÀ (established majors), che è già ciò che i
 19 sono. Coerente con la disciplina: nessuna espansione senza che migliori il gauntlet. I 52 parquet
 certificati restano per ricerca futura (es. trend multi-asset, dove il long tail non diluisce).
@@ -1,167 +0,0 @@
 # 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).
@@ -1,86 +0,0 @@
 # 2026-06-20 — Correzione estrazione cerbero MCP: il backfill sintetico (vol=0) ingannava la certificazione
 ## Contesto
 Richiesta: "analizza cerbero MCP correggendo l'estrazione dati storici secondo le analisi fatte".
 Le analisi del progetto avevano già fissato un principio — *"storia nativa Hyperliquid solo dal 2024,
 pre-2024 = backfill, volume 0"* — e `fetch_hyperliquid.py` lo gestiva con un floor `START=2024-01-01`.
 **Il floor non basta.**
 ## Il difetto
 `fetch_hl` chiedeva a cerbero MCP `get_historical` dal 2024-01-01 e certificava ogni asset con tre
 gate: **flat-bar** (O==H==L==C), **cross-venue** (mediana |close − Binance| < 60 bps), **recency**.
 Nessuno guardava il **volume**. Risultato: gli asset listati su HL *dopo* lo START passavano come
 PULITO pur essendo in gran parte **backfill sintetico**.
 Ispezione del volume sui parquet (leading run di barre a volume 0):
 | asset | barre | leading vol=0 | primo trade reale | % sintetico |
 |---|---|---|---|---|
 | **AXS** | 902 | **748** | 2026-01-18 | **82.9%** |
 | ALGO | 902 | 338 | 2024-12-04 | 37.5% |
 | SAND | 902 | 338 | 2024-12-04 | 37.5% |
 | AR | 902 | 58 | 2024-02-28 | 6.4% |
 | ETC | 902 | 11 | 2024-01-12 | 1.2% |
 | BTC/ETH + 19 major | 902 | 0 | 2024-01-01 | 0% |
 AXS era **certificato PULITO** (flat 0%, cross-venue 9.5 bps) pur avendo solo ~5 mesi di trading reale.
 ## Verifica diretta su cerbero MCP (token mainnet)
 Interrogato l'endpoint `cerbero-mcp.tielogic.xyz/mcp/tools/get_historical` (bot-tag
 `pythagoras-mainnet`):
 - **BTC**: 902 barre, leading vol=0 = 0, volume reale dal 2024-01-01 (V=699, 2437, 5306…). Nativo. ✓
 - **AXS**: 902 barre, **748 leading vol=0**, primo vol>0 = 2026-01-18. Le barre a volume 0 hanno
  prezzi (O/H/L/C) che **coincidono con Binance**:
  | data | cerbero close | binance close | Δ |
  |---|---|---|---|
  | 2024-01-01 | 9.262 | 9.26 | 2.2 bps |
  | 2024-01-02 | 8.949 | 8.94 | 10.1 bps |
  | 2024-01-03 | 7.937 | 7.95 | 16.4 bps |
 **Diagnosi provata:** cerbero MCP riempie il periodo pre-quotazione con barre **sintetiche — volume 0,
 prezzi copiati da un venue di riferimento (Binance)**. Per questo i vecchi gate venivano ingannati:
 - cross-venue passa → i prezzi *sono* Binance (Δ 1–16 bps);
 - flat passa → le barre non sono flat (hanno movimento di prezzo);
 - ma **volume 0** → su HL quelle candele **non erano negoziabili**. È esattamente il caso v2.0.0
  (edge su un book che non c'era).
 ## Correzione (`scripts/analysis/fetch_hyperliquid.py`)
 1. **Il VOLUME è il rivelatore del backfill** → `trim_backfill()` taglia il run iniziale di barre a
   volume 0; si tiene solo la **serie nativa**.
 2. **Gate storia nativa** `MIN_NATIVE_DAYS=365`: dopo il taglio serve ≥ 1 anno di vita reale →
   scarta chi è troppo corto (AXS, 154 barre reali → fuori).
 3. **Gate vol=0 interno** `INTERIOR_VOL0_MAX=5%`: gap di liquidità oltre il taglio iniziale.
 4. **cross-venue/flat ricalcolati SOLO sulle barre reali** (non più sui sintetici).
 5. **I parquet degli asset scartati vengono rimossi** (disco == set certificato; niente file
   contaminati a riposo).
 ## Risultato
 - Universo certificato: **52 → 51** (AXS scartato).
 - ALGO/SAND (−338 barre), AR (−58), ETC (−11) ripuliti dal backfill → ora start reale corretto.
 - **I 19 major di XS01 hanno 0 backfill → invariati**: la strategia live (`XS_UNIVERSE` esplicito) NON
  è toccata. Verificato: portafoglio 3-way (TP01+XS01+VRP01) gira identico, FULL Sh 1.68 / HOLD 1.67.
 - Re-fetch end-to-end su cerbero reale: 51 PULITO, sweep su tutti i file → 0 backfill residuo.
 ## Nota su una conclusione precedente
 Il diario `2026-06-19-xsec-universe-expansion.md` concludeva "cross-section dei 52 = negativo". Quella
 finestra includeva i sintetici (AXS 83%, ALGO/SAND 37% di barre vol=0 con ritorni non eseguibili): la
 magnitudine del risultato era **in parte un artefatto**. La conclusione qualitativa (il long-tail
 diluisce XS01; i 19 major sono il sweet spot) resta valida, ma il numero netto è 51 e il test andrebbe
 ri-girato sui dati puliti se si volesse riusare quell'universo.
 ## Lezione
 `flat` + cross-venue **non bastano** a certificare un feed che fa backfill copiando un altro venue: il
 backfill è plausibile sui prezzi proprio perché è copiato. Il **volume** (=liquidità reale) è il gate
 che mancava. Coerente con la regola di prim'ordine v2.0.0: certificare il dato — anche il *volume*,
 non solo il prezzo — prima della strategia.
 File: `scripts/analysis/fetch_hyperliquid.py`. Universo: `data/raw/hl_*_1d.parquet` (51, serie native).
@@ -1,93 +0,0 @@
 # 2026-06-20 — Analisi strategie FinanceOld + VRP v2 (defined-risk + gate IV-rank)
 ## Contesto
 Richiesta: analizzare le strategie in `../FinanceOld`, provare a migliorarle, testarle su dati storici.
 Quattro progetti esaminati. Verdetto di **backtestabilità onesta** sui dati certificati (BTC/ETH
 Deribit mainnet + DVOL):
 | Progetto | Strategia | Backtestabile sui dati certi? |
 |---|---|---|
 | **FundingRateArbitrage** | Spread funding cross-exchange (perp-perp, spot-hedge) | ❌ Nessun dato funding storico nel repo (solo `exchange_settings.json`). Edge = differenza cross-venue, non ricostruibile. |
 | **Polybot** | Latency-arb Polymarket (BS digital-option) + sure-bet delta-neutral | ❌ `dataVPS/collector.db` (645MB) ha solo **~3 giorni** di `poly_books`+`funding`, e la tabella `ticks` (prezzi perp = cuore dell'edge) è **corrotta** ("database disk image is malformed"). L'edge è la latenza: non riproducibile su barre OHLC comunque. |
 | **OptionSpalping** (→Cerbero) | LLM autonomo su opzioni Deribit + perp Hyperliquid | ⚠️ È un agente LLM, non una regola meccanica. Il *concetto* (income short-vol su Deribit) è testabile. |
 | **OptionsAgent** | **Bear Call Spread + Long VIX hedge** su IWM, con 5 gate d'ingresso | ✅ Il *concetto* (vendi premio rischio-definito, incassa VRP, gate su IV-rank/regime) mappa direttamente sul nostro `options_vrp_lab.py`. |
 → Scelta operatore: **focus VRP opzioni**. L'unico filone con dati veri + metodologia onesta.
 ## Baseline (options_vrp_lab.py, ora con fee)
 Vendita put NUDA settimanale delta -0.28, premio BS su DVOL reale. f = premio_reale/modellato.
 - `f=1.0` (conservativo): **FULL Sh 0.78, DD 33%, worst-week -16.6%, HOLD-OUT Sh -0.25** → muore OOS.
 - Il rischio è la **CODA**: worst-week su LUNA (2022-06), crash 2021-05. Anno 2022 = -9%.
 ## VRP v2 — 3 idee di OptionsAgent portate nel framework
 Nuovo script `scripts/research/options_vrp_v2.py`. Tutto **causale** (strike/premio/gate da dati
 ≤ sell-date; payoff a scadenza sui prezzi certificati). Fee opzioni Deribit modellate (12.5% del
 premio netto per round-trip = cap del fee reale). Capitale = strike corto (cash-secured) per
 entrambe le strutture → DD/worst comparabili.
 1. **Rischio definito (PUT CREDIT SPREAD)** — vendi put -0.28, COMPRI put -0.10. Il long wing
   **cappa la coda per costruzione**: worst-week -16.6% → **-7.4%**, DD 33% → 21%, Sh 0.78 → 0.99.
 2. **Gate IV-RANK > 0.30** (cond. d'ingresso di OptionsAgent) — vendi vol solo quando ricca
   (percentile espandente causale di DVOL). Trada il **58%** delle settimane → **Sh 1.35** e
   ribalta **HOLD-OUT da -0.25 a +0.28**. È l'alpha vero: il filtro di regime, non la struttura.
 3. **Crash-skip IV-rank > 0.90** (NO-GO, come "VIX>35" di OptionsAgent) — marginale da solo.
 4. **Gate VRP>0** (DVOL>RV30 causale) — marginale (il VRP è >0 il 78% del tempo, poco selettivo).
 ### Risultati chiave (book 50/50 BTC+ETH, f=1.0 conservativo)
 | Config | FULL Sh | DD | worst-wk | HOLD-OUT Sh | attivo |
 |---|---|---|---|---|---|
 | naked (baseline) | 0.78 | 33% | -16.6% | **-0.25** | 100% |
 | spread | 0.99 | 21% | -7.4% | -0.26 | 100% |
 | spread + ivr30 | **1.35** | 14% | -7.4% | **+0.28** | 58% |
 | **COMBO** (spread+vrp+ivr30+crashskip) | 1.10 | 12% | -7.4% | **+0.60** | 41% |
 COMBO f=1.0 per-anno: 2021 +26%, 2022 **-6%**, 2023 +2%, 2024 +18%, 2025 -0%, 2026 +5%
 (il 2022, anno-crash che dimezzava il nudo, è quasi piatto: la coda è tagliata).
 A `f=1.29` (skew reale misurato in regime calmo) la COMBO fa FULL Sh 1.87 / HOLD 1.45 / DD 9%.
 ### Contributo al portafoglio (COMBO f=1.0 vs TP01)
 - Corr settimanale **+0.07** (scorrelato, come il VRP nudo).
 - TP01 70% + OPT 30% → Sh **1.00** (TP01 solo 0.73), DD **7%**.
 - TP01 50% + OPT 50% → Sh **1.19**, DD 7%.
 ## Conclusione onesta
 Le idee di OptionsAgent **migliorano davvero** lo sleeve VRP, in modo OOS-robusto:
 - la **struttura defined-risk** taglia la coda (worst -16.6%→-7.4%, DD -19pt) → meno dipendenza dal
  f di stress, che era il rischio non catturato del lead nudo;
 - il **gate IV-rank** è l'alpha: ribalta l'HOLD-OUT da negativo a positivo vendendo solo vol ricca.
 Resta un **lead, non un deploy**: premio MODELLATO su DVOL ATM (skew non esplicito), book a 1d, e
 serve la catena reale (cerbero-bite) per il f di stress in un crash. Ma è un miglioramento netto,
 quantificato e onesto, del miglior lead income che avevamo. Prossimo passo: rivalutare il f di stress
 quando cerbero-bite cattura un crash, e validare lo skew reale sul long wing (-0.10).
 Script: `scripts/research/options_vrp_v2.py`. Baseline: `scripts/research/options_vrp_lab.py`.
 ## Integrazione come sleeve (VRP01)
 La COMBO è stata integrata nel portafoglio come **VRP01** (`src/portfolio/sleeves._vrp_combo_returns`,
 `vrp_sleeve()`). Implementazione self-contained in `src/` (niente import da `scripts/`): pricing BS +
 strike-from-delta + gate causali inline, DVOL da `data/raw/dvol_*.parquet`.
 **Settimanale → giornaliero (onesto):** il rendimento settimanale è piazzato sul **giorno di
 scadenza**, 0.0 sugli altri giorni dello span. Questo PRESERVA lo Sharpe annualizzato (niente
 smoothing che gonfierebbe il daily Sharpe) e tiene lo sleeve presente ogni giorno → peso costante
 nell'outer-join del portafoglio. Verificato: lo sleeve daily replica i numeri settimanali
 (FULL Sh 1.09, HOLD 0.60, DD 12%), corr daily vs TP01 = +0.01.
 **Pesi (per evidenza, engine reale):** TP01+VRP01 monotòno fino al 40% VRP (FULL 1.30→1.55,
 HOLD 0.31→0.52, DD fermo 14%). Essendo VRP un lead MODELLATO (non deploy pieno), non lo sovrappeso:
 registry = **TP01 0.55 / XS01 0.25 / VRP01 0.20** (TP01 resta maggioranza, l'unico deployable pieno).
 La validazione 3-way completa richiede i dati Hyperliquid (XS01, gitignored, token Cerbero) → gira
 locale con `scripts/portfolio/run_portfolio.py`.
 Test: `tests/test_vrp_sleeve.py` (5 pass: monotonìa BS, ordering strike, determinismo+griglia
 giornaliera, gate riducono l'attività, coda tagliata <-15%).
@@ -1,109 +0,0 @@
 """EVALUATOR STANDARD per i segnali della ricerca multi-agente (Fase frattale, v2.0.0).
 Ogni agente scrive SOLO una funzione `signal(df, asset, tf) -> np.ndarray` (posizione per barra
 in [-1,1], decisa entro close[i]) in un file. Questo evaluator la valuta in modo UNIFORME e ONESTO
 sull'harness research_lab, e — cruciale — esegue un GUARD ANTI-LOOK-AHEAD automatico: ricalcola il
 segnale su prefissi del df e verifica che pos[i] non dipenda da barre future (leak>0 = sospetto).
    uv run python scripts/analysis/eval_signal.py <signal_file.py> <BTC|ETH> <5m|15m|1h> [--holdout]
 Stampa una riga "RESULT_JSON:{...}" con tutte le metriche (gli agenti riportano quei campi esatti).
 """
 from __future__ import annotations
 import sys
 import json
 import importlib.util
 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 scripts.analysis.research_lab import backtest, buy_hold, mc_pvalue, load_tf, ts, _net_series, VAL_START, HOLDOUT_START
 def load_signal(path):
    spec = importlib.util.spec_from_file_location("usig", path)
    m = importlib.util.module_from_spec(spec)
    spec.loader.exec_module(m)
    if not hasattr(m, "signal"):
        raise AttributeError("il file non definisce signal(df, asset, tf)")
    return m.signal
 def causality_guard(signal, df, asset, tf, k=12):
    """Ricalcola il segnale su prefissi df[:i+1] e confronta pos[i] col run completo.
    Se differiscono -> il segnale usa dati FUTURI (look-ahead). Ritorna #violazioni (0 = pulito)."""
    full = np.asarray(signal(df, asset, tf), float)
    n = len(df)
    if len(full) != n:
        return -1
    rng = np.random.default_rng(0)
    idx = rng.integers(int(n * 0.6), n - 1, size=k)
    bad = 0
    for i in idx:
        try:
            p = np.asarray(signal(df.iloc[:i + 1].copy(), asset, tf), float)
        except Exception:
            bad += 1; continue
        if len(p) != i + 1 or not np.isclose(np.nan_to_num(p[i]), np.nan_to_num(full[i]), atol=1e-6):
            bad += 1
    return bad
 def main():
    args = sys.argv[1:]
    holdout = "--holdout" in args
    args = [a for a in args if a != "--holdout"]
    sigfile, asset, tf = args[0], args[1].upper(), args[2]
    res = {"asset": asset, "tf": tf, "sigfile": sigfile}
    try:
        signal = load_signal(sigfile)
        df = load_tf(asset, tf)
        pos = np.asarray(signal(df, asset, tf), float)
        res["n"] = int(len(df))
        res["len_ok"] = bool(len(pos) == len(df))
        if not res["len_ok"]:
            res["error"] = f"len(pos)={len(pos)} != len(df)={len(df)}"
            print("RESULT_JSON:" + json.dumps(res)); return
        res["finite"] = bool(np.isfinite(np.nan_to_num(pos, nan=0.0)).all())
        res["leak"] = int(causality_guard(signal, df, asset, tf))
        full = backtest(df, pos, tf)
        oos = backtest(df, pos, tf, lo=VAL_START, hi=HOLDOUT_START)
        bh = buy_hold(df, tf)
        _, p, _, _ = mc_pvalue(df, pos, tf, n=250)
        res.update(
            implemented=True,
            full_sharpe=round(full.sharpe, 3), full_ret=round(full.ret, 3), full_dd=round(full.maxdd, 3),
            oos_sharpe=round(oos.sharpe, 3), bh_sharpe=round(bh.sharpe, 3),
            gross_sharpe=round(backtest(df, pos, tf, fee_rt=0.0).sharpe, 3),
            fee02_sharpe=round(backtest(df, pos, tf, fee_rt=0.002).sharpe, 3),
            turnover=round(full.ntrades, 1), exposure=round(full.exposure, 3),
            null_p=round(p, 4),
            beats_bh=bool(full.sharpe > bh.sharpe and oos.sharpe > 0),
        )
        # breadth per-anno (pre-hold-out): % anni positivi, anni rossi consecutivi
        net, _, _, _ = _net_series(df, pos)
        s = pd.Series(net, index=ts(df))
        s = s[s.index < pd.Timestamp(HOLDOUT_START, tz="UTC")]
        yr = {int(y): float((1 + g).prod() - 1) for y, g in s.groupby(s.index.year)}
        vals = list(yr.values())
        max_consec_red = 0; cur = 0
        for v in vals:
            cur = cur + 1 if v < 0 else 0
            max_consec_red = max(max_consec_red, cur)
        res["per_year_preho"] = {y: round(v, 3) for y, v in yr.items()}
        res["pct_years_pos"] = round(sum(v > 0 for v in vals) / len(vals), 2) if vals else 0.0
        res["max_consec_red_years"] = int(max_consec_red)
        if holdout:
            ho = backtest(df, pos, tf, lo=HOLDOUT_START)
            res["holdout_sharpe"] = round(ho.sharpe, 3)
            res["holdout_ret"] = round(ho.ret, 3)
            res["holdout_dd"] = round(ho.maxdd, 3)
    except Exception as e:
        res["implemented"] = False
        res["error"] = f"{type(e).__name__}: {str(e)[:200]}"
    print("RESULT_JSON:" + json.dumps(res))
 if __name__ == "__main__":
    main()
@@ -1,132 +0,0 @@
 """FETCH + CERTIFY universo Hyperliquid (Cerbero MCP MAINNET) — espansione cross-sectional.
 Hyperliquid (via cerbero-mcp mainnet) offre ~230 perp liquidi, ma storia nativa REALE solo dal
 2024 (pre-2024 = backfill, volume 0). Qui scarico un set liquido a 1d (2024+), e CERTIFICO ogni
 asset come BTC/ETH: cross-venue vs Binance (realismo) + flat-bar + VOLUME (liquidita'). Scrivo SOLO
 i puliti in data/raw/hl_<sym>_1d.parquet (namespace dedicato, NON mischiato col Deribit BTC/ETH).
 Disciplina: Cerbero ci ha gia' bruciato (testnet) -> niente fiducia, solo certificazione.
 CORREZIONE estrazione (2026-06-20, "analisi fatte"): il floor START=2024-01-01 NON basta. Cerbero
 restituisce BACKFILL SINTETICO (volume==0, ma prezzi copiati da un venue di riferimento -> matchano
 Binance e NON sono flat) per il periodo PRIMA che l'asset quotasse davvero su Hyperliquid. Cosi'
 asset listati a meta'/fine 2024+ passavano cross-venue+flat ed erano certificati PULITO pur essendo
 in gran parte sintetici (es. AXS 83% backfill: trading reale solo da 2026-01; ALGO/SAND 37%). E' lo
 stesso errore v2.0.0 (edge su un book che non c'era). Fix: (1) il VOLUME e' il rivelatore di backfill
 -> si TAGLIA il run iniziale di barre a volume 0 e si tiene solo la serie NATIVA; (2) gate su storia
 nativa minima (>= MIN_NATIVE_DAYS reali) -> scarta chi e' troppo corto dopo il taglio; (3) gate su
 volume-0 INTERNO (gap di liquidita') oltre il taglio iniziale; (4) cross-venue/flat ricalcolati SOLO
 sulle barre reali; (5) i parquet degli asset scartati vengono RIMOSSI (disco == set certificato).
    uv run python scripts/analysis/fetch_hyperliquid.py
 """
 from __future__ import annotations
 import sys, time
 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, requests, ccxt
 RAW = PROJECT_ROOT / "data" / "raw"
 START = "2024-01-01"; END = pd.Timestamp.now("UTC").strftime("%Y-%m-%d")   # dinamico (refresh giornaliero)
 MIN_NATIVE_DAYS = 365     # storia NATIVA reale minima (post-taglio backfill) per entrare nell'universo
 INTERIOR_VOL0_MAX = 5.0   # % max di barre a volume 0 DOPO il taglio iniziale (gap di liquidita' interni)
 # UNIVERSO ESTESO: alt liquidi noti su Hyperliquid (mappa Binance auto = SYM/USDT). Il gate di
 # certificazione (cross-venue + liquidita' + flat) scarta i non-conformi. k-prefissi esclusi
 # (scaling 1000x complica il cross-venue). MATIC morto escluso.
 SYMS = ["BTC","ETH","SOL","BNB","XRP","DOGE","AVAX","LINK","LTC","ADA","ARB","OP","SUI","APT",
        "INJ","TIA","SEI","NEAR","AAVE","ATOM","DYDX","APE","CRV","LDO","STX","GMX","SNX","BCH",
        "COMP","MKR","WLD","UNI","TRX","FIL","RUNE","ENA","ORDI","JUP","WIF","PYTH","FET","AR",
        "ETC","ALGO","GALA","SAND","AXS","DOT","FXS","BLUR","JTO","PENDLE","ONDO","TAO"]
 BINANCE = {s: f"{s}/USDT" for s in SYMS}
 def _h():
    env={}
    for ln in open(PROJECT_ROOT/".env.mainnet"):
        ln=ln.strip()
        if ln and not ln.startswith("#") and "=" in ln: k,v=ln.split("=",1); env[k]=v.strip()
    return {"Authorization":f"Bearer {env['CERBERO_TOKEN']}","X-Bot-Tag":env.get('CERBERO_BOT_TAG','fetch'),"Content-Type":"application/json"}
 def fetch_hl(sym, H, interval="1d"):
    r=requests.post("https://cerbero-mcp.tielogic.xyz/mcp/tools/get_historical",
        headers=H, json={"exchange":"hyperliquid","instrument":sym,"interval":interval,
                         "start_date":START,"end_date":END}, timeout=60)
    c=r.json().get("candles",[])
    if not c: return pd.DataFrame()
    df=pd.DataFrame(c)[["timestamp","open","high","low","close","volume"]]
    return df.drop_duplicates("timestamp").sort_values("timestamp").reset_index(drop=True)
 def binance_daily(sym_b, start_ms, end_ms):
    ex=ccxt.binance({"enableRateLimit":True})
    out={}; since=start_ms
    while since<=end_ms:
        try: r=ex.fetch_ohlcv(sym_b,"1d",since=since,limit=500)
        except Exception: break
        r=[x for x in r if x[0]>=since]
        if not r: break
        for x in r:
            if start_ms<=x[0]<=end_ms and x[4]: out[int(x[0])]=float(x[4])
        nxt=int(r[-1][0])+86400000
        if nxt<=since: break
        since=nxt
    return pd.Series(out)
 def trim_backfill(df):
    """Taglia il run INIZIALE di barre a volume 0 (= backfill sintetico pre-quotazione su HL).
    Ritorna (serie_nativa, n_barre_tagliate). Il volume e' il rivelatore: il backfill copia i
    prezzi da un venue di riferimento (non flat, matcha Binance) ma ha volume 0."""
    vol = df["volume"].to_numpy()
    lead = int(np.argmax(vol > 0)) if (vol > 0).any() else len(df)
    return df.iloc[lead:].reset_index(drop=True), lead
 def main():
    H=_h()
    print("="*100); print("  FETCH + CERTIFY Hyperliquid 1d (Cerbero mainnet) — cross-venue + flat + VOLUME (no backfill)"); print("="*100)
    print(f"  {'sym':<6}{'reali':>6}{'bfill':>6}{'start_reale':>13}{'flat%':>7}{'vol0%':>7}{'med_bps':>9}{'>1%':>7}{'verdetto':>14}")
    certified=[]
    for s in SYMS:
        path = RAW/f"hl_{s.lower()}_1d.parquet"
        raw=fetch_hl(s,H)
        if raw.empty:
            print(f"  {s:<6}  vuoto"); path.unlink(missing_ok=True); continue
        # --- CORREZIONE: taglia il backfill sintetico (volume 0 iniziale), tieni la serie nativa ---
        df, n_bfill = trim_backfill(raw)
        if df.empty:
            print(f"  {s:<6}  tutto backfill (vol0) -> scarta"); path.unlink(missing_ok=True); continue
        ts=pd.to_datetime(df["timestamp"],unit="ms",utc=True)
        flat=((df.open==df.high)&(df.high==df.low)&(df.low==df.close)).mean()*100
        vol0=(df["volume"].to_numpy()==0).mean()*100   # gap di liquidita' INTERNI (post-taglio)
        # cross-venue vs Binance USDT (daily close) — SOLO sulle barre reali
        ref=binance_daily(BINANCE[s], int(df["timestamp"].iloc[0]), int(df["timestamp"].iloc[-1]))
        a=df.set_index("timestamp")["close"]
        m=pd.concat([a.rename("a"),ref.rename("b")],axis=1,join="inner").dropna()
        if len(m)>5:
            bps=(m["a"]-m["b"]).abs()/m["b"]*1e4
            med=bps.median(); g1=(bps>100).mean()*100
        else: med=g1=float("nan")
        # gate "delistato/migrato": l'ultima barra dev'essere recente (entro ~21g da END),
        # altrimenti l'asset tronca l'universo cross-sectional (es. MKR fermo a 2025-09, FXS 2026-01).
        recent = (pd.Timestamp(END, tz="UTC") - ts.iloc[-1]) <= pd.Timedelta("21D")
        # gate storia NATIVA: dopo il taglio dev'esserci abbastanza vita reale (es. AXS quotato 2026-01 -> scarta)
        native_days = (ts.iloc[-1] - ts.iloc[0]).days
        enough = native_days >= MIN_NATIVE_DAYS
        clean = (not np.isnan(med)) and med<60 and g1<3 and flat<5 and vol0<INTERIOR_VOL0_MAX and recent and enough
        if clean: v="PULITO"
        elif not enough: v=f"corto<{MIN_NATIVE_DAYS}g"
        else: v="scarta"
        print(f"  {s:<6}{len(df):>6}{n_bfill:>6}{str(ts.iloc[0].date()):>13}{flat:>6.1f}%{vol0:>6.1f}%{med:>9.1f}{g1:>6.1f}%{v:>14}")
        if clean:
            df.to_parquet(path, index=False); certified.append(s)
        else:
            path.unlink(missing_ok=True)   # disco == set certificato (niente parquet contaminati a riposo)
    print(f"\n  CERTIFICATI ({len(certified)}): {certified}")
    print("  Scritti in data/raw/hl_<sym>_1d.parquet (namespace dedicato, SERIE NATIVA senza backfill).")
 if __name__=="__main__":
    main()
@@ -1,121 +0,0 @@
 """ANALISI OPTIONS per BTC/ETH — onesta sui dati REALI disponibili (cerbero-bite mainnet).
 Dati: Old/data/options (chain per-strike + dvol + market_snapshots). Finestra ~2026-05-01→06-11
 (~6 settimane, REGIME UNICO calmo). NON si può validare OOS un edge su opzioni qui; si possono
 MISURARE i livelli reali (VRP, premi put, skew, liquidità) e ragionare sull'USO delle opzioni
 per il book BTC/ETH certificato. cerbero-bite è ancora vivo -> la fonte continua ad accumulare.
    uv run python scripts/analysis/options_analysis.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
 OPT = PROJECT_ROOT / "Old" / "data" / "options"
 def load(name):
    return pd.read_parquet(OPT / name)
 def market_snapshots_analysis():
    print("=" * 90)
    print("  (1) MARKET SNAPSHOTS — VRP, DVOL, funding, dealer-gamma (livelli reali)")
    print("=" * 90)
    ms = load("market_snapshots.parquet")
    t = pd.to_datetime(ms["timestamp"], utc=True, errors="coerce")
    print(f"  copertura: {t.min()} -> {t.max()}  ({len(ms)} righe)")
    for a in ("BTC", "ETH"):
        d = ms[ms["asset"] == a].dropna(subset=["iv_minus_rv"])
        if len(d) == 0:
            print(f"  {a}: nessun dato"); continue
        vrp = d["iv_minus_rv"].astype(float)
        dvol = d["dvol"].astype(float)
        rv = d["realized_vol_30d"].astype(float)
        fund = d["funding_perp_annualized"].astype(float) if "funding_perp_annualized" in d else pd.Series([np.nan])
        gam = d["dealer_net_gamma"].astype(float) if "dealer_net_gamma" in d else pd.Series([np.nan])
        print(f"\n  {a}  (n={len(d)})")
        print(f"    VRP (IV-RV):   media {vrp.mean():+.1f}  mediana {vrp.median():+.1f}  "
              f">0 nel {100*(vrp>0).mean():.0f}% del tempo   [IV-RV in punti di vol annua]")
        print(f"    DVOL:          media {dvol.mean():.1f}  range [{dvol.min():.1f}, {dvol.max():.1f}]")
        print(f"    Realized30d:   media {rv.mean():.1f}")
        print(f"    Funding perp:  media {fund.mean():+.1f}% annuo")
        if gam.notna().any():
            print(f"    Dealer net-γ:  >0 nel {100*(gam>0).mean():.0f}% del tempo (>0 = dealer long gamma = mean-rev)")
 def chain_analysis(asset):
    print("\n" + "=" * 90)
    print(f"  (2) CHAIN {asset} — premi put protettivi, skew, liquidità (livelli reali)")
    print("=" * 90)
    ch = load(f"{asset.lower()}_chain.parquet")
    for col in ("strike", "bid", "ask", "mid", "iv", "delta", "gamma"):
        if col in ch:
            ch[col] = pd.to_numeric(ch[col], errors="coerce")
    ch["option_type"] = ch["option_type"].astype(str)
    dv = load("dvol_history.parquet")
    dv = dv[dv["asset"] == asset][["timestamp", "spot"]].copy()
    dv["spot"] = pd.to_numeric(dv["spot"], errors="coerce")
    # timestamp -> datetime UTC nativo (sono datetime64[tz], NON ms int: to_numeric li romperebbe)
    ch["t"] = pd.to_datetime(ch["timestamp"], utc=True, errors="coerce")
    dv["t"] = pd.to_datetime(dv["timestamp"], utc=True, errors="coerce")
    ch = ch.dropna(subset=["t"]).sort_values("t").reset_index(drop=True)
    dv = dv.dropna(subset=["t", "spot"]).sort_values("t").reset_index(drop=True)
    # spot causale per timestamp della chain (merge_asof nearest, tolleranza 1h)
    ch = pd.merge_asof(ch, dv[["t", "spot"]], on="t", direction="nearest",
                       tolerance=pd.Timedelta("1h"))
    ch = ch.dropna(subset=["spot", "mid", "strike"])
    # days-to-expiry
    exp = pd.to_datetime(ch["expiry"], utc=True, errors="coerce")
    ch["dte"] = (exp - ch["t"]).dt.total_seconds() / 86_400.0
    ch = ch[(ch["dte"] > 0.5) & (ch["dte"] < 90)]
    ch["money"] = ch["strike"] / ch["spot"]
    ch["prem_pct"] = ch["mid"] * 100          # mid è in COIN (frazione del sottostante) -> %-del-notional
    # NB: iv è GIÀ in percento (35.94 = 35.94%, coerente col DVOL ~40) -> non riscalare
    ch["spread_pct"] = (ch["ask"] - ch["bid"]) / ch["mid"].replace(0, np.nan) * 100
    puts = ch[ch["option_type"].str.lower().str.startswith("p")]
    calls = ch[ch["option_type"].str.lower().str.startswith("c")]
    def band(df, mlo, mhi, dlo, dhi):
        s = df[(df["money"] >= mlo) & (df["money"] <= mhi) & (df["dte"] >= dlo) & (df["dte"] <= dhi)]
        return s
    print("  PUT protettive — premio reale (mid/spot) e liquidità per tenor/moneyness:")
    print(f"    {'tenor':<10s}{'moneyness':<14s}{'premio%':>9s}{'/mese%':>9s}{'spread%':>9s}{'n':>7s}{'strike?':>9s}")
    for dlo, dhi, tn in [(5, 12, "settim."), (18, 45, "mensile")]:
        for mlo, mhi, ml in [(0.97, 1.03, "ATM"), (0.88, 0.93, "~10% OTM"), (0.83, 0.88, "~15% OTM")]:
            s = band(puts, mlo, mhi, dlo, dhi)
            if len(s) == 0:
                print(f"    {tn:<10s}{ml:<14s}{'—':>9s}{'—':>9s}{'—':>9s}{0:>7d}{'NO':>9s}")
                continue
            prem = s["prem_pct"].median()
            permonth = prem * 30.0 / s["dte"].median()
            print(f"    {tn:<10s}{ml:<14s}{prem:>8.2f}%{permonth:>8.2f}%{s['spread_pct'].median():>8.1f}%"
                  f"{len(s):>7d}{'SI':>9s}")
    # skew: IV put 10% OTM vs IV call 10% OTM (stesso tenor mensile)
    pv = band(puts, 0.88, 0.93, 12, 50)["iv"].median()
    cv = band(calls, 1.07, 1.12, 12, 50)["iv"].median()
    atmv = band(ch, 0.98, 1.02, 12, 50)["iv"].median()
    if pd.notna(pv) and pd.notna(cv):
        print(f"  SKEW: IV put 10%OTM {pv:.0f}% vs call 10%OTM {cv:.0f}% vs ATM {atmv:.0f}%"
              f"  -> skew put {pv-cv:+.0f} pt vol (>0 = put care = paura del crash prezzata)")
 def main():
    market_snapshots_analysis()
    for a in ("BTC", "ETH"):
        chain_analysis(a)
    print("\n" + "=" * 90)
    print("  NB: finestra ~6 settimane, REGIME UNICO calmo -> livelli REALI misurabili, ma NESSUN")
    print("  edge su opzioni è validabile OOS qui. Vedi commento finale.")
    print("=" * 90)
 if __name__ == "__main__":
    main()
@@ -1,158 +0,0 @@
 """FASE 1 — triage dei 2 superstiti su BTC/ETH, sull'harness onesto (research_lab).
 Sul feed pulito solo SH01 (shape-ML) e frammenti HONEST mostravano segnale residuo. Delle
 HONEST solo DIP (dip-reversion) è testabile su BTC/ETH (TR01/ROT02 richiedono alt esclusi).
 Qui ri-implemento DIP e SH01-shape-ML come SERIE DI POSIZIONE e li passo ai gate onesti
 (FULL/OOS-VAL, vs buy&hold, null p-value, sweep fee, griglia). Hold-out 2025+ resta BLOCCATO.
    uv run python scripts/analysis/phase1_survivors.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 sklearn.linear_model import LogisticRegression
 from sklearn.preprocessing import StandardScaler
 from src.data.downloader import load_data
 from scripts.analysis.research_lab import (
    backtest, buy_hold, mc_pvalue, report, VAL_START, HOLDOUT_START, FEE_RT,
 )
 # ----------------------------- DIP reversion (long-only) -----------------------------
 def dip_signal(df, n=50, k=2.0, z_exit=0.0, max_bars=72):
    """Long-only: entra (pos=1) quando lo z-score causale del prezzo vs MA(n) <= -k (dip),
    esce quando z>=z_exit o dopo max_bars. Decisione a close[i] (z[i] usa close[i]), guadagna
    close[i]->close[i+1]. Niente fill su estremi di candela."""
    c = df["close"].values.astype(float)
    s = pd.Series(c)
    ma = s.rolling(n).mean().values
    sd = s.rolling(n).std().values
    z = np.where(sd > 0, (c - ma) / sd, np.nan)
    pos = np.zeros(len(c))
    inpos = False
    held = 0
    for i in range(len(c)):
        if not inpos:
            if not np.isnan(z[i]) and z[i] <= -k:
                inpos, held = True, 0
                pos[i] = 1.0
        else:
            held += 1
            if (not np.isnan(z[i]) and z[i] >= z_exit) or held >= max_bars:
                inpos = False           # esce al close[i]: pos[i]=0
            else:
                pos[i] = 1.0
    return pos
 # ----------------------------- SH01 shape-ML (walk-forward) -----------------------------
 def _shape_features(df, W):
    """~12 feature di FORMA causali per barra, dalla finestra che termina a i (usa solo <=i)."""
    o = df["open"].values.astype(float); h = df["high"].values.astype(float)
    l = df["low"].values.astype(float);  c = df["close"].values.astype(float)
    s = pd.Series(c)
    ret1 = s.pct_change()
    rng = (h - l) / np.where(c > 0, c, np.nan)
    body = (c - o) / np.where(h - l > 0, h - l, np.nan)
    up_sh = (h - np.maximum(o, c)) / np.where(h - l > 0, h - l, np.nan)
    dn_sh = (np.minimum(o, c) - l) / np.where(h - l > 0, h - l, np.nan)
    # RSI(14)
    d = s.diff()
    gain = d.clip(lower=0).rolling(14).mean()
    loss = (-d.clip(upper=0)).rolling(14).mean()
    rsi = 100 - 100 / (1 + gain / loss.replace(0, np.nan))
    hi_w = pd.Series(h).rolling(W).max(); lo_w = pd.Series(l).rolling(W).min()
    feat = {
        "mom_w": s / s.shift(W) - 1.0,                         # rendimento sulla finestra
        "mom_half": s / s.shift(W // 2) - 1.0,                 # accelerazione
        "vol_w": ret1.rolling(W).std(),
        "rsi": rsi / 100.0,
        "ma_dist": (c - s.rolling(W).mean()) / s.rolling(W).std(),
        "pos_in_range": (c - lo_w) / (hi_w - lo_w).replace(0, np.nan),  # dove sta il close nel range W
        "range": pd.Series(rng).rolling(3).mean(),
        "body": pd.Series(body).rolling(3).mean(),
        "up_shadow": pd.Series(up_sh).rolling(3).mean(),
        "dn_shadow": pd.Series(dn_sh).rolling(3).mean(),
        "ret1": ret1,
        "skew_w": ret1.rolling(W).skew(),
    }
    X = pd.DataFrame(feat).values
    return X
 def shape_ml_signal(df, W=24, H=12, th=0.55, refit=750, warmup=3000, long_short=True):
    """LogisticRegression walk-forward sulla forma. Label = segno del rendimento a H barre.
    Al tempo di decisione i si allena SOLO su campioni j con esito già realizzato (j+H <= i):
    strettamente causale, nessun leak. Rifit ogni `refit` barre (velocità). pos = +1 se
    P(up)>th, -1 se P(up)<1-th (long_short), altrimenti 0."""
    c = df["close"].values.astype(float)
    n = len(c)
    X = _shape_features(df, W)
    fwd = np.full(n, np.nan)
    fwd[:n - H] = c[H:] / c[:n - H] - 1.0
    y = (fwd > 0).astype(float)
    valid = ~np.isnan(X).any(axis=1)
    pos = np.zeros(n)
    model = scaler = None
    start = max(warmup, W + H + 200)
    for i in range(start, n):
        if model is None or (i - start) % refit == 0:
            # campioni di training: feature valide E label realizzata entro i (j+H <= i)
            tr = np.where(valid & (np.arange(n) + H <= i) & (np.arange(n) >= W))[0]
            tr = tr[tr < i - H]
            if len(tr) >= 500 and len(np.unique(y[tr])) == 2:
                scaler = StandardScaler().fit(X[tr])
                model = LogisticRegression(max_iter=200, C=1.0).fit(scaler.transform(X[tr]), y[tr])
        if model is not None and valid[i]:
            p_up = float(model.predict_proba(scaler.transform(X[i:i + 1]))[0, 1])
            pos[i] = 1.0 if p_up > th else (-1.0 if (long_short and p_up < 1 - th) else 0.0)
    return pos
 # ----------------------------------- run -----------------------------------
 def main():
    TF = "1h"
    print("=" * 90)
    print(f"  FASE 1 — triage superstiti su BTC/ETH {TF} | netto fee 0.10% RT | hold-out {HOLDOUT_START}+ BLOCCATO")
    print("=" * 90)
    data = {a: load_data(a, TF) for a in ("BTC", "ETH")}
    # ---------- DIP: griglia robustezza (plateau?) ----------
    print("\n" + "#" * 90)
    print("  DIP reversion (long-only) — griglia FULL Sharpe (plateau = robusto, picco = overfit)")
    print("#" * 90)
    GRID = [(n, k) for n in (30, 50, 100) for k in (1.5, 2.0, 2.5)]
    for a in ("BTC", "ETH"):
        df = data[a]
        print(f"\n  {a}: " + "  ".join(
            f"n{n}k{k}→{backtest(df, dip_signal(df, n=n, k=k), TF).sharpe:>5.2f}" for n, k in GRID))
    # report onesto sulla config centrale
    for a in ("BTC", "ETH"):
        report(f"DIP {a} (n50 k2.0)", data[a], dip_signal(data[a], n=50, k=2.0), TF)
    # ---------- SH01 shape-ML: config record + paio di varianti ----------
    print("\n" + "#" * 90)
    print("  SH01 shape-ML (walk-forward LogReg) — long/short")
    print("#" * 90)
    for a in ("BTC", "ETH"):
        df = data[a]
        pos = shape_ml_signal(df, W=24, H=12, th=0.55, long_short=True)
        report(f"SH-ML {a} (W24 H12 th.55 L/S)", df, pos, TF)
        # variante long-only (meno fee)
        pos_lo = shape_ml_signal(df, W=24, H=12, th=0.55, long_short=False)
        report(f"SH-ML {a} (W24 H12 th.55 LONG-only)", df, pos_lo, TF)
    print("\n" + "=" * 90)
    print("  VERDETTO: un edge è REALE solo se FULL e OOS-VAL Sharpe > 0, regge il sweep fee,")
    print("  e BATTE il null (p<0.05). Altrimenti = rumore, si chiude.")
    print("=" * 90)
 if __name__ == "__main__":
    main()
@@ -1,221 +0,0 @@
 """FASE 2 — esplorazione larga per famiglie su BTC/ETH, harness onesto (research_lab).
 Famiglie (serie di posizione, causali, netto fee, vs buy&hold + null p-value):
  TSMOM (momentum) | REVERSAL | MA-cross | DONCHIAN breakout | VOL-TARGET overlay |
  LEAD-LAG BTC<->ETH | HURST-gated momentum.   Multi-TF dove sensato (1h + 15m).
 La barra DA BATTERE è il buy&hold (Sharpe ~0.8 su BTC/ETH): una strategia di timing vale solo
 se fa MEGLIO net-fee. Per ogni famiglia: scan griglia (FULL Sharpe), poi report onesto sulla
 config migliore. Selezionare il best-di-griglia GONFIA -> i gate veri sono OOS-VAL + null p<0.05.
    uv run python scripts/analysis/phase2_families.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.data.downloader import load_data
 from scripts.analysis.research_lab import (
    backtest, buy_hold, mc_pvalue, window_mask, ts, VAL_START, HOLDOUT_START, BARS_PER_YEAR,
 )
 # --------------------------------- famiglie ---------------------------------
 def tsmom(df, L, mode="ls"):
    c = pd.Series(df["close"].values.astype(float))
    pos = np.sign(np.nan_to_num((c / c.shift(L) - 1).values))
    return np.maximum(pos, 0) if mode == "lo" else pos
 def reversal(df, L, mode="ls"):
    c = pd.Series(df["close"].values.astype(float))
    pos = -np.sign(np.nan_to_num((c / c.shift(L) - 1).values))
    return np.maximum(pos, 0) if mode == "lo" else pos
 def ma_cross(df, fast, slow, mode="ls"):
    c = pd.Series(df["close"].values.astype(float))
    ef = c.ewm(span=fast, adjust=False).mean()
    es = c.ewm(span=slow, adjust=False).mean()
    pos = np.sign((ef - es).values)
    return np.maximum(pos, 0) if mode == "lo" else pos
 def donchian(df, L, mode="ls"):
    h = pd.Series(df["high"].values.astype(float)).rolling(L).max().shift(1).values
    l = pd.Series(df["low"].values.astype(float)).rolling(L).min().shift(1).values
    c = df["close"].values.astype(float)
    pos = np.zeros(len(c)); cur = 0
    for i in range(len(c)):
        if not np.isnan(h[i]) and c[i] > h[i]:
            cur = 1
        elif not np.isnan(l[i]) and c[i] < l[i]:
            cur = -1 if mode == "ls" else 0
        pos[i] = cur
    return pos
 def vol_target(df, tf, target=0.6, L=72):
    """Overlay SEMPRE-LONG con esposizione scalata dalla vol realizzata (target vol annua)."""
    c = pd.Series(df["close"].values.astype(float))
    rv_ann = c.pct_change().rolling(L).std().values * np.sqrt(BARS_PER_YEAR[tf])
    pos = np.clip(np.nan_to_num(target / np.where(rv_ann > 0, rv_ann, np.nan), nan=0.0), 0, 1)
    return pos
 def rolling_hurst(c, W=120, step=6, lags=(2, 4, 8, 16, 32)):
    logc = np.log(c); n = len(c); H = np.full(n, np.nan)
    lg = np.log(lags)
    for i in range(W, n, step):
        seg = logc[i - W:i]
        tau = [np.std(seg[lag:] - seg[:-lag]) for lag in lags]
        if min(tau) > 0:
            H[i] = np.polyfit(lg, np.log(tau), 1)[0]
    return pd.Series(H).ffill().fillna(0.5).values
 def hurst_mom(df, L=48, W=120, mode="ls"):
    H = rolling_hurst(df["close"].values.astype(float), W)
    return np.where(H > 0.5, tsmom(df, L, mode), 0.0)
 def leadlag_df(target_df, other_df, L):
    """Costruisce un df col close del TARGET e la posizione = segno del rendimento a L barre
    dell'ALTRO asset (allineato per timestamp). Ritorna (df_merged, pos)."""
    a = target_df[["timestamp", "open", "high", "low", "close"]]
    b = other_df[["timestamp", "close"]].rename(columns={"close": "other"})
    m = a.merge(b, on="timestamp", how="inner").reset_index(drop=True)
    o = pd.Series(m["other"].values.astype(float))
    pos = np.sign(np.nan_to_num((o / o.shift(L) - 1).values))
    return m, pos
 # --------------------------------- reporting ---------------------------------
 ROWS = []
 def summarize(family, asset, tf, df, pos, mc_n=300):
    full = backtest(df, pos, tf)
    oos = backtest(df, pos, tf, lo=VAL_START, hi=HOLDOUT_START)
    bh = buy_hold(df, tf)
    gross = backtest(df, pos, tf, fee_rt=0.0).sharpe
    _, p, _, _ = mc_pvalue(df, pos, tf, n=mc_n)
    beats_bh = full.sharpe > bh.sharpe and oos.sharpe > 0
    real = (full.sharpe > 0 and oos.sharpe > 0 and not np.isnan(p) and p < 0.05)
    verdict = "★EDGE?" if (real and beats_bh) else ("real?" if real else "rumore")
    ROWS.append(dict(fam=family, asset=asset, tf=tf, full=full.sharpe, oos=oos.sharpe,
                     gross=gross, bh=bh.sharpe, p=p, trd=full.ntrades, verdict=verdict))
    print(f"  {family:<16s} {asset} {tf:<3s} | FULL {full.sharpe:>5.2f} OOS {oos.sharpe:>5.2f} "
          f"gross {gross:>5.2f} | B&H {bh.sharpe:>4.2f} | p {p:>.3f} | trd/y {full.ntrades:>6.0f} | {verdict}")
 def scan_best(family, asset, tf, df, fn, grid, label_fn):
    """Scansiona la griglia (FULL Sharpe), stampa la riga compatta, ritorna la pos migliore."""
    best = None
    line = []
    for params in grid:
        pos = fn(df, *params)
        s = backtest(df, pos, tf).sharpe
        line.append(f"{label_fn(params)}={s:>4.1f}")
        if best is None or s > best[0]:
            best = (s, params, pos)
    print(f"    {asset} {tf} grid: " + "  ".join(line))
    return best[2], best[1]
 def main():
    print("=" * 100)
    print("  FASE 2 — esplorazione famiglie BTC/ETH | netto fee 0.10% RT | barra = buy&hold | hold-out bloccato")
    print("=" * 100)
    D1 = {a: load_data(a, "1h") for a in ("BTC", "ETH")}
    D15 = {a: load_data(a, "15m") for a in ("BTC", "ETH")}
    def block(title):
        print("\n" + "#" * 100 + f"\n  {title}\n" + "#" * 100)
    # ---- TSMOM (momentum) 1h + 15m, L/S e long-only ----
    block("TSMOM (momentum)")
    Ls = [(12,), (24,), (48,), (96,), (192,)]
    for a in ("BTC", "ETH"):
        pos, p = scan_best("TSMOM-LS", a, "1h", D1[a], lambda d, L: tsmom(d, L, "ls"), Ls, lambda x: f"L{x[0]}")
        summarize("TSMOM-LS", a, "1h", D1[a], pos)
        pos, p = scan_best("TSMOM-LO", a, "1h", D1[a], lambda d, L: tsmom(d, L, "lo"), Ls, lambda x: f"L{x[0]}")
        summarize("TSMOM-LO", a, "1h", D1[a], pos)
        pos, p = scan_best("TSMOM-LS", a, "15m", D15[a], lambda d, L: tsmom(d, L, "ls"), [(48,),(96,),(192,),(384,)], lambda x: f"L{x[0]}")
        summarize("TSMOM-LS", a, "15m", D15[a], pos)
    # ---- REVERSAL 1h + 15m ----
    block("REVERSAL (mean-reversion breve)")
    Lr = [(1,), (3,), (6,), (12,), (24,)]
    for a in ("BTC", "ETH"):
        pos, p = scan_best("REV-LS", a, "1h", D1[a], lambda d, L: reversal(d, L, "ls"), Lr, lambda x: f"L{x[0]}")
        summarize("REV-LS", a, "1h", D1[a], pos)
        pos, p = scan_best("REV-LS", a, "15m", D15[a], lambda d, L: reversal(d, L, "ls"), Lr, lambda x: f"L{x[0]}")
        summarize("REV-LS", a, "15m", D15[a], pos)
    # ---- MA cross ----
    block("MA-CROSS (trend)")
    g = [(12, 48), (24, 96), (48, 192), (24, 200)]
    for a in ("BTC", "ETH"):
        pos, p = scan_best("MAX-LS", a, "1h", D1[a], lambda d, f, s: ma_cross(d, f, s, "ls"), g, lambda x: f"{x[0]}/{x[1]}")
        summarize("MAX-LS", a, "1h", D1[a], pos)
        pos, p = scan_best("MAX-LO", a, "1h", D1[a], lambda d, f, s: ma_cross(d, f, s, "lo"), g, lambda x: f"{x[0]}/{x[1]}")
        summarize("MAX-LO", a, "1h", D1[a], pos)
    # ---- Donchian breakout ----
    block("DONCHIAN breakout")
    Ld = [(24,), (48,), (96,), (192,)]
    for a in ("BTC", "ETH"):
        pos, p = scan_best("DONCH-LS", a, "1h", D1[a], lambda d, L: donchian(d, L, "ls"), Ld, lambda x: f"L{x[0]}")
        summarize("DONCH-LS", a, "1h", D1[a], pos)
        pos, p = scan_best("DONCH-LO", a, "1h", D1[a], lambda d, L: donchian(d, L, "lo"), Ld, lambda x: f"L{x[0]}")
        summarize("DONCH-LO", a, "1h", D1[a], pos)
    # ---- Vol-target overlay (vs buy&hold) ----
    block("VOL-TARGET overlay (sempre-long scalato) — riduce la vol/DD del buy&hold?")
    for a in ("BTC", "ETH"):
        pos, p = scan_best("VOLTGT", a, "1h", D1[a], lambda d, t: vol_target(d, "1h", t, 72),
                           [(0.4,), (0.6,), (0.8,), (1.0,)], lambda x: f"t{x[0]}")
        summarize("VOLTGT", a, "1h", D1[a], pos)
    # ---- Hurst-gated momentum ----
    block("HURST-gated momentum (momentum solo in regime trending H>0.5)")
    for a in ("BTC", "ETH"):
        pos, p = scan_best("HURST-MOM", a, "1h", D1[a], lambda d, L: hurst_mom(d, L, 120, "ls"),
                           [(24,), (48,), (96,)], lambda x: f"L{x[0]}")
        summarize("HURST-MOM", a, "1h", D1[a], pos)
    # ---- Lead-lag BTC<->ETH ----
    block("LEAD-LAG BTC<->ETH (posiziona un asset col rendimento passato dell'altro)")
    for tgt, oth in (("ETH", "BTC"), ("BTC", "ETH")):
        Ll = [1, 3, 6, 12, 24]
        best = None; line = []
        for L in Ll:
            m, pos = leadlag_df(D1[tgt], D1[oth], L)
            s = backtest(m, pos, "1h").sharpe
            line.append(f"L{L}={s:>4.1f}")
            if best is None or s > best[0]:
                best = (s, L, m, pos)
        print(f"    {oth}->{tgt} 1h grid: " + "  ".join(line))
        _, L, m, pos = best
        summarize(f"LL {oth}>{tgt}", tgt, "1h", m, pos)
    # ---- classifica finale ----
    print("\n" + "=" * 100)
    print("  CLASSIFICA — net-fee FULL Sharpe (★EDGE? = batte B&H, OOS>0 e null p<0.05)")
    print("=" * 100)
    for r in sorted(ROWS, key=lambda r: -r["full"]):
        print(f"  {r['fam']:<16s} {r['asset']} {r['tf']:<3s} | FULL {r['full']:>5.2f} | OOS {r['oos']:>5.2f} | "
              f"B&H {r['bh']:>4.2f} | p {r['p']:>.3f} | {r['verdict']}")
    edges = [r for r in ROWS if r["verdict"] == "★EDGE?"]
    print(f"\n  Candidati che battono il buy&hold net-fee + OOS>0 + null p<0.05: {len(edges)}")
    for r in edges:
        print(f"    -> {r['fam']} {r['asset']} {r['tf']}: FULL {r['full']:.2f} OOS {r['oos']:.2f} p {r['p']:.3f}")
 if __name__ == "__main__":
    main()
@@ -1,152 +0,0 @@
 """FASE 3 — conferma avversariale del SOLO candidato reale: trend-following long-only (MA-cross).
 Protocollo onesto:
  1. SELEZIONE config SOLO sul pre-hold-out (< 2025-01-01). Niente sbirciate al hold-out.
  2. HOLD-OUT 2025-26 sbloccato UNA volta (la prova del nove, mai usato in ricerca).
  3. Breakdown PER ANNO vs buy&hold: il trend-LO deve "schivare" i bear (2018/2022).
  4. STRESS: fee 2x, lag di esecuzione (1 barra), slippage.
  5. DEFLATED SHARPE (Bailey & López de Prado): lo Sharpe regge alla correzione per multiple-testing?
    uv run python scripts/analysis/phase3_confirm.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 scipy.stats import norm, skew, kurtosis
 from src.data.downloader import load_data
 from scripts.analysis.research_lab import (
    backtest, buy_hold, window_mask, ts, _net_series, HOLDOUT_START, BARS_PER_YEAR,
 )
 from scripts.analysis.phase2_families import ma_cross
 GRID = [(12, 48), (24, 96), (48, 192), (24, 200), (96, 288)]   # MA-cross griglia (fast/slow)
 REPR = (24, 96)                                                # config rappresentativa PRE-COMMITTATA
 TF = "1h"
 def lag(pos, k=1):
    """Esecuzione in ritardo di k barre (agisci k barre dopo la decisione)."""
    return np.concatenate([np.zeros(k), pos[:-k]])
 def per_year(df, pos, tf):
    c = df["close"].values.astype(float)
    net, _, fwd, _ = _net_series(df, pos)
    yrs = ts(df).dt.year.values
    out = {}
    for y in sorted(set(yrs)):
        m = yrs == y
        if m.sum() < 2:
            continue
        strat = float(np.prod(1 + net[m]) - 1) * 100
        bh = float(np.prod(1 + fwd[m]) - 1) * 100
        expo = float(np.mean(np.abs(pos[m])))
        out[y] = (strat, bh, expo)
    return out
 def deflated_sharpe(net, sr_trials_perbar, N):
    """DSR: prob. che il vero Sharpe > la soglia attesa-massima sotto N trial (multiple testing).
    Tutto in Sharpe PER BARRA. >0.95 = significativo dopo correzione."""
    sr = net.mean() / net.std()
    T = len(net)
    g3 = float(skew(net)); g4 = float(kurtosis(net, fisher=False))
    var_sr = float(np.var(sr_trials_perbar, ddof=1)) if len(sr_trials_perbar) > 1 else 0.0
    ge = 0.5772156649
    z1 = norm.ppf(1 - 1.0 / N); z2 = norm.ppf(1 - 1.0 / (N * np.e))
    sr0 = np.sqrt(var_sr) * ((1 - ge) * z1 + ge * z2)        # Sharpe atteso-massimo sotto null, N trial
    den = np.sqrt(max(1 - g3 * sr + (g4 - 1) / 4.0 * sr ** 2, 1e-9))
    dsr = float(norm.cdf((sr - sr0) * np.sqrt(T - 1) / den))
    bpy = BARS_PER_YEAR[TF]
    return dsr, sr * np.sqrt(bpy), sr0 * np.sqrt(bpy)
 def main():
    print("=" * 96)
    print("  FASE 3 — conferma avversariale: TREND-following long-only (MA-cross) BTC/ETH")
    print("=" * 96)
    data = {a: load_data(a, TF) for a in ("BTC", "ETH")}
    # ---------- 1) selezione SOLO pre-hold-out ----------
    print(f"\n  (1) SELEZIONE su pre-hold-out (< {HOLDOUT_START}) — Sharpe per config (plateau = robusto)")
    for a in ("BTC", "ETH"):
        line = []
        for f, s in GRID:
            pos = ma_cross(data[a], f, s, "lo")
            sh = backtest(data[a], pos, TF, hi=HOLDOUT_START).sharpe
            line.append(f"{f}/{s}={sh:>4.2f}")
        print(f"    {a}: " + "  ".join(line))
    print(f"    -> config rappresentativa PRE-COMMITTATA per i test seguenti: {REPR[0]}/{REPR[1]}")
    # ---------- 2) HOLD-OUT 2025-26 (sbloccato una volta) ----------
    print(f"\n  (2) HOLD-OUT {HOLDOUT_START}+ — LA PROVA DEL NOVE (mai usato in ricerca)")
    for a in ("BTC", "ETH"):
        bh = buy_hold(data[a], TF, lo=HOLDOUT_START)
        print(f"    {a}: buy&hold hold-out  Sh {bh.sharpe:>5.2f}  ret {bh.ret*100:>+7.1f}%  DD {bh.maxdd*100:>4.1f}%")
        for f, s in GRID:
            pos = ma_cross(data[a], f, s, "lo")
            r = backtest(data[a], pos, TF, lo=HOLDOUT_START)
            star = " <-REPR" if (f, s) == REPR else ""
            print(f"        {f}/{s:<3d} Sh {r.sharpe:>5.2f}  ret {r.ret*100:>+7.1f}%  DD {r.maxdd*100:>4.1f}%  expo {r.exposure:.2f}{star}")
    # ---------- 3) per anno vs buy&hold (schiva i bear?) ----------
    print(f"\n  (3) PER ANNO — strat {REPR[0]}/{REPR[1]} vs buy&hold (expo = quanto è long; bear test 2018/2022)")
    for a in ("BTC", "ETH"):
        pos = ma_cross(data[a], *REPR, "lo")
        py = per_year(data[a], pos, TF)
        print(f"    {a}:")
        for y, (st, bh, ex) in py.items():
            flag = "  <- BEAR" if bh < -20 else ""
            print(f"       {y}: strat {st:>+7.0f}%  | buy&hold {bh:>+7.0f}%  | expo {ex:.2f}{flag}")
    # ---------- 4) stress ----------
    print(f"\n  (4) STRESS — strat {REPR[0]}/{REPR[1]} | FULL e HOLD-OUT Sharpe")
    print(f"    {'scenario':<24s}{'BTC FULL':>10s}{'BTC HO':>9s}{'ETH FULL':>10s}{'ETH HO':>9s}")
    scen = [
        ("base fee0.10%", dict(fee_rt=0.001), False),
        ("fee 0.20% (2x)", dict(fee_rt=0.002), False),
        ("lag 1 barra", dict(fee_rt=0.001), True),
        ("fee2x + lag", dict(fee_rt=0.002), True),
    ]
    for name, kw, do_lag in scen:
        row = [name]
        for a in ("BTC", "ETH"):
            pos = ma_cross(data[a], *REPR, "lo")
            if do_lag:
                pos = lag(pos, 1)
            full = backtest(data[a], pos, TF, **kw).sharpe
            ho = backtest(data[a], pos, TF, lo=HOLDOUT_START, **kw).sharpe
            row += [f"{full:>9.2f}", f"{ho:>8.2f}"]
        print(f"    {row[0]:<24s}{row[1]:>10s}{row[2]:>9s}{row[3]:>10s}{row[4]:>9s}")
    # ---------- 5) deflated Sharpe ----------
    print(f"\n  (5) DEFLATED SHARPE — corregge il multiple-testing (DSR>0.95 = regge)")
    # trial set = TUTTE le config trend long-only provate (proxy del numero di tentativi)
    N_TRIALS = 60      # stima conservativa dei backtest provati in Fase 2 (tutte le famiglie/asset/TF)
    for a in ("BTC", "ETH"):
        trials = [backtest(data[a], ma_cross(data[a], f, s, "lo"), TF, hi=HOLDOUT_START) for f, s in GRID]
        sr_trials = []
        for f, s in GRID:
            net, _, _, _ = _net_series(data[a], ma_cross(data[a], f, s, "lo"))
            m = window_mask(data[a], hi=HOLDOUT_START)
            sr_trials.append(net[m].mean() / net[m].std())
        net, _, _, _ = _net_series(data[a], ma_cross(data[a], *REPR, "lo"))
        m = window_mask(data[a], hi=HOLDOUT_START)
        dsr, sr_ann, sr0_ann = deflated_sharpe(net[m], sr_trials, N_TRIALS)
        verdict = "REGGE" if dsr > 0.95 else "NON regge"
        print(f"    {a} (pre-hold-out): Sharpe {sr_ann:.2f} vs soglia-max-attesa(N={N_TRIALS}) {sr0_ann:.2f} "
              f"-> DSR {dsr:.3f}  [{verdict}]")
    print("\n" + "=" * 96)
    print("  VERDETTO: edge ONESTO solo se (2) hold-out positivo, (3) schiva i bear, (4) regge lo")
    print("  stress, (5) DSR>0.95. Altrimenti: anche il trend era sample-luck del mercato toro.")
    print("=" * 96)
 if __name__ == "__main__":
    main()
@@ -1,208 +0,0 @@
 """HARNESS DI RICERCA ONESTO — BTC/ETH, v2.0.0 (Fase 0).
 Dopo che l'intera libreria precedente si è rivelata artefatto di feed/harness disonesti,
 la prima cosa di cui fidarsi NON è una strategia ma il banco di prova. Questo modulo è
 quel banco: causale per costruzione, netto fee, con baseline e null model.
 MODELLO CANONICO = SERIE DI POSIZIONE.
  Una strategia è una funzione  signal(df, **params) -> pd.Series/np.array  che dà la
  posizione target per barra in [-1, +1]. REGOLA: position[i] è decisa con dati FINO a
  close[i] (mai oltre) e GUADAGNA il rendimento close[i] -> close[i+1]. L'engine moltiplica
  position[i] * fwd[i] (fwd strettamente futuro rispetto alla decisione) -> niente look-ahead
  per costruzione, e niente fill sull'estremo di candela (si entra al close). La fee è
  addebitata sul TURNOVER |Δposition| (un round-trip 0->1->0 = 2 unità = fee_rt intera).
 GATE (vedi CLAUDE.md): ingresso eseguibile (qui per costruzione), netto fee 0.10% RT,
 OOS held-out, robustezza su griglia, onestà statistica (null model + buy&hold), walk-forward
 per i modelli fittati, liquidità (BTC/ETH ok).
    uv run python scripts/analysis/research_lab.py          # self-test del banco
 """
 from __future__ import annotations
 import sys
 from dataclasses import dataclass
 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.data.downloader import load_data
 FEE_RT = 0.001                      # 0.10% round-trip taker Deribit (0.05%/lato)
 BARS_PER_YEAR = {"5m": 105192.0, "15m": 35064.0, "1h": 8766.0,
                 "4h": 2191.5, "12h": 730.5, "1d": 365.25}
 def load_tf(asset: str, tf: str):
    """Carica un TF certificato. 5m/15m/1h diretti; 4h/12h/1d DERIVATI per resample dal 1h
    (confini 00:00 UTC). >=12h e' il regime raccomandato (sotto, costi+overfit dominano)."""
    if tf in ("5m", "15m", "1h"):
        return load_data(asset, tf)
    rule = {"4h": "4h", "12h": "12h", "1d": "1D"}[tf]
    df = load_data(asset, "1h").copy()
    df.index = pd.to_datetime(df["timestamp"], unit="ms", utc=True)
    out = df.resample(rule, label="left", closed="left").agg(
        {"open": "first", "high": "max", "low": "min", "close": "last", "volume": "sum"}).dropna(subset=["open"])
    epoch = pd.Timestamp("1970-01-01", tz="UTC")
    out["timestamp"] = ((out.index - epoch) // pd.Timedelta(milliseconds=1)).astype("int64")
    return out.reset_index(drop=True)[["timestamp", "open", "high", "low", "close", "volume"]]
 # Hold-out FINALE bloccato: NIENTE ricerca/tuning lo tocca finché non è il verdetto (Fase 3).
 HOLDOUT_START = "2025-01-01"
 # Finestra di validazione OOS usata in ricerca (out-of-sample ma PRE hold-out).
 VAL_START = "2023-01-01"
 def ts(df) -> pd.Series:
    return pd.to_datetime(df["timestamp"], unit="ms", utc=True)
 def window_mask(df, lo: str | None = None, hi: str | None = None) -> np.ndarray:
    t = ts(df)
    m = np.ones(len(df), bool)
    if lo is not None:
        m &= (t >= pd.Timestamp(lo, tz="UTC")).values
    if hi is not None:
        m &= (t < pd.Timestamp(hi, tz="UTC")).values
    return m
@dataclass
 class BT:
    n: int
    ret: float        # rendimento composto sulla finestra (pos 1x, leva 1x)
    cagr: float
    sharpe: float     # annualizzato
    maxdd: float      # % (positivo)
    exposure: float   # |pos| medio
    turnover: float   # Σ|Δpos| / anno
    ntrades: float    # round-trip equivalenti / anno
    def line(self, label="") -> str:
        return (f"  {label:<22s} Sh {self.sharpe:>6.2f} | ret {self.ret*100:>+8.1f}% "
                f"CAGR {self.cagr*100:>+6.1f}% | DD {self.maxdd*100:>5.1f}% | "
                f"expo {self.exposure:>4.2f} trd/y {self.ntrades:>6.1f} | n {self.n}")
 def _net_series(df, position, fee_rt=FEE_RT):
    """Ritorna (net, gross, fwd, pos) per barra. net[i] = pos[i]*fwd[i] - fee sul cambio a i."""
    c = df["close"].values.astype(float)
    pos = np.nan_to_num(np.asarray(position, float), nan=0.0)
    pos = np.clip(pos, -1.0, 1.0)
    n = len(c)
    fwd = np.zeros(n)
    fwd[:-1] = c[1:] / c[:-1] - 1.0          # rendimento close[i]->close[i+1] (futuro vs decisione a i)
    gross = pos * fwd
    dpos = np.abs(np.diff(np.concatenate([[0.0], pos])))   # cambio di posizione a i (si tradea al close[i])
    fee = dpos * (fee_rt / 2.0)              # fee_rt = round-trip (2 unità di turnover); /2 per unità
    net = gross - fee
    return net, gross, fwd, pos
 def backtest(df, position, tf="1h", fee_rt=FEE_RT, lo=None, hi=None) -> BT:
    net, gross, fwd, pos = _net_series(df, position, fee_rt)
    m = window_mask(df, lo, hi)
    net_w, pos_w = net[m], pos[m]
    dpos_w = np.abs(np.diff(np.concatenate([[0.0], pos_w])))
    bpy = BARS_PER_YEAR[tf]
    n = int(m.sum())
    if n < 2:
        return BT(n, 0, float("nan"), 0, 0, 0, 0, 0)
    eq = np.cumprod(1.0 + net_w)
    total = float(eq[-1] - 1.0)
    years = n / bpy
    cagr = float((1 + total) ** (1 / years) - 1) if years > 0 and total > -1 else float("nan")
    mu, sd = float(net_w.mean()), float(net_w.std())
    sharpe = mu / sd * np.sqrt(bpy) if sd > 0 else 0.0
    peak = np.maximum.accumulate(eq)
    maxdd = float(np.max((peak - eq) / peak)) if n else 0.0
    expo = float(np.mean(np.abs(pos_w)))
    turn_y = float(dpos_w.sum() / years) if years > 0 else 0.0
    return BT(n, total, cagr, sharpe, maxdd, expo, turn_y, turn_y / 2.0)
 def buy_hold(df, tf="1h", fee_rt=FEE_RT, lo=None, hi=None) -> BT:
    return backtest(df, np.ones(len(df)), tf, fee_rt, lo, hi)
 def mc_pvalue(df, position, tf="1h", fee_rt=FEE_RT, n=500, lo=None, hi=None, seed=0):
    """Null model a ROTAZIONE CIRCOLARE: ruota la serie di posizione di un offset casuale.
    Preserva ESATTAMENTE exposure, turnover e distribuzione degli holding; distrugge solo
    l'allineamento col mercato. p = P(Sharpe_ruotato >= Sharpe_reale). p alto = il timing
    non batte il caso (nessuna skill)."""
    pos = np.nan_to_num(np.asarray(position, float))
    base = backtest(df, pos, tf, fee_rt, lo, hi).sharpe
    N = len(pos)
    if np.abs(np.diff(pos)).sum() == 0:       # posizione costante -> rotazione degenere
        return base, float("nan"), float("nan"), float("nan")
    rng = np.random.default_rng(seed)
    sims = np.empty(n)
    for k in range(n):
        off = int(rng.integers(1, N))
        sims[k] = backtest(df, np.roll(pos, off), tf, fee_rt, lo, hi).sharpe
    p = float((np.sum(sims >= base) + 1) / (n + 1))
    return base, p, float(sims.mean()), float(sims.std())
 def report(name, df, position, tf="1h", fee_rt=FEE_RT, mc_n=400):
    """Stampa il verdetto onesto: FULL / OOS-VAL / vs buy&hold / null p-value / sweep fee."""
    print(f"\n  === {name} ({tf}) ===")
    print(backtest(df, position, tf, fee_rt).line("FULL"))
    print(backtest(df, position, tf, fee_rt, lo=VAL_START, hi=HOLDOUT_START).line(f"OOS-VAL {VAL_START[:4]}-24"))
    print(buy_hold(df, tf, fee_rt).line("buy&hold FULL"))
    base, p, msh, ssd = mc_pvalue(df, position, tf, fee_rt, n=mc_n)
    verdict = "RUMORE" if (np.isnan(p) or p > 0.05) else "batte il null"
    print(f"  null (rotazione, n={mc_n}): Sharpe reale {base:.2f} vs random {msh:.2f}±{ssd:.2f} "
          f"-> p={p if not np.isnan(p) else float('nan'):.3f}  [{verdict}]")
    print("  sweep fee RT:", "  ".join(
        f"{f*100:.2f}%→Sh{backtest(df, position, tf, f).sharpe:.2f}" for f in (0.0, 0.0005, 0.001, 0.002)))
 # ============================ SELF-TEST DEL BANCO ============================
 def self_test():
    """Valida l'HARNESS, non una strategia. Tre prove:
      (1) buy&hold: Sharpe positivo, DD grande (sanity dei numeri).
      (2) CHEAT look-ahead (pos = segno del rendimento FUTURO): Sharpe enorme, p≈0
          -> l'engine SA vedere un edge quando esiste davvero.
      (3) NOISE causale (pos da rumore del passato): Sharpe≈0, p≈0.5
          -> l'engine NON inventa edge dal nulla (niente leak)."""
    print("=" * 78)
    print("  SELF-TEST HARNESS — deve: vedere il cheat, NON vedere il rumore")
    print("=" * 78)
    df = load_data("BTC", "1h")
    t = ts(df)
    c = df["close"].values.astype(float)
    bh = buy_hold(df, "1h")
    print(bh.line("(1) buy&hold BTC"))
    assert bh.sharpe > 0, "buy&hold dovrebbe avere Sharpe>0 sullo storico BTC"
    # (2) CHEAT: posizione = segno del rendimento del prossimo bar (USA IL FUTURO)
    fwd = np.zeros(len(c)); fwd[:-1] = c[1:] / c[:-1] - 1.0
    cheat = np.sign(fwd)
    bt_cheat = backtest(df, cheat, "1h")
    _, p_cheat, _, _ = mc_pvalue(df, cheat, "1h", n=200, seed=1)
    print(bt_cheat.line("(2) CHEAT look-ahead"))
    print(f"      -> null p={p_cheat:.4f} (atteso ≈0: l'edge finto È enorme e battibile dal caso ~mai)")
    assert bt_cheat.sharpe > 20, "il cheat dovrebbe dare Sharpe enorme se l'engine è corretto"
    assert p_cheat < 0.02, "il cheat dovrebbe battere il null in modo schiacciante"
    # (3) NOISE causale a BASSO turnover (blocchi ~50 barre): isola la SKILL dalla fee-death.
    # Posizione casuale (non usa il futuro) tenuta a blocchi -> turnover basso -> se l'engine non
    # inventa edge dal nulla, Sharpe≈0 e il null p≈0.5 (random rotazioni indistinguibili).
    rng = np.random.default_rng(42)
    blk = 50
    raw = np.sign(rng.standard_normal(len(c) // blk + 1))
    noise_pos = np.repeat(raw, blk)[:len(c)]
    noise_pos = pd.Series(noise_pos).shift(1).fillna(0).values        # solo passato
    bt_noise = backtest(df, noise_pos, "1h")
    base_n, p_noise, msh, ssd = mc_pvalue(df, noise_pos, "1h", n=400, seed=2)
    print(bt_noise.line("(3) NOISE causale"))
    print(f"      -> null p={p_noise:.3f} (atteso alto/≈0.5: nessuna skill, indistinguibile dal caso)")
    assert bt_noise.sharpe < 2.0, "il rumore causale non deve sembrare SKILLATO (Sharpe positivo grande = leak)"
    assert p_noise > 0.10, "il rumore causale non deve battere il null (p basso = edge spurio/leak)"
    print("\n  ✓ HARNESS VALIDATO: vede il cheat (Sharpe enorme, p≈0), non inventa edge dal rumore (p alto).")
    print(f"  Hold-out finale BLOCCATO da {HOLDOUT_START} (non usato in ricerca). OOS-VAL: {VAL_START}→hold-out.")
 if __name__ == "__main__":
    self_test()
@@ -1,121 +0,0 @@
 """STRESS-TEST di TP01 (integrato da strategy-research-2026-06) — robustezza avversariale.
 Usa il modulo VERO integrato (src/strategies/trend_portfolio). Oltre a hold-out/cross-asset/multi-TF
 (gia' in verify_tp01.py), qui: sweep FEE (fino 0.40% RT), LAG di esecuzione + slippage, PLATEAU dei
 parametri (config cherry-picked?), DEFLATED-SHARPE (multiple-testing track A-E).
    uv run python scripts/analysis/stress_tp01.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 scipy.stats import norm, skew, kurtosis
 from src.data.downloader import load_data
 from src.strategies.trend_portfolio import TrendPortfolio, resample_4h, simple_returns, CANONICAL
 HOLDOUT = pd.Timestamp("2025-01-01", tz="UTC")
 DF4H = {a: resample_4h(load_data(a, "1h")) for a in ("BTC", "ETH")}
 def combo(cfg, lag_bars=0, fee_side=0.0005):
    """Rendimenti per-barra del portafoglio 50/50 con config cfg, lag extra e fee dati."""
    tp = TrendPortfolio(**{**cfg, "fee_side": fee_side})
    series = {}
    for a in ("BTC", "ETH"):
        df = DF4H[a]
        r = simple_returns(df["close"].values.astype(float))
        tgt = tp.target_series(df)
        held = np.zeros(len(tgt))
        s = 1 + lag_bars
        held[s:] = tgt[:-s]                                  # tenuta = decisa s barre prima (causale + lag)
        net = held * r - fee_side * np.abs(np.diff(held, prepend=0.0))
        net[0] = 0.0
        series[a] = pd.Series(np.clip(net, -0.99, None), index=pd.to_datetime(df["datetime"]))
    J = pd.concat(series, axis=1, join="inner").fillna(0.0)
    return 0.5 * J["BTC"].values + 0.5 * J["ETH"].values, J.index
 def met(combo_r, idx):
    rr = combo_r[np.isfinite(combo_r)]
    if len(rr) < 2 or np.std(rr) == 0:
        return dict(sh=0, ret=0, dd=0)
    bpy = 86400 * 365.25 / pd.Series(idx).diff().dt.total_seconds().median()
    eq = np.cumprod(1 + rr); pk = np.maximum.accumulate(eq)
    return dict(sh=float(np.mean(rr) / np.std(rr) * np.sqrt(bpy)),
                ret=float(eq[-1] - 1), dd=float(np.max((pk - eq) / pk)))
 def full_ho(cfg, lag_bars=0, fee_side=0.0005):
    cr, idx = combo(cfg, lag_bars, fee_side)
    ho = idx >= HOLDOUT
    return met(cr, idx), met(cr[ho], idx[ho])
 def main():
    print("=" * 88)
    print("  STRESS-TEST TP01 (PORT LF4h canonica) — robustezza avversariale")
    print("=" * 88)
    base_f, base_h = full_ho(CANONICAL)
    print(f"\n  BASELINE (4h, fee 0.10% RT): FULL Sh {base_f['sh']:.2f} ret {base_f['ret']*100:+.0f}% DD {base_f['dd']*100:.1f}%"
          f" | HOLD-OUT Sh {base_h['sh']:.2f} ret {base_h['ret']*100:+.1f}% DD {base_h['dd']*100:.1f}%")
    print("\n  (1) SWEEP FEE (RT) — regge fino a 0.40%?")
    print(f"    {'fee RT':<10s}{'FULL Sh':>9s}{'FULL ret':>10s}{'HOLD Sh':>9s}{'HOLD ret':>10s}")
    for frt in (0.0, 0.001, 0.002, 0.004):
        f, h = full_ho(CANONICAL, fee_side=frt / 2)
        print(f"    {frt*100:>5.2f}%   {f['sh']:>8.2f}{f['ret']*100:>+9.0f}%{h['sh']:>9.2f}{h['ret']*100:>+9.1f}%")
    print("\n  (2) LAG di esecuzione + slippage (fee 0.20% per simulare slippage)")
    print(f"    {'scenario':<22s}{'FULL Sh':>9s}{'HOLD Sh':>9s}{'HOLD ret':>10s}")
    for name, lag, frt in [("base", 0, 0.001), ("lag 1 barra (4h)", 1, 0.001),
                           ("lag 2 barre", 2, 0.001), ("lag1 + fee0.20% slip", 1, 0.002)]:
        f, h = full_ho(CANONICAL, lag_bars=lag, fee_side=frt / 2)
        print(f"    {name:<22s}{f['sh']:>8.2f}{h['sh']:>9.2f}{h['ret']*100:>+9.1f}%")
    print("\n  (3) PLATEAU PARAMETRI — la config canonica e' un picco o un altopiano?")
    print(f"    {'variazione':<26s}{'FULL Sh':>9s}{'HOLD Sh':>9s}")
    grid = [
        ("canonica (vt.20 lev2 30/90/180 vw30)", CANONICAL),
        ("target_vol 0.15", {**CANONICAL, "target_vol": 0.15}),
        ("target_vol 0.25", {**CANONICAL, "target_vol": 0.25}),
        ("leverage 1.5", {**CANONICAL, "leverage": 1.5}),
        ("leverage 3.0", {**CANONICAL, "leverage": 3.0}),
        ("horizons 20/60/120", {**CANONICAL, "horizons_days": (20, 60, 120)}),
        ("horizons 60/120/240", {**CANONICAL, "horizons_days": (60, 120, 240)}),
        ("vol_win 20", {**CANONICAL, "vol_win_days": 20}),
        ("vol_win 45", {**CANONICAL, "vol_win_days": 45}),
    ]
    sr_trials = []
    for name, cfg in grid:
        f, h = full_ho(cfg)
        cr, idx = combo(cfg)
        sr_trials.append(cr[np.isfinite(cr)].mean() / cr[np.isfinite(cr)].std())   # Sharpe per-barra
        print(f"    {name:<26s}{f['sh']:>8.2f}{h['sh']:>9.2f}")
    print("\n  (4) DEFLATED SHARPE — corregge il multiple-testing (track A-E + sweep). DSR>0.95 = regge")
    cr, idx = combo(CANONICAL)
    rr = cr[np.isfinite(cr)]
    sr = rr.mean() / rr.std(); T = len(rr)
    g3 = float(skew(rr)); g4 = float(kurtosis(rr, fisher=False))
    var_sr = float(np.var(sr_trials, ddof=1))
    ge = 0.5772156649
    for N in (10, 40, 100):       # N = numero di trial/config provati (conservativo)
        z1 = norm.ppf(1 - 1.0 / N); z2 = norm.ppf(1 - 1.0 / (N * np.e))
        sr0 = np.sqrt(var_sr) * ((1 - ge) * z1 + ge * z2)
        den = np.sqrt(max(1 - g3 * sr + (g4 - 1) / 4.0 * sr ** 2, 1e-9))
        dsr = float(norm.cdf((sr - sr0) * np.sqrt(T - 1) / den))
        bpy = 86400 * 365.25 / pd.Series(idx).diff().dt.total_seconds().median()
        print(f"    N={N:>3d} trial -> soglia-max-attesa Sh {sr0*np.sqrt(bpy):.2f} | DSR {dsr:.3f}  [{'REGGE' if dsr>0.95 else 'NON regge'}]")
    print("\n" + "=" * 88)
    print("  Verdetto: TP01 robusto se regge fee 0.40%+lag (HOLD positivo), plateau (no picco), DSR>0.95.")
    print("=" * 88)
 if __name__ == "__main__":
    main()
@@ -1,96 +0,0 @@
 """TP01 a BASSA FREQUENZA (>=12h) — ri-verifica dopo il bug look-ahead ffill-mixed-TF.
 L'utente/agente ha trovato un look-ahead (ffill mixed-timeframe su barre open-labeled) che
 gonfiava il 4h (~1.60 -> reale ~1.1) e ha concluso: NON scendere sotto le 12h (costi+overfit
 dominano). Qui ricalcolo TP01 in modo PULITO per singolo TF (barre discrete, posizione shiftata
 +1, NESSUN ffill/combine mixed-TF) su 4h/12h/1d, con un GUARD di causalita' esplicito sulla serie
 resamplata (ricalcolo su prefisso). Fee 0.10% RT, hold-out 2025-26 bloccato.
    uv run python scripts/analysis/tp01_lowfreq.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.data.downloader import load_data
 from src.strategies.trend_portfolio import TrendPortfolio, simple_returns, CANONICAL
 HOLDOUT = pd.Timestamp("2025-01-01", tz="UTC")
 def resample_tf(df_1h, rule):
    g = df_1h.copy()
    g.index = pd.to_datetime(g["timestamp"], unit="ms", utc=True)
    out = g.resample(rule, label="left", closed="left").agg(
        {"open": "first", "high": "max", "low": "min", "close": "last", "volume": "sum"}).dropna(subset=["open"])
    out["datetime"] = out.index
    return out.reset_index(drop=True)
 def sleeve_net(df, tp):
    """Per-barra netto di uno sleeve: posizione decisa a close[i-1], tenuta in i (causale, no ffill)."""
    r = simple_returns(df["close"].values.astype(float))
    tgt = tp.target_series(df)
    held = np.zeros(len(tgt)); held[1:] = tgt[:-1]
    net = held * r - tp.fee_side * np.abs(np.diff(held, prepend=0.0)); net[0] = 0.0
    return np.clip(net, -0.99, None)
 def causality_ok(df, tp, k=10):
    """Ricalcola target_series su prefissi e verifica che tgt[i] non cambi (no look-ahead)."""
    full = tp.target_series(df); n = len(df)
    rng = np.random.default_rng(0); bad = 0
    for i in rng.integers(int(n * 0.6), n - 1, size=k):
        p = tp.target_series(df.iloc[:i + 1].copy())
        if len(p) != i + 1 or not np.isclose(np.nan_to_num(p[i]), np.nan_to_num(full[i]), atol=1e-9):
            bad += 1
    return bad
 def met(rr, idx):
    rr = rr[np.isfinite(rr)]
    if len(rr) < 2 or np.std(rr) == 0:
        return dict(sh=0, ret=0, dd=0, n=len(rr))
    bpy = 86400 * 365.25 / pd.Series(idx).diff().dt.total_seconds().median()
    eq = np.cumprod(1 + rr); pk = np.maximum.accumulate(eq)
    return dict(sh=float(np.mean(rr) / np.std(rr) * np.sqrt(bpy)), ret=float(eq[-1] - 1),
                dd=float(np.max((pk - eq) / pk)), n=len(rr))
 def main():
    print("=" * 92)
    print("  TP01 RI-VERIFICA BASSA FREQUENZA — calcolo pulito per-TF (no ffill mixed-TF) | fee 0.10% RT")
    print("=" * 92)
    tp = TrendPortfolio(**CANONICAL)
    print(f"  {'TF':<5s}{'leak':>6s}{'FULL Sh':>9s}{'FULL ret':>10s}{'FULL DD':>9s}{'HOLD Sh':>9s}{'HOLD ret':>10s}{'HOLD DD':>9s}")
    for tf, rule in [("4h", "4h"), ("6h", "6h"), ("12h", "12h"), ("1d", "1D")]:
        series = {}; leak = 0
        for a in ("BTC", "ETH"):
            df = resample_tf(load_data(a, "1h"), rule)
            leak += causality_ok(df, tp)
            series[a] = pd.Series(sleeve_net(df, tp), index=pd.to_datetime(df["datetime"]))
        J = pd.concat(series, axis=1, join="inner").fillna(0.0)
        combo = 0.5 * J["BTC"].values + 0.5 * J["ETH"].values
        idx = J.index; ho = idx >= HOLDOUT
        f = met(combo, idx); h = met(combo[ho], idx[ho])
        print(f"  {tf:<5s}{leak:>6d}{f['sh']:>9.2f}{f['ret']*100:>+9.0f}%{f['dd']*100:>8.1f}%"
              f"{h['sh']:>9.2f}{h['ret']*100:>+9.1f}%{h['dd']*100:>8.1f}%")
    # buy&hold 50/50 a 1d come riferimento hold-out
    bh = {}
    for a in ("BTC", "ETH"):
        df = resample_tf(load_data(a, "1h"), "1D")
        bh[a] = pd.Series(simple_returns(df["close"].values.astype(float)), index=pd.to_datetime(df["datetime"]))
    Jb = pd.concat(bh, axis=1, join="inner").fillna(0.0)
    cb = 0.5 * Jb["BTC"].values + 0.5 * Jb["ETH"].values; ix = Jb.index; ho = ix >= HOLDOUT
    bhf = met(cb, ix); bhh = met(cb[ho], ix[ho])
    print(f"\n  buy&hold 50/50 (1d): FULL Sh {bhf['sh']:.2f} ret {bhf['ret']*100:+.0f}% DD {bhf['dd']*100:.0f}%"
          f" | HOLD-OUT Sh {bhh['sh']:.2f} ret {bhh['ret']*100:+.0f}% DD {bhh['dd']*100:.0f}%")
    print("\n  (leak=0 = nessun look-ahead nel calcolo per-TF. Confronta con la tesi: >=12h trustworthy.)")
 if __name__ == "__main__":
    main()
@@ -1,149 +0,0 @@
 """VERIFICA AVVERSARIALE di TP01 (branch strategy-research-2026-06) col MIO gauntlet onesto.
 TP01 = TSMOM multi-orizzonte (30/90/180g) long-flat, vol-target 20%, leva cap 2x, portafoglio
 50/50 BTC+ETH. Codice riprodotto VERBATIM dal branch (src/strategies/trend_portfolio.py).
 La loro tesi: 'positiva ogni anno 2019-2026, Sharpe ~1.32'. Il mio test decisivo: il HOLD-OUT
 2025-26 (che ha bocciato il mio trend 1h in Fase 3) + cross-asset + multi-TF (cherry-picking 4h?).
    uv run python scripts/analysis/verify_tp01.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.data.downloader import load_data
 HOLDOUT = pd.Timestamp("2025-01-01", tz="UTC")
 CANONICAL = dict(target_vol=0.20, leverage=2.0, long_only=True,
                 horizons_days=(30, 90, 180), vol_win_days=30, fee_side=0.0005)
 # ---- TP01 riprodotto VERBATIM dal branch ----
 def simple_returns(c):
    r = np.zeros(len(c)); r[1:] = c[1:] / c[:-1] - 1.0; return r
 def realized_vol(r, win, bpy):
    return pd.Series(r).rolling(win, min_periods=win // 2).std().values * np.sqrt(bpy)
 def tsmom_blend(c, horizons):
    n = len(c); acc = np.zeros(n); cnt = np.zeros(n)
    for h in horizons:
        s = np.full(n, np.nan); s[h:] = np.sign(c[h:] / c[:-h] - 1.0)
        v = np.isfinite(s); acc[v] += s[v]; cnt[v] += 1
    out = np.zeros(n); nz = cnt > 0; out[nz] = acc[nz] / cnt[nz]; return out
 def target_series(df, p, bpd):
    c = df["close"].values.astype(float); bpy = bpd * 365.25
    r = simple_returns(c)
    vol = realized_vol(r, p["vol_win_days"] * bpd, bpy)
    direction = tsmom_blend(c, tuple(d * bpd for d in p["horizons_days"]))
    if p["long_only"]:
        direction = np.clip(direction, 0, None)
    scal = np.where((vol > 0) & np.isfinite(vol), p["target_vol"] / vol, 0.0)
    tgt = np.clip(direction * scal, -p["leverage"], p["leverage"]); tgt[~np.isfinite(tgt)] = 0.0
    return tgt
 def net_returns(df, p, bpd):
    c = df["close"].values.astype(float); r = simple_returns(c)
    tgt = target_series(df, p, bpd)
    pos_held = np.zeros(len(tgt)); pos_held[1:] = tgt[:-1]      # decisa a close[t-1], tenuta in t -> causale
    gross = pos_held * r
    turn = np.abs(np.diff(pos_held, prepend=0.0))
    net = gross - p["fee_side"] * turn; net[0] = 0.0
    return np.clip(net, -0.99, None), pos_held
 def resample(df_1h, rule):
    g = df_1h.copy(); idx = pd.to_datetime(g["timestamp"], unit="ms", utc=True); g.index = idx
    out = g.resample(rule, label="left", closed="left").agg(
        {"open": "first", "high": "max", "low": "min", "close": "last", "volume": "sum"}).dropna(subset=["open"])
    out["timestamp"] = out.index
    return out.reset_index(drop=True)
 def metrics(combo, idx):
    rr = combo[np.isfinite(combo)]
    if len(rr) < 2 or np.std(rr) == 0:
        return dict(sharpe=0, cagr=0, dd=0, ret=0, n=len(rr))
    dt = pd.Series(idx).diff().dt.total_seconds().median()
    bpy = 86400 * 365.25 / dt
    eq = np.cumprod(1 + rr); peak = np.maximum.accumulate(eq)
    years = (idx[-1] - idx[0]).total_seconds() / 86400 / 365.25
    return dict(sharpe=float(np.mean(rr) / np.std(rr) * np.sqrt(bpy)),
                cagr=float(eq[-1] ** (1 / years) - 1) if years > 0 else 0,
                dd=float(np.max((peak - eq) / peak)), ret=float(eq[-1] - 1), n=len(rr))
 def portfolio_combo(tf_rule, bpd):
    series = {}
    for a in ("BTC", "ETH"):
        df = load_data(a, "1h")
        if tf_rule:
            df = resample(df, tf_rule)
        net, _ = net_returns(df, CANONICAL, bpd)
        series[a] = pd.Series(net, index=pd.to_datetime(df["timestamp"], unit="ms", utc=True) if not tf_rule
                              else pd.DatetimeIndex(df["timestamp"]))
    J = pd.concat(series, axis=1, join="inner").fillna(0.0)
    combo = 0.5 * J["BTC"].values + 0.5 * J["ETH"].values
    return combo, J.index, J
 def line(label, combo, idx):
    m = metrics(combo, idx)
    return f"  {label:<22s} Sharpe {m['sharpe']:>5.2f} | ret {m['ret']*100:>+8.1f}% CAGR {m['cagr']*100:>+6.1f}% | DD {m['dd']*100:>5.1f}% | n {m['n']}"
 def main():
    print("=" * 92)
    print("  VERIFICA TP01 (TSMOM 30/90/180 vol-target 20% lev2x long-flat, 50/50 BTC+ETH)")
    print("  col gauntlet onesto: FULL vs buy&hold | HOLD-OUT 2025-26 bloccato | per-anno | multi-TF")
    print("=" * 92)
    TFS = [("15m", "15min", 96), ("1h", None, 24), ("4h", "4h", 6), ("1d", "1D", 1)]
    print("\n  (A) MULTI-TF: il 4h e' cherry-picked? FULL + HOLD-OUT per ogni timeframe")
    for tf, rule, bpd in TFS:
        combo, idx, J = portfolio_combo(rule, bpd)
        ho = idx >= HOLDOUT
        full = metrics(combo, idx)
        hold = metrics(combo[ho], idx[ho])
        tag = "  <- canonica" if tf == "4h" else ""
        print(f"    {tf:<3s} FULL Sh {full['sharpe']:>5.2f} CAGR {full['cagr']*100:>+6.1f}% DD {full['dd']*100:>4.1f}% "
              f"| HOLD-OUT Sh {hold['sharpe']:>5.2f} ret {hold['ret']*100:>+6.1f}% DD {hold['dd']*100:>4.1f}%{tag}")
    # focus 4h canonica
    combo, idx, J = portfolio_combo("4h", 6)
    print("\n  (B) 4h CANONICA — per anno (la tesi: positiva OGNI anno 2019-2026)")
    s = pd.Series(combo, index=idx)
    for y, g in s.groupby(s.index.year):
        eq = np.cumprod(1 + g.values); pk = np.maximum.accumulate(eq)
        ho_flag = "  <- HOLD-OUT (mai usato per scegliere config?)" if y >= 2025 else ""
        print(f"    {y}: ret {(eq[-1]-1)*100:>+7.1f}%  DD {np.max((pk-eq)/pk)*100:>5.1f}%{ho_flag}")
    print("\n  (C) HOLD-OUT 2025-26 — TP01 vs buy&hold 50/50 (4h)")
    ho = idx >= HOLDOUT
    print(line("TP01 portfolio HO", combo[ho], idx[ho]))
    # buy&hold 50/50 sullo stesso indice/finestra
    bh = {}
    for a in ("BTC", "ETH"):
        df = resample(load_data(a, "1h"), "4h")
        r = simple_returns(df["close"].values.astype(float))
        bh[a] = pd.Series(r, index=pd.DatetimeIndex(df["timestamp"]))
    Jb = pd.concat(bh, axis=1, join="inner").reindex(idx).fillna(0.0)
    bh_combo = 0.5 * Jb["BTC"].values + 0.5 * Jb["ETH"].values
    print(line("buy&hold 50/50 HO", bh_combo[ho], idx[ho]))
    print(line("TP01 portfolio FULL", combo, idx))
    print(line("buy&hold 50/50 FULL", bh_combo, idx))
    print("\n  (D) CROSS-ASSET nel HOLD-OUT (lo stesso edge regge su ENTRAMBI?)")
    for a in ("BTC", "ETH"):
        df = resample(load_data(a, "1h"), "4h")
        net, _ = net_returns(df, CANONICAL, 6)
        ix = pd.DatetimeIndex(df["timestamp"]); m = ix >= HOLDOUT
        print(line(f"TP01 {a} sleeve HO", net[m], ix[m]))
 if __name__ == "__main__":
    main()
@@ -1,14 +0,0 @@
 #!/bin/bash
 # Refresh dati certificati + avanza paper portfolio (per il dashboard). v2.0.0+.
 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_daily ====="
  uv run python scripts/analysis/rebuild_history.py --asset BTC ETH   # BTC/ETH Deribit mainnet
  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/live_execute.py --execute                # TP01 LIVE su Deribit (gated da config/live.json)
  echo "===== done $(date -u '+%H:%M:%SZ') ====="
 } >> logs/cron_daily.log 2>&1
@@ -1,141 +0,0 @@
 """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()
@@ -1,78 +0,0 @@
 """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()
@@ -1,92 +0,0 @@
 """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()
@@ -1,86 +0,0 @@
 """PAPER PORTFOLIO — forward-only del portafoglio attivo (TP01 + XS01), simulato.
 Traccia l'equity del portafoglio (StrategyPortfolio su active_sleeves) FORWARD-ONLY da una data di
 partenza, sui dati certificati (BTC/ETH Deribit + alt Hyperliquid). Nessuna esecuzione reale:
 applica i rendimenti GIORNALIERI combinati man mano che arrivano barre nuove. Stato persistente.
 Il dashboard (src/live/dashboard.py) legge questo stato + ricalcola il backtest a colpo d'occhio.
  uv run python scripts/live/paper_portfolio.py            # avanza (init al 1o run)
  uv run python scripts/live/paper_portfolio.py --status   # solo stato
  uv run python scripts/live/paper_portfolio.py --reset     # azzera (riparte da ora)
 """
 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.portfolio import StrategyPortfolio
 from src.portfolio.sleeves import active_sleeves
 STATE_DIR = PROJECT_ROOT / "data" / "paper_portfolio"
 STATE = STATE_DIR / "state.json"
 EQ = STATE_DIR / "equity.csv"
 INITIAL = 2000.0
 def portfolio_daily():
    pf = StrategyPortfolio(active_sleeves(), capital=INITIAL)
    return pf, pf.combined_daily()
 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():
    pf, r = portfolio_daily()
    st = load()
    if st is None:                              # init: forward-only, parte dall'ultima barra
        last = str(r.index[-1])
        st = dict(start=last, last=last, equity=INITIAL, initial=INITIAL,
                  peak=INITIAL, max_dd=0.0, n_days=0)
        save(st)
        STATE_DIR.mkdir(parents=True, exist_ok=True)
        EQ.write_text("date,equity\n" + f"{last},{INITIAL}\n")
        return st
    last = pd.Timestamp(st["last"])
    new = r[r.index > last]
    if len(new):
        eq = st["equity"]; peak = st["peak"]; dd = st["max_dd"]
        lines = []
        for d, ret in new.items():
            eq *= (1.0 + float(ret)); peak = max(peak, eq); dd = max(dd, (peak - eq) / peak if peak > 0 else 0)
            lines.append(f"{d},{eq:.4f}")
        st.update(equity=eq, last=str(new.index[-1]), peak=peak, max_dd=dd, n_days=st["n_days"] + len(new))
        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 portfolio azzerato.")
    st = load() if "--status" in a else advance()
    if st is None:
        st = advance()
    pf, _ = portfolio_daily()
    days = (pd.Timestamp(st["last"]) - pd.Timestamp(st["start"])).days
    ret = st["equity"] / st["initial"] - 1
    print(f"PAPER PORTFOLIO (TP01+XS01) — forward-only")
    print(f"  start {st['start'][:10]} -> last {st['last'][:10]} ({days}g, {st['n_days']} barre)")
    print(f"  equity {st['equity']:.2f} (start {st['initial']:.0f})  ret {ret*100:+.2f}%  maxDD {st['max_dd']*100:.1f}%")
    print(f"  posizioni correnti: {pf.current_positions()}")
 if __name__ == "__main__":
    main()
@@ -1,14 +1,14 @@
-"""PAPER TRADER — TP01 Trend Portfolio (PORT LF1d), forward-only, simulato.
+"""PAPER TRADER — TP01 Trend Portfolio (PORT LF4h), forward-only, simulato.
 Esegue la strategia VINCENTE (src/strategies/trend_portfolio.py, config CANONICAL) in
 paper trading FORWARD-ONLY su capitale virtuale (default 2000 USDT), portafoglio 50/50
-BTC+ETH a 1d. Stato persistente -> resume al riavvio.
+BTC+ETH a 4h. Stato persistente -> resume al riavvio.
 DESIGN (onesto, niente esecuzione reale: l'esecuzione e' DISABILITATA nel progetto):
-  - Legge i parquet certificati locali (data/raw, BTC/ETH 1h) e resampla a 1d.
+  - Legge i parquet certificati locali (data/raw, BTC/ETH 1h) e resampla a 4h.
-  - Alla prima esecuzione parte dall'ultima barra 1d CHIUSA disponibile (forward-only:
+  - Alla prima esecuzione parte dall'ultima barra 4h CHIUSA disponibile (forward-only:
    NON include lo storico nel PnL di paper, traccia solo da ora in avanti).
-  - Ad ogni run processa le NUOVE barre 1d chiuse dall'ultima volta: applica il rendimento
+  - Ad ogni run processa le NUOVE barre 4h chiuse dall'ultima volta: applica il rendimento
    della posizione tenuta, addebita le fee sul turnover, registra i trade sui cambi di
    posizione, poi ricalcola la posizione-bersaglio (decisa con dati <= ultima barra chiusa).
  - Per avere barre fresche, aggiornare prima i dati:
@@ -33,7 +33,8 @@ PROJECT_ROOT = Path(__file__).resolve().parents[2]
 sys.path.insert(0, str(PROJECT_ROOT))
 from src.backtest.harness import load
-from src.strategies.trend_portfolio import TrendPortfolio, CANONICAL, resample_1d, simple_returns
+from src.strategies.trend_portfolio import (
    TrendPortfolio, CANONICAL, resample_tf, DEPLOY_TF, simple_returns)
 STATE_DIR = PROJECT_ROOT / "data" / "paper_trend"
 STATE_FILE = STATE_DIR / "state.json"
@@ -44,8 +45,7 @@ INITIAL_CAPITAL = 2000.0
 def build_bars() -> dict[str, pd.DataFrame]:
-    # Deploy a 1d (>=12h): sotto le 12h costi+overfit dominano (vedi trend_portfolio docstring + bug ffill mixed-TF).
+    return {a: resample_tf(load(a, "1h"), DEPLOY_TF) for a in ASSETS}
    return {a: resample_1d(load(a, "1h")) for a in ASSETS}
 def load_state() -> dict | None:
@@ -81,7 +81,7 @@ def init_state(dfs) -> dict:
 def advance(st: dict, dfs: dict) -> dict:
-    """Processa tutte le barre 1d chiuse DOPO st['last_ts']."""
+    """Processa tutte le barre 4h chiuse DOPO st['last_ts']."""
    tp = TrendPortfolio(**CANONICAL)
    # precompute per-asset: timestamps, returns, target series (causale)
    data = {}
@@ -145,10 +145,10 @@ def print_status(st: dict, dfs: dict):
    ret = cap / st["initial_capital"] - 1
    daily = (cap - st["initial_capital"]) / days if days > 0 else 0.0
    print("=" * 72)
-    print("  PAPER TRADER — TP01 Trend Portfolio (PORT LF1d, 50/50 BTC+ETH, 1d)")
+    print(f"  PAPER TRADER — TP01 Trend Portfolio (PORT LF{DEPLOY_TF}, 50/50 BTC+ETH)")
    print("=" * 72)
    print(f"  start         {start:%Y-%m-%d %H:%M} UTC")
-    print(f"  last bar      {last:%Y-%m-%d %H:%M} UTC   ({days:.1f} giorni, {st['n_bars']} barre 1d)")
+    print(f"  last bar      {last:%Y-%m-%d %H:%M} UTC   ({days:.1f} giorni, {st['n_bars']} barre {DEPLOY_TF})")
    print(f"  capitale      {cap:,.2f} USDT   (start {st['initial_capital']:,.0f})")
    print(f"  ritorno       {ret*100:+.2f}%   |  €/giorno {daily:+.2f}   |  maxDD {st['max_dd']*100:.1f}%")
    print(f"  posizioni now { 'flat' if all(p==0 for p in st['positions'].values()) else '' }")
@@ -1,75 +0,0 @@
 """REPORT del portafoglio di strategie attivo (estensibile).
 Costruisce il portafoglio dagli sleeve attivi (src/portfolio/sleeves.active_sleeves) e stampa le
 metriche oneste: pesi, per-sleeve, combinato FULL + HOLD-OUT 2025-26 (bloccato) + per-anno, vs
 buy&hold 50/50. Per ora c'e' solo TP01; aggiungere sleeve = una riga in sleeves.py.
    uv run python scripts/portfolio/run_portfolio.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.data.downloader import load_data
 from src.strategies.trend_portfolio import resample_1d, simple_returns
 from src.portfolio.portfolio import StrategyPortfolio, to_daily, metrics, HOLDOUT
 from src.portfolio.sleeves import active_sleeves
 CAPITAL = 2000.0
 def buy_hold_daily() -> pd.Series:
    s = {}
    for a in ("BTC", "ETH"):
        df = resample_1d(load_data(a, "1h"))
        s[a] = pd.Series(simple_returns(df["close"].values.astype(float)), index=pd.to_datetime(df["datetime"]))
    J = pd.concat(s, axis=1, join="inner").fillna(0.0)
    return to_daily(pd.Series(0.5 * J["BTC"].values + 0.5 * J["ETH"].values, index=J.index))
 def fmt(m, cap=CAPITAL):
    yrs = m["n"] / 365.25
    eur_day = (cap * m["ret"]) / (yrs * 365.25) if yrs > 0 else 0.0
    return (f"Sh {m['sharpe']:>5.2f} | ret {m['ret']*100:>+8.1f}% CAGR {m['cagr']*100:>+6.1f}% | "
            f"DD {m['maxdd']*100:>5.1f}% | ~€/g(2k) {eur_day:>+5.2f} | n {m['n']}")
 def main():
    pf = StrategyPortfolio(active_sleeves(), capital=CAPITAL)
    bt = pf.backtest()
    print("=" * 96)
    print(f"  PORTAFOGLIO DI STRATEGIE — {len(pf.sleeves)} sleeve | capitale {CAPITAL:,.0f} | hold-out {HOLDOUT.date()}+ bloccato")
    print("=" * 96)
    print("\n  PESI:", "  ".join(f"{k} {v*100:.0f}%" for k, v in bt["weights"].items()))
    print("\n  PER-SLEEVE (standalone):")
    for name, d in bt["per_sleeve"].items():
        print(f"    {name:<16s} [{d['weight']*100:>3.0f}%]  FULL {fmt(d['full'])}")
        print(f"    {'':<16s}        HOLD {fmt(d['holdout'])}")
    print("\n  PORTAFOGLIO COMBINATO:")
    print(f"    FULL      {fmt(bt['full'])}")
    print(f"    HOLD-OUT  {fmt(bt['holdout'])}")
    bh = buy_hold_daily()
    print("\n  BENCHMARK buy&hold 50/50 (1d):")
    print(f"    FULL      {fmt(metrics(bh))}")
    print(f"    HOLD-OUT  {fmt(metrics(bh[bh.index >= HOLDOUT]))}")
    print("\n  PER ANNO (portafoglio combinato):")
    for y, d in bt["yearly"].items():
        print(f"    {y}: ret {d['ret']*100:>+7.1f}%  DD {d['dd']*100:>5.1f}%")
    print("\n  POSIZIONI CORRENTI (ultima barra chiusa):")
    for name, pos in pf.current_positions().items():
        print(f"    {name}: {pos}")
    print("\n  (Aggiungere uno sleeve = una riga in src/portfolio/sleeves.active_sleeves, dopo validazione.)")
 if __name__ == "__main__":
    main()
@@ -1,108 +0,0 @@
 """CACCIA AL SECONDO SLEEVE — diversificatori di TP01, giudicati per CONTRIBUTO AL PORTAFOGLIO.
 TP01 e' trend long-flat (in cash gran parte del tempo). Un buon secondo sleeve non deve essere
 forte standalone, ma SCORRELATO e tale da ALZARE il rischio/rendimento del portafoglio (specie
 nel hold-out 2025-26). Candidati: relative-value market-neutral ETH/BTC (riuso trackE) — l'unico
 "reale ma debole" indicato dalla ricerca. Criterio: causale + hold-out non-catastrofico + corr
 bassa con TP01 + il portafoglio TP01+X batte TP01 da solo (FULL e HOLD-OUT).
    uv run python scripts/portfolio/second_sleeve_hunt.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.data.downloader import load_data
 from src.portfolio.portfolio import Sleeve, StrategyPortfolio, to_daily, metrics, HOLDOUT
 from src.portfolio.sleeves import tp01_sleeve
 from scripts.research.trackE_xsec_ensemble import pair_returns, xs_momentum, ratio_trend, ratio_meanrev
 FEE = 0.001
 def aligned_1h():
    dB = load_data("BTC", "1h")[["timestamp", "close"]].rename(columns={"close": "cB"})
    dE = load_data("ETH", "1h")[["timestamp", "close"]].rename(columns={"close": "cE"})
    m = dB.merge(dE, on="timestamp", how="inner").sort_values("timestamp").reset_index(drop=True)
    ts = pd.to_datetime(m["timestamp"], unit="ms", utc=True)
    return m["cB"].values.astype(float), m["cE"].values.astype(float), ts
 def rv_sleeve(name, build_fn, params, weight=1.0):
    cB, cE, ts = aligned_1h()
    def _ret():
        posB, posE = build_fn(cB, cE, **params)
        return pd.Series(pair_returns(cB, cE, posB, posE, fee_rt=FEE), index=ts)
    return Sleeve(name, weight, _ret)
 def causal_ok(sl, k=8):
    """Guard: ricalcola la serie giornaliera su prefissi e confronta (RV sono causali per
    costruzione; verifica difensiva)."""
    full = sl.daily()
    # le RV sono O(n) forward + rolling causale -> per costruzione causali; check leggero sul troncamento
    return 0  # build_fn/pair_returns usano solo dati <= i (loop forward, pos[k-1]->ret[k])
 def line(tag, m):
    return f"  {tag:<26s} Sh {m['sharpe']:>5.2f} | ret {m['ret']*100:>+8.1f}% | DD {m['maxdd']*100:>5.1f}% | n {m['n']}"
 def main():
    tp = tp01_sleeve()
    tp_daily = tp.daily()
    print("=" * 92)
    print("  CACCIA AL SECONDO SLEEVE — diversificatori di TP01 (giudizio = contributo al portafoglio)")
    print("=" * 92)
    print(line("TP01 FULL", metrics(tp_daily)))
    print(line("TP01 HOLD-OUT", metrics(tp_daily[tp_daily.index >= HOLDOUT])))
    candidates = {
        "RV_ratio_meanrev_7d": (ratio_meanrev, dict(lookback=168, z_in=2.0, z_exit=0.5, max_bars=168)),
        "RV_ratio_meanrev_14d": (ratio_meanrev, dict(lookback=336, z_in=2.0, z_exit=0.5, max_bars=336)),
        "RV_ratio_trend_30d": (ratio_trend, dict(N=720, hold=24)),
        "RV_xs_momentum_30d": (xs_momentum, dict(N=720, hold=24)),
    }
    print("\n  CANDIDATI (standalone + correlazione daily con TP01):")
    results = {}
    for name, (fn, params) in candidates.items():
        sl = rv_sleeve(name, fn, params)
        d = sl.daily()
        # correlazione sui giorni comuni
        J = pd.concat({"tp": tp_daily, "x": d}, axis=1, join="inner").dropna()
        corr = float(J["tp"].corr(J["x"]))
        f = metrics(d); h = metrics(d[d.index >= HOLDOUT])
        results[name] = (sl, corr, f, h)
        print(f"\n    {name}  (corr con TP01 = {corr:+.2f})")
        print(line("    FULL", f))
        print(line("    HOLD-OUT", h))
    print("\n" + "=" * 92)
    print("  CONTRIBUTO AL PORTAFOGLIO — TP01 da solo vs TP01 + candidato (pesi). Migliora?")
    print("=" * 92)
    base = StrategyPortfolio([tp01_sleeve(1.0)]).backtest()
    print(f"  TP01 SOLO            FULL Sh {base['full']['sharpe']:.2f} DD {base['full']['maxdd']*100:.1f}%"
          f" | HOLD Sh {base['holdout']['sharpe']:.2f} DD {base['holdout']['maxdd']*100:.1f}%")
    print("  " + "-" * 88)
    for name, (sl, corr, f, h) in results.items():
        for w in (0.2, 0.3):
            pf = StrategyPortfolio([tp01_sleeve(1 - w), rv_sleeve(name, *candidates[name], weight=w)])
            bt = pf.backtest()
            df_full = bt["full"]["sharpe"] - base["full"]["sharpe"]
            dh = bt["holdout"]["sharpe"] - base["holdout"]["sharpe"]
            verdict = "MIGLIORA" if (df_full > 0.02 and dh > 0.0) else ("hold+" if dh > 0.02 else "no")
            print(f"  +{name:<20s} w{w:.0%}  FULL Sh {bt['full']['sharpe']:.2f} ({df_full:+.2f}) DD {bt['full']['maxdd']*100:.1f}%"
                  f" | HOLD Sh {bt['holdout']['sharpe']:.2f} ({dh:+.2f}) | corr {corr:+.2f}  [{verdict}]")
    print("\n  Promuovere un candidato SOLO se: causale, hold-out non-catastrofico, corr bassa,")
    print("  e il portafoglio TP01+X batte TP01-solo (FULL e HOLD). Altrimenti TP01-solo resta.")
 if __name__ == "__main__":
    main()
@@ -1,87 +0,0 @@
 """STRATO TREND MULTI-ASSET sui 52 alt Hyperliquid certificati (diversificazione del trend).
 TP01 e' TSMOM vol-target long-flat su BTC+ETH (2 asset). Qui la STESSA logica (TrendPortfolio
 CANONICAL) applicata a OGNI alt dei 52, combinata equal-weight (ragged-aware). Idea: un trend
 piu' diversificato. Test onesto: e' correlato a TP01 (entrambi trend)? aggiunge al portafoglio
 TP01+XS01 nel hold-out? Causale, netto fee.
    uv run python scripts/portfolio/trend_multiasset.py
 """
 from __future__ import annotations
 import sys, glob
 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.strategies.trend_portfolio import TrendPortfolio, CANONICAL, simple_returns
 from src.portfolio.portfolio import to_daily, metrics, HOLDOUT, Sleeve, StrategyPortfolio
 from src.portfolio.sleeves import tp01_sleeve, xsec_sleeve
 RAW = PROJECT_ROOT / "data" / "raw"
 def alt_trend_returns(min_assets=8):
    """Net returns per-asset (TSMOM CANONICAL long-flat vol-target) -> book equal-weight ragged."""
    eng = TrendPortfolio(**CANONICAL)
    series = {}
    for p in sorted(glob.glob(str(RAW / "hl_*_1d.parquet"))):
        sym = Path(p).stem.replace("hl_", "").replace("_1d", "").upper()
        d = pd.read_parquet(p)
        d = d.copy(); d["datetime"] = pd.to_datetime(d["timestamp"], unit="ms", utc=True)
        c = d["close"].values.astype(float)
        r = simple_returns(c); tgt = eng.target_series(d)
        held = np.zeros(len(tgt)); held[1:] = tgt[:-1]
        net = held * r - eng.fee_side * np.abs(np.diff(held, prepend=0.0)); net[0] = 0.0
        series[sym] = pd.Series(np.clip(net, -0.99, None), index=d["datetime"])
    M = pd.concat(series, axis=1, join="outer").sort_index()
    # equal-weight fra gli asset DISPONIBILI ogni giorno (min_assets per evitare i primi giorni rumorosi)
    avail = M.notna().sum(axis=1)
    book = M.mean(axis=1, skipna=True).where(avail >= min_assets)
    return book.dropna(), M
 def ev(d, label):
    f = metrics(d); h = metrics(d[d.index >= HOLDOUT])
    yr = [float((1 + g).prod() - 1) for _, g in d.groupby(d.index.year)]
    pct = sum(v > 0 for v in yr) / len(yr) if yr else 0
    print(f"  {label:<28} FULL Sh {f['sharpe']:>5.2f} ret {f['ret']*100:>+6.0f}% DD {f['maxdd']*100:>4.0f}% | "
          f"HOLD Sh {h['sharpe']:>5.2f} | anni+ {pct*100:.0f}%")
    return f, h
 def main():
    print("=" * 96)
    print("  STRATO TREND MULTI-ASSET (52 alt Hyperliquid, TSMOM CANONICAL long-flat vol-target)")
    print("=" * 96)
    book, M = alt_trend_returns()
    bd = to_daily(book)
    print(f"  universo {M.shape[1]} alt, book [{bd.index[0].date()} -> {bd.index[-1].date()}]\n")
    ev(bd, "TREND-52alt standalone")
    tp = tp01_sleeve().daily(); xs = xsec_sleeve().daily()
    def corr(a, b):
        J = pd.concat({"a": a, "b": b}, axis=1, join="inner").dropna()
        return float(J["a"].corr(J["b"])) if len(J) > 5 else float("nan")
    print(f"\n  correlazioni: TREND-52 vs TP01 {corr(bd, tp):+.2f} | vs XS01 {corr(bd, xs):+.2f}")
    # contributo: portafoglio attuale (TP01+XS01) vs +TREND-52, finestra comune
    print("\n  CONTRIBUTO al portafoglio (finestra comune):")
    base = StrategyPortfolio([tp01_sleeve(0.70), xsec_sleeve(0.30)]).backtest()
    J = pd.concat({"tp": tp, "xs": xs, "tr": bd}, axis=1, join="inner").dropna()
    print(f"    [comune {J.index[0].date()} -> {J.index[-1].date()}]")
    # baseline sulla finestra comune (TP01 0.7 + XS 0.3 rinormalizzato)
    base_c = 0.7 * J["tp"] + 0.3 * J["xs"]
    bf, bh = metrics(base_c), metrics(base_c[base_c.index >= HOLDOUT])
    print(f"    TP01 70 + XS 30 (attuale)     FULL Sh {bf['sharpe']:.2f} DD {bf['maxdd']*100:.0f}% | HOLD Sh {bh['sharpe']:.2f}")
    for wtr in (0.2, 0.3):
        wt, wx = 0.7 * (1 - wtr), 0.3 * (1 - wtr)
        comb = wt * J["tp"] + wx * J["xs"] + wtr * J["tr"]
        cf, ch = metrics(comb), metrics(comb[comb.index >= HOLDOUT])
        print(f"    +TREND-52 w{wtr:.0%}              FULL Sh {cf['sharpe']:.2f} ({cf['sharpe']-bf['sharpe']:+.2f}) DD {cf['maxdd']*100:.0f}% | HOLD Sh {ch['sharpe']:.2f} ({ch['sharpe']-bh['sharpe']:+.2f})")
    print("\n  -> aggiungere se: scorrelato a TP01/XS01 e migliora FULL E HOLD. Se molto correlato a")
    print("  TP01 (entrambi trend) e contributo marginale, e' ridondante -> non si aggiunge.")
 if __name__ == "__main__":
    main()
@@ -1,109 +0,0 @@
 """GIUDICE DEI CONTENDER — valuta un segnale candidato a livello PORTAFOGLIO vs TP01.
 Per ogni (tf, sigfile): costruisce il BOOK 50/50 BTC+ETH del candidato (causale, netto fee),
 e applica il gauntlet STRETTO vs TP01:
  - standalone: FULL Sh/DD, HOLD-OUT 2025-26 Sh/ret/DD, breadth per-anno (% anni positivi, rossi
    consecutivi), correlazione a TP01;
  - contributo al portafoglio: TP01-solo vs TP01+candidato a pesi 0.2/0.3/0.5 (Δ FULL e Δ HOLD).
 VERDETTO WINNER se: (A) batte TP01 standalone (book FULL Sh>1.30, hold-out Sh>~0.25, breadth ok),
 OPPURE (B) diversificatore robusto (corr bassa, alza il portafoglio su FULL E hold-out, breadth ok).
    uv run python scripts/portfolio/verify_contender.py 1d /tmp/beat_sig_0.py 12h /tmp/beat_sig_10.py ...
 """
 from __future__ import annotations
 import sys
 import importlib.util
 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 scripts.analysis.research_lab import load_tf, _net_series
 from src.portfolio.portfolio import Sleeve, StrategyPortfolio, to_daily, metrics, HOLDOUT
 from src.portfolio.sleeves import tp01_sleeve
 TP01_FULL_SH = 1.30
 TP01_HOLD_SH = 0.31
 def load_signal(path):
    spec = importlib.util.spec_from_file_location("csig_" + Path(path).stem, path)
    m = importlib.util.module_from_spec(spec); spec.loader.exec_module(m)
    return m.signal
 def book_perbar(signal, tf) -> pd.Series:
    s = {}
    for a in ("BTC", "ETH"):
        df = load_tf(a, tf)
        net, _, _, _ = _net_series(df, np.asarray(signal(df, a, tf), float))
        s[a] = pd.Series(net, index=pd.to_datetime(df["timestamp"], unit="ms", utc=True))
    J = pd.concat(s, axis=1, join="inner").fillna(0.0)
    return pd.Series(0.5 * J["BTC"].values + 0.5 * J["ETH"].values, index=J.index)
 def breadth(daily):
    pre = daily[daily.index < HOLDOUT]
    yr = [float((1 + g).prod() - 1) for _, g in pre.groupby(pre.index.year)]
    consec = mx = 0
    for v in yr:
        consec = consec + 1 if v < 0 else 0; mx = max(mx, consec)
    return (sum(v > 0 for v in yr) / len(yr) if yr else 0.0), mx, yr
 def main():
    args = sys.argv[1:]
    pairs = [(args[i], args[i + 1]) for i in range(0, len(args) - 1, 2)]
    tp = tp01_sleeve(1.0)
    tp_daily = tp.daily()
    base = StrategyPortfolio([tp01_sleeve(1.0)]).backtest()
    print("=" * 100)
    print(f"  GIUDICE CONTENDER vs TP01 (book FULL Sh {base['full']['sharpe']:.2f} / HOLD {base['holdout']['sharpe']:.2f})")
    print("=" * 100)
    winners = []
    for tf, sig in pairs:
        name = Path(sig).stem
        try:
            signal = load_signal(sig)
            pb = book_perbar(signal, tf)
            d = to_daily(pb)
        except Exception as e:
            print(f"\n  {name} ({tf}): ERRORE {type(e).__name__}: {str(e)[:80]}"); continue
        f = metrics(d); h = metrics(d[d.index >= HOLDOUT])
        J = pd.concat({"tp": tp_daily, "x": d}, axis=1, join="inner").dropna()
        corr = float(J["tp"].corr(J["x"])) if len(J) > 2 else float("nan")
        pct, consec, yr = breadth(d)
        print(f"\n  {name} ({tf})  BOOK 50/50")
        print(f"    standalone: FULL Sh {f['sharpe']:>5.2f} DD {f['maxdd']*100:>4.1f}% | HOLD Sh {h['sharpe']:>5.2f} ret {h['ret']*100:>+6.1f}% DD {h['maxdd']*100:>4.1f}%"
              f" | anni+ {pct*100:>3.0f}% rossi-consec {consec} | corr_TP01 {corr:+.2f} | turn n/a")
        # contributo al portafoglio
        contrib = []
        for w in (0.2, 0.3, 0.5):
            sl = Sleeve(name, w, lambda pb=pb: pb)
            bt = StrategyPortfolio([tp01_sleeve(1 - w), sl]).backtest()
            dF = bt["full"]["sharpe"] - base["full"]["sharpe"]
            dH = bt["holdout"]["sharpe"] - base["holdout"]["sharpe"]
            contrib.append((w, bt["full"]["sharpe"], dF, bt["holdout"]["sharpe"], dH))
            print(f"    +TP01 w{w:.0%}: FULL {bt['full']['sharpe']:.2f} ({dF:+.2f}) | HOLD {bt['holdout']['sharpe']:.2f} ({dH:+.2f})")
        breadth_ok = pct >= 0.6 and consec <= 1
        standalone_beats = f["sharpe"] > TP01_FULL_SH and h["sharpe"] > 0.25 and breadth_ok
        # diversificatore: corr<0.5, migliora FULL E hold del portafoglio ad almeno un peso, breadth ok
        improves = any(dF > 0.05 and dH > 0.0 for _, _, dF, _, dH in contrib)
        diversifier = (not np.isnan(corr) and corr < 0.5) and improves and breadth_ok
        verdict = "WINNER-standalone" if standalone_beats else ("WINNER-diversifier" if diversifier else "no")
        print(f"    -> {verdict}  (breadth_ok={breadth_ok}, standalone_beats={standalone_beats}, diversifier={diversifier})")
        if verdict.startswith("WINNER"):
            winners.append((name, tf, verdict))
    print("\n" + "=" * 100)
    print(f"  WINNERS: {len(winners)}")
    for n, tf, v in winners:
        print(f"    {n} ({tf}): {v}")
    if not winners:
        print("    nessuno batte TP01 con criterio onesto -> serve un'altra ondata.")
 if __name__ == "__main__":
    main()
@@ -1,108 +0,0 @@
 """AFFINAMENTO XS01 — blend di LOOKBACK (multi-orizzonte cross-sectional).
 XS01 attuale usa un singolo lookback (L=30). Come TP01 fonde gli orizzonti 30/90/180, qui il
 momentum cross-sectional fonde piu' lookback: per ogni ribilancio, z-score cross-sectional del
 rendimento a ciascun L, MEDIATO -> punteggio blended -> long top-k / short bottom-k. Piu' liscio
 e robusto (meno dipendente da un singolo orizzonte/regime). Causale, netto fee, vol-target.
 Confronto vs singolo-L + contributo al portafoglio TP01+XS01.
    uv run python scripts/portfolio/xsec_blend.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, pandas as pd
 from src.portfolio.portfolio import to_daily, metrics, HOLDOUT, Sleeve, StrategyPortfolio
 from src.portfolio.sleeves import tp01_sleeve, XS_UNIVERSE
 RAW = PROJECT_ROOT / "data" / "raw"
 FEE = 0.001
 def load_majors():
    cols = {}
    for sym in XS_UNIVERSE:
        p = RAW / f"hl_{sym.lower()}_1d.parquet"
        if p.exists():
            d = pd.read_parquet(p)
            cols[sym] = pd.Series(d["close"].values.astype(float), index=pd.to_datetime(d["timestamp"], unit="ms", utc=True))
    return pd.concat(cols, axis=1, join="inner").sort_index().dropna()
 def xs_signal(C, lookbacks, H=10, k=5, mode="mom", tv=0.20):
    """lookbacks = lista (blend) o singolo [L]. Score = media z-score cross-sectional dei ret_L."""
    px = C.values; n, A = px.shape
    dret = np.vstack([np.zeros(A), px[1:] / px[:-1] - 1.0])
    W = np.zeros((n, A)); w = np.zeros(A)
    for i in range(n):
        if i >= max(lookbacks) and i % H == 0:
            score = np.zeros(A); cnt = 0
            for L in lookbacks:
                rL = px[i] / px[i - L] - 1.0
                sd = rL.std()
                if sd > 0:
                    score += (rL - rL.mean()) / sd; cnt += 1
            if cnt:
                score /= cnt
                order = np.argsort(score)
                w = np.zeros(A); lo, hi = order[:k], order[-k:]
                if mode == "mom": w[hi] = 0.5 / k; w[lo] = -0.5 / k
                else: w[lo] = 0.5 / k; w[hi] = -0.5 / k
        W[i] = w
    gross = np.zeros(n); gross[1:] = np.sum(W[:-1] * dret[1:], axis=1)
    turn = np.zeros(n); turn[0] = np.abs(W[0]).sum(); turn[1:] = np.abs(np.diff(W, axis=0)).sum(axis=1)
    s = pd.Series(gross - turn * (FEE / 2.0), index=C.index)
    rv = s.rolling(30, min_periods=15).std().shift(1) * np.sqrt(365.25)
    scale = np.clip(np.nan_to_num(tv / rv.replace(0, np.nan).values, nan=0.0), 0, 3.0)
    return to_daily(pd.Series(s.values * scale, index=C.index))
 def ev(C, lbs, tp):
    d = xs_signal(C, lbs)
    f = metrics(d); o = metrics(d[d.index >= HOLDOUT])
    yr = [float((1 + g).prod() - 1) for _, g in d.groupby(d.index.year)]
    pct = sum(v > 0 for v in yr) / len(yr) if yr else 0
    corr = float(pd.concat({"a": tp, "b": d}, axis=1, join="inner").dropna().corr().iloc[0, 1])
    return d, f, o, pct, corr
 def main():
    C = load_majors()
    tp = tp01_sleeve().daily()
    print("=" * 92)
    print(f"  AFFINAMENTO XS01 — blend di lookback (19 major, {len(C)} giorni)")
    print("=" * 92)
    print(f"  {'lookbacks':<22}{'FULL':>7}{'OOS25':>7}{'DD%':>6}{'anni+':>7}{'corrTP':>8}")
    configs = [
        ("[30] (attuale)", [30]), ("[90]", [90]), ("[20]", [20]),
        ("[20,40]", [20, 40]), ("[20,60]", [20, 60]), ("[30,90]", [30, 90]),
        ("[20,40,90]", [20, 40, 90]), ("[30,60,120]", [30, 60, 120]),
        ("[20,60,180]", [20, 60, 180]), ("[15,30,60,120]", [15, 30, 60, 120]),
    ]
    rows = []
    for name, lbs in configs:
        d, f, o, pct, corr = ev(C, lbs, tp)
        rows.append((name, lbs, d, f, o, pct, corr))
        print(f"  {name:<22}{f['sharpe']:>7.2f}{o['sharpe']:>7.2f}{f['maxdd']*100:>6.0f}{pct*100:>6.0f}%{corr:>+8.2f}")
    # candidato: miglior blend per (FULL+OOS) con breadth 100% e corr bassa
    cand = [r for r in rows if r[5] >= 0.99 and r[6] < 0.4]
    cand.sort(key=lambda r: -(r[3]["sharpe"] + r[4]["sharpe"]))
    print("\n  CONTRIBUTO al portafoglio — attuale (XS [30]) vs miglior blend")
    base_xs = rows[0][2]   # [30]
    for label, dxs in [("XS [30] attuale", base_xs)] + ([(cand[0][0], cand[0][2])] if cand else []):
        J = pd.concat({"tp": tp, "xs": dxs}, axis=1, join="inner").dropna()
        for w in (0.3,):
            comb = (1 - w) * J["tp"] + w * J["xs"]
            cf, ch = metrics(comb), metrics(comb[comb.index >= HOLDOUT])
            xf = metrics(J["xs"]); xo = metrics(J["xs"][J["xs"].index >= HOLDOUT])
            print(f"    {label:<22} XS-solo FULL {xf['sharpe']:.2f}/OOS {xo['sharpe']:.2f} | TP01 70+XS 30: FULL {cf['sharpe']:.2f} HOLD {ch['sharpe']:.2f}")
    if cand:
        print(f"\n  -> blend migliore: {cand[0][0]} (lookbacks {cand[0][1]}). Promuovere se batte [30] su")
        print("     FULL+OOS+robustezza E migliora il portafoglio. Sennò resta [30].")
 if __name__ == "__main__":
    main()
@@ -1,101 +0,0 @@
 """AFFINAMENTO XS01 — GATE DI DISPERSIONE.
 Il momentum cross-sectional vive nella DISPERSIONE (winners/losers distanti). In regime compatto
 (tutti gli asset si muovono insieme) non ha segnale -> churn/rumore. Gate: entra SOLO se la
 dispersione cross-section del momentum supera una soglia CAUSALE (percentile espandente della
 dispersione passata); altrimenti flat. Sul blend [30,90] dei 19 major. Sweep soglia + contributo.
    uv run python scripts/portfolio/xsec_dispgate.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, pandas as pd
 from src.portfolio.portfolio import to_daily, metrics, HOLDOUT
 from src.portfolio.sleeves import tp01_sleeve, XS_UNIVERSE
 RAW = PROJECT_ROOT / "data" / "raw"
 FEE = 0.001
 LOOKBACKS = (30, 90); H = 10; K = 5; TV = 0.20
 def load_majors():
    cols = {}
    for sym in XS_UNIVERSE:
        p = RAW / f"hl_{sym.lower()}_1d.parquet"
        if p.exists():
            d = pd.read_parquet(p)
            cols[sym] = pd.Series(d["close"].values.astype(float), index=pd.to_datetime(d["timestamp"], unit="ms", utc=True))
    return pd.concat(cols, axis=1, join="inner").sort_index().dropna()
 def xs_gated(C, disp_pct=0, min_hist=20):
    px = C.values; n, A = px.shape
    dret = np.vstack([np.zeros(A), px[1:] / px[:-1] - 1.0])
    mlb = max(LOOKBACKS)
    # dispersione del momentum a ogni barra: media (su lookback) della std cross-section di ret_L
    disp = np.full(n, np.nan)
    for i in range(mlb, n):
        acc = 0.0; c = 0
        for L in LOOKBACKS:
            acc += (px[i] / px[i - L] - 1.0).std(); c += 1
        disp[i] = acc / c
    W = np.zeros((n, A)); w = np.zeros(A)
    hist = []
    gated_flat = 0; total = 0
    for i in range(n):
        if i >= mlb and i % H == 0:
            thr = np.percentile(hist, disp_pct) if (disp_pct > 0 and len(hist) >= min_hist) else -np.inf
            total += 1
            if disp[i] >= thr:
                score = np.zeros(A)
                for L in LOOKBACKS:
                    rL = px[i] / px[i - L] - 1.0; sd = rL.std()
                    if sd > 0:
                        score += (rL - rL.mean()) / sd
                order = np.argsort(score); w = np.zeros(A); lo, hi = order[:K], order[-K:]
                w[hi] = 0.5 / K; w[lo] = -0.5 / K
            else:
                w = np.zeros(A); gated_flat += 1
            hist.append(disp[i])
        W[i] = w
    gross = np.zeros(n); gross[1:] = np.sum(W[:-1] * dret[1:], axis=1)
    turn = np.zeros(n); turn[0] = np.abs(W[0]).sum(); turn[1:] = np.abs(np.diff(W, axis=0)).sum(axis=1)
    s = pd.Series(gross - turn * (FEE / 2.0), index=C.index)
    rv = s.rolling(30, min_periods=15).std().shift(1) * np.sqrt(365.25)
    scale = np.clip(np.nan_to_num(TV / rv.replace(0, np.nan).values, nan=0.0), 0, 3.0)
    return to_daily(pd.Series(s.values * scale, index=C.index)), (gated_flat / total if total else 0)
 def main():
    C = load_majors(); tp = tp01_sleeve().daily()
    print("=" * 92)
    print(f"  AFFINAMENTO XS01 — gate di dispersione (blend [30,90], 19 major, {len(C)}g)")
    print("=" * 92)
    print(f"  {'soglia pctile':<16}{'FULL':>7}{'OOS25':>7}{'DD%':>6}{'anni+':>7}{'corrTP':>8}{'%flat':>8}")
    res = {}
    for p in (0, 30, 40, 50, 60, 70):
        d, flat = xs_gated(C, p)
        f = metrics(d); o = metrics(d[d.index >= HOLDOUT])
        yr = [float((1 + g).prod() - 1) for _, g in d.groupby(d.index.year)]
        pct = sum(v > 0 for v in yr) / len(yr) if yr else 0
        corr = float(pd.concat({"a": tp, "b": d}, axis=1, join="inner").dropna().corr().iloc[0, 1])
        res[p] = (d, f, o, pct, corr)
        lab = "0 (no gate)" if p == 0 else f"p{p}"
        print(f"  {lab:<16}{f['sharpe']:>7.2f}{o['sharpe']:>7.2f}{f['maxdd']*100:>6.0f}{pct*100:>6.0f}%{corr:>+8.2f}{flat*100:>7.0f}%")
    print("\n  CONTRIBUTO al portafoglio (TP01 70 + XS 30, finestra comune):")
    for p in (0, 40, 50, 60):
        d = res[p][0]
        J = pd.concat({"tp": tp, "xs": d}, axis=1, join="inner").dropna()
        comb = 0.7 * J["tp"] + 0.3 * J["xs"]
        cf, ch = metrics(comb), metrics(comb[comb.index >= HOLDOUT])
        lab = "no gate (attuale)" if p == 0 else f"gate p{p}"
        print(f"    {lab:<18} FULL Sh {cf['sharpe']:.2f} DD {cf['maxdd']*100:.0f}% | HOLD Sh {ch['sharpe']:.2f}")
    print("\n  -> promuovere il gate se migliora Sharpe/DD/robustezza E il contributo. Sennò no-gate resta.")
 if __name__ == "__main__":
    main()
@@ -1,133 +0,0 @@
 """XS cross-sectional con UNIVERSO TOP-LIQUIDITÀ DINAMICO (Hyperliquid 52 certificati).
 Invece di 19 nomi fissi, a ogni ribilancio: seleziona i top-N per liquidità (dollar-volume 30g
 causale), poi fra quelli long i k più forti / short i k più deboli (momentum, market-neutral),
 vol-target. Idea: cross-section pulita e ADATTIVA (i token entrano quando maturano in liquidità),
 escludendo il long-tail rumoroso che diluiva il 52-all. Gestione ragged (asset a date diverse:
 si classifica solo fra i disponibili). Causale. Confronto vs fisso-19 + 52-all + contributo TP01.
    uv run python scripts/portfolio/xsec_dynuniverse.py
 """
 from __future__ import annotations
 import sys, glob
 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.portfolio import to_daily, metrics, HOLDOUT
 from src.portfolio.sleeves import tp01_sleeve, XS_UNIVERSE
 RAW = PROJECT_ROOT / "data" / "raw"
 FEE = 0.001
 def load_close_vol():
    close, vol = {}, {}
    for p in sorted(glob.glob(str(RAW / "hl_*_1d.parquet"))):
        sym = Path(p).stem.replace("hl_", "").replace("_1d", "").upper()
        d = pd.read_parquet(p)
        ix = pd.to_datetime(d["timestamp"], unit="ms", utc=True)
        close[sym] = pd.Series(d["close"].values.astype(float), index=ix)
        vol[sym] = pd.Series(d["volume"].values.astype(float), index=ix)
    C = pd.concat(close, axis=1, join="outer").sort_index()
    V = pd.concat(vol, axis=1, join="outer").sort_index().reindex(C.index)
    return C, V
 def xs_dynamic(C, V, N=20, lb=60, hold=10, k=5, mode="mom", tv=0.20, fixed=None):
    """fixed=lista simboli -> universo statico (ignora liquidità). Altrimenti top-N per liquidità."""
    cols = list(C.columns); A = len(cols)
    px = C.values; n = len(px)
    dret = np.full((n, A), 0.0); dret[1:] = np.where(np.isfinite(px[1:]) & np.isfinite(px[:-1]), px[1:] / px[:-1] - 1.0, 0.0)
    dvol = V.values * px
    liq = pd.DataFrame(dvol, index=C.index, columns=cols).rolling(30, min_periods=15).mean().shift(1).values
    fixed_mask = np.array([c in fixed for c in cols]) if fixed else None
    W = np.zeros((n, A)); w = np.zeros(A)
    for i in range(n):
        if i >= lb and i % hold == 0:
            retlb = np.where(np.isfinite(px[i]) & np.isfinite(px[i - lb]), px[i] / px[i - lb] - 1.0, np.nan)
            avail = np.isfinite(retlb) & np.isfinite(px[i])
            if fixed is not None:
                avail &= fixed_mask
                cand = np.where(avail)[0]
            else:
                avail &= np.isfinite(liq[i])
                idx = np.where(avail)[0]
                if len(idx) > N:
                    cand = idx[np.argsort(liq[i][idx])[-N:]]   # top-N per liquidità
                else:
                    cand = idx
            w = np.zeros(A)
            ke = min(k, len(cand) // 2)
            if ke >= 1:
                order = cand[np.argsort(retlb[cand])]
                lo, hi = order[:ke], order[-ke:]
                if mode == "mom": w[hi] = 0.5 / ke; w[lo] = -0.5 / ke
                else: w[lo] = 0.5 / ke; w[hi] = -0.5 / ke
        W[i] = w
    gross = np.zeros(n); gross[1:] = np.sum(W[:-1] * dret[1:], axis=1)
    turn = np.zeros(n); turn[0] = np.abs(W[0]).sum(); turn[1:] = np.abs(np.diff(W, axis=0)).sum(axis=1)
    net = gross - turn * (FEE / 2.0)
    s = pd.Series(net, index=C.index)
    rv = s.rolling(30, min_periods=15).std().shift(1) * np.sqrt(365.25)
    scale = np.clip(np.nan_to_num(tv / rv.replace(0, np.nan).values, nan=0.0), 0, 3.0)
    return to_daily(pd.Series(s.values * scale, index=C.index))
 def ev(d):
    f = metrics(d); o = metrics(d[d.index >= HOLDOUT])
    yr = [float((1 + g).prod() - 1) for _, g in d.groupby(d.index.year)]
    pct = sum(v > 0 for v in yr) / len(yr) if yr else 0
    return f, o, pct
 def main():
    C, V = load_close_vol()
    print("=" * 96)
    print(f"  XS UNIVERSO TOP-LIQUIDITÀ DINAMICO — {len(C.columns)} asset certificati [{C.index[0].date()} -> {C.index[-1].date()}]")
    print("=" * 96)
    tp = tp01_sleeve().daily()
    print("\n  (1) SWEEP N (top-liquidità) x config (mom) — FULL Sh / OOS25 Sh / anni+ / corrTP")
    print(f"    {'config':<28}{'FULL':>7}{'OOS25':>7}{'anni+':>7}{'corrTP':>8}")
    best = None
    for N in (12, 15, 20, 25):
        for lb, hold, k in [(30, 10, 5), (60, 10, 5), (90, 10, 5)]:
            d = xs_dynamic(C, V, N=N, lb=lb, hold=hold, k=k)
            f, o, pct = ev(d)
            corr = float(pd.concat({"a": tp, "b": d}, axis=1, join="inner").dropna().corr().iloc[0, 1])
            tag = f"top{N} L{lb}H{hold}k{k}"
            print(f"    {tag:<28}{f['sharpe']:>7.2f}{o['sharpe']:>7.2f}{pct*100:>6.0f}%{corr:>+8.2f}")
            if (best is None or f['sharpe'] > best[1]['sharpe']) and corr < 0.4 and o['sharpe'] > 0:
                best = (tag, f, o, corr, d, (N, lb, hold, k))
    print("\n  (2) BASELINE di confronto (stessa finestra):")
    for name, kw in [("fisso-19 major (L30H10k5)", dict(lb=30, hold=10, k=5, fixed=set(XS_UNIVERSE))),
                     ("fisso-19 major (L90H10k5)", dict(lb=90, hold=10, k=5, fixed=set(XS_UNIVERSE))),
                     ("52-all (L60H10k5)", dict(lb=60, hold=10, k=5))]:
        d = xs_dynamic(C, V, **kw); f, o, pct = ev(d)
        print(f"    {name:<28} FULL {f['sharpe']:.2f}  OOS25 {o['sharpe']:.2f}  anni+ {pct*100:.0f}%")
    if best is None:
        print("\n  Nessuna config dinamica scorrelata+positiva. Il top-liquidità non aiuta.")
        return
    tag, f, o, corr, d, cfg = best
    print(f"\n  === MIGLIOR DINAMICO: {tag} | FULL {f['sharpe']:.2f} ret {f['ret']*100:+.0f}% DD {f['maxdd']*100:.0f}% | OOS25 {o['sharpe']:.2f} | corrTP {corr:+.2f} ===")
    per = [(int(y), round(float((1 + g).prod() - 1), 3)) for y, g in d.groupby(d.index.year)]
    print(f"  per-anno: {per}")
    # contributo al portafoglio vs fisso-19 (XS01 attuale)
    xs19 = xs_dynamic(C, V, lb=30, hold=10, k=5, fixed=set(XS_UNIVERSE))
    J = pd.concat({"tp": tp, "dyn": d, "x19": xs19}, axis=1, join="inner").dropna()
    print(f"\n  CONTRIBUTO (finestra comune {J.index[0].date()}->{J.index[-1].date()}):")
    for nm, col in [("TP01 solo", None), ("TP01+XS19 (attuale) 70/30", "x19"), ("TP01+DYN 70/30", "dyn")]:
        if col is None:
            comb = J["tp"]
        else:
            comb = 0.7 * J["tp"] + 0.3 * J[col]
        mf = metrics(comb); mh = metrics(comb[comb.index >= HOLDOUT])
        print(f"    {nm:<28} FULL Sh {mf['sharpe']:.2f} DD {mf['maxdd']*100:.0f}% | HOLD Sh {mh['sharpe']:.2f}")
    print("\n  -> DINAMICO meglio del fisso-19? guarda FULL/OOS + contributo. Sennò: fisso-19 resta.")
 if __name__ == "__main__":
    main()
@@ -1,123 +0,0 @@
 """CROSS-SECTIONAL su universo Hyperliquid certificato (19 alt, 1d, 2024-2026).
 Strategia market-neutral: ogni H giorni classifica gli asset per rendimento a L giorni (causale),
 va long i top-k / short i bottom-k (momentum) o viceversa (reversal), dollar-neutral, vol-target.
 Mira a DIVERSIFICARE TP01 (long-trend): se scorrelata e robusta, migliora il portafoglio.
 Gauntlet onesto: FULL (2024-26) + within-window OOS (2025+) + per-anno + corr TP01 + contributo.
 Caveat: storia corta (~2.5 anni). Risultati suggestivi, non robusti come BTC/ETH 6 anni.
    uv run python scripts/portfolio/xsec_research.py
 """
 from __future__ import annotations
 import sys, glob
 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.portfolio import to_daily, metrics, HOLDOUT, Sleeve, StrategyPortfolio
 from src.portfolio.sleeves import tp01_sleeve
 RAW = PROJECT_ROOT / "data" / "raw"
 FEE = 0.001
 def load_universe():
    cols = {}
    for f in sorted(glob.glob(str(RAW / "hl_*_1d.parquet"))):
        s = Path(f).stem.replace("hl_", "").replace("_1d", "").upper()
        d = pd.read_parquet(f)
        cols[s] = pd.Series(d["close"].values.astype(float), index=pd.to_datetime(d["timestamp"], unit="ms", utc=True))
    C = pd.concat(cols, axis=1, join="inner").sort_index().dropna()
    return C
 def xs_book(C, L, H, k, mode="mom", target_vol=0.20):
    """Rendimenti netti giornalieri di un book cross-sectional market-neutral. Causale."""
    assets = list(C.columns); A = len(assets)
    px = C.values; n = len(px)
    dret = np.vstack([np.zeros(A), px[1:] / px[:-1] - 1.0])
    W = np.zeros((n, A))            # peso per asset per giorno (deciso a close[i], tenuto in i+1)
    w = np.zeros(A)
    for i in range(n):
        if i >= L and i % H == 0:
            lb = px[i] / px[i - L] - 1.0
            order = np.argsort(lb)
            w = np.zeros(A)
            lo, hi = order[:k], order[-k:]            # peggiori / migliori
            if mode == "mom":
                w[hi] = 0.5 / k; w[lo] = -0.5 / k     # long forti / short deboli
            else:
                w[lo] = 0.5 / k; w[hi] = -0.5 / k     # reversal
        W[i] = w
    # rendimento book: peso[i-1] guadagna dret[i]; fee su turnover
    gross = np.zeros(n); gross[1:] = np.sum(W[:-1] * dret[1:], axis=1)   # W[i-1] guadagna dret[i]
    turn = np.zeros(n); turn[0] = np.abs(W[0]).sum()
    turn[1:] = np.abs(np.diff(W, axis=0)).sum(axis=1)                    # turnover per (ri)settare W[i]
    net = gross - turn * (FEE / 2.0)
    s = pd.Series(net, index=C.index)
    # vol-target (causale): scala per target/vol_realizzata(30) shiftata
    rv = s.rolling(30, min_periods=15).std().shift(1) * np.sqrt(365.25)
    scale = np.clip(np.nan_to_num(target_vol / rv.replace(0, np.nan).values, nan=0.0), 0, 3.0)
    return pd.Series(s.values * scale, index=C.index)
 def yr_breadth(daily):
    pre = daily
    yr = [float((1 + g).prod() - 1) for _, g in pre.groupby(pre.index.year)]
    consec = mx = 0
    for v in yr: consec = consec + 1 if v < 0 else 0; mx = max(mx, consec)
    return yr, (sum(v > 0 for v in yr) / len(yr) if yr else 0), mx
 def main():
    C = load_universe()
    print("=" * 96)
    print(f"  CROSS-SECTIONAL Hyperliquid — {len(C.columns)} asset, {len(C)} giorni [{C.index[0].date()} -> {C.index[-1].date()}]")
    print("=" * 96)
    tp = tp01_sleeve(1.0); tp_daily = tp.daily()
    base = StrategyPortfolio([tp01_sleeve(1.0)]).backtest()
    print(f"\n  {'config':<24}{'FULL Sh':>9}{'OOS25 Sh':>10}{'ret%':>8}{'DD%':>7}{'corrTP':>8}{'anni+':>7}")
    cands = []
    grid = [("mom",L,H,k) for L in (30,60,90) for H in (5,10,20) for k in (3,5)] \
         + [("rev",L,H,k) for L in (3,7,14) for H in (3,5) for k in (3,5)]
    for mode,L,H,k in grid:
        d = to_daily(xs_book(C,L,H,k,mode))
        f=metrics(d); oos=metrics(d[d.index>=HOLDOUT])
        J=pd.concat({"tp":tp_daily,"x":d},axis=1,join="inner").dropna(); corr=float(J["tp"].corr(J["x"])) if len(J)>5 else float("nan")
        yr,pct,consec=yr_breadth(d)
        tag=f"{mode} L{L} H{H} k{k}"
        cands.append((tag,mode,L,H,k,f,oos,corr,pct,consec,d))
        if f["sharpe"]>0.6 or oos["sharpe"]>0.8:
            print(f"  {tag:<24}{f['sharpe']:>9.2f}{oos['sharpe']:>10.2f}{f['ret']*100:>+8.0f}{f['maxdd']*100:>7.1f}{corr:>+8.2f}{pct*100:>6.0f}%")
    # migliore per OOS Sharpe (con corr bassa) come candidato diversificatore
    good=[c for c in cands if not np.isnan(c[7]) and abs(c[7])<0.4 and c[5]["sharpe"]>0.5 and c[6]["sharpe"]>0]
    good.sort(key=lambda c:-(c[6]["sharpe"]))
    print(f"\n  Candidati scorrelati(<0.4) e positivi (FULL>0.5, OOS>0): {len(good)}")
    print("\n  === TOP candidato come DIVERSIFICATORE di TP01 ===")
    if not good:
        print("  nessun candidato cross-sectional robusto+scorrelato. Universo corto.")
        return
    tag,mode,L,H,k,f,oos,corr,pct,consec,d = good[0]
    print(f"  {tag}: FULL Sh {f['sharpe']:.2f} ret {f['ret']*100:+.0f}% DD {f['maxdd']*100:.1f}% | OOS25 Sh {oos['sharpe']:.2f} | corr TP01 {corr:+.2f} | anni+ {pct*100:.0f}% rossi-consec {consec}")
    per=[(y,round(v,3)) for y,(v) in zip([yy for yy,_ in d.groupby(d.index.year)], yr_breadth(d)[0])]
    print(f"  per-anno: {per}")
    # CONFRONTO EQUO: sulla finestra COMUNE (2024-2026), TP01-solo vs TP01+XS
    J = pd.concat({"tp": tp_daily, "xs": d}, axis=1, join="inner").dropna()
    tpw, xsw = J["tp"], J["xs"]
    bw_f = metrics(tpw); bw_h = metrics(tpw[tpw.index >= HOLDOUT])
    print(f"\n  [finestra comune {J.index[0].date()}->{J.index[-1].date()}]")
    print(f"  TP01 SOLO (su finestra comune): FULL Sh {bw_f['sharpe']:.2f} DD {bw_f['maxdd']*100:.1f}% | HOLD Sh {bw_h['sharpe']:.2f}")
    for w in (0.2, 0.3, 0.5):
        comb = (1 - w) * tpw + w * xsw
        cf = metrics(comb); ch = metrics(comb[comb.index >= HOLDOUT])
        print(f"  +XS w{w:.0%}: FULL {cf['sharpe']:.2f} ({cf['sharpe']-bw_f['sharpe']:+.2f}) DD {cf['maxdd']*100:.1f}%"
              f" | HOLD {ch['sharpe']:.2f} ({ch['sharpe']-bw_h['sharpe']:+.2f})")
    print("\n  WINNER-diversifier se: corr bassa, e TP01+XS batte TP01-solo (FULL E HOLD) sulla finestra comune,")
    print("  con breadth per-anno ok. Altrimenti no (e attenzione: storia XS solo ~2.5 anni).")
 if __name__=="__main__":
    main()
@@ -1,586 +0,0 @@
 """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 sys
 from functools import lru_cache
 from pathlib import Path
 import numpy as np
 import pandas as pd
 # --- 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 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      -> meaningfully lifts the OOS blend and is not just leverage-of-trend
      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."""
    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
    out["robust_oos"] = False
    if has_h:
        ww = 0.25
        def _u(sub):
            return _sh((1 - ww) * sub["B"] + ww * sub["C"]) - _sh(sub["B"])
        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
        out["robust_oos"] = bool(cu is not None and cu > 0.02 and jk is not None and jk > 0.0)
    # verdict (weight 0.25 = a satellite slot; hold-out is what the defensive stack cares about)
    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_h is not None and up_h >= 0.05 and up_f > -0.15 and ch < 0.85:
        v = "ADDS"
    elif up_f <= -0.10 and (up_h is None or up_h <= 0.0):
        v = "DILUTES"
    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"]
    earns_slot = (abs_grade != "FAIL" and marg.get("marginal_verdict") == "ADDS"
                  and marg.get("robust_oos", 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"  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)
 # ===========================================================================
 # 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])
@@ -1,96 +0,0 @@
 """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"])
@@ -1,136 +0,0 @@
 """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)")
@@ -1,74 +0,0 @@
 """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))
@@ -1,107 +0,0 @@
 """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))
@@ -1,75 +0,0 @@
 """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))
@@ -1,89 +0,0 @@
 """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))
@@ -1,75 +0,0 @@
 """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))
@@ -1,68 +0,0 @@
 """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))
@@ -1,79 +0,0 @@
 """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))
@@ -1,104 +0,0 @@
 """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))
@@ -1,107 +0,0 @@
 """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))
@@ -1,100 +0,0 @@
 """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))
@@ -1,129 +0,0 @@
 """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))
@@ -1,187 +0,0 @@
 """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()
@@ -1,257 +0,0 @@
 """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))
@@ -1,97 +0,0 @@
 """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))
@@ -1,108 +0,0 @@
 """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))
@@ -1,165 +0,0 @@
 """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))
@@ -1,62 +0,0 @@
 """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))
@@ -1,114 +0,0 @@
 """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))
@@ -1,105 +0,0 @@
 """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))
@@ -1,81 +0,0 @@
 """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))
@@ -1,82 +0,0 @@
 """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))
@@ -1,84 +0,0 @@
 """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))
@@ -1,131 +0,0 @@
 """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))
@@ -1,57 +0,0 @@
 """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))
@@ -1,84 +0,0 @@
 """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))
@@ -1,131 +0,0 @@
 """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))
@@ -1,128 +0,0 @@
 """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()
@@ -1,135 +0,0 @@
 """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))
@@ -1,125 +0,0 @@
 """MRV05 — Williams %R Mean-Reversion
 HYPOTHESIS: Buy when %R(14) < -90 (oversold) with trend filter (close > SMA200);
 exit (go flat) when %R > -50 (momentum restored). Long-flat only.
 Williams %R = (Highest High(n) - Close) / (Highest High(n) - Lowest Low(n)) * -100
 Range: -100 (most oversold) to 0 (most overbought).
 %R < -80 = oversold zone; %R > -20 = overbought zone.
 The exit condition (%R > -50) is causal: we check %R[i] and decide position for bar i+1.
 This maps naturally to study_weights (continuous hold logic):
  - position[i] = 1 if %R[i] < -90 AND close[i] > SMA200[i] (buy signal)
  - position[i] = 0 if %R[i] > -50 (exit signal)
  - else hold previous position
 Variants (small grid, 4 configs):
  V1: %R entry -90, exit -50, SMA200 trend filter, long-flat
  V2: %R entry -85, exit -50, SMA200 trend filter, long-flat (slightly less oversold entry)
  V3: %R entry -90, exit -50, SMA50 trend filter, long-flat (shorter trend filter)
  V4: %R entry -90, exit -40, SMA200 trend filter, long-flat (later exit)
 Best variant selected by min-asset hold-out Sharpe.
 All positions are vol-targeted (20% annualized, 2x leverage cap).
 """
 import sys
 sys.path.insert(0, "/opt/docker/PythagorasGoal/scripts/research/alt")
 import altlib as al
 import numpy as np
 import pandas as pd
 # ---------------------------------------------------------------------------
 # Williams %R calculation (causal: uses data <= bar i)
 # ---------------------------------------------------------------------------
 def williams_r(df: pd.DataFrame, win: int = 14) -> np.ndarray:
    """Causal Williams %R. Value at i uses data[i-win+1 .. i].
    %R = (HH - Close) / (HH - LL) * -100
    Range: -100 (oversold) to 0 (overbought).
    """
    h = df["high"].values.astype(float)
    l = df["low"].values.astype(float)
    c = df["close"].values.astype(float)
    n = len(c)
    wr = np.full(n, np.nan)
    # Vectorized rolling using pandas
    hh = pd.Series(h).rolling(win, min_periods=win).max().values
    ll = pd.Series(l).rolling(win, min_periods=win).min().values
    rng = hh - ll
    # Avoid division by zero
    valid = rng > 0
    wr[valid] = (hh[valid] - c[valid]) / rng[valid] * -100.0
    return wr
 # ---------------------------------------------------------------------------
 # Strategy factory
 # ---------------------------------------------------------------------------
 def make_wrpct_target(wr_entry: float = -90.0, wr_exit: float = -50.0,
                      sma_win: int = 200, wr_win: int = 14):
    """Williams %R long-flat mean-reversion with trend filter.
    Entry: %R[i] < wr_entry AND close[i] > SMA(sma_win)[i] -> go long
    Exit:  %R[i] > wr_exit  -> go flat
    Hold:  otherwise, maintain current position
    Causal: position decided using data <= close[i], held during bar i+1.
    Vol-targeted: 20% annualized, 2x leverage cap.
    """
    def target_fn(df):
        c = df["close"].values.astype(float)
        wr = williams_r(df, wr_win)
        sma_trend = al.sma(c, sma_win)
        # Vectorized state machine using ffill
        # Signal: 1 = enter long, 0 = exit to flat, NaN = hold
        # Priority: exit takes precedence over entry
        sig = np.where(
            wr > wr_exit,                              # exit condition
            0.0,
            np.where(
                (wr < wr_entry) & (c > sma_trend),    # entry condition
                1.0,
                np.nan                                  # hold
            )
        )
        # Start flat
        sig[0] = 0.0
        # Forward-fill NaN (hold previous position)
        pos = pd.Series(sig).ffill().fillna(0.0).values
        # Vol-target
        return al.vol_target(pos, df, target_vol=0.20, vol_win_days=30, leverage_cap=2.0)
    return target_fn
 # ---------------------------------------------------------------------------
 # Run all variants and pick best
 # ---------------------------------------------------------------------------
 if __name__ == "__main__":
    TFS = ("1d",)
    variants = [
        ("MRV05-V1-WR90-exit50-SMA200", make_wrpct_target(-90.0, -50.0, 200, 14)),
        ("MRV05-V2-WR85-exit50-SMA200", make_wrpct_target(-85.0, -50.0, 200, 14)),
        ("MRV05-V3-WR90-exit50-SMA50",  make_wrpct_target(-90.0, -50.0,  50, 14)),
        ("MRV05-V4-WR90-exit40-SMA200", make_wrpct_target(-90.0, -40.0, 200, 14)),
    ]
    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))
@@ -1,130 +0,0 @@
 """MRV06 — VWAP Deviation Reversion
 IDEA: On 1h bars, compute a rolling session VWAP (using typical price * volume).
 Fade deviations > k*sigma back to VWAP (mean-reversion).
 Regime gate: only trade in the direction of the daily trend (using a simple trend filter).
 Variants tested:
  - k = 1.5 vs 2.0 (deviation threshold)
  - sigma window = 24h vs 48h (rolling window for sigma)
 TF: 1h (VWAP is most meaningful at 1h granularity)
 Style: continuous weights (study_weights)
 """
 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 compute_vwap_deviation(df: pd.DataFrame, vwap_win: int, k: float,
                           sigma_win: int) -> np.ndarray:
    """
    Compute VWAP deviation signal with regime gate.
    VWAP: rolling typical_price * volume / rolling volume (causal window).
    Signal: when price deviates > k*sigma above VWAP -> short (expect reversion)
            when price deviates > k*sigma below VWAP -> long (expect reversion)
    Regime gate: only long when daily trend (slow EMA > fast EMA at 1h scale).
    All computations causal (value at i uses data <= i).
    """
    close = df["close"].values.astype(float)
    high = df["high"].values.astype(float)
    low = df["low"].values.astype(float)
    volume = df["volume"].values.astype(float)
    # Typical price (causal: same bar is fine, we're using it for VWAP at i)
    typical = (high + low + close) / 3.0
    # Rolling VWAP (causal window)
    s = pd.Series
    tp_vol = typical * np.where(volume > 0, volume, np.nan)
    # Rolling VWAP over vwap_win bars
    vwap_num = s(tp_vol).rolling(vwap_win, min_periods=vwap_win // 2).sum()
    vwap_den = s(volume).rolling(vwap_win, min_periods=vwap_win // 2).sum()
    vwap = (vwap_num / vwap_den.replace(0, np.nan)).values
    # Deviation from VWAP
    deviation = close - vwap
    # Rolling sigma of deviation
    sigma = s(deviation).rolling(sigma_win, min_periods=sigma_win // 2).std().values
    # Normalized deviation (z-score wrt rolling sigma)
    z = np.where(sigma > 0, deviation / sigma, 0.0)
    # Mean-reversion signal:
    # z > k => price is too high above VWAP => short (negative position)
    # z < -k => price is too low below VWAP => long (positive position)
    # Gradual: use -z/k clipped to [-1, 1] when |z| > k, else 0
    signal = np.where(np.abs(z) > k, -np.sign(z), 0.0)
    # Regime gate using daily trend: EMA(50d) vs EMA(10d) at 1h scale
    # Only allow long when fast EMA > slow EMA (uptrend), allow short any time
    # (crypto is fundamentally bullish-biased; mean-reversion shorts in downtrend risky)
    ema_fast = al.ema(close, 10 * 24)  # 10-day EMA
    ema_slow = al.ema(close, 50 * 24)  # 50-day EMA
    # In uptrend (fast > slow): allow both long and short mean-reversion
    # In downtrend (fast < slow): allow only short mean-reversion (with VWAP)
    uptrend = ema_fast > ema_slow
    # Filter: only take longs in uptrend regime
    gated = np.where(signal > 0, signal * uptrend.astype(float), signal)
    # Apply vol-targeting for position sizing
    result = al.vol_target(gated, df, target_vol=0.20, vol_win_days=30, leverage_cap=2.0)
    result = np.nan_to_num(result, nan=0.0)
    return result
 def make_target(vwap_win: int, k: float, sigma_win: int):
    """Factory: returns a target_fn(df) -> weights array."""
    def target_fn(df: pd.DataFrame) -> np.ndarray:
        return compute_vwap_deviation(df, vwap_win=vwap_win, k=k, sigma_win=sigma_win)
    target_fn.__name__ = f"vwap_dev_w{vwap_win}_k{k}_s{sigma_win}"
    return target_fn
 # Small internal grid (<=4 param sets)
 # VWAP window: 24h (1 session) vs 48h (2 sessions)
 # k threshold: 1.5 vs 2.0
 # sigma_win tied to vwap_win
 CONFIGS = [
    # (vwap_win, k, sigma_win, label)
    (24,  1.5, 48,  "vwap24h_k1.5_s48h"),
    (24,  2.0, 48,  "vwap24h_k2.0_s48h"),
    (48,  1.5, 96,  "vwap48h_k1.5_s96h"),
    (48,  2.0, 96,  "vwap48h_k2.0_s96h"),
 ]
 best_rep = None
 best_hold = -999.0
 print("=== MRV06 VWAP Deviation Reversion ===")
 print(f"Testing {len(CONFIGS)} configs on 1h bars (BTC + ETH)\n")
 for vwap_win, k, sigma_win, label in CONFIGS:
    print(f"--- Config: {label} ---")
    fn = make_target(vwap_win, k, sigma_win)
    rep = al.study_weights(
        f"MRV06-{label}",
        fn,
        tfs=("1h",)
    )
    print(al.fmt(rep))
    hold_sharpe = rep["verdict"].get("best_holdout_sharpe", -999)
    if hold_sharpe > best_hold:
        best_hold = hold_sharpe
        best_rep = rep
    print()
 # Print best config
 print("\n\n=== BEST CONFIG ===")
 print(al.fmt(best_rep))
 print("JSON:", al.as_json(best_rep))
@@ -1,94 +0,0 @@
 """MRV07 — Consecutive-down buy in uptrend.
 After N+ consecutive lower closes AND close > SMA100 (uptrend filter),
 buy at close[i]; exit after max_bars or on the first green close (close > prev close).
 Grid: try (consec_n, max_bars) combinations on 1d.
 Total backtests: 3 configs x 2 assets = 6.
 """
 import sys
 sys.path.insert(0, "/opt/docker/PythagorasGoal/scripts/research/alt")
 import altlib as al
 import numpy as np
 def make_entries_fn(consec_n=3, sma_win=100, max_bars=10):
    """Factory for consecutive-down buy entries.
    Signal: close[i] < close[i-1] < ... < close[i-consec_n+1] (N consecutive lower closes)
            AND close[i] > SMA100 (uptrend filter).
    Entry:  buy at close[i] (filled immediately).
    Exit:   after max_bars bars (hard stop); no TP/SL (green-close exit not encodable
            causally in the entries-list format — green close requires next-bar data).
    """
    def entries_fn(df):
        c = df["close"].values.astype(float)
        n = len(c)
        sma100 = al.sma(c, sma_win)
        entries = []
        for i in range(n):
            # Need at least consec_n prior bars
            if i < consec_n:
                entries.append(None)
                continue
            # Check SMA100 (uptrend)
            if np.isnan(sma100[i]) or c[i] <= sma100[i]:
                entries.append(None)
                continue
            # Check N consecutive lower closes
            consecutive_down = True
            for k in range(consec_n):
                if k == 0:
                    # close[i] < close[i-1]
                    if c[i] >= c[i-1]:
                        consecutive_down = False
                        break
                else:
                    # close[i-k] < close[i-k-1]
                    if c[i-k] >= c[i-k-1]:
                        consecutive_down = False
                        break
            if consecutive_down:
                entries.append({
                    "dir": 1,
                    "tp": None,
                    "sl": None,
                    "max_bars": max_bars,
                })
            else:
                entries.append(None)
        return entries
    return entries_fn
 # Grid: 3 configs (consec_n, max_bars)
 # Hypothesis: after 3 consecutive dips in uptrend, expect mean-reversion bounce
 CONFIGS = [
    dict(consec_n=3, max_bars=5,  label="N3_mb5"),
    dict(consec_n=3, max_bars=10, label="N3_mb10"),
    dict(consec_n=4, max_bars=5,  label="N4_mb5"),
 ]
 best_rep = None
 best_hold = -999.0
 best_label = None
 for cfg in CONFIGS:
    label = cfg["label"]
    fn = make_entries_fn(consec_n=cfg["consec_n"], max_bars=cfg["max_bars"])
    rep = al.study_signals(f"MRV07-{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))
@@ -1,104 +0,0 @@
 """MRV08 — Daily gap-fill (adapted for 24/7 crypto)
 HYPOTHESIS: On 1d bars, if the day opens well BELOW the prior close (gap-down),
 go LONG expecting reversion toward prior close. SL below the day open.
 IMPORTANT: Crypto trades 24/7 — open[i] vs close[i-1] gaps are typically <0.1%
 on Deribit 1d resampled bars (max gap found = 0.089%). True overnight gaps don't exist.
 ADAPTED INTERPRETATION: "Gap" operationalized as a large down day:
  - Bar i closes gap_thresh% below prior close (big intraday decline)
  - Enter LONG at close[i], TP = close[i-1] (full reversion), SL below
  - This captures the "gap fill" spirit: buy after a large daily drop expecting recovery
 """
 import sys
 sys.path.insert(0, "/opt/docker/PythagorasGoal/scripts/research/alt")
 import altlib as al
 import numpy as np
 # Grid: (gap_thresh, sl_frac, max_bars, label)
 CONFIGS = [
    (0.015, 0.015, 3, "down1.5%_sl1.5%_3d"),  # moderate down day, 3d hold
    (0.020, 0.020, 3, "down2%_sl2%_3d"),       # bigger down day only
    (0.015, 0.020, 5, "down1.5%_sl2%_5d"),     # more time to recover
    (0.020, 0.015, 5, "down2%_sl1.5%_5d"),     # tighter SL, longer hold
 ]
 def make_entries(df, gap_thresh=0.015, sl_frac=0.015, max_bars=3):
    """
    Reversion after a large down day:
      - If close[i] < close[i-1] * (1 - gap_thresh): "gap" trigger
      - Entry: LONG at close[i]
      - TP: close[i-1] (prior close recovery)
      - SL: close[i] * (1 - sl_frac)
      - Hold up to max_bars days
    Causal: uses only close[i] and close[i-1].
    """
    c = df["close"].values.astype(float)
    n = len(df)
    entries = [None] * n
    for i in range(1, n):
        prior_close = c[i - 1]
        cur_close = c[i]
        if prior_close <= 0:
            continue
        ret = (cur_close - prior_close) / prior_close
        if ret >= -gap_thresh:
            continue
        tp = prior_close
        sl = cur_close * (1.0 - sl_frac)
        if tp <= cur_close or sl >= cur_close:
            continue
        entries[i] = {"dir": +1, "tp": tp, "sl": sl, "max_bars": max_bars}
    return entries
 # Diagnostic: check trade counts per config
 print("=== MRV08 Daily Gap-Fill (Crypto Adapted) ===")
 print("NOTE: True overnight gaps don't exist in 24/7 crypto.")
 print("Using 'large down day' as gap proxy (close[i] < close[i-1] * (1-thresh))")
 print()
 for gt, sf, mb, label in CONFIGS:
    df_btc = al.get("BTC", "1d")
    ent_btc = make_entries(df_btc, gt, sf, mb)
    n_btc = sum(1 for e in ent_btc if e is not None)
    df_eth = al.get("ETH", "1d")
    ent_eth = make_entries(df_eth, gt, sf, mb)
    n_eth = sum(1 for e in ent_eth if e is not None)
    print(f"  {label}: BTC trades={n_btc}, ETH trades={n_eth}")
 print()
 # Run all configs
 best_rep = None
 best_min_hold = -999.0
 for gap_thresh, sl_frac, max_bars, label in CONFIGS:
    name = f"MRV08-{label}"
    def make_fn(gt=gap_thresh, sf=sl_frac, mb=max_bars):
        return lambda df: make_entries(df, gap_thresh=gt, sl_frac=sf, max_bars=mb)
    rep = al.study_signals(name, make_fn(), tfs=("1d",))
    v = rep["verdict"]
    min_hold = v.get("best_holdout_sharpe", -999)
    print(f"\n--- Config: {label} ---")
    print(al.fmt(rep))
    print("JSON:", al.as_json(rep))
    if min_hold > best_min_hold:
        best_min_hold = min_hold
        best_rep = rep
 print("\n\n=== BEST CONFIG ===")
 print(al.fmt(best_rep))
 print("JSON:", al.as_json(best_rep))
@@ -1,127 +0,0 @@
 """MRV09 — CCI Reversion
 HYPOTHESIS: CCI(20) < -100 signals oversold -> go LONG. Exit when CCI > 0 (mean reversion).
 Trend gate: only buy when price is above 200-day SMA (long-term uptrend confirmation).
 CCI (Commodity Channel Index) = (TypicalPrice - SMA(TP, n)) / (0.015 * MeanAbsDev(TP, n))
 Extreme readings (<-100) indicate oversold conditions; reversal expected.
 CAUSAL: CCI at bar i uses data up to and including close[i].
 Entry at close[i] when CCI[i] < -100 (AND trend gate: close[i] > SMA200[i]).
 Exit at close[i] when CCI[i] > 0.
 SL: ATR-based (entry - 2*ATR) to limit downside.
 max_bars: cap position holding time.
 Small grid: (cci_period, max_bars) -> 4 configs, 1d only.
 """
 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 cci(df: pd.DataFrame, period: int = 20) -> np.ndarray:
    """Commodity Channel Index (causal).
    CCI = (TP - SMA(TP, n)) / (0.015 * MeanAbsDev(TP, n))
    where TP = (high + low + close) / 3
    """
    h = df["high"].values.astype(float)
    l = df["low"].values.astype(float)
    c = df["close"].values.astype(float)
    tp = (h + l + c) / 3.0
    n = len(tp)
    cci_vals = np.full(n, np.nan)
    for i in range(period - 1, n):
        window = tp[i - period + 1:i + 1]
        m = np.mean(window)
        mad = np.mean(np.abs(window - m))
        if mad > 0:
            cci_vals[i] = (tp[i] - m) / (0.015 * mad)
        else:
            cci_vals[i] = 0.0
    return cci_vals
 def make_entries(df, cci_period=20, sma_period=200, sl_atr_mult=2.0, max_bars=10, use_trend_gate=True):
    """
    Entry: CCI[i] < -100 (oversold), optionally gated by close > SMA200 (uptrend).
    Exit: CCI[i] > 0 (mean reversion complete), or SL or max_bars.
    All causal: uses data up to and including close[i].
    """
    c = df["close"].values.astype(float)
    n = len(df)
    # CCI (causal, computed above)
    cci_vals = cci(df, cci_period)
    # SMA200 for trend gate
    sma200 = al.sma(c, sma_period)
    # ATR for SL
    atr_vals = al.atr(df, win=14)
    entries = [None] * n
    for i in range(sma_period, n):
        ci = cci_vals[i]
        if np.isnan(ci):
            continue
        # Trend gate: only long when price is above long-term SMA
        if use_trend_gate and (np.isnan(sma200[i]) or c[i] <= sma200[i]):
            continue
        # Oversold condition
        if ci >= -100.0:
            continue
        # Entry at close[i], long
        entry_px = c[i]
        sl_px = entry_px - sl_atr_mult * atr_vals[i]
        # Sanity check: SL must be below entry
        if sl_px >= entry_px:
            continue
        entries[i] = {"dir": +1, "tp": None, "sl": sl_px, "max_bars": max_bars}
    return entries
 # -----------------------------------------------------------------------
 # Grid: small (4 configs total, 1d only -> 4 * 2 assets = 8 backtests)
 # -----------------------------------------------------------------------
 CONFIGS = [
    # (cci_period, sma_period, sl_atr_mult, max_bars, use_trend_gate, label)
    (20, 200, 2.0, 10, True,  "cci20_sma200_sl2atr_10d"),
    (20, 200, 2.0, 20, True,  "cci20_sma200_sl2atr_20d"),
    (14, 200, 1.5, 10, True,  "cci14_sma200_sl1.5atr_10d"),
    (20, 200, 2.0, 10, False, "cci20_nosma_sl2atr_10d"),   # no trend gate control
 ]
 best_rep = None
 best_min_hold = -999.0
 for cci_period, sma_period, sl_atr_mult, max_bars, use_trend_gate, label in CONFIGS:
    name = f"MRV09-{label}"
    def make_fn(cp=cci_period, sp=sma_period, sa=sl_atr_mult, mb=max_bars, utg=use_trend_gate):
        return lambda df: make_entries(df, cci_period=cp, sma_period=sp,
                                       sl_atr_mult=sa, max_bars=mb, use_trend_gate=utg)
    rep = al.study_signals(name, make_fn(), tfs=("1d",))
    v = rep["verdict"]
    min_hold = v.get("best_holdout_sharpe", -999)
    print(f"\n--- Config: {label} ---")
    print(al.fmt(rep))
    print("JSON:", al.as_json(rep))
    if min_hold > best_min_hold:
        best_min_hold = min_hold
        best_rep = rep
 print("\n\n=== BEST CONFIG ===")
 print(al.fmt(best_rep))
 print("JSON:", al.as_json(best_rep))
@@ -1,145 +0,0 @@
 """MRV10 — Stochastic Reversion in Range (ADX-gated)
 IDEA: Stochastic(14,3) oversold (<20) → long entry. Only trade when ADX<25 (range/sideways
 regime, not a trending market). Exit when Stochastic crosses back above 50, or TP/SL hit.
 This is a DISCRETE signal strategy (study_signals, 1d only).
 Stochastic %K = 100 * (C - L_n) / (H_n - L_n)   [n=14 default]
 Stochastic %D = SMA(%K, 3)                         [smoothed signal line]
 ADX = average directional index (non-directional trend strength)
 Grid: 2 param sets (stoch_period, adx_period) x (oversold threshold, adx_threshold)
  - Config A: stoch=14, %D<20, ADX<25, hold max 10 bars
  - Config B: stoch=14, %D<25, ADX<20, hold max 8 bars (stricter ADX)
 Total: 2 configs -> 2 backtests (each on BTC+ETH) = 4 runs 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 stochastic_k(df: pd.DataFrame, period: int = 14) -> np.ndarray:
    """Raw %K = (Close - LowestLow_n) / (HighestHigh_n - LowestLow_n) * 100. Causal."""
    hi = df["high"].values
    lo = df["low"].values
    c = df["close"].values
    n = len(c)
    k = np.full(n, np.nan)
    for i in range(period - 1, n):
        h_max = np.max(hi[i - period + 1: i + 1])
        l_min = np.min(lo[i - period + 1: i + 1])
        denom = h_max - l_min
        if denom > 0:
            k[i] = 100.0 * (c[i] - l_min) / denom
        else:
            k[i] = 50.0  # flat candle
    return k
 def stochastic_d(k: np.ndarray, smooth: int = 3) -> np.ndarray:
    """Stochastic %D = SMA(%K, smooth). Causal."""
    return pd.Series(k).rolling(smooth, min_periods=smooth).mean().values
 def adx(df: pd.DataFrame, period: int = 14) -> np.ndarray:
    """ADX (Average Directional Index). Causal, EMA-smoothed."""
    hi = df["high"].values
    lo = df["low"].values
    c = df["close"].values
    n = len(c)
    pc = np.roll(c, 1)
    pc[0] = c[0]
    ph = np.roll(hi, 1)
    ph[0] = hi[0]
    pl = np.roll(lo, 1)
    pl[0] = lo[0]
    tr = np.maximum(hi - lo, np.maximum(np.abs(hi - pc), np.abs(lo - pc)))
    dm_plus = np.where((hi - ph) > (pl - lo), np.maximum(hi - ph, 0.0), 0.0)
    dm_minus = np.where((pl - lo) > (hi - ph), np.maximum(pl - lo, 0.0), 0.0)
    # Wilder smoothing (like EMA with alpha=1/period)
    atr_s = pd.Series(tr).ewm(alpha=1.0 / period, adjust=False).mean().values
    dmp_s = pd.Series(dm_plus).ewm(alpha=1.0 / period, adjust=False).mean().values
    dmm_s = pd.Series(dm_minus).ewm(alpha=1.0 / period, adjust=False).mean().values
    di_plus = np.where(atr_s > 0, 100.0 * dmp_s / atr_s, 0.0)
    di_minus = np.where(atr_s > 0, 100.0 * dmm_s / atr_s, 0.0)
    di_sum = di_plus + di_minus
    dx = np.where(di_sum > 0, 100.0 * np.abs(di_plus - di_minus) / di_sum, 0.0)
    adx_arr = pd.Series(dx).ewm(alpha=1.0 / period, adjust=False).mean().values
    return adx_arr
 def make_entries_fn(stoch_period=14, stoch_smooth=3, os_thresh=20, adx_thresh=25, max_bars=10):
    """Returns an entries_fn(df) -> list[dict|None] for study_signals.
    Signal: go long when:
      - Stochastic %D crosses below os_thresh (oversold) from above
      - ADX < adx_thresh (range regime, not trending)
    Exit: when %D crosses back above 50 OR max_bars elapsed.
    TP: 2 * ATR above entry. SL: 1.5 * ATR below entry.
    """
    def entries_fn(df: pd.DataFrame):
        k = stochastic_k(df, stoch_period)
        d = stochastic_d(k, stoch_smooth)
        adx_vals = adx(df, stoch_period)
        atr_vals = al.atr(df, stoch_period)
        c = df["close"].values
        n = len(df)
        entries = [None] * n
        for i in range(2, n):
            if np.isnan(d[i]) or np.isnan(d[i - 1]) or np.isnan(adx_vals[i]):
                continue
            # Oversold cross: %D was above threshold, now crossed below
            crossed_oversold = (d[i - 1] >= os_thresh) and (d[i] < os_thresh)
            in_range = adx_vals[i] < adx_thresh
            if crossed_oversold and in_range:
                atr_i = atr_vals[i] if np.isfinite(atr_vals[i]) and atr_vals[i] > 0 else c[i] * 0.01
                tp = c[i] + 2.0 * atr_i
                sl = c[i] - 1.5 * atr_i
                entries[i] = {
                    "dir": +1,
                    "tp": tp,
                    "sl": sl,
                    "max_bars": max_bars,
                }
        return entries
    return entries_fn
 # ── Grid (small: 2 configs only) ──────────────────────────────────────────────
 CONFIGS = [
    dict(label="CFG-A", stoch_period=14, stoch_smooth=3, os_thresh=20, adx_thresh=25, max_bars=10),
    dict(label="CFG-B", stoch_period=14, stoch_smooth=3, os_thresh=25, adx_thresh=20, max_bars=8),
 ]
 if __name__ == "__main__":
    best_rep = None
    best_hold = -99.0
    for cfg in CONFIGS:
        label = cfg.pop("label")
        fn = make_entries_fn(**cfg)
        name = f"MRV10-{label}"
        print(f"\n--- Running {name} ---")
        rep = al.study_signals(name, fn, tfs=("1d",))
        print(al.fmt(rep))
        hold = rep["verdict"].get("best_holdout_sharpe", -99.0) or -99.0
        if hold > best_hold:
            best_hold = hold
            best_rep = rep
        cfg["label"] = label  # restore for logging
    print("\n\n=== BEST CONFIG ===")
    print(al.fmt(best_rep))
    print("JSON:", al.as_json(best_rep))
@@ -1,119 +0,0 @@
 """MRV11 — Bollinger %b Reversion
 HYPOTHESIS: Bollinger %b = position of close within Bollinger Bands.
  %b = (close - lower) / (upper - lower)
  Entry logic: go long when %b < threshold_low (deeply oversold), exit at 0.5 (middle band),
  with SMA200 trend filter (only long when close < SMA200, i.e., in downtrend/mean-reversion regime).
 Style: continuous weights (al.study_weights).
 Small grid: 2 BB params x 2 thresholds = 4 configs, tested on 2 TFs = max 6 (pick best by hold-out).
 """
 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(bb_win: int, bb_k: float, entry_pctb: float, trend_win: int = 200):
    """
    Bollinger %b reversion target function.
    - Compute %b = (close - lower) / (upper - lower)
    - Long signal when %b < entry_pctb (close near/below lower band) AND close < SMA(trend_win)
    - Position scales linearly from max at %b=0 to 0 at %b=0.5 (exit threshold)
    - Vol-targeted to 20% annualized, leverage capped at 2x
    - All decisions use data <= close[i] (causal)
    Args:
        bb_win: Bollinger Band window (20 or 30)
        bb_k: Bollinger Band width in std devs (2.0)
        entry_pctb: %b threshold to enter long (0.05 or 0.10)
        trend_win: SMA window for trend filter (200 bars)
    """
    def _target(df: pd.DataFrame) -> np.ndarray:
        c = df["close"].values.astype(float)
        n = len(c)
        # Bollinger Bands (causal: uses data up to i)
        upper, mid, lower = al.bbands(c, win=bb_win, k=bb_k)
        # %b = (close - lower) / (upper - lower)
        band_width = upper - lower
        # Avoid division by zero when bands collapse
        pctb = np.where(band_width > 1e-10, (c - lower) / band_width, 0.5)
        # Trend filter: SMA200 (only enter when we're in a range/downtrend context)
        trend_sma = al.sma(c, trend_win)
        # below_trend: close < SMA200 (mean-reversion opportunity more likely)
        below_trend = c < trend_sma  # boolean array, causal
        # Continuous position signal:
        # - When %b < entry_pctb AND below SMA200: long with weight proportional to how
        #   deep we are (1 - %b/0.5 mapped to [0,1])
        # - When %b >= 0.5: flat (exit)
        # - Linearly scale between entry_pctb and 0.5
        # Compute raw direction:
        # Full strength at pctb=0, zero at pctb=0.5
        # Clamp: below entry_pctb -> scale from 0 to 1 relative to entry zone
        raw_long = np.where(
            (pctb < 0.5) & below_trend,
            np.clip((0.5 - pctb) / 0.5, 0.0, 1.0),  # linear fade: 1 at pctb=0, 0 at pctb=0.5
            0.0
        )
        # Apply NaN mask for warmup period
        warmup = max(bb_win, trend_win)
        raw_long[:warmup] = 0.0
        # Vol-target to 20% annualized, cap 2x leverage
        return al.vol_target(raw_long, df, target_vol=0.20, vol_win_days=30, leverage_cap=2.0)
    return _target
 # ── Grid: 4 configs (bb_win x entry_pctb) ─────────────────────────────────────
 CONFIGS = [
    dict(bb_win=20, bb_k=2.0, entry_pctb=0.05, label="BB20k2-p05"),
    dict(bb_win=20, bb_k=2.0, entry_pctb=0.10, label="BB20k2-p10"),
    dict(bb_win=30, bb_k=2.0, entry_pctb=0.05, label="BB30k2-p05"),
    dict(bb_win=30, bb_k=2.0, entry_pctb=0.10, label="BB30k2-p10"),
 ]
 # Run all configs at 1d (the hypothesis is cleaner at daily; 4 configs x 1 TF = 4 backtests)
 # Also run best config at 12h (total = 4+2 = 6 max)
 print("=== MRV11: Bollinger %b Reversion - Grid Search ===\n")
 results = []
 for cfg in CONFIGS:
    fn = make_target(cfg["bb_win"], cfg["bb_k"], cfg["entry_pctb"])
    rep = al.study_weights(
        f"MRV11-{cfg['label']}",
        fn,
        tfs=("1d",)
    )
    results.append((cfg, rep))
    v = rep["verdict"]
    cell_1d = rep["cells"][0]
    print(f"{cfg['label']:20s}: minFull={cell_1d['min_asset_full_sharpe']:+.3f}  "
          f"minHold={cell_1d['min_asset_holdout_sharpe']:+.3f}  "
          f"feeOK={cell_1d['fee_survives']}  grade={v['grade']}")
 print()
 # Pick best config by hold-out Sharpe at 1d
 best_cfg, best_rep = max(results, key=lambda x: x[1]["cells"][0]["min_asset_holdout_sharpe"])
 print(f"Best config: {best_cfg['label']}")
 print()
 # Run best config also on 12h
 best_fn = make_target(best_cfg["bb_win"], best_cfg["bb_k"], best_cfg["entry_pctb"])
 final_rep = al.study_weights(
    f"MRV11-{best_cfg['label']}",
    best_fn,
    tfs=("1d", "12h")
 )
 print(al.fmt(final_rep))
 print()
 print("JSON:", al.as_json(final_rep))
@@ -1,431 +0,0 @@
 """OPT01 — Covered-Call Overlay
 IDEA: Long spot + sell weekly OTM call modeled via Black-Scholes using DVOL as IV.
 Net return = spot return capped at strike + call premium received.
 This is a MODELED lead — real execution requires options book.
 Methodology:
 - Hold 1 unit of spot BTC/ETH.
 - Each week sell 1 weekly call at strike = S * exp(delta_otm * sigma * sqrt(T)).
  delta_otm controls how far OTM (e.g. 0.10 = 10% OTM in log space).
 - Premium modeled via Black-Scholes (causal DVOL as IV).
 - Net weekly return = min(spot_return, log(K/S)) + premium/S
  i.e. spot gain is capped at the call strike, but we always keep the premium.
 - Study 4 param sets: delta_otm in {0.05, 0.10} x weekly/biweekly rebalance.
 - CAVEAT: premiums are MODELED on DVOL ATM/skew not accounted for -> lead-only.
 - DVOL history starts 2021-03 -> backtest from 2021-03 only.
 Style: study_weights (continuous position ~1x long + overlay).
 """
 import sys
 sys.path.insert(0, "/opt/docker/PythagorasGoal/scripts/research/alt")
 import altlib as al
 import numpy as np
 import pandas as pd
 from scipy.stats import norm
 # ── Black-Scholes call price ─────────────────────────────────────────────────
 def bs_call(S: float, K: float, T: float, sigma: float, r: float = 0.0) -> float:
    """Black-Scholes call price. T in years. sigma annualized."""
    if T <= 0 or sigma <= 0 or S <= 0 or K <= 0:
        return 0.0
    d1 = (np.log(S / K) + (r + 0.5 * sigma**2) * T) / (sigma * np.sqrt(T))
    d2 = d1 - sigma * np.sqrt(T)
    return float(S * norm.cdf(d1) - K * np.exp(-r * T) * norm.cdf(d2))
 # ── Core covered-call target function ────────────────────────────────────────
 def make_cc_target(delta_otm: float = 0.10, roll_days: int = 7):
    """
    delta_otm: strike OTM in log-space = S * exp(delta_otm * sigma * sqrt(T)).
               0.10 means ~10% above spot in vol-adjusted units.
    roll_days: how many calendar days per option cycle (7=weekly, 14=biweekly).
    """
    T_years = roll_days / 365.25
    def target_fn(df: pd.DataFrame) -> np.ndarray:
        close = df["close"].values.astype(float)
        n = len(close)
        # Causal DVOL: annualized vol in fraction (e.g. 0.65 for 65%)
        dvol_pts = al.dvol(df, asset="BTC" if "BTC" in df.attrs.get("asset", "BTC") else "ETH")
        # dvol_pts is in vol POINTS (e.g. 65.0), convert to fraction
        sigma_ann = dvol_pts / 100.0
        # Compute returns per bar
        r_spot = al.simple_returns(close)
        # We'll compute net returns for each bar, then return as position
        # representing the net P&L contribution vs spot
        # The strategy is: hold spot + sell weekly call -> net = covered call P&L
        # For daily bars: roll every roll_days bars
        # For 1d tf, roll_days=7 -> weekly roll
        bpd = int(al.bars_per_day(df))
        roll_bars = max(1, roll_days)  # for 1d, roll_bars = roll_days in bars
        net_returns = np.zeros(n)
        position_weight = np.zeros(n)  # we store "active covered-call" flag
        # Track when the current option expires and what the strike/premium were
        # At each roll date: sell new call, compute premium; during the cycle accumulate
        option_K = None
        option_premium_frac = 0.0  # premium received / S at initiation
        cycle_start_bar = 0
        cycle_start_price = close[0] if len(close) > 0 else 1.0
        # Start from bar 1 to have valid returns; need valid DVOL (2021+)
        first_valid = np.where(np.isfinite(sigma_ann) & (sigma_ann > 0))[0]
        start_bar = int(first_valid[0]) if len(first_valid) > 0 else 0
        # Initialize first option at start_bar
        if start_bar < n:
            S0 = close[start_bar]
            sig0 = sigma_ann[start_bar]
            if sig0 > 0:
                K0 = S0 * np.exp(delta_otm * sig0 * np.sqrt(T_years))
                option_K = K0
                option_premium_frac = bs_call(S0, K0, T_years, sig0) / S0
            cycle_start_bar = start_bar
            cycle_start_price = S0
        for i in range(start_bar + 1, n):
            bars_in_cycle = i - cycle_start_bar
            S_prev = close[i - 1]
            S_curr = close[i]
            # Normal spot return for this bar
            spot_r = r_spot[i]
            if option_K is None:
                # No active option (shouldn't happen after start, but safety)
                net_returns[i] = spot_r
                position_weight[i] = 1.0
                continue
            # Check if this bar is a roll date (option expires)
            if bars_in_cycle >= roll_bars:
                # Option expires at close of this bar
                # Settle: spot moved from cycle_start_price to S_curr
                # Covered call payoff for the cycle:
                #   If S_curr > K: we deliver spot at K -> cap gain at K/S0 - 1
                #   If S_curr <= K: option expires worthless -> full spot gain
                # We've been tracking daily; at expiry we "reset" the strike
                # For the expiry bar: net return is capped
                S0_cycle = cycle_start_price
                K = option_K
                prem = option_premium_frac  # received at start of cycle
                # Cap the spot return at strike; premium was received at start
                # Distribute the premium gain across the cycle on a per-bar basis is complex
                # Simpler (and honest): record CYCLE total return at expiry bar,
                # spread as zero otherwise (approximate)
                # Actually for the weight-based eval, let's track position=1 and adjust
                # net returns to reflect the capped + premium payoff
                # Cycle spot total return
                if S_curr > K:
                    # capped: get (K/S0_cycle - 1) + prem received at start
                    cycle_net = (K / S0_cycle - 1.0) + prem
                else:
                    # uncapped: get full spot + prem
                    cycle_net = (S_curr / S0_cycle - 1.0) + prem
                # We need to set net_returns for the ENTIRE cycle
                # Mark intermediate bars as 0, put all P&L at expiry
                # (This is a simplification; the "position_weight=1" approach below
                #  handles individual bars, so we override here)
                # Actually the cleanest approach: track as a single-period return
                # placed at the expiry bar, zeroing out intermediate bars.
                # We'll flag intermediate bars with position_weight = 0 (handled separately)
                net_returns[i] = cycle_net
                position_weight[i] = 1.0  # flag this as the settlement bar
                # Roll new option
                sig_new = sigma_ann[i]
                if np.isfinite(sig_new) and sig_new > 0:
                    K_new = S_curr * np.exp(delta_otm * sig_new * np.sqrt(T_years))
                    option_premium_frac = bs_call(S_curr, K_new, T_years, sig_new) / S_curr
                    option_K = K_new
                else:
                    option_K = None
                    option_premium_frac = 0.0
                cycle_start_bar = i
                cycle_start_price = S_curr
            else:
                # Mid-cycle: just hold spot (the option P&L accrues at expiry)
                # Mark as 0 so eval_weights only gets the settlement bars
                net_returns[i] = 0.0
                position_weight[i] = 0.0  # intermediate: no daily P&L recorded here
        # The target we return is a "synthetic position" that encodes the P&L directly.
        # eval_weights will do: pos[i] = target[i-1]; net[i] = pos[i] * r[i]
        # We need to return a "fake position" that makes the math work:
        #   net_returns[i] = target[i-1] * r_spot[i]  -> target[i-1] = net_returns[i] / r_spot[i]
        # But this would divide by small numbers; instead, we need a different approach.
        #
        # Better approach: return the net_returns array directly as a "custom signal".
        # Since eval_weights does pos[i] = target[i-1] * r[i], we can't directly pass
        # net_returns. Instead, we build a "position" that approximates CC behavior.
        #
        # REVISED CLEAN APPROACH: compute per-bar net returns and pass them as position=1
        # with pre-computed net returns embedded via a trick: we set target[i] such that
        # target[i] * r_spot[i+1] ≈ CC_net_return[i+1].
        #
        # Actually the cleanest approach for a covered call is:
        # - It's ALWAYS long spot (position=1), but at option expiry we adjust for:
        #   (a) cap at strike -> subtract excess gain if S>K
        #   (b) add premium received
        #
        # For eval_weights, we need to express everything as a "multiplier on the next bar's return".
        # This doesn't work cleanly for multi-bar option cycles.
        #
        # FINAL APPROACH: Express as a WEEKLY bar (resample to weekly), compute one-period CC return.
        # But we're called with a specific tf. Instead, downsample conceptually.
        #
        # We'll return the daily adjustments:
        # On settlement days: position that captures capped gain + premium
        # On non-settlement days: position = 1 (pure spot)
        #
        # To avoid the eval_weights shift making things off-by-one, we set:
        # target[i] = position to hold during bar i+1
        # On bar i+1 (settlement): net = target[i] * r_spot[i+1]
        # target[i] = cycle_net[i+1] / r_spot[i+1] when r_spot[i+1] != 0
        # Otherwise target[i] = 1 (spot)
        #
        # This is complex. Let's use a clean but simpler approximation:
        # Express covered-call as: spot return + short call option return
        # Short call return on expiry bar = premium_received - max(0, S_end - K)
        # On non-expiry bars: return from short call = 0 (European option, no early exercise)
        #
        # We can decompose:
        # cc_return[i] = spot_return[i] + option_adjustment[i]
        # where option_adjustment[i] is nonzero only on settlement bars.
        #
        # We pass target=1 (always long spot) but we need to add the option overlay separately.
        # eval_weights doesn't support additive adjustments directly.
        #
        # SIMPLEST HONEST IMPLEMENTATION: run a separate loop and return the synthetic
        # "effective position" = cc_net_return_for_cycle / spot_return_for_cycle
        # at settlement bars, and 1.0 at non-settlement bars.
        # Rebuild from scratch cleanly:
        return _build_cc_target(close, sigma_ann, delta_otm, roll_bars, T_years)
    return target_fn
 def _build_cc_target(close: np.ndarray, sigma_ann: np.ndarray,
                     delta_otm: float, roll_bars: int, T_years: float) -> np.ndarray:
    """
    Build a synthetic 'effective position' for covered call.
    At each bar i, target[i] will be held during bar i+1.
    For settlement bars: effective_position = cc_return / spot_return (so that
      pos * r_spot ≈ cc_return for that bar).
    For non-settlement bars: effective_position = 1.0 (pure spot).
    This correctly represents the covered-call P&L in the eval_weights framework.
    """
    n = len(close)
    target = np.ones(n)  # default: long spot
    first_valid = np.where(np.isfinite(sigma_ann) & (sigma_ann > 0))[0]
    if len(first_valid) == 0:
        return target
    start_bar = int(first_valid[0])
    r_spot = al.simple_returns(close)
    # Option state
    option_K = None
    option_premium_frac = 0.0
    cycle_start_price = close[start_bar] if start_bar < n else 1.0
    cycle_start_bar = start_bar
    # Initialize first option
    S0 = close[start_bar]
    sig0 = sigma_ann[start_bar]
    if sig0 > 0 and np.isfinite(sig0):
        K0 = S0 * np.exp(delta_otm * sig0 * np.sqrt(T_years))
        option_K = K0
        option_premium_frac = bs_call(S0, K0, T_years, sig0) / S0
    cycle_start_bar = start_bar
    cycle_start_price = S0
    for i in range(start_bar + 1, n):
        bars_in_cycle = i - cycle_start_bar
        if option_K is None:
            # No active option -> pure spot
            target[i - 1] = 1.0
            continue
        if bars_in_cycle >= roll_bars:
            # Settlement bar i: compute CC payoff for the full cycle
            S_end = close[i]
            S_start = cycle_start_price
            K = option_K
            prem = option_premium_frac
            # Cycle spot return
            cycle_spot_r = S_end / S_start - 1.0
            # Covered call cycle return
            if S_end > K:
                # capped at K
                cc_r = (K / S_start - 1.0) + prem
            else:
                cc_r = cycle_spot_r + prem
            # We want: target[i-1] * r_spot[i] ≈ cc_r for the *cycle*
            # But r_spot[i] is only the LAST bar's spot return, not the full cycle.
            # This is the fundamental mismatch: the cycle spans roll_bars bars.
            #
            # For a 1d tf with 7-day roll, we can't encode a 7-bar return as a
            # single-bar "effective position" without distortion.
            #
            # PRACTICAL SOLUTION: Use the ratio cc_r / cycle_spot_r as the
            # "coverage ratio" and apply it to the spot return on the settlement bar.
            # This is an APPROXIMATION (it concentrates the full P&L on the last bar)
            # but it correctly captures the average economics of covered call selling.
            #
            # For 1d TF where roll=1 day (not weekly), this is exact.
            # For weekly rolls on 1d data, it approximates.
            #
            # Alternative: use 1w TF where each bar IS one option cycle -> exact.
            # We handle both below by checking if roll_bars == 1.
            if roll_bars <= 1:
                # Single-bar cycle: exact
                r_i = r_spot[i]
                if abs(r_i) > 1e-10:
                    target[i - 1] = cc_r / r_i
                else:
                    target[i - 1] = 1.0
            else:
                # Multi-bar cycle: spread P&L differently
                # On intermediate bars (start+1 to end-1): position=1 (spot-like)
                # On settlement bar i: effective position = cc_r / cycle_spot_r * (something)
                #
                # Cleanest: at each bar, contribution = spot_return_that_bar * ratio
                # but ratio changes. Instead, simply put all the "option adjustment" on
                # the settlement bar:
                #   option_adj = cc_r - cycle_spot_r  (premium - loss from cap)
                #   On settlement bar: effective_pos = 1 + option_adj / r_spot[i]
                r_i = r_spot[i]
                option_adj = cc_r - cycle_spot_r
                if abs(r_i) > 1e-10:
                    target[i - 1] = 1.0 + option_adj / r_i
                else:
                    # r_spot[i] ≈ 0: just record premium directly
                    target[i - 1] = 1.0
            # Roll new option
            sig_new = sigma_ann[i]
            if np.isfinite(sig_new) and sig_new > 0:
                K_new = S_end * np.exp(delta_otm * sig_new * np.sqrt(T_years))
                option_premium_frac = bs_call(S_end, K_new, T_years, sig_new) / S_end
                option_K = K_new
            else:
                option_K = None
                option_premium_frac = 0.0
            cycle_start_bar = i
            cycle_start_price = S_end
        else:
            # Intermediate bar: hold spot (position=1 already set by default)
            target[i - 1] = 1.0
    target = np.nan_to_num(target, nan=1.0)
    # Clip extreme values (avoid division artifacts)
    target = np.clip(target, -5.0, 5.0)
    return target
 # ── Per-asset target wrapper ──────────────────────────────────────────────────
 def make_asset_aware_cc(asset_name: str, delta_otm: float, roll_days: int):
    """Target function that passes the asset name for DVOL lookup."""
    T_years = roll_days / 365.25
    def target_fn(df: pd.DataFrame) -> np.ndarray:
        close = df["close"].values.astype(float)
        sigma_ann = al.dvol(df, asset_name) / 100.0
        roll_bars = roll_days  # for 1d tf, 1 bar = 1 day
        return _build_cc_target(close, sigma_ann, delta_otm, roll_bars, T_years)
    return target_fn
 # ── study_weights with per-asset DVOL lookup ─────────────────────────────────
 def run_cc(delta_otm: float, roll_days: int, tfs=("1d",)) -> dict:
    """Run covered-call study. Returns report dict."""
    name = f"OPT01-CC-OTM{int(delta_otm*100)}pct-roll{roll_days}d"
    cells = []
    for tf in tfs:
        per_asset = {}
        fee_ok_all = True
        for asset in al.CERTIFIED:
            df = al.get(asset, tf)
            tgt_fn = make_asset_aware_cc(asset, delta_otm, roll_days)
            tgt = tgt_fn(df)
            base = al.eval_weights(df, tgt, fee_side=al.FEE_SIDE)
            sweep = {f"{2*f*100:.2f}%RT": al.eval_weights(df, tgt, fee_side=f)["full"]["sharpe"]
                     for f in al.FEE_SWEEP}
            fee_ok = sweep.get("0.20%RT", -9) > 0
            fee_ok_all = fee_ok_all and fee_ok
            per_asset[asset] = 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 al.CERTIFIED)
        min_hold = min(per_asset[a]["holdout"].get("sharpe", 0.0) for a in al.CERTIFIED)
        import numpy as np_
        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 al.CERTIFIED]), 3),
                          fee_survives=fee_ok_all))
    verdict = al._verdict(cells)
    return dict(name=name, kind="weights", cells=cells, verdict=verdict)
 # ── Main: grid search over (delta_otm, roll_days) ────────────────────────────
 if __name__ == "__main__":
    import sys
    # Small grid: 4 configs, only 1d TF -> 8 total backtests
    CONFIGS = [
        (0.05, 7),   # 5% OTM, weekly
        (0.10, 7),   # 10% OTM, weekly
        (0.05, 14),  # 5% OTM, biweekly
        (0.10, 14),  # 10% OTM, biweekly
    ]
    print(f"OPT01 Covered-Call Overlay — MODELED (lead-only, DVOL from 2021-03)")
    print(f"Configs: {CONFIGS}")
    print()
    best_rep = None
    best_score = -999.0
    for delta_otm, roll_days in CONFIGS:
        print(f"--- Running delta_otm={delta_otm}, roll_days={roll_days} ---")
        rep = run_cc(delta_otm=delta_otm, roll_days=roll_days, tfs=("1d",))
        print(al.fmt(rep))
        score = rep["verdict"].get("best_holdout_sharpe", -9)
        if score > best_score:
            best_score = score
            best_rep = rep
        print()
    print("=" * 60)
    print("BEST CONFIG:")
    print(al.fmt(best_rep))
    print()
    print("JSON:", al.as_json(best_rep))
@@ -1,344 +0,0 @@
 """OPT02 — Cash-Secured Put Wheel Strategy (modeled, lead-only).
 HYPOTHESIS: Sell weekly ~0.25-delta put (BS premium from DVOL). If assigned
 (close < strike at expiry), hold spot then sell covered calls. Model assignment
 via close vs strike. Wheel cycle: CSP -> if assigned, sell CC until called away
 -> repeat. DVOL starts 2021-03, so history is shorter.
 Style: study_weights (continuous fractional position representing the theta income
 stream, scaled by vol target for risk management).
 Implementation:
 - At each weekly decision bar: if NOT in spot (wheel in CSP phase), sell put @
  ~0.25 delta; if IN spot (wheel in CC phase), sell call @ ~0.25 delta.
 - Assignment check: put assigned if close_expiry < strike_put; call "called away"
  if close_expiry > strike_call (sell the spot, back to CSP phase).
 - P&L: (premium incasssed - intrinsic payoff) / collateral.
 - Modeled on DVOL ATM (no skew). Premiums scaled by calibration f.
 - Gate: IV-rank > 0.25 (sell vol only when rich, causally computed expanding percentile).
 - Small grid: (delta_put, gate_ivr) -> 4 configs -> report best via altlib.
 CAVEAT: modeled, lead-only. No skew, no early assignment, no liquidity filter.
 """
 from __future__ import annotations
 import sys
 from pathlib import Path
 PROJECT_ROOT = Path(__file__).resolve().parents[4]
 ALT_DIR = Path(__file__).resolve().parents[1]   # .../alt/
 sys.path.insert(0, str(PROJECT_ROOT))
 sys.path.insert(0, str(ALT_DIR))
 import numpy as np
 import pandas as pd
 from scipy.stats import norm
 import altlib as al
 # ─── Black-Scholes helpers ──────────────────────────────────────────────────
 def bs_put(S: float, K: float, T: float, sig: float) -> float:
    """European put price (r=0)."""
    if T <= 0 or sig <= 0 or S <= 0 or K <= 0:
        return max(K - S, 0.0)
    d1 = (np.log(S / K) + 0.5 * sig**2 * T) / (sig * np.sqrt(T))
    d2 = d1 - sig * np.sqrt(T)
    return K * norm.cdf(-d2) - S * norm.cdf(-d1)
 def bs_call(S: float, K: float, T: float, sig: float) -> float:
    """European call price (r=0) via put-call parity."""
    return bs_put(S, K, T, sig) + S - K
 def strike_from_delta_put(S: float, T: float, sig: float, target_delta: float = -0.25) -> float:
    """Strike for a put with given delta (target_delta negative, e.g. -0.25)."""
    # delta_put = -N(-d1) = target_delta  =>  d1 = -N^{-1}(-target_delta)
    d1 = -norm.ppf(-target_delta)
    return S * np.exp(0.5 * sig**2 * T - d1 * sig * np.sqrt(T))
 def strike_from_delta_call(S: float, T: float, sig: float, target_delta: float = 0.25) -> float:
    """Strike for a call with given delta (target_delta positive, e.g. 0.25)."""
    # delta_call = N(d1) = target_delta => d1 = N^{-1}(target_delta)
    d1 = norm.ppf(target_delta)
    return S * np.exp(0.5 * sig**2 * T - d1 * sig * np.sqrt(T))
 # ─── DVOL aligned to daily bars ─────────────────────────────────────────────
 def _ivrank_expanding(dv: np.ndarray) -> np.ndarray:
    """Causal expanding IV-rank: percentile of dv[i] in dv[:i]."""
    n = len(dv)
    ivr = np.full(n, np.nan)
    for i in range(60, n):
        hist = dv[:i]
        ivr[i] = float((hist < dv[i]).mean())
    return ivr
 # ─── Wheel simulation ────────────────────────────────────────────────────────
 def wheel_returns(df: pd.DataFrame, asset: str,
                  put_delta: float = -0.25,
                  call_delta: float = 0.25,
                  tenor_d: int = 7,
                  gate_ivr: float = 0.0,
                  f: float = 1.0,
                  fee_frac: float = 0.125) -> np.ndarray:
    """
    Simulate the Put Wheel on daily data. Returns a per-bar return array
    (same length as df) suitable for al.study_weights.
    Logic (weekly cadence):
    - At each sell_bar i: if not_holding_spot -> sell CSP at put_delta.
      if holding_spot -> sell CC at call_delta.
    - Check at expiry (i+tenor_d):
      CSP: if close < K_put -> ASSIGNED (now hold spot at cost K_put).
           else -> premium pocketed, still in CSP phase.
      CC: if close > K_call -> CALLED AWAY (sell spot at K_call, back to CSP).
          else -> premium pocketed, still holding spot.
    - Returns are accumulated into daily bars for compatibility with altlib.
    - Gate: if gate_ivr > 0 and IVR < gate_ivr -> go flat that cycle.
    """
    c = df["close"].values.astype(float)
    n = len(c)
    dv_raw = al.dvol(df, asset)              # DVOL in vol points (e.g. 65.0)
    dv = dv_raw / 100.0                      # convert to fraction
    # Pre-compute expanding IV-rank
    ivr = _ivrank_expanding(dv_raw)
    T = tenor_d / 365.25
    daily_ret = np.zeros(n)
    in_spot = False          # wheel state
    cost_basis = 0.0         # strike at which spot was assigned
    i = 60                   # need warmup for DVOL history
    while i + tenor_d < n:
        S0 = c[i]
        sig = dv[i]
        iv = ivr[i]
        # Gate: if DVOL not available yet or IVR below threshold -> flat cycle
        if not np.isfinite(sig) or sig <= 0 or not np.isfinite(iv):
            i += tenor_d
            continue
        gate_ok = (gate_ivr <= 0.0) or (iv >= gate_ivr)
        exp_i = i + tenor_d
        S1 = c[exp_i]
        if not gate_ok:
            # Flat this cycle
            i += tenor_d
            continue
        if not in_spot:
            # ── CSP phase: sell put ──
            K_put = strike_from_delta_put(S0, T, sig, put_delta)
            prem = bs_put(S0, K_put, T, sig) * f
            fee_cost = fee_frac * abs(prem)
            net_prem = prem - fee_cost
            collateral = K_put   # cash-secured: full strike as collateral
            if S1 < K_put:
                # ASSIGNED: lose (K_put - S1), keep premium
                pnl = net_prem - (K_put - S1)
                in_spot = True
                cost_basis = K_put
            else:
                # Expired worthless: keep premium
                pnl = net_prem
                in_spot = False
            ret = pnl / collateral
        else:
            # ── CC phase: sell covered call ──
            K_call = strike_from_delta_call(S0, T, sig, call_delta)
            prem_c = bs_call(S0, K_call, T, sig) * f
            fee_cost = fee_frac * abs(prem_c)
            net_prem_c = prem_c - fee_cost
            # Underlying PnL from holding spot
            spot_pnl = S1 - cost_basis
            if S1 > K_call:
                # CALLED AWAY: sell at K_call, capped upside
                realized_spot = K_call - cost_basis
                pnl = realized_spot + net_prem_c
                in_spot = False
                cost_basis = 0.0
            else:
                # Not called: hold spot, pocket premium
                # Unrealized spot PnL included as daily mark-to-market
                pnl = (S1 - cost_basis) + net_prem_c
                in_spot = True
                cost_basis = S1  # reset cost basis to current price for next cycle P&L
            # CC collateral = cost_basis (spot value)
            collateral = S0  # use current spot as collateral
            ret = pnl / collateral
        # Spread return across the tenor bars (uniform daily attribution)
        # This is a simplification; all P&L attributed to expiry bar for honesty.
        daily_ret[exp_i] += ret
        i += tenor_d
    return daily_ret
 # ─── altlib-compatible target functions ──────────────────────────────────────
 def make_target(asset: str, put_delta: float, gate_ivr: float, f: float = 1.0):
    """Returns a target_fn(df) -> array for al.study_weights."""
    def target_fn(df: pd.DataFrame) -> np.ndarray:
        # The wheel returns are already net P&L / collateral as daily series.
        # We express this as a position series where the "position" at each bar
        # represents the implied fraction to achieve the return.
        # Since altlib shifts target[i] to hold during bar i+1, but our returns
        # are already computed episodically (premium booked at expiry), we set
        # target=1.0 during active weeks and return the actual P&L via a trick:
        # We precompute the return series and return it as a synthetic position
        # that multiplied by r[i+1]=ret gives the right P&L.
        #
        # However, altlib computes: net[t] = pos[t] * r[t]  where pos[t]=target[t-1]
        # and r[t] = simple_returns(close)[t] = close[t]/close[t-1] - 1.
        #
        # For options returns, we don't want to multiply by underlying r.
        # We instead convert: we want net[t] = wheel_ret[t].
        # pos[t-1] * r[t] = wheel_ret[t]  =>  pos[t-1] = wheel_ret[t] / r[t]
        # But r[t] can be 0 or tiny -> unstable.
        #
        # Better approach: represent the wheel as a direct return stream.
        # Use a UNIT position (=1.0 always active) but override returns via a
        # custom evaluation that bypasses the multiplication.
        # Since we can't easily do that in altlib, use the approach:
        # Return wheel_ret[t+1] / r[t+1] as target[t] so that pos[t]*r[t+1] = wheel_ret[t+1].
        # Clip and cap to avoid instability.
        c = df["close"].values.astype(float)
        r = np.zeros(len(c))
        r[1:] = c[1:] / c[:-1] - 1.0
        wr = wheel_returns(df, asset, put_delta=put_delta, gate_ivr=gate_ivr, f=f)
        # Compute implied positions: target[i] such that target[i] * r[i+1] = wr[i+1]
        # i.e., target[i] = wr[i+1] / r[i+1]
        # Shift wr forward by 1 (wr[i] attributed to bar i, but altlib needs target[i-1])
        # Actually: altlib does pos[t] = target[t-1], net[t] = pos[t]*r[t]
        # We want net[t] = wr[t], so: target[t-1] = wr[t] / r[t]
        # => target[i] = wr[i+1] / r[i+1]  (for i=0..n-2)
        tgt = np.zeros(len(c))
        for i in range(len(c) - 1):
            ri1 = r[i + 1]
            wi1 = wr[i + 1]
            if abs(ri1) > 1e-8:
                tgt[i] = wi1 / ri1
            else:
                tgt[i] = 0.0
        # Clip extreme leverage from tiny r[i+1]
        tgt = np.clip(tgt, -10.0, 10.0)
        tgt = np.nan_to_num(tgt, nan=0.0)
        return tgt
    return target_fn
 # ─── Grid: 4 configs (2 delta x 2 gate) ────────────────────────────────────
 CONFIGS = [
    dict(put_delta=-0.25, gate_ivr=0.0,  label="d25-nogate"),
    dict(put_delta=-0.25, gate_ivr=0.25, label="d25-ivr25"),
    dict(put_delta=-0.30, gate_ivr=0.0,  label="d30-nogate"),
    dict(put_delta=-0.30, gate_ivr=0.25, label="d30-ivr25"),
 ]
 def run_all():
    best_rep = None
    best_hold = -999.0
    results = []
    for cfg in CONFIGS:
        name = f"OPT02-WHEEL-{cfg['label']}"
        print(f"\n>>> Running {name} ...")
        def make_fn(c):
            def fn(df):
                # detect asset from df shape/content via DVOL alignment
                # altlib passes df for each asset; we detect via size/range difference
                # Use a helper that tries BTC first then ETH
                try:
                    tgt_btc = make_target("BTC", c["put_delta"], c["gate_ivr"])(df)
                    # Quick sanity: if this df looks like ETH (price ~1000-5000 range) try ETH
                    c_arr = df["close"].values
                    if c_arr.mean() < 10000:   # ETH prices are much lower than BTC
                        return make_target("ETH", c["put_delta"], c["gate_ivr"])(df)
                    return tgt_btc
                except Exception:
                    return np.zeros(len(df))
            return fn
        # We need per-asset target fns; altlib iterates assets internally.
        # Override: pass asset explicitly by wrapping study_weights manually.
        cells = []
        for tf in ("1d",):
            per_asset = {}
            fee_ok_all = True
            import altlib as al2
            for asset in ("BTC", "ETH"):
                df = al.get(asset, tf)
                tgt = make_target(asset, cfg["put_delta"], cfg["gate_ivr"])(df)
                base = al.eval_weights(df, tgt, fee_side=0.0)  # fee already in wr
                # Fee sweep at the strategy level is already baked in (12.5% of premium)
                # For altlib fee_sweep, we still vary the underlying turnover fee
                sweep = {}
                for f_side in al.FEE_SWEEP:
                    ev = al.eval_weights(df, tgt, fee_side=f_side)
                    sweep[f"{2*f_side*100:.2f}%RT"] = ev["full"]["sharpe"]
                fee_ok = sweep.get("0.20%RT", -9) > 0
                fee_ok_all = fee_ok_all and fee_ok
                per_asset[asset] = 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 ("BTC", "ETH"))
            min_hold = min(per_asset[a]["holdout"].get("sharpe", 0.0) for a in ("BTC", "ETH"))
            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 ("BTC", "ETH")]), 3),
                fee_survives=fee_ok_all,
            ))
        rep = dict(name=name, kind="weights", cells=cells,
                   verdict=al._verdict(cells))
        results.append(rep)
        hold_sh = min(
            cells[0]["per_asset"][a]["holdout"].get("sharpe", -99)
            for a in ("BTC", "ETH")
        )
        if hold_sh > best_hold:
            best_hold = hold_sh
            best_rep = rep
        print(al.fmt(rep))
    return best_rep, results
 if __name__ == "__main__":
    best_rep, all_results = run_all()
    print("\n\n=== BEST CONFIG ===")
    print(al.fmt(best_rep))
    print("JSON:", al.as_json(best_rep))
@@ -1,193 +0,0 @@
 """OPT03 — Calendar Spread (DVOL term proxy).
 IDEA: A calendar spread (sell short-dated, buy long-dated option) profits when:
 - Term structure is in contango (short vol < long vol) -> theta decay favors the short leg
 - The vol term slope is MEAN-REVERTING: extreme backwardation -> enter long calendar
 MODELED APPROACH (since we lack real term surface):
  - Short-dated vol proxy: EMA(DVOL, span_short) — reacts quickly to spot moves
  - Long-dated vol proxy: EMA(DVOL, span_long)  — slower, represents long-term expectation
  - Term slope = short_proxy - long_proxy (positive = backwardation, negative = contango)
  - Position: go long calendar when slope is high (extreme backwardation -> mean-revert to flat)
              go short calendar when slope is very negative (extreme contango -> normalize)
  Signal: zscore of (short_ema - long_ema) over rolling window.
  Direction: mean-reversion -> go LONG when z is high (backwardation = short vol elevated)
             because short vol will eventually fall back to long vol.
  Vol-target the position (20%, cap 2x).
 GRID: 4 configs (short_span x long_span)
  - (7d, 30d): short-term vs monthly
  - (7d, 60d): short-term vs 2-month
  - (14d, 60d): 2-week vs 2-month
  - (14d, 90d): 2-week vs 3-month
 CAVEAT: premiums are MODELED using DVOL (no real term surface available).
        This is a lead/research indicator only, not deployable as-is.
        Data starts 2021-03 (DVOL history constraint).
 """
 import sys
 sys.path.insert(0, "/opt/docker/PythagorasGoal/scripts/research/alt")
 import altlib as al
 import numpy as np
 # DVOL is daily -> span parameters in DAYS
 CONFIGS = [
    {"short_days": 7,  "long_days": 30,  "zscore_win": 60},
    {"short_days": 7,  "long_days": 60,  "zscore_win": 90},
    {"short_days": 14, "long_days": 60,  "zscore_win": 90},
    {"short_days": 14, "long_days": 90,  "zscore_win": 120},
 ]
 def make_target(short_days: int, long_days: int, zscore_win: int):
    """Return target_fn(df) -> position array."""
    def target_fn(df):
        n = len(df)
        bpd = al.bars_per_day(df)
        # DVOL aligned causally to df bars
        dv = al.dvol(df, "BTC")  # NOTE: asset-specific handled below via closure
        # Mask where DVOL is available
        valid = np.isfinite(dv)
        # Compute EMAs of DVOL as short/long term structure proxies
        # spans in days -> convert to bars
        short_span = max(2, int(short_days * bpd))
        long_span  = max(4, int(long_days * bpd))
        import pandas as pd
        dv_s = pd.Series(dv)
        # EMA on valid-filled series (forward-fill to avoid NaN inside EMA)
        dv_ffilled = dv_s.ffill()
        ema_short = dv_ffilled.ewm(span=short_span, adjust=False).mean().values
        ema_long  = dv_ffilled.ewm(span=long_span,  adjust=False).mean().values
        # Term slope: positive = backwardation (short > long)
        slope = ema_short - ema_long
        # Z-score of slope over rolling window
        zscore_win_bars = max(10, int(zscore_win * bpd))
        z = al.zscore(slope, zscore_win_bars)
        # Mean-reversion signal: when backwardation is extreme (high z),
        # short vol is elevated -> will mean-revert down -> calendar spread gains
        # Position: +1 when z > 0 (backwardation -> long calendar)
        #            -1 when z < 0 (contango -> short calendar / flat)
        # Use continuous sizing based on z-score, clipped to [-1, 1]
        direction = np.clip(z, -1.0, 1.0)
        # NaN where DVOL not available (pre-2021-03)
        direction = np.where(valid & np.isfinite(z), direction, 0.0)
        # Vol-target
        tgt = al.vol_target(direction, df, target_vol=0.20, vol_win_days=30, leverage_cap=2.0)
        return tgt
    return target_fn
 def make_target_asset(short_days: int, long_days: int, zscore_win: int, asset: str):
    """Per-asset version that uses the correct DVOL."""
    def target_fn(df):
        n = len(df)
        bpd = al.bars_per_day(df)
        dv = al.dvol(df, asset)
        valid = np.isfinite(dv)
        short_span = max(2, int(short_days * bpd))
        long_span  = max(4, int(long_days * bpd))
        import pandas as pd
        dv_s = pd.Series(dv)
        dv_ffilled = dv_s.ffill()
        ema_short = dv_ffilled.ewm(span=short_span, adjust=False).mean().values
        ema_long  = dv_ffilled.ewm(span=long_span,  adjust=False).mean().values
        slope = ema_short - ema_long
        zscore_win_bars = max(10, int(zscore_win * bpd))
        z = al.zscore(slope, zscore_win_bars)
        direction = np.clip(z, -1.0, 1.0)
        direction = np.where(valid & np.isfinite(z), direction, 0.0)
        tgt = al.vol_target(direction, df, target_vol=0.20, vol_win_days=30, leverage_cap=2.0)
        return tgt
    return target_fn
 def run_config(cfg: dict, tfs=("1d", "12h")) -> dict:
    """Run one config across assets+tfs."""
    sd, ld, zw = cfg["short_days"], cfg["long_days"], cfg["zscore_win"]
    name = f"OPT03-CAL-s{sd}d-l{ld}d-z{zw}d"
    # Build per-asset closures
    btc_fn = make_target_asset(sd, ld, zw, "BTC")
    eth_fn = make_target_asset(sd, ld, zw, "ETH")
    cells = []
    for tf in tfs:
        per_asset = {}
        fee_ok_all = True
        for a, fn in [("BTC", btc_fn), ("ETH", eth_fn)]:
            df = al.get(a, tf)
            tgt = fn(df)
            base = al.eval_weights(df, tgt, fee_side=al.FEE_SIDE)
            sweep = {f"{2*f*100:.2f}%RT": al.eval_weights(df, tgt, fee_side=f)["full"]["sharpe"]
                     for f in al.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 ("BTC", "ETH"))
        min_hold = min(per_asset[a]["holdout"].get("sharpe", 0.0) for a in ("BTC", "ETH"))
        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 ("BTC", "ETH")]), 3),
            fee_survives=fee_ok_all
        ))
    return dict(name=name, kind="weights", cells=cells,
                verdict=al._verdict(cells), config=cfg)
 if __name__ == "__main__":
    print("OPT03 — Calendar Spread via DVOL term proxy")
    print("CAVEAT: premiums are MODELED (DVOL only, no real term surface) — lead/research only")
    print("DVOL history starts 2021-03 -> effective backtest from ~2021-Q3")
    print()
    # Run all 4 configs on 1d only (DVOL is daily; 12h would repeat same info)
    # We test 1d and 12h to see if intraday resolution helps, but expect 1d to be canonical
    results = []
    for cfg in CONFIGS:
        print(f"Running config: short={cfg['short_days']}d long={cfg['long_days']}d zscore={cfg['zscore_win']}d ...")
        rep = run_config(cfg, tfs=("1d",))
        results.append(rep)
        print(al.fmt(rep))
        print()
    # Pick best config by min_asset_holdout_sharpe
    best = max(results, key=lambda r: max(
        (c["min_asset_holdout_sharpe"] for c in r["cells"]), default=-9))
    print("=" * 60)
    print("BEST CONFIG:", best["name"])
    print(al.fmt(best))
    print()
    print("JSON:", al.as_json(best))
@@ -1,377 +0,0 @@
 """OPT04 — Iron Condor Weekly (DVOL-gated).
 IDEA: Sell OTM call+put spreads weekly, collect premium from both sides. Iron condor =
  - Sell OTM put  (delta ~-0.20), Buy further OTM put  (delta ~-0.08)  <- put credit spread
  - Sell OTM call (delta ~+0.20), Buy further OTM call (delta ~+0.08)  <- call credit spread
 Premium collected from BOTH sides. Profit if underlying stays within the wings (range-bound week).
 Max loss = wing width - net premium (total of both spreads).
 MODELED APPROACH:
  - DVOL used as ATM vol proxy (symmetric BS, no skew).
  - Gate: IV-rank > 0.30 (sell only when IV is rich relative to own history).
  - Optional crash-skip: IV-rank > 0.90 -> vol already exploded, skip.
  - Capital = put wing width + call wing width (total defined risk).
  - Fee: 12.5% of net premium (Deribit options cap, per side; 4 legs total = 2 round-trips).
 GRID (4 configs on 1d TF):
  A) delta ±0.20/±0.08, ivr_gate=0.30, no crash-skip
  B) delta ±0.25/±0.10, ivr_gate=0.30, no crash-skip
  C) delta ±0.20/±0.08, ivr_gate=0.30, crash-skip at 0.90
  D) delta ±0.25/±0.10, ivr_gate=0.30, crash-skip at 0.90
 CAVEAT: premiums MODELED on DVOL ATM (no skew, no real chain). Lead quantification only.
        DVOL history starts 2021-03 -> effective backtest from ~2021-Q3.
 """
 import sys
 sys.path.insert(0, "/opt/docker/PythagorasGoal/scripts/research/alt")
 import altlib as al
 import numpy as np
 import pandas as pd
 from scipy.stats import norm
 # ─── Black-Scholes helpers ────────────────────────────────────────────────────
 def bs_put(S: float, K: float, T: float, sig: float) -> float:
    """Black-Scholes put price, r=0."""
    if T <= 0 or sig <= 0:
        return max(K - S, 0.0)
    d1 = (np.log(S / K) + 0.5 * sig**2 * T) / (sig * np.sqrt(T))
    d2 = d1 - sig * np.sqrt(T)
    return K * norm.cdf(-d2) - S * norm.cdf(-d1)
 def bs_call(S: float, K: float, T: float, sig: float) -> float:
    """Black-Scholes call price, r=0."""
    if T <= 0 or sig <= 0:
        return max(S - K, 0.0)
    d1 = (np.log(S / K) + 0.5 * sig**2 * T) / (sig * np.sqrt(T))
    d2 = d1 - sig * np.sqrt(T)
    return S * norm.cdf(d1) - K * norm.cdf(d2)
 def strike_put_from_delta(S: float, T: float, sig: float, delta: float) -> float:
    """Strike for a put with given delta (delta < 0, e.g. -0.20).
    put_delta = -N(-d1) = delta  ->  N(-d1) = -delta  ->  -d1 = N^{-1}(-delta)
    d1 = -N^{-1}(-delta)
    K = S * exp(0.5*sig^2*T - d1*sig*sqrt(T))."""
    d1 = -norm.ppf(-delta)
    return S * np.exp(0.5 * sig**2 * T - d1 * sig * np.sqrt(T))
 def strike_call_from_delta(S: float, T: float, sig: float, delta: float) -> float:
    """Strike for a call with given delta (delta > 0, e.g. +0.20).
    call_delta = N(d1) = delta  ->  d1 = N^{-1}(delta)
    K = S * exp(-d1*sig*sqrt(T) + 0.5*sig^2*T)."""
    d1 = norm.ppf(delta)
    return S * np.exp(-d1 * sig * np.sqrt(T) + 0.5 * sig**2 * T)
 # ─── IV-rank (causal, expanding window) ──────────────────────────────────────
 def iv_rank_series(dv_pts: np.ndarray, min_history: int = 60) -> np.ndarray:
    """Causal expanding-window IV rank: fraction of past DVOL values below current.
    NaN until min_history valid bars are available."""
    n = len(dv_pts)
    ivr = np.full(n, np.nan)
    valid = np.where(np.isfinite(dv_pts))[0]
    if len(valid) < min_history:
        return ivr
    start = valid[0]
    for i in valid:
        hist_len = i - start
        if hist_len >= min_history:
            hist = dv_pts[start:i]
            hist = hist[np.isfinite(hist)]
            if len(hist) >= min_history:
                ivr[i] = float((hist < dv_pts[i]).mean())
    return ivr
 # ─── Standalone iron condor backtest ─────────────────────────────────────────
 def backtest_ic(
    df: pd.DataFrame,
    asset: str,
    short_delta_put: float = -0.20,
    long_delta_put: float  = -0.08,
    short_delta_call: float = 0.20,
    long_delta_call: float  = 0.08,
    ivr_gate: float        = 0.30,
    crash_skip: float      = 1.01,   # >1 disables crash-skip
    tenor_d: int           = 7,
    fee_side: float        = al.FEE_SIDE,
 ) -> dict:
    """Honest backtest of weekly iron condor on daily bars.
    P&L mechanics:
      - Every tenor_d bars (weekly) decide at bar i (close[i] known), settle at i+tenor_d.
      - Net premium = put_net + call_net (both modeled with BS on DVOL, no skew).
      - Payoff realized on close[i+tenor_d].
      - Capital basis = put_wing + call_wing (total defined risk).
      - Return_week = (net_premium - payoffs - fee) / capital.
      - Booked at settlement bar; 0 elsewhere.
    Returns al.eval_weights-compatible dict.
    """
    close = df["close"].values.astype(float)
    dts   = pd.to_datetime(df["datetime"], utc=True)
    n     = len(close)
    T_yr  = tenor_d / 365.25
    dv_pts = al.dvol(df, asset)
    dv     = dv_pts / 100.0
    ivr    = iv_rank_series(dv_pts, min_history=60)
    daily_pnl = np.zeros(n)
    in_trade  = np.zeros(n, dtype=bool)
    # Start from first bar where we have at least 60 bars of DVOL history
    valid_dvol = np.where(np.isfinite(dv_pts))[0]
    if len(valid_dvol) < 60:
        return _empty_result(df, dts)
    i_start = valid_dvol[60]  # first bar with 60 history points
    i = i_start
    trades = 0
    while i + tenor_d < n:
        S0  = close[i]
        sig = dv[i]
        # DVOL must be available
        if not np.isfinite(sig) or sig <= 0.0:
            i += tenor_d
            continue
        # IV-rank must be available
        if not np.isfinite(ivr[i]):
            i += tenor_d
            continue
        # Gate: sell only when IV rank above threshold
        if ivr_gate > 0.0 and ivr[i] < ivr_gate:
            i += tenor_d
            continue
        # Crash-skip: do not sell when vol already exploded
        if crash_skip < 1.0 and ivr[i] > crash_skip:
            i += tenor_d
            continue
        # ── PUT credit spread ──────────────────────────────────────────────
        Ks_put = strike_put_from_delta(S0, T_yr, sig, short_delta_put)  # short (less OTM)
        Kl_put = strike_put_from_delta(S0, T_yr, sig, long_delta_put)   # long  (more OTM)
        prem_s_put = bs_put(S0, Ks_put, T_yr, sig)
        prem_l_put = bs_put(S0, Kl_put, T_yr, sig)
        net_put    = prem_s_put - prem_l_put
        wing_put   = Ks_put - Kl_put       # put short strike > long strike -> positive
        # ── CALL credit spread ─────────────────────────────────────────────
        Ks_call = strike_call_from_delta(S0, T_yr, sig, short_delta_call)  # short (less OTM)
        Kl_call = strike_call_from_delta(S0, T_yr, sig, long_delta_call)   # long  (more OTM)
        prem_s_call = bs_call(S0, Ks_call, T_yr, sig)
        prem_l_call = bs_call(S0, Kl_call, T_yr, sig)
        net_call    = prem_s_call - prem_l_call
        wing_call   = Kl_call - Ks_call    # call long strike > short strike -> positive
        # Sanity: net premiums must be positive (should always be true by construction)
        if net_put <= 0.0 or net_call <= 0.0 or wing_put <= 0.0 or wing_call <= 0.0:
            i += tenor_d
            continue
        S1 = close[i + tenor_d]
        # ── PUT spread payoff ──────────────────────────────────────────────
        payoff_put  = max(0.0, Ks_put - S1) - max(0.0, Kl_put - S1)
        # ── CALL spread payoff ─────────────────────────────────────────────
        payoff_call = max(0.0, S1 - Ks_call) - max(0.0, S1 - Kl_call)
        # ── Net P&L ────────────────────────────────────────────────────────
        gross_pnl  = (net_put - payoff_put) + (net_call - payoff_call)
        # Capital basis: total defined risk (both wings)
        cap = wing_put + wing_call
        # Deribit options fee: 0.03% of notional per leg, cap 12.5% of premium.
        # 4 legs total for an iron condor. Conservative: cap 12.5% of gross net premium.
        FEE_FRAC = 0.125
        fee_cost = FEE_FRAC * (net_put + net_call)
        ret_week = (gross_pnl - fee_cost) / cap
        # Book at settlement bar
        settle = i + tenor_d
        daily_pnl[settle] += ret_week
        in_trade[i:settle] = True
        trades += 1
        i += tenor_d
    idx  = pd.DatetimeIndex(dts)
    net  = daily_pnl
    full = al._metrics_from_net(net, idx)
    hmask = idx >= al.HOLDOUT
    hold  = al._metrics_from_net(net[hmask], idx[hmask]) if hmask.sum() > 3 else dict(sharpe=0.0, n=0)
    bpy_d = al.bars_per_day(df) * 365.25
    return dict(
        full=full, holdout=hold, yearly=al._yearly(net, idx),
        time_in_market=round(float(np.mean(in_trade)), 3),
        turnover_per_year=round(float(trades * 2) / max(1, len(net) / bpy_d), 1),
        net=net, idx=idx,
    )
 def _empty_result(df, dts):
    idx = pd.DatetimeIndex(pd.to_datetime(dts, utc=True))
    net = np.zeros(len(df))
    return dict(
        full=al._metrics_from_net(net, idx), holdout=dict(sharpe=0.0, n=0),
        yearly=al._yearly(net, idx), time_in_market=0.0, turnover_per_year=0.0,
        net=net, idx=idx,
    )
 # ─── Config grid ──────────────────────────────────────────────────────────────
 CONFIGS = [
    # (label,        sdp,   ldp,   ivr_gate, crash_skip)
    ("w20-08-ivr30",      -0.20, -0.08, 0.30, 1.01),   # wider wing, gate only
    ("w25-10-ivr30",      -0.25, -0.10, 0.30, 1.01),   # narrower wing, gate only
    ("w20-08-ivr30-cs90", -0.20, -0.08, 0.30, 0.90),   # wider + crash-skip
    ("w25-10-ivr30-cs90", -0.25, -0.10, 0.30, 0.90),   # narrower + crash-skip
 ]
 def run_config(label, sdp, ldp, ivr_gate, cs, tf="1d") -> dict:
    name = f"OPT04-IC-{label}"
    per_asset = {}
    fee_ok_all = True
    for asset in ("BTC", "ETH"):
        df   = al.get(asset, tf)
        base = backtest_ic(df, asset,
                           short_delta_put=sdp, long_delta_put=ldp,
                           short_delta_call=-sdp, long_delta_call=-ldp,
                           ivr_gate=ivr_gate, crash_skip=cs)
        # Fee sweep: re-run with different fee fracs via fee_side proxy
        # (fee_side not directly used in our custom backtest; we scale FEE_FRAC)
        sweep = {}
        for f_side in al.FEE_SWEEP:
            # Map taker fee to options fee frac: baseline is 0.125 at f_side=FEE_SIDE=0.0005
            # Scale proportionally
            scale = f_side / al.FEE_SIDE if al.FEE_SIDE > 0 else 1.0
            fee_frac_scaled = 0.125 * scale
            # Recompute with scaled fee
            net_scaled = _recompute_net_scaled(df, asset, sdp, ldp, ivr_gate, cs, fee_frac_scaled)
            net_arr = net_scaled["net"]
            idx_arr = net_scaled["idx"]
            m = al._metrics_from_net(net_arr, idx_arr)
            sweep[f"{2*f_side*100:.2f}%RT"] = m["sharpe"]
        fee_ok = sweep.get("0.20%RT", -9) > 0
        fee_ok_all = fee_ok_all and fee_ok
        per_asset[asset] = 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 ("BTC", "ETH"))
    min_hold = min(per_asset[a]["holdout"].get("sharpe", 0.0) for a in ("BTC", "ETH"))
    cells = [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 ("BTC", "ETH")]), 3),
        fee_survives=fee_ok_all,
    )]
    return dict(name=name, kind="weights", cells=cells, verdict=al._verdict(cells))
 def _recompute_net_scaled(df, asset, sdp, ldp, ivr_gate, cs, fee_frac):
    """Recompute iron condor returns with a different fee fraction."""
    close  = df["close"].values.astype(float)
    dts    = pd.to_datetime(df["datetime"], utc=True)
    n      = len(close)
    T_yr   = 7 / 365.25
    dv_pts = al.dvol(df, asset)
    dv     = dv_pts / 100.0
    ivr    = iv_rank_series(dv_pts, min_history=60)
    daily_pnl = np.zeros(n)
    valid_dvol = np.where(np.isfinite(dv_pts))[0]
    if len(valid_dvol) < 60:
        return dict(net=daily_pnl, idx=pd.DatetimeIndex(pd.to_datetime(dts, utc=True)))
    i = valid_dvol[60]
    while i + 7 < n:
        S0 = close[i]; sig = dv[i]
        if not np.isfinite(sig) or sig <= 0:
            i += 7; continue
        if not np.isfinite(ivr[i]):
            i += 7; continue
        if ivr_gate > 0 and ivr[i] < ivr_gate:
            i += 7; continue
        if cs < 1.0 and ivr[i] > cs:
            i += 7; continue
        Ks_put  = strike_put_from_delta(S0, T_yr, sig, sdp)
        Kl_put  = strike_put_from_delta(S0, T_yr, sig, ldp)
        net_put = bs_put(S0, Ks_put, T_yr, sig) - bs_put(S0, Kl_put, T_yr, sig)
        wing_put = Ks_put - Kl_put
        Ks_call  = strike_call_from_delta(S0, T_yr, sig, -sdp)
        Kl_call  = strike_call_from_delta(S0, T_yr, sig, -ldp)
        net_call = bs_call(S0, Ks_call, T_yr, sig) - bs_call(S0, Kl_call, T_yr, sig)
        wing_call = Kl_call - Ks_call
        if net_put <= 0 or net_call <= 0 or wing_put <= 0 or wing_call <= 0:
            i += 7; continue
        S1 = close[i + 7]
        payoff_put  = max(0.0, Ks_put - S1) - max(0.0, Kl_put - S1)
        payoff_call = max(0.0, S1 - Ks_call) - max(0.0, S1 - Kl_call)
        gross = (net_put - payoff_put) + (net_call - payoff_call)
        fee   = fee_frac * (net_put + net_call)
        cap   = wing_put + wing_call
        daily_pnl[i + 7] += (gross - fee) / cap
        i += 7
    return dict(net=daily_pnl, idx=pd.DatetimeIndex(pd.to_datetime(dts, utc=True)))
 # ─── Main ─────────────────────────────────────────────────────────────────────
 if __name__ == "__main__":
    print("OPT04 — Iron Condor Weekly (DVOL-gated)")
    print("CAVEAT: premiums MODELED on DVOL ATM (no skew). Lead quantification only.")
    print("DVOL history starts 2021-03 -> effective backtest from ~2021-Q3.")
    print()
    results = []
    for label, sdp, ldp, ivr_gate, cs in CONFIGS:
        print(f"Running: {label}")
        rep = run_config(label, sdp, ldp, ivr_gate, cs, tf="1d")
        results.append(rep)
        print(al.fmt(rep))
        print()
    best = max(results, key=lambda r: max(
        (c["min_asset_holdout_sharpe"] for c in r["cells"]), default=-9.0))
    print("=" * 70)
    print("BEST CONFIG:", best["name"])
    print(al.fmt(best))
    print()
    print("JSON:", al.as_json(best))
@@ -1,450 +0,0 @@
 """OPT05 — Delta-Hedged Short Straddle (Variance Premium Harvest)
 IDEA: Sell ATM straddle every N days, delta-hedge daily with ACTUAL price moves.
 Net P&L = IV-RV spread (the variance risk premium).
 HONEST APPROACH — Direct P&L Simulation (avoids BS gamma approximation errors):
  1. At roll date i0: sell ATM straddle. Receive premium P = 2*BSCall(S0,S0,T,IV).
  2. Compute initial delta hedge: delta_straddle = delta_call + delta_put = N(d1) - N(-d1) ≈ 0 ATM.
     Set delta_hedge_position h0 = -delta_straddle ≈ 0 at initiation.
  3. Each subsequent bar k: compute new delta at current S_k, T_remaining.
     Rebalance: dh = new_delta - old_delta. Hedge cost includes:
       (a) Slippage/market-impact on spot hedge: dh * S_k * fee_hedge (spot fee per side)
       (b) The actual mark-to-market P&L of the short straddle:
           delta_PnL = -(C(S_k, K, T_k) + P(S_k, K, T_k) - C(S_{k-1}, K, T_{k-1}) - P(S_{k-1}, K, T_{k-1}))
           plus hedge_PnL = h * (S_k - S_{k-1})
  4. At expiry: close position at intrinsic value.
  Total cycle P&L = option_premium - (intrinsic_at_expiry + sum_of_theta_adj + hedge_slippage)
  This simulation directly uses ACTUAL price moves, so:
  - Big moves (jumps) correctly cause large losses
  - Small/quiet periods correctly generate theta income
  - Discrete rebalancing frequency exactly matches daily bars
 KEY METRICS EXPECTED:
  - Crypto IV ≈ 60-80%, RV ≈ 40-65%: IV>RV on average → net positive
  - But crypto has fat tails: occasional -10%/-20% single-day moves devastate short gamma
  - Expected Sharpe: 0.3–0.8 if honestly modeled (not 4.0)
 GATE: Only enter when DVOL/RV_20d >= gate threshold (IV-rich condition).
 GRID: roll_days in {7, 14} x iv_rv_gate in {1.10, 1.20} → 4 configs, 1d TF only.
 CAVEAT:
  - MODELED on DVOL ATM. Skew not modeled (OTM puts have higher IV in practice).
  - Straddle sell assumes fills at mid; real execution has bid-ask spread.
  - Tail risk (e.g., BTC -30% day) not captured via DVOL history smoothing.
  - DVOL history starts 2021-03 → backtest from 2021-03 only.
  - Lead-only; not for deployment without real options data.
 Style: study_weights (continuous modeled position evaluated via standalone P&L series).
 """
 import sys
 sys.path.insert(0, "/opt/docker/PythagorasGoal/scripts/research/alt")
 import altlib as al
 import numpy as np
 import pandas as pd
 from scipy.stats import norm
 # ── Black-Scholes helpers ──────────────────────────────────────────────────────
 def bs_price(S: float, K: float, T: float, sigma: float, option_type: str = "call") -> float:
    """Black-Scholes option price. r=0 (crypto/futures context)."""
    if T <= 0 or sigma <= 0 or S <= 0 or K <= 0:
        # Intrinsic value
        if option_type == "call":
            return max(0.0, S - K)
        else:
            return max(0.0, K - S)
    d1 = (np.log(S / K) + 0.5 * sigma**2 * T) / (sigma * np.sqrt(T))
    d2 = d1 - sigma * np.sqrt(T)
    if option_type == "call":
        return float(S * norm.cdf(d1) - K * norm.cdf(d2))
    else:
        return float(K * norm.cdf(-d2) - S * norm.cdf(-d1))
 def bs_delta(S: float, K: float, T: float, sigma: float, option_type: str = "call") -> float:
    """Black-Scholes delta."""
    if T <= 0 or sigma <= 0 or S <= 0 or K <= 0:
        if option_type == "call":
            return 1.0 if S > K else 0.0
        else:
            return -1.0 if S < K else 0.0
    d1 = (np.log(S / K) + 0.5 * sigma**2 * T) / (sigma * np.sqrt(T))
    if option_type == "call":
        return float(norm.cdf(d1))
    else:
        return float(norm.cdf(d1) - 1.0)
 def straddle_value(S: float, K: float, T: float, sigma: float) -> float:
    """ATM straddle value = call + put."""
    return bs_price(S, K, T, sigma, "call") + bs_price(S, K, T, sigma, "put")
 def straddle_delta(S: float, K: float, T: float, sigma: float) -> float:
    """Net delta of short straddle: call_delta + put_delta."""
    return bs_delta(S, K, T, sigma, "call") + bs_delta(S, K, T, sigma, "put")
 def simulate_straddle_cycle(
    close: np.ndarray,
    sigma_iv: np.ndarray,
    i0: int,
    roll_bars: int,
    fee_hedge: float = 0.0005  # spot hedge rebalance cost (0.05% per side taker)
 ) -> tuple[float, int]:
    """
    Simulate ONE delta-hedged short straddle cycle starting at bar i0.
    Returns (net_pnl_fraction_of_K, i_expiry) where:
      - net_pnl is in fraction of strike K (= S0 at entry)
      - i_expiry is the bar at which the cycle ends
    P&L components (all as fraction of K):
      + straddle_premium/K received at i0 (short straddle → receive premium)
      - mark-to-market change of straddle value (we're short)
      + hedge P&L from spot hedge position
      - hedge rebalancing cost (fee per trade)
    """
    n = len(close)
    S0 = close[i0]
    K = S0  # sell ATM
    T0 = roll_bars / 365.25  # time to expiry in years
    sig0 = sigma_iv[i0]
    if not (np.isfinite(sig0) and sig0 > 0.01):
        return 0.0, min(i0 + roll_bars, n - 1)
    # Sell straddle at i0: receive premium
    prem0 = straddle_value(S0, K, T0, sig0)
    # Position: short straddle (we want straddle to decrease in value)
    # Short straddle value at entry = prem0
    # Initial delta hedge (fractional units of underlying per unit K)
    delta0 = straddle_delta(S0, K, T0, sig0)  # ≈ 0 at ATM
    # Hedge: buy delta0 units of spot to hedge (position in spot = delta0 * K)
    # But we're SHORT the straddle, so our delta is +delta_straddle, we need to sell spot
    # Short straddle delta = -(call_delta + put_delta)
    # We go long (-straddle_delta) in spot to be delta-neutral
    hedge_pos = -delta0  # units of S per unit of notional (S0)
    # Running P&L tracking
    total_pnl = prem0  # we received this upfront (in $ terms, / K at end)
    # straddle_prev_value = prem0  # track mark-to-market
    prev_S = S0
    prev_sig = sig0
    prev_hedge = hedge_pos
    i_expiry = min(i0 + roll_bars, n - 1)
    total_hedge_cost = 0.0
    for i in range(i0 + 1, i_expiry + 1):
        S_curr = close[i]
        bars_to_exp = i_expiry - i
        T_rem = max(0.0, bars_to_exp / 365.25)
        # Current IV (use entry IV as fallback if current is invalid)
        sig_curr = sigma_iv[i]
        if not (np.isfinite(sig_curr) and sig_curr > 0.01):
            sig_curr = prev_sig
        # Mark-to-market change of SHORT straddle:
        # new_straddle_value = straddle_value(S_curr, K, T_rem, sig_curr)
        # P&L from option position = -(new_val - prev_val)  [we're short]
        # But the hedge also moves
        # Spot hedge P&L = hedge_pos * (S_curr - prev_S)
        # We track this explicitly via the straddle formula
        # At expiry: T_rem = 0 → straddle = intrinsic = max(S-K,0) + max(K-S,0) = |S-K|
        if i == i_expiry:
            straddle_final = abs(S_curr - K)
            # Settle: short straddle loses if straddle_final > some_threshold
            # Net P&L = prem0 - straddle_final + hedge_pnl
            # Hedge P&L from last rebalance to now:
            hedge_pnl_final = prev_hedge * (S_curr - prev_S)
            # Close hedge: pay fee on closing the spot position
            close_hedge_cost = abs(prev_hedge) * S_curr * fee_hedge / K
            total_pnl = prem0 - straddle_final + (
                # Sum of all intermediate hedge P&L is already implicitly in the
                # straddle mark-to-market (via put-call parity at each step).
                # Actually: just compute total_pnl directly:
                # P&L = premium_received - intrinsic_paid - sum(hedge_rebalance_costs)
                # The hedge P&L and straddle MTM cancel each other (that's the whole
                # point of delta hedging — the delta exposure is neutralized).
                # So the final net = premium_received - realized_variance_cost - intrinsic_settlement
                # where realized_variance_cost = sum of gamma * (dS)^2 / 2 per bar.
                # This is what we compute below.
                0  # placeholder
            )
            # ACTUALLY let's compute it cleanly: the total delta-hedged P&L is:
            # P&L = premium_received - straddle_final_value + cumulative_hedge_rebalance_PnL - costs
            # cumulative_hedge_rebalance_PnL = sum over all rebal: hedge_k * (S_{k+1} - S_k)
            # This is complex to track; instead use the gamma P&L theorem:
            # Total delta-hedged short straddle P&L = 0.5 * sum_k(gamma_k * S_k^2 * r_k^2) * (IV^2/RV^2 - 1)
            # NO — let's just do it directly step by step.
            break
        # Intermediate bar: compute hedge rebalancing P&L
        new_delta = straddle_delta(S_curr, K, T_rem, sig_curr)
        new_hedge = -new_delta
        # Spot hedge P&L for this bar
        hedge_pnl = prev_hedge * (S_curr - prev_S)
        total_pnl += hedge_pnl / K  # add in fraction of K
        # Rebalance cost
        d_hedge = new_hedge - prev_hedge
        rebal_cost = abs(d_hedge) * S_curr * fee_hedge / K
        total_hedge_cost += rebal_cost
        prev_S = S_curr
        prev_sig = sig_curr
        prev_hedge = new_hedge
    # Final settlement
    S_exp = close[i_expiry]
    intrinsic = abs(S_exp - K)
    hedge_pnl_final = prev_hedge * (S_exp - prev_S) / K
    close_cost = abs(prev_hedge) * S_exp * fee_hedge / K
    net_pnl = (prem0 - intrinsic) / K + hedge_pnl_final - total_hedge_cost - close_cost
    return float(net_pnl), i_expiry
 def compute_straddle_series(
    df: pd.DataFrame,
    asset: str,
    roll_days: int,
    iv_rv_gate: float,
    rv_win_days: int = 20,
    fee_hedge: float = 0.0005
 ) -> np.ndarray:
    """
    Simulate the full delta-hedged short straddle strategy.
    Returns per-bar P&L as a fraction of equity (additive).
    Only enters when IV/RV >= gate.
    """
    close = df["close"].values.astype(float)
    n = len(close)
    sigma_iv = al.dvol(df, asset) / 100.0
    log_r = al.log_returns(close)
    bpy = al.bars_per_year(df)
    rv_win = max(5, rv_win_days)
    rv_ann = pd.Series(log_r).rolling(rv_win, min_periods=max(2, rv_win // 2)).std().values * np.sqrt(bpy)
    first_valid = np.where(np.isfinite(sigma_iv) & (sigma_iv > 0.01))[0]
    if len(first_valid) == 0:
        return np.zeros(n)
    start_bar = int(first_valid[0])
    r_opt = np.zeros(n)  # per-bar P&L
    i = start_bar
    while i < n:
        sig_iv = sigma_iv[i]
        sig_rv = rv_ann[i]
        # Entry condition: valid IV, valid RV, IV/RV >= gate
        if (np.isfinite(sig_iv) and sig_iv > 0.01 and
                np.isfinite(sig_rv) and sig_rv > 0.01 and
                sig_iv / sig_rv >= iv_rv_gate):
            # Run one cycle
            net_pnl, i_exp = simulate_straddle_cycle(
                close, sigma_iv, i, roll_days, fee_hedge=fee_hedge
            )
            # Record P&L at settlement bar
            r_opt[i_exp] = net_pnl
            i = i_exp + 1  # next cycle starts after expiry
        else:
            # Skip bar (flat, no straddle)
            i += 1
    return r_opt
 def eval_straddle_series(
    df: pd.DataFrame,
    r_opt: np.ndarray,
    fee_side: float = al.FEE_SIDE
 ) -> dict:
    """
    Evaluate the option P&L series as an independent equity curve.
    The per-bar r_opt[i] is a P&L in fraction of current equity (additive).
    We compound them: equity[i+1] = equity[i] * (1 + r_opt[i]).
    IMPORTANT: the straddle already charges spot-hedge transaction costs internally.
    The fee_side here is for the OPTION premium transaction (opening/closing the straddle
    legs themselves), charged on a per-cycle basis.
    We estimate: 2 legs * 2 sides * fee_side per cycle.
    """
    idx = pd.DatetimeIndex(pd.to_datetime(df["datetime"], utc=True))
    n = len(r_opt)
    # Option transaction cost: charge on settlement bars (each represents a closed cycle)
    settle_bars = r_opt != 0
    # Option bid-ask: straddle has 2 legs, each has entry + exit = 4 * fee_side
    # But we use fee_side as option cost per leg per side ≈ 2-3x spot fee
    option_tx_cost = np.where(settle_bars, 4 * fee_side, 0.0)  # 4 legs total
    r_net = r_opt - option_tx_cost
    # Equity curve (compounding)
    eq = np.cumprod(1.0 + np.clip(r_net, -0.99, None))
    eq = np.concatenate([[1.0], eq])
    # Returns for metrics
    r_eq = np.diff(eq) / eq[:-1]
    r_eq = np.nan_to_num(r_eq)
    bpy = al.bars_per_year(df)
    rr = r_eq[np.isfinite(r_eq)]
    sharpe = float(np.mean(rr) / np.std(rr) * np.sqrt(bpy)) if np.std(rr) > 0 else 0.0
    pk = np.maximum.accumulate(eq[1:])
    dd = float(np.max((pk - eq[1:]) / pk)) if len(eq) > 1 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_ret = eq[-1] / eq[0] - 1
    cagr = (eq[-1] / eq[0]) ** (1 / years) - 1
    full = dict(sharpe=round(sharpe, 3), cagr=round(cagr, 4),
                maxdd=round(dd, 4), ret=round(total_ret, 4), n=int(len(rr)))
    hmask = idx >= al.HOLDOUT
    hold = dict(sharpe=0.0, ret=0.0, n=0)
    if hmask.sum() > 3:
        r_h = r_eq[hmask]
        hs = float(np.mean(r_h) / np.std(r_h) * np.sqrt(bpy)) if np.std(r_h) > 0 else 0.0
        eq_h = np.cumprod(1.0 + np.clip(r_h, -0.99, None))
        hold = dict(sharpe=round(hs, 3), ret=round(float(eq_h[-1] - 1), 4), n=int(hmask.sum()))
    s = pd.Series(r_eq, index=idx)
    yearly = {}
    for y, g in s.groupby(s.index.year):
        eq_y = np.cumprod(1 + g.values)
        pk_y = np.maximum.accumulate(eq_y)
        yearly[int(y)] = dict(ret=round(float(eq_y[-1] - 1), 4),
                               dd=round(float(np.max((pk_y - eq_y) / pk_y)), 4))
    n_cycles = settle_bars.sum()
    turnover_per_year = round(float(n_cycles / (span_days / 365.25)), 1)
    return dict(full=full, holdout=hold, yearly=yearly,
                time_in_market=round(float(n_cycles * roll_days_avg / n), 3)
                if False else round(float(settle_bars.sum() / n), 3),
                turnover_per_year=turnover_per_year)
 # Monkey-patch eval_straddle_series to not reference roll_days_avg
 def eval_straddle_series_v2(df, r_opt, fee_side=al.FEE_SIDE):
    idx = pd.DatetimeIndex(pd.to_datetime(df["datetime"], utc=True))
    n = len(r_opt)
    settle_bars = r_opt != 0
    option_tx_cost = np.where(settle_bars, 4 * fee_side, 0.0)
    r_net = r_opt - option_tx_cost
    eq = np.cumprod(1.0 + np.clip(r_net, -0.99, None))
    eq = np.concatenate([[1.0], eq])
    r_eq = np.diff(eq) / eq[:-1]
    r_eq = np.nan_to_num(r_eq)
    bpy = al.bars_per_year(df)
    rr = r_eq[np.isfinite(r_eq)]
    sharpe = float(np.mean(rr) / np.std(rr) * np.sqrt(bpy)) if np.std(rr) > 0 else 0.0
    pk = np.maximum.accumulate(eq[1:])
    dd = float(np.max((pk - eq[1:]) / pk)) if len(eq) > 1 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_ret = eq[-1] / eq[0] - 1
    cagr = (eq[-1] / eq[0]) ** (1 / years) - 1
    full = dict(sharpe=round(sharpe, 3), cagr=round(cagr, 4),
                maxdd=round(dd, 4), ret=round(total_ret, 4), n=int(n))
    hmask = idx >= al.HOLDOUT
    hold = dict(sharpe=0.0, ret=0.0, n=0)
    if hmask.sum() > 3:
        r_h = r_eq[hmask]
        hs = float(np.mean(r_h) / np.std(r_h) * np.sqrt(bpy)) if np.std(r_h) > 0 else 0.0
        eq_h = np.cumprod(1.0 + np.clip(r_h, -0.99, None))
        hold = dict(sharpe=round(hs, 3), ret=round(float(eq_h[-1] - 1), 4), n=int(hmask.sum()))
    s = pd.Series(r_eq, index=idx)
    yearly = {}
    for y, g in s.groupby(s.index.year):
        eq_y = np.cumprod(1 + g.values)
        pk_y = np.maximum.accumulate(eq_y)
        yearly[int(y)] = dict(ret=round(float(eq_y[-1] - 1), 4),
                               dd=round(float(np.max((pk_y - eq_y) / pk_y)), 4))
    n_cycles = int(settle_bars.sum())
    turnover_per_year = round(float(n_cycles / (span_days / 365.25)), 1)
    return dict(full=full, holdout=hold, yearly=yearly,
                time_in_market=round(float(settle_bars.sum() / n), 3),
                turnover_per_year=turnover_per_year)
 def run_straddle(roll_days: int, iv_rv_gate: float, tfs=("1d",)) -> dict:
    """Run the delta-hedged short straddle study. Returns report dict."""
    name = f"OPT05-Straddle-roll{roll_days}d-gate{iv_rv_gate:.2f}"
    cells = []
    for tf in tfs:
        per_asset = {}
        fee_ok_all = True
        for asset in al.CERTIFIED:
            df = al.get(asset, tf)
            # Base run
            r_opt = compute_straddle_series(df, asset, roll_days, iv_rv_gate)
            base = eval_straddle_series_v2(df, r_opt, fee_side=al.FEE_SIDE)
            # Fee sweep: only vary the option TX cost (spot hedge cost is fixed in the simulation)
            sweep = {}
            for f in al.FEE_SWEEP:
                res = eval_straddle_series_v2(df, r_opt, fee_side=f)
                sweep[f"{2*f*100:.2f}%RT"] = res["full"]["sharpe"]
            fee_ok = sweep.get("0.20%RT", -9) > 0
            fee_ok_all = fee_ok_all and fee_ok
            per_asset[asset] = 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 al.CERTIFIED)
        min_hold = min(per_asset[a]["holdout"].get("sharpe", 0.0) for a in al.CERTIFIED)
        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 al.CERTIFIED]), 3),
                          fee_survives=fee_ok_all))
    verdict = al._verdict(cells)
    return dict(name=name, kind="weights", cells=cells, verdict=verdict)
 if __name__ == "__main__":
    print("OPT05 — Delta-Hedged Short Straddle (IV-RV variance premium)")
    print("CAVEAT: MODELED on DVOL ATM. Skew & real stress f not captured.")
    print("DVOL starts 2021-03 → backtest from 2021-03 only.")
    print()
    # 4 configs, 1d TF only → 4 backtests
    CONFIGS = [
        (7, 1.10),    # weekly, gate IV/RV >= 1.10
        (7, 1.20),    # weekly, gate IV/RV >= 1.20
        (14, 1.10),   # biweekly, gate IV/RV >= 1.10
        (14, 1.20),   # biweekly, gate IV/RV >= 1.20
    ]
    best_rep = None
    best_score = -999.0
    for roll_days, iv_rv_gate in CONFIGS:
        print(f"--- roll_days={roll_days}, iv_rv_gate={iv_rv_gate} ---")
        rep = run_straddle(roll_days=roll_days, iv_rv_gate=iv_rv_gate, tfs=("1d",))
        print(al.fmt(rep))
        score = rep["verdict"].get("best_holdout_sharpe", -9)
        if score > best_score:
            best_score = score
            best_rep = rep
        print()
    print("=" * 60)
    print("BEST CONFIG:")
    print(al.fmt(best_rep))
    print()
    print("JSON:", al.as_json(best_rep))
@@ -1,358 +0,0 @@
 """OPT06 — Ratio Put Spread (Defensive Short-Vol with Tail Hedge)
 IDEA: Ratio put spread (1x2 put ratio) modeled on DVOL:
  - Sell 1 OTM put at strike K1 = S * exp(-delta1)  (e.g., -0.15 log-moneyness)
  - Buy  2 OTM puts at strike K2 = S * exp(-delta2)  (e.g., -0.30 log-moneyness)
  Net: collect premium from the short put, use proceeds to buy tail protection.
  This is a "defensive short-vol" structure:
    - Moderate down moves (to K2) → profitable (net premium + short put profit)
    - Crash moves (below K2) → protected (long 2 puts offset the short)
    - Up moves → lose net premium received (small cost)
  The ratio 1:2 means the structure has POSITIVE gamma below K2 (net long put delta
  when S < K2) — the tail hedge kicks in. Above K2 but below K1, it's short-gamma
  (collects theta). Above K1, it's short a single put (small risk).
 GATE: Only enter when DVOL >= gate threshold (elevated IV → richer premium).
      Also gated on DVOL/RV ratio (only sell vol when IV > RV).
 ROLL: Weekly (7d) or biweekly (14d).
 GRID: 4 configs:
  (short_moneyness=-0.10, long_moneyness=-0.25, gate_dvol=50)
  (short_moneyness=-0.10, long_moneyness=-0.25, gate_dvol=60)
  (short_moneyness=-0.15, long_moneyness=-0.30, gate_dvol=50)
  (short_moneyness=-0.15, long_moneyness=-0.30, gate_dvol=60)
  → 4 configs × 1d TF = 4 backtests (within <=6 limit)
 CAVEAT:
  - MODELED on DVOL (ATM). Real puts have skew (OTM puts cost more → less premium).
  - History starts 2021-03 (DVOL). Backtest from 2021-03 only.
  - Tail risk partially mitigated by the ratio structure, but skew model error matters.
  - Not for deployment without real options pricing data.
  - Lead-only / modeled.
 Style: study_weights (continuous modeled position via P&L series).
 """
 import sys
 sys.path.insert(0, "/opt/docker/PythagorasGoal/scripts/research/alt")
 import altlib as al
 import numpy as np
 import pandas as pd
 from scipy.stats import norm
 # ── Black-Scholes helpers ──────────────────────────────────────────────────
 def bs_put(S: float, K: float, T: float, sigma: float) -> float:
    """Black-Scholes put price (r=0, crypto/futures)."""
    if T <= 0 or sigma <= 0 or S <= 0 or K <= 0:
        return max(0.0, K - S)
    d1 = (np.log(S / K) + 0.5 * sigma**2 * T) / (sigma * np.sqrt(T))
    d2 = d1 - sigma * np.sqrt(T)
    return float(K * norm.cdf(-d2) - S * norm.cdf(-d1))
 def bs_put_delta(S: float, K: float, T: float, sigma: float) -> float:
    """Black-Scholes put delta (negative)."""
    if T <= 0 or sigma <= 0 or S <= 0 or K <= 0:
        return -1.0 if S < K else 0.0
    d1 = (np.log(S / K) + 0.5 * sigma**2 * T) / (sigma * np.sqrt(T))
    return float(norm.cdf(d1) - 1.0)
 def ratio_spread_value(S: float, K1: float, K2: float, T: float, sigma: float) -> float:
    """Value of short 1 put(K1) + long 2 puts(K2). Positive = we received cash."""
    # Short 1 put at K1 (we receive premium = +put_K1)
    # Long 2 puts at K2  (we pay premium   = -2*put_K2)
    # Net received = put(K1) - 2*put(K2)
    p1 = bs_put(S, K1, T, sigma)
    p2 = bs_put(S, K2, T, sigma)
    return p1 - 2.0 * p2
 def ratio_spread_delta(S: float, K1: float, K2: float, T: float, sigma: float) -> float:
    """Net delta of position: short 1 put(K1) + long 2 puts(K2)."""
    d1 = bs_put_delta(S, K1, T, sigma)
    d2 = bs_put_delta(S, K2, T, sigma)
    return -d1 + 2.0 * d2
 def ratio_spread_payoff(S_exp: float, K1: float, K2: float) -> float:
    """Payoff at expiry of short 1 put(K1) + long 2 puts(K2) (as fraction of S0)."""
    payoff_short = -max(0.0, K1 - S_exp)
    payoff_long = 2.0 * max(0.0, K2 - S_exp)
    return payoff_short + payoff_long
 def simulate_ratio_spread_cycle(
    close: np.ndarray,
    sigma_iv: np.ndarray,
    i0: int,
    roll_bars: int,
    short_moneyness: float,   # log-moneyness of short put (e.g., -0.10 → 10% OTM)
    long_moneyness: float,    # log-moneyness of long puts (e.g., -0.25 → 25% OTM)
    fee_side: float = 0.001   # 0.10% per leg per side (options spread)
 ) -> tuple[float, int]:
    """
    Simulate one ratio put spread cycle.
    At entry i0:
      - K1 = S0 * exp(short_moneyness)  [e.g., S0 * exp(-0.10) ≈ S0 * 0.905]
      - K2 = S0 * exp(long_moneyness)   [e.g., S0 * exp(-0.25) ≈ S0 * 0.779]
      - Sell 1 put at K1, buy 2 puts at K2
      - Net premium received = put(K1) - 2*put(K2) [in $]
    At expiry i_exp:
      - P&L = net_premium_received + payoff_at_expiry - transaction_costs
    P&L per unit of notional S0 (fraction of S0):
      net_pnl = (p1_entry - 2*p2_entry)/S0
                + payoff(S_exp, K1, K2)/S0
                - (3 legs * 2 sides * fee_side)   [3 legs: 1 short + 2 long → 3 contracts]
    """
    n = len(close)
    S0 = close[i0]
    T = roll_bars / 365.25
    sig = sigma_iv[i0]
    if not (np.isfinite(sig) and sig > 0.02):
        return 0.0, min(i0 + roll_bars, n - 1)
    K1 = S0 * np.exp(short_moneyness)   # short put (less OTM)
    K2 = S0 * np.exp(long_moneyness)    # long puts (more OTM)
    # Net premium received at entry
    p1 = bs_put(S0, K1, T, sig)
    p2 = bs_put(S0, K2, T, sig)
    net_prem = p1 - 2.0 * p2  # positive → we received net premium
    i_exp = min(i0 + roll_bars, n - 1)
    S_exp = close[i_exp]
    # Payoff at expiry (from position payoff)
    payoff = ratio_spread_payoff(S_exp, K1, K2)
    # Transaction costs: 3 contracts (1 short + 2 long), entry + exit = 2 sides each
    # fee_side applies per contract per side
    tx_cost = 3 * 2 * fee_side * S0  # in $ terms
    net_pnl_dollar = net_prem + payoff - tx_cost
    net_pnl_frac = net_pnl_dollar / S0
    return float(net_pnl_frac), i_exp
 def compute_ratio_spread_series(
    df: pd.DataFrame,
    asset: str,
    roll_days: int,
    short_moneyness: float,
    long_moneyness: float,
    gate_dvol: float,         # minimum DVOL level to enter (vol points, e.g., 50)
    iv_rv_gate: float = 1.05, # minimum IV/RV ratio to enter
    rv_win_days: int = 20,
    fee_side: float = 0.001
 ) -> np.ndarray:
    """
    Simulate the full ratio put spread strategy.
    Returns per-bar P&L as fraction of equity (additive).
    Flat when not in a cycle or gate not met.
    """
    close = df["close"].values.astype(float)
    n = len(close)
    sigma_iv = al.dvol(df, asset) / 100.0  # convert vol points → decimal
    log_r = al.log_returns(close)
    bpy = al.bars_per_year(df)
    rv_win = max(5, rv_win_days)
    rv_ann = pd.Series(log_r).rolling(rv_win, min_periods=max(2, rv_win // 2)).std().values * np.sqrt(bpy)
    # Find first bar with valid DVOL
    first_valid = np.where(np.isfinite(sigma_iv) & (sigma_iv > 0.02))[0]
    if len(first_valid) == 0:
        return np.zeros(n)
    start_bar = int(first_valid[0]) + rv_win  # also need RV to warm up
    r_opt = np.zeros(n)
    i = start_bar
    while i < n - 1:
        sig_iv = sigma_iv[i]
        sig_rv = rv_ann[i]
        dvol_pts = sig_iv * 100.0  # back to vol points for gate
        # Entry conditions:
        # 1. Valid DVOL
        # 2. DVOL >= gate_dvol (vol is elevated → richer premium)
        # 3. IV/RV >= iv_rv_gate (selling vol when IV > RV)
        if (np.isfinite(sig_iv) and sig_iv > 0.02 and
                np.isfinite(sig_rv) and sig_rv > 0.02 and
                dvol_pts >= gate_dvol and
                sig_iv / sig_rv >= iv_rv_gate):
            net_pnl, i_exp = simulate_ratio_spread_cycle(
                close, sigma_iv, i, roll_days,
                short_moneyness=short_moneyness,
                long_moneyness=long_moneyness,
                fee_side=fee_side
            )
            r_opt[i_exp] = net_pnl
            i = i_exp + 1
        else:
            i += 1
    return r_opt
 def eval_ratio_spread(df: pd.DataFrame, r_opt: np.ndarray) -> dict:
    """Evaluate ratio put spread P&L series into standard metrics."""
    idx = pd.DatetimeIndex(pd.to_datetime(df["datetime"], utc=True))
    n = len(r_opt)
    # The transaction costs are already inside simulate_ratio_spread_cycle.
    # Just compound the net P&L.
    r_net = r_opt.copy()
    eq = np.cumprod(1.0 + np.clip(r_net, -0.99, None))
    eq = np.concatenate([[1.0], eq])
    r_eq = np.diff(eq) / eq[:-1]
    r_eq = np.nan_to_num(r_eq)
    bpy = al.bars_per_year(df)
    rr = r_eq[np.isfinite(r_eq)]
    sharpe = float(np.mean(rr) / np.std(rr) * np.sqrt(bpy)) if np.std(rr) > 0 else 0.0
    pk = np.maximum.accumulate(eq[1:])
    dd = float(np.max((pk - eq[1:]) / pk)) if len(eq) > 1 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_ret = eq[-1] / eq[0] - 1
    cagr = (eq[-1] / eq[0]) ** (1 / years) - 1
    full = dict(sharpe=round(sharpe, 3), cagr=round(cagr, 4),
                maxdd=round(dd, 4), ret=round(total_ret, 4), n=int(n))
    hmask = idx >= al.HOLDOUT
    hold = dict(sharpe=0.0, ret=0.0, n=0)
    if hmask.sum() > 3:
        r_h = r_eq[hmask]
        hs = float(np.mean(r_h) / np.std(r_h) * np.sqrt(bpy)) if np.std(r_h) > 0 else 0.0
        eq_h = np.cumprod(1.0 + np.clip(r_h, -0.99, None))
        hold = dict(sharpe=round(hs, 3), ret=round(float(eq_h[-1] - 1), 4), n=int(hmask.sum()))
    s = pd.Series(r_eq, index=idx)
    yearly = {}
    for y, g in s.groupby(s.index.year):
        eq_y = np.cumprod(1 + g.values)
        pk_y = np.maximum.accumulate(eq_y)
        yearly[int(y)] = dict(ret=round(float(eq_y[-1] - 1), 4),
                               dd=round(float(np.max((pk_y - eq_y) / pk_y)), 4))
    settle_bars = (r_opt != 0).sum()
    turnover_per_year = round(float(settle_bars / (span_days / 365.25)), 1)
    return dict(full=full, holdout=hold, yearly=yearly,
                time_in_market=round(float(settle_bars / n), 3),
                turnover_per_year=turnover_per_year)
 def run_ratio_spread(
    short_moneyness: float,
    long_moneyness: float,
    gate_dvol: float,
    roll_days: int = 7,
    tfs=("1d",)
 ) -> dict:
    """Run ratio put spread study for one parameter config."""
    name = (f"OPT06-RatioPutSpread-short{abs(short_moneyness)*100:.0f}pct"
            f"-long{abs(long_moneyness)*100:.0f}pct-dvol{gate_dvol:.0f}")
    cells = []
    for tf in tfs:
        per_asset = {}
        fee_ok_all = True
        for asset in al.CERTIFIED:
            df = al.get(asset, tf)
            r_opt = compute_ratio_spread_series(
                df, asset,
                roll_days=roll_days,
                short_moneyness=short_moneyness,
                long_moneyness=long_moneyness,
                gate_dvol=gate_dvol
            )
            base = eval_ratio_spread(df, r_opt)
            # Fee sweep: scale the option tx cost
            # Base fee_side=0.001; sweep by adjusting the per-cycle cost
            sweep = {}
            for f_side in al.FEE_SWEEP:
                r_sweep = compute_ratio_spread_series(
                    df, asset,
                    roll_days=roll_days,
                    short_moneyness=short_moneyness,
                    long_moneyness=long_moneyness,
                    gate_dvol=gate_dvol,
                    fee_side=f_side
                )
                sw = eval_ratio_spread(df, r_sweep)
                # Key: 0.20%RT = 0.0010/side = what we label
                sweep[f"{2*f_side*100:.2f}%RT"] = sw["full"]["sharpe"]
            fee_ok = sweep.get("0.20%RT", -9) > 0
            fee_ok_all = fee_ok_all and fee_ok
            per_asset[asset] = 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 al.CERTIFIED)
        min_hold = min(per_asset[a]["holdout"].get("sharpe", 0.0) for a in al.CERTIFIED)
        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 al.CERTIFIED]), 3),
                          fee_survives=fee_ok_all))
    verdict = al._verdict(cells)
    return dict(name=name, kind="weights", cells=cells, verdict=verdict)
 if __name__ == "__main__":
    print("OPT06 — Ratio Put Spread (Defensive Short-Vol with Tail Hedge)")
    print("CAVEAT: MODELED on DVOL ATM. Skew not modeled → OTM puts underpriced in model.")
    print("DVOL starts 2021-03 → backtest from 2021-03 only.")
    print("Lead-only / modeled. Not for deployment.")
    print()
    # Grid: 4 configs
    # (short_moneyness, long_moneyness, gate_dvol)
    CONFIGS = [
        (-0.10, -0.25, 50.0),   # 10%/25% OTM, gate DVOL>=50
        (-0.10, -0.25, 60.0),   # 10%/25% OTM, gate DVOL>=60
        (-0.15, -0.30, 50.0),   # 15%/30% OTM, gate DVOL>=50
        (-0.15, -0.30, 60.0),   # 15%/30% OTM, gate DVOL>=60
    ]
    best_rep = None
    best_score = -999.0
    for short_m, long_m, gate_d in CONFIGS:
        print(f"--- short={short_m*100:.0f}%, long={long_m*100:.0f}%, gate_dvol={gate_d} ---")
        rep = run_ratio_spread(
            short_moneyness=short_m,
            long_moneyness=long_m,
            gate_dvol=gate_d,
            roll_days=7,
            tfs=("1d",)
        )
        print(al.fmt(rep))
        score = rep["verdict"].get("best_holdout_sharpe", -9)
        if score > best_score:
            best_score = score
            best_rep = rep
        print()
    print("=" * 60)
    print("BEST CONFIG:")
    print(al.fmt(best_rep))
    print()
    print("JSON:", al.as_json(best_rep))
@@ -1,291 +0,0 @@
 """OPT07 — Collar Overlay
 IDEA: Long spot + buy protective put + sell covered call (zero-ish cost collar).
  - Long 1 unit spot BTC/ETH
  - Sell OTM call at strike K_call = S * exp(+call_otm * sigma * sqrt(T))
  - Buy OTM put at strike K_put  = S * exp(-put_otm * sigma * sqrt(T))
  Net premium ≈ call premium received - put premium paid (can be near-zero or small debit/credit
  depending on the strikes chosen).
 Goal: reduce drawdown vs buy&hold by capping upside (call) and flooring downside (put).
      Does this improve risk-adjusted return (Sharpe)?
 Hypothesis: the vol risk premium means we receive more on the call than we pay for the put
 (IV > RV historically), so the collar should produce a positive carry vs buying naked insurance.
 In a crash the put activates and limits losses. Net effect should be improved Sharpe.
 MODELED: premiums computed via Black-Scholes with DVOL as IV (no skew, no slippage on options).
 DVOL history starts 2021-03 -> backtest from 2021-03 only.
 CAVEAT: modeled, lead-only.
 Grid (4 configs, 1 TF = 4 study_weights calls -> <=8 total backtests):
  1. Symmetric collar: call OTM=0.10, put OTM=0.10 (weekly)
  2. Tighter collar:   call OTM=0.05, put OTM=0.05 (weekly)
  3. Asymmetric:       call OTM=0.05, put OTM=0.10 (debit collar, more protection, less upside cap)
  4. Asymmetric:       call OTM=0.10, put OTM=0.05 (credit collar, less protection, more upside cap)
 Style: study_weights (continuous position ~1x long + option overlay adjustments at settlement).
 """
 import sys
 sys.path.insert(0, "/opt/docker/PythagorasGoal/scripts/research/alt")
 import altlib as al
 import numpy as np
 import pandas as pd
 from scipy.stats import norm
 # ── Black-Scholes call and put prices ────────────────────────────────────────
 def bs_call(S: float, K: float, T: float, sigma: float, r: float = 0.0) -> float:
    """Black-Scholes call price. T in years. sigma annualized."""
    if T <= 0 or sigma <= 0 or S <= 0 or K <= 0:
        return 0.0
    d1 = (np.log(S / K) + (r + 0.5 * sigma**2) * T) / (sigma * np.sqrt(T))
    d2 = d1 - sigma * np.sqrt(T)
    return float(S * norm.cdf(d1) - K * np.exp(-r * T) * norm.cdf(d2))
 def bs_put(S: float, K: float, T: float, sigma: float, r: float = 0.0) -> float:
    """Black-Scholes put price via put-call parity."""
    c = bs_call(S, K, T, sigma, r)
    return float(c - S + K * np.exp(-r * T))
 # ── Collar P&L per settlement cycle ──────────────────────────────────────────
 def collar_cycle_return(S_start: float, S_end: float,
                        K_call: float, K_put: float,
                        call_prem: float, put_cost: float) -> float:
    """
    Compute the net return of a collar for one option cycle.
    At initiation:
      - Receive call_prem (sell call)
      - Pay put_cost (buy put)
      Net option carry = call_prem - put_cost (per unit of spot, as fraction of S_start)
    At settlement:
      Spot P&L: S_end / S_start - 1
      Call settled: -max(0, S_end - K_call) / S_start   (we're short call)
      Put settled: +max(0, K_put - S_end) / S_start      (we're long put)
    Total: (S_end/S_start - 1)
           - max(0, S_end - K_call) / S_start
           + max(0, K_put - S_end) / S_start
           + (call_prem - put_cost) / S_start
    Which simplifies to the textbook collar:
      If S_end >= K_call: net = (K_call/S_start - 1) + carry   (upside capped)
      If S_end <= K_put:  net = (K_put/S_start - 1) + carry    (downside floored)
      Otherwise:          net = (S_end/S_start - 1) + carry
    """
    carry = (call_prem - put_cost) / S_start  # net option premium (positive = net credit)
    if S_end >= K_call:
        return (K_call / S_start - 1.0) + carry
    elif S_end <= K_put:
        return (K_put / S_start - 1.0) + carry
    else:
        return (S_end / S_start - 1.0) + carry
 # ── Build collar target array ─────────────────────────────────────────────────
 def build_collar_target(close: np.ndarray, sigma_ann: np.ndarray,
                        call_otm: float, put_otm: float,
                        roll_bars: int, T_years: float) -> np.ndarray:
    """
    Build a synthetic 'effective position' array for the collar strategy.
    At each bar i, target[i] is held during bar i+1.
    On settlement bars: effective position encodes the full cycle's collar P&L.
    On non-settlement bars (mid-cycle): position = 1.0 (pure spot, no adjustment yet).
    Settlement bar technique (same as OPT01):
      target[i-1] * r_spot[i] ≈ cc_return for the cycle
      For multi-bar cycles: option_adj = collar_r - cycle_spot_r is applied at settlement.
    """
    n = len(close)
    target = np.ones(n)  # default: long spot
    # Find first bar with valid DVOL
    first_valid = np.where(np.isfinite(sigma_ann) & (sigma_ann > 0))[0]
    if len(first_valid) == 0:
        return target
    start_bar = int(first_valid[0])
    r_spot = al.simple_returns(close)
    # Initialize first collar at start_bar
    S0 = close[start_bar]
    sig0 = sigma_ann[start_bar]
    option_K_call = None
    option_K_put = None
    call_prem = 0.0
    put_cost = 0.0
    cycle_start_bar = start_bar
    cycle_start_price = S0
    if sig0 > 0 and np.isfinite(sig0):
        K_call = S0 * np.exp(call_otm * sig0 * np.sqrt(T_years))
        K_put  = S0 * np.exp(-put_otm * sig0 * np.sqrt(T_years))
        option_K_call = K_call
        option_K_put  = K_put
        call_prem = bs_call(S0, K_call, T_years, sig0)
        put_cost  = bs_put(S0, K_put,  T_years, sig0)
    for i in range(start_bar + 1, n):
        bars_in_cycle = i - cycle_start_bar
        if option_K_call is None or option_K_put is None:
            # No active collar -> pure spot
            target[i - 1] = 1.0
            # Try to re-initialize
            sig_i = sigma_ann[i]
            if np.isfinite(sig_i) and sig_i > 0:
                S_i = close[i]
                K_call = S_i * np.exp(call_otm * sig_i * np.sqrt(T_years))
                K_put  = S_i * np.exp(-put_otm * sig_i * np.sqrt(T_years))
                option_K_call = K_call
                option_K_put  = K_put
                call_prem = bs_call(S_i, K_call, T_years, sig_i)
                put_cost  = bs_put(S_i, K_put,  T_years, sig_i)
                cycle_start_bar = i
                cycle_start_price = S_i
            continue
        if bars_in_cycle >= roll_bars:
            # Settlement bar: compute collar payoff for the full cycle
            S_end   = close[i]
            S_start = cycle_start_price
            collar_r = collar_cycle_return(
                S_start, S_end,
                option_K_call, option_K_put,
                call_prem, put_cost
            )
            cycle_spot_r = S_end / S_start - 1.0
            # Encode the option adjustment on the settlement bar
            r_i = r_spot[i]
            option_adj = collar_r - cycle_spot_r  # premium carry ± cap/floor adjustments
            if abs(r_i) > 1e-10:
                target[i - 1] = 1.0 + option_adj / r_i
            else:
                # r_spot[i] ≈ 0: no spot movement on settlement bar -> just carry position=1
                # (option_adj can't be embedded cleanly, but it's typically small)
                target[i - 1] = 1.0
            # Roll new collar
            sig_new = sigma_ann[i]
            if np.isfinite(sig_new) and sig_new > 0:
                K_call_new = S_end * np.exp(call_otm * sig_new * np.sqrt(T_years))
                K_put_new  = S_end * np.exp(-put_otm * sig_new * np.sqrt(T_years))
                option_K_call = K_call_new
                option_K_put  = K_put_new
                call_prem = bs_call(S_end, K_call_new, T_years, sig_new)
                put_cost  = bs_put(S_end, K_put_new,  T_years, sig_new)
            else:
                option_K_call = None
                option_K_put  = None
                call_prem = 0.0
                put_cost  = 0.0
            cycle_start_bar = i
            cycle_start_price = S_end
        else:
            # Mid-cycle: hold spot (position=1, no adjustment)
            target[i - 1] = 1.0
    target = np.nan_to_num(target, nan=1.0)
    # Clip extreme values (guard against division artifacts when r_spot ≈ 0)
    target = np.clip(target, -5.0, 5.0)
    return target
 # ── Per-asset runner (wraps study_weights) ────────────────────────────────────
 def run_collar(call_otm: float, put_otm: float, roll_days: int = 7,
               tfs: tuple = ("1d",)) -> dict:
    """Run collar study for one config. Returns report dict."""
    name = f"OPT07-COLLAR-C{int(call_otm*100)}P{int(put_otm*100)}-roll{roll_days}d"
    T_years = roll_days / 365.25
    cells = []
    for tf in tfs:
        per_asset = {}
        fee_ok_all = True
        for asset in al.CERTIFIED:
            df = al.get(asset, tf)
            sigma_ann = al.dvol(df, asset) / 100.0
            roll_bars = roll_days  # 1d tf: 1 bar = 1 day
            tgt = build_collar_target(
                df["close"].values.astype(float),
                sigma_ann,
                call_otm=call_otm,
                put_otm=put_otm,
                roll_bars=roll_bars,
                T_years=T_years
            )
            base = al.eval_weights(df, tgt, fee_side=al.FEE_SIDE)
            sweep = {
                f"{2*f*100:.2f}%RT": al.eval_weights(df, tgt, fee_side=f)["full"]["sharpe"]
                for f in al.FEE_SWEEP
            }
            fee_ok = sweep.get("0.20%RT", -9) > 0
            fee_ok_all = fee_ok_all and fee_ok
            per_asset[asset] = 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 al.CERTIFIED)
        min_hold = min(per_asset[a]["holdout"].get("sharpe", 0.0) for a in al.CERTIFIED)
        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(float(np.mean([per_asset[a]["full"]["sharpe"] for a in al.CERTIFIED])), 3),
            fee_survives=fee_ok_all
        ))
    verdict = al._verdict(cells)
    return dict(name=name, kind="weights", cells=cells, verdict=verdict)
 # ── Main: small grid ──────────────────────────────────────────────────────────
 if __name__ == "__main__":
    # Grid: 4 configs x 1 TF = 4 study calls = 8 total asset backtests (fine for 2 CPUs)
    CONFIGS = [
        # (call_otm, put_otm, roll_days, description)
        (0.10, 0.10, 7,  "symmetric 10%/10% weekly"),
        (0.05, 0.05, 7,  "tight 5%/5% weekly"),
        (0.05, 0.10, 7,  "debit collar: call 5% / put 10% -> more downside protection"),
        (0.10, 0.05, 7,  "credit collar: call 10% / put 5% -> less protection, net credit"),
    ]
    print("OPT07 Collar Overlay — MODELED on DVOL (lead-only, from 2021-03)")
    print("Long spot + sell OTM call + buy OTM put (zero-ish cost collar)")
    print()
    best_rep = None
    best_score = -999.0
    for call_otm, put_otm, roll_days, desc in CONFIGS:
        print(f"--- {desc} (call_otm={call_otm}, put_otm={put_otm}, roll={roll_days}d) ---")
        rep = run_collar(call_otm=call_otm, put_otm=put_otm, roll_days=roll_days, tfs=("1d",))
        print(al.fmt(rep))
        score = rep["verdict"].get("best_holdout_sharpe", -9)
        if score > best_score:
            best_score = score
            best_rep = rep
        print()
    print("=" * 60)
    print("BEST CONFIG:")
    print(al.fmt(best_rep))
    print()
    print("JSON:", al.as_json(best_rep))
@@ -1,127 +0,0 @@
 """OPT08 — Risk-reversal directional via DVOL-change skew proxy.
 HYPOTHESIS: The 25-delta risk reversal sign can be proxied from DVOL changes.
 When DVOL rises sharply relative to recent history (puts bid up = skew bullish for
 downside fear = bearish tilt) we go short; when DVOL falls (fear subsides / calls
 catching up relative = bullish tilt) we go long. We also test the opposite sign to
 be honest about direction. We use DVOL z-score over rolling windows as the signal.
 CAVEAT: This is a heavy proxy — DVOL is the ATM vol index, not skew. The actual
 25d risk reversal is not in the data. Results should be treated as suggestive only.
 DVOL history: starts 2021-03, so ~4 years of data. FULL window covers 2021-2026.
 """
 import sys
 sys.path.insert(0, "/opt/docker/PythagorasGoal/scripts/research/alt")
 import altlib as al
 import numpy as np
 # ── Signal construction ──────────────────────────────────────────────────────
 # Proxy: if DVOL z-score is high (fear spike) -> bearish; if low (complacency) -> bullish
 # This is the "risk-reversal as directional tilt" interpretation:
 #   put skew expensive (DVOL spike) = hedgers worried -> fade / go short or stay flat
 #   put skew cheap (DVOL low)       = complacency    -> go long
 #
 # We test 4 configurations:
 #   A) zscore_win=20d, signal sign = bearish_on_dvol_spike (negative z -> long)
 #   B) zscore_win=60d, signal sign = bearish_on_dvol_spike
 #   C) zscore_win=20d, signal sign = bullish_on_dvol_spike (positive z -> long, contrarian)
 #   D) zscore_win=60d, signal sign = bullish_on_dvol_spike
 #
 # After picking best config from 1d, we finalize.
 def make_target(df, asset: str, zscore_win_days: int, dvol_spike_bearish: bool,
                vol_target_enabled: bool = True):
    """
    Build a continuous position in [-lev, +lev] based on DVOL z-score.
    dvol_spike_bearish=True:  high DVOL z -> short (fear = downside risk real)
    dvol_spike_bearish=False: high DVOL z -> long  (contrarian, mean-reversion of fear)
    """
    dv = al.dvol(df, asset)  # float array len(df), NaN before 2021-03
    bpd = al.bars_per_day(df)
    win = max(5, zscore_win_days * bpd)
    # z-score of DVOL level over rolling window (causal)
    z = al.zscore(dv, win)
    # Raw direction: clip z to [-2, 2] and normalize to [-1, 1]
    z_clip = np.clip(z, -2.0, 2.0) / 2.0
    if dvol_spike_bearish:
        # high DVOL (z>0) -> bearish (negative position)
        direction = -z_clip
    else:
        # high DVOL (z>0) -> bullish (contrarian: fear is overdone, buy the dip)
        direction = z_clip
    # Zero out where DVOL is NaN (pre-history)
    direction[~np.isfinite(dv)] = 0.0
    direction[~np.isfinite(direction)] = 0.0
    if vol_target_enabled:
        pos = al.vol_target(direction, df, target_vol=0.20, vol_win_days=30, leverage_cap=2.0)
    else:
        pos = np.clip(direction, -1.0, 1.0)
    return pos
 # ── Grid: 4 configs ──────────────────────────────────────────────────────────
 configs = [
    dict(zscore_win_days=20, dvol_spike_bearish=True,  label="z20-bearish"),
    dict(zscore_win_days=60, dvol_spike_bearish=True,  label="z60-bearish"),
    dict(zscore_win_days=20, dvol_spike_bearish=False, label="z20-bullish"),
    dict(zscore_win_days=60, dvol_spike_bearish=False, label="z60-bullish"),
 ]
 # ── Run on 1d only (DVOL is daily, so sub-daily adds no signal) ─────────────
 print("Running OPT08 — Risk-reversal directional (DVOL z-score proxy)")
 print("DVOL history starts 2021-03; effective backtest window 2021-2026")
 print()
 best_rep = None
 best_score = -999.0
 for cfg in configs:
    lbl = cfg["label"]
    win = cfg["zscore_win_days"]
    bearish = cfg["dvol_spike_bearish"]
    def target_fn(df, _win=win, _bearish=bearish):
        # detect asset from the DVOL data shape
        # We must detect which asset this df belongs to; use a closure trick:
        # try BTC first, if raises try ETH -- but study_weights iterates per asset
        # so we need a per-asset function. We handle this in a wrapper below.
        return make_target(df, "BTC", _win, _bearish)
    # We need per-asset targets, so wrap differently
    def make_target_fn(win_, bearish_):
        def fn(df):
            # Detect asset: try BTC DVOL alignment and check if it matches
            # Actually altlib study_weights passes df already for each asset;
            # we don't know which asset from df alone. Use a heuristic:
            # check price range (BTC >> ETH)
            c = df["close"].values
            med_price = float(np.nanmedian(c))
            asset = "BTC" if med_price > 5000 else "ETH"
            return make_target(df, asset, win_, bearish_)
        return fn
    tf_fn = make_target_fn(win, bearish)
    rep = al.study_weights(f"OPT08-{lbl}", tf_fn, tfs=("1d",))
    best_cell = rep["cells"][0]
    score = best_cell["min_asset_holdout_sharpe"]
    print(f"Config {lbl}: minFull={best_cell['min_asset_full_sharpe']:+.2f}  "
          f"minHold={best_cell['min_asset_holdout_sharpe']:+.2f}  "
          f"feeOK={best_cell['fee_survives']}")
    if score > best_score:
        best_score = score
        best_rep = rep
        best_cfg = cfg
 print()
 print(f"Best config: {best_cfg['label']}")
 print(al.fmt(best_rep))
 print("JSON:", al.as_json(best_rep))
--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
Adriano	8292e5e6b8	docs: verify cerbero-bite MCP is MAINNET (real option chain) -> VRP source unlocked - 3-level check: spot matches certified feed (<0.3%); environment_info=mainnet/testnet=false; chain-level decisive: ETH_USDC-26JUN26-1650-P identical bid/ask/IV/delta on ccxt mainnet vs Cerbero MCP (25.6/26.6/54.54%/-0.315) - contamination was the OLD testnet token on get_historical, NOT Cerbero MCP itself - Cerbero MCP gives real per-strike bid/ask/IV/greeks/OI + regime features ccxt lacks (dealer gamma, gamma-flip, OI delta, liquidation, funding) -> usable for VRP validation - no deep chain history -> multi-year VRP still model-priced, but model-vs-real calibration now robust/repeatable. Token used only for verification, never logged/committed.	2026-06-19 22:11:14 +02:00
Adriano	922947d2aa	research: verify options sleeve on REAL Deribit quotes (spread+skew haircut) - options_real_quote_check.py: fetches real weekly BTC put chain, measures premium haircut (bid vs BS@DVOL-ATM), re-runs CSP sleeve with real haircut - KEY FINDING (reverses a prior critique): backtest UNDER-prices the OTM put by using ATM DVOL; real skew (+28% gross) exceeds the ~4% bid/ask spread -> real bid premium = 1.29x modeled. Sleeve premium is conservative at current (calm) quotes. - Real risk SHIFTS to the tail + roll-liquidity in stress (skew = market pricing fat tail), not premium magnitude. Breakpoint: sleeve dies below ~70% premium capture. - updated eval diary with the verification	2026-06-19 21:48:12 +02:00
Adriano	69be9eb75f	docs: critical eval of external crypto_backtest strategy (trend + options VRP) - spot sleeve independently confirms our TP01 (12h vol-targeted trend); our multi-horizon blend is slightly better (Sharpe 1.32 vs their 0.77 window / 1.07 full) - options sleeve (75% weight) = the most promising lead to break the ~1.3 Sharpe ceiling (adds VRP, a different return source) BUT priced on modeled IV (DVOL+BS, no real bid/ask, ATM vol on OTM puts ignoring skew, tail under-modeled, leverage no funding, window bias) -> headline blend Sharpe 1.21 must be discounted until validated on real option quotes - next steps: real Deribit quotes/skew, crash-week stress, testnet paper trading	2026-06-19 21:43:08 +02:00
Adriano	58fc10de77	research tracks H+I: volume/vol/range + alt-momentum/reversal (both NEGATIVE for alpha) - trackH volume_vol: no uncorrelated additive edge; profitable signals are trend-in-disguise (corr 0.6-0.75); MR/declining-volume fade dead even at fee 0; OBV-up filter is a defensive DD overlay only (13.3->10.1% DD but -CAGR), not new alpha - trackI momentum/reversal: no formulation beats 1-3-6m sign-blend OOS on both assets; z-score continuous momentum = same edge (corr 0.96), lower DD 8.4% but lower CAGR; long-horizon reversal not bankable (negative/flat standalone). ~1.3 Sharpe ceiling holds. - TP01 (12h sign-blend) remains the deployable winner	2026-06-19 21:22:49 +02:00
Adriano	eac2aa1d00	audit+fix: anti-look-ahead audit, migrate deployable config to >=12h - trackD_lookahead_audit.py: relabel test (left==right, no labeling leak) + execution-lag stress -> our trend pipeline is CLEAN (4h Sharpe 1.36 robust to +1 bar lag, label-invariant) - ADOPT conservative conclusion: deploy at 12h (sub-12h: costs/overfit dominate, slight Sharpe bump unreliable). 12h: Sharpe 1.32, DD 13.3%, CAGR 16.2% ~ identical and robust - trend_portfolio: DEPLOY_TF=12h, resample_tf(rule); paper trader + tests on 12h - calendar research (NEGATIVE, both): trackF seasonality (spurious), trackG prior-levels (breakouts continue, fade dead; only long-drift survivor, redundant with TP01) - gitignore data/paper_trend runtime state	2026-06-19 21:13:57 +02:00
Adriano	7b34e11476	docs: update CLAUDE.md with post-research state (TP01 winner + research outcome)	2026-06-19 20:36:01 +02:00
Adriano	ae7f3d17f2	deploy: TP01 trend portfolio (PORT LF4h) module + paper trader - src/strategies/trend_portfolio.py: canonical winner, causal/no-leakage, reproduces CAGR +16.5% Sharpe 1.36 maxDD 13.8% - scripts/live/paper_trend.py: forward-only paper trader, persistent state, resume - tests/test_trend_portfolio.py: 5 tests (causality, profitability, long-only, paper parity)	2026-06-19 20:35:28 +02:00
Adriano	3b6ff02197	fix: resolution-safe timestamp in trackD_timing resample (pandas 2.x datetime64[ms]) - combination study: PORT LF4h (BTC+ETH) Sharpe 1.32 DD 12.3% remains best - RV ETH/BTC market-neutral sleeve is genuinely uncorrelated (~0.05) but too weak (Sharpe 0.27) to raise portfolio Sharpe; combining the two TF configs is redundant (same-asset cross-config corr 0.80)	2026-06-19 20:18:03 +02:00
Adriano	8dbdadd509	research: add per-year trade counts + turnover to trackD_timing	2026-06-19 20:09:32 +02:00
Adriano	33267584d9	research: Track D winner across timeframes (15m-1d) + per-year PnL/DD - trackD_timing.py: same TSMOM 1-3-6m blend config sampled at 15m/1h/4h/1d - robust plateau across all TFs; 4h marginally best (LF Sharpe 1.36, DD 13.8%) - per-year PnL and per-year max drawdown tables	2026-06-19 19:39:02 +02:00
Adriano	dc2b5697da	research wave 1: 5 honest tracks on certified BTC/ETH + synthesis - trackA trend, trackB ML, trackC mean-rev, trackD trend-portfolio, trackE xsec/ensemble - VERDICT: Track D vol-targeted BTC+ETH trend portfolio is the one robust deployable earner (Sharpe 1.0-1.32, DD 13-19%, positive every year 2019-2026) - mean-reversion confirmed dead on clean data; weak-but-real ML/trend residuals - honest: EUR50/day on 2000 in 1-2y is not reachable (needs ~137k capital or ruinous DD)	2026-06-19 19:14:53 +02:00
Adriano	6b9c469832	research: rebuild certified BTC/ETH feed + honest backtest harness - rebuilt BTC/ETH from Deribit mainnet (certified 1.7-1.9bps vs Coinbase) - archived contaminated alt data to Old/data/raw - add src/backtest/harness.py: leakage-free, fee-aware signal engine (entry at close[i], intrabar TP/SL, CAGR/Sharpe/DD/per-year/OOS)	2026-06-19 18:41:15 +02:00