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/reconcile_account.py

@@ -20,7 +20,6 @@ Nessun ordine, nessuna modifica di stato: SOLO lettura.
 """
 from __future__ import annotations
 
-import json
 import sys
 import time
 from pathlib import Path
@@ -30,63 +29,17 @@ sys.path.insert(0, str(PROJECT_ROOT))
 
 from src.live.cerbero_client import CerberoClient
 from src.live.execution import contract_spec
+from src.live.books import real_books, account_net   # fonte UNICA dei libri (usata
+                                                     # anche dal guard del netting)
 
-PAPER = PROJECT_ROOT / "data" / "portfolio_paper"
 RECHECK_SLEEP = 10          # anti-race: secondi fra i due passaggi
 TOL_STEPS = 1.5             # tolleranza = 1.5 × step contratto
 
 
-def _inst(asset: str) -> str:
-    return f"{asset}_USDC-PERPETUAL"
-
-
-def expected_books() -> tuple[dict[str, float], dict[str, float]]:
-    """(atteso per strumento dai libri, quota orfana registrata per strumento).
-    Amount firmato in base-coin: buy=+, sell=-."""
-    books: dict[str, float] = {}
-    orphans: dict[str, float] = {}
-    for sp in sorted(PAPER.glob("*/status.json")):
-        st = json.loads(sp.read_text())
-        wid = sp.parent.name
-        parts = wid.split("__")
-        if st.get("real_in_position"):
-            if "real_amount_a" in st and st.get("real_amount_a"):
-                # pairs: asset da worker_id (…__ETH_BTC__1h)
-                a, b = parts[1].split("_")
-                for asset, side, amt in ((a, st["real_side_a"], st["real_amount_a"]),
-                                         (b, st["real_side_b"], st["real_amount_b"])):
-                    sgn = 1 if side == "buy" else -1
-                    books[_inst(asset)] = books.get(_inst(asset), 0.0) + sgn * amt
-            elif st.get("real_amount"):
-                # single-leg: fade/DIP01/SH01
-                sgn = 1 if st.get("real_side") == "buy" else -1
-                books[_inst(parts[1])] = books.get(_inst(parts[1]), 0.0) + sgn * st["real_amount"]
-        for o in st.get("orphan_legs", []):
-            # gamba che il libro ha chiuso ma il conto ha ancora (entry_side = verso
-            # in cui la posizione e' rimasta aperta sul conto)
-            sgn = 1 if o.get("entry_side") == "buy" else -1
-            orphans[o["instrument"]] = orphans.get(o["instrument"], 0.0) + sgn * float(o["amount"])
-    return books, orphans
-
-
-def account_positions(client: CerberoClient) -> dict[str, float]:
-    """Posizioni reali per strumento, amount firmato in base-coin."""
-    out: dict[str, float] = {}
-    for p in client.get_positions(currency="USDC") or []:
-        inst = p.get("instrument")
-        size = float(p.get("size") or 0)
-        mark = float(p.get("mark_price") or 0)
-        if not inst or not size or not mark:
-            continue
-        amt = size / mark
-        out[inst] = amt if p.get("direction") == "long" else -amt
-    return out
-
-
-def compute_drift() -> list[dict]:
-    client = CerberoClient()
-    books, orphans = expected_books()
-    acct = account_positions(client)
+def compute_drift(client: CerberoClient | None = None) -> list[dict]:
+    client = client or CerberoClient()
+    books, orphans = real_books()
+    acct = account_net(client)
     rows = []
     for inst in sorted(set(books) | set(orphans) | set(acct)):
         exp = books.get(inst, 0.0) + orphans.get(inst, 0.0)