revisione 02/09: il rotolante si CONTROLLA ogni ora (non "si ri-ancora"), TWR con limiti dichiarati e tre stati

Quattro segnalazioni della revisione sui commit di oggi, tutte verificate e riparate.

1. book_execute.py (+ CLAUDE.md §5.7, memoria 40): «il disaster-SL rotolante si ri-ancora ogni
   ora» era falso — ensure_disaster_sl lascia il bracket finche' lo stop e' entro il 5% e la
   taglia entro il 10%; il giro orario CONTROLLA, ri-ancora oltre la tolleranza (mark
   +5,263%/-4,762%). Lo stop siede fra -26,3% e -33,3% dal mark corrente.
2. journal.rendimento_twr: limite dichiarato (D5) — l'intervallo che contiene un movimento
   certo esce intero dal rendimento, il suo P&L di mercato va in `certi`; errore massimo meta'
   del movimento per costruzione (25/08: ~$0,5). Non si stima (P12). Segmenti a lunghezza zero
   non prodotti; nessun tempo a mercato -> 0,0 dichiarato numero.
3. base di equity zero: `twr` E `trading` None con motivo (il salto 0->X e' invisibile al
   classificatore, `trading` valeva l'intero conto); il report stampa n/d.
4. test_book_cadenza: la guardia estrae ogni prescrizione «ogni/every N unita'» e pretende 60
   minuti, con controllo positivo (M15); limite P13 dichiarato.

Test +5 (847 verdi). Diari 02/09 e 02/09b con la sezione "Revisione".

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

tests/test_book_cadenza.py

@@ -68,10 +68,41 @@ def _cron_installato() -> str | None:
 
 
 # ---------------------------------------------------------------- regressione sul docstring
+# La guardia non cerca due letterali («ogni ~230»): estrae OGNI prescrizione di cadenza scritta
+# come «ogni/every N unita'» e pretende che valga 60 minuti. ⚠️ Limite dichiarato (P13): una
+# guardia sui numeri non copre il ragionamento — una prosa che prescrive una cadenza senza la
+# parola «ogni» passa. Il controllo positivo qui sotto dice cosa la guardia VEDE.
 
-def test_il_docstring_non_prescrive_piu_i_230_minuti():
+_NUMERI = {"un": 1, "una": 1, "due": 2, "tre": 3, "quattro": 4, "sei": 6, "otto": 8, "dodici": 12}
+_RX_CADENZA = re.compile(
+    r"\b(?:ogni|every)\s*~?\s*(\d+|un'?|una|due|tre|quattro|sei|otto|dodici)?\s*'?\s*"
+    r"(minuti|minuto|minutes?|min|m|ore|ora|hours?|h)\b", re.I)
+
+
+def prescrizioni_minuti(testo: str) -> list[int]:
+    """Ogni «ogni N unita'» del testo, in minuti. «ogni ora» -> 60, «ogni ~230 minuti» -> 230."""
+    out = []
+    for m in _RX_CADENZA.finditer(testo):
+        n_raw, unita = m.group(1), m.group(2).lower()
+        n = 1 if n_raw is None else (int(n_raw) if n_raw.isdigit() else _NUMERI[n_raw.rstrip("'")])
+        out.append(n * (60 if unita.startswith(("or", "h")) else 1))
+    return out
+
+
+def test_la_guardia_vede_le_prescrizioni_che_deve_vedere():
+    # controllo positivo (M15): i modi in cui il docstring potrebbe ri-prescrivere la riga 4h
+    assert prescrizioni_minuti("va lanciato ogni ~230 minuti con la feed") == [230]
+    assert prescrizioni_minuti("il giro va lanciato ogni quattro ore") == [240]
+    assert prescrizioni_minuti("every 4 hours, then every 230 min") == [240, 230]
+    assert prescrizioni_minuti("controllato ogni ora; ogni 60 minuti") == [60, 60]
+    assert prescrizioni_minuti("fino a 230m di latenza") == []      # non e' una prescrizione
+
+
+def test_il_docstring_prescrive_solo_la_cadenza_oraria():
     d = _docstring()
-    assert "ogni ~230" not in d and "ogni 230" not in d
+    p = prescrizioni_minuti(d)
+    assert p, "il docstring deve contenere almeno una prescrizione di cadenza"
+    assert all(x == 60 for x in p), f"prescrizioni non orarie nel docstring: {p}"
     assert re.search(r"CADENZA:\s*ORARIA", d), "il docstring deve dichiarare la cadenza ORARIA"
 
 

tests/test_journal.py

@@ -568,3 +568,36 @@ def test_twr_riproduce_il_numero_del_diario_01_09(db, monkeypatch):
     r = J.rendimento_twr(db, "2026-09-01T23:59:59+00:00")
     assert round(100 * r["twr"], 2) == 10.80
     assert r["certi"] == pytest.approx(1399.39)
+
+
+def test_twr_a_base_zero_e_None_anche_sul_trading(db, monkeypatch):
+    # revisione 02/09: a base zero `movimenti_capitale` non vede il salto 0 -> X del primo
+    # versamento, quindi `trading = e1-e0-certi` varrebbe l'intero conto. Tre stati, non due.
+    monkeypatch.setattr(J, "_px_1h", lambda a: _px_piatto())
+    _serie_equity(db, [("2026-08-24T09:47:01+00:00", 0.0),
+                       ("2026-08-24T10:47:01+00:00", 598.06),
+                       ("2026-08-25T10:47:01+00:00", 610.0)])
+    r = J.rendimento_twr(db, "2026-08-25T23:59:59+00:00")
+    assert r["twr"] is None and r["trading"] is None and "base" in r["motivo"]
+
+
+def test_twr_due_movimenti_consecutivi_non_producono_segmenti_a_lunghezza_zero(db, monkeypatch):
+    monkeypatch.setattr(J, "_px_1h", lambda a: _px_piatto())
+    _serie_equity(db, [("2026-08-24T10:47:01+00:00", 600.0),
+                       ("2026-08-24T11:47:01+00:00", 2000.0),      # movimento nel PRIMO intervallo
+                       ("2026-08-24T12:47:01+00:00", 3400.0),      # movimento consecutivo
+                       ("2026-08-25T10:47:01+00:00", 3434.0)])     # +1% di trading
+    r = J.rendimento_twr(db, "2026-08-25T23:59:59+00:00")
+    assert len(r["segmenti"]) == 1 and r["segmenti"][0]["ret"] == pytest.approx(0.01)
+    assert r["twr"] == pytest.approx(0.01)
+    assert all(s["da"] != s["a"] for s in r["segmenti"])
+    assert r["certi"] == pytest.approx(1400.0 + 1400.0)
+
+
+def test_twr_senza_tempo_a_mercato_e_zero_non_None(db, monkeypatch):
+    # due letture, la seconda e' un versamento: nessun segmento, rendimento 0, dichiarato numero
+    monkeypatch.setattr(J, "_px_1h", lambda a: _px_piatto())
+    _serie_equity(db, [("2026-08-24T10:47:01+00:00", 600.0),
+                       ("2026-08-24T11:47:01+00:00", 2000.0)])
+    r = J.rendimento_twr(db, "2026-08-25T23:59:59+00:00")
+    assert r["twr"] == 0.0 and r["segmenti"] == [] and r["trading"] == pytest.approx(0.0)

tests/test_trades_report.py

@@ -66,3 +66,17 @@ def test_il_report_senza_movimenti_dice_lo_stesso_numero_di_prima(monkeypatch, c
     _carica_script().report()
     out = capsys.readouterr().out
     assert "TWR                : +5.00%" in out and "movimenti capitale" not in out
+
+
+def test_il_report_a_base_zero_dice_n_d_e_non_l_intero_conto(monkeypatch, capsys):
+    monkeypatch.setattr(J, "_px_1h", lambda a: _px_piatto())
+    con = T.connect()
+    _prepara(con, [("2026-08-24T09:47:01+00:00", 0.0),
+                   ("2026-08-24T10:47:01+00:00", 598.06),
+                   ("2026-08-25T10:47:01+00:00", 610.0)])
+    con.close()
+    _carica_script().report()
+    out = capsys.readouterr().out
+    assert "trading da arming  : n/d" in out and "TWR                : n/d" in out
+    assert "trading da arming  : +610.00" not in out        # l'intero conto NON e' "trading"
+    assert "(+610.00 di equity, movimenti di capitale INCLUSI)" in out   # il fatto resta, etichettato