gate XSR01: riscrittura DICHIARATA (opzione A dell'operatore) + haircut con script

Decisione operatore 26/08, a 58 giorni dall'esito, in direzione che stringe:
(1) capitale deploy $5k -> $20k — riconcilia il gate (25/07) con la decisione
vincolante "100% Deribit fino a $20k" (26/07), posteriore, che governa (M28);
deploy XSR01 e scelta del venue ora coincidono in un punto solo.
(2) gamba haircut: numero decisivo da r0826_xsr_haircut.py (N11) a pavimento
$10 (il vero, HL-EXEC), citato con la frazione di ordini eseguiti (P7).
Misurato: FULL 968 barre floor $10 -> haircut -1,1% con 22% di eseguiti (la
guardia da sola era vacua: un libro fermo ha haircut piccolo); ticket mediano
$3,34/gamba, 84% sotto $10 — sostituisce il "$14,41" senza script.
(3) contesto 1.82 -> 1.79 (lente dei gate). Soglie numeriche INVARIATE.

Chiude il debito S5.3. Diario 2026-08-26-xsr01-gate-riscritto.md.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01B9UyJLHzR7EJzxR3iQ3RN1

CLAUDE.md

@@ -162,7 +162,7 @@ sull'hold-out; cambiarne le soglie guardando l'esito, pure.
 | gate | data | criterio | stato |
 |---|---|---|---|
 | **STATARB** | 2026-09-27 | soglie 24/07 (non toccate) + diagnostica statica sempre-short | ✅ monitor riparato e rigenerato il 26/08: la serie vera da' Sharpe **−1,61** a oggi → coi criteri invariati punta al **RITIRO**. Si legge il 27/09, non prima |
-| **XSR01** | 2026-10-23 | Sharpe ≥1,0 **E** haircut a $5.000 ≤40% (se sfonda → ritiro a prescindere), poi `weights_tilt_null` e capitale ≥$5k | 🚨 legge un monitor **mal tarato** (§5.3), e P(capitale ≥$5k quel giorno) = **0,0%** (mediana $2.635) → **il criterio di capitale non e' raggiungibile**. Sotto la lente RENDITA il sleeve e' **eguagliato da un conto remunerato** (📌 sotto) |
+| **XSR01** | 2026-10-23 | Sharpe ≥1,0 **E** haircut ≤40% — dal 26/08 il numero decisivo e' `r0826_xsr_haircut.py` a **pavimento $10**, citato con la frazione di ordini eseguiti — poi `weights_tilt_null` e **capitale ≥$20k** | ✅ **riscritto il 26/08 su decisione dell'operatore** (dichiarato prima dell'esito, stringe: diario `2026-08-26-xsr01-gate-riscritto`): capitale allineato a "100% Deribit fino a $20k"; serie forward rigenerata (31 barre vere, Sharpe −2,72). Sotto la lente RENDITA il sleeve resta **eguagliato da un conto remunerato** (📌 sotto) |
 | **DVOLSPREAD** | kill 2026-10-24 se Sh<−0,50; decisione 2027-01-24 | (a) Sharpe>0 (b) marginale ADDS+robust_oos+insample_edge (c) **DSR ≥0,95** (d) `weights_tilt_null`; **veto** se barre attive <80% → si estende, non si decide | ✅ serie rigenerata il 26/08 (−4,41 a oggi, era −14,73 sulla serie rotta); il veto barre-attive ora conta barre VERE e la guardia PREMATURO sorveglia il monitor |
 | **GATE PROP-01** | chiuso 22-23/08 | (a) listino 13/13 ✅ (b) ancora SKH01 23/23 ✅ (c) economica+sopravvivenza 2/2 ✅ | **chiuso 3/3** — ma il numero operativo e' sceso 42% → 7,8% → 4,4% → 2,6% |
 | **GATE PREVDAY-01** | scritto 23/08 | 10 condizioni | **8/10**: la cella che GIRA non e' quella che la selezione onesta sceglie, e quella viva **fallisce il DSR** (0,905) |
@@ -197,10 +197,12 @@ d'ancora in modo diverso (nella differenza si cancella in parte, nel livello per
    ingoiato. **Resta:** `alerted=True` marcato **prima** dell'invio → un 🚨 perso e' perso per
    l'episodio intero (gli episodi storici durano 200-2.324 ore). Cambiarlo **cambia il comportamento**
    → decisione dell'operatore.
-3. 🚨 **Il gate XSR01 del 23/10 legge un monitor tarato sul pavimento del venue sbagliato**
+3. ✅ **RISOLTO (2026-08-26, decisione dell'operatore: opzione "riscrivere adesso").** Gate
-   (C* vero $15.000-20.000, non ~$3.000). Due sole vie pulite: riscrivere la soglia **adesso**
+   XSR01 riscritto in modo dichiarato, prima dell'esito, in direzione che stringe: capitale
-   dichiarando che la si riscrive prima di vedere l'esito, **oppure** lasciarla e **citare il difetto
+   $5k → **$20k** (riconcilia con la decisione 26/07, che e' posteriore e governa), gamba haircut
-   alla decisione**. Decisione dell'operatore.
+   letta da `r0826_xsr_haircut.py` a pavimento $10 con la frazione di ordini eseguiti accanto
+   (misurata: haircut FULL −1,1% con **22% di eseguiti** — la guardia da sola era vacua), soglie
+   numeriche INVARIATE. Diario `2026-08-26-xsr01-gate-riscritto.md`.
 4. ❓ **Due domande al commercialista, aperte** (valgono ~$22k di muro e ~€30/mese di versamento):
    (a) i derivati Deribit (inverse, margine e regolamento in cripto, sede extra-UE) stanno in
    `c-sexies` (33%) o `c-quater` (26%)? E il collaterale sconta il 2‰ al 31/12? (b) i payout di una

docs/diary/2026-08-26-xsr01-gate-riscritto.md

@@ -0,0 +1,44 @@
+# 2026-08-26 — Gate XSR01 (23/10): riscrittura DICHIARATA, decisa dall'operatore
+
+**Decisione dell'operatore** (oggi, discussione in sessione): opzione **A** fra le tre proposte —
+riscrivere ora il gate, dichiarandolo, invece di lasciarlo e citare i difetti (B) o ritirare
+XSR01 in anticipo (C, che avrebbe violato la pre-registrazione).
+
+Il docstring del gate prescrive: *"ogni modifica va motivata nel diario come violazione"*.
+Questa e' quella motivazione. **Scritta a 58 giorni dalla decisione, prima di vederne l'esito,
+e in direzione che STRINGE i criteri** — le tre proprieta' che rendono una riscrittura
+difendibile invece che selection-on-forward.
+
+## Le tre modifiche
+
+1. **Capitale per il deploy: $5.000 → $20.000.** Non e' tuning: il gate fu scritto il 25/07,
+   e il 26/07 l'operatore ha preso la decisione vincolante *"100% Deribit fino a $20k"* —
+   posteriore, quindi governa (M28: quando due impegni si contraddicono, la contraddizione e'
+   informazione). Il criterio a $5k autorizzava capitale su Hyperliquid che un'altra decisione
+   gia' vietava. Ora il deploy di XSR01 e la riapertura della scelta del venue coincidono a
+   $20k: **una decisione sola, un punto solo**.
+2. **Gamba haircut: il numero decisivo viene da uno script committato** —
+   `r0826_xsr_haircut.py` (N11: il "$14,41" dell'ammissione non aveva script ed era ~2,4x
+   ottimista), **a pavimento $10** (il pavimento vero misurato da HL-EXEC; il libro REAL-$5000
+   del monitor gira a $5 ed e' ottimista per costruzione), **citato accanto alla frazione di
+   ordini eseguiti** (P7). Misurato oggi, ed e' la conferma empirica del difetto dello
+   strumento: sul FULL a pavimento $10 l'haircut e' **−1,1%** con **il 22% di ordini
+   eseguiti** — la guardia non puo' quasi scattare per costruzione, perche' un libro che non
+   si muove ha haircut piccolo. **La soglia resta il 40% pre-registrato: nessuna soglia nuova
+   viene scritta oggi coi dati in mano.**
+3. **Contesto corretto:** il riferimento `IS_SHARPE_NET = 1.82` era una terza lente
+   (XSR-REPRO): ora cita **1,79**, lente dei gate alla scoperta. Il criterio non cambia.
+
+## I numeri di oggi (58 giorni alla decisione — NON decidono niente)
+
+- forward rigenerato (serie vera dal 26/08): **31 barre, Sharpe −2,72**, maxDD 0,8%
+- ticket per gamba a $5.000: mediano **$3,34**, medio $5,99, 63% sotto $5, **84% sotto $10**
+  (46.200 ordini replay) — riproduce XSR-REPRO e sostituisce il $14,41
+- haircut forward a pavimento $10: −10,7% (dentro la guardia), **ordini eseguiti 38%**
+- FULL 968 barre: MODELED Sharpe 2,12; floor $10 → haircut −1,1%, eseguiti **22%**
+
+## Cosa riaprirebbe XSR01 (registrato qui perche' non vada riscoperto)
+
+Capitale ≥$60k (per un 25% sopra C\*) · un venue con C\* più basso di $15-20k · una misura che
+mostri nel meccanismo qualcosa oltre la coppia (media, vol) — il null del 25/08
+(`r0825_xsr_rendita.py`) ha detto che oggi non c'e'.

docs/memory/10-sleeve-e-candidati.md

@@ -315,15 +315,20 @@ Ogni numero va letto con la sua banda d'ancora e la sua lente.
   con turnover 38.5% del lordo/g su 50 alt anche illiquidi e **slippage NON modellato** (rischio #1).
   **Eseguibilita':** ticket/gamba $1.73 a $600 (**sotto min-order $5 → STAT-MODE oggi**), $5.76 a
   $2000, **$14.41 a $5000** → diventa reale a **~$5k**, non ai ~$20k di XS01.
-  🚨 **IL GATE QUI SOTTO LEGGE UN MONITOR MAL TARATO (misurato 2026-08-23, §67): il pavimento del
+  ✅ **GATE RISCRITTO IL 2026-08-26 (decisione dell'operatore, opzione A: riscrivere adesso,
-  venue usato per l'haircut e' quello sbagliato — C\* vero $15.000-20.000, non i ~$3.000 riportati da
+  dichiarandolo — diario `2026-08-26-xsr01-gate-riscritto.md`).** A 58 giorni dalla decisione,
-  HL-EXEC con un criterio piu' permissivo.** Le soglie **NON sono state toccate**: cambiarle guardando
+  prima dell'esito, in direzione che stringe: (1) **capitale deploy $5k → $20k** — il gate del
-  questa misura a due mesi dalla decisione sarebbe selection-on-holdout. Le due vie pulite: riscriverle
+  25/07 contraddiceva la decisione vincolante "100% Deribit fino a $20k" del 26/07, posteriore,
-  **adesso** dichiarando che le si riscrive prima di vedere l'esito, oppure lasciarle e **citare il
+  che governa (M28); ora deploy XSR01 e scelta del venue coincidono in UN punto; (2) gamba
-  difetto al momento della decisione**. **Decisione dell'operatore.**
+  haircut letta da **`r0826_xsr_haircut.py`** (N11) a **pavimento $10** (il vero, HL-EXEC) con
-  **Gate pre-registrato 2026-10-23** (forward-day 0): deploy solo se Sharpe≥1.0 **E** haircut di
+  la **frazione di ordini eseguiti** accanto (P7) — misurato: FULL 968 barre, floor $10 →
-  eseguibilita' a $5000 ≤40% (se l'haircut sfonda → **RITIRO a prescindere dallo Sharpe**), poi
+  haircut **−1,1%** con **22% di eseguiti**: la guardia da sola era vacua (un libro fermo ha
-  weights_tilt_null e capitale ≥$5k. Monitor in `cron_daily.sh`, 3 libri (MODELED $2000 / REAL $600 /
+  haircut piccolo); ticket mediano **$3,34**/gamba, 84% sotto $10 — riproduce XSR-REPRO e
+  sostituisce il "$14,41" senza script; (3) contesto 1.82 → 1.79 (lente dei gate). **Soglie
+  numeriche INVARIATE** (Sharpe 1,0/0,3; haircut 40%): nessuna soglia nuova coi dati in mano.
+  **Gate pre-registrato 2026-10-23** (forward-day 0): deploy solo se Sharpe≥1.0 **E** haircut
+  ≤40% (strumento onesto di cui sopra; se sfonda → **RITIRO a prescindere dallo Sharpe**), poi
+  weights_tilt_null e **capitale ≥$20k**. Monitor in `cron_daily.sh`, 3 libri (MODELED $2000 / REAL $600 /
   REAL $5000). ⚠ Lezione: XSR01 **non e' nato da un'idea nuova ma dalla DIAGNOSI di un fallimento**
   (ampiezza effettiva 4.5 → c'e' un fattore comune da togliere); e i suoi null vanno confrontati
   **a fee zero**, perche' permutare un segnale ne fa esplodere il turnover e il null perderebbe per

scripts/research/r0725_xsr_deploy_gate.py

@@ -11,6 +11,23 @@ deflated-Sharpe 0.985, corr ~0 a tutti e 5 gli sleeve. Sopravvive a tre null fee
 test di lag. NON e' nel book per tre motivi dichiarati: storia corta e monotona crescente,
 `weights_tilt_null` fallito, e margine di costo sottile con slippage NON modellato.
 
+⚠️ MODIFICA DICHIARATA 2026-08-26 (diario `2026-08-26-xsr01-gate-riscritto.md`) — decisa
+dall'operatore PRIMA di vedere l'esito, a 58 giorni dalla data, e in direzione che STRINGE:
+  1. CAPITALE per il deploy: $5.000 -> $20.000. Non e' tuning sull'esito: riconcilia il gate
+     (scritto il 25/07) con la decisione vincolante "100% Deribit fino a $20k" (26/07), che e'
+     POSTERIORE e lo governa — sotto $20k nessun capitale esce da Deribit, quindi il criterio
+     a $5k autorizzava una cosa che un'altra decisione gia' vietava (M28).
+  2. GAMBA HAIRCUT: il numero decisivo alla decisione e' quello dello script committato
+     `r0826_xsr_haircut.py` a pavimento $10 (il pavimento VERO misurato, HL-EXEC 22/08 — il
+     libro REAL-$5000 del monitor gira a $5 ed e' ottimista per costruzione), CITATO ACCANTO
+     alla frazione di ordini eseguiti (P7): a $10 si esegue ~1 ordine su 5, e un haircut
+     piccolo con pochi ordini eseguiti non e' eseguibilita', e' un libro fermo. La SOGLIA
+     resta il 40% pre-registrato: nessuna soglia nuova viene scritta oggi coi dati in mano.
+  3. Il riferimento "in-sample 1.82" era una TERZA lente (XSR-REPRO 22/08): la lente dei gate
+     da' 1.79 alla scoperta. Corretto il contesto, non il criterio.
+La serie forward e' quella RIGENERATA il 26/08 (advance() riparato, §5.1): stessa finestra,
+stesso forward-day 0, barre finalmente VERE.
+
 REGOLA (immutabile — ogni modifica va motivata nel diario come violazione):
   - Data decisione: 2026-10-23 (90 giorni forward dal 2026-07-25). Non prima.
   - Metrica primaria: Sharpe annualizzato di `net_modeled` su TUTTA la finestra forward.
@@ -22,7 +39,7 @@ REGOLA (immutabile — ogni modifica va motivata nel diario come violazione):
   - Esiti:
       Sharpe >= 1.0  AND haircut$5000 <= 40%  -> CANDIDATO SLEEVE: proporre peso {5,10}% e
                         giudicarlo con `weights_tilt_null` (che oggi NON passa) + maxDD combinato.
-                        Deploy solo se il tilt-null passa E il capitale e' >= $5000.
+                        Deploy solo se il tilt-null passa E il capitale e' >= $20.000 (mod. 26/08).
       0.3 <= Sh < 1.0                          -> ESTENDI una sola volta di 90g (2027-01-21).
       Sharpe < 0.3  OR haircut > 40%           -> RITIRO dal forward-monitor.
   - Guardie accessorie: config invariata (il test `tests/test_paper_xsr.py` la blocca);
@@ -47,7 +64,8 @@ DECISION_EXT = date(2027, 1, 21)
 SH_DEPLOY = 1.0
 SH_RETIRE = 0.3
 HAIRCUT_MAX = 0.40
-IS_SHARPE_NET = 1.82          # riferimento in-sample, per contesto
+CAPITALE_DEPLOY = 20_000.0    # mod. dichiarata 26/08: riconcilia col muro "100% Deribit" (26/07)
+IS_SHARPE_NET = 1.79          # lente dei gate alla scoperta (il "1.82" era una terza lente)
 
 
 def main() -> None:
@@ -78,7 +96,10 @@ def main() -> None:
     print(f"  Sharpe fwd (mod) : {sh:+.2f}   (in-sample netta era {IS_SHARPE_NET:.2f})")
     print(f"  maxDD fwd        : {dd:.1%}")
     print(f"  ritorno MODELED  : {tot_m*100:+.2f}%     REAL-$5000: {tot_5*100:+.2f}%")
-    print(f"  haircut eseguib. : {haircut*100:.1f}%   (guardia <= {HAIRCUT_MAX*100:.0f}%)")
+    print(f"  haircut monitor  : {haircut*100:.1f}%   (pavimento $5 — ottimista per costruzione)")
+    print(f"  guardia <= {HAIRCUT_MAX*100:.0f}%: il numero DECISIVO e' quello di "
+          f"`r0826_xsr_haircut.py` a pavimento $10,")
+    print( "                     citato accanto alla frazione di ordini eseguiti (mod. 26/08)")
     print(f"  data decisione   : {DECISION}  (proroga unica: {DECISION_EXT})")
 
     if today < DECISION:
@@ -89,7 +110,8 @@ def main() -> None:
         print("\n  -> RITIRO: l'haircut di eseguibilita' supera la guardia. E' costo, non edge.")
     elif sh >= SH_DEPLOY:
         print("\n  -> CANDIDATO SLEEVE: proporre peso {5,10}% e passarlo a weights_tilt_null "
-              "(oggi NON passa) + maxDD combinato. Deploy solo con capitale >= $5000.")
+              f"(oggi NON passa) + maxDD combinato. Deploy solo con capitale >= "
+              f"${CAPITALE_DEPLOY:,.0f} (mod. 26/08, allineato a '100% Deribit fino a $20k').")
     elif sh >= SH_RETIRE:
         print(f"\n  -> SOTTO SOGLIA ma >= {SH_RETIRE}: estensione unica fino al {DECISION_EXT}.")
     else:

scripts/research/r0826_xsr_haircut.py

@@ -0,0 +1,139 @@
+"""r0826_xsr_haircut.py — l'haircut di eseguibilita' di XSR01 a $5.000, MISURATO con uno script.
+
+PERCHE' ESISTE. La seconda gamba del gate XSR01 (23/10) e' "haircut a $5.000 <= 40%", ma:
+  (a) il numero pubblicato all'ammissione ($14,41 di ticket/gamba) NON ha uno script committato
+      che lo riproduca ed e' ~2,4x ottimista (XSR-REPRO 22/08: mediano vero $3,33/gamba);
+  (b) il libro REAL-$5000 del monitor gira con pavimento $5, ma il pavimento VERO misurato del
+      venue e' $10 (HL-EXEC 22/08) — e a $10 si esegue ~1 ordine su 5;
+  (c) il paradosso dello strumento: con POCHI ordini eseguiti il libro reale resta vicino al
+      modellato nei periodi calmi -> l'haircut misurato dal monitor puo' sembrare piccolo
+      proprio quando l'eseguibilita' e' pessima. La frazione di ordini eseguiti va letta
+      ACCANTO all'haircut, mai al suo posto (P7: uno "zero" si legge accanto alla quota di
+      campione utilizzabile).
+
+COSA FA. Replay dei libri XSR01 col codice di PRODUZIONE (`paper_xsr._step`, nessuna
+reimplementazione — il metodo dell'audit 22/08), capitale $5.000, pavimenti $5 e $10, su due
+finestre: FULL (tutte le barre chiuse, ~2,6 anni: la risoluzione) e FORWARD (dal forward-day 0
+del gate, 2026-07-25: cio' che il gate legge). Sole barre CHIUSE (paper_guard).
+
+E' lo script che il gate del 23/10 cita come strumento DECISIVO per la gamba haircut
+(modifica dichiarata del 2026-08-26, diario `2026-08-26-xsr01-gate-riscritto.md`).
+
+    uv run python scripts/research/r0826_xsr_haircut.py
+"""
+from __future__ import annotations
+
+import importlib.util
+import json
+import sys
+from pathlib import Path
+
+import numpy as np
+import pandas as pd
+
+ROOT = Path(__file__).resolve().parents[2]
+sys.path.insert(0, str(ROOT))
+
+from src.live.paper_guard import MS_1D, nuove_chiuse  # noqa: E402
+
+CAP = 5_000.0
+PAVIMENTI = (5.0, 10.0)       # $5 = il pavimento del monitor · $10 = il pavimento VERO (HL-EXEC)
+ANN = float(np.sqrt(365.0))
+
+
+def _px():
+    spec = importlib.util.spec_from_file_location("_hx_paper_xsr",
+                                                  ROOT / "scripts" / "live" / "paper_xsr.py")
+    m = importlib.util.module_from_spec(spec)
+    spec.loader.exec_module(m)
+    return m
+
+
+def _sh(r: np.ndarray) -> float:
+    return float(r.mean() / r.std() * ANN) if len(r) > 1 and r.std() > 0 else float("nan")
+
+
+def replay(px, idx: list[int], W, R, rb, n_gambe: int, min_order: float | None) -> dict:
+    bk = px._book(CAP, n_gambe)
+    net = []
+    for i in idx:
+        net.append(px._step(bk, W[i], R[i], float(rb[i]), min_order))
+    net = np.asarray(net)
+    tot = float(np.prod(1 + net) - 1)
+    n_ordini = bk["n_fill"] + bk["n_skip"]
+    return dict(net=net, tot=tot, sh=_sh(net),
+                frazione_eseguita=(bk["n_fill"] / n_ordini if n_ordini else float("nan")))
+
+
+def misura(px, idx: list[int], W, R, rb, n_gambe: int) -> dict:
+    """Per una finestra: MODELED + un libro reale per pavimento, con l'haircut del gate."""
+    out = dict(modeled=replay(px, idx, W, R, rb, n_gambe, None))
+    tot_m = out["modeled"]["tot"]
+    for f in PAVIMENTI:
+        r = replay(px, idx, W, R, rb, n_gambe, f)
+        r["haircut"] = (tot_m - r["tot"]) / abs(tot_m) if tot_m != 0 else float("nan")
+        out[f] = r
+    return out
+
+
+def ticket_stats(W, idx: list[int]) -> dict:
+    """Taglia degli ordini per gamba a $5.000: |Δw| x capitale a ogni ribilancio."""
+    t = []
+    prev = np.zeros(W.shape[1])
+    for i in idx:
+        w = np.nan_to_num(W[i])
+        d = np.abs(w - prev) * CAP
+        t.extend(d[d > 0].tolist())
+        prev = w
+    t = np.asarray(t)
+    return dict(mediano=float(np.median(t)), medio=float(np.mean(t)),
+                sotto5=float((t < 5.0).mean()), sotto10=float((t < 10.0).mean()), n=len(t))
+
+
+def main() -> None:
+    print("=" * 96)
+    print(f"  XSR01 — haircut di eseguibilita' a ${CAP:,.0f}, replay col codice di produzione")
+    print("=" * 96)
+    px = _px()
+    ts, dt, W, R, rb, syms = px.build_panel()
+    st = json.loads((ROOT / "data" / "paper_xsr" / "state.json").read_text())
+    chiuse = nuove_chiuse(ts, 0, MS_1D)
+    fwd = [i for i in chiuse if ts[i] > st["start_ts"]]
+    Wv = np.nan_to_num(np.asarray(W, float))
+    Rv = np.nan_to_num(np.asarray(R, float))
+
+    tk = ticket_stats(Wv, chiuse)
+    print(f"\n  TICKET PER GAMBA a ${CAP:,.0f} (riproduce/sostituisce il '$14,41' senza script):")
+    print(f"    mediano ${tk['mediano']:.2f} · medio ${tk['medio']:.2f} · "
+          f"sotto $5: {tk['sotto5']:.0%} · sotto $10: {tk['sotto10']:.0%}  "
+          f"({tk['n']:,} ordini su {len(chiuse)} barre)")
+
+    for nome, idx in (("FULL (tutte le barre chiuse)", chiuse), ("FORWARD (dal 2026-07-25)", fwd)):
+        if len(idx) < 5:
+            print(f"\n  {nome}: {len(idx)} barre — troppo corta, nessun numero")
+            continue
+        m = misura(px, idx, Wv, Rv, rb, len(syms))
+        print(f"\n  {nome} — {len(idx)} barre "
+              f"({pd.Timestamp(int(ts[idx[0]]), unit='ms', tz='UTC').date()} -> "
+              f"{pd.Timestamp(int(ts[idx[-1]]), unit='ms', tz='UTC').date()})")
+        print(f"    {'libro':<18} {'tot':>9} {'Sharpe':>8} {'haircut':>9} {'ordini eseguiti':>17}")
+        print("    " + "-" * 66)
+        print(f"    {'MODELED':<18} {m['modeled']['tot']:>8.2%} {m['modeled']['sh']:>8.2f} "
+              f"{'—':>9} {'—':>17}")
+        for f in PAVIMENTI:
+            r = m[f]
+            print(f"    {'REAL floor $%.0f' % f:<18} {r['tot']:>8.2%} {r['sh']:>8.2f} "
+                  f"{r['haircut']:>8.1%} {r['frazione_eseguita']:>16.0%}")
+        if nome.startswith("FORWARD"):
+            h10 = m[10.0]["haircut"]
+            fe10 = m[10.0]["frazione_eseguita"]
+            print(f"\n    VERDETTO gate (gamba haircut, pavimento VERO $10): "
+                  f"{h10:+.1%} contro guardia 40%"
+                  f" -> {'SFONDA (RITIRO a prescindere)' if abs(h10) > 0.40 else 'dentro la guardia'}")
+            print(f"    ⚠️ da leggere ACCANTO: ordini eseguiti {fe10:.0%} — un haircut piccolo "
+                  f"con pochi ordini\n       eseguiti non e' eseguibilita', e' un libro che non "
+                  f"si muove (P7).")
+
+
+if __name__ == "__main__":
+    main()