feat(dashboard): Deribit-only book panel (TP01+SKH01) + accumulation forecast

New section showing the executable Deribit-only book (TP01 75% + SKH01 25%): combined
FULL/HOLD Sharpe+DD, plus the reinvest-winnings accumulation projection (historical &
conservative CAGR, €5k→5y/10y, conservative €/day run-rate). Reuses the already-computed
sleeve daily series (no extra heavy compute). Honest caveats (bull sample, no leverage,
SKH01 not live, ~€177k for €50/day).

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

scripts/portfolio/forecast_deribit_book.py

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

scripts/portfolio/run_deribit_book.py

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

src/live/dashboard.py

@@ -32,6 +32,21 @@ def build():
     pf = StrategyPortfolio(active_sleeves(), capital=2000.0)
     bt = pf.backtest()
     eq = bt["equity"]; idx = bt["index"]
+    # BOOK DERIBIT-ONLY eseguibile (TP01 75% + SKH01 25%), riusando i daily gia' calcolati
+    try:
+        sl_by = {s.name: s for s in pf.sleeves}
+        tp_d, sk_d = sl_by["TP01_trend_1d"].daily(), sl_by["SKH01_skyhook"].daily()
+        Jd = pd.concat({"t": tp_d, "s": sk_d}, axis=1, join="inner").fillna(0.0)
+        der = 0.75 * Jd["t"] + 0.25 * Jd["s"]
+        mm = ((1.0 + der).resample("ME").prod() - 1.0).dropna()
+        d_cagr = float(np.prod(1.0 + mm.values) ** (12.0 / len(mm)) - 1.0) if len(mm) else 0.0
+        cons = d_cagr * 0.5
+        rd = (1.0 + cons) ** (1.0 / 365.0) - 1.0 if cons > 0 else 0.0
+        deribit = dict(full=metrics(der), hold=metrics(der[der.index >= HOLDOUT]),
+                       cagr=d_cagr, cons_cagr=cons, eday_5k=5000.0 * rd,
+                       eq5_5y=5000.0 * (1.0 + cons) ** 5, eq5_10y=5000.0 * (1.0 + cons) ** 10)
+    except Exception as e:
+        deribit = {"error": f"{type(e).__name__}: {e}"}
     # sparkline: subsample ~400 punti
     step = max(1, len(eq) // 400)
     spark = [(str(idx[i].date()), float(eq[i])) for i in range(0, len(eq), step)]
@@ -56,7 +71,7 @@ def build():
         full=bt["full"], holdout=bt["holdout"], weights=bt["weights"],
         per_sleeve=bt["per_sleeve"], yearly=bt["yearly"],
         positions=pf.current_positions(), spark=spark, paper=paper, prevday=prevday,
-        combo=combo, gtaa_weights=gtaa_w,
+        combo=combo, gtaa_weights=gtaa_w, deribit=deribit,
         shadow=shadow, trades=trades, bh=None,
     )
     _CACHE.update(t=time.time(), data=data)
@@ -146,6 +161,18 @@ def html():
                    + f" <span style='color:#8a93a0'>(asof {asof})</span>")
     else:
         gw_html = "n/d (cache ETF assente — gira fetch_ib_equities.py)"
