feat(live): worker con exit TP/SL/max_bars per MR01 + doc aggiornata

StrategyWorker ora supporta exit guidati dalla strategia via Signal.metadata
(take-profit alla media / stop-loss ad ATR / time-limit), con fallback al
vecchio hold_bars/stop -2% per strategie senza metadata. Usa fee_rt della
strategia (MR01 = 0.10% RT reale Deribit, non piu' 0.20% hardcoded).
Persistenza di tp/sl/max_bars in status.json per resume.

Re-validato col worker reale (replay finestre mobili 1h, fee 0.10%):
  BTC 1h MR01: +196% OOS, ETH 1h: +251% OOS (nov 2023->mag 2026) — coerente col backtest.

README + CLAUDE.md riscritti: squeeze = artefatto di look-ahead -> waste,
MR01 mean-reversion unica attiva, metodologia anti-look-ahead e fee reali 0.10% RT.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

src/live/strategy_worker.py

@@ -55,6 +55,13 @@ class StrategyWorker:
         self.started_at = datetime.now(timezone.utc).isoformat()
         self.last_bar_ts: int = 0
 
+        # Exit guidati dalla strategia via Signal.metadata (0 = usa hold_bars/stop legacy)
+        self.tp: float = 0.0
+        self.sl: float = 0.0
+        self.max_bars: int = 0
+        # Fee dalla strategia (MR01 = 0.001 realistico Deribit), fallback al default modulo
+        self.fee_rt: float = float(getattr(strategy, "fee_rt", FEE_RT))
+
         self._load_state()
         self._save_state()
 
@@ -78,6 +85,9 @@ class StrategyWorker:
         self.total_wins = state.get("total_wins", 0)
         self.started_at = state.get("started_at", self.started_at)
         self.last_bar_ts = state.get("last_bar_ts", 0)
+        self.tp = state.get("tp", 0.0)
+        self.sl = state.get("sl", 0.0)
+        self.max_bars = state.get("max_bars", 0)
 
         self._log("RESUME", {"capital": round(self.capital, 2),
                               "total_trades": self.total_trades,
@@ -95,6 +105,9 @@ class StrategyWorker:
             "total_wins": self.total_wins,
             "started_at": self.started_at,
             "last_bar_ts": self.last_bar_ts,
+            "tp": self.tp,
+            "sl": self.sl,
+            "max_bars": self.max_bars,
             "last_update": datetime.now(timezone.utc).isoformat(),
         }
         with open(self.status_path, "w") as f:
@@ -125,12 +138,19 @@ class StrategyWorker:
         self.entry_time = datetime.now(timezone.utc).isoformat()
         self.bars_held = 0
 
+        meta = signal.metadata or {}
+        self.tp = float(meta.get("tp", 0.0) or 0.0)
+        self.sl = float(meta.get("sl", 0.0) or 0.0)
+        self.max_bars = int(meta.get("max_bars", 0) or 0)
+
         trade_data = {
             "direction": "long" if signal.direction == 1 else "short",
             "price": round(current_price, 2),
             "size": round(size, 6),
             "notional": round(notional, 2),
             "capital": round(self.capital, 2),
+            "tp": round(self.tp, 2) if self.tp else None,
+            "sl": round(self.sl, 2) if self.sl else None,
         }
         self._log("OPEN", trade_data)
         self._notify("OPENED", trade_data)
@@ -141,7 +161,7 @@ class StrategyWorker:
 
         price_change = (current_price - self.entry_price) / self.entry_price
         trade_return = price_change * self.direction
-        net = trade_return * self.leverage - FEE_RT * self.leverage
+        net = trade_return * self.leverage - self.fee_rt * self.leverage
         pnl = self.capital * self.position_size * net
 
         is_win = trade_return > 0
@@ -174,6 +194,9 @@ class StrategyWorker:
         self.entry_price = 0
         self.entry_time = ""
         self.bars_held = 0
+        self.tp = 0.0
+        self.sl = 0.0
+        self.max_bars = 0
 
     def tick(self, df: pd.DataFrame, df_1h: pd.DataFrame | None = None):
         """Chiamato ad ogni poll con DataFrame OHLCV aggiornato.
@@ -195,7 +218,23 @@ class StrategyWorker:
                 self.bars_held += 1
                 self.last_bar_ts = current_ts
 
-            if self.bars_held >= self.hold_bars:
+            if self.tp and self.sl:
+                # Exit guidati dalla strategia: SL (conservativo, prima), poi TP, poi time-limit
+                if self.direction == 1:
+                    if current_price <= self.sl:
+                        self._close_position(current_price, "stop_loss")
+                    elif current_price >= self.tp:
+                        self._close_position(current_price, "take_profit")
+                    elif self.max_bars and self.bars_held >= self.max_bars:
+                        self._close_position(current_price, "time_limit")
+                else:
+                    if current_price >= self.sl:
+                        self._close_position(current_price, "stop_loss")
+                    elif current_price <= self.tp:
+                        self._close_position(current_price, "take_profit")
+                    elif self.max_bars and self.bars_held >= self.max_bars:
+                        self._close_position(current_price, "time_limit")
+            elif self.bars_held >= self.hold_bars:
                 self._close_position(current_price, "hold_limit")
             else:
                 pnl_pct = (current_price - self.entry_price) / self.entry_price * self.direction