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>

src/portfolio/runner.py

@@ -475,15 +475,28 @@ def run(config_path: str = "portfolios.yml"):
             def _tick_safe(s, w):
                 try:
                     _tick(s, w)
-                    worker_err_streak.pop(s.sid, None)
+                    n_prev = worker_err_streak.pop(s.sid, 0)
+                    if n_prev >= 5:
+                        # recovery dichiarato (code-review: alert one-shot senza
+                        # ripresa = silenzio indistinguibile dal guasto)
+                        from src.live.telegram_notifier import notify_event
+                        notify_event("WORKER_ERROR_STREAK",
+                                     {"worker": s.sid, "status": "RIPRESO",
+                                      "dopo_streak": n_prev})
                 except Exception as e:
                     n = worker_err_streak.get(s.sid, 0) + 1
                     worker_err_streak[s.sid] = n
                     print(f"[runner] errore worker {s.sid}: {e} (streak {n}; gli altri proseguono)")
-                    if n == 5:
+                    # alert a 5 e poi ogni 50 poll (~1h): un worker rotto per
+                    # giorni non deve sparire dopo il primo Telegram. Include
+                    # se ha una posizione REALE aperta (exit non valutati!)
+                    if n == 5 or n % 50 == 0:
                         from src.live.telegram_notifier import notify_event
-                        notify_event("WORKER_ERROR_STREAK",
-                                     {"worker": s.sid, "streak": n, "errore": str(e)[:200]})
+                        notify_event("WORKER_ERROR_STREAK", {
+                            "worker": s.sid, "streak": n, "errore": str(e)[:200],
+                            "real_in_position": bool(getattr(w, "real_in_position", False)),
+                            "in_position": bool(getattr(w, "in_position", False)),
+                            "nota": "exit NON valutati per questo worker"})
 
             for s in live_specs:
                 _tick_safe(s, workers[s.sid])