From 12625b331571cd4ee7925b877d7b617f78961eb9 Mon Sep 17 00:00:00 2001 From: Adriano Dal Pastro Date: Thu, 11 Jun 2026 19:32:24 +0000 Subject: [PATCH] =?UTF-8?q?feat(exec):=20gate=20TP=5FPHANTOM=20=E2=80=94?= =?UTF-8?q?=20il=20tocco=20TP=20va=20confermato=20dal=20book=20reale,=20no?= =?UTF-8?q?n=20dal=20feed?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Il feed testnet stampa wick che 'toccano' il TP intrabar senza che il prezzo abbia mai scambiato al livello: il sim bookava +4% fantasma a bars_held=0 e _real_close chiudeva A MERCATO una posizione col resting TP a zero fill (-fee/spread a giro, 14 giri l'11-06). Ora StrategyWorker._tp_phantom sopprime l'exit take_profit quando: tocco sim + resting LIMIT zero-fill + prezzo corrente che non ha raggiunto il livello (il limit sul book reale e' l'oracolo del tocco). Zero parametri (verita' d'esecuzione, non filtro di strategia); SL close-confirm e max_bars restano attivi nello stesso tick; fill parziale/prezzo oltre il livello/worker non eseguito/errore rete -> comportamento storico. Log TP_PHANTOM dedup per barra + alert Telegram una tantum. 5 test nuovi (104 passed). Co-Authored-By: Claude Fable 5 --- CLAUDE.md | 12 ++++ docs/TODO.md | 11 +-- src/live/strategy_worker.py | 45 +++++++++++-- tests/portfolio/test_tp_phantom.py | 104 +++++++++++++++++++++++++++++ 4 files changed, 163 insertions(+), 9 deletions(-) create mode 100644 tests/portfolio/test_tp_phantom.py diff --git a/CLAUDE.md b/CLAUDE.md index 623191e..e99b3c1 100644 --- a/CLAUDE.md +++ b/CLAUDE.md @@ -451,6 +451,18 @@ queste fade, ma va confermato col paper trader live prima di rischiare capitale di parità della stessa tornata (v1.1.3): TR01 fee×leva + forming-bar TR01/Pairs + WARN `PANEL_SHORT` su TSM01/ROT02; `hourly_report` ora mostra i multi-asset (sezione MULTI-ASSET). Diario `docs/diary/2026-06-07-sweep-fixes.md`. +- **TP_PHANTOM — il tocco TP va confermato dal book reale (v1.1.23, 2026-06-11).** Il feed + testnet stampa wick anomali che (a) generano segnali fade su ETH e (b) "toccano" il TP + intrabar della stessa barra: il sim bookava +4% fantasma a bars_held=0 e `_real_close` + chiudeva A MERCATO una posizione il cui resting TP non aveva mai fillato (−fee/spread a + giro, 14 giri l'11-06, report Telegram 26/0 vs reale 11/15 — fix conteggio in v1.1.22). + Gate in `StrategyWorker._tp_phantom` (zero parametri, verita' d'esecuzione, NON un filtro + di strategia): tocco sim + **resting LIMIT a zero fill** + prezzo corrente che non ha + raggiunto il livello → exit SOPPRESSA (il limit sul book reale e' l'oracolo: se il prezzo + avesse scambiato li', avrebbe fillato); SL close-confirm e max_bars restano attivi. + Fill (anche parziale) o prezzo oltre il livello o worker non eseguito → comportamento + storico. Fail-open su errori di rete. Log `TP_PHANTOM` dedup per barra + alert Telegram. + Test `tests/portfolio/test_tp_phantom.py`. - **TP reale = LIMIT reduce-only AL LIVELLO (2026-06-04).** Misurati +235 bps di slippage medio sulle uscite take-profit market-on-poll (sim esce al livello intrabar, il reale chiudeva al poll post-rimbalzo: sim +11.85 vs reale +0.62 USD sui primi 7 close). Fix: a ogni `REAL_OPEN` il worker piazza un **limit reduce-only al TP** (`ExecutionClient.place_tp_limit`, prezzo quantizzato al tick, SOLA quota del worker) → `REAL_TP_RESTING`; a ogni chiusura sim `_real_close` **cancella il resting → riconcilia i fill (anche parziali) via `get_trade_history` per order_id → market reduce-only solo del residuo** → ledger su prezzo combinato. `real_tp_order_id` persistito in `status.json` (resume-safe). Lo **SL resta market-on-poll** (deliberato: i trigger Deribit generano un nuovo order_id al trigger → fill non verificabile per order_id; e sul SL il rimbalzo lavora a favore). Fill da resting = fee **maker ~0%**. Smoke: `live_shadow_smoke.py` (2 scenari, testnet). Diario `docs/diary/2026-06-04-shadow-divergence.md`. - **position_size per-famiglia (2026-06-07).** `portfolios.yml` accetta `position_size_family` (chiave = `weighting.family_of`); plumbing `runner.pos_for_spec`. **PAIRS a 0.20** (esposizione diff --git a/docs/TODO.md b/docs/TODO.md index 18b61cc..0bbc209 100644 --- a/docs/TODO.md +++ b/docs/TODO.md @@ -71,11 +71,12 @@ z-score estremo) e (b) "toccano" il TP intrabar della stessa barra → il sim booka +4% fantasma a bars_held=0, il reale apre+chiude pagando solo fee/spread (~−0.17€ a giro, 14 giri oggi ≈ −2.3€). Il real-truth ledger contabilizza GIUSTO (per questo - esiste) e il report orario ora conta i win dal flag reale. NON aggiungere filtri - anti-spike ai segnali (= fit su un artefatto del testnet, divergenza dal backtest); - su feed mainnet il fenomeno non esiste. Osservare la frequenza: se il churn cresce, - valutare un gate di QUALITÀ FEED a monte (validazione barre nel data layer, non - nella strategia). + esiste) e il report orario ora conta i win dal flag reale. MITIGATO in v1.1.23: + gate `TP_PHANTOM` (il tocco TP deve essere confermato dal fill del resting sul book + reale, o dal prezzo oltre il livello) → niente più chiusure a mercato su wick + fantasma. Resta l'ENTRY spike-driven (il segnale stesso nasce dal wick): NON + filtrarlo nei segnali (= fit su artefatto testnet); osservare la frequenza dei log + TP_PHANTOM — se cresce, valutare un gate di QUALITÀ FEED nel data layer. - [ ] **FADE in coda storica (2026-06-11)**: il rolling 120g equal-weight delle 6 fade è al **2° percentile** della propria storia (−1.0% vs p5 +0.4%); il PORT06 complessivo resta diff --git a/src/live/strategy_worker.py b/src/live/strategy_worker.py index a49f3bf..34861c7 100644 --- a/src/live/strategy_worker.py +++ b/src/live/strategy_worker.py @@ -71,6 +71,8 @@ class StrategyWorker: self.real_dsl_order_id = "" # STOP_MARKET disaster bracket on-book (persistito) self.real_trades = 0 self.real_first_notified = False # alert Telegram "esecuzione viva" una tantum + self._tp_phantom_ts = 0 # dedup log TP_PHANTOM per barra (non persistito) + self._tp_phantom_notified = False # alert Telegram una tantum per processo self.worker_id = f"{strategy.name}__{asset}__{tf}" self.work_dir = data_dir / self.worker_id @@ -448,6 +450,41 @@ class StrategyWorker: # applied: fill reali presenti (parts) o chiusura comunque verificata return real_pnl, bool(parts) or verified + def _tp_phantom(self, current_price: float, current_ts: int) -> bool: + """TP "toccato" solo nel feed? Il LIMIT resting sul book REALE e' l'oracolo: + se il prezzo avesse davvero scambiato al livello si sarebbe fillato (almeno + in parte). Tocco sim + resting a zero fill + prezzo corrente che NON ha + raggiunto il TP = spike-print del feed (testnet, 2026-06-11: 14 giri fantasma + su ETH, sim +4% l'uno, reale −fee/spread l'uno) → exit SOPPRESSA, la posizione + continua il suo ciclo normale (SL close-confirm e max_bars restano attivi). + Zero parametri: e' un check di verita' d'esecuzione, non un filtro di + strategia; sui worker senza esecuzione reale ritorna False (parita' storica). + Fail-open: se la query fill fallisce (rete) si chiude come prima.""" + if not (self.execution_enabled and self.real_in_position + and self.real_tp_order_id and self.tp): + return False + # prezzo gia' oltre il livello → tocco genuino anche senza fill (gap fra poll) + if (self.direction == 1 and current_price >= self.tp) or \ + (self.direction == -1 and current_price <= self.tp): + return False + try: + tp_amt, _, _ = self.executor.resting_fills(self.exec_instrument, + self.real_tp_order_id) + except Exception: + return False + if tp_amt > 0: + return False + if current_ts != self._tp_phantom_ts: + self._tp_phantom_ts = current_ts + data = {"tp": self.tp, "price": current_price, "direction": self.direction, + "tp_order_id": self.real_tp_order_id, + "note": "wick solo nel feed (resting zero-fill, prezzo lontano dal livello) -> exit soppressa"} + self._log("TP_PHANTOM", data) + if not self._tp_phantom_notified: + self._tp_phantom_notified = True + self._notify("TP_PHANTOM", data) + return True + def _close_position(self, current_price: float, reason: str): if not self.in_position: return @@ -549,14 +586,14 @@ class StrategyWorker: if not np.isfinite(buf): buf = 0.0 if self.direction == 1: - if bar_high >= self.tp: + if bar_high >= self.tp and not self._tp_phantom(current_price, current_ts): self._close_position(self.tp, "take_profit") elif confirm_close < self.sl - buf: self._close_position(current_price, "stop_loss") elif self.max_bars and self.bars_held >= self.max_bars: self._close_position(current_price, "time_limit") else: - if bar_low <= self.tp: + if bar_low <= self.tp and not self._tp_phantom(current_price, current_ts): self._close_position(self.tp, "take_profit") elif confirm_close > self.sl + buf: self._close_position(current_price, "stop_loss") @@ -568,14 +605,14 @@ class StrategyWorker: if self.direction == 1: if bar_low <= self.sl: self._close_position(self.sl, "stop_loss") - elif bar_high >= self.tp: + elif bar_high >= self.tp and not self._tp_phantom(current_price, current_ts): self._close_position(self.tp, "take_profit") elif self.max_bars and self.bars_held >= self.max_bars: self._close_position(current_price, "time_limit") else: if bar_high >= self.sl: self._close_position(self.sl, "stop_loss") - elif bar_low <= self.tp: + elif bar_low <= self.tp and not self._tp_phantom(current_price, current_ts): self._close_position(self.tp, "take_profit") elif self.max_bars and self.bars_held >= self.max_bars: self._close_position(current_price, "time_limit") diff --git a/tests/portfolio/test_tp_phantom.py b/tests/portfolio/test_tp_phantom.py new file mode 100644 index 0000000..cab58db --- /dev/null +++ b/tests/portfolio/test_tp_phantom.py @@ -0,0 +1,104 @@ +"""TP_PHANTOM (2026-06-11): il tocco TP che esiste solo nel feed (spike-print testnet) +NON deve chiudere — il LIMIT resting sul book reale e' l'oracolo: zero fill + prezzo +lontano dal livello = wick fantasma -> exit soppressa. Con fill reale (anche parziale), +o prezzo realmente oltre il livello, o worker senza esecuzione -> comportamento storico.""" +import pandas as pd + +from src.live.strategy_worker import StrategyWorker +from src.live.strategy_loader import load_strategy + + +def _df(last_high, last_low, n=120, price=100.0): + c = [price] * n + h = [price] * n + l = [price] * n + h[-1] = last_high + l[-1] = last_low + ts = (pd.date_range("2024-01-01", periods=n, freq="1h", tz="UTC").astype("int64") // 10**6) + return pd.DataFrame({"timestamp": ts, "open": c, "high": h, "low": l, "close": c, "volume": 1.0}) + + +class _FakeExecutor: + """Solo cio' che serve al gate + alla _real_close di un eventuale exit.""" + def __init__(self, tp_filled_amount=0.0): + self.tp_filled_amount = tp_filled_amount + self.verify_polls = 1 + self.verify_sleep = 0.0 + + def resting_fills(self, instrument, order_id): + return self.tp_filled_amount, 102.0 if self.tp_filled_amount else None, 0.0 + + def cancel_order(self, order_id): + return {"state": "cancelled"} + + def close_amount(self, instrument, side, amount, label=""): + class F: + verified = True + amount = 0.01 + fill_price = 100.0 + fee_usd = 0.01 + order_id = "X" + return F() + + +def _long_worker(tmp, executor=None): + w = StrategyWorker(strategy=load_strategy("MR01_bollinger_fade"), asset="BTC", tf="1h", + capital=1000.0, data_dir=tmp, + executor=executor, + exec_instrument="BTC_USDC-PERPETUAL" if executor else None) + w._notify = lambda *a, **k: None + w.in_position = True + w.direction = 1 + w.entry_price = 100.0 + w.tp = 102.0 + w.sl = 98.0 + w.max_bars = 24 + w.bars_held = 1 + w.last_bar_ts = 0 + if executor: + w.real_in_position = True + w.real_side = "buy" + w.real_amount = 0.01 + w.real_entry_price = 100.0 + w.real_entry_notional = 1.0 + w.real_tp_order_id = "TP-1" + return w + + +def test_phantom_touch_suppressed(tmp_path): + # wick a 102.5 nel feed, resting zero-fill, close 100 lontano dal TP -> NON chiude + w = _long_worker(tmp_path, executor=_FakeExecutor(tp_filled_amount=0.0)) + w.tick(_df(last_high=102.5, last_low=99.5)) + assert w.in_position + assert w.real_in_position + + +def test_real_fill_closes(tmp_path): + # stesso wick ma il resting HA fillato -> tocco reale -> chiude + w = _long_worker(tmp_path, executor=_FakeExecutor(tp_filled_amount=0.01)) + w.tick(_df(last_high=102.5, last_low=99.5)) + assert not w.in_position + + +def test_price_beyond_tp_closes_without_fill(tmp_path): + # close corrente OLTRE il TP (gap fra poll): tocco genuino anche a zero fill + w = _long_worker(tmp_path, executor=_FakeExecutor(tp_filled_amount=0.0)) + df = _df(last_high=103.0, last_low=99.5) + df.loc[df.index[-1], "close"] = 102.6 + w.tick(df) + assert not w.in_position + + +def test_no_executor_keeps_legacy_behavior(tmp_path): + # worker senza esecuzione reale: il gate non si applica (parita' storica) + w = _long_worker(tmp_path, executor=None) + w.tick(_df(last_high=102.5, last_low=99.5)) + assert not w.in_position + + +def test_phantom_does_not_block_other_exits(tmp_path): + # tocco TP fantasma E max_bars raggiunto nello stesso tick -> esce a time_limit + w = _long_worker(tmp_path, executor=_FakeExecutor(tp_filled_amount=0.0)) + w.bars_held = 24 + w.tick(_df(last_high=102.5, last_low=99.5)) + assert not w.in_position