fix(gtaa): costo IB reale (pavimento fisso) + esecuzione a banda — lo sleeve era cieco al capitale

DIFETTO. src/portfolio/gtaa.py modellava il costo come 2bps PROPORZIONALI e il modulo si
dichiarava "eseguibile a basso capitale, switch mensile/basso turnover". Entrambe false:
il vol-target e' CONTINUO (l'esposizione cambia ogni giorno, su 6 gambe) e IB non ha una
fee proporzionale ma un PAVIMENTO FISSO per ordine, min(max($0.35, $0.0035/az), 1% del
controvalore) = ~$530/anno indipendenti dal capitale.

Il modello vecchio era quindi CIECO AL CAPITALE: dava Sharpe 0.64 sia a $50.000 sia a $600.
Alla taglia grande era sostanzialmente giusto (0.64 vs 0.59-0.66 reali); a $600 la realta'
e' -0.55 di Sharpe e -3.5%/anno di CAGR. L'errore era tutto concentrato dove lo sleeve
verrebbe realmente deployato.

FIX. Il modulo ora:
  * modella la commissione IB reale (ib_commission);
  * esegue a BANDA + CADENZA (settimanale, $50/gamba) — config scelta sul PLATEAU del sweep
    (weekly/monthly x banda 25-100 -> Sh 0.45-0.64 a ogni capitale), non sull'argmax
    in-sample (banda $50 daily a $600 = cella isolata che crolla a banda 100);
  * prende il CAPITALE allocato come parametro: gtaa_returns(capital=...);
  * dichiara la soglia di deployabilita': GTAA_MIN_CAPITAL=$3.000 + gtaa_is_deployable();
  * espone gtaa_rebalance_plan(held, capital) per l'esecutore — salta le gambe il cui
    nozionale non supera la banda (un ordine da $12 costa $0.35 = 2.9%).
sleeves.py dichiara esplicitamente il capitale assunto (GTAA_DEFAULT_CAPITAL=$10.000 allocati
= book ~$50k al peso 20%) invece di nasconderlo.

IMPATTO SUL BOOK (misurato sostituendo la sola gamba GTAA, non citato):
  GTAA01 standalone  Sh 0.64 -> 0.61   CAGR 3.76% -> 3.65%
  book 5 sleeve      FULL 2.22 -> 2.22  HOLD 2.36 -> 2.38  maxDD 6.2% -> 6.0%
Trascurabile alla taglia assunta: il fix conta per il DEPLOY (a $600-2k passa da -3.5%/anno
a +3.0%/anno). PESI INVARIATI -> nessun weights_tilt_null richiesto.

CORREZIONE A UN ERRORE DI ANALISI DELLA SESSIONE. Il diario citava il modello vecchio a
"Sharpe 0.77 / CAGR 5.5%": artefatto di annualizzazione: la serie GTAA grezza ha ~252 barre
/anno (soli giorni di borsa) e metrics() annualizza a 365 con years=n/365.25 -> Sharpe x1.20
e CAGR x1.45. Le righe per-capitale erano gia' su calendario 365, quindi era falsata solo la
riga di riferimento. Corretti diario, CLAUDE.md e r0725_capcurve.py.
LEZIONE: una serie su giorni di borsa non si passa a metrics() senza to_daily().

Test: 221 pass (+4 in tests/test_gtaa_sleeve.py: pavimento non proporzionale, dipendenza dal
capitale + soglia, senza-banda-e-distruttivo, piano che salta le gambe sotto banda).
Smoke: scripts/live/paper_combo.py gira invariato.

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

scripts/research/r0725_capcurve.py

@@ -13,7 +13,8 @@ Tre parti:
      ALLOCATI a quello sleeve, con il modello di costo del SUO venue:
        - Deribit (TP01, SKH01): fee proporzionale 0.05%/lato, min order $5 (skip, non trade).
        - IB (GTAA01): commissione = min(max($0.35, $0.0035/azione), 1% del controvalore)
-         -> **pavimento FISSO per ordine**, mai modellato prima (gtaa.py usa 2bps proporzionali).
+         -> **pavimento FISSO per ordine**. gtaa.py usava 2bps proporzionali + ribilancio
+         continuo: difetto trovato QUI e poi corretto nel modulo (banda + costo IB reale).
        - Hyperliquid (XSR01): fee 0.045%/lato, min order $5, 50 gambe.
      Novita' vs tutto il lavoro precedente: la curva GTAA, cioe' a che capitale il 3o sleeve
      smette di essere un costo.
@@ -45,7 +46,7 @@ sys.path.insert(0, str(ROOT))
 
 from src.data.downloader import load_data  # noqa: E402
 from src.portfolio.gtaa import EQ_UNIVERSE, _close, _exposure  # noqa: E402
-from src.portfolio.portfolio import combine_outer, metrics  # noqa: E402
+from src.portfolio.portfolio import combine_outer, metrics, to_daily  # noqa: E402
 from src.portfolio.sleeves import _skyhook_returns, _tp01_returns  # noqa: E402
 from src.strategies.trend_portfolio import CANONICAL, TrendPortfolio, resample_1d, simple_returns  # noqa: E402
 
@@ -103,7 +104,7 @@ def _tp01_realistic_cached(alloc: float) -> pd.Series:
 def _gtaa_realistic_cached(alloc: float, universe=EQ_UNIVERSE) -> pd.Series:
     """GTAA con capitale ALLOCATO `alloc`, costo IB REALE (pavimento fisso per ordine).
 
-    gtaa.py modella 2bps proporzionali: a $600 su 6 gambe l'ordine tipico e' ~$10-30 e la
+    gtaa.py modellava 2bps proporzionali: a $600 su 6 gambe l'ordine tipico e' ~$10-30 e la
     commissione IB minima ($0.35) e' l'**1-3%** del controvalore, cioe' 15-150x il modello.
     Qui ogni gamba e' un conto separato: si ribilancia solo se il nozionale supera il minimo
     frazionale, e si paga min(max(0.35, 0.0035*azioni), 1%*valore) A OGNI ordine.
@@ -187,10 +188,8 @@ def part_a2() -> dict:
     print("  A2) GTAA01 — la BANDA di ribilanciamento puo' salvarlo? (costo fisso IB $0.35/ordine)")
     print("=" * 100)
     from src.portfolio.gtaa import gtaa_returns
-    g_model = gtaa_returns()
-    if g_model.index.tz is None:
-        g_model.index = g_model.index.tz_localize("UTC")
-    print(f"  riferimento MODELLATO (2bps propor., ribil. continuo): "
+    g_model = to_daily(gtaa_returns())          # calendario 365: vedi nota in part_a()
+    print(f"  riferimento MODELLATO (costo/banda correnti del modulo): "
           f"Sh {metrics(g_model)['sharpe']:.2f}  CAGR {metrics(g_model)['cagr']:.1%}")
 
     best = {}
@@ -265,9 +264,10 @@ def part_a() -> dict:
     print("\n  GTAA01 (IB, 6 ETF, commissione min $0.35/ordine — PAVIMENTO FISSO)")
     print(f"    {'alloc':>10} {'Sharpe':>8} {'CAGR':>8} {'maxDD':>8}   {'drag comm/anno':>15}")
     from src.portfolio.gtaa import gtaa_returns
-    g_model = gtaa_returns()
-    if g_model.index.tz is None:
-        g_model.index = g_model.index.tz_localize("UTC")
+    # to_daily: la serie GTAA grezza ha solo i giorni di borsa (~252/anno) e metrics()
+    # annualizza a 365 -> senza questa conversione il riferimento e' gonfiato ~1.20x (Sharpe)
+    # e ~1.45x (CAGR). Le righe realistiche sono gia' su calendario 365.
+    g_model = to_daily(gtaa_returns())
     mg_model = metrics(g_model)
     for a in alloc_grid:
         s = gtaa_realistic(a)
@@ -277,7 +277,7 @@ def part_a() -> dict:
         print(f"    {a:>10,.0f} {m['sharpe']:>8.2f} {m['cagr']:>8.1%} {m['maxdd']:>8.1%}"
               f"   {drag:>15.2%}")
     print(f"    {'MODELLATO':>10} {mg_model['sharpe']:>8.2f} {mg_model['cagr']:>8.1%} {mg_model['maxdd']:>8.1%}"
-          f"   {'(2bps propor.)':>15}")
+          f"   {'(modulo, banda)':>15}")
     out["_models"] = dict(TP01=m_model, GTAA01=mg_model)
     return out