fix(exec): code-review serale — guard anti-posizione-nuda sul netting + verità per-frazione

7 finder paralleli sul diff della giornata (8adf388..HEAD), fix dei confermati:

CRITICI (money-path):
- close_amount: GUARD stato-stantio sul fallback netting — il residuo
  non-reduce-only e' consentito solo fino al gap (conto reale - libri degli
  altri worker - orfani) nella direzione della chiusura (src/live/books.py =
  fonte unica, usata anche dal reconciler). Senza guard, un close su stato
  stantio (DSL scattato in outage, flatten manuale) APRIVA una posizione nuda
  a taglia piena bookata come 'chiusura verificata'. Fail-safe se il gap non
  e' calcolabile. Check polvere PRIMA di _quantize_step (che clampa al lotto
  minimo: un residuo 1e-17 diventava un ordine nudo da un lotto).
- _real_close: market_amt = filled_amount anche a merged verified=False (i
  contratti chiusi dal reduce-only non si buttano se il leg netting fallisce);
  REAL_CLOSE_PARTIAL non piu' gateato su verified (era soppresso proprio nel
  caso parziale reale).
- pairs: verita' per-FRAZIONE di gamba (gross proporzionale al fillato, orfano
  = solo il residuo — prima falsava reconciler e real_capital della parte gia'
  chiusa); REAL_OPEN_PAIR booka filled_amount; docstring applied corretta.
- open_pair unwind: chiude il FILLATO, non il richiesto (senza il cap silenzioso
  del reduce-only avrebbe mangiato quota altrui).
- place_tp_limit: quantize CONSERVATIVO (sell=floor/buy=ceil) — il rounding al
  tick piu' vicino poteva mettere il resting oltre il TP sim -> tocco genuino
  classificato phantom sistematicamente.

ROBUSTEZZA/OSSERVABILITA':
- runner: WORKER_ERROR_STREAK a 5 e poi ogni 50 poll + recovery RIPRESO +
  flag real_in_position nell'alert (prima: one-shot a n==5, poi silenzio).
- _tp_phantom: TTL 120s sul verdetto (era ~50 HTTP/h per worker a barra
  fantasma); merge notes con entrambi gli order_id (audit-trail).
- reset_flatten: _quantize_step Decimal (round float produceva amount che
  Deribit rifiuta); hourly_report: book XS01 con gambe SHORT visibili (abs).
- validate_xsec_worker: POS/LEV importati (non hardcoded); xs01_tranche:
  regression-lock ESEGUITO vs xsec_sim; reconcile su src/live/books;
  drift_monitor: rolling vettoriale + exit code 1 su warn.

Test: +4 guard/dust, fixture filled_amount -> 114 passed.
Deferiti (TODO): resting esposti al netting, lifecycle orphan_legs, finestra
trade-history TP_PHANTOM, validazione feed a monte, dedup minori.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>

scripts/analysis/xs01_tranche_research.py

@@ -102,6 +102,27 @@ def combined_metrics(branches, ts, yrs_span):
                 sharpe=sharpe, dd=float(((pk - eq) / pk).max() * 100))
 
 
+def regression_lock(M=None):
+    """xsec_trades(phase=0) DEVE riprodurre xsec_sim (n trade e ret totale):
+    la copia e' load-bearing (la usano gate e validate_xsec_worker) — senza
+    lock eseguito un fix all'engine canonico non si propagherebbe e la
+    validazione live certificherebbe un engine stantio (code-review 2026-06-11)."""
+    from scripts.strategies.XS01_cross_sectional import xsec_sim
+    if M is None:
+        M = aligned_panel()
+    ts = pd.to_datetime(M.index, unit="ms", utc=True)
+    tr = xsec_trades(phase=0, M=M)
+    eq = equity_from(tr, ts)
+    ref = xsec_sim()
+    n_ok = len(tr) == ref["trades"]
+    ret = (eq.iloc[-1] / 1000 - 1) * 100 if len(eq) else 0.0
+    ret_ok = abs(ret - ref["ret"]) < 1e-6 * max(1.0, abs(ref["ret"]))
+    if not (n_ok and ret_ok):
+        raise AssertionError(f"REGRESSION-LOCK FALLITO: trades {len(tr)} vs {ref['trades']}, "
+                             f"ret {ret:.6f} vs {ref['ret']:.6f}")
+    print(f"  regression-lock OK: {len(tr)} trade, ret {ret:+.2f}% == xsec_sim")
+
+
 def run():
     M = aligned_panel()
     ts = pd.to_datetime(M.index, unit="ms", utc=True)
@@ -109,6 +130,7 @@ def run():
     print("=" * 96)
     print("  XS01 phase-tranching — sensibilita' di fase + ensemble K=2/3 | griglia pre-registrata")
     print("=" * 96)
+    regression_lock(M)
     for tag, split in (("FULL", 0.0), ("OOS", 1 - OOS_FRAC)):
         yrs_span = (ts[-1] - ts[max(int(n * split), LB)]).days / 365.25 or 1
         rows = []