+    db = d.get("deribit")
+    if db and "error" not in db:
+        f2, h2 = db["full"], db["hold"]
+        deribit_html = (
+            f"FULL <b>Sh {f2['sharpe']:.2f}</b> ret {f2['ret']*100:+.0f}% DD {f2['maxdd']*100:.1f}% &nbsp;·&nbsp; "
+            f"HOLD-OUT <b>Sh {h2['sharpe']:.2f}</b> DD {h2['maxdd']*100:.1f}%<br>"
+            f"<span style='color:#8a93a0;font-size:13px'>accumulo (reinvesti le vincite, no leva) — CAGR storico "
+            f"<b>{db['cagr']*100:.0f}%</b>, conservativo <b>{db['cons_cagr']*100:.0f}%</b>: "
+            f"da €5k → ~€{db['eq5_5y']:,.0f} (5a) / ~€{db['eq5_10y']:,.0f} (10a) &nbsp;·&nbsp; "
+            f"run-rate oggi ~<b>€{db['eday_5k']:.2f}/g</b> @conservativo</span>")
+    else:
+        deribit_html = "n/d" + (f" — {db['error']}" if db and db.get("error") else "")
     sh = d.get("shadow")
     if sh and "error" not in sh:
         bits = " &nbsp;·&nbsp; ".join(
@@ -221,6 +248,10 @@ th{{color:#8a93a0;font-weight:500}}.y{{display:inline-block;background:#161b22;b
 <div class=box><b>TP01 (Deribit) + GTAA (IB)</b> — le DUE gambe ESEGUIBILI a basso capitale, scorrelate (corr ~0.21) → blend Sharpe ~1.5, drawdown dimezzato. <b>Nessuna esecuzione reale</b>:<br>{combo_html}<br>
 <span style="color:#8a93a0;font-size:13px">posizioni azionabili IB (GTAA, peso ETF):</span> {gw_html}</div>
 <p class=warn>⚠️ PAPER cross-venue: valida l'operativita' su due conti (Deribit + IB) a rischio zero. Lo Sharpe ~1.5 e' ottimistico (finestra crypto corta/favorevole); il dato robusto e' la diversificazione (corr 0.21, DD dimezzato), non il livello. XS01/VRP01 esclusi (STAT-MODE): qui solo TP01+GTAA.</p>
+<div class="section">BOOK DERIBIT-ONLY — eseguibile (TP01 + SKH01)</div>
+<div class=box><b>TP01 75% + SKH01 25%</b> — le due gambe direzionali BTC/ETH sullo STESSO venue (Deribit), ribilancio mensile. Sottoinsieme realmente armabile (XS01/VRP01 esclusi):<br>{deribit_html}<br>
+<span style="color:#8a93a0;font-size:13px">forecast: <code>scripts/portfolio/forecast_deribit_book.py</code> · report: <code>scripts/portfolio/run_deribit_book.py</code></span></div>
+<p class=warn>⚠️ Accumulo = proiezione condizionata (storico bull crypto → pianifica sul conservativo); nessuna leva; SKH01 research/forward-monitor (solo TP01 armato live). A €50/g servono ~€177k @conservativo: la via è capitale+tempo, non leva.</p>
 <div class="section">FORWARD-MONITOR — lead paper (non deploy)</div>
 <div class=box><b>PREVDAY range-breakout</b> — lead ORTOGONALE a TP01 (corr ~0.15 full / ~0 hold; marginal ADDS, non-hedge, robusto allo shift del confine-giorno). Forward-only, <b>nessuna esecuzione reale</b>:<br>{prevday_html}</div>
 <p class=warn>⚠️ LEAD in osservazione, NON deployato. Sopravvissuto alla verifica avversariale dell'onda intraday; lo teniamo in paper per validarlo fuori-campione-vero. I due libri (modeled vs real-$600) mostrano l'haircut di fill che lo scettico aveva segnalato.</p>

src/portfolio/portfolio.py

@@ -68,6 +68,44 @@ def yearly(daily: pd.Series) -> dict:
     return out
 
 
+def rebalance_sim(daily_cols: dict[str, pd.Series], weights: dict,
+                  period_days: int, cost_rate: float = 0.0005) -> dict:
+    """Ribilanciamento PERIODICO REALISTICO (vs il rebalance-continuo implicito di combined_daily).
+
+    Tra una data di ribilanciamento e l'altra ogni sleeve DERIVA col suo rendimento (i pesi si
+    scostano dal target). Ogni `period_days` si riporta al target pagando il turnover:
+        cost = cost_rate * sum_i |valore_i - target_i|   (cost_rate = fee per-lato, Deribit taker ~0.0005)
+    Modella l'attrito reale che il rebalance-continuo (combined_daily) ignora. period_days=1 con
+    cost_rate=0 ricade sul rebalance-continuo. Ritorna serie netta + turnover annuo + n ribilanci."""
+    J = pd.concat(daily_cols, axis=1, join="inner").sort_index().fillna(0.0)
+    cols = list(J.columns)
+    w = np.array([weights[c] for c in cols], float); w = w / w.sum()
+    R = J.values
+    n = len(J)
+    E = 1.0
+    v = w * E
+    out = np.zeros(n)
+    n_rebal = 0
+    turn_tot = 0.0
+    for t in range(n):
+        Eprev = E
+        v = v * (1.0 + R[t])
+        E = float(v.sum())
+        if (t + 1) % period_days == 0:                       # giorno di ribilanciamento
+            target = w * E
+            turn = float(np.abs(v - target).sum())
+            cost = cost_rate * turn
+            E -= cost
+            v = w * E
+            n_rebal += 1
+            turn_tot += turn / max(Eprev, 1e-12)
+        out[t] = E / Eprev - 1.0 if Eprev > 0 else 0.0
+    years = n / DAYS_PER_YEAR
+    return dict(daily=pd.Series(out, index=J.index),
+                turnover_per_year=round(turn_tot / years, 2) if years > 0 else 0.0,
+                n_rebalances=n_rebal, period_days=period_days, cost_rate=cost_rate)
+
+
 class StrategyPortfolio:
     def __init__(self, sleeves: list[Sleeve], capital: float = 2000.0):
         if not sleeves:

src/portfolio/sleeves.py

@@ -236,8 +236,41 @@ def _skyhook_returns() -> pd.Series:
     return pd.Series(0.5 * J["BTC"].values + 0.5 * J["ETH"].values, index=J.index)
 
 
+def _skyhook_positions() -> dict:
+    """Stato corrente del book Skyhook per asset (introspezione live): se c'e' un trade APERTO ORA
+    -> dir/entry/sl/tp/barre-trascorse; altrimenti 'flat'. Replica la logica non-overlap di
+    entry+exit (TP/SL/max_bars) fino all'ultima barra 230m chiusa. Causale: usa solo barre chiuse."""
+    out = {}
+    for a in ASSETS:
+        ltf, htf = build_frames(load_data(a, "5m"))
+        ent = skyhook_entries(ltf, htf, SKH01_V2_DD)
+        H = ltf["high"].values; L = ltf["low"].values; Cc = ltf["close"].values
+        n = len(ltf); i = 0; open_pos = "flat"
+        while i < n:
+            e = ent[i]
+            if e is None:
+                i += 1; continue
+            d, sl, tp, mb = e["dir"], e["sl"], e["tp"], e["max_bars"]
+            exit_idx = None
+            for s in range(1, mb + 1):
+                j = i + s
+                if j >= n:                                   # non ancora uscito: posizione APERTA ora
+                    break
+                hit = (L[j] <= sl or H[j] >= tp) if d == 1 else (H[j] >= sl or L[j] <= tp)
+                if hit or s == mb:
+                    exit_idx = j; break
+            if exit_idx is None:
+                open_pos = dict(dir="LONG" if d == 1 else "SHORT", entry=round(float(Cc[i]), 2),
+                                sl=round(float(sl), 2), tp=round(float(tp), 2),
+                                bars_in=int((n - 1) - i), max_bars=int(mb))
+                break
+            i = exit_idx + 1
+        out[a] = open_pos
+    return out
+
+
 def skyhook_sleeve(weight: float = 0.25) -> Sleeve:
-    return Sleeve("SKH01_skyhook", weight, _skyhook_returns)
+    return Sleeve("SKH01_skyhook", weight, _skyhook_returns, pos_fn=_skyhook_positions)
 
 
 # ----------------------------- REGISTRY -----------------------------
@@ -253,3 +286,16 @@ def active_sleeves() -> list[Sleeve]:
         vrp_sleeve(weight=0.15),       # options short-vol (put credit spread + gate IV-rank), dal 2021 (lead modellato, scorrelato)
         skyhook_sleeve(weight=0.25),   # dual-TF regime+breakout BTC/ETH, dal 2019 (quasi-ortogonale, exit %-asimmetrici, research)
     ]
+
+
+def deribit_book_sleeves() -> list[Sleeve]:
+    """BOOK DERIBIT-ONLY realmente eseguibile (TP01 + SKH01, 75/25): le DUE gambe direzionali
+    BTC/ETH sullo stesso venue (Deribit), entrambe dal 2019. Esclude XS01 (Hyperliquid, stat-mode)
+    e VRP01 (opzioni modellate). FULL Sharpe ~1.78 / HOLD ~1.17 / DD ~9% (research; SKH01 daily-step).
+    Pensato per il deploy reale a basso capitale: stesso conto, stesso feed, ribilanciamento
+    periodico (vedi src.portfolio.portfolio.rebalance_sim + scripts/portfolio/run_deribit_book.py).
+    TP01 e' gia' armato live; SKH01 e' il candidato 2a gamba (da validare codice d'esecuzione)."""
+    return [
+        tp01_sleeve(weight=0.75),
+        skyhook_sleeve(weight=0.25),
+    ]

tests/test_portfolio.py

@@ -7,7 +7,7 @@ import numpy as np
 import pandas as pd
 import pytest
 
-from src.portfolio.portfolio import Sleeve, StrategyPortfolio, to_daily, metrics
+from src.portfolio.portfolio import Sleeve, StrategyPortfolio, to_daily, metrics, rebalance_sim
 
 
 def _const_sleeve(name, weight, val, n=400):
@@ -15,6 +15,37 @@ def _const_sleeve(name, weight, val, n=400):
     return Sleeve(name, weight, lambda: pd.Series(val, index=idx))
 
 
+def _ret_series(vals):
+    idx = pd.date_range("2020-01-01", periods=len(vals), freq="1D", tz="UTC")
+    return pd.Series(vals, index=idx)
+
+
+def test_rebalance_sim_no_cost_period1_matches_continuous():
+    """period=1 + cost=0 deve coincidere col rebalance-continuo (weighted-return giornaliero)."""
+    rng = np.random.default_rng(0)
+    A = _ret_series(rng.normal(0.001, 0.02, 300))
+    B = _ret_series(rng.normal(0.000, 0.03, 300))
+    w = {"A": 0.6, "B": 0.4}
+    sim = rebalance_sim({"A": A, "B": B}, w, period_days=1, cost_rate=0.0)
+    cont = 0.6 * A + 0.4 * B
+    assert np.allclose(sim["daily"].values, cont.values, atol=1e-12)
+    assert sim["n_rebalances"] == 300
+
+
+def test_rebalance_sim_cost_reduces_return_and_counts():
+    """Il costo del turnover abbassa il rendimento; ribilanci meno frequenti = meno costo."""
+    rng = np.random.default_rng(1)
+    A = _ret_series(rng.normal(0.001, 0.02, 360))
+    B = _ret_series(rng.normal(0.001, 0.04, 360))
+    w = {"A": 0.5, "B": 0.5}
+    free = rebalance_sim({"A": A, "B": B}, w, period_days=7, cost_rate=0.0)["daily"]
+    weekly = rebalance_sim({"A": A, "B": B}, w, period_days=7, cost_rate=0.001)
+    monthly = rebalance_sim({"A": A, "B": B}, w, period_days=30, cost_rate=0.001)
+    assert weekly["daily"].sum() < free.sum()                  # il costo morde
+    assert monthly["n_rebalances"] < weekly["n_rebalances"]    # mensile ribilancia meno
+    assert weekly["turnover_per_year"] > 0
+
+
 def test_single_sleeve_equals_itself():
     s = _const_sleeve("A", 1.0, 0.001)
     pf = StrategyPortfolio([s])

tests/test_skyhook.py

@@ -129,6 +129,16 @@ def test_short_override_changes_only_shorts():
     assert longs_same > 0 and shorts_diff > 0
 
 
+def test_skyhook_pos_fn_structure():
+    """pos_fn introspettiva: dict BTC/ETH, ciascuno 'flat' o dict con dir/entry/sl/tp coerenti."""
+    from src.portfolio.sleeves import _skyhook_positions
+    pos = _skyhook_positions()
+    assert set(pos.keys()) == {"BTC", "ETH"}
+    for a, p in pos.items():
+        assert p == "flat" or (isinstance(p, dict) and p["dir"] in ("LONG", "SHORT")
+                               and p["sl"] > 0 and p["tp"] > 0 and 0 <= p["bars_in"] <= p["max_bars"])
+
+
 def test_v2dd_robust_both_assets():
     """SKH01-V2-DD: PASS netto fee su BTC&ETH, hold-out forte, e maxDD standalone <30%."""
     import skyhooklib as sk