research(intraday): fill-haircut PREVDAY a basso capitale -> blocker d'esecuzione BENIGNO

Stima SUBITO (invece di aspettare il forward-monitor) quanto il fill reale a $600 erode il lead
PREVDAY, replicando i due libri di paper_prevday.py su tutto il path 1h (2019-03 -> 2026-06):
 - MODELED (continuo) vs REAL-$C (skip ribilanciamenti < $5 min-order), sweep C {600,2k,20k}.
 - HAIRCUT $600 = +0.01 Sharpe (FULL e HOLD): saltare il 98.4% dei micro-ribilanciamenti del
   vol-target non costa nulla (trade infinitesimi: fee risparmiata e tracking-error entrambi
   trascurabili; fee-drag 2.49% -> 2.39%). L'uplift hold-out del blend 80/20 regge +0.56 -> +0.55.

Conseguenza: dei 4 blocker no-deploy, il #4 (fill a basso capitale) e' SMONTATO. Restano i 3
strutturali (hedge-shaped, fallisce il null a corr-zero, tail-luck). PREVDAY resta forward-monitor.
Lezione: eseguire eval_weights_smallcap PRIMA di scartare un lead per 'fill irreale'.

Diario: 2026-06-21-prevday-fill-haircut.md.

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

scripts/research/intraday/fill_haircut.py

@@ -0,0 +1,153 @@
+"""fill_haircut — quanto il fill REALE a basso capitale erode il lead PREVDAY (e TP01)?
+
+Lo scettico d'esecuzione (diario 2026-06-21) ha segnalato che il vol-target di PREVDAY fa ~8500
+ribilanciamenti/anno, di cui 97-98% < $1 di nozionale a $600: a quel capitale NON puoi piazzare
+quegli ordini (min_order $5), quindi il libro MODELED (ribilanciamento continuo, frictionless) è
+una finzione. Il forward-monitor traccia MODELED-$2000 vs REAL-$600 per misurare il gap nei mesi
+a venire — qui lo stimiamo SUBITO su tutto lo storico, replicando la STESSA logica di paper_prevday.
+
+Due libri, identici tranne il fill:
+  MODELED : ribilancia ad ogni barra alla posizione-bersaglio (fee proporzionale su ogni |Δ|).
+  REAL-$C : capitale C, salta i ribilanciamenti con nozionale |Δpos|*leg_cap < min_order ($5)
+            (posizione resta "stale" -> tracking error, ma niente fee sui trade infinitesimi).
+
+Sweep capitale {600, 2000, 20000} per mostrare a quanto l'haircut svanisce. Poi la domanda-soldi:
+il blend 80%TP01+20%PREVDAY conserva l'uplift hold-out (+0.56 modellato) usando PREVDAY-REAL-$600?
+
+    uv run python scripts/research/intraday/fill_haircut.py
+"""
+import sys
+from pathlib import Path
+
+import numpy as np
+import pandas as pd
+
+ROOT = Path(__file__).resolve().parents[3]
+sys.path.insert(0, str(ROOT))
+from src.backtest.harness import load                       # noqa: E402
+from src.strategies.prevday_breakout import target as pv_target  # noqa: E402
+from src.portfolio.portfolio import to_daily                # noqa: E402
+from src.portfolio.sleeves import _tp01_returns             # noqa: E402
+
+HOLD = pd.Timestamp("2025-01-01", tz="UTC")
+FEE_SIDE = 0.0005          # 0.05%/side = 0.10% RT
+MIN_ORDER = 5.0
+WEIGHT = 0.5
+ASSETS = ["BTC", "ETH"]
+
+
+def _sh(x):
+    x = x.dropna()
+    return float(x.mean() / x.std() * np.sqrt(365.25)) if len(x) > 2 and x.std() > 0 else 0.0
+
+
+def _dd(x):
+    eq = (1 + x.fillna(0)).cumprod()
+    return float(((eq - eq.cummax()) / eq.cummax()).min())
+
+
+def simulate(targets: dict, rets: dict, idx_dt, capital):
+    """Bar-by-bar 50/50 book. capital=None -> MODELED (continuous). Returns (daily_ret, stats)."""
+    n = len(idx_dt)
+    held = {a: 0.0 for a in ASSETS}
+    net = np.zeros(n)
+    exec_ct = {a: 0 for a in ASSETS}
+    skip_ct = {a: 0 for a in ASSETS}
+    fee_tot = 0.0
+    for i in range(n):
+        step = 0.0
+        for a in ASSETS:
+            tgt = float(targets[a][i]); r = float(rets[a][i]); h = held[a]
+            if capital is None:                      # MODELED: always rebalance
+                new_h = tgt; traded = abs(tgt - h)
+                exec_ct[a] += 1 if traded > 1e-9 else 0
+            else:                                    # REAL-$C: skip sub-min_order
+                leg_cap = capital * WEIGHT
+                if abs(tgt - h) * leg_cap >= MIN_ORDER:
+                    new_h = tgt; traded = abs(tgt - h); exec_ct[a] += 1
+                else:
+                    new_h = h; traded = 0.0; skip_ct[a] += 1
+            fee = FEE_SIDE * traded
+            fee_tot += WEIGHT * fee
+            step += WEIGHT * (h * r - fee)           # earn on position HELD into bar, pay fee on rebalance
+            held[a] = new_h
+        net[i] = step
+    s = pd.Series(net, index=idx_dt)
+    daily = s.groupby(s.index.floor("1D")).sum()
+    yrs = (idx_dt[-1] - idx_dt[0]).days / 365.25
+    ex = sum(exec_ct.values()); sk = sum(skip_ct.values())
+    stats = dict(execs_per_yr=ex / yrs, skip_frac=sk / (ex + sk) if (ex + sk) else 0.0,
+                 fee_drag_per_yr=fee_tot / yrs)
+    return daily, stats
+
+
+def build_targets():
+    targets, rets, ts_sets = {}, {}, {}
+    dts = {}
+    for a in ASSETS:
+        df = load(a, "1h").reset_index(drop=True)
+        c = df["close"].values.astype(float)
+        r = np.zeros(len(c)); r[1:] = c[1:] / c[:-1] - 1.0
+        targets[a] = pv_target(df); rets[a] = r
+        ts = df["timestamp"].values.astype("int64")
+        ts_sets[a] = ts
+        dts[a] = pd.to_datetime(df["datetime"], utc=True).values
+    common = sorted(set(ts_sets["BTC"]).intersection(ts_sets["ETH"]))
+    pos = {a: {int(t): i for i, t in enumerate(ts_sets[a])} for a in ASSETS}
+    T, R = {a: [] for a in ASSETS}, {a: [] for a in ASSETS}
+    dt_out = []
+    for t in common:
+        i_btc = pos["BTC"][int(t)]
+        dt_out.append(dts["BTC"][i_btc])
+        for a in ASSETS:
+            i = pos[a][int(t)]
+            T[a].append(targets[a][i]); R[a].append(rets[a][i])
+    idx = pd.to_datetime(dt_out, utc=True)
+    return {a: np.array(T[a]) for a in ASSETS}, {a: np.array(R[a]) for a in ASSETS}, idx
+
+
+def row(label, daily):
+    J = daily.dropna(); JH = J[J.index >= HOLD]
+    yrs = (J.index[-1] - J.index[0]).days / 365.25
+    cagr = (1 + J).prod() ** (1 / yrs) - 1
+    return (f"  {label:<18s} FULL Sh {_sh(J):+5.2f}  HOLD Sh {_sh(JH):+5.2f}  "
+            f"CAGR {cagr*100:+5.1f}%  DD {_dd(J)*100:4.0f}%")
+
+
+def main():
+    print("=" * 92)
+    print("  FILL-HAIRCUT — PREVDAY: libro MODELED (continuo) vs REAL-$C (skip < $5 min-order)")
+    print("=" * 92)
+    T, R, idx = build_targets()
+    print(f"  path 1h: {len(idx)} barre  {idx[0].date()} -> {idx[-1].date()}\n")
+
+    books = {}
+    for cap, lab in [(None, "MODELED ($∞)"), (20000, "REAL-$20k"), (2000, "REAL-$2000"), (600, "REAL-$600")]:
+        daily, st = simulate(T, R, idx, cap)
+        books[lab] = daily
+        print(row(lab, daily) +
+              f"   | rebal/yr {st['execs_per_yr']:6.0f}  skip {st['skip_frac']*100:4.1f}%  "
+              f"fee-drag/yr {st['fee_drag_per_yr']*100:4.2f}%")
+
+    mod = books["MODELED ($∞)"]; real = books["REAL-$600"]
+    hc_full = _sh(mod.dropna()) - _sh(real.dropna())
+    JHm = mod[mod.index >= HOLD]; JHr = real[real.index >= HOLD]
+    hc_hold = _sh(JHm) - _sh(JHr)
+    print(f"\n  >> HAIRCUT $600 (MODELED - REAL): FULL Sharpe {hc_full:+.2f}  |  HOLD-OUT Sharpe {hc_hold:+.2f}")
+
+    # money question: does the blend uplift survive at REAL-$600?
+    print("\n" + "-" * 92)
+    print("  BLEND 80%TP01 + 20%PREVDAY — sopravvive l'uplift hold-out col fill reale?")
+    tp = to_daily(_tp01_returns())
+    for lab, pv in [("MODELED", mod), ("REAL-$600", real)]:
+        J = pd.concat({"TP": tp, "PV": pv}, axis=1).dropna(); JH = J[J.index >= HOLD]
+        for w in (0.20, 0.30):
+            b = (1 - w) * J["TP"] + w * J["PV"]; bh = (1 - w) * JH["TP"] + w * JH["PV"]
+            print(f"  PV={lab:<9s} w={w:.0%}  FULL {_sh(b):+.2f} (upl {_sh(b)-_sh(J['TP']):+.2f})  "
+                  f"HOLD {_sh(bh):+.2f} (upl {_sh(bh)-_sh(JH['TP']):+.2f})")
+    print(f"  [TP01 solo: FULL {_sh(tp.dropna()):+.2f}  HOLD {_sh(tp[tp.index>=HOLD]):+.2f}]")
+    print("=" * 92)
+
+
+if __name__ == "__main__":
+    main()