"""
core/engine.py — Headless Trading-Engine (ohne UI)
====================================================
Hält die core/-Objekte, fährt die Refresh-Loops als Threads und liefert einen
aggregierten Snapshot. Einziges Frontend ist die Web-/Mobile-Oberfläche
(`server.py` + `web/`).
  MT5Data · TradeManager · TrailingManager · WaveRecommender ·
  ElliottAnalyzer · TradersUnionProvider · TradingAgent ·
  DailyLevels · GapAnalyzer

Wichtig: MT5 ist Windows-gebunden → die Engine läuft auf demselben Rechner wie
das MT5-Terminal. Es sollte immer nur EINE Engine-Instanz gegen das Terminal
laufen.
"""
from __future__ import annotations
import threading
import time
from datetime import datetime
from zoneinfo import ZoneInfo

import MetaTrader5 as mt5

from core.config import (
    HISTORY_DB_FILE, MAGIC, load_config, set_margin_buffer, set_risk_per_trade,
    get_margin_buffer as _cfg_margin_buffer,
)
# ⚠ `parse_zones` wurde am 2026-07-31 hier entfernt (letzter Nutzer war `_sr_levels`,
# s. dort): die `[zones]`-Config stammte aus einem ~10 $ tieferen Kursregime und
# lieferte der Wellen-Konfidenz Phantom-Level. Die Funktion bleibt in `core/config.py`
# und die `[zones]`-Sektion in der ini erhalten — reaktivierbar, falls je gewollt.
from core.logger      import get_logger
from core.history     import HistoryLogger
from core.mt5data     import MT5Data
from core.trader      import TradeManager
from core.trailing    import TrailingManager
from core.tu_rating   import TradersUnionProvider
from core.wave_rec    import WaveRecommender
from core.elliott     import ElliottAnalyzer
from core.agent       import TradingAgent
from core.news        import NewsFetcher, NewsTranslator
from core.notify      import send_telegram
from core.mailer      import send_graph_mail
from core.mt5_utils   import mt5_lock
from core.market_hours import session_state
from core.daily_levels import DailyLevels
from core.gaps        import GapAnalyzer
from core.structure   import MarketStructure
from core.patterns    import PatternDetector
from core.candles     import CandleAnatomy
from core.cone        import build as _cone_build
from core.candle_logger import CandleLogger
from core.wave_rec    import (_atr as _wr_atr, _ema_last,
                              _EMA_FAST, _EMA_SLOW, _TREND_DEADBAND, _STRETCH_MAX,
                              # Ausbruchs-Aufschlag der Box — DIESELBE Konstante, die
                              # `_squeeze_one` nutzt. Nachbauen wäre die Sorte Kopie,
                              # die im Projekt schon 4 divergierende Exit-Modelle
                              # erzeugt hat.
                              _SQ_K as _SQ_K_ENG)

log = get_logger("engine")

_ATR_TF_MAP = {"M1": mt5.TIMEFRAME_M1, "M5": mt5.TIMEFRAME_M5,
               "M15": mt5.TIMEFRAME_M15, "M30": mt5.TIMEFRAME_M30,
               "H1": mt5.TIMEFRAME_H1}

# Loop-Intervalle (Sekunden) — entsprechen den *_REFRESH_MS-Werten des Widgets
_PRICE_S      = 0.5
_TREND_S      = 5.0
_POS_S        = 1.0
_TU_S         = 300.0   # TU ist nur noch Snapshot-Anzeige (aus Empfehlung/Verdict/
                        # Copilot entfernt) — 5 min statt 60 s reicht, spart Scrape+Log
_AGENT_WARMUP = 20.0    # erste Beurteilung erst, wenn Daten geladen sind
_CLOSE_ALERT_COOLDOWN_S = 300.0   # CLOSE-Telegram max. 1×/5 min (kein Spam, wenn
                                  # der Kurs ums Signal-Level pendelt)
_MIN_CONF_DISPLAY = 70            # Konfidenz-Schwelle für die "Order ohne Signal"-
                                  # Warnung im Frontend (nur Anzeige-Konstante — war
                                  # bis 2026-07-23 auf dem entfernten Dry-Run-Auto-
                                  # Trader beheimatet, hier als eigener Wert erhalten)
_BERLIN = ZoneInfo("Europe/Berlin")
_OB_IMB_MIN = 0.30   # Orderbuch-Imbalance darunter = zu schwach fuer eine Stimme
_PAT_W = 0.25        # Verdict-Gewicht der Chartmuster-Stimme (bestaetigt; `forming`
                     # zaehlt halb). User-Vorgabe 2026-08-01 „5 %" — empirisch aus den
                     # letzten 4.000 `verdict_votes`: Median der uebrigen Gewichte 4,50
                     # → 0,25/(4,50+0,25) = 5,3 % Anteil an der Bias-Nadel (vorher 1,0
                     # = 18,2 %). Begruendung + Beleglage bei der Stimme in `_verdict`.
_SQUEEZE_NIGHT = (0, 1, 2, 3, 4, 5, 6, 7)   # STATISTISCHE Nacht-Definition
# ⚠ `_SQUEEZE_NIGHT` ist NICHT mehr das Entry-Gate — es bleibt die Definition von
# „Nacht" für die Entry-Checkliste (dort gilt die Kostenfalle: über ALLE Nacht-Bars
# 0,333×ATR) und für den Tag/Nacht-Split im B4-Monitor (damit der Vergleich mit den
# Altdaten stabil bleibt). Welche Stunden der Auto-Squeeze wirklich AUSSETZT, steht
# in `[trading] auto_squeeze_night_hours` (s. `_squeeze_night_hours`).
_SQUEEZE_NIGHT_DEFAULT = "3,4,5,6"   # gemessen günstigstes ≥4-h-Fenster, s. u.
_SQUEEZE_SR_COOLDOWN_S = 180.0   # nach S/R-Close kein Auto-Squeeze in GLEICHER Richtung
                                 # (sonst Close-„Level hält" vs. Entry-„Level bricht"-
                                 # Roundtrip in 1 s; 2026-07-17)
_SQUEEZE_REENTRY_COOLDOWN_S = 180.0  # nach JEDEM Close eines Trades (Notfall/SL/Time-Stop/
                                 # manuell) kein Gleichrichtungs-Squeeze-Wiedereinstieg —
                                 # gegen die Open→Instant-Close-Kaskade bei zu engem Stop
                                 # (real 2026-07-27 15:39: −3-€-Stop killte Entry #1 in 16 s,
                                 # Squeeze noch aktiv → sofortiger Re-Entry; 2026-07-28)
_TICK_STALE_S = 180        # kein Tick seit X s → Markt gilt als geschlossen.
                           # Absichtlich tick-basiert statt kalenderbasiert: deckt
                           # Wochenende, Feiertage UND Broker-Ausfall mit einer Regel.
_TRADE_MARKS = 6            # so viele letzte Trades im MQL5-Chart markieren
                            # (Kerze umranden: Eröffnung hellgrün, Close dunkelgrün)
_STARTUP_GRACE_S = 60.0          # nach Bot-Start schließt der Bot 60 s lang KEINEN
                                 # laufenden Trade server-seitig (S/R-Close/Notfall/
                                 # Time-Stop/Reverse) — die Daten (Preis/ATR/P(break)/
                                 # Level) stabilisieren sich erst; verhindert den
                                 # Sofort-Close direkt nach restart_server.bat.
                                 # Broker-SL bleibt unberührt (läuft am Broker).

# ── Kalibriertes P(Durchbruch)-Modell (logistische Regression, auf H1 trainiert,
# auf H2 KALIBRIERT geprüft: AUC 0,71, predicted≈echt; `analyze_srwaves.py`).
# Merkmale (in Positionsrichtung): [mom6, mom3, mit-Trend(0/1), Level-Distanz/ATR].
# Standardisierung (mu/sd) + Gewichte (intercept + 4) aus `backtest_srclose_prob.py`.
# P(break)-Modell — auf **M30-Level** trainiert (Umstellung 2026-07-30, gemessen
# `backtest_level_tf.py`): M30-Pivots schlagen die alten M5-Pivots in BEIDEN Hälften
# (AUC out-of-sample 0,721 vs 0,710 · R-Ertrag der Close-Regel ~2× · Level 1,95 statt
# 0,61×ATR entfernt = die „S/R-Linien kleben aneinander"-Beobachtung des Users).
# Ablauf: out-of-sample validiert (H1→H2), danach auf ALLEN 80k Bars nachtrainiert
# (34.771 Touches, Basisrate 39,4 %, Kalibrierung trifft: 23/25 · 38/36 · 58/59 · 86/87).
# ⚠ Die Merkmale bleiben M5-basiert (mom6/mom3 auf M5-Bars) — nur die LEVEL sind M30.
# Alte M5-Werte (falls je zurück): MU (0.7482,0.7036,0.9112,0.7072) ·
# SD (1.1597,0.9687,0.2844,0.6403) · W (-0.5853,0.1192,0.7820,0.1204,-0.2994).
# ⚠⚠ NEU TRAINIERT 2026-07-31 auf einer LIVE-SPIEGELNDEN Stichprobe
# (`backtest_pbreak_retrain.py` + `backtest_pbreak_rvalue.py`). GRUND: die alten
# Werte waren auf einer Situation trainiert, die live gar nicht vorkommt.
#   Training ALT: Level beim Entry FIXIERT (≥0,3×ATR weg), warten auf den ersten
#                 Touch nach einem echten ANLAUF  →  mom3 ≈ 1,45×ATR (ein Schub)
#   LIVE:         `_draw_levels` wählt das nächste Level JEDE SEKUNDE NEU (Hysterese)
#                 → der Kurs steht neben einem Level, das gerade erst das nächste
#                 wurde, ohne Anlauf  →  mom3 ≈ 0,15×ATR
# Gemessen (aus `candles_m1` rekonstruiert, n=2275): mom3 live 0,149 vs. ALT-µ 1,4523
# (−1,303) · mom6 0,181 vs 1,6565 (−1,476). Der daraus folgende z-Versatz (−1,05)
# erklärt die gesamte Fehlkalibrierung: das Modell sagte live IMMER ~23 % (real 41 %),
# lag damit stets unter der Schwelle → **das Gate war seit Inbetriebnahme nie aktiv**
# (91 % aller Berührungen geschlossen = der 2× verworfene pauschale S/R-Close).
# KONTROLLE auf der live-spiegelnden Stichprobe: ALT erreicht dort **AUC 0,368**
# (schlechter als Zufall!), NEU **0,654** out-of-sample (Fit H1 → H2).
# R-Ertrag (Echtkosten, Baseline = nur Trailing): NEU schlägt ALT in BEIDEN Hälften
# bei JEDER Schwelle; gegen die Baseline gewinnt es bei 0,35/0,45/0,55 in beiden
# (bei 0,60 kippt H1). Bestwert **0,35** (H1 +357, H2 +1418 gegen Baseline) →
# `sr_close_pbreak` entsprechend auf 0,35 gesetzt.
# ⚠ Das Gewicht von mom3 DREHT das Vorzeichen (+1,4330 → −0,5420): im Anlauf-Kontext
# hieß Schwung „Level bricht", im Klebe-am-Level-Kontext heißt er „Level hält".
# Deshalb war ALT live schlechter als eine Münze und nicht bloß nutzlos.
# Final auf allen 80k Bars gefittet (n=76.542 Events, Basisrate 37,8 %), nachdem
# H1→H2 out-of-sample validiert war — gleiches Vorgehen wie beim ersten Modell.
# Alte M30-Anlauf-Werte (Rückweg): MU (1.6565,1.4523,0.9465,1.9133) ·
# SD (2.5291,2.4177,0.2250,2.1257) · W (-0.3264,0.4719,1.4330,0.0943,-0.1885).
_PB_MU = (0.1962, 0.2071, 0.5300, 3.2624)
_PB_SD = (1.3109, 0.9579, 0.4991, 3.5649)
_PB_W  = (-0.5216, 0.0712, -0.5420, 0.0047, 0.0386)   # [b0, mom6, mom3, wt, dist]

def _p_break(mom6: float, mom3: float, wt: float, dist: float) -> float:
    """P(Level-Durchbruch) ∈ (0,1) aus den 4 standardisierten Merkmalen."""
    import math
    feat = (mom6, mom3, wt, dist)
    z = _PB_W[0]
    for k in range(4):
        z += _PB_W[k + 1] * (feat[k] - _PB_MU[k]) / _PB_SD[k]
    return 1.0 / (1.0 + math.exp(-max(-30.0, min(30.0, z))))


class TradingEngine:
    """Headless-Pendant zu OilWidget: hält die core-Objekte, fährt die
    Refresh-Loops als Threads und liefert einen aggregierten Snapshot."""

    def __init__(self, cfg=None):
        self.cfg = cfg or load_config()
        try:
            set_margin_buffer(float(self.cfg["trading"].get("margin_buffer_pct", "90")))
        except Exception as e:
            log.warning(f"Margin-Buffer aus Config: {e}")
        try:
            set_risk_per_trade(float(self.cfg["trading"].get("risk_pct", "1.5")))
        except Exception as e:
            log.warning(f"Risiko/Trade aus Config: {e}")

        # ── History + Telegram ────────────────────────────────────────────
        self.history = HistoryLogger(HISTORY_DB_FILE)
        tg = self.cfg["telegram"]
        self.history.configure_telegram(
            enabled = tg.get("enabled", "false").strip().lower() == "true",
            token   = tg.get("bot_token", "").strip(),
            chat_id = tg.get("chat_id", "").strip(),
        )

        # ── Markt / Trading / Trailing ────────────────────────────────────
        self.data   = MT5Data()
        self.trader = TradeManager()
        self.trader.history = self.history
        self.trail  = TrailingManager(self.trader)
        self.trail.set_notify(self._on_trail_event)
        # (Dry-Run-Auto-Trader entfernt 2026-07-23 — war Verlierer im Backtest,
        # UI-Toggle längst weg. `min_conf`-Anzeigekonstante bleibt, s. unten.)

        # ── Analyse-Module ────────────────────────────────────────────────
        self.tu      = TradersUnionProvider()
        self.wave    = WaveRecommender(self.tu, mt5.TIMEFRAME_M5)
        try:
            self.wave.set_breakout_k(float(self.cfg["trading"].get("breakout_k", "1.0")))
        except (TypeError, ValueError):
            pass
        try:
            self.wave.set_entry_room(float(self.cfg["trading"].get("entry_room_atr", "0.6")))
        except (TypeError, ValueError):
            pass
        # Reversal/Bounce-Setup — Default hier **false** (User-Entscheidung 2026-08-04
        # nach `backtest_reversal_angle.py`: in JEDER Variante beidhälftig negativ, und
        # es hebelt Anti-Überdehnung + M30-Filter aus). Der Modul-Default in `wave_rec`
        # bleibt True, damit die Backtests unverändert bleiben — abgeschaltet wird
        # ausschließlich hier im Live-Pfad. `reversal_enabled=true` holt es zurück.
        self.wave.set_reversal_enabled(
            (self.cfg["trading"].get("reversal_enabled", "false") or "false")
            .strip().lower() == "true")
        # Tageszeit-Gate aus Config (Komma-Liste von Stunden; leer = AUS). Fehlt der
        # Key → gemessener Default (im wave_rec-Konstanten-Set). User-Vorgabe 2026-07-22:
        # ini auf leer → Gate aus, obwohl 12/16 gemessen negativ sind.
        _dh = self.cfg["trading"].get("dead_hours", None)
        if _dh is not None:
            self.wave.set_dead_hours([h.strip() for h in _dh.split(",") if h.strip()])
        self.elliott = ElliottAnalyzer(mt5.TIMEFRAME_M5)
        self.structure = MarketStructure()   # Marktstruktur (M30) — reine Anzeige
        self.patterns  = PatternDetector()   # visuelle Chartmuster (M30) — reine Anzeige
        # Kerzen-Anatomie (M5) — REINE ANZEIGE. Die Lehrbuch-Deutung ist gemessen
        # invertiert (`backtest_candles.py`), das Handelssignal fiel durch
        # (`backtest_candle_fade.py`) → kein Verdict-Gewicht, kein Trigger.
        self.candle_anat = CandleAnatomy("M5")
        # Echte Liquiditäts-Wände vom HL-Orderbuch (Anzeige im MT5-Chart, kein Signal).
        # Braucht das HL-Dashboard auf 8001; ist es aus, bleibt der Chart unverändert.
        from core.hl_walls import HLWalls
        _t2 = self.cfg["trading"]
        self.hl_walls = HLWalls(
            url=_t2.get("hl_walls_url", "http://localhost:8001/api/walls"),
            enabled=_t2.get("export_hl_walls", "true").lower() == "true")
        self.candles = CandleLogger(HISTORY_DB_FILE)   # M1-Candle-Log (Daten-Sammlung)
        # Wirtschaftskalender (Handbuch-Regel „keine Trades vor High-Impact-News").
        # ⚠ NICHT gemessen (Events zu selten für 2-Stichproben) → sperrt nur die
        # AUTONOMEN Entries + warnt in der Checkliste, blockt keine manuelle Order.
        # Der gemessene EIA-Blackout (Mi 15:30–16:30) bleibt unabhängig davon aktiv.
        from core.econ_calendar import EconCalendar
        self.calendar = EconCalendar(
            before_min=int(_t2.get("news_blackout_before_min", "15")),
            after_min =int(_t2.get("news_blackout_after_min", "15")),
            enabled   =_t2.get("news_blackout", "true").lower() == "true")
        # News: eigener Fetch-Loop (versorgt UI /api/news UND Agent-Kontext)
        tcfg = self.cfg["translation"]
        translator = NewsTranslator(
            enabled  = tcfg.get("enabled", "true").lower() == "true",
            target   = tcfg.get("target_language", "de"),
            provider = tcfg.get("provider", "google"),
        )
        self.news = NewsFetcher(translator=translator)
        self._news_refresh_s = max(60, int(self.cfg["news"].get("refresh_min", "10")) * 60)
        self.agent   = TradingAgent(
            self.cfg, data=self.data, trader=self.trader, trail=self.trail,
            tu=self.tu, wave=self.wave, history=self.history,
            news=self.news, elliott=self.elliott, engine=self)
        # Letzte kalibrierte Größen für den Copiloten (2026-08-02). Der Snapshot
        # rechnet sie ohnehin je Zyklus — hier nur festhalten, damit `agent.
        # _tool_market` sie mitgeben kann, OHNE sie ein zweites Mal zu rechnen
        # (derselbe Fehler wie beim Konsens-Pfeil, der ein zweites `_verdict()` zog).
        self._last_sr_close_hint: dict | None = None
        self._last_stop_approach: dict | None = None
        self._last_cone: dict | None = None
        # Tägliche WTI-Intraday-Level per Web-Recherche (z.ai/GLM + web_search).
        # Nur Kontext → S/R + Anzeige, NICHT Handelsrichtung.
        zc = self.cfg["zai"] if self.cfg.has_section("zai") else {}
        self.daily = DailyLevels(zc.get("api_key", ""),
                                 zc.get("base_url", "https://api.z.ai/api/paas/v4"),
                                 zc.get("model", "glm-4.5-flash"))
        self._daily_last_run: str | None = None   # ISO-Datum des letzten Laufs
        self._daily_fails = 0
        self._weekly_last_run = None               # (ISO-Jahr, KW) des letzten B4-Reports
        # Versand-Status überlebt Neustarts — sonst schickt jeder restart_server.bat
        # nach 07:30 den Tages-/Wochenreport ERNEUT (war real: 3× am 07.07.)
        import os as _os
        self._report_state_path = _os.path.join(
            _os.path.dirname(_os.path.dirname(_os.path.abspath(__file__))),
            "report_state.json")
        self._load_report_state()
        # Kurslücken-Analyse (D1): Fill-Level als S/R-Magnete (Kontext/Konfidenz,
        # keine eigene Handelsrichtung). Refresh gedrosselt (~10 min) im Trend-Loop.
        self.gaps = GapAnalyzer(refresh_s=600)

        self.require_token = self.cfg["web"].get("require_token", "true").strip().lower() == "true"
        self._tf_select = self.cfg["trading"].get("tf_select", "heuristic").strip()
        self._tf_min    = self.cfg["trading"].get("tf_min", "M5").strip().upper()
        if self._tf_min not in _ATR_TF_MAP:
            self._tf_min = "M5"
        # Obergrenze der Heuristik-TF (Daytrading: nur M1–M15). M30/H1 bleiben als
        # Kontext (Filter/Konfluenz), werden aber NICHT mehr als Basis-TF gewählt.
        self._tf_max    = self.cfg["trading"].get("tf_max", "H1").strip().upper()
        if self._tf_max not in _ATR_TF_MAP:
            self._tf_max = "H1"
        self._wave_tf_label  = "M5"
        # Mindest-Verweildauer der TF-Heuristik (Fix 2026-07-31, s. `_tf_loop`):
        # verhindert das Hin-und-Her, wenn der Score einer TF im Trend auf 0,0 fällt
        # (Überdehnung) und nach dem Rücksetzer zurückspringt. 0 = aus.
        try:
            self._tf_min_dwell_s = float(self.cfg["trading"].get("tf_min_dwell_s", "900"))
        except (TypeError, ValueError):
            self._tf_min_dwell_s = 900.0
        self._tf_last_switch = 0.0
        self._last_rec: dict = {}
        self._agent_fail_cnt = 0
        self._close_alert_ts = 0.0      # letzter CLOSE-Telegram-Push (5-min-Cooldown)
        self._close_alert_ticket = None # Ticket, auf das sich der Cooldown bezieht
        self._close_alert_count = 0     # wie oft der Flip-Close-Alarm gefeuert hat
        self._auto_sr_close = self.cfg["trading"].get("auto_sr_close", "true").lower() == "true"
        try:
            self._sr_close_pbreak = float(self.cfg["trading"].get("sr_close_pbreak", "0.60"))
        except (TypeError, ValueError):
            self._sr_close_pbreak = 0.60
        self._sr_close_pbreak = max(0.30, min(0.90, self._sr_close_pbreak))  # sinnvolles Band
        self._sr_close_count = 0        # wie oft der Bot am S/R automatisch schloss
        self._sr_close_last_ticket = None   # verhindert Doppel-Auslösung je Ticket
        # Autonomer Entry auf den gemessen-validierten Squeeze-Ausbruch (nur FLAT).
        # ⚠ ECHTE Order — Default AUS (Autonomie nie stillschweigend an). `[trading]
        # auto_squeeze=true` aktiviert. Dedup über (dir, level) des Ausbruchs.
        self._auto_squeeze = self.cfg["trading"].get("auto_squeeze", "false").lower() == "true"
        self._squeeze_skip_night = self.cfg["trading"].get("auto_squeeze_skip_night", "true").lower() == "true"
        # ── WELCHE Stunden ausgesetzt werden (2026-08-05, gemessen `backtest_cost_gate.py`).
        # War fest 0–7. Die Messung zeigt: KEINE Stunde ist in beiden Halbjahren negativ —
        # es gibt keine „toten Stunden". Jedes Fenster kostet also Ertrag; die Sperre kauft
        # ausschließlich Beaufsichtigungs-Ruhe. 3–6 Uhr ist das günstigste Fenster mit noch
        # ≥4 h Schutz: Preis ΣR −12,5/−62,9 R gegen −42,4/−242,6 bei 0–7 (≈ 27 %).
        # Leere Liste = wirkt wie `auto_squeeze_skip_night=false`.
        self._squeeze_night_hours = tuple(
            int(x) for x in str(self.cfg["trading"].get(
                "auto_squeeze_night_hours", _SQUEEZE_NIGHT_DEFAULT)).split(",")
            if x.strip().isdigit() and 0 <= int(x) <= 23)
        # Stop-&-Reverse nur, wenn explizit an (Default aus) — der Reverse ist unbelegt;
        # der flat-Entry bleibt davon unberührt (der validierte Teil).
        self._squeeze_reverse = self.cfg["trading"].get("auto_squeeze_reverse", "false").lower() == "true"
        self._squeeze_last_sig = None      # Dedup Entry (flat)
        # ── Einstieg über RUHENDE Stop-Orders statt Market (2026-08-05, gemessen
        # `backtest_squeeze_entry.py`: der Einstiegspreis IST der Edge). Die Orders
        # liegen, solange der Squeeze `armed` ist, an beiden Box-Grenzen.
        self._squeeze_pending = self.cfg["trading"].get(
            "squeeze_pending_entry", "true").lower() == "true"
        # Market bleibt der Fallback — aber nur, solange der Kurs noch im gemessen
        # positiven Bereich über dem Level steht (0,20×ATR → ØR +0,244/+0,426).
        try:
            self._squeeze_max_chase = float(self.cfg["trading"].get(
                "squeeze_max_chase_atr", "0.20"))
        except (TypeError, ValueError):
            self._squeeze_max_chase = 0.20
        # Signal-Pfad bekommt dieselbe Mechanik (2026-08-05, gemessen
        # `backtest_auto_signal_v3.py`: am Bestätigungs-Level ØR +0,35/+0,32 statt
        # −0,09/−0,11 am Markt — SIG besteht damit ERSTMALS die 2-Stichproben-Regel).
        self._signal_pending = self.cfg["trading"].get(
            "signal_pending_entry", "true").lower() == "true"
        self._pending_levels = None
        self._pending_quelle = ""
        # Welche Pending-Order stammt von welchem Pfad? Bei einem FILL ist die
        # Positions-Nummer identisch mit der Order-Nummer (MT5) — nur so laesst
        # sich die adoptierte Position nachtraeglich dem Bot zuordnen.
        self._pending_tickets: dict[int, str] = {}
        self._pending_tagged: set = set()
        self._squeeze_pending_err = None
        self._squeeze_chase_logged = None
        self._signal_chase_logged = None
        self._squeeze_reverse_sig = None   # Dedup Reverse-Close (Gegen-Trade)
        self._squeeze_entry_count = 0
        # ── Autonomer Entry auf die EMPFEHLUNG (User-Wunsch 2026-07-30) ───────────
        # ⚠ GEMESSEN NICHT tragfähig (H1 negativ, s. backtest_auto_signal.py) — auf
        # ausdrücklichen User-Wunsch gebaut, Default AUS, mit den besten Parametern.
        _t = self.cfg["trading"]
        self._auto_signal = _t.get("auto_signal", "false").lower() == "true"
        try:
            self._auto_signal_min_conf = int(float(_t.get("auto_signal_min_conf", "75")))
        except (TypeError, ValueError):
            self._auto_signal_min_conf = 75
        self._auto_signal_skip_night = _t.get("auto_signal_skip_night", "true").lower() == "true"
        self._signal_last_sig = None       # Dedup: (dir, Signal-Episode) 1× handeln
        self._signal_entry_count = 0
        # 15-Minuten-Regel für BOT-eröffnete Trades (gemessen kalibriert: 0,5×ATR)
        try:
            self._adverse15_atr = max(0.0, float(_t.get("adverse_15min_atr", "0.5")))
        except (TypeError, ValueError):
            self._adverse15_atr = 0.5
        self._bot_open_ticket = None       # Ticket, das der Bot selbst eröffnet hat
        self._bot_open_source = None       # ... und WOMIT (auto_squeeze | auto_signal).
                                           # Nötig, weil die 15-Min-Regel nur für den
                                           # Auto-Signal-Pfad gemessen ist (s. unten).
        self._adverse15_done_ticket = None # 15-Min-Prüfung je Ticket nur 1×
        self._adverse15_count = 0
        self._sr_close_ts = 0.0            # Zeit + Richtung des letzten S/R-Closes
        self._sr_close_dir = None          # → Cooldown gegen Gleichrichtungs-Roundtrip
        self._open_pos_dir = None          # Richtung der aktuell offenen Position (LONG/SHORT)
        self._pos_close_ts = 0.0           # Zeit + Richtung des letzten Positions-Close (JEDE
        self._news_block_logged = None     # Dedup für die News-Blackout-Logzeile
        # Markt-zu-Erkennung über die letzte KURSBEWEGUNG (s. `snapshot`) — die
        # Tick-Zeitstempel taugen dafür nicht (Abholzeit bzw. zirkulärer Offset).
        self._last_bid = None
        self._last_bid_move_ts = 0.0
        # Auto-Flip-Close (User-Wunsch 2026-07-31) — ⚠ GEMESSEN NEGATIV in beiden
        # Hälften (`backtest_flipclose2.py`), s. `_check_flip_close`. Default-Schwelle
        # 0,5×ATR = die mildeste der gemessenen Varianten.
        _tf_cfg = self.cfg["trading"]
        self._flip_close = _tf_cfg.get("auto_flip_close", "false").lower() == "true"
        try:
            self._flip_close_min_r = float(_tf_cfg.get("auto_flip_close_min_r", "0.5"))
        except (TypeError, ValueError):
            self._flip_close_min_r = 0.5
        # Nachrang gegenüber dem S/R-Close (gemessen besser, s. `_check_flip_close`)
        self._flip_close_subordinate = \
            _tf_cfg.get("auto_flip_close_subordinate", "true").lower() == "true"
        self._flip_close_done_ticket = None
        self._flip_close_count = 0
        self._pos_close_dir = None         # Art) → Squeeze-Wiedereinstiegs-Sperre (gegen die
                                           # Open→Instant-Close-Kaskade bei zu engem Notfall-Stop)
        self._sr_close_min_gain_armed_ticket = None  # Ticket, für das die %-Schwelle schon
                                            # aus echter Margin berechnet wurde (Retry-Schutz,
                                            # s. `_check_auto_close`)
        try:
            self._sr_close_min_gain = max(0.0, float(
                self.cfg["trading"].get("sr_close_min_gain", "0")))
        except (TypeError, ValueError):
            self._sr_close_min_gain = 0.0
        # Gewinn-Close automatisch auf X% des Einsatzes (Margin) DIESER Position setzen,
        # sobald sie eröffnet wird (User-Vorgabe 2026-07-23) — überschreibt den manuell
        # gemerkten/persistierten Wert bei jeder ECHT NEUEN Position (nicht beim
        # Wiedererkennen nach Neustart, s. `_check_auto_close`). 0 = aus (dann bleibt der
        # manuell gesetzte/gemerkte Wert wie bisher maßgeblich).
        try:
            self._sr_close_min_gain_pct = max(0.0, float(
                self.cfg["trading"].get("sr_close_min_gain_pct", "1.0")))
        except (TypeError, ValueError):
            self._sr_close_min_gain_pct = 1.0
        self._pb_state = None   # geglättetes P(break) + Hysterese-Zone je Level
        self._stop_pb_state = None   # dito für die Gegen-/Stop-Seiten-Anzeige
                                # (gemessen `analyze_pbreak_flicker.py`: mom3 der
                                # laufenden Kerze ließ P ~7–15 Pp je M5-Bar springen)
        # UI-Einstellungen neustart-fest (Fix 2026-07-19): Toggles/Werte, die über
        # die App gesetzt werden (Auto-Squeeze, S/R-Auto-Close, Mindestgewinn),
        # überschreiben nach dem Laden die ini-Defaults — vorher war z. B. ein am
        # Handy gesetzter Mindestgewinn nach jedem restart_server.bat wieder weg.
        import os as _os2
        self._runtime_state_path = _os2.path.join(
            _os2.path.dirname(_os2.path.dirname(_os2.path.abspath(__file__))),
            "runtime_state.json")
        self._load_runtime_state()
        self._mql5_files_dir = None     # <terminal>\MQL5\Files (lazy, für den Indikator)
        self._export_trade_marks = self.cfg["trading"].get("export_trade_marks", "false").lower() == "true"
        self._export_mql5 = self.cfg["trading"].get("export_mql5_levels", "true").lower() == "true"
        # Kegel im MT5-Chart: per Default AUS, seit die Pfeile ihn ersetzen (2026-07-31).
        self._export_cone = self.cfg["trading"].get("export_cone", "false").lower() == "true"
        # Konsens-Pfeil (AR;K) — Default AUS, spiegelt `InpShowConsensus=false` im
        # Indikator. Bei `true` wird je Export ein zweites `_verdict()` gerechnet.
        self._export_consensus_arrow = self.cfg["trading"].get(
            "export_consensus_arrow", "false").lower() == "true"
        self._draw_last = {"r": None, "s": None}   # letzte gezeichnete S/R (Hysterese)
        try:      # WHT-Quellensteuer (Broker behält % je GEWINN ein) → Netto-Anzeige
            self._wht_pct = max(0.0, float(self.cfg["trading"].get("wht_pct", "0") or 0))
        except (TypeError, ValueError):
            self._wht_pct = 0.0
        self._draw_cache: tuple[float, dict] | None = None   # (ts, result) TTL ~1 s —
        # 4 Aufrufer (Snapshot 2×, pos_loop, CSV, Charts): EIN Ergebnis je Sekunde
        # garantiert identische Linien in Kachel/Chart/Close-Meldung + spart Lock-Last
        self._emergency_loss: float | None = None   # aktiver Notfall-Stop (Verlust)
        self._last_pos_ticket = None                 # für Auto-Arm beim Öffnen
        # Mindest-Notfall-Stop (Kontowährung): ein von Hand gesetzter Wert UNTER
        # diesem Minimum wird als „aus" behandelt statt scharfgestellt — sonst killt
        # ein Vertipper (z. B. „1") jeden Trade sofort, weil die Schwelle unter dem
        # Spread liegt UND per _emergency_remember auf ALLE Folge-Trades vererbt wird
        # (real 2026-07-27: −1-€-Stop schloss Trades in derselben Sekunde). 0 = aus.
        try:
            self._emergency_min = max(0.0, float(self.cfg["trading"].get("emergency_min_eur", "3") or 0))
        except (TypeError, ValueError):
            self._emergency_min = 3.0
        # Beim Öffnen einer neuen Position wird der Notfall-Stop automatisch auf
        # den ZULETZT genutzten Wert gesetzt (gemerkt über Trades hinweg). Start-
        # wert = [trading] auto_emergency_loss (0 = Auto-Arm aus).
        try:
            self._emergency_remember = float(self.cfg["trading"].get("auto_emergency_loss", "10") or 0)
        except (TypeError, ValueError):
            self._emergency_remember = 10.0
        # Auto-Notfall-Stop als % des Kontos (User-Vorgabe 2026-07-15): ist
        # `[trading] auto_emergency_pct` > 0, wird beim Öffnen der Stop auf
        # pct% der Balance gesetzt (skaliert mit dem Konto) STATT auf den
        # gemerkten Fixwert. 0 = aus (Fixwert-Verhalten wie bisher).
        try:
            self._emergency_pct = max(0.0, float(self.cfg["trading"].get("auto_emergency_pct", "0") or 0))
        except (TypeError, ValueError):
            self._emergency_pct = 0.0
        # Notfall-Stop als % der EINSATZ-Margin dieser Position (User-Vorgabe
        # 2026-07-23, `[trading] auto_emergency_margin_pct=3.0`) — dritter, margin-
        # basierter Modus, hat Vorrang vor dem Balance-%-Modus (`_emergency_pct`)
        # und dem Fixwert, wenn >0. Retry-sicher wie `_sr_close_min_gain_pct`
        # armiert (s. `_check_auto_close`): `order_calc_margin` kann im ersten Tick
        # nach dem Öffnen noch 0 liefern. ⚠ Bekannte Kopplungs-Regel (CLAUDE.md):
        # ein %-Notfall-Stop ist unter Margin-Sizing enger als der 2×ATR-SL — bewusste
        # User-Vorgabe trotzdem, kein Gegen-Argument wiederholen.
        try:
            self._emergency_margin_pct = max(0.0, float(
                self.cfg["trading"].get("auto_emergency_margin_pct", "0") or 0))
        except (TypeError, ValueError):
            self._emergency_margin_pct = 0.0
        self._emergency_margin_armed_ticket = None  # Retry-Schutz wie bei sr_close_min_gain
        # ── Circuit Breaker (Tagesverlust-Stopp, User-Vorgabe 2026-07-27) ──────────
        # `[trading] daily_loss_limit_pct` > 0: erreicht der TAGES-P&L (realisiert heute
        # + offene Position) −pct% der Balance, schließt der Bot die Position und
        # eröffnet KEINE neuen Auto-Trades mehr bis zum nächsten Tag. Überlebens-Netz
        # gegen Verlust-Kaskaden (früher abgelehnt; mit dem Autonomie-Ziel reaktiviert
        # — unter 80 %-Margin schützt es v. a. gegen die Serie, nicht den Einzeltrade,
        # dessen 2×ATR-SL allein schon >pct% verlieren kann). 0 = aus.
        try:
            self._cb_limit_pct = max(0.0, float(self.cfg["trading"].get("daily_loss_limit_pct", "0") or 0))
        except (TypeError, ValueError):
            self._cb_limit_pct = 0.0
        self._circuit_tripped_date = None      # Berlin-Datum, an dem der Breaker griff
        self._cb_realized = (0.0, 0.0)         # (ts, realisierter Tages-P&L) gecacht ~30 s
        # Gewinn-mitnehmen (Take-Profit) — symmetrisch zum Notfall-Stop: schließt
        # bei P&L ≥ +Wert. Gemerkter Wert über Trades hinweg (0 = Auto-Arm aus).
        self._takeprofit: float | None = None
        try:
            self._takeprofit_remember = float(self.cfg["trading"].get("auto_takeprofit", "0") or 0)
        except (TypeError, ValueError):
            self._takeprofit_remember = 0.0
        # Notfall-Stop/TP überleben Neustarts: sonst re-armiert ein restart_server.bat
        # eine OFFENE Position auf die 2%-Automatik und verwirft eine manuelle Über-
        # steuerung (real 2026-07-17 14:30: −25 € → −19,42 €, dann Notfall-Close bei
        # −19,64). Persistiert {ticket, loss, tp}; in _check_auto_close wiederhergestellt,
        # solange dasselbe Ticket noch offen ist.
        self._emergency_state_path = _os.path.join(
            _os.path.dirname(_os.path.dirname(_os.path.abspath(__file__))),
            "emergency_state.json")
        self._emergency_state_ticket = None
        self._emergency_state_loss = None
        self._emergency_state_tp = None
        self._emergency_state_trail = None   # Trailing-Zustand per-Ticket (neustart-fest)
        self._load_emergency_state()
        # Startup-Schonfrist: bis zu diesem Zeitpunkt kein server-seitiger Auto-Close
        # (in start() gesetzt). Konfigurierbar via [trading] startup_close_grace_s.
        try:
            self._startup_grace_s = max(0.0, float(
                self.cfg["trading"].get("startup_close_grace_s", str(_STARTUP_GRACE_S))))
        except (TypeError, ValueError):
            self._startup_grace_s = _STARTUP_GRACE_S
        self._no_autoclose_until = 0.0
        self._running        = False
        self._connected      = False
        self._error: str | None = None
        self._threads: list[threading.Thread] = []
        # Snapshot-Cache: ein berechneter Snapshot wird über alle WS-Clients +
        # HTTP-Aufrufe geteilt (TTL) → SQLite/Verdict nur 1×/TTL statt N×/s.
        self._snap_cache: dict | None = None
        self._snap_cache_ts: float = 0.0
        self._snap_lock = threading.Lock()
        self._sqmon_cache: dict | None = None      # Auto-Squeeze-Monitor (B4), TTL 60 s
        self._sqmon_cache_ts: float = 0.0

    # ══════════════════════════════════════════════════════════════════════
    #  LIFECYCLE
    # ══════════════════════════════════════════════════════════════════════
    def start(self) -> bool:
        """Verbindet MT5, übernimmt offene Positionen und startet die Loops."""
        preferred = self.cfg["trading"].get("last_symbol", "").strip() or None
        if not self.data.connect(preferred_symbol=preferred):
            self._error = self.data.error
            log.error(f"MT5-Connect fehlgeschlagen: {self.data.error}")
            return False
        self._connected = True
        self._adopt_positions()

        # Start-Timeframe: fester tf_select hat Vorrang, sonst letzte Wahl aus
        # der Config; Heuristik/Agent justieren danach laufend.
        if self._tf_select.upper() in _ATR_TF_MAP:
            saved_tf = self._tf_select.upper()
        else:
            saved_tf = self.cfg["trading"].get("atr_tf", "M5").strip().upper()
        if saved_tf not in _ATR_TF_MAP:
            saved_tf = "M5"
        # Start-TF in das erlaubte Band [tf_min … tf_max] klemmen (Heuristik-Modus)
        if self._tf_select == "heuristic":
            order = list(_ATR_TF_MAP.keys())
            lo = order.index(self._tf_min); hi = order.index(self._tf_max)
            r  = order.index(saved_tf)
            saved_tf = order[min(max(r, lo), hi)]
        self._wave_tf_label = saved_tf
        const = _ATR_TF_MAP[saved_tf]
        self.wave.set_timeframe(const)
        self.elliott.set_timeframe(const)
        self.trail.set_atr_tf_override(const)

        threading.Thread(target=self.trader.reconcile_open_trades,
                         daemon=True, name="reconcile").start()
        # RSS-Feeds im Hintergrund validieren (ausgefallene werden ersetzt)
        threading.Thread(target=self.news.validate_feeds,
                         daemon=True, name="feed-validator").start()

        # Startup-Schonfrist scharf: die nächsten `_startup_grace_s` s schließt der
        # Bot keinen laufenden Trade selbst (S/R-Close/Notfall/Time-Stop/Reverse) —
        # verhindert Sofort-Close eines adoptierten Trades auf noch-instabilen Daten.
        self._no_autoclose_until = time.time() + self._startup_grace_s
        self.trail.set_no_close_until(self._no_autoclose_until)
        if self._startup_grace_s > 0:
            log.info(f"Startup-Schonfrist: {self._startup_grace_s:.0f} s kein Auto-Close")

        self._running = True
        # _tu_loop stillgelegt (2026-07-19): TU ist aus Empfehlung/Verdict/Copilot
        # raus UND die Dashboard-Kachel ist ausgeblendet → der 5-min-Scrape lief
        # für niemanden. Reaktivieren = self._tu_loop wieder in die Liste.
        for loop in (self._price_loop, self._trend_loop, self._pos_loop,
                     self._news_loop, self._tf_loop, self._agent_loop,
                     self._daily_loop):
            t = threading.Thread(target=loop, daemon=True, name=loop.__name__)
            t.start()
            self._threads.append(t)

        log.info(f"Engine gestartet · Symbol {self.data.symbol} · TF {saved_tf}")
        log.info("Auto-Squeeze-Nachtsperre: " + (
            ", ".join(f"{h}:00" for h in self._squeeze_night_hours)
            if (self._squeeze_skip_night and self._squeeze_night_hours) else "AUS"))
        return True

    def stop(self):
        self._running = False
        try:
            self.data.disconnect()
        except Exception:
            pass

    def _adopt_positions(self):
        """Beim Start vorhandene MT5-Positionen übernehmen (wie main() im Widget)."""
        try:
            all_pos = mt5.positions_get() or []
            log.info(f"Sofort-Adoption: {len(all_pos)} offene Position(en)")
            if all_pos:
                own  = [p for p in all_pos if getattr(p, "magic", 0) == MAGIC]
                pick = own[0] if own else all_pos[0]
                if pick.symbol != self.data.symbol:
                    log.info(f"Symbol-Switch beim Start: {self.data.symbol} → "
                             f"{pick.symbol} (offene Position T={pick.ticket})")
                    ok, msg = self.data.switch_symbol(pick.symbol)
                    if not ok:
                        log.warning(f"Symbol-Switch fehlgeschlagen: {msg}")
            self.trader.refresh(self.data.symbol)
        except Exception as e:
            log.warning(f"Sofort-Adoption: {e}", exc_info=True)

    # ══════════════════════════════════════════════════════════════════════
    #  LOOPS  (jeder MT5-Call sichert sich intern den globalen mt5_lock)
    # ══════════════════════════════════════════════════════════════════════
    def _price_loop(self):
        cnt = 0
        while self._running:
            cnt += 1
            try:
                self.data.fetch_price()
                s = self.data.snapshot()
                if s.get("bid") and s.get("ask") and self.data.symbol:
                    try:
                        self.trail.on_price(self.data.symbol, s["bid"], s["ask"])
                    except Exception as te:
                        log.warning(f"trail.on_price: {te}")
            except Exception as e:
                log.error(f"_price_loop#{cnt}: {e}", exc_info=True)
            time.sleep(_PRICE_S)

    def _trend_loop(self):
        while self._running:
            try:
                self.data.fetch_trend()
                if self.data.symbol:
                    # S/R-Kontext an das Wellenmodul geben (für die Konfidenz)
                    try:
                        srl = self._sr_levels(self.data.snapshot())
                        self.wave.set_sr_context(srl.get("resistance"),
                                                 srl.get("support"))
                    except Exception as se:
                        log.warning(f"set_sr_context: {se}")
                    try:    self.gaps.maybe_refresh(self.data.symbol)
                    except Exception as ge: log.warning(f"gaps.maybe_refresh: {ge}")
                    try:    self.wave.refresh_market(self.data.symbol)
                    except Exception as we: log.warning(f"wave.refresh_market: {we}")
                    try:    self.elliott.refresh_market(self.data.symbol)
                    except Exception as ee: log.warning(f"elliott.refresh_market: {ee}")
                    try:    self.structure.refresh_market(self.data.symbol)
                    except Exception as se2: log.warning(f"structure.refresh_market: {se2}")
                    try:    self.patterns.refresh_market(self.data.symbol)
                    except Exception as pe2: log.warning(f"patterns.refresh_market: {pe2}")
                    try:    self.candle_anat.refresh_market(self.data.symbol)
                    except Exception as ka: log.warning(f"candles.refresh_market: {ka}")
                    try:    self.candles.log(self.data.symbol)   # M1-Candle-Log (~55 s)
                    except Exception as ce: log.warning(f"candles.log: {ce}")
                    try:    self._evaluate_pbreak_predictions()  # ~alle 5 min, self-throttled
                    except Exception as pe: log.warning(f"pbreak_predictions: {pe}")
                    try:    self._evaluate_rec_outcomes()        # ~alle 5 min, self-throttled
                    except Exception as re_: log.warning(f"rec_outcomes: {re_}")
                    # Selbstmessung der M15-Karte (2026-08-08): ohne Rueckkopplung
                    # koennte sie monatelang falsch stehen, ohne dass es auffaellt —
                    # genau die Luecke, die `pbreak_predictions` beim P(break)-Modell
                    # geschlossen hat.
                    try:    self._evaluate_m15_states()          # ~alle 5 min, self-throttled
                    except Exception as me: log.warning(f"m15_states: {me}")
                    # Kegel-Abdeckung + ACI-Nachjustierung (2026-08-08)
                    try:    self._evaluate_cone_checks()
                    except Exception as ce: log.warning(f"cone_checks: {ce}")
                    # Wirtschaftskalender (self-throttled ~1 h, außerhalb des mt5_lock
                    # unkritisch — reiner HTTP-Fetch mit Timeout)
                    # HL-Kontext (Funding/OI/Premium) — reine Anzeige.
                    # ⚠⚠ IM DAEMON-THREAD, nicht inline: der Aufruf fragt die
                    # HL-API live nach allen Öl-Märkten und braucht real ~7 s.
                    # Inline würde er den Trend-Loop bei jedem Fälligwerden
                    # (~5 min) so lange anhalten — dieselbe Begründung, aus der
                    # der Wirtschaftskalender im Thread läuft. `market()` ist
                    # selbst gedrosselt und thread-sicher, ein zweiter Aufruf
                    # während der erste läuft liefert einfach den Cache.
                    try:
                        if not getattr(self, "_hl_ctx_busy", False):
                            self._hl_ctx_busy = True
                            threading.Thread(target=self._hl_ctx_refresh,
                                             daemon=True).start()
                    except Exception as he: log.debug(f"hl market: {he}")
                    try:    self.calendar.maybe_refresh()
                    except Exception as ke: log.warning(f"calendar.refresh: {ke}")
                self._run_analysis()
            except Exception as e:
                log.error(f"_trend_loop: {e}", exc_info=True)
            self._sleep(_TREND_S)

    def _pos_loop(self):
        while self._running:
            try:
                if self.data.symbol:
                    self.trader.refresh(self.data.symbol)
                    self._check_circuit_breaker()   # Tagesverlust-Stopp (Überleben zuerst)
                    self._check_auto_close()
                    self._check_adverse15()      # 15-Min-Regel (nur Bot-Trades)
                    self._check_flip_close()     # Empfehlung dreht → schließen
                    self._check_sr_close()
                    # ZUERST die ruhenden Stop-Orders pflegen (setzen/stornieren),
                    # DANN der Market-Fallback: so kann eine bereits liegende Order
                    # den Ausbruch am Level abfangen, bevor nachgejagt würde.
                    self._check_pending_fill()   # gefuellte Pending-Order zuordnen
                    self._manage_squeeze_pending()
                    self._check_auto_squeeze()   # autonomer Entry auf Squeeze-Ausbruch
                    self._check_auto_signal()    # autonomer Entry auf die Empfehlung
            except Exception as e:
                log.error(f"_pos_loop: {e}", exc_info=True)
            self._sleep(_POS_S)

    def set_emergency(self, value) -> float | None:
        """Notfall-Verlust-Schwelle setzen/löschen (Kontowährung, als positiver
        Betrag gespeichert). None/leer/0 → aus. Rückgabe = aktiver Wert."""
        try:
            v = abs(float(value)) if value not in (None, "", "0", 0) else None
            if v is not None and v <= 0:
                v = None
        except (TypeError, ValueError):
            v = None
        # Vertipper-Schutz: ein Wert unter dem Minimum (Spread-Region) würde den
        # Trade sofort schließen UND sich auf alle Folge-Trades vererben → als „aus"
        # behandeln (Fix 2026-07-27, real: −1-€-Stop killte jeden Trade sofort).
        if v is not None and self._emergency_min > 0 and v < self._emergency_min:
            log.warning(f"Notfall-Stop −{v:.2f} < Minimum {self._emergency_min:.2f} € "
                        f"(zu eng, würde sofort schließen) → als AUS behandelt")
            v = None
        self._emergency_loss = v
        if v is not None:
            self._emergency_remember = v   # für die nächste Position merken
        else:
            self._emergency_remember = 0.0  # „aus" schaltet auch den Auto-Arm ab
        log.info(f"Notfall-Stop {('gesetzt: -' + format(v, '.2f')) if v else 'aus'}")
        self._save_emergency_state()   # Handeingabe neustart-fest (Fix 2026-07-17)
        return self._emergency_loss

    def set_takeprofit(self, value) -> float | None:
        """Gewinn-Ziel setzen/löschen (Kontowährung, positiver Betrag). None/leer/0
        → aus. Gemerkt für die nächste Position. Rückgabe = aktiver Wert."""
        try:
            v = abs(float(value)) if value not in (None, "", "0", 0) else None
            if v is not None and v <= 0:
                v = None
        except (TypeError, ValueError):
            v = None
        self._takeprofit = v
        if v is not None:
            self._takeprofit_remember = v
        else:
            self._takeprofit_remember = 0.0  # „aus" schaltet auch den Auto-Arm ab
        log.info(f"Gewinn-Ziel {('gesetzt: +' + format(v, '.2f')) if v else 'aus'}")
        self._save_emergency_state()   # Handeingabe neustart-fest (Fix 2026-07-17)
        return self._takeprofit

    def _in_startup_grace(self) -> bool:
        """True in den ersten `_startup_grace_s` s nach Bot-Start — dann schließt der
        Bot keinen laufenden Trade selbst (Daten noch nicht stabil nach Neustart)."""
        return time.time() < self._no_autoclose_until

    # ── Circuit Breaker (Tagesverlust-Stopp) ─────────────────────────────────────
    def _day_realized_cached(self) -> float:
        """Realisierter Tages-P&L (heute geschlossene Trades), gecacht ~30 s —
        damit die SQLite-Abfrage nicht jeden 1-s-Tick läuft."""
        now = time.time()
        if now - self._cb_realized[0] < 30:
            return self._cb_realized[1]
        try:
            v = float((self.history.stats_overview("today") or {}).get("total_pnl") or 0.0)
        except Exception:
            v = self._cb_realized[1]
        self._cb_realized = (now, v)
        return v

    def _circuit_halted(self) -> bool:
        """True, wenn der Circuit Breaker HEUTE (Berlin) bereits ausgelöst hat →
        keine neuen Auto-Trades bis zum nächsten Tag."""
        if self._cb_limit_pct <= 0 or not self._circuit_tripped_date:
            return False
        return self._circuit_tripped_date == datetime.now(_BERLIN).date()

    def _check_circuit_breaker(self):
        """Tagesverlust-Stopp (User-Vorgabe 2026-07-27): erreicht der Tages-P&L
        (realisiert heute + offene Position) −`daily_loss_limit_pct`% der Balance,
        schließt der Bot die Position und sperrt neue Auto-Trades bis zum nächsten
        Tag. Wirkt auch bei gesperrtem Handy. Fail-safe."""
        if self._cb_limit_pct <= 0:
            return
        if self._in_startup_grace():       # nach Neustart nicht auf halb-init Daten feuern
            return
        today = datetime.now(_BERLIN).date()
        if self._circuit_tripped_date and self._circuit_tripped_date != today:
            self._circuit_tripped_date = None      # neuer Tag → Reset
            log.info("Circuit Breaker zurückgesetzt (neuer Handelstag)")
        if self._circuit_tripped_date == today:
            return                                  # heute schon ausgelöst
        bal = float(self.data.balance or 0.0)
        if bal <= 0:
            return
        ps = self.trader.snapshot()
        open_pnl = float(ps.get("pnl") or 0.0)
        day_total = self._day_realized_cached() + open_pnl
        limit_eur = self._cb_limit_pct / 100.0 * bal
        if day_total > -limit_eur:
            return
        self._circuit_tripped_date = today
        log.warning(f"🛑 CIRCUIT BREAKER: Tages-P&L {day_total:+.2f} ≤ -{limit_eur:.2f} € "
                    f"({self._cb_limit_pct:.0f}% von {bal:.0f}) → Position schließen, "
                    f"keine Auto-Trades mehr heute")
        sym = self.data.symbol or ""
        tg = self.cfg["telegram"]
        tg_on = (tg.get("enabled", "false").lower() == "true" and tg.get("bot_token"))
        if ps.get("ticket"):
            err = self.trader.close(reason="circuit_breaker")
            if err:
                log.error(f"Circuit-Breaker-Close fehlgeschlagen: {err}")
        if tg_on:
            try:
                send_telegram(f"🛑 <b>CIRCUIT BREAKER</b>\n{sym} Tagesverlust {day_total:+.2f} € "
                              f"≤ -{limit_eur:.2f} € ({self._cb_limit_pct:.0f}% der Balance). "
                              f"Position geschlossen, keine Auto-Trades mehr heute.",
                              tg["bot_token"], tg["chat_id"])
            except Exception as e:
                log.warning(f"Circuit-Breaker-Telegram: {e}")

    def _check_auto_close(self):
        """Server-seitiger Auto-Close (wirkt auch bei gesperrtem Handy): Notfall-Stop
        (P&L ≤ −Schwelle) UND Gewinn-mitnehmen (P&L ≥ +Ziel). Beide werden bei einer
        NEUEN Position automatisch auf den zuletzt genutzten Wert gesetzt; manuelles
        Übersteuern im laufenden Trade bleibt erhalten."""
        ps = self.trader.snapshot()
        ticket = ps.get("ticket")
        if not ticket:
            # Flat-Übergang: hatten wir gerade noch eine Position, merke Zeit+Richtung
            # → Squeeze-Wiedereinstiegs-Sperre (gegen Open→Instant-Close-Kaskade). Gilt
            # für JEDE Close-Art (Notfall/SL/Time-Stop/manuell); der S/R-Close hat schon
            # seinen eigenen Marker, dieser deckt den Rest ab.
            if self._last_pos_ticket is not None and self._open_pos_dir:
                self._pos_close_ts = time.time()
                self._pos_close_dir = self._open_pos_dir
            self._open_pos_dir = None
            self._last_pos_ticket = None
            self._emergency_loss = None
            self._takeprofit = None
            return
        self._open_pos_dir = "LONG" if ps.get("order_type") == 0 else "SHORT"
        if ticket != self._last_pos_ticket:      # neue/wiedererkannte Position
            self._last_pos_ticket = ticket
            if ticket == self._emergency_state_ticket:
                # Dieselbe (noch offene) Position nach Neustart/Wiedererkennung →
                # persistierten Wert WIEDERHERSTELLEN (inkl. manueller Übersteuerung),
                # NICHT auf die pct-Automatik zurücksetzen (Fix 2026-07-17: Neustart
                # bei offenem Trade kappte sonst die von Hand gesetzten −25 € auf −19,42).
                self._emergency_loss = self._emergency_state_loss
                self._takeprofit = self._emergency_state_tp
                self._sr_close_min_gain_armed_ticket = ticket  # wiederhergestellter Wert
                                            # gilt als final — NICHT auf 1% zurücksetzen
                self._emergency_margin_armed_ticket = ticket   # dito für den margin-%-Stop
                log.info(f"Auto-Close wiederhergestellt (Pos {ticket}): Stop "
                         f"{('-'+format(self._emergency_loss,'.2f')) if self._emergency_loss else 'aus'} · TP "
                         f"{('+'+format(self._takeprofit,'.2f')) if self._takeprofit else 'aus'}")
                # Trailing wiederherstellen: war es vor dem Neustart AN, wieder aktivieren
                # (Fix 2026-07-29: Trailing lebte nur im Speicher → nach jedem Neustart
                # aus, die Position lief nur mit Broker-SL, ohne Breakeven/Time-Stop; der
                # User musste es manuell einschalten). War es AUS (z. B. manuelles SL/TP
                # → deaktiviert), bleibt es aus — der persistierte Zustand entscheidet.
                if self._emergency_state_trail and not self.trail.enabled and self.data.symbol:
                    self.trail.toggle(self.data.symbol)
                    log.info(f"Trailing wiederhergestellt (Pos {ticket}) nach Neustart")
            else:                                # echt neue Position → armieren
                if self._emergency_margin_pct > 0:
                    pass   # wird unten margin-basiert (retry-sicher) gesetzt
                elif self._emergency_pct > 0 and self.data.balance:
                    # % des Kontos (skaliert dynamisch, User-Vorgabe)
                    self._emergency_loss = round(self._emergency_pct / 100.0 * float(self.data.balance), 2)
                elif self._emergency_remember and self._emergency_remember > 0:
                    self._emergency_loss = float(self._emergency_remember)
                if self._takeprofit_remember and self._takeprofit_remember > 0:
                    self._takeprofit = float(self._takeprofit_remember)
                log.info(f"Auto-Close armiert (Pos {ticket}): Stop "
                         f"{('-'+format(self._emergency_loss,'.2f')) if self._emergency_loss else 'aus'} · TP "
                         f"{('+'+format(self._takeprofit,'.2f')) if self._takeprofit else 'aus'}")
                self._save_emergency_state()
        # Gewinn-Close (Mindestgewinn für den S/R-Auto-Close) auf X% des EINSATZES
        # dieser Position setzen (Margin kommt frisch aus dem trader.refresh()
        # unmittelbar vor diesem Aufruf in _pos_loop). Läuft NICHT nur einmalig beim
        # Ticket-Wechsel, sondern jeden Tick erneut, bis es geklappt hat (Fix
        # 2026-07-23): war `order_calc_margin` genau im ersten Tick nach dem Öffnen
        # noch 0/nicht verfügbar, blieb die Schwelle sonst dauerhaft auf dem STALEN
        # Wert der vorherigen Position hängen (`_last_pos_ticket` war da schon
        # umgesetzt, der Ticket-Wechsel-Zweig feuert nur 1×) — konnte den Trade zu
        # früh (falscher, zu niedriger Alt-Wert) ODER dauerhaft mit falscher Schwelle
        # laufen lassen.
        if (self._sr_close_min_gain_pct > 0
                and self._sr_close_min_gain_armed_ticket != ticket):
            margin = ps.get("margin") or 0.0
            if margin > 0:
                self._sr_close_min_gain = round(
                    self._sr_close_min_gain_pct / 100.0 * margin, 2)
                self._sr_close_min_gain_armed_ticket = ticket
                self._save_runtime_state()
                log.info(f"Gewinn-Close armiert (Pos {ticket}): "
                         f"+{self._sr_close_min_gain:.2f} ({self._sr_close_min_gain_pct:.0f}% Margin {margin:.2f})")
        # Notfall-Stop als % der Margin — gleiches Retry-Muster (margin-Wert kann im
        # ersten Tick nach dem Öffnen noch 0 sein). Hat Vorrang vor Balance-%/Fixwert
        # (die im "echt neue Position"-Zweig oben bewusst übersprungen wurden, wenn
        # `_emergency_margin_pct>0`).
        if (self._emergency_margin_pct > 0
                and self._emergency_margin_armed_ticket != ticket):
            margin = ps.get("margin") or 0.0
            if margin > 0:
                self._emergency_loss = round(
                    self._emergency_margin_pct / 100.0 * margin, 2)
                self._emergency_margin_armed_ticket = ticket
                self._save_emergency_state()
                log.info(f"Notfall-Stop armiert (Pos {ticket}): "
                         f"-{self._emergency_loss:.2f} ({self._emergency_margin_pct:.0f}% Margin {margin:.2f})")
        # Trailing-Zustand per-Ticket neustart-fest halten: nur bei ÄNDERUNG schreiben
        # (kein Datei-I/O je Tick). Fängt auch die Selbst-Deaktivierung des Trailings
        # (manuelles SL/TP im Terminal, `_do_modify`) — sonst würde der Neustart ein vom
        # User abgeschaltetes Trailing wieder anwerfen.
        if bool(self.trail.enabled) != bool(self._emergency_state_trail):
            self._save_emergency_state()
        if self._in_startup_grace():      # Startup-Schonfrist: armieren ja, schließen nein
            return
        pnl = ps.get("pnl")
        if pnl is None:
            return
        tg = self.cfg["telegram"]
        tg_on = (tg.get("enabled", "false").lower() == "true" and tg.get("bot_token"))
        sym = self.data.symbol or ""

        def _do(reason, ok_icon, ok_word, level_txt):
            err = self.trader.close(reason=reason)
            if err:
                log.error(f"{ok_word} fehlgeschlagen: {err}")
                if tg_on:
                    try: send_telegram(f"⚠ <b>{ok_word} FEHLGESCHLAGEN</b>\n{sym} P&L {pnl:+.2f} "
                                       f"({level_txt}) — bitte MANUELL schließen! ({err})",
                                       tg["bot_token"], tg["chat_id"])
                    except Exception as e: log.warning(f"Auto-Close-Telegram (Fehler): {e}")
                return False
            if tg_on:
                try: send_telegram(f"{ok_icon} <b>{ok_word}</b>\n{sym} bei P&L {pnl:+.2f} "
                                   f"({level_txt}) geschlossen.", tg["bot_token"], tg["chat_id"])
                except Exception as e: log.warning(f"Auto-Close-Telegram: {e}")
            return True

        thr = self._emergency_loss
        if thr and pnl <= -abs(thr):
            log.warning(f"🚨 NOTFALL-CLOSE: P&L {pnl:+.2f} ≤ -{abs(thr):.2f}")
            if _do("emergency", "🚨", "Notfall-Close", f"Schwelle -{abs(thr):.2f}"):
                self._emergency_loss = None
            return
        tp = self._takeprofit
        if tp and pnl >= abs(tp):
            log.info(f"💰 GEWINN-CLOSE: P&L {pnl:+.2f} ≥ +{abs(tp):.2f}")
            if _do("takeprofit", "💰", "Gewinn mitgenommen", f"Ziel +{abs(tp):.2f}"):
                self._takeprofit = None
            return

    def _check_sr_close(self):
        """Automatischer S/R-Close (User-Vorgabe): schließt eine Position **im Plus**
        selbstständig, wenn die gemessene Bedingung greift (Kurs klebt am gegenüber-
        liegenden Level + schwacher Anlauf → Durchbruch ~26 %, Close schlägt Laufen-
        lassen; `backtest_srbreak.py`). Nur bei `auto_sr_close=true`, genau 1×/Ticket,
        wirkt auch bei gesperrtem Handy. Fail-safe."""
        if not self._auto_sr_close:
            return
        if self._in_startup_grace():      # Startup-Schonfrist: kein Sofort-Close nach Neustart
            return
        ps = self.trader.snapshot()
        ticket = ps.get("ticket")
        if not ticket:
            self._sr_close_last_ticket = None
            return
        if ticket == self._sr_close_last_ticket:   # bereits ausgelöst → nicht erneut
            return
        pnl = ps.get("pnl")
        if pnl is None or pnl <= 0:                 # NUR bei Trade im Plus (User-Vorgabe)
            return
        # Optionaler Mindestgewinn (User-Vorgabe; Default 0=aus — gemessen ist ohne
        # besser): unter der Schwelle wird am Level NICHT geschlossen, Trade läuft.
        if self._sr_close_min_gain > 0 and pnl < self._sr_close_min_gain:
            return
        hint = self._sr_close_hint(self.data.snapshot(), ps, self.wave.snapshot())
        if not hint or not hint.get("close"):      # am Level, aber P(break) ≥ Schwelle → laufen lassen
            return
        self._sr_close_last_ticket = ticket         # vor dem Close markieren (kein Doppel)
        sym = self.data.symbol or ""
        _confirm = hint.get("confirm")
        log.info(f"🎯 S/R-AUTO-CLOSE: {sym} P&L {pnl:+.2f} — am Level {hint['level']}, "
                 f"Durchbruch nur ~{hint['p_break']}% (< {self._sr_close_pbreak:.0%})"
                 + (f" — Bestätigung erst ab {_confirm}" if _confirm else "")
                 + " → Gewinn sichern")
        err = self.trader.close(reason="sr_close")
        tg = self.cfg["telegram"]
        tg_on = (tg.get("enabled", "false").lower() == "true" and tg.get("bot_token"))
        if err:
            log.error(f"S/R-Auto-Close fehlgeschlagen: {err}")
            self._sr_close_last_ticket = None        # Fehlschlag → nächster Tick erneut
            if tg_on:
                try: send_telegram(f"⚠ <b>S/R-Close FEHLGESCHLAGEN</b>\n{sym} P&L {pnl:+.2f} "
                                   f"— bitte MANUELL schließen! ({err})",
                                   tg["bot_token"], tg["chat_id"])
                except Exception as e: log.warning(f"S/R-Close-Telegram (Fehler): {e}")
            return
        # Richtung + Zeit merken → Auto-Squeeze-Cooldown gegen Gleichrichtungs-Roundtrip
        self._sr_close_dir = "LONG" if ps.get("order_type") == 0 else "SHORT"
        self._sr_close_ts = time.time()
        self._sr_close_count += 1
        if tg_on:
            try: send_telegram(f"🎯 <b>S/R-Auto-Close</b>\n{sym} bei P&L {pnl:+.2f} geschlossen "
                               f"— Kurs klebte am Level {hint['level']} mit schwachem Anlauf "
                               f"(Durchbruch ~{hint['p_break']}% unwahrscheinlich).",
                               tg["bot_token"], tg["chat_id"])
            except Exception as e: log.warning(f"S/R-Close-Telegram: {e}")

    def _auto_guard(self, pfad: str) -> str | None:
        """Die NICHT richtungsabhängigen Gates für autonome Entries.
        `pfad` = "squeeze" | "signal". → Grundtext, wenn geblockt, sonst None.

        ⚠ Bewusst EINE Funktion für ALLE Einstiegswege (ruhende Stop-Order UND
        Market-Fallback, Squeeze UND Signal). Kopien derselben Gates wären genau die
        Divergenz, die dieses Projekt siebenmal als Deployment-Drift dokumentiert hat
        — und bei einer RUHENDEN Order wiegt sie schwerer: eine vergessene
        Pending-Order feuert im gesperrten Fenster, ohne dass jemand hinschaut."""
        if pfad == "squeeze":
            if not self._auto_squeeze:
                return "Auto-Squeeze aus"
            skip = self._squeeze_skip_night
        else:
            if not self._auto_signal:
                return "Auto-Signal aus"
            skip = self._auto_signal_skip_night
        if self._circuit_halted():
            return "Circuit-Breaker"
        if skip and datetime.now(_BERLIN).hour in self._squeeze_night_hours:
            return "Nacht-Fenster"
        _bl = self.calendar.blackout()
        if _bl:
            if self._news_block_logged != _bl["title"]:
                self._news_block_logged = _bl["title"]
                log.info(f"📅 News-Blackout — kein Auto-Entry: {_bl['title']} "
                         f"({_bl['impact']}, in {_bl['minutes']:.0f} min)")
            return "News-Blackout"
        self._news_block_logged = None
        return None

    def _squeeze_guard(self) -> str | None:
        """Alias — `_check_auto_squeeze` ruft weiterhin diesen Namen."""
        return self._auto_guard("squeeze")

    def _check_pending_fill(self):
        """Hat eine von UNS platzierte Pending-Order gefuellt? Dann nachtragen.

        ⚠ WARUM: eine gefuellte Pending-Order laeuft NICHT durch `_open` — MT5
        oeffnet die Position selbst, und `trader._refresh_locked` adoptiert sie per
        magic-match und loggt sie OHNE Setup. Am 06.08. fuellten drei `SQZ-STOP`-
        Orders und landeten als `setup=NULL` in der DB, also ununterscheidbar von
        manuellen Trades. Damit zaehlten der B4-Monitor und die Reminder
        `squeeze_b5` / `squeeze_entry_gap` **null Bot-Trades**, obwohl der Bot
        gehandelt hatte — die Messpipeline war blind fuer genau den Umbau, den sie
        kontrollieren soll.
        Die Zuordnung ist eindeutig: bei einem Pending-Fill ist die POSITIONS-Nummer
        identisch mit der ORDER-Nummer (in den Broker-Daten vom 06.08. verifiziert).
        """
        try:
            if not self._pending_tickets:
                return
            ps = self.trader.snapshot()
            tk = ps.get("ticket")
            if not tk or tk in self._pending_tagged:
                return
            quelle = self._pending_tickets.get(int(tk))
            if not quelle:
                return                       # fremde/manuelle Position
            d = "LONG" if ps.get("order_type") == 0 else "SHORT"
            setup = f"SQUEEZE_{d}" if quelle == "squeeze" else f"AUTOSIG_{d}"
            self._pending_tagged.add(tk)
            self._pending_tickets.pop(int(tk), None)
            ok = self.history.tag_bot_trade(int(tk), setup) if self.history else False
            # Dieselbe Buchfuehrung wie beim Market-Pfad, damit B4/B5 zaehlen
            self._bot_open_ticket = tk
            self._bot_open_source = "auto_squeeze" if quelle == "squeeze" else "auto_signal"
            if quelle == "squeeze":
                self._squeeze_entry_count += 1
            else:
                self._signal_entry_count += 1
            log.info(f"🎯 PENDING-FILL ({quelle}): {d} @ {ps.get('entry_price')} "
                     f"— Position {tk} als {setup} getaggt"
                     + ("" if ok else " ⚠ DB-Nachtrag fehlgeschlagen"))
            tg = self.cfg["telegram"]
            if tg.get("enabled", "false").lower() == "true" and tg.get("bot_token"):
                try:
                    send_telegram(f"🎯 <b>Pending-Fill ({quelle})</b>\n"
                                  f"{self.data.symbol or ''} {d} @ "
                                  f"{ps.get('entry_price')} — ruhende Stop-Order "
                                  f"am Level ausgeloest.",
                                  tg["bot_token"], tg["chat_id"])
                except Exception as e:
                    log.warning(f"Pending-Fill-Telegram: {e}")
        except Exception as e:
            log.error(f"_check_pending_fill: {e}", exc_info=True)

    def _pending_ziel(self) -> tuple[dict, str]:
        """Welche Stop-Orders SOLLEN liegen? → ({order_type: preis}, Quelle).

        ⚠⚠ EIN gemeinsamer Ziel-Zustand für Squeeze UND Signal — nicht zwei Manager.
        Zwei getrennte Manager würden über `trader.pending_orders()` jeweils die
        Orders des anderen sehen und **gegenseitig stornieren**; der Bug wäre
        sporadisch und im Log kaum zu erkennen.

        VORRANG: Squeeze schlägt Signal. Der Squeeze ist unabhängig validiert und
        seltener (Kompression ~2–3×/Woche), das Signal feuert dauernd — bei einem
        Positions-Slot ist die Reihenfolge damit eindeutig. Ist der Squeeze `armed`,
        legt das Signal nichts.
        """
        ws = self.wave.snapshot() or {}
        atr = (ws.get("pb_feats") or {}).get("atr") or 0.0
        if atr <= 0:
            return {}, ""
        # ── 1) Squeeze: beide Box-Grenzen ────────────────────────────────
        sq = ws.get("squeeze") or {}
        hi, lo = sq.get("box_hi"), sq.get("box_lo")
        if (self._squeeze_pending and sq.get("state") == "armed" and hi and lo
                and self._auto_guard("squeeze") is None):
            return ({mt5.ORDER_TYPE_BUY_STOP:  round(float(hi) + _SQ_K_ENG * atr, 3),
                     mt5.ORDER_TYPE_SELL_STOP: round(float(lo) - _SQ_K_ENG * atr, 3)},
                    "squeeze")
        # ── 2) Signal: EINE Order am Bestätigungs-Level ──────────────────
        # Gemessen `backtest_auto_signal_v3.py`: am Level ØR +0,35/+0,32 (PF 2,2)
        # gegen −0,09/−0,11 am Markt — dieselbe Mechanik, die den Squeeze rettet.
        bo = ws.get("breakout") or {}
        if (self._signal_pending and bo.get("pending") and bo.get("level")
                and bo.get("dir") in ("LONG", "SHORT")
                and (bo.get("conf") or 0) >= self._auto_signal_min_conf
                and self._auto_guard("signal") is None):
            ot = (mt5.ORDER_TYPE_BUY_STOP if bo["dir"] == "LONG"
                  else mt5.ORDER_TYPE_SELL_STOP)
            return {ot: round(float(bo["level"]), 3)}, "signal"
        return {}, ""

    def _manage_squeeze_pending(self):
        """RUHENDE Stop-Orders an beiden Box-Grenzen, solange der Squeeze `armed` ist.

        WARUM (gemessen `backtest_squeeze_entry.py`, 2026-08-05): der Squeeze hat
        seinen gesamten Edge im EINSTIEGSPREIS. Die Market-Order auf dem 5-s-Poll
        füllt live im Median 0,275×ATR hinter dem Level (Mittel 0,686, Max 4,3) →
        ØR kippt von +0,456 auf −0,158. Eine ruhende Stop-Order deckelt den Preis
        konstruktiv: selbst mit 0,20×ATR Fill-Slippage bleibt ØR +0,244/+0,426.

        Beide Seiten werden bestückt (die Box kann nach oben ODER unten brechen);
        füllt eine, existiert eine Position → `soll` wird False und die Gegenseite
        wird im selben Tick storniert. Das ersetzt ein echtes OCO, das MT5 nicht hat.
        """
        if not self._squeeze_pending:
            return
        sym = self.data.symbol or ""
        if not sym:
            return
        try:
            ps = self.trader.snapshot()
            atr = ((self.wave.snapshot() or {}).get("pb_feats") or {}).get("atr") or 0.0
            ziel, quelle = self._pending_ziel()
            # Orders sollen NUR liegen, wenn zusätzlich: flat · Schonfrist vorbei.
            # Beides kann sich jederzeit ändern → JEDEN Tick neu bewertet, nicht
            # beim Platzieren einmal geprüft.
            if ps.get("ticket") or self._in_startup_grace() or atr <= 0:
                ziel, quelle = {}, ""
            offen = self.trader.pending_orders(sym)
            if not ziel:
                for o in offen:
                    err = self.trader.cancel_pending(o.ticket)
                    if not err:
                        self._pending_tickets.pop(int(o.ticket), None)
                        log.info(f"⏸ Pending-Entry storniert (T={o.ticket}) — "
                                 + ("Position offen" if ps.get("ticket")
                                    else "Setup nicht mehr gültig"))
                if offen:
                    self._pending_levels = None
                    self._pending_quelle = ""
                return
            # Bestehende Orders behalten, wenn ihr Trigger noch passt (Toleranz
            # 0,02×ATR) — sonst löschen und neu setzen. Ohne die Toleranz würde
            # jede ATR-Zuckung die Orders löschen/neu setzen (Broker-Last, Log-Flut).
            # ⚠ Beim Signal-Pfad ist das wichtiger als beim Squeeze: `_pend`
            # verankert sich bei jeder k×ATR-Gegenbewegung neu, das Level wandert.
            tol = max(0.02 * atr, 0.001)
            vorhanden = {}
            for o in offen:
                z = ziel.get(o.type)
                if z is not None and abs(o.price_open - z) <= tol and o.type not in vorhanden:
                    vorhanden[o.type] = o.ticket
                else:
                    self.trader.cancel_pending(o.ticket)
                    self._pending_tickets.pop(int(o.ticket), None)
            for otype, preis in ziel.items():
                if otype in vorhanden:
                    continue
                tag = "SQZ-STOP" if quelle == "squeeze" else "SIG-STOP"
                t, err = self.trader.place_stop(
                    sym, otype, preis, comment=tag,
                    # gleiche Regel wie beim Market-Pfad (s. `_open`)
                    atr_tf=(mt5.TIMEFRAME_M5 if quelle == "squeeze" else None))
                if t:
                    self._pending_tickets[int(t)] = quelle
                    log.info(f"🎯 Pending-Entry ({quelle}) gesetzt: "
                             f"{'BUY_STOP' if otype == mt5.ORDER_TYPE_BUY_STOP else 'SELL_STOP'}"
                             f" @ {preis:.3f} (T={t})")
                elif err and self._squeeze_pending_err != err:
                    # ⚠ Nur bei ÄNDERUNG loggen: „Kurs hat das Level bereits passiert"
                    # tritt im 1-s-Takt auf, sobald der Kurs am Level klebt.
                    self._squeeze_pending_err = err
                    log.info(f"Pending-Entry ({quelle}) nicht platzierbar "
                             f"({preis:.3f}): {err}")
            self._pending_levels = ziel
            self._pending_quelle = quelle
        except Exception as e:
            log.error(f"_manage_squeeze_pending: {e}", exc_info=True)

    def _check_auto_squeeze(self):
        """Autonomer Entry auf den gemessen-validierten Volatilitäts-Squeeze-Ausbruch
        (`wave.squeeze.state == 'active'`), NUR wenn flat. Feuert **1× je Ausbruch**
        (Dedup über dir+level; re-armt, sobald der Squeeze klärt). Emergency-Stop
        armiert beim Öffnen automatisch (2 % Konto, via `_check_auto_close`). Fail-safe."""
        try:
            if self._squeeze_guard() is not None:   # aus · Circuit · Nacht · News
                return
            sq = (self.wave.snapshot() or {}).get("squeeze") or {}
            if sq.get("state") != "active":
                self._squeeze_last_sig = None          # Ausbruch geklärt → re-armen
                return
            d = sq.get("dir"); lvl = sq.get("level")
            if d not in ("LONG", "SHORT") or lvl is None:
                return
            sig = (d, round(float(lvl), 2))
            # Nacht-Fenster, News-Blackout, Circuit-Breaker und der An/Aus-Schalter
            # sitzen jetzt in `_squeeze_guard()` (oben geprüft) — EINE Quelle für
            # Pending- und Market-Weg, s. dort.
            ps = self.trader.snapshot()
            ticket = ps.get("ticket")
            if ticket:
                pos_dir = "LONG" if ps.get("order_type") == 0 else "SHORT"
                if pos_dir == d:
                    self._squeeze_last_sig = sig       # gleiche Richtung → schon dabei
                    return
                # ── Stop-&-Reverse (Default AUS, `auto_squeeze_reverse`): unbelegt +
                # dreht am Ausbruch-Extrem (real 2026-07-17 18:55). Ist er aus, bleibt
                # der Gegen-Trade unangetastet — Drehen ist dann MANUELLE Entscheidung.
                # `_squeeze_last_sig` NICHT setzen → schließt der Gegen-Trade (SL/manuell),
                # kann der flat-Entry auf denselben Ausbruch noch feuern.
                if not self._squeeze_reverse:
                    return
                if self._in_startup_grace():   # Startup-Schonfrist: kein Reverse-Close nach Neustart
                    return
                # Trade läuft GEGEN den Ausbruch → sofort schließen. Der nächste (flat)
                # Tick eröffnet dann in Ausbruchsrichtung über den Entry-Pfad. Dedup über
                # reverse_sig (kein Doppel-Close, während die Position noch schließt).
                if sig == self._squeeze_reverse_sig:
                    return
                self._squeeze_reverse_sig = sig
                sym = self.data.symbol or ""
                pnl = ps.get("pnl")
                log.info(f"🔄 AUTO-SQUEEZE-REVERSE: {pos_dir}-Position gegen {d}-Ausbruch "
                         f"@ {lvl} (P&L {pnl:+.2f} EUR) → sofort schließen, dann drehen")
                err = self.trader.close(reason="squeeze_reverse")
                tg = self.cfg["telegram"]
                tg_on = (tg.get("enabled", "false").lower() == "true" and tg.get("bot_token"))
                if err:
                    log.error(f"Auto-Squeeze-Reverse-Close fehlgeschlagen: {err}")
                    self._squeeze_reverse_sig = None    # Fehlschlag → nächster Tick erneut
                elif tg_on:
                    try: send_telegram(f"🔄 <b>Auto-Squeeze-Reverse</b>\n{sym} {pos_dir}-"
                                       f"Position (P&L {pnl:+.2f}) gegen {d}-Ausbruch @ {lvl} "
                                       f"geschlossen — dreht auf {d}.",
                                       tg["bot_token"], tg["chat_id"])
                    except Exception as e: log.warning(f"Squeeze-Reverse-Telegram: {e}")
                return

            # FLAT → Entry-Pfad
            if sig == self._squeeze_last_sig:
                return                                 # diesen Ausbruch schon gehandelt
            # Cooldown: nicht in GLEICHER Richtung direkt nach einem S/R-Close wieder
            # eröffnen — der Close ging von „Level hält" aus, ein sofortiger Gleich-
            # richtungs-Entry wäre der widersprüchliche 1-s-Roundtrip (2026-07-17).
            # `_squeeze_last_sig` NICHT setzen → nach Ablauf feuert der Ausbruch, falls
            # noch aktiv. Gegenrichtung (Reverse) bleibt unberührt (läuft oben).
            if (d == self._sr_close_dir
                    and time.time() - self._sr_close_ts < _SQUEEZE_SR_COOLDOWN_S):
                return
            # Wiedereinstiegs-Sperre nach JEDEM Close (Notfall/SL/Time-Stop/manuell):
            # nicht sofort in GLEICHER Richtung neu eröffnen — verhindert die
            # Open→Instant-Close-Kaskade bei zu engem Stop (2026-07-27). `_squeeze_last_sig`
            # NICHT setzen → nach Ablauf feuert der Ausbruch, falls noch aktiv.
            if (d == self._pos_close_dir
                    and time.time() - self._pos_close_ts < _SQUEEZE_REENTRY_COOLDOWN_S):
                return
            # ── NACHJAGD-BREMSE (2026-08-05, gemessen `backtest_squeeze_entry.py`).
            # Der Market-Weg ist nur noch der FALLBACK, wenn keine Pending-Order
            # gegriffen hat (Broker-Mindestabstand, Squeeze sprang direkt auf
            # `active`, Order-Fehler). Gemessen ist ein Einstieg bis rund
            # **0,20×ATR** über dem Level in BEIDEN Hälften positiv (ØR +0,244/
            # +0,426); darüber kippt es Richtung −0,158/−0,006. Also: nur bis dahin
            # nachkaufen, sonst diesen Ausbruch auslassen.
            # ⚠ `_squeeze_last_sig` wird dabei NICHT gesetzt — läuft der Kurs zum
            # Level zurück (Ausbruch bleibt `active`), darf der Entry noch kommen.
            atr_m5 = ((self.wave.snapshot() or {}).get("pb_feats") or {}).get("atr") or 0.0
            tick = self.data.snapshot() or {}
            px = tick.get("ask") if d == "LONG" else tick.get("bid")
            if atr_m5 > 0 and px:
                weg = (float(px) - float(lvl)) * (1 if d == "LONG" else -1) / atr_m5
                if weg > self._squeeze_max_chase:
                    if self._squeeze_chase_logged != sig:
                        self._squeeze_chase_logged = sig
                        log.info(f"⏭ Auto-Squeeze übersprungen: Kurs steht schon "
                                 f"{weg:.2f}×ATR über dem Level {lvl} "
                                 f"(Grenze {self._squeeze_max_chase:.2f}) — "
                                 f"gemessen ab hier kein Edge mehr")
                    return
            self._squeeze_last_sig = sig
            if isinstance(self._last_rec, dict):
                self._last_rec["setup"] = f"SQUEEZE_{d}"
            log.info(f"🚀 AUTO-SQUEEZE-ENTRY: {d} @ Ausbruch {lvl} — eröffne selbständig")
            err = (self.open_long(source="auto_squeeze") if d == "LONG"
                   else self.open_short(source="auto_squeeze"))
            sym = self.data.symbol or ""
            tg = self.cfg["telegram"]
            tg_on = (tg.get("enabled", "false").lower() == "true" and tg.get("bot_token"))
            if err:
                log.error(f"Auto-Squeeze-Entry fehlgeschlagen: {err}")
                if tg_on:
                    try: send_telegram(f"⚠ <b>Auto-Squeeze-Entry FEHLGESCHLAGEN</b>\n"
                                       f"{sym} {d} @ {lvl} — {err}", tg["bot_token"], tg["chat_id"])
                    except Exception as e: log.warning(f"Squeeze-Telegram (Fehler): {e}")
                return
            self._squeeze_entry_count += 1
            if tg_on:
                try: send_telegram(f"🚀 <b>Auto-Squeeze-Entry</b>\n{sym} {d} selbständig "
                                   f"eröffnet (Ausbruch aus Kompression @ {lvl}).",
                                   tg["bot_token"], tg["chat_id"])
                except Exception as e: log.warning(f"Squeeze-Telegram: {e}")
        except Exception as e:
            log.error(f"_check_auto_squeeze: {e}", exc_info=True)

    def set_auto_squeeze(self, on: bool) -> bool:
        """Autonomen Squeeze-Entry an/aus (UI/Config). Rückgabe = neuer Zustand."""
        self._auto_squeeze = bool(on)
        self._squeeze_last_sig = None
        log.info(f"Auto-Squeeze-Entry {'AN' if self._auto_squeeze else 'AUS'}")
        self._save_runtime_state()
        return self._auto_squeeze

    def _check_auto_signal(self):
        """Autonomer Entry auf die EMPFEHLUNG (Wave-Signal), nur wenn FLAT.
        ⚠ GEMESSEN NICHT tragfähig (`backtest_auto_signal.py`: H1 ØR −0,05…−0,18 in
        BEIDEN Konfidenz-Stufen, H2 positiv = Regime-Kippen; Live-Dry-Run 2026-07-23
        WR 29 %/PF 0,64). Auf ausdrücklichen User-Wunsch (2026-07-30) gebaut, Default
        AUS, mit den gemessen besten Parametern (Konf≥75 + Nacht-Sperre) und dem
        15-Min-Adverse-Schutz. B4/B5: Live-Perf. gegen die Erwartung halten — driftet
        es weg, zurückbauen. Dedup: 1× je Signal-Episode (re-armt bei WARTEN/Flip)."""
        if not self._auto_signal:
            return
        if self._circuit_halted():        # Tagesverlust-Stopp → heute keine Auto-Trades
            return
        try:
            sig_snap = self.wave.signal() or {}
            d = sig_snap.get("signal")
            if d not in ("LONG", "SHORT"):
                self._signal_last_sig = None     # WARTEN → Episode zu Ende, re-armen
                return
            conf = sig_snap.get("conf_pct") or 0
            if conf < self._auto_signal_min_conf:
                return                            # zu schwach (Dedup NICHT setzen)
            # Nacht-Sperre — dasselbe Fenster wie beim Auto-Squeeze
            # (`auto_squeeze_night_hours`, Default 3–6). Kein Dedup-Marker, damit das
            # Signal danach noch feuern kann, falls es dann noch steht.
            # ⚠ Anders als beim Squeeze ist die Kostenfalle für die WELLEN-Population
            # gemessen einschlägig (alle Nacht-Bars 0,333×ATR) — hier ist der Guard also
            # auch ertrags-begründet. Der Pfad ist ohnehin aus (`auto_signal=false`).
            if (self._auto_signal_skip_night
                    and datetime.now(_BERLIN).hour in self._squeeze_night_hours):
                return
            # News-Blackout (s. `_check_auto_squeeze`) — kein Dedup-Marker.
            if self.calendar.blackout():
                return
            ps = self.trader.snapshot()
            if ps.get("ticket"):
                # Position offen: läuft sie in Signalrichtung, gilt die Episode als
                # „schon dabei" (kein Nachkauf); Gegen-Position wird NICHT gedreht
                # (unbelegt — dieselbe Begründung wie beim Squeeze-Reverse).
                pos_dir = "LONG" if ps.get("order_type") == 0 else "SHORT"
                if pos_dir == d:
                    self._signal_last_sig = d
                return
            if d == self._signal_last_sig:
                return                            # diese Episode schon gehandelt
            # Wiedereinstiegs-Sperren (wie beim Squeeze): nach S/R-Close bzw. nach
            # JEDEM Close nicht sofort gleichgerichtet neu eröffnen.
            now = time.time()
            if (d == self._sr_close_dir and now - self._sr_close_ts < _SQUEEZE_SR_COOLDOWN_S):
                return
            if (d == self._pos_close_dir and now - self._pos_close_ts < _SQUEEZE_REENTRY_COOLDOWN_S):
                return
            # ── NACHJAGD-BREMSE (2026-08-05, gemessen `backtest_auto_signal_v3.py`).
            # Der Market-Weg ist nur noch FALLBACK, wenn die ruhende Stop-Order am
            # Bestätigungs-Level nicht gegriffen hat. Am Level ØR +0,35/+0,32, am
            # Bar-Close −0,09/−0,11 — und der Härtetest zeigt den Kipp-Punkt bei
            # ~0,25–0,30×ATR Abstand (bei +0,20 noch +0,148/+0,090). Also nur bis
            # `squeeze_max_chase_atr` nachkaufen, sonst diese Episode auslassen.
            # ⚠ `_signal_last_sig` wird NICHT gesetzt → kommt der Kurs ans Level
            # zurück, darf der Entry noch kommen.
            ws = self.wave.snapshot() or {}
            bo = ws.get("breakout") or {}
            atr_m5 = (ws.get("pb_feats") or {}).get("atr") or 0.0
            lvl = bo.get("level") if bo.get("dir") == d else None
            tick = self.data.snapshot() or {}
            px = tick.get("ask") if d == "LONG" else tick.get("bid")
            if lvl and atr_m5 > 0 and px:
                weg = (float(px) - float(lvl)) * (1 if d == "LONG" else -1) / atr_m5
                if weg > self._squeeze_max_chase:
                    if self._signal_chase_logged != d:
                        self._signal_chase_logged = d
                        log.info(f"⏭ Auto-Signal übersprungen: Kurs steht schon "
                                 f"{weg:.2f}×ATR über dem Bestätigungs-Level {lvl} "
                                 f"(Grenze {self._squeeze_max_chase:.2f}) — "
                                 f"gemessen ab hier kein Edge mehr")
                    return
            self._signal_chase_logged = None
            self._signal_last_sig = d
            if isinstance(self._last_rec, dict):
                self._last_rec["setup"] = f"AUTOSIG_{d}"
            log.info(f"🎯 AUTO-SIGNAL-ENTRY: {d} (Konfidenz {conf}% ≥ "
                     f"{self._auto_signal_min_conf}%) — eröffne selbständig")
            err = (self.open_long(source="auto_signal") if d == "LONG"
                   else self.open_short(source="auto_signal"))
            sym = self.data.symbol or ""
            tg = self.cfg["telegram"]
            tg_on = (tg.get("enabled", "false").lower() == "true" and tg.get("bot_token"))
            if err:
                log.error(f"Auto-Signal-Entry fehlgeschlagen: {err}")
                self._signal_last_sig = None       # Fehlschlag → nächster Tick erneut
                if tg_on:
                    try: send_telegram(f"⚠ <b>Auto-Signal-Entry FEHLGESCHLAGEN</b>\n"
                                       f"{sym} {d} (Konf {conf}%) — {err}",
                                       tg["bot_token"], tg["chat_id"])
                    except Exception as e: log.warning(f"Signal-Telegram (Fehler): {e}")
                return
            self._signal_entry_count += 1
            if tg_on:
                try: send_telegram(f"🎯 <b>Auto-Signal-Entry</b>\n{sym} {d} selbständig "
                                   f"eröffnet (Empfehlung, Konfidenz {conf}%).",
                                   tg["bot_token"], tg["chat_id"])
                except Exception as e: log.warning(f"Signal-Telegram: {e}")
        except Exception as e:
            log.error(f"_check_auto_signal: {e}", exc_info=True)

    def set_auto_signal(self, on: bool) -> bool:
        """Autonomen Signal-Entry an/aus (UI/Config). Rückgabe = neuer Zustand."""
        self._auto_signal = bool(on)
        self._signal_last_sig = None
        log.info(f"Auto-Signal-Entry {'AN' if self._auto_signal else 'AUS'} "
                 f"(Konf≥{self._auto_signal_min_conf}%"
                 f"{', Nacht-Sperre' if self._auto_signal_skip_night else ''})")
        self._save_runtime_state()
        return self._auto_signal

    def _check_adverse15(self):
        """15-Minuten-Regel (User-Wunsch 2026-07-30): steht ein **vom Bot eröffneter**
        Trade 15 min nach Entry mehr als `adverse_15min_atr`×ATR im Minus → schließen
        (der Einstieg war falsch; gemessen: Gewinner nehmen Ø 0,19 $ Hitze, Verlierer
        0,41 $). ⚠ Schwelle GEMESSEN kalibriert = **0,5×ATR**; „sobald im Minus" wäre
        die schlechteste Variante (WR 39→31 %). Netto bringt die Regel über beide
        Halbjahre ~nichts (Regime-Schutz: hilft im schlechten, kostet im guten) —
        bewusst als Sicherheit eingebaut. Greift NICHT bei manuellen Trades (dort
        bleibt die Diskretion beim User) und nicht in der Startup-Schonfrist."""
        if self._adverse15_atr <= 0:
            return
        if self._in_startup_grace():
            return
        ps = self.trader.snapshot()
        ticket = ps.get("ticket")
        if not ticket:
            return
        if ticket != self._bot_open_ticket:      # nur Bot-eröffnete Trades
            return
        # ⚠ SQUEEZE-TRADES AUSGENOMMEN (gemessen `backtest_adverse15_squeeze.py`,
        # 2026-07-31). Die Schwelle 0,5×ATR wurde in `backtest_auto_signal.py` auf
        # WAVE-SIGNAL-Entries kalibriert und dann auf ALLE Bot-Trades angewandt —
        # wieder ein Kalibrierungs-Bruch. Auf SQUEEZE-Entries schadet die Regel bei
        # JEDER Schwelle in BEIDEN Hälften (Δ gegen „ohne Regel": 0,3 → −25/−38 ·
        # **0,5 → −18/−34** · 0,8 → −12/−39 · 1,2 → −5/−18) — monoton, d. h. die
        # Regel selbst ist das Problem, nicht ihre Einstellung. Grund: der Squeeze ist
        # runner-abhängig (43 % Treffer, Ertrag im Tail), und ein Schnitt nach 15 min
        # trifft genau den Tail. Ohne Regel H1 −54/H2 **+220**, mit 0,5 H1 −72/H2 +186.
        # Anlass war der 31.07.: zwei Squeeze-Trades wurden per adverse15 gekappt
        # (−13,77 / −28,09 €), danach wären +19,28 bzw. +17,60 € möglich gewesen —
        # während dieselbe Regel beim Auto-Signal-Trade desselben Tages 32 € rettete.
        if self._bot_open_source == "auto_squeeze":
            return
        if ticket == self._adverse15_done_ticket:  # je Ticket nur 1× prüfen
            return
        ot = ps.get("open_time") or 0
        if not ot:
            return
        age = time.time() - float(ot)
        if age < 15 * 60:
            return                                # noch keine 15 min alt
        self._adverse15_done_ticket = ticket      # Prüfzeitpunkt erreicht → 1× bewerten
        # Verlust in ATR messen (M5-ATR wie im Backtest, Floor wie live)
        try:
            atr = float(((self.wave.snapshot() or {}).get("pb_feats") or {}).get("atr") or 0.0)
        except Exception:
            atr = 0.0
        atr = max(atr, 0.06)
        entry = float(ps.get("entry_price") or 0.0)
        cur = float(ps.get("cur_price") or 0.0)
        if not entry or not cur:
            return
        d = 1 if ps.get("order_type") == 0 else -1
        adverse_atr = (entry - cur) * d / atr     # >0 = läuft gegen die Position
        if adverse_atr < self._adverse15_atr:
            log.info(f"15-Min-Check (Pos {ticket}): {adverse_atr:+.2f}×ATR gegen die "
                     f"Position — unter Schwelle {self._adverse15_atr:.2f}, läuft weiter")
            return
        pnl = ps.get("pnl")
        log.warning(f"⏱ 15-MIN-ADVERSE-CLOSE: Pos {ticket} läuft {adverse_atr:.2f}×ATR "
                    f"gegen die Richtung (≥ {self._adverse15_atr:.2f}) — P&L "
                    f"{(pnl if pnl is not None else 0):+.2f} → Einstieg war falsch, schließen")
        err = self.trader.close(reason="adverse15")
        tg = self.cfg["telegram"]
        tg_on = (tg.get("enabled", "false").lower() == "true" and tg.get("bot_token"))
        if err:
            log.error(f"15-Min-Adverse-Close fehlgeschlagen: {err}")
            self._adverse15_done_ticket = None    # Fehlschlag → nächster Tick erneut
            return
        self._adverse15_count += 1
        if tg_on:
            try: send_telegram(f"⏱ <b>15-Min-Regel</b>\n{self.data.symbol or ''} nach 15 min "
                               f"{adverse_atr:.2f}×ATR gegen die Richtung (P&L "
                               f"{(pnl if pnl is not None else 0):+.2f}) → geschlossen.",
                               tg["bot_token"], tg["chat_id"])
            except Exception as e: log.warning(f"Adverse15-Telegram: {e}")

    def set_sr_autoclose(self, on: bool) -> bool:
        """Automatischen S/R-Close an/aus (UI/Config). Rückgabe = neuer Zustand."""
        self._auto_sr_close = bool(on)
        log.info(f"Auto-S/R-Close {'AN' if self._auto_sr_close else 'AUS'}")
        self._save_runtime_state()
        return self._auto_sr_close

    def set_sr_close_min_gain(self, value) -> float:
        """Mindestgewinn (EUR) für den S/R-Auto-Close. 0/leer = aus."""
        try:
            v = max(0.0, float(value)) if value not in (None, "") else 0.0
        except (TypeError, ValueError):
            v = 0.0
        self._sr_close_min_gain = v
        log.info(f"S/R-Close-Mindestgewinn {('+' + format(v, '.2f')) if v > 0 else 'aus'}")
        self._save_runtime_state()   # neustart-fest (Fix 2026-07-22 — war vergessen)
        return self._sr_close_min_gain

    def set_sltp(self, sl=None, tp=None) -> dict:
        """Manuelles SL/TP der offenen Position setzen. **Deaktiviert das Trailing**
        (User-Vorgabe) — sonst zöge es SL/TP beim nächsten Tick wieder um. Rückgabe
        {ok, sl, tp} oder {ok:false, error}."""
        err = self.trader.modify_sltp(sl, tp)
        if err:
            return {"ok": False, "error": err}
        was = self.trail.deactivate()
        if self.data.symbol:
            self.trader.refresh(self.data.symbol)   # Snapshot mit neuen Werten
        ps = self.trader.snapshot()
        log.info(f"Manuelles SL/TP übernommen — Trailing "
                 f"{'AUS (war an)' if was else 'war bereits aus'}")
        return {"ok": True, "sl": ps.get("sl"), "tp": ps.get("tp"), "trail_was_on": was}

    def _tu_loop(self):
        while self._running:
            try:
                self.tu.fetch()
            except Exception as e:
                log.warning(f"_tu_loop: {e}")
            self._sleep(_TU_S)

    def _news_loop(self):
        if self._sleep(6):     # kurz warten, bis MT5/Feeds bereit sind
            return
        while self._running:
            try:
                self.news.fetch()
            except Exception as e:
                log.warning(f"_news_loop: {e}")
            if self._sleep(self._news_refresh_s):
                return

    def _agent_loop(self):
        if self._sleep(_AGENT_WARMUP):
            return
        while self._running:
            try:
                if self.agent.auto_enabled and self.agent.is_configured():
                    ok = self.agent.analyze()
                    if ok:
                        adv = self.agent.snapshot().get("advisory") or {}
                        tf = adv.get("timeframe")
                        if tf and self._tf_select == "agent":
                            self._apply_wave_tf(tf)
                        if self.agent.tg_push:
                            self._agent_telegram()
                    snaps = self.agent.snapshot()
                    self._agent_fail_cnt = (0 if not snaps.get("error")
                                            else min(self._agent_fail_cnt + 1, 5))
            except Exception as e:
                log.error(f"_agent_loop: {e}", exc_info=True)
            # Backoff bei wiederholten Fehlern (Quota schonen)
            interval = min(self.agent.interval_min * (2 ** self._agent_fail_cnt), 120)
            if self._sleep(interval * 60):
                return

    def _sleep(self, secs: float) -> bool:
        """Schläft `secs`, aber in 0.5-s-Schritten unterbrechbar.
        Gibt True zurück, wenn die Engine in der Zwischenzeit gestoppt wurde."""
        end = time.time() + secs
        while time.time() < end:
            if not self._running:
                return True
            time.sleep(min(0.5, max(0.0, end - time.time())))
        return not self._running

    # ── Analyse (entspricht _do_refresh_analysis im Widget) ────────────────
    def _run_analysis(self):
        s = self.data.snapshot()
        if self._export_mql5:
            self._write_levels_file()
        self.trail.set_sr(s.get("sr"))
        self.trail.set_trend_angle(s.get("angles", {}).get("M15", 90.0))

        rec = self.wave.signal()
        self._check_close_alert(rec)

        # Empfehlung in die DB loggen (für Tages-Reviews; eigenes Throttling in
        # history.log_recommendation → flutet nicht).
        try:
            adv = (self.agent.snapshot() or {}).get("advisory") or {}
            # News-Sentiment mitloggen (2026-07-24, Idee 6): war seit einer Weile
            # None — wieder befüllt, damit die Prädiktivität in ein paar Monaten
            # messbar ist (analyze_verdict_calibration.py fand H2 nur n=4/6).
            try:
                _news = float((self.news.sentiment or {}).get("score") or 0.0)
            except Exception:
                _news = None
            self.history.log_recommendation(
                signal=rec.get("signal"), score=float(rec.get("score") or 0.0),
                conf_pct=int(rec.get("conf_pct") or 0),
                angles=s.get("angles") or {},
                reversal=("rev" if "REV" in (rec.get("setup") or "") else None),
                ai_sentiment=adv.get("bias"), ai_confidence=adv.get("confidence"),
                setup=rec.get("setup"), regime=None, rsi=s.get("rsi_m15"),
                news_score=_news,
                # Stufe-2-Telemetrie (2026-07-31): WELCHES Gate blockt gerade?
                # Ohne das war live nicht feststellbar, warum der Bot zu 93 %
                # WARTEN sagt (Backtest-Erwartung ~43 %).
                block=rec.get("block"))
        except Exception as e:
            log.warning(f"log_recommendation: {e}")

        # ── Selbst-Kalibrierung: eine Zeile je EPISODE (2026-08-06) ──────────
        # WARUM: die Qualitaet der Empfehlung war bis heute unsichtbar — sie musste
        # auf Nachfrage rueckwirkend gemessen werden (`analyze_signal_live.py`:
        # 48–51 % Treffer ueber 1.071 Episoden). Dasselbe Muster wie
        # `pbreak_predictions` hat den Ausfall des P(break)-Modells LIVE aufgedeckt,
        # was kein Backtest konnte. Reine Messung, kein Eingriff in die Logik.
        # ⚠ Nur bei RICHTUNGSWECHSEL, nicht je Minute — sonst zaehlt man dieselbe
        # Marktlage dutzendfach (der Fehler, den die Episoden-Bildung behebt).
        try:
            _sig = rec.get("signal")
            if _sig in ("LONG", "SHORT") and _sig != getattr(self, "_rec_epi_sig", None):
                _atr = float((s.get("pb_feats") or {}).get("atr") or 0.0)
                _px = float((self.data.snapshot() or {}).get("bid") or 0.0)
                if _atr > 0 and _px > 0 and self.history:
                    self.history.log_rec_outcome(
                        signal=_sig, conf_pct=int(rec.get("conf_pct") or 0),
                        tf=str(rec.get("tf") or self.wave.timeframe_name or ""),
                        price=_px, atr=_atr)
            if _sig in ("LONG", "SHORT", "WARTEN"):
                # WARTEN re-armt: die naechste Richtung ist eine NEUE Episode.
                self._rec_epi_sig = _sig if _sig != "WARTEN" else None
        except Exception as e:
            log.debug(f"log_rec_outcome: {e}")

        # Verdict-Stimmen-Logging (2026-07-24, Idee 2b): Modul-Votes 1×/min in die
        # DB (`verdict_votes`), damit die UNBELEGTEN Stimmen (KI-Copilot, Elliott)
        # nach ein paar Wochen datenbasiert bewertet werden können (behalten /
        # Gewicht senken / raus wie TU). Erste Messung (analyze_verdict_calibration.
        # py, 2026-07-24): Copilot nicht robust prädiktiv, n aber klein → sammeln.
        try:
            vd = self._verdict(s, rec, self.wave.snapshot(), self.tu.snapshot(),
                               self.agent.snapshot(), self.elliott.snapshot(),
                               self.patterns.snapshot())
            vv = {v["name"]: v for v in vd.get("votes") or []}
            def _v(name, key="vote"):
                return (vv.get(name) or {}).get(key, 0)
            self.history.log_verdict_votes(
                headline=vd.get("headline") or "WARTEN",
                conf=int(vd.get("conf") or 0), bias=float(vd.get("bias") or 0.0),
                tf=vd.get("tf") or "", wave=_v("Welle"), m30=_v("M30"), h1=_v("H1"),
                ki=_v("KI-Copilot"), ki_w=float(_v("KI-Copilot", "weight") or 0.0),
                elliott=_v("Elliott"), elliott_w=float(_v("Elliott", "weight") or 0.0),
                squeeze=_v("Squeeze"), news_score=_news,
                # Die drei ab 2026-07-30 ergänzten Stimmen MITLOGGEN — nur so ist in
                # ein paar Wochen datenbasiert entscheidbar, ob sie bleiben (Muster:
                # Kontrolltest zeigt kleinen Zusatz) bzw. ob die UNGEMESSENEN
                # Orderbuch-/Liq-Trend-Stimmen überhaupt Prädiktivität haben.
                pattern=_v("Muster"), pattern_w=float(_v("Muster", "weight") or 0.0),
                orderbook=_v("Orderbuch"),
                orderbook_w=float(_v("Orderbuch", "weight") or 0.0),
                liqtrend=_v("Liq-Trend"),
                liqtrend_w=float(_v("Liq-Trend", "weight") or 0.0))
        except Exception as e:
            log.debug(f"log_verdict_votes: {e}")

        # Kontext für Trade-Logging (set_open_context beim Öffnen)
        # ── Voller Entscheidungszustand beim Einstieg (Stufe 1 „Manuelle Trades",
        # 2026-08-04). Bis dahin wurden 5 Felder gespeichert, davon zwei fast nie
        # befüllt — die Marktlage eines manuellen Einstiegs war damit NICHT
        # rekonstruierbar. Alles hier ist bereits berechnet (Snapshot-Teile), es
        # wird nur eingesammelt. Reine Telemetrie, kein Verhalten.
        _ctx = {}
        try:
            # ⚠ `wave_snap` existiert in dieser Methode NICHT (anders als in
            # `snapshot()`) — hier den Snapshot selbst holen. Ein NameError wäre vom
            # `except` unten still geschluckt worden und hätte den Kontext dauerhaft
            # leer gelassen, ohne dass es jemand merkt.
            _ws = self.wave.snapshot() or {}
            _bid = s.get("bid")
            _atr5 = (_ws.get("pb_feats") or {}).get("atr")
            _sh = self._last_sr_close_hint or {}
            _sa = self._last_stop_approach or {}
            _dl = self._draw_levels() or {}
            _res = (_dl.get("res") or [None])[0]
            _sup = (_dl.get("sup") or [None])[0]
            _st = (self.structure.snapshot() or {}).get("trend")
            _sq = (_ws.get("squeeze") or {}).get("state")
            _ses = (session_state() or {}).get("phase")
            _cone = self._last_cone or {}
            _c120 = next((l for l in (_cone.get("levels") or [])
                          if l.get("band") == 80 and l.get("minutes") == 120), None)
            _ctx = {
                "p_break_target": _sh.get("p_break"),
                "p_break_stop":   _sa.get("p_break"),
                "dist_res_atr":   (round((_res - _bid) / _atr5, 2)
                                   if (_res and _bid and _atr5) else None),
                "dist_sup_atr":   (round((_bid - _sup) / _atr5, 2)
                                   if (_sup and _bid and _atr5) else None),
                "structure":      _st,
                "squeeze":        _sq,
                "htf_trend":      _ws.get("htf_trend"),
                "h1_trend":       _ws.get("h1_trend"),
                "spread_atr":     (round(float(s.get("spread") or 0) / _atr5, 3)
                                   if _atr5 else None),
                "session":        _ses,
                "block_reason":   rec.get("block"),
                "conf_pct":       rec.get("conf_pct"),
                "atr_m5":         (round(_atr5, 4) if _atr5 else None),
                # `vd` entsteht oben in einem try — bei einem Fehler dort wäre es
                # gar nicht definiert. `locals()`-Guard statt NameError.
                "bias":           (locals().get("vd") or {}).get("bias"),
                # Position im 120-min-Kegel: 0 = unteres Band, 1 = oberes
                "cone_pos":       (round((_bid - _c120["lo"])
                                         / max(_c120["hi"] - _c120["lo"], 1e-9), 3)
                                   if (_c120 and _bid) else None),
                "hour":           datetime.now(_BERLIN).hour,
            }
        except Exception as e:
            log.debug(f"open-context: {e}")
        self._last_rec = {
            "rec_signal":    rec.get("signal"),
            "rec_score":     rec.get("score"),
            "ai_sentiment":  None,
            "ai_confidence": None,
            "setup":         rec.get("setup"),
            "regime":        None,
            "rsi":           s.get("rsi_m15"),
            "news_score":    _news,
            "ctx":           _ctx,
        }

    def _check_flip_close(self):
        """Auto-Flip-Close: dreht die Empfehlung GEGEN die offene Position und steht
        sie mindestens `min_r`×ATR im Plus → schließen. (`[trading] auto_flip_close`)

        ⚠⚠ **GEMESSEN NEGATIV — auf ausdrücklichen User-Wunsch trotzdem gebaut**
        (2026-07-31 „schließe den Trade automatisch beim Close-Signal").
        `backtest_flipclose2.py` (80k M5, 2 Halbjahre, Echtkosten, Exit aus
        `core/exit_model.py`) — JEDE Variante ist in BEIDEN Hälften schlechter als
        gar kein Flip-Close:
            Basis (kein Flip)   H1 ΣR −537 · H2 −140
            Flip ab 0,0×ATR     Δ H1 −126 · H2 −221
            Flip ab 0,3×ATR     Δ H1  −77 · H2 −216
            Flip ab 0,5×ATR     Δ H1  −92 · H2 −160   ← die MILDESTE, deshalb Default
            Flip auch im Minus  Δ H1 −205 · H2 −364
        Mechanik: die Trefferquote steigt (39 → 45 %), der Ertrag fällt —
        **Gewinner-Kappen**, weil die nachlaufende EMA oft mitten im Pullback dreht
        und der Trade weitergelaufen wäre.
        ⚠ Das bestätigt das ältere Urteil (`backtest_flipclose.py`, 2026-07-16). Die
        Neumessung war trotzdem nötig: das alte Skript nutzte ein VIERTES Exit-Modell
        (Trail fest 1,5 · keine Lock-Phase · kein Time-Stop · kein Initial-TP ·
        `_MAXH` 288 · Phasen über den Bar-Close statt über das High-Water) — auf
        dieser Grundlage wäre das Urteil für den Live-Betrieb nicht bindend gewesen.
        **B4/B5-Pflicht:** Live-Ertrag gegen die Erwartung halten; driftet es weg →
        `auto_flip_close=false`. Der Alarm (Blinken/Ton/Telegram) bleibt unabhängig
        davon bestehen.
        """
        if not self._flip_close or self._in_startup_grace():
            return
        try:
            ps = self.trader.snapshot()
            ticket = ps.get("ticket")
            if not ticket:
                self._flip_close_done_ticket = None
                return
            if ticket == self._flip_close_done_ticket:
                return                       # für dieses Ticket schon ausgelöst
            pnl = float(ps.get("pnl") or 0.0)
            if pnl <= 0:
                return                       # nie im Minus (gemessen die schlechteste Variante)
            sig = (self.wave.signal() or {}).get("signal")
            if sig not in ("LONG", "SHORT"):
                return
            is_long = ps.get("order_type") == mt5.ORDER_TYPE_BUY
            if (is_long and sig != "SHORT") or (not is_long and sig != "LONG"):
                return                       # kein Gegen-Signal
            # Mindestgewinn in ×ATR (M5, wie im Backtest)
            atr = float(((self.wave.snapshot() or {}).get("pb_feats") or {}).get("atr") or 0.0)
            entry = float(ps.get("entry_price") or 0.0)
            bid = float((self.data.snapshot() or {}).get("bid") or 0.0)
            if atr > 0 and entry and bid:
                d = 1 if is_long else -1
                prof_atr = (bid - entry) * d / max(atr, 0.06)
                if prof_atr < self._flip_close_min_r:
                    return
            else:
                return                       # ohne ATR keine Schwelle → nicht schließen
            # ── NACHRANG gegenüber dem S/R-Close (gemessen `backtest_exit_combo.py`,
            # 2026-07-31): liegt ein S/R-ZIEL in Reichweite (≤0,6×ATR, dieselbe
            # Schwelle wie der Live-Hinweis), hat der **validierte** Exit Vorrang und
            # der Flip hält sich zurück. Grund: der Flip nahm dem S/R-Close messbar
            # Trades weg (535→507 in H1, 284→252 in H2 = 5–11 %) — und zwar genau
            # die, für die dieser validiert ist. Mit Nachrang ist es in BEIDEN
            # Hälften besser als ohne (H1 +62 statt +56, H2 −49 statt −50).
            # `auto_flip_close_subordinate=false` schaltet den Nachrang ab.
            if self._flip_close_subordinate:
                try:
                    dl = self._draw_levels()
                    tgt = (dl.get("res") or [None])[0] if is_long \
                        else (dl.get("sup") or [None])[0]
                    if tgt is not None and abs(tgt - bid) <= 0.6 * max(atr, 0.06):
                        return               # S/R-Ziel in Reichweite → Vorrang dort
                except Exception:
                    pass
            self._flip_close_done_ticket = ticket
            log.info(f"🔄 AUTO-FLIP-CLOSE: Empfehlung dreht auf {sig} — "
                     f"{'LONG' if is_long else 'SHORT'} bei P&L {pnl:+.2f} € "
                     f"({prof_atr:.2f}×ATR) geschlossen")
            err = self.trader.close(reason="flip_close")
            if err:
                log.error(f"Auto-Flip-Close fehlgeschlagen: {err}")
                self._flip_close_done_ticket = None      # nächster Tick erneut
                return
            self._flip_close_count += 1
            tg = self.cfg["telegram"]
            if tg.get("enabled", "false").lower() == "true" and tg.get("bot_token"):
                try:
                    send_telegram(
                        f"🔄 <b>AUTO-FLIP-CLOSE</b>\n{self.data.symbol or ''} "
                        f"{'LONG' if is_long else 'SHORT'} geschlossen — Empfehlung "
                        f"dreht auf {sig}.\nGewinn {pnl:+.2f} € ({prof_atr:.2f}×ATR)",
                        tg["bot_token"], tg["chat_id"])
                except Exception as e:
                    log.warning(f"Flip-Close-Telegram: {e}")
        except Exception as e:
            log.error(f"_check_flip_close: {e}", exc_info=True)

    def _check_close_alert(self, rec: dict):
        """Telegram-CLOSE-Alarm NUR bei Signal-Flip gegen die Position (echter
        Wende-Grund). Max. 1×/5 min (`_CLOSE_ALERT_COOLDOWN_S`) — sonst spammt es.
        Auch bei gesperrtem Handy. (S/R-Ziel-Alarm entfernt — stupste zum verfrühten
        Gewinner-Kappen; den Gewinner führt das Trailing.)"""
        ps = self.trader.snapshot()
        ticket = ps.get("ticket")
        if not ticket:
            return   # keine Position → kein Alarm; Cooldown NICHT zurücksetzen
                     # (ein kurz flackerndes Ticket darf den Cooldown nicht killen)
        if ticket != self._close_alert_ticket:
            self._close_alert_ticket = ticket
            self._close_alert_ts = 0.0   # NUR bei echter neuer Position sofort melden
        is_long = ps.get("order_type") == mt5.ORDER_TYPE_BUY
        sig = rec.get("signal")
        pnl = ps.get("pnl") or 0.0

        # Close-Alarm NUR bei Signal-FLIP gegen die Position (echter Wende-Grund).
        # Der frühere S/R-Ziel-Alarm wurde entfernt — er stupste zum verfrühten
        # Kappen der Gewinner (Verlust-Schiefe); den Gewinner führt das Trailing.
        reason = None
        if pnl > 0:                     # Close-Alarm NUR bei Trade im Plus
            if (is_long and sig == "SHORT") or (not is_long and sig == "LONG"):
                reason = f"Empfehlung dreht auf {sig} ({rec.get('conf_pct')}%) — Gewinn sichern"

        if not reason:
            return
        if time.time() - self._close_alert_ts < _CLOSE_ALERT_COOLDOWN_S:
            return                      # innerhalb des 5-min-Cooldowns — kein Spam
        self._close_alert_ts = time.time()
        self._close_alert_count += 1
        log.info(f"🔔 Flip-Close-Alarm #{self._close_alert_count}: "
                 f"{self.data.symbol or ''} {'LONG' if is_long else 'SHORT'} "
                 f"P&L {pnl:+.2f} — {reason}")
        tg = self.cfg["telegram"]
        if tg.get("enabled", "false").lower() == "true" and tg.get("bot_token"):
            try:
                send_telegram(
                    f"🔔 <b>CLOSE-Signal</b>\n"
                    f"{self.data.symbol or ''} — offene "
                    f"{'LONG' if is_long else 'SHORT'}-Position (P&L {pnl:+.2f})\n"
                    f"{reason} — Schließen erwägen.",
                    tg["bot_token"], tg["chat_id"])
            except Exception as e:
                log.warning(f"Close-Telegram: {e}")

    def _apply_wave_tf(self, tf_label: str, source: str = ""):
        """Wellen-Timeframe übernehmen (Wave/Elliott/Trailing koppeln).
        Ein laufender Trade behält seinen eingefrorenen TF."""
        tf_label = (tf_label or "").upper().strip()
        const = _ATR_TF_MAP.get(tf_label)
        if const is None or tf_label == self._wave_tf_label:
            return
        self._wave_tf_label = tf_label
        self.wave.set_timeframe(const)
        self.elliott.set_timeframe(const)
        self.trail.set_atr_tf_override(const)
        if self.data.symbol:
            threading.Thread(
                target=lambda: self.wave.refresh_market(self.data.symbol),
                daemon=True).start()
        log.info(f"Wellen-Timeframe → {tf_label}{(' ('+source+')') if source else ''}")
        # Nur im Speicher merken — NICHT in die oil_widget_config.ini schreiben:
        # save_config() schreibt die ganze (Secrets-)Datei neu und verliert dabei
        # alle Kommentare; bei jedem Heuristik-Switch wäre das ständiger Churn.
        # Beim Neustart wählt die Heuristik den TF binnen einer Minute ohnehin neu.
        try:
            self.cfg["trading"]["atr_tf"] = tf_label
        except Exception:
            pass

    # ── TF-Heuristik: TF mit dem klarsten handelbaren EMA-Trend wählen ────────
    _TF_BIAS = 0.10   # höhere TF leicht bevorzugen (Stabilität): weight = 1+rank*bias

    def _choose_tf(self, sym: str):
        """Bewertet die erlaubten TF nach Trendklarheit (|EMA12-EMA50|/ATR, nicht
        überdehnt), bevorzugt höhere TF leicht und respektiert tf_min.
        Gibt (beste_TF, scores) zurück."""
        order = list(_ATR_TF_MAP.keys())          # M1..H1
        min_rank = order.index(self._tf_min) if self._tf_min in order else order.index("M5")
        max_rank = order.index(self._tf_max) if self._tf_max in order else len(order) - 1
        scores: dict = {}
        best_lbl, best_score = None, 0.0
        with mt5_lock(timeout=2) as got:
            if not got:
                return None, scores
            for rank, (lbl, tf) in enumerate(_ATR_TF_MAP.items()):
                if rank < min_rank or rank > max_rank:   # außerhalb [tf_min … tf_max]
                    scores[lbl] = 0.0; continue
                r = mt5.copy_rates_from_pos(sym, tf, 0, 80)
                if r is None or len(r) < _EMA_SLOW + 5:
                    scores[lbl] = 0.0; continue
                h = [float(b["high"]) for b in r]
                l = [float(b["low"])  for b in r]
                c = [float(b["close"]) for b in r]
                atr = _wr_atr(h, l, c)
                if not atr or atr <= 0:
                    scores[lbl] = 0.0; continue
                ef = _ema_last(c, _EMA_FAST); es = _ema_last(c, _EMA_SLOW)
                sep     = abs(ef - es) / atr
                stretch = abs(c[-1] - es) / atr
                raw = sep if (sep >= _TREND_DEADBAND and stretch <= _STRETCH_MAX) else 0.0
                score = raw * (1.0 + rank * self._TF_BIAS)   # höhere TF leicht bevorzugt
                scores[lbl] = round(score, 2)
                if score > best_score:
                    best_score, best_lbl = score, lbl
        return best_lbl, scores

    def _tf_loop(self):
        if self._tf_select != "heuristic":
            return   # feste TF oder Agent steuert → keine Heuristik
        if self._sleep(8):
            return
        while self._running:
            try:
                if self.data.symbol:
                    best, scores = self._choose_tf(self.data.symbol)
                    cur = self._wave_tf_label
                    # ── Mindest-Verweildauer (Fix 2026-07-31) ────────────────────
                    # Die 1,2×-Hysterese unten ist WIRKUNGSLOS, sobald der Score der
                    # aktuellen TF auf exakt 0,0 fällt — und genau das tut er, sobald
                    # sie überdehnt ist (`_choose_tf`). Im Trend kippt M5 dadurch
                    # regelmäßig raus (Score 0,00) und nach dem nächsten Rücksetzer
                    # wieder rein (1,93): real 33 Wechsel/Tag, Median-Abstand 5 min.
                    # Zusammen mit dem `_pend`-Reset (dort gefixt) hielt das die
                    # Breakout-Bestätigung dauerhaft offen → 93 % WARTEN live gegen
                    # ~43 % Backtest-Erwartung. Die Verweildauer gibt einer TF Zeit,
                    # ihr Signal überhaupt fertig zu bestätigen. 0 = aus.
                    now = time.time()
                    dwell_ok = (self._tf_min_dwell_s <= 0 or
                                (now - self._tf_last_switch) >= self._tf_min_dwell_s)
                    # Hysterese: nur wechseln, wenn klar besser (kein Flattern)
                    if dwell_ok and best and best != cur and \
                       scores.get(best, 0) > scores.get(cur, 0) * 1.2:
                        self._tf_last_switch = now
                        self._apply_wave_tf(best, source=f"Heuristik {scores}")
            except Exception as e:
                log.warning(f"_tf_loop: {e}")
            if self._sleep(60):
                return

    def _load_report_state(self):
        """Letzte Report-Versanddaten laden (überlebt Neustarts, s. __init__)."""
        try:
            import json
            with open(self._report_state_path, encoding="utf-8") as f:
                st = json.load(f)
            self._daily_last_run = st.get("daily") or None
            wk = st.get("weekly")
            self._weekly_last_run = tuple(wk) if wk else None
        except FileNotFoundError:
            pass
        except Exception as e:
            log.warning(f"report_state laden: {e}")

    def _save_report_state(self):
        try:
            import json
            with open(self._report_state_path, "w", encoding="utf-8") as f:
                json.dump({"daily": self._daily_last_run,
                           "weekly": list(self._weekly_last_run)
                                     if self._weekly_last_run else None}, f)
        except Exception as e:
            log.warning(f"report_state speichern: {e}")

    def _load_runtime_state(self):
        """UI-gesetzte Einstellungen laden (überleben Neustarts). Nur Keys, die
        auch in der Datei stehen, überschreiben die ini-Defaults."""
        try:
            import json
            with open(self._runtime_state_path, encoding="utf-8") as f:
                st = json.load(f)
            if "auto_squeeze" in st:
                self._auto_squeeze = bool(st["auto_squeeze"])
            if "auto_signal" in st:
                self._auto_signal = bool(st["auto_signal"])
            if "auto_sr_close" in st:
                self._auto_sr_close = bool(st["auto_sr_close"])
            if "sr_close_min_gain" in st:
                self._sr_close_min_gain = max(0.0, float(st["sr_close_min_gain"] or 0))
            if "manual_margin" in st:
                from core.config import set_manual_margin as _set
                self._manual_margin = _set(st["manual_margin"] or 0)
            if "margin_pct" in st:
                from core.config import set_margin_buffer as _setp, get_margin_buffer
                _setp(float(st["margin_pct"] or 0) or 95.0)
                self._margin_pct = round(get_margin_buffer() * 100.0, 1)
            if "cone_skalen" in st:
                # ⚠ JSON liefert String-Schluessel → auf int zurueckholen, sonst
                # findet `cone.build` sie nicht (es sucht nach `bars` als int).
                # ⚠ Der Block MUSS im `try` stehen: der erste Entwurf landete
                # hinter den except-Klauseln, wo `st` gar nicht mehr existiert.
                self._cone_skalen = {int(k): float(v)
                                     for k, v in (st["cone_skalen"] or {}).items()}
            log.info(f"Runtime-State geladen: BRK={'AN' if self._auto_squeeze else 'aus'} · "
                     f"S/R-Close={'AN' if self._auto_sr_close else 'aus'} · "
                     f"MinGewinn={self._sr_close_min_gain:+.2f} · "
                     f"Einsatz={'auto' if not getattr(self, '_manual_margin', 0) else f'{self._manual_margin:.2f}'}"
                     f" · Einsatz-%={getattr(self, '_margin_pct', 0):.0f}")
        except FileNotFoundError:
            pass
        except Exception as e:
            log.warning(f"runtime_state laden: {e}")

    def _save_runtime_state(self):
        try:
            import json, os
            tmp = self._runtime_state_path + ".tmp"
            with open(tmp, "w", encoding="utf-8") as f:
                json.dump({"auto_squeeze": self._auto_squeeze,
                           "auto_signal": self._auto_signal,
                           "auto_sr_close": self._auto_sr_close,
                           "sr_close_min_gain": self._sr_close_min_gain,
                           "manual_margin": getattr(self, "_manual_margin", 0.0),
                           "margin_pct": getattr(self, "_margin_pct", 0.0),
                           # Kegel-ACI-Skalen (2026-08-08): ohne Persistenz waere
                           # die muehsam erlernte Kalibrierung nach jedem Neustart
                           # weg und liefe von 1,0 neu an. ⚠ JSON-Schluessel sind
                           # Strings — `cone.build` und der ACI-Schritt lesen
                           # deshalb beide Formen (int UND str).
                           "cone_skalen": {str(k): v for k, v in
                                           (getattr(self, "_cone_skalen", None)
                                            or {}).items()}}, f)
            os.replace(tmp, self._runtime_state_path)
        except Exception as e:
            log.warning(f"runtime_state speichern: {e}")

    def _load_emergency_state(self):
        """Aktiven Notfall-Stop/Take-Profit + zugehöriges Ticket laden (überlebt
        Neustarts). Wird in `_check_auto_close` nur angewandt, solange dasselbe
        Ticket noch offen ist — sonst armiert die neue Position normal."""
        try:
            import json
            with open(self._emergency_state_path, encoding="utf-8") as f:
                st = json.load(f)
            self._emergency_state_ticket = st.get("ticket")
            self._emergency_state_loss = st.get("loss")
            self._emergency_state_tp = st.get("tp")
            self._emergency_state_trail = st.get("trail")
        except FileNotFoundError:
            pass
        except Exception as e:
            log.warning(f"emergency_state laden: {e}")

    def _save_emergency_state(self):
        """Notfall-Stop/TP + Ticket atomar persistieren (bei Auto-Arm UND manuellem
        Set) — damit ein Neustart/Wiedererkennen die Schwelle nicht auf die Automatik
        zurücksetzt (Fix 2026-07-17)."""
        try:
            import json, os
            tmp = self._emergency_state_path + ".tmp"
            with open(tmp, "w", encoding="utf-8") as f:
                json.dump({"ticket": self._last_pos_ticket,
                           "loss": self._emergency_loss,
                           "tp": self._takeprofit,
                           "trail": bool(self.trail.enabled)}, f)
            os.replace(tmp, self._emergency_state_path)
            self._emergency_state_ticket = self._last_pos_ticket
            self._emergency_state_loss = self._emergency_loss
            self._emergency_state_tp = self._takeprofit
            self._emergency_state_trail = bool(self.trail.enabled)
        except Exception as e:
            log.warning(f"emergency_state speichern: {e}")

    def _daily_loop(self):
        """Holt 1×/Tag ab 07:30 Berlin die Tages-Level (Web-Recherche). Fail-safe:
        bei Fehlschlag bis zu 3 Versuche, dann Tag abhaken (alte Level bleiben)."""
        from datetime import datetime
        from zoneinfo import ZoneInfo
        berlin = ZoneInfo("Europe/Berlin")
        if self._sleep(10):
            return
        while self._running:
            try:
                now = datetime.now(berlin)
                today = now.date().isoformat()
                due = (self._daily_last_run != today
                       and (now.hour, now.minute) >= (7, 30))
                if due and self.data.symbol:
                    price = (self.data.snapshot() or {}).get("bid")
                    if self.daily.is_configured() and price:
                        self.daily.run(price)            # best-effort, fail-safe
                    ok = self._send_daily_report()        # Telegram + E-Mail
                    if ok or self._daily_fails >= 2:
                        self._daily_last_run = today; self._daily_fails = 0
                        self._save_report_state()
                    else:
                        self._daily_fails += 1
                # B4-Wochenreport: montags ab 07:30, 1×/Woche (Track B)
                wk = now.isocalendar()[:2]
                if (now.weekday() == 0 and (now.hour, now.minute) >= (7, 30)
                        and self._weekly_last_run != wk):
                    if self._send_weekly_report():
                        self._weekly_last_run = wk
                        self._save_report_state()
            except Exception as e:
                log.warning(f"_daily_loop: {e}")
            if self._sleep(120):
                return

    def _send_daily_report(self) -> bool:
        """Tagesreport = heutige Web-Prognose + Vortags-Bilanz → Telegram +
        E-Mail (trading@hocks.eu). True, wenn min. ein Kanal sendete. Fail-safe."""
        from datetime import datetime, timedelta
        try:
            st = self.history.stats_overview("yesterday") or {}
        except Exception as e:
            log.warning(f"daily stats: {e}"); st = {}
        n   = st.get("n_trades", 0); pnl = st.get("total_pnl", 0.0) or 0.0
        wr  = st.get("winrate", 0.0) or 0.0; pf = st.get("profit_factor")
        cur = (self.data.snapshot() or {}).get("currency") or "EUR"
        yday = (datetime.now() - timedelta(days=1)).strftime("%d.%m.%Y")
        pf_s = f"{pf:.2f}" if pf else "—"

        dl = self.daily.snapshot()
        if dl.get("support") is not None:
            fc = (f"Bias {dl['bias']} · Support {dl['support']:.2f} · "
                  f"Widerstand {dl['res_lo']:.2f}–{dl['res_hi']:.2f}\n{dl.get('summary','')}")
        else:
            fc = f"nicht verfügbar ({dl.get('error') or '—'})"

        txt = (f"📊 <b>Oil Tagesreport</b>\n\n"
               f"<b>Heute — Prognose (Web):</b>\n{fc}\n\n"
               f"<b>Gestern ({yday}):</b>\n"
               f"{n} Trades · WR {wr:.0f}% · PnL {pnl:+.2f} {cur} · PF {pf_s}")
        html = (f"<h2>Oil Tagesreport</h2>"
                f"<h3>Heute — Prognose (Web)</h3><p>{fc.replace(chr(10), '<br>')}</p>"
                f"<h3>Gestern ({yday})</h3><p>{n} Trades · Trefferquote {wr:.0f} % · "
                f"PnL <b>{pnl:+.2f} {cur}</b> · Profit-Faktor {pf_s}</p>"
                f"<p style='color:#888;font-size:12px'>Prognose ist Dritt-Kontext "
                f"(Web-Recherche), kein Handelssignal.</p>")

        sent = False
        tg = self.cfg["telegram"]
        if tg.get("enabled", "false").lower() == "true" and tg.get("bot_token"):
            try:
                send_telegram(txt, tg["bot_token"], tg["chat_id"]); sent = True
            except Exception as e:
                log.warning(f"daily telegram: {e}")
        if self.cfg.has_section("graph"):
            report_to = (self.cfg["graph"].get("report_to")
                         or "trading@hocks.eu, axel@hocks.eu")
            if send_graph_mail(self.cfg["graph"], f"Oil Trading Report {yday}",
                               html, report_to):
                sent = True
        log.info(f"Tagesreport gesendet: {sent}")
        return sent

    def _send_weekly_report(self) -> bool:
        """B4-Wochenreport (Track B) → E-Mail + Telegram. Hält Live-Stats gegen die
        Backtest-Erwartung, flaggt Leckagen. Fail-safe: kein Kanal/Fehler → False."""
        from datetime import datetime
        from html import escape
        try:
            from weekly_review import build_report
            # M5 für den Squeeze-Monitor unter mt5_lock holen (kein shutdown!) und
            # durchreichen — so ruft build_report selbst keine MT5-Funktion auf.
            m5 = None
            try:
                with mt5_lock(timeout=5) as got:
                    if got and self.data.symbol:
                        rr = mt5.copy_rates_from_pos(self.data.symbol, mt5.TIMEFRAME_M5, 0, 30*288+30)
                        if rr is not None and len(rr):
                            pt = mt5.symbol_info(self.data.symbol).point
                            m5 = {"H": [float(b["high"]) for b in rr], "L": [float(b["low"]) for b in rr],
                                  "C": [float(b["close"]) for b in rr],
                                  "SP": [float(b["spread"]) * pt for b in rr]}
            except Exception as e:
                log.debug(f"weekly m5: {e}")
            text = build_report(m5=m5)
        except Exception as e:
            log.warning(f"weekly build: {e}"); return False
        kw = datetime.now().isocalendar()[1]
        subject = f"Oil Wochenreport (B4) — KW{kw}"
        html = ("<h2>Oil Wochenreport (B4)</h2>"
                f"<pre style='font-family:Consolas,monospace;font-size:12px;line-height:1.35'>"
                f"{escape(text)}</pre>"
                "<p style='color:#888;font-size:12px'>Live-Stats vs. Backtest-Erwartung "
                "(Track B/B4). Bei [!]: Ursache trennen (Regime/Disziplin/Sizing), nicht "
                "am Signal drehen.</p>")
        sent = False
        tg = self.cfg["telegram"]
        if tg.get("enabled", "false").lower() == "true" and tg.get("bot_token"):
            try:
                send_telegram(f"📈 <b>Wochenreport (B4) KW{kw}</b>\n<pre>{escape(text)}</pre>",
                              tg["bot_token"], tg["chat_id"]); sent = True
            except Exception as e:
                log.warning(f"weekly telegram: {e}")
        if self.cfg.has_section("graph"):
            report_to = (self.cfg["graph"].get("report_to")
                         or "trading@hocks.eu, axel@hocks.eu")
            try:
                if send_graph_mail(self.cfg["graph"], subject, html, report_to):
                    sent = True
            except Exception as e:
                log.warning(f"weekly mail: {e}")
        log.info(f"Wochenreport gesendet: {sent}")
        return sent

    # ── Telegram-Callbacks (UI-frei) ───────────────────────────────────────
    def _on_trail_event(self, event: str, volume: float, price: float, profit: float):
        tg = self.cfg["telegram"]
        if not (tg.get("enabled", "false").lower() == "true" and tg.get("bot_token")):
            return
        try:
            if event == "partial":
                send_telegram(
                    f"💰 <b>Teil-Exit (Partial TP)</b>\n"
                    f"{self.data.symbol or ''}  ·  {volume:.2f} L @ {price:.3f}\n"
                    f"Gewinn-Distanz {profit:+.3f} — Rest läuft mit Trailing weiter",
                    tg["bot_token"], tg["chat_id"])
            elif event == "adverse":
                send_telegram(
                    f"🛑 <b>Früh-Ausstieg</b>\n"
                    f"{self.data.symbol or ''}  ·  {volume:.2f} L @ {price:.3f}\n"
                    f"Trade lief {abs(profit):.3f} gegen den Einstieg — geschlossen",
                    tg["bot_token"], tg["chat_id"])
        except Exception as e:
            log.warning(f"Trail-Event-Telegram: {e}")

    def _agent_telegram(self):
        snap = self.agent.snapshot()
        adv  = snap.get("advisory")
        if not adv:
            return
        tg = self.cfg["telegram"]
        if tg.get("enabled", "false").lower() == "true" and tg.get("bot_token"):
            try:
                risks = "\n".join(f"• {r}" for r in adv.get("risks", []))
                send_telegram(
                    f"🧠 <b>KI-Copilot: {adv['bias']} ({adv['confidence']}%)</b>\n"
                    f"{adv['headline']}\n\n{adv['reasoning']}"
                    + (f"\n\n<b>Risiken</b>\n{risks}" if risks else ""),
                    tg["bot_token"], tg["chat_id"])
            except Exception as e:
                log.warning(f"Agent-Telegram: {e}")

    # ══════════════════════════════════════════════════════════════════════
    #  TRADE-AKTIONEN  (für die Trade-Endpoints in server.py — Schritt 3)
    # ══════════════════════════════════════════════════════════════════════
    def open_long(self, source: str = "manuell") -> str | None:
        return self._open(self.trader.open_long, "LONG", source)

    def open_short(self, source: str = "manuell") -> str | None:
        return self._open(self.trader.open_short, "SHORT", source)

    def _open(self, fn, want: str, source: str = "manuell") -> str | None:
        sym = self.data.symbol
        if not sym:
            return "Kein Symbol verbunden"
        # KEIN harter Block mehr: Handel ohne passende Empfehlung ist erlaubt —
        # das Frontend warnt + lässt bestätigen (User-Entscheidung). Hier nur
        # protokollieren, WER handelt und ob gegen die aktuelle Empfehlung.
        # ⚠ `source` korrekt attribuieren: autonome Auto-Squeeze-Orders laufen
        # durch denselben Pfad — vorher schrieb er fälschlich „vom User bestätigt".
        sig = (self.wave.signal() or {}).get("signal", "WARTEN")
        if source == "auto_squeeze":
            log.info(f"[ORDER] {want} — autonom vom Auto-Squeeze eröffnet "
                     f"(Signal={sig})")
        elif source == "auto_signal":
            log.info(f"[ORDER] {want} — autonom auf die Empfehlung eröffnet "
                     f"(Signal={sig})")
        elif sig != want:
            log.info(f"[ORDER] {want} ohne passende Empfehlung (Signal={sig}) "
                     f"— vom User bestätigt, wird eröffnet")
        self.trader.set_open_context(**self._last_rec)
        # ⚠ SL-ATR-Zeitebene quellen-abhaengig (2026-08-05, User-Entscheidung nach
        # `backtest_sl_basis.py`): SQUEEZE bekommt **M5**, alles andere bleibt bei
        # M15. Begruendung: auf Squeeze-Entries ist der Ertrag zwischen beiden
        # Basen ein Wash (innerhalb eines Standardfehlers), der Worst-Case sinkt
        # aber von −8,83 auf −2,44xATR_M5 = Faktor 3. Auf der WELLEN-Population
        # ist der weite M15-SL dagegen in BEIDEN Halbjahren besser — deshalb
        # bewusst KEINE globale Umstellung. Strukturell begruendet: Breakout- und
        # Pullback-Einstiege haben verschiedene Nachlauf-Dynamik.
        _atr_tf = mt5.TIMEFRAME_M5 if source == "auto_squeeze" else None
        err = fn(sym, _atr_tf)
        if err:
            return err
        # Vom BOT eröffnete Trades markieren → nur für die greift die 15-Min-Regel
        # (manuelle Trades bleiben in der Diskretion des Users, User-Vorgabe).
        if source in ("auto_squeeze", "auto_signal"):
            try:
                self._bot_open_ticket = self.trader.snapshot().get("ticket")
                self._bot_open_source = source
                self._adverse15_done_ticket = None
            except Exception:
                pass
        # Trailing automatisch aktivieren (wie _after_trade im Widget)
        if not self.trail.enabled:
            self.trail.set_setup(self._last_rec.get("setup"))
            self.trail.toggle(sym)
        return None

    def close(self) -> str | None:
        return self.trader.close(reason="manual")

    def toggle_trail(self) -> bool:
        sym = self.data.symbol
        if sym:
            return self.trail.toggle(sym)
        return self.trail.enabled

    def _sr_levels(self, market: dict) -> dict:
        """Nächste Widerstandslinie ÜBER Preis (Short) und Unterstützung UNTER
        Preis (Long) — kombiniert dynamische S/R-Levels + die [zones]-Config."""
        bid = market.get("bid")
        if not bid:
            return {"resistance": None, "support": None,
                    "resistances": [], "supports": []}
        sr = market.get("sr") or {}
        above, below = [], []
        for r in (sr.get("resistances") or []):
            p = r.get("price")
            if p: (above if p > bid else below).append(p)
        for s in (sr.get("supports") or []):
            p = s.get("price")
            if p: (above if p > bid else below).append(p)
        # ⚠ [zones]-CONFIG ENTFERNT (2026-07-31, Modul-Audit). Vorher flossen hier
        # beide Kanten jeder `[zones]`-Zone als S/R-Linien ein — 16 Kanten aus einem
        # ~10 $ TIEFEREN Kursregime (Zonen bei 72,90–77,00 bei einem Kurs von 85,3).
        # Aus dem CHART wurden sie schon am 2026-07-14 entfernt, WEIL sie stale sind;
        # in die Wellen-Konfidenz liefen sie aber weiter.
        # Realer Fall beim Audit (Kurs 85,342): `market.sr` hatte GAR KEINE
        # Widerstände (M15-Cluster sind in frischen Trends oft leer) → der nächste
        # „Widerstand" kam aus der stale `fvg`-Zone bei **88,00** (2,66 $ weg),
        # während der echte bei **85,315** lag (0,03 $ weg). Der Konfidenz-Abzug
        # „dicht unter Widerstand" (−12) greift nur innerhalb 0,5×ATR und feuerte
        # deshalb NIE, obwohl er hätte feuern müssen.
        # Entfernen ist KEINE Strategieänderung, sondern das Streichen von Daten aus
        # einem anderen Preisregime: fehlt ein Level, gibt es weder Bonus noch Abzug —
        # das ist ehrlicher als ein falsches Level.
        # ⚠ OFFEN (messpflichtig, NICHT hier gemacht): die Wellen-Konfidenz stattdessen
        # aus `_draw_levels` (M30, dieselbe Quelle wie Chart + S/R-Close) speisen. Das
        # würde den −12-Abzug tatsächlich auslösen → Konfidenz sinkt → das 55%-Gate
        # verschiebt sich. Strategieänderung, gehört gemessen.
        # Tages-Level aus der Morgen-Recherche (Kontext)
        try:
            for lv in self.daily.zone_lines():
                (above if lv > bid else below).append(lv)
        except Exception:
            pass
        # Offene Kurslücken (D1-Gaps) als Fill-Magnete (Kontext/Konfidenz)
        try:
            for lv in self.gaps.zone_lines():
                (above if lv > bid else below).append(lv)
        except Exception:
            pass
        above = sorted(set(round(p, 3) for p in above))
        below = sorted(set(round(p, 3) for p in below), reverse=True)
        return {
            "resistance":  above[0] if above else None,   # nächster Widerstand (Short)
            "support":     below[0] if below else None,   # nächste Unterstützung (Long)
            "resistances": above[:3],
            "supports":    below[:3],
        }

    def _draw_levels(self) -> dict:
        """S/R-Linien fürs ZEICHNEN (PWA-Charts + MQL5-CSV) UND für den
        P(break)-Auto-Close: echte Kursstruktur = rohe **M30**-Pivots
        (`wave.pb_levels30`), geclustert (~0,5×ATR).

        ⚠ **TF-Umstellung M5→M30 am 2026-07-30** (User: „die S/R-Linien liegen oft
        sehr nahe beieinander"), gemessen `backtest_level_tf.py` über 80k M5-Bars in
        2 Halbjahren — M30 gewinnt in BEIDEN: Level-Abstand **1,95 statt 0,61×ATR**
        (nur 28 % statt 71 % näher als 1×ATR), AUC out-of-sample 0,721 vs 0,710,
        R-Ertrag der Close-Regel **rund doppelt** (+12.424/+13.047 vs +6.698/+7.749).
        Das P(break)-Modell (`_PB_MU/_SD/_W`) wurde dafür auf M30-Leveln NACHTRAINIERT.
        Fallback auf die alten M5-Level (`pb_levels`), falls M30 noch nicht da ist.
        ⚠ NICHT betroffen: das **Entry-Raum-Gate** nutzt weiter `pb_levels` (M5) —
        `entry_room_atr=0.6` ist darauf kalibriert.

        Zeichnet **nur die NÄCHSTE je Seite** (2 Linien total,
        deckungsgleich mit den Dashboard-Werten `sr-res`/`sr-sup`) — sonst tauchten
        beim Kurslauf die weiter entfernten Linien laufend auf/ab (User-Feedback
        2026-07-14). Bugfix davor: Linien kamen aus `_sr_levels` (stale [zones]-Config
        + Tageslevel + Gaps) — Uralt-Level statt aktueller Struktur. Ergebnis wird
        ~1 s gecacht (Konsistenz über alle Anzeigen + weniger Lock-Last)."""
        now = time.time()
        dc = self._draw_cache
        if dc and (now - dc[0]) < 1.0:
            return dc[1]
        try:
            ws  = self.wave.snapshot() or {}
            # M30-Level (gemessen besser); M5 nur als Fallback beim Kaltstart, bis
            # der erste M30-Turn-Fetch durch ist.
            lv  = ws.get("pb_levels30") or ws.get("pb_levels") or {}
            atr = (ws.get("pb_feats") or {}).get("atr") or 0.2
            bid = (self.data.snapshot() or {}).get("bid")
            if not bid:
                return {"res": [], "sup": []}
            # ⚠ Clusterung/Auswahl/Hysterese liegen seit 2026-08-07 in
            # `core/sr_levels.py` — die Backtests bauten sie vorher NACH und
            # wichen dabei ab (gemischter Rohpool statt ph/pl getrennt; 4,5 %
            # der Zeitpunkte hatten einen anderen Widerstand). Verhalten hier
            # unverändert, bitgenau geprüft in `tests/test_sr_levels.py`.
            from core.sr_levels import cluster as _cluster_lv
            from core.sr_levels import halten as _halten_lv
            from core.sr_levels import naechste as _naechste_lv

            def cluster(vals):
                return _cluster_lv(vals, atr)
            # Fix 2026-07-23 (User-Frage „Widerstand/Support-Retest von der falschen
            # Seite"): Widerstand/Support werden NACH AKTUELLER KURSPOSITION gewählt
            # (über/unter bid), NICHT mehr strikt nach Entstehungstyp (Swing-Hoch `ph`
            # vs. Swing-Tief `pl`). Vorher blieb ein gebrochenes Level für IMMER im
            # falschen Topf hängen: ein Swing-Tief, das der Kurs unterschritt und von
            # UNTEN erneut ansteuerte, tauchte nie als Widerstand auf (kam nur aus `ph`);
            # ein Swing-Hoch, das der Kurs überschritt und von OBEN erneut ansteuerte
            # (Retest), tauchte nie als Support auf (kam nur aus `pl`) — 2 von 4 Retest-
            # Varianten hatten dadurch nie eine Durchbruchwahrscheinlichkeit.
            # ⚠ ph/pl bleiben GETRENNT geclustert (nicht vorher zusammenlegen!) — ein
            # erster Versuch clusterte den kombinierten Rohpool direkt, was in dichten
            # Zonen zu Ketten-Mega-Clustern führte (doppelte Punktdichte → die einfache
            # Nachbar-Kette lief über >1×ATR durch). Erst NACH dem separaten Clustern
            # (unveränderte Granularität wie vorher) werden die beiden fertigen
            # Linien-Listen zusammengeführt und rein nach Position zu bid gewählt.
            ph_c = cluster(lv.get("ph") or [])
            pl_c = cluster(lv.get("pl") or [])
            both = ph_c + pl_c
            # NUR die nächste je Seite (2 Linien total = wie im Dashboard)
            r, s = _naechste_lv(both, bid)
            # Hysterese „klebrig" (Fix 2026-07-21): die gezeichnete Linie bleibt
            # stehen, solange der Kurs sie nicht WIRKLICH durchbricht (bid > R+0,1×ATR
            # bzw. bid < S−0,1×ATR). Ein neuer, näherer Pivot löst KEINEN Wechsel aus
            # — genau das war die Zitter-Quelle (auf M5 bilden sich laufend neue Pivots).
            # Ausnahme: ist die alte Linie weit weg (>1,5×ATR) UND ein deutlich näheres
            # Level existiert, wird sie übernommen (sonst bleibt sie irrelevant hängen).
            r = _halten_lv(r, self._draw_last.get("r"), bid, atr, True)
            s = _halten_lv(s, self._draw_last.get("s"), bid, atr, False)
            self._draw_last = {"r": r, "s": s}
            out = {"res": [r] if r is not None else [],
                   "sup": [s] if s is not None else []}
            self._draw_cache = (now, out)
            return out
        except Exception:
            return {"res": [], "sup": []}

    def _dash_sr(self, market: dict) -> dict:
        """S/R fürs Dashboard — GLEICHE Pivot-Quelle wie die Chart-Linien
        (`_draw_levels`), damit Position-Kachel und Chart übereinstimmen."""
        dl = self._draw_levels()
        res = dl.get("res") or []; sup = dl.get("sup") or []
        return {"resistance": (res[0] if res else None),
                "support":    (sup[0] if sup else None),
                "resistances": res, "supports": sup}

    def _write_levels_file(self):
        """Schreibt S/R als CSV nach `<terminal>\\MQL5\\Files\\sr_levels.csv`,
        damit ein MQL5-Indikator (mql5/SR_Levels.mq5) sie im Terminal zeichnet — das
        Python-MT5-Paket kann keine Chart-Objekte erzeugen. Atomarer Write (.tmp→replace),
        damit der Indikator nie eine halbe Datei liest."""
        import os
        if self._mql5_files_dir is None:
            try:
                with mt5_lock(timeout=2) as got:
                    if got:
                        ti = mt5.terminal_info()
                        self._mql5_files_dir = os.path.join(ti.data_path, "MQL5", "Files")
            except Exception:
                self._mql5_files_dir = ""      # einmal fehlgeschlagen → nicht endlos retryen
        if not self._mql5_files_dir:
            return
        try:
            dl = self._draw_levels()      # echte Pivot-Struktur, nicht [zones]-Config
            lines = [f"SYM;{self.data.symbol or ''}"]
            # P(Durchbruch) je Linie mitgeben (User-Wunsch 2026-07-30) → der Indikator
            # schreibt sie ins Label: „Widerstand 84.536 · Durchbruch 34%".
            # Richtung: Widerstand = Bruch nach OBEN (+1), Support = nach UNTEN (−1);
            # Merkmale identisch zu `_sr_close_hint`/`_stop_approach_hint` (M5-Momentum,
            # `wt` = EMA-Richtung stimmt mit der Bruchrichtung, `dist` = Abstand/ATR).
            # ⚠ Das Modell ist auf GENAU diese M30-Level trainiert (Nachtraining
            # 2026-07-30) — Kalibrierung out-of-sample geprüft (AUC 0,72).
            def _pb_for(level, dd):
                try:
                    pf = (self.wave.snapshot() or {}).get("pb_feats") or {}
                    atr = pf.get("atr"); m6 = pf.get("mom6"); m3 = pf.get("mom3")
                    ed = pf.get("ema_diff")
                    b = (self.data.snapshot() or {}).get("bid")
                    if not (atr and b) or None in (m6, m3, ed):
                        return None
                    wt = 1.0 if ed * dd > 0 else 0.0
                    return round(_p_break(m6 * dd, m3 * dd, wt, abs(level - b) / atr) * 100)
                except Exception:
                    return None
            for p in dl.get("res", []):
                _pb = _pb_for(p, 1)
                lines.append(f"R;{p}" + (f";{_pb}" if _pb is not None else ""))
            for p in dl.get("sup", []):
                _pb = _pb_for(p, -1)
                lines.append(f"S;{p}" + (f";{_pb}" if _pb is not None else ""))
            # Regressionskanal (M30) als Trendlinien-Anker → MQL5 zieht OBJ_TREND
            # (Format CH;<U|M|L>;t1;p1;t2;p2 mit Broker-Zeiten).
            try:
                cl = (self.structure.snapshot() or {}).get("channel_line")
                if cl and cl.get("t1") and cl.get("t2"):
                    for kind, key in (("U", "upper"), ("M", "mid"), ("L", "lower")):
                        pts = cl.get(key)
                        if pts and len(pts) == 2:
                            lines.append(f"CH;{kind};{cl['t1']};{pts[0]};{cl['t2']};{pts[1]}")
            except Exception:
                pass
            # Chartmuster-Linien (PT;…) 2026-07-30 auf User-Wunsch ENTFERNT — die
            # Kachel/PWA-Anzeige bleibt, im MT5-Chart wurde es zu voll. Der Indikator
            # (v1.12) hat den PT-Handler ebenfalls nicht mehr.
            # ECHTE Liquiditäts-Wände von Hyperliquid (größtes L2-Level je Seite,
            # basis-korrigiert auf CFD-Niveau) — Format LQ;<B|A>;preis;size.
            # Anders als R/S NICHT aus Pivots geschätzt, sondern tatsächlich ruhende
            # Orders. REINE ANZEIGE (Übertragbarkeit auf den CFD wird gerade gemessen).
            # Format: LQ;<B|A>;preis;size;<U|D>;<1|0>  (Pfeil-Richtung = Wirkrichtung
            # der Wand nach der Lesart „sie hält"; letztes Feld 1 = die GRÖSSERE der
            # beiden Wände). Zusätzlich LT;t1;p1;t2;p2;<U|D> = Liquiditäts-Trendlinie
            # (Regression über den volumengewichteten Wand-Schwerpunkt) — Zeiten
            # werden hier in BROKER-Zeit umgerechnet, weil MT5-Charts die brauchen.
            try:
                w = self.hl_walls.walls()
                if w:
                    dom = w.get("dominant")
                    ab = "U" if (w.get("arrow_bid") == "up") else "D"
                    aa = "D" if (w.get("arrow_ask") == "down") else "U"
                    lines.append(f"LQ;B;{w['bid']};{w['bid_sz']:.0f};{ab};{1 if dom=='B' else 0}")
                    lines.append(f"LQ;A;{w['ask']};{w['ask_sz']:.0f};{aa};{1 if dom=='A' else 0}")
                    tr = w.get("trend")
                    if tr and tr.get("t1") and tr.get("t2"):
                        boff = self.trader._broker_offset_s()
                        lines.append(f"LT;{int(tr['t1'])+boff};{tr['p1']};"
                                     f"{int(tr['t2'])+boff};{tr['p2']};"
                                     f"{'U' if tr.get('dir')=='up' else 'D'}")
            except Exception:
                pass
            # Liquiditätszonen (Equal Highs/Lows, M30): EQ;<H|L>;lo;hi;<broker_time>
            # → goldenes Band ab dem ersten Pivot, nach rechts verlängert.
            # ⚠ REINE ANZEIGE (als Signal gemessen verworfen, s. backtest_liquidity_sweep).
            try:
                zs = (self.wave.snapshot() or {}).get("liq_zones") or {}
                boff_z = self.trader._broker_offset_s()
                for key, tag in (("eqh", "H"), ("eql", "L")):
                    z = zs.get(key)
                    if z and z.get("lo") and z.get("hi"):
                        # `t` ist ROHE Broker-Zeit aus copy_rates → NICHT nochmal
                        # umrechnen (anders als die HL-Trendlinie, die lokal tickt).
                        lines.append(f"EQ;{tag};{z['lo']};{z['hi']};{int(z['t'])}")
            except Exception:
                pass
            # KONSOLIDIERUNGS-BOX (M5, dieselbe wie der validierte Squeeze):
            # CO;lo;hi;<0|1>  — letztes Feld 1 = komprimiert (≤2,5×ATR, Ausbruch steht
            # bevor), 0 = nur die aktuelle 10-Bar-Spanne. ⚠ REINE ANZEIGE: die
            # Konsolidierungs-SETUPS (False Breakout, Distribution, Accumulation,
            # Retest) sind gemessen ALLE verworfen (`backtest_consolidation.py`);
            # validiert ist nur der Squeeze-AUSBRUCH. Die Box zeigt also, WO gerade
            # gestaut wird — nicht, wohin es geht.
            try:
                _sq = (self.wave.snapshot() or {}).get("squeeze") or {}
                _lo, _hi = _sq.get("box_lo"), _sq.get("box_hi")
                if _lo and _hi and _hi > _lo:
                    _tight = 1 if _sq.get("state") in ("armed", "active") else 0
                    lines.append(f"CO;{_lo};{_hi};{_tight}")
            except Exception:
                pass
            # Aktueller Kurs für die fette Anzeige oben rechts (User-Wunsch): PX;bid
            try:
                _bid = (self.data.snapshot() or {}).get("bid")
                if _bid:
                    lines.append(f"PX;{_bid}")
            except Exception:
                pass
            _atr5 = 0.0
            try:
                _atr5 = float(((self.wave.snapshot() or {}).get("pb_feats") or {})
                              .get("atr") or 0.0)
            except Exception:
                pass
            # ── WAHRSCHEINLICHKEITS-KEGEL (CN) — im Chart per Default AUS
            # (User 2026-07-31: „anstatt des Trichters hätte ich gerne einen Pfeil").
            # Die Dashboard-Kachel „Erwartete Spanne" bleibt; `[trading] export_cone=true`
            # holt den Kegel in den Chart zurück.
            if self._export_cone:
                try:
                    _cn = _cone_build(_bid, _atr5, bands=(80,))
                    for lv in (_cn or {}).get("levels", []):
                        lines.append(f"CN;{lv['minutes']};{lv['lo']};{lv['hi']}")
                except Exception:
                    pass
            # ── PFEILE: AR;<art>;<von>;<nach>;<text>  (art L | S | K) ──────────────
            # ⚠ EINORDNUNG — die freie Frage „wohin läuft der Kurs?" ist im Projekt
            # GEMESSEN ein Münzwurf (`analyze_reversal.py`: AUC 0,499–0,509 out-of-
            # sample, in-sample nur 0,52). Deshalb zeigt KEINER dieser Pfeile eine
            # freie Kursprognose, sondern jeweils eine Aussage mit eigener Beleglage:
            #   L = am nächsten LEVEL, aus dem kalibrierten P(break) (AUC 0,65 oos,
            #       live kalibriert 27 % vorhergesagt vs 28 % real) — BEDINGTE Aussage
            #       an einem realen Objekt, die einzige belegte Richtungsangabe.
            #   S = SQUEEZE-Ausbruch — das einzige 2-Stichproben-validierte
            #       Richtungssignal (ØR +0,14…+0,23). Erscheint nur bei `active`.
            #   K = KONSENS der Verdict-Module — ⚠ NICHT kalibriert
            #       (`analyze_verdict_calibration.py`: in H2 sogar invertiert), heißt
            #       deshalb „Konsens" und nicht „Prognose".
            try:
                _dl = dl
                _r = (_dl.get("res") or [None])[0]
                _s = (_dl.get("sup") or [None])[0]
                if _bid and _atr5 > 0:
                    # (L) nächstes Level = das nähere von beiden
                    cand = [(abs(x - _bid), x, 1 if x > _bid else -1)
                            for x in (_r, _s) if x is not None]
                    if cand:
                        _d0, _lv0, _dd = min(cand)
                        _p = _pb_for(_lv0, _dd)          # in Prozent (0–100) oder None
                        # ⚠ TOTBAND 45–55 %: dort ist P(break) ein Münzwurf. Einen
                        # Pfeil zu zeichnen würde daraus eine Richtungsaussage machen —
                        # genau der Fehler, den das Projekt heute mehrfach vermieden hat
                        # (freie Richtung = AUC 0,5). Stattdessen ein FLACHER Pfeil mit
                        # „unentschieden".
                        if _p is not None:
                            if 45 <= _p <= 55:
                                to = _bid          # waagerecht = keine Aussage
                                txt = f"{_p}% — unentschieden"
                            elif _p > 55:
                                to = _lv0 + _dd * 0.5 * _atr5
                                txt = f"{_p}% Durchbruch"
                            else:
                                to = _bid - _dd * 1.0 * _atr5
                                txt = f"{100 - _p}% Abprall"
                            lines.append(f"AR;L;{round(_bid, 3)};{round(to, 3)};{txt}")
                    # (S) Squeeze — nur wenn aktiv
                    _sq = (self.wave.snapshot() or {}).get("squeeze") or {}
                    if _sq.get("state") == "active" and _sq.get("dir") and _sq.get("level"):
                        _sd = 1 if _sq["dir"] == "LONG" else -1
                        lines.append(f"AR;S;{round(float(_sq['level']), 3)};"
                                     f"{round(float(_sq['level']) + _sd * 2.0 * _atr5, 3)};"
                                     f"Squeeze {_sq['dir']}")
                    # (K) Konsens — Länge proportional zum Bias-Betrag (max 2×ATR)
                    # ⚠ NUR berechnen, wenn der Pfeil auch gezeichnet wird
                    # (Review 2026-08-02): Der Indikator verwirft `AR;K` seit v1.33
                    # per Default (`InpShowConsensus=false` → `continue`), der Bot
                    # rechnete dafür aber im ~5-s-Export-Takt ein KOMPLETTES zweites
                    # `_verdict()` — Arbeit für eine Linie, die niemand zeichnet, plus
                    # das Risiko, dass dieses zweite Verdict vom Verdict im Snapshot
                    # abweicht. Der Schalter spiegelt jetzt den Indikator-Default;
                    # wer `InpShowConsensus=true` setzt, setzt hier `export_consensus
                    # _arrow=true` dazu.
                    if self._export_consensus_arrow:
                        _vd = self._verdict(self.data.snapshot(), self.wave.signal(),
                                            self.wave.snapshot(), None,
                                            self.agent.snapshot(), self.elliott.snapshot(),
                                            self.patterns.snapshot())
                        _b = float(_vd.get("bias") or 0.0)
                        if abs(_b) >= 0.2:
                            lines.append(f"AR;K;{round(_bid, 3)};"
                                         f"{round(_bid + (1 if _b > 0 else -1) * min(abs(_b), 1.0) * 2.0 * _atr5, 3)};"
                                         f"Konsens {_b:+.2f}")
            except Exception:
                pass
            # ── HYPERLIQUID-ERSATZKURS bei geschlossenem Markt (User 2026-08-01):
            # HL;<mt5_aequivalent>;<alter_s>;<bid>;<ask>;<trend U|D|->  — der Indikator
            # zeigt ihn UNTER dem (eingefrorenen) MT5-Kurs, sobald kein Tick mehr
            # kommt. HL (`xyz:CL`) handelt 24/7, Pepperstone nicht; ohne das sieht man
            # am Wochenende einen Freitags-Kurs und merkt es nicht.
            try:
                _w = self.hl_walls.walls()
                if _w and _w.get("mid_mt5") is not None:
                    _tr = (_w.get("trend") or {}).get("dir")
                    lines.append(f"HL;{_w['mid_mt5']:.3f};{float(_w.get('age_s') or 0):.0f};"
                                 f"{_w.get('bid')};{_w.get('ask')};"
                                 f"{'U' if _tr == 'up' else 'D' if _tr == 'down' else '-'}")
            except Exception:
                pass
            # G/V der offenen Position, direkt unter dem Kurs (User-Wunsch 2026-07-30):
            # PL;wert;waehrung. **NETTO** wie im Dashboard — bei Gewinn abzüglich der
            # WHT-Quellensteuer, die der Broker einbehält (`[trading] wht_pct`); bei
            # Verlust unverändert (da fällt keine Steuer an). Ohne Position keine Zeile
            # → der Indikator löscht das Label.
            try:
                _ps = self.trader.snapshot()
                if _ps.get("ticket") and _ps.get("pnl") is not None:
                    _p = float(_ps["pnl"])
                    if _p > 0 and self._wht_pct > 0:
                        _p *= (1.0 - self._wht_pct / 100.0)
                    _cur = (self.data.snapshot() or {}).get("currency") or ""
                    lines.append(f"PL;{_p:.2f};{_cur}")
            except Exception:
                pass
            # Trade-Marker: TR;<O|C>;<broker_time>  → der Indikator umrandet die Kerze,
            # in der eröffnet (hellgrün) bzw. geschlossen (dunkelgrün) wurde
            # (User-Vorgabe 2026-07-30). Offene Position + die letzten Trades des Tages.
            # ⚠ Per Default AUS (User-Wunsch 2026-07-30: „entferne die Umrandungen
            # für Trade open und close" — kurz nach dem Einbau wieder verworfen).
            # Code bleibt reaktivierbar via `[trading] export_trade_marks=true`;
            # spart im Aus-Zustand die DB-Abfrage im ~5-s-Export-Takt.
            # ⚠ Kein `raise StopIteration` mehr als Sprung (2026-07-31, Audit):
            # StopIteration IST eine Exception und wurde vom breiten `except` unten
            # gefangen — funktionierte, wäre aber sofort fragil, sobald dort jemand
            # Logging ergänzt (Phantom-Fehler bei JEDEM Export-Takt).
            if self._export_trade_marks:
                try:
                    boff = self.trader._broker_offset_s()
                    marks: list[tuple[str, int]] = []
                    ps = self.trader.snapshot()
                    if ps.get("ticket") and ps.get("open_time"):
                        marks.append(("O", int(float(ps["open_time"]) + boff)))
                    for t in (self.history.last_closed_trades(_TRADE_MARKS) or []):
                        if t.get("entry_time"):
                            marks.append(("O", int(float(t["entry_time"]) + boff)))
                        if t.get("exit_time"):
                            marks.append(("C", int(float(t["exit_time"]) + boff)))
                    for kind, ts in marks[:2 * _TRADE_MARKS + 1]:
                        lines.append(f"TR;{kind};{ts}")
                except Exception:
                    pass
            # Zonen NICHT mehr aus der (statischen) [zones]-Config — die dynamische
            # Handels-Range zeichnet der Indikator selbst aus den Chart-Kerzen (TF-genau).
            path = os.path.join(self._mql5_files_dir, "sr_levels.csv")
            with open(path + ".tmp", "w", encoding="ascii", errors="ignore") as f:
                f.write("\n".join(lines) + "\n")
            os.replace(path + ".tmp", path)
        except Exception as e:
            log.debug(f"write_levels: {e}")

    def _verdict(self, market, wave_signal, wave_snap, tu, agent, elliott,
                 snap_parts_patterns=None) -> dict:
        """Gesamtempfehlung aus den Modulen für die Widget-Grafik.

        Headline = die **validierte Welle** (einziges Modul mit belegtem Edge);
        die übrigen Module bilden einen gewichteten Konsens-Balken. REINE
        ANZEIGE — ändert NICHT die Order-Logik (die hört nur auf die Welle).
        Votes: +1 LONG, −1 SHORT, 0 neutral.
        """
        def word(v):
            return "auf" if v > 0 else "ab" if v < 0 else "flach"

        bid = (market or {}).get("bid")
        votes = []

        def add(name, vote, weight, detail, used=True):
            """`used=False` = das Modul hat DAUERHAFT kein Stimmrecht (gemessen
            ohne Inhalt) und wird im Dashboard NICHT mehr als Chip gezeigt.
            ⚠ Es bleibt trotzdem in `votes` — `log_verdict_votes` speist daraus
            die Telemetrie, und die 25.000-Verdict-Messung braucht die Reihe
            weiter. Ausgeblendet wird nur die Anzeige, nicht die Messung.
            Nicht zu verwechseln mit `weight=0` aus SITUATIVER Stille (Welle bei
            WARTEN, Squeeze ohne Ausbruch): die sprechen zeitweise und bleiben
            sichtbar."""
            votes.append({"name": name, "vote": int(vote), "weight": weight,
                          "detail": detail, "used": bool(used)})

        # 1) Welle — primär (validierter Edge). ⚠ Bei WARTEN hat sie KEINE Aussage
        # → Gewicht 0 (Fix 2026-07-30). Vorher stand w=3,0 permanent im Nenner und
        # zog die Bias-Nadel dauerhaft zur Mitte — derselbe Logikfehler, der am
        # 2026-07-15 beim Squeeze behoben wurde, hier übersehen. Das wog schwer:
        # gemessen sind ~91 % der letzten 2000 Empfehlungen WARTEN, die Nadel war
        # also fast immer künstlich gedämpft (real: bias 0,312 statt 0,500).
        wsig = (wave_signal or {}).get("signal")
        wv = 1 if wsig == "LONG" else -1 if wsig == "SHORT" else 0
        add("Welle", wv, 3.0 if wv != 0 else 0.0,
            f"{wsig or '—'} · {(wave_signal or {}).get('conf_pct', 0)}%")

        # 2/3) M30 / H1 — die EMA-Signale, die die Welle tatsächlich nutzt.
        # ⚠ Gewicht 0 OHNE Aussage (Fix 2026-07-31) — dieselbe Regel wie bei Welle,
        # Squeeze, Elliott und KI; bei der Verdict-Überarbeitung am 30.07. hier
        # übersehen. Eine 0-Stimme bedeutet „EMA-Abstand im Totband" = keine Aussage,
        # nicht „neutral" — mit vollem Gewicht im Nenner zog sie die Bias-Nadel
        # dauerhaft zur Mitte.
        # GEMESSEN an 7.074 geloggten Verdicts (`verdict_votes`): **M30 ist in 57,9 %
        # der Fälle ohne Aussage** (H1 nur in 1,8 %) → Ø-Bias-Betrag 0,371 → **0,441**,
        # Median-Verstärkung **1,30×**, in **33,3 %** der Zeilen deutlich stärkere Nadel.
        # ⚠ Anlass war die User-Frage „H1 aus der Gesamtempfehlung entfernen?". Die
        # Antwort ist NEIN — die vermutete Doppelzählung ist gemessen schwach (bei
        # gerichteter Welle stimmt M30 nur zu 14,9 % mit ihr überein, H1 zu 47 %; M30
        # und H1 untereinander nur zu 33,8 %). Der eigentliche Defekt war dieser hier.
        # REINE ANZEIGE — die Order-Logik hängt an der Wellen-Headline, nicht am Bias.
        m30 = int((wave_snap or {}).get("htf_trend", 0) or 0)
        h1  = int((wave_snap or {}).get("h1_trend", 0) or 0)
        add("M30", m30, 1.5 if m30 != 0 else 0.0, word(m30))
        add("H1",  h1,  1.5 if h1  != 0 else 0.0, word(h1))

        # 4) TradersUnion ENTFERNT aus dem Verdict-Konsens (User-Vorgabe 2026-07-06):
        # lagt + nicht backtestbar + Standard-Indikator-Konfluenz = kein Edge. Bleibt
        # nur noch reine Anzeige (Snapshot `tu`), zählt NICHT mehr in Bias/Agree.

        # 5) KI-Copilot — Gewicht NUR bei gerichteter Aussage (LONG/SHORT).
        # ⚠ GEÄNDERT 2026-07-31 (Modul-Audit): vorher zählte ein explizites "NEUTRAL"
        # als echte Stimme mit Gewicht 1,0. Gemessen an 7.084 Verdicts ist das aber
        # **in 93,1 % der Fälle** der Zustand — also der Normalzustand des Copiloten,
        # kein abgewogenes Urteil (Elliott zeigt dasselbe Muster nur in 1,3 %).
        # Damit hatte ausgerechnet das Modul mit der SCHWÄCHSTEN Beleglage
        # (`analyze_verdict_calibration.py`: nicht robust prädiktiv) den GRÖSSTEN
        # dämpfenden Einfluss auf die Bias-Nadel. Wirkung der Angleichung:
        # Ø|bias| 0,441 → 0,569 (Median-Verstärkung 1,25×, betrifft 79,5 % der Zeilen);
        # kumuliert mit den Fixes von Welle/Squeeze/M30/H1: 0,370 → 0,569 = 1,54×.
        # Der Chip bleibt sichtbar und zeigt „NEUTRAL", er stimmt nur nicht mehr mit ab.
        adv = (agent or {}).get("advisory") or {}
        ab  = adv.get("bias")
        av  = 1 if ab == "LONG" else -1 if ab == "SHORT" else 0
        add("KI-Copilot", av, 1.0 if av != 0 else 0.0,
            f"{ab or '—'} · {adv.get('confidence', 0)}%")

        # 6) Elliott/FVG — nur stimmberechtigt, wenn ein Ziel existiert (sonst w=0)
        ev, edet, ew = 0, "—", 0.0
        tgt = (elliott or {}).get("target")
        if tgt is not None and bid:
            ev = -1 if tgt < bid else 1 if tgt > bid else 0
            edet = f"{(elliott or {}).get('wave', '—')} → {tgt:.3f}"
            # ⚠⚠ GEWICHT AUF 0 GESETZT (2026-08-06, gemessen
            # `analyze_verdict_modules.py` über 15.544 Zeilen). Elliott hatte mit
            # **1.384 Episoden die grösste Stichprobe** der ganzen Tabelle und ist
            # darin **flach**: Überschuss −0,075 / +0,032 ×ATR, **50 % Treffer**.
            # Gleichzeitig war es mit **25,9 % die zweitlauteste Stimme** der
            # Bias-Nadel — weil es praktisch nie schweigt (stumm in 1 % der Zeilen).
            # Zusammen mit H1 (38,1 %) bildete es einen Dauerhintergrund von ~64 %,
            # gegen den die episodischen Module erst anschieben mussten.
            # Ein Modul mit der grössten Stichprobe und ohne messbaren Inhalt darf
            # den Konsens nicht dominieren. Der CHIP bleibt (reine Anzeige, das Ziel
            # ist als Kontext nützlich) — nur die Stimme entfällt.
            # ⚠ Reine ANZEIGE-Änderung: die Order steuert die Welle über die
            # Headline, nicht der Konsens. Zurück: `ew = 1.0 if ev != 0 else 0.0`.
            ew = 0.0
        add("Elliott", ev, ew, edet, used=False)

        # 7) Squeeze-Breakout — Event-Signal: stimmt NUR bei `active` mit (dann 2,0,
        # gemessen 2-Stichproben-positiv, unter der Welle=3,0). armed/keine → Gewicht 0
        # — sonst dämpft das fast immer neutrale Modul die Bias-Nadel dauerhaft
        # (Logikfehler bis 2026-07-15: w=2,0 stand permanent im Nenner → Nadel ~×0,8).
        sq = (wave_snap or {}).get("squeeze") or {}
        sq_active = sq.get("state") == "active"
        sqv = (1 if sq.get("dir") == "LONG" else -1) if sq_active else 0
        add("Squeeze", sqv, 2.0 if sq_active else 0.0,
            f"{sq.get('state') or '—'}" + (f" {sq.get('dir')}" if sq.get("dir") else ""))

        # 8) Chartmuster — User-Vorgabe 2026-07-30 („berücksichtige die Chartmuster
        # in der Gesamtempfehlung, sobald eins erkannt wird"). Gewicht bewusst KLEIN:
        # der fällige KONTROLLTEST (2026-07-30) zeigt, dass die Muster einen zwar in
        # BEIDEN Hälften positiven, aber kleinen Zusatz über einen GENERISCHEN
        # Breakout hinaus liefern — Muster ØR +0,206/+0,328 vs. beliebiger Swing-Bruch
        # +0,184/+0,220 (Delta nur +0,022 in H1, +0,108 in H2). Der Löwenanteil des
        # Ertrags kommt also vom Breakout+Trailing, nicht vom Muster. `forming` zählt
        # nur halb, weil das Muster dort noch nicht bestätigt ist. Ziel-Trefferquote
        # bleibt niedrig (23–26 %), die Stimme sagt also „Richtungstendenz", nicht
        # „Kursziel".
        # ⚠ ABGESENKT 1,0 → `_PAT_W`=0,25 (User-Vorgabe 2026-08-01 „geben wir dem
        # Muster doch 5 %"). Anlass war die Nachmessung der 2026-07-31 ergänzten
        # Handbuch-Muster: von den 8 gemessenen Alt-Typen schlägt nur `cup` die
        # Kontrolle, und unter 6 neu getesteten Typen war `wedge_rise` der einzige
        # Treffer — bei 6 Vergleichen ist das gut mit Zufall vereinbar. Empfehlung war
        # Gewicht 0 (reine Anzeige); der User wollte die Stimme behalten, aber klein.
        # 0,25 ist EMPIRISCH gesetzt, nicht geraten: über die letzten 4.000
        # `verdict_votes` liegt die Gewichtssumme der übrigen Module im Median bei
        # 4,50 → Anteil 0,25/(4,50+0,25) = **5,3 %** (die alten 1,0 waren 18,2 %).
        # Ändert sich das Modul-Gefüge, mit derselben Rechnung nachziehen.
        # REINE ANZEIGE — der Bias steuert keine Order (die hängt an der Wellen-
        # Headline); die Stimme wird in `verdict_votes` weiter mitgeloggt.
        pv, pdet, pw = 0, "—", 0.0
        try:
            _pats = (snap_parts_patterns or {}).get("patterns") or []
            # ⚠ NUR GEMESSENE Muster-Typen stimmen mit (Fix 2026-07-31): das Gewicht
            # 1,0 stammt aus dem Kontrolltest (`backtest_patterns.py` gegen einen
            # generischen Swing-Bruch), der nur Doppeltop/-boden, Tasse/inv. Tasse,
            # SKS/inv. SKS und auf-/absteigendes Dreieck abdeckte. Die am selben Tag
            # aus dem Handbuch ergänzten Typen (Flagge, Wimpel, Rechteck, Keil,
            # Dreifach) sind REINE ANZEIGE — sonst würde ein validiertes Gewicht
            # still mit unvalidierten Eingaben gefüttert (genau der Deployment-Drift-
            # Fehler, der heute fünfmal aufgefallen ist). `measured` kommt aus
            # `core/patterns.py`; fehlt das Feld (Alt-Snapshot), gilt es als gemessen.
            _p0 = next((m for m in _pats
                        if m.get("dir") in ("bull", "bear") and m.get("measured", True)),
                       None)
            if _p0:
                pv = 1 if _p0["dir"] == "bull" else -1
                _conf = _p0.get("status") == "confirmed"
                pw = _PAT_W if _conf else _PAT_W / 2
                pdet = f"{_p0.get('name', '—')} · {'bestätigt' if _conf else 'bildet sich'}"
        except Exception:
            pass
        add("Muster", pv, pw, pdet)

        # 9/10) ORDERBUCH-Imbalance + LIQUIDITÄTS-TREND (User-Vorgabe 2026-07-30).
        # ⚠ BEIDE sind UNGEMESSEN — anders als alle anderen Stimmen. Die Übertragbar-
        # keit von Hyperliquid-Orderbuchdaten auf den Pepperstone-CFD wird gerade
        # erst erhoben (`analyze_bookflow.py`, ab ~50k Snapshots ≈ 3 Tage erster Blick).
        # ⚠ Der Lead-Lag-Test (2026-07-30, 72 h) zeigt sogar, dass **Pepperstone
        # FÜHRT** (Peak bei k=−1, r=0,525) und HL folgt — HL ist ein Oracle-basierter
        # HIP-3-Perp, also strukturell Follower. Das dämpft die Erwartung erheblich.
        # Deshalb bewusst das KLEINSTE Gewicht im ganzen Verdict (0,5 je Stimme;
        # zum Vergleich: Welle 3,0 · Squeeze 2,0 · Muster/Elliott/KI 1,0).
        # Beide werden in `verdict_votes` mitgeloggt → in ein paar Wochen ist
        # datenbasiert entscheidbar, ob sie bleiben, mehr Gewicht bekommen oder
        # rausfliegen (wie TU 2026-07-06).
        ov, odet, ow = 0, "—", 0.0
        lv, ldet, lw = 0, "—", 0.0
        try:
            w = self.hl_walls.walls()
            if w:
                imb = w.get("imb5")
                if isinstance(imb, (int, float)) and abs(imb) >= _OB_IMB_MIN:
                    ov = 1 if imb > 0 else -1
                    # ⚠⚠ GEWICHT AUF 0 (2026-08-06). Das Orderbuch-Modul ist aus
                    # ZWEI unabhängigen Richtungen als nicht tragfähig gemessen:
                    #  · `analyze_verdict_modules.py` (15.544 Zeilen): über **2.688
                    #    Episoden beidhälftig NEGATIV** (−0,054/−0,066 ×ATR, 49 %
                    #    Treffer) — der einzige konsistent falsche Beitrag im Feld.
                    #  · Das HL-Projekt selbst (`bookflow_report.txt`): Bid/Ask-Druck
                    #    auf den CFD übertragen −0,61/−0,52 bp und KIPPT; die eigene
                    #    Schwelle dort lautet „< ~3 bp ist von den Kosten gefressen".
                    # Dazu der Lead-Lag-Befund: **Pepperstone führt** (Peak k=−1 ≈ 6 s),
                    # HL-Richtung trifft nach 6 s zu 51 % (n=545) — alles
                    # Preis-Abgeleitete von HL läuft hinterher.
                    # Der CHIP bleibt (Imbalance ist als Kontext lesbar), nur die
                    # Stimme entfällt. Zurück: `ow = 0.5`.
                    ow = 0.0
                    odet = f"Imbalance {imb:+.2f}"
                elif isinstance(imb, (int, float)):
                    odet = f"Imbalance {imb:+.2f} (zu schwach)"
                tr = w.get("trend") or {}
                if tr.get("dir") in ("up", "down"):
                    lv = 1 if tr["dir"] == "up" else -1
                    lw = 0.5
                    ldet = f"{tr['dir']} {tr.get('slope_per_h', 0):+.2f}$/h"
        except Exception:
            pass
        add("Orderbuch", ov, ow, odet, used=False)
        add("Liq-Trend", lv, lw, ldet)

        # Bias nur über stimmberechtigte Module (weight>0); agree/total = wie viele
        # der ANDEREN stimmberechtigten Module die Wellen-Richtung teilen (die Welle
        # zählte sich vorher selbst mit — „3/6 für LONG" war geschönt).
        wsum = sum(v["weight"] for v in votes) or 1.0
        bias = sum(v["weight"] * v["vote"] for v in votes) / wsum
        others = [v for v in votes if v["name"] != "Welle" and v["weight"] > 0]
        # Referenzrichtung für „agree": normal die Welle. Sagt sie WARTEN (91 % der
        # Zeit), gibt es keine Wellen-Richtung — dann zählt die Übereinstimmung mit
        # der BIAS-Richtung (Fix 2026-07-30). Vorher stand dort immer „0/N", obwohl
        # sich die anderen Module durchaus einig waren.
        ref = wv if wv != 0 else (1 if bias > 0 else -1 if bias < 0 else 0)
        agree = sum(1 for v in others if ref != 0 and v["vote"] == ref)
        return {
            "headline": wsig, "conf": (wave_signal or {}).get("conf_pct", 0),
            "tf": (wave_snap or {}).get("tf"),   # Zeitebene, für die die Empfehlung gilt
            "bias": round(bias, 3), "agree": agree, "total": len(others),
            # ⚠ `ref_dir` = WORAUF sich `agree` bezieht (Fix 2026-07-31). Bei WARTEN
            # ist das NICHT die Headline, sondern die Bias-Richtung — das Frontend
            # beschriftete es vorher mit der Headline und schrieb dadurch
            # „stark LONG · 4/4 Module für WARTEN". Die Richtung kommt jetzt VON HIER,
            # statt im Frontend aus `bias` nachgebaut zu werden (dort galt ein
            # ±0,05-Totband, hier `bias > 0` — die Nachbildung wäre am Rand
            # auseinandergelaufen; genau die Sorte Divergenz, die heute mehrfach
            # aufgefallen ist).
            "ref_dir": "LONG" if ref > 0 else "SHORT" if ref < 0 else None,
            # Wie viele Module HABEN gerade keine Aussage (Gewicht 0)? Ohne diese Zahl
            # las sich „4/4" widersprüchlich zu den 9 sichtbaren Chips.
            "silent": sum(1 for v in votes if not v["weight"]),
            "votes": votes,
        }

    # ══════════════════════════════════════════════════════════════════════
    #  SNAPSHOT  (ein JSON-fähiger Zustand für /api/snapshot + WebSocket)
    # ══════════════════════════════════════════════════════════════════════
    _SNAP_TTL_S = 0.8   # geteilter Snapshot gilt so lange als frisch

    def set_manual_margin(self, eur: float) -> float:
        """Feste Einsatz-Margin in Kontowährung (User-Wunsch 2026-08-04).
        0 = automatisch (wie bisher `margin_buffer_pct` % der freien Margin).

        ⚠ Wirkt auf ALLE neuen Positionen — manuelle wie autonome (Squeeze/Signal).
        Die freie Margin bleibt Obergrenze; `calc_lots` deckelt und loggt das.
        Neustart-fest über `runtime_state.json`."""
        from core.config import set_manual_margin as _set
        v = _set(eur)
        self._manual_margin = v
        self._save_runtime_state()
        return v

    def set_margin_pct(self, pct: float) -> float:
        """Einsatz als PROZENT der freien Margin (User-Wunsch 2026-08-05).

        Das ist die zweite Hälfte des Einsatz-Felds: `set_manual_margin` gibt einen
        FESTEN Betrag vor, das hier den ANTEIL. Beides existierte bisher nur in der
        `ini` (`margin_buffer_pct`, live 95) — die Prozent-Schraube hatte keine UI.

        ⚠ VORRANG: ein fester Betrag (`manual_margin > 0`) schlägt den Prozentsatz —
        `calc_lots` prüft ihn zuerst. Der Prozentsatz bleibt dabei die Obergrenze
        (freie Margin × pct), ein zu hoher Fixbetrag wird darauf gedeckelt.
        ⚠ Wirkt auf ALLE neuen Positionen, auch die autonomen. Neustart-fest.
        ⚠ `set_margin_buffer` klemmt auf 1–99 % — 100 % wäre ohnehin unhaltbar
        (kein Puffer für Spread/Swap → Margin-Call beim Öffnen)."""
        from core.config import set_margin_buffer as _set, get_margin_buffer
        _set(pct)
        self._margin_pct = round(get_margin_buffer() * 100.0, 1)
        self._save_runtime_state()
        return self._margin_pct

    def _manual_stats_cached(self) -> dict | None:
        """Kennzahlen der manuellen Trades für die Karte „Manuelle Trades"
        (2026-08-04). Gleiches Cache-Muster wie `_alignment_cached` — die
        Aggregation läuft über die ganze `trades`-Tabelle und hat im 1-s-Snapshot
        nichts zu suchen."""
        now = time.time()
        if now - getattr(self, "_manual_ts", 0.0) > 120:
            try:
                self._manual_cache = self.history.manual_stats(30)
            except Exception as e:
                log.debug(f"manual_stats: {e}")
                self._manual_cache = None
            self._manual_ts = now
        return getattr(self, "_manual_cache", None)

    def _alignment_cached(self) -> dict | None:
        """Ausrichtungs-Split (mit/gegen/ohne Empfehlung) für den Order-Dialog —
        ehrliche eigene Zahlen statt generischem Hinweis (2026-07-24; Gegen-Signal-
        Trades sind die gemessene Kern-Leckage).
        ⚠ Seit 2026-08-06 über die **volle Historie** (1.216 Trades) statt der
        letzten 40 — der Befund ist dort beidhälftig robust, über 40 war er eine
        Momentaufnahme. Zusätzlich je Lot normiert (`pnl_lot`), weil absolute
        Euro-Vergleiche bei wechselnder Positionsgröße ungültig sind.
        DB-Query gecacht (~120 s), Snapshot bleibt billig."""
        now = time.time()
        if now - getattr(self, "_align_ts", 0.0) > 120:
            try:
                self._align_cache = self.history.alignment_stats(0)
            except Exception as e:
                log.debug(f"alignment_stats: {e}")
                self._align_cache = None
            self._align_ts = now
        return getattr(self, "_align_cache", None)

    def _hl_ctx_refresh(self):
        """Holt den HL-Kontext im Hintergrund (s. Aufrufstelle im Trend-Loop)."""
        try:
            d = self.hl_walls.market()
            if d:
                self._hl_ctx = d
        except Exception as e:
            log.debug(f"hl market: {e}")
        finally:
            self._hl_ctx_busy = False

    def _block_mix_cached(self) -> dict | None:
        """WELCHE Gates blocken heute, und wie oft? (2026-08-06)

        WARUM SICHTBAR: auf die Frage „warum gab es heute so wenige Empfehlungen?"
        liess sich das nur per DB-Abfrage beantworten. Real am 06.08.: von 646
        Zeilen waren **6 ungeblockt** — entry_room 274 · min_conf 225 ·
        breakout_pending 88 · htf_counter 50. Die Karte sagt das jetzt selbst.
        Reine Anzeige, ~120 s gecacht."""
        now = time.time()
        if now - getattr(self, "_blockmix_ts", 0.0) > 120:
            try:
                import sqlite3
                con = sqlite3.connect(HISTORY_DB_FILE, timeout=5.0)
                rows = con.execute(
                    "SELECT COALESCE(block_reason,'') b, COUNT(*) n FROM recommendations "
                    "WHERE date(timestamp,'unixepoch','localtime') = date('now','localtime') "
                    "GROUP BY b ORDER BY n DESC").fetchall()
                con.close()
                ges = sum(r[1] for r in rows)
                self._blockmix_cache = {
                    "total": ges,
                    "frei": next((r[1] for r in rows if not r[0]), 0),
                    "top": [{"grund": r[0], "n": r[1]} for r in rows if r[0]][:4],
                } if ges else None
            except Exception as e:
                log.debug(f"block_mix: {e}")
                self._blockmix_cache = None
            self._blockmix_ts = now
        return getattr(self, "_blockmix_cache", None)

    def _m15_track_cached(self) -> dict | None:
        """Selbstmessung der M15-Karte — Trefferquote ihrer eigenen Lesart.

        ⚠ Gegen 50 % zu lesen. Gemessen wird NUR die bedingte Lesart am Level
        („Abprall → eher abwaerts"), nicht eine freie Richtungsprognose — eine
        solche ist im Projekt gemessen unmoeglich (AUC 0,50 oos / 0,52
        in-sample). ~120 s gecacht."""
        now = time.time()
        if now - getattr(self, "_m15track_ts", 0.0) > 120:
            try:
                self._m15track_cache = (self.history.m15_accuracy(200)
                                        if self.history else None)
            except Exception as e:
                log.debug(f"m15_track: {e}")
                self._m15track_cache = None
            self._m15track_ts = now
        return getattr(self, "_m15track_cache", None)

    def _entry_gap_cached(self) -> dict | None:
        """AUSFUEHRUNGS-QUALITAET: kommt der Bot-Einstieg AM Level an?

        ⚠⚠ WARUM DAS DIE WICHTIGSTE UNBEOBACHTETE ZAHL WAR. Der Umbau auf
        ruhende Stop-Orders (05.08.) hatte als einziges Erfolgskriterium: der
        Abstand Einstieg↔Level muss gegen 0 gehen (vorher Median +0,275×ATR).
        Das ist der groesste je gemessene Hebel des Projekts (+0,32 R gegenueber
        Market) — und niemand hat je hineingesehen.

        ⚠ DIE ERFOLGSMELDUNG IST PARADOX: eine per PENDING gefuellte Order
        erzeugt **keine** `AUTO-SQUEEZE-ENTRY`-Logzeile (die entsteht nur im
        Market-Fallback). Bot-Trades OHNE Log-Treffer sind also der ERFOLG.
        Hier wird deshalb das gezaehlt, was ohne Logdatei bestimmbar ist:
        wie viele Bot-Trades es seit dem Umbau gab und wie viele davon ueber
        den Market-Fallback liefen (erkennbar am Zaehler `squeeze_entry_count`
        bzw. am Setup-Tag). ~300 s gecacht — DB-Abfrage gehoert nicht in den
        1-s-Snapshot."""
        now = time.time()
        if now - getattr(self, "_entrygap_ts", 0.0) > 300:
            try:
                import sqlite3
                con = sqlite3.connect(HISTORY_DB_FILE, timeout=5.0)
                # Stichtag = Umbau auf ruhende Stop-Orders (05.08. 08:55)
                seit = 1786000500
                n, = con.execute(
                    "SELECT COUNT(*) FROM trades WHERE entry_time >= ? "
                    "AND setup LIKE 'SQUEEZE%'", (seit,)).fetchone()
                con.close()
                self._entrygap_cache = {"n_seit_umbau": n, "soll": 12}
            except Exception as e:
                log.debug(f"entry_gap: {e}")
                self._entrygap_cache = None
            self._entrygap_ts = now
        return getattr(self, "_entrygap_cache", None)

    def _rec_track_cached(self) -> dict | None:
        """Selbst-Kalibrierung: Trefferquote der letzten Empfehlungs-Episoden.

        ⚠ Gegen 50 % zu lesen, nicht gegen 0 — es ist eine Richtungsaussage.
        Gemessener Ausgangsstand (`analyze_signal_live.py`, 1.071 Episoden):
        48–51 %. Diese Zeile macht laufend sichtbar, ob sich das aendert, statt
        dass es erst auf Nachfrage rueckwirkend gemessen wird. ~120 s gecacht."""
        now = time.time()
        if now - getattr(self, "_rectrack_ts", 0.0) > 120:
            try:
                self._rectrack_cache = (self.history.rec_accuracy(200)
                                        if self.history else None)
            except Exception as e:
                log.debug(f"rec_accuracy: {e}")
                self._rectrack_cache = None
            self._rectrack_ts = now
        return getattr(self, "_rectrack_cache", None)

    def _loss_streak_today(self) -> tuple[int, int]:
        """(Verlust-Trades heute, Trades heute) — für den Mental-Check der Entry-
        Checkliste („nach 2 Losses Session beenden"). DB-Query ~120 s gecacht."""
        now = time.time()
        if now - getattr(self, "_streak_ts", 0.0) > 120:
            try:
                import datetime as _dt
                t0 = _dt.datetime.now(_BERLIN).replace(
                    hour=0, minute=0, second=0, microsecond=0).timestamp()
                with self.history._connect() as conn:
                    rows = conn.execute(
                        "SELECT pnl FROM trades WHERE exit_time>=? AND pnl IS NOT NULL",
                        (t0,)).fetchall()
                self._streak_cache = (sum(1 for r in rows if (r[0] or 0) < 0), len(rows))
            except Exception as e:
                log.debug(f"loss_streak: {e}")
                self._streak_cache = (0, 0)
            self._streak_ts = now
        return getattr(self, "_streak_cache", (0, 0))

    def _entry_checklist(self, side: str, snap_parts: dict) -> dict:
        """Prüft die Trade-Setup-Checkliste (User-Vorgabe 2026-07-30) für eine
        geplante Eröffnung und liefert die VERLETZTEN Punkte zurück.

        Warum server-seitig: die Daten liegen alle hier (TF-Ampel, Struktur, Level,
        News, Tages-P&L, Trade-Historie) — das Frontend soll nur anzeigen.

        Jeder Punkt: `state` = "fail" (klar dagegen) | "warn" (Vorsicht) | "ok".
        Reine ENTSCHEIDUNGSHILFE — sie blockt nichts (wie der bisherige Dialog),
        macht aber sichtbar, was gegen den Trade spricht. Die Gewichtung ist NICHT
        aus einem Backtest, sondern aus (a) den im Projekt GEMESSENEN Leckagen
        (Handeln ohne Signal, Nacht/teure Stunden, Verlust-Serien) und (b) der
        vom User vorgegebenen Checkliste."""
        want = "LONG" if side == "long" else "SHORT"
        d = 1 if want == "LONG" else -1
        items: list[dict] = []
        add = lambda k, st, lab, det: items.append(
            {"key": k, "state": st, "label": lab, "detail": det})

        wave = snap_parts.get("wave") or {}
        market = snap_parts.get("market") or {}
        # ── 1. Signal-Deckung (die gemessene Kern-Leckage) ───────────────────
        sig = (wave.get("signal") or "WARTEN") if isinstance(wave.get("signal"), str) \
            else ((wave.get("signal") or {}).get("signal") or "WARTEN")
        if sig == want:
            add("signal", "ok", "Empfehlung deckt den Trade", f"Signal {sig}")
        elif sig in ("WARTEN", "—", None):
            add("signal", "fail", "Keine Empfehlung (WARTEN)",
                "gemessen: Trades ohne Signal sind die größte Verlustquelle")
        else:
            add("signal", "fail", f"Empfehlung steht GEGEN dich ({sig})",
                "gemessen: 40 % Trefferquote gegen das Signal")
        # ── 2. HTF-Trend klar? (Checklisten-Punkt 1) ─────────────────────────
        turns = wave.get("tf_turns") or {}
        htf = [turns.get(t, {}).get("dir") if isinstance(turns.get(t), dict)
               else turns.get(t) for t in ("M30", "H1")]
        htf = [x for x in htf if x in (1, -1, 0)]
        if htf and all(x == d for x in htf):
            add("htf", "ok", "HTF-Trend (M30+H1) trägt die Richtung", "")
        elif htf and any(x == -d for x in htf):
            add("htf", "fail", "HTF-Trend steht dagegen (M30/H1)",
                "deine Regel: nur MIT dem HTF-Trend, niemals dagegen")
        else:
            add("htf", "warn", "HTF-Trend unklar/seitwärts", "kein klarer M30/H1-Trend")
        # ── 3. Entry-Raum bis zum Gegenlevel (gemessen monoton) ──────────────
        try:
            dl = self._draw_levels()
            atr = float((wave.get("pb_feats") or {}).get("atr") or 0.0) or 0.2
            bid = market.get("bid")
            tgt = (dl.get("res") or [None])[0] if d > 0 else (dl.get("sup") or [None])[0]
            if bid and tgt:
                room = abs(tgt - bid) / atr
                if room < 0.6:
                    add("room", "fail", f"Kein Raum: Level nur {room:.1f}×ATR entfernt",
                        "gemessen: <0,6×ATR Raum = negativer Erwartungswert")
                elif room < 1.0:
                    add("room", "warn", f"Wenig Raum ({room:.1f}×ATR bis zum Level)", "")
                else:
                    add("room", "ok", f"Raum bis zum Level: {room:.1f}×ATR", "")
        except Exception:
            pass
        # ── 4. News-Konflikt (Checklisten-Punkt 3) ───────────────────────────
        ns = snap_parts.get("news_sentiment")
        if isinstance(ns, (int, float)) and abs(ns) >= 0.5:
            if (ns > 0) != (d > 0):
                add("news", "fail",
                    f"News-Flow steht dagegen ({ns:+.2f})",
                    "stark bullische/bärische Schlagzeilen gegen deine Richtung")
            else:
                add("news", "ok", f"News-Flow stützt ({ns:+.2f})", "")
        # ── 5. Kosten (Spread/ATR — gemessen Ø 0,265) ────────────────────────
        cr = snap_parts.get("cost_ratio")
        if isinstance(cr, (int, float)) and cr > 0:
            if cr >= 0.32:
                add("cost", "fail", f"Kosten hoch ({cr:.2f}×ATR)",
                    "gemessen: ab ~0,32×ATR frisst der Spread den Edge")
            elif cr >= 0.20:
                add("cost", "warn", f"Kosten erhöht ({cr:.2f}×ATR)", "")
            else:
                add("cost", "ok", f"Kosten günstig ({cr:.2f}×ATR)", "")
        # ── 6. Mental-Check: Verlust-Serie heute (Checklisten-Punkt 5) ───────
        losses, total = self._loss_streak_today()
        day_total = float((snap_parts.get("day_pl") or {}).get("total") or 0.0)
        if losses >= 2:
            bal = float(self.data.balance or 0.0)
            pct = (abs(day_total) / bal * 100.0) if (bal and day_total < 0) else 0.0
            add("streak", "fail",
                f"Heute schon {losses} Verluste ({total} Trades, {day_total:+.0f} €"
                + (f" = {pct:.0f}% des Kontos)" if pct else ")"),
                "deine Regel: nach 2 Losses Session beenden")
        elif day_total < 0:
            add("streak", "warn", f"Tag im Minus ({day_total:+.0f} €)", "")
        else:
            add("streak", "ok", f"Tagesbilanz {day_total:+.0f} €", "")
        # ── 7. Nacht-/Kostenfalle (gemessen: 0–7 Uhr Berlin) ─────────────────
        try:
            hb = datetime.now(_BERLIN).hour
            if hb in _SQUEEZE_NIGHT:
                add("hour", "fail", f"Nacht-Stunde ({hb}:00 Berlin)",
                    "gemessen: 0–7 Uhr = Kostenfalle (Spread ÷ dünner ATR)")
        except Exception:
            pass
        # ── 8. Wirtschaftskalender (Handbuch: „keine Trades vor High-Impact-News")
        # ⚠ NICHT gemessen (zu wenige Events für eine 2-Stichproben-Aussage) —
        # deshalb hier nur „warn", nicht „fail": es soll den Verdict nicht allein
        # auf `stop` kippen. Der Bot selbst pausiert im Fenster (autonome Entries).
        try:
            bl = self.calendar.blackout()
            if bl:
                m = bl["minutes"]
                when = (f"in {m:.0f} min" if m > 0 else f"vor {abs(m):.0f} min")
                add("event", "warn", f"News-Fenster: {bl['title']} ({when})",
                    "Handbuch-Regel: 15 min um High-Impact-Events nicht handeln "
                    "(im Projekt nicht gegengemessen)")
            else:
                nx = self.calendar.next_event()
                if nx and nx["minutes"] <= 90:
                    add("event", "ok",
                        f"Nächstes Event: {nx['title']} in {nx['minutes']} min", "")
        except Exception:
            pass
        fails = sum(1 for x in items if x["state"] == "fail")
        warns = sum(1 for x in items if x["state"] == "warn")
        return {"side": want, "items": items, "fails": fails, "warns": warns,
                "verdict": ("stop" if fails >= 2 else "warn" if (fails or warns) else "ok")}

    def snapshot_cached(self) -> dict:
        """Teilt EINEN frisch berechneten Snapshot über alle WS-Clients/HTTP-
        Aufrufe (TTL ~0,8 s). Spart SQLite/Verdict-Last bei mehreren Geräten —
        unabhängig von der Client-Anzahl wird nur ~1×/TTL gerechnet."""
        now = time.time()
        with self._snap_lock:
            if self._snap_cache and (now - self._snap_cache_ts) < self._SNAP_TTL_S:
                return self._snap_cache
        snap = self.snapshot()                 # teuer → außerhalb des Locks rechnen
        with self._snap_lock:
            self._snap_cache = snap
            self._snap_cache_ts = time.time()
        return snap

    def _fetch_m5_monitor(self, days: int = 30):
        """M5-Bars für den Squeeze-Monitor (unter mt5_lock, aus der Server-Instanz)."""
        import MetaTrader5 as mt5
        from core.mt5_utils import mt5_lock
        sym = self.data.symbol
        if not sym:
            return None
        with mt5_lock(timeout=5) as got:
            if not got:
                return None
            bars = mt5.copy_rates_from_pos(sym, mt5.TIMEFRAME_M5, 0, days * 288 + 30)
            si = mt5.symbol_info(sym)
            point = si.point if si else 0.01
        if bars is None or len(bars) == 0:
            return None
        return {"H": [float(b["high"]) for b in bars], "L": [float(b["low"]) for b in bars],
                "C": [float(b["close"]) for b in bars],
                "SP": [float(b["spread"]) * point for b in bars]}

    def _evaluate_pbreak_predictions(self, window_min: int = 60):
        """Wertet offene Abprall/Durchbruch-Vorhersagen anhand von `candles_m1` aus —
        DIESELBE Definition wie beim Modell-Training (`_BRK_ATR=0,5`/`_BRK_W=12` M5-
        Bars = 60 min in `backtest_srclose_prob.py`): erreicht der Kurs zuerst
        `confirm_price` → 'break', zuerst `reject_price` → 'bounce', keins von beiden
        binnen 60 min → 'bounce' (Timeout, wie im Training). Self-throttled (~5 min),
        aus `_trend_loop`. `candles_m1.time` ist rohe Broker-Zeit — Offset nötig."""
        now = time.time()
        if now - getattr(self, "_pbreak_eval_ts", 0.0) < 300:
            return
        self._pbreak_eval_ts = now
        try:
            import sqlite3
            off = self.trader._broker_offset_s()
            con = sqlite3.connect(HISTORY_DB_FILE, timeout=5.0)
            con.row_factory = sqlite3.Row
            pend = con.execute(
                "SELECT id, ts, direction, predicted, confirm_price, reject_price "
                "FROM pbreak_predictions WHERE outcome IS NULL"
            ).fetchall()
            for r in pend:
                d = 1 if r["direction"] == "LONG" else -1
                t0_b = r["ts"] + off                    # Vorhersage-Zeit in Broker-Zeit
                t1_b = t0_b + window_min * 60
                bars = con.execute(
                    "SELECT h, l, time FROM candles_m1 WHERE time > ? AND time <= ? "
                    "ORDER BY time ASC", (t0_b, t1_b)).fetchall()
                outcome = None
                for b in bars:
                    hit_confirm = (b["h"] >= r["confirm_price"]) if d > 0 else (b["l"] <= r["confirm_price"])
                    hit_reject  = (b["l"] <= r["reject_price"])  if d > 0 else (b["h"] >= r["reject_price"])
                    if hit_confirm:
                        outcome = "break"; break
                    if hit_reject:
                        outcome = "bounce"; break
                if outcome is None and time.time() >= (r["ts"] + window_min * 60):
                    outcome = "bounce"                  # Timeout, wie im Training (brk=False)
                if outcome:
                    correct = 1 if r["predicted"] == outcome else 0
                    con.execute(
                        "UPDATE pbreak_predictions SET outcome=?, outcome_ts=?, correct=? WHERE id=?",
                        (outcome, int(time.time()), correct, r["id"]))
            con.commit(); con.close()
        except Exception as e:
            log.debug(f"pbreak_predictions auswerten: {e}")

    def _log_m15_state(self, s: dict | None, market):
        """Loggt einen Zustandswechsel der M15-Karte — die Rueckkopplung, die
        der Karte bisher fehlte.

        ⚠⚠ NUR BEI WECHSEL. Wer je Tick loggt, bekommt dieselbe Cluster-
        Verzerrung, die am 07.08. elf widerlegte Hypothesen ausgeloest hat
        (roh 922 Zeilen 52,6 %, entkoppelt 93 Zeilen 45,2 %) — und die mein
        erster Tagestest reproduzierte (46 fortlaufende Bars als 46 Trades).
        Der Zustand wird aus Status UND Lesart gebildet: wechselt nur das
        Level, ist es ein neuer Zustand; bleibt alles gleich, passiert nichts.
        ⚠ Fail-safe: ein Fehler hier darf den Snapshot nie stoeren.
        """
        try:
            if not s:
                return
            zonen = s.get("zonen") or []
            kosten = (s.get("kosten") or {}).get("ratio")
            atr = s.get("atr_m15")
            bid = (market or {}).get("bid")
            if not atr or not bid:
                return
            nah = min(zonen, key=lambda x: x["gap_atr15"]) if zonen else None
            status = ("rot" if (kosten is not None and kosten >= 0.32)
                      else "gruen" if (nah and nah["gap_atr15"] <= 0.5) else "gelb")
            # Lesart: dieselbe Regel wie im Frontend (45–55 % = Muenzwurf)
            lesart = "unklar"
            if nah and nah.get("p_break") is not None:
                pb = nah["p_break"]
                if pb < 45 or pb > 55:
                    bricht = pb > 55
                    res = nah["seite"] == "res"
                    lesart = "auf" if (res if bricht else not res) else "ab"
            schluessel = (status, lesart,
                          None if not nah else round(nah["level"], 3))
            if schluessel == getattr(self, "_m15_last_key", None):
                return                      # kein Wechsel → nichts loggen
            self._m15_last_key = schluessel
            self.history.log_m15_state(
                status=status, veto=(s.get("bias") or {}).get("verboten"),
                kosten=kosten, level=None if not nah else nah["level"],
                gap_atr=None if not nah else nah["gap_atr15"],
                p_break=None if not nah else nah.get("p_break"),
                lesart=lesart, price=bid, atr=atr)
        except Exception as e:
            log.debug(f"m15_state log: {e}")

    def _log_cone_check(self, cone: dict | None):
        """Legt je Horizont EINEN nicht-ueberlappenden Abdeckungs-Check an.

        ⚠⚠ NICHT-UEBERLAPPEND ist hier kein Detail: ein 120-min-Fenster alle
        5 min waere 24-fach ueberlappend. Genau daran ist `analyze_hl_funding.py`
        (06.08.) aufgelaufen, und die Faelligkeitsbedingung `pbreak_accuracy_v2`
        ueberschaetzte damit die Beweismenge um das Zehnfache (07.08.). Ein neuer
        Check startet je Horizont erst, wenn der vorige abgelaufen ist."""
        try:
            if not cone or not self.history:
                return
            now = time.time()
            letzte = getattr(self, "_cone_check_ts", None)
            if letzte is None:
                letzte = self._cone_check_ts = {}
            for lv in cone.get("levels") or []:
                if lv.get("band") != 80:
                    continue
                b = lv.get("bars")
                fenster = (lv.get("minutes") or 0) * 60
                if not b or not fenster:
                    continue
                if now - letzte.get(b, 0.0) < fenster:
                    continue                     # voriger Check laeuft noch
                letzte[b] = now
                self.history.log_cone_check(
                    bars=b, band=80, price=cone.get("price") or 0.0,
                    lo=lv["lo"], hi=lv["hi"], skala=lv.get("skala") or 1.0)
        except Exception as e:
            log.debug(f"cone_check log: {e}")

    def _evaluate_cone_checks(self):
        """Loest faellige Kegel-Checks auf und fuehrt den ACI-Schritt aus.

        ⚠ Der Kegel war dokumentiert **3–5 Pp zu eng** (80 % nominal → real
        76,7 / 76,6 / 75,3 %) und blieb es seit dem 31.07., weil Nachfitten das
        Problem nur verschiebt. ACI justiert stattdessen laufend nach.
        ⚠ `candles_m1.time` ist ROHE Broker-Zeit — Offset noetig."""
        now = time.time()
        if now - getattr(self, "_cone_eval_ts", 0.0) < 300:
            return
        self._cone_eval_ts = now
        try:
            import sqlite3
            from core.cone import MINUTES, aci_update
            off = self.trader._broker_offset_s()
            con = sqlite3.connect(HISTORY_DB_FILE, timeout=5.0)
            con.row_factory = sqlite3.Row
            offen = con.execute(
                "SELECT id, ts, bars, band, lo, hi, skala FROM cone_checks "
                "WHERE done IS NULL OR done = 0").fetchall()
            skalen = dict(getattr(self, "_cone_skalen", {}) or {})
            for r in offen:
                ziel = r["ts"] + MINUTES.get(r["bars"], 30) * 60
                if now < ziel:
                    continue
                row = con.execute(
                    "SELECT c FROM candles_m1 WHERE time <= ? AND time > ? "
                    "ORDER BY time DESC LIMIT 1",
                    (ziel + off, ziel + off - 900)).fetchone()
                if not row:
                    if now >= r["ts"] + 6 * 3600:      # keine Bars mehr zu erwarten
                        con.execute("UPDATE cone_checks SET done=1 WHERE id=?", (r["id"],))
                    continue
                drin = 1 if r["lo"] <= row["c"] <= r["hi"] else 0
                con.execute("UPDATE cone_checks SET drin=?, done=1 WHERE id=?",
                            (drin, r["id"]))
                s = float(skalen.get(r["bars"]) or 1.0)
                skalen[r["bars"]] = aci_update(s, verfehlt=(drin == 0),
                                               band=r["band"] or 80)
            con.commit(); con.close()
            if skalen != getattr(self, "_cone_skalen", None):
                self._cone_skalen = skalen
                self._save_runtime_state()          # Neustart-fest
                log.info("Kegel-ACI: Skalen " + ", ".join(
                    f"{k}→{v:.3f}" for k, v in sorted(skalen.items())))
        except Exception as e:
            log.debug(f"cone_checks auswerten: {e}")

    def _evaluate_m15_states(self):
        """Traegt den Forward-Return offener M15-Zustaende nach.

        ⚠ Gewertet wird die LESART, nicht der Status: `hit=1`, wenn der Kurs in
        die Richtung lief, die die Karte am Level angezeigt hat. Zustaende ohne
        gerichtete Lesart (Muenzwurf-Zone 45–55 %) bekommen keine Richtung und
        zaehlen in der Quote nicht mit.
        ⚠ `candles_m1.time` ist ROHE Broker-Zeit — Offset noetig (die im Projekt
        mehrfach dokumentierte Falle)."""
        now = time.time()
        if now - getattr(self, "_m15_eval_ts", 0.0) < 300:
            return
        self._m15_eval_ts = now
        try:
            import sqlite3
            off = self.trader._broker_offset_s()
            con = sqlite3.connect(HISTORY_DB_FILE, timeout=5.0)
            con.row_factory = sqlite3.Row
            offen = con.execute(
                "SELECT id, ts, lesart, price, atr, ret30, ret60 FROM m15_states "
                "WHERE done IS NULL OR done = 0").fetchall()
            for r in offen:
                if r["lesart"] not in ("auf", "ab") or not r["atr"] or r["atr"] <= 0:
                    con.execute("UPDATE m15_states SET done=1 WHERE id=?", (r["id"],))
                    continue
                d = 1 if r["lesart"] == "auf" else -1
                sets, args = [], []
                for feld, minuten in (("ret30", 30), ("ret60", 60)):
                    if r[feld] is not None:
                        continue
                    ziel = r["ts"] + minuten * 60
                    if now < ziel:
                        continue
                    row = con.execute(
                        "SELECT c FROM candles_m1 WHERE time <= ? AND time > ? "
                        "ORDER BY time DESC LIMIT 1",
                        (ziel + off, ziel + off - 900)).fetchone()
                    if row:
                        v = (row["c"] - r["price"]) * d / r["atr"]
                        sets.append(f"{feld}=?"); args.append(round(v, 4))
                        sets.append(f"hit{feld[3:]}=?"); args.append(1 if v > 0 else 0)
                if now >= r["ts"] + 60 * 60 and (r["ret60"] is not None
                                                 or any("ret60" in x for x in sets)):
                    sets.append("done=?"); args.append(1)
                elif now >= r["ts"] + 6 * 3600:
                    sets.append("done=?"); args.append(1)   # keine Bars mehr zu erwarten
                if sets:
                    args.append(r["id"])
                    con.execute(f"UPDATE m15_states SET {', '.join(sets)} WHERE id=?", args)
            con.commit(); con.close()
        except Exception as e:
            log.debug(f"m15_states auswerten: {e}")

    def _evaluate_rec_outcomes(self):
        """Traegt fuer offene Empfehlungs-Episoden den Forward-Return nach.

        ⚠ `candles_m1.time` ist ROHE Broker-Zeit (UTC+3), `rec_outcomes.ts` ist
        lokale Epoch — der Offset muss drauf (dieselbe Falle wie bei
        `_evaluate_pbreak_predictions`). Genommen wird der letzte M1-Close bis
        zum Zielzeitpunkt; fehlen Bars (Wochenende, Broker-Ausfall), bleibt die
        Zeile offen statt falsch bewertet zu werden.

        `hit` = 1, wenn der Kurs in Signalrichtung lief. Die Quote ist gegen 50 %
        zu lesen, nicht gegen 0."""
        now = time.time()
        if now - getattr(self, "_rec_eval_ts", 0.0) < 300:
            return
        self._rec_eval_ts = now
        try:
            import sqlite3
            off = self.trader._broker_offset_s()
            con = sqlite3.connect(HISTORY_DB_FILE, timeout=5.0)
            con.row_factory = sqlite3.Row
            offen = con.execute(
                "SELECT id, ts, signal, price, atr, ret30, ret60 FROM rec_outcomes "
                "WHERE done IS NULL OR done = 0").fetchall()
            for r in offen:
                d = 1 if r["signal"] == "LONG" else -1
                if not r["atr"] or r["atr"] <= 0:
                    con.execute("UPDATE rec_outcomes SET done=1 WHERE id=?", (r["id"],))
                    continue
                werte = {}
                for feld, minuten in (("ret30", 30), ("ret60", 60)):
                    if r[feld] is not None:
                        werte[feld] = r[feld]
                        continue
                    ziel = r["ts"] + minuten * 60
                    if now < ziel:
                        continue                      # noch nicht faellig
                    row = con.execute(
                        "SELECT c FROM candles_m1 WHERE time <= ? AND time > ? "
                        "ORDER BY time DESC LIMIT 1",
                        (ziel + off, ziel + off - 900)).fetchone()
                    if row:
                        werte[feld] = (row["c"] - r["price"]) * d / r["atr"]
                sets, args = [], []
                for feld in ("ret30", "ret60"):
                    if feld in werte and r[feld] is None:
                        sets.append(f"{feld}=?"); args.append(round(werte[feld], 4))
                        sets.append(f"hit{feld[3:]}=?"); args.append(1 if werte[feld] > 0 else 0)
                faellig60 = now >= r["ts"] + 60 * 60
                if faellig60 and ("ret60" in werte or r["ret60"] is not None):
                    sets.append("done=?"); args.append(1)
                elif now >= r["ts"] + 6 * 3600:
                    # Nach 6 h keine Bars mehr zu erwarten (Wochenende/Ausfall) →
                    # schliessen, damit die Zeile die Auswertung nicht ewig belegt.
                    sets.append("done=?"); args.append(1)
                if sets:
                    args.append(r["id"])
                    con.execute(f"UPDATE rec_outcomes SET {', '.join(sets)} WHERE id=?",
                                args)
            con.commit(); con.close()
        except Exception as e:
            log.debug(f"rec_outcomes auswerten: {e}")

    def squeeze_monitor(self) -> dict:
        """Auto-Squeeze-Monitor (B4) für das Dashboard: (1) LIVE-Trades (echt, DB —
        das Gesamtsystem inkl. realer Exits) und (2) die MECHANISCHE Neuberechnung
        der Squeeze-Regel auf ~30 Tagen M5 (Entry-Edge ISOLIERT, Backtest-Exit) gegen
        die Erwartung (ØR +0,14…+0,23 · PF>1). Cache TTL 60 s (M5-Fetch+Scan)."""
        import sqlite3
        now = time.time()
        if self._sqmon_cache and now - self._sqmon_cache_ts < 60:
            return self._sqmon_cache
        exp = {"or_lo": 0.14, "or_hi": 0.23}

        # ── 1) Live-Trades (echt) — SQUEEZE_* aus der DB ──────────────────────
        live = {"n": 0}
        try:
            con = sqlite3.connect(HISTORY_DB_FILE); con.row_factory = sqlite3.Row
            rows = [r for r in con.execute(
                "SELECT direction, entry_price, exit_price, sl_at_entry, pnl, entry_time "
                "FROM trades WHERE setup LIKE 'SQUEEZE%' AND exit_time IS NOT NULL")]
            con.close()
            pnls = [r["pnl"] for r in rows if r["pnl"] is not None]
            if pnls:
                n = len(pnls); wins = [p for p in pnls if p > 0]; losses = [p for p in pnls if p < 0]
                Rs = []
                for r in rows:                       # ØR-Näherung via SL-Distanz (SL≈2×ATR)
                    d = 1 if r["direction"] in ("BUY", "LONG") else -1
                    sld = abs((r["entry_price"] or 0) - (r["sl_at_entry"] or 0))
                    if sld > 0 and r["exit_price"] and r["entry_price"]:
                        Rs.append(2.0 * (r["exit_price"] - r["entry_price"]) * d / sld)
                day, night = [], []
                for r in rows:
                    if r["pnl"] is None: continue
                    h = (datetime.fromtimestamp(r["entry_time"], _BERLIN).hour
                         if r["entry_time"] else 12)
                    (night if h in _SQUEEZE_NIGHT else day).append(r["pnl"])
                live = {
                    "n": n, "wr": round(100 * len(wins) / n),
                    "avg_win":  round(sum(wins) / len(wins), 2) if wins else 0.0,
                    "avg_loss": round(sum(losses) / len(losses), 2) if losses else 0.0,
                    "ratio": (round((sum(wins) / len(wins)) / abs(sum(losses) / len(losses)), 2)
                              if wins and losses else None),
                    "sum_eur": round(sum(pnls), 2),
                    "oR": round(sum(Rs) / len(Rs), 3) if Rs else None,
                    "day":   {"n": len(day),   "sum": round(sum(day), 2)},
                    "night": {"n": len(night), "sum": round(sum(night), 2)},
                }
        except Exception as e:
            live = {"n": 0, "error": str(e)[:100]}

        # ── 2) Mechanik (B4) — Squeeze-Regel neu gerechnet, Entry-Edge isoliert ──
        mech = {"error": "keine M5-Daten"}
        try:
            m5 = self._fetch_m5_monitor()
            if m5 and len(m5["C"]) >= 300:
                # ⚠ Frueher: `import backtest_breakout_squeeze as BQ` PLUS
                # `BQ._N = ...; BQ._K = ...`. Damit haing LIVE-Code an einem
                # Backtest-Skript, und die Live-Parameter wurden ueber MUTIERTE
                # MODUL-GLOBALE eingeschleust (prozessweit wirksam). Jetzt liegt
                # die Mechanik in `core/` und die Parameter stehen in der
                # Signatur. Verhalten unveraendert (bitgenau geprueft,
                # `tests/test_squeeze_scan.py`).
                from core.squeeze_scan import atr_series, scan
                from core.wave_rec import _SQ_N, _SQ_MULT, _SQ_K
                H, L, C, SP = m5["H"], m5["L"], m5["C"], m5["SP"]
                A = atr_series(H, L, C)
                sq, _ = scan(H, L, C, A, SP, 1.0, 0, len(C), _SQ_MULT,
                             box_n=_SQ_N, k=_SQ_K)
                n = len(sq)
                if n:
                    w = sum(1 for x in sq if x > 0); s = sum(sq)
                    up = sum(x for x in sq if x > 0); dn = -sum(x for x in sq if x < 0)
                    mech = {"n": n, "wr": round(100 * w / n), "oR": round(s / n, 3),
                            "pf": round(up / dn, 2) if dn > 0 else 99.9, "sum": round(s)}
                else:
                    mech = {"n": 0}
        except Exception as e:
            mech = {"error": str(e)[:100]}

        # ── 3) Verdict aus der Mechanik (isoliert = apples-to-apples zum Backtest) ──
        verdict = "watch"
        if mech.get("n", 0) >= 6 and mech.get("oR") is not None:
            if mech["oR"] > 0 and mech.get("pf", 0) > 1:
                verdict = "ontrack" if mech["oR"] >= exp["or_lo"] else "weak"
            else:
                verdict = "drift"

        res = {"live": live, "mech": mech, "expect": exp, "verdict": verdict,
               "params": {"box": None}}
        try:
            from core.wave_rec import _SQ_N, _SQ_MULT, _SQ_K
            res["params"] = {"box": _SQ_N, "k": _SQ_K, "mult": _SQ_MULT}
        except Exception:
            pass
        self._sqmon_cache = res; self._sqmon_cache_ts = now
        return res

    def _compact_stats(self, period: str) -> dict:
        """Kompakte Kennzahlen für die Live-Statistik-Kachel (WR, PF, Ø-Gewinn/
        -Verlust, Verhältnis, Trades, PnL) — aus `stats_overview`."""
        try:
            ov = self.history.stats_overview(period) or {}
        except Exception:
            return {}
        if ov.get("error"):
            return {}
        aw = ov.get("avg_win", 0.0) or 0.0
        al = ov.get("avg_loss", 0.0) or 0.0
        pf = ov.get("profit_factor")
        return {
            "n":        ov.get("n_trades", 0) or 0,
            "wr":       round(ov.get("winrate", 0.0) or 0.0),
            "pf":       round(pf, 2) if pf is not None else None,
            "avg_win":  round(aw, 2),
            "avg_loss": round(al, 2),
            "ratio":    round(aw / abs(al), 2) if al < 0 else None,
            "pnl":      round(ov.get("total_pnl", 0.0) or 0.0, 2),
        }

    def snapshot(self) -> dict:
        try:
            # 5 → 10 (User-Wunsch 2026-08-04). ⚠ Auch das `slice(0, 10)` in
            # `app.js` mitziehen — es begrenzt unabhängig davon nochmal.
            last_trades = self.history.last_closed_trades(10)
        except Exception as e:
            log.warning(f"last_closed_trades: {e}")
            last_trades = []
        market      = self.data.snapshot()
        wave_signal = self.wave.signal()
        wave_snap   = self.wave.snapshot()
        elliott     = self.elliott.snapshot()
        tu          = self.tu.snapshot()
        agent       = self.agent.snapshot()
        position    = self.trader.snapshot()
        # Tages-P/L: realisiert (heute geschlossene Trades) + offene Position
        try:
            day_realized = float((self.history.stats_overview("today") or {})
                                 .get("total_pnl") or 0.0)
        except Exception as e:
            log.warning(f"day stats: {e}"); day_realized = 0.0
        open_pnl = float(position.get("pnl") or 0.0)
        day_pl = {"realized": round(day_realized, 2), "open": round(open_pnl, 2),
                  "total": round(day_realized + open_pnl, 2)}
        # Circuit Breaker — Status für die UI (Tagesverlust-Stopp)
        _bal = float(self.data.balance or 0.0)
        _cb_limit_eur = round(self._cb_limit_pct / 100.0 * _bal, 2) if self._cb_limit_pct > 0 else None
        circuit_breaker = {
            "enabled": self._cb_limit_pct > 0, "limit_pct": self._cb_limit_pct,
            "limit_eur": _cb_limit_eur, "day_total": day_pl["total"],
            "tripped": self._circuit_halted(),
        }
        sr_close_hint = self._sr_close_hint(market, position, wave_snap)
        stop_approach = self._stop_approach_hint(market, position, wave_snap)
        _cone = _cone_build(
            (market or {}).get("bid"),
            float(((wave_snap or {}).get("pb_feats") or {}).get("atr") or 0.0),
            skalen=getattr(self, "_cone_skalen", None))
        # M15-Setup EINMAL rechnen (nicht im Dict), damit die Selbstmessung
        # daran haengen kann — ein zweiter Aufruf waere Arbeit fuer dieselben
        # Zahlen (der Konsens-Pfeil-Fehler).
        # ⚠ MUSS hier stehen, nicht in `_run_analysis`: dort gibt es weder
        # `market` noch `wave_snap`. Der erste Entwurf tat genau das und
        # erzeugte einen NameError im 1-Sekunden-Pfad. `py_compile` sieht das
        # NICHT, `ruff F821` schon (4 Befunde, darunter `_m15` selbst) — genau
        # die Fehlerklasse, fuer die der Linter am 07.08. eingebaut wurde.
        _m15 = self._m15_setup(market, wave_snap, _cone,
                               self._alignment_cached())
        self._log_m15_state(_m15, market)
        self._log_cone_check(_cone)
        # Für den KI-Copiloten festhalten (2026-08-02) — er bekam bis dahin nur
        # das Wellen-Signal und sah ausgerechnet die beiden kalibrierten Größen
        # des Projekts nicht. Hier nur ZUWEISEN, nicht neu rechnen.
        self._last_sr_close_hint = sr_close_hint
        self._last_stop_approach = stop_approach
        self._last_cone = _cone
        # einmal holen — Verdict-Stimme UND Snapshot-Feld nutzen dasselbe Objekt
        _pat_snap = self.patterns.snapshot()
        # ── Marktstatus + Hyperliquid-Kurs (User 2026-08-01) ─────────────────
        # ⚠ ZWEI Sackgassen bei der Markt-zu-Erkennung, beide verworfen:
        #   (1) `tick_local_ts` ist die lokale ABHOLZEIT — erneuert sich bei jedem
        #       Abruf, auch wenn der Broker denselben alten Tick liefert.
        #   (2) `tick_server_ts` minus `trader._broker_offset_s()` ist ZIRKULÄR: die
        #       Offset-Funktion leitet den Zeitzonen-Versatz selbst aus dem letzten
        #       Tick ab (`off = tick.time - now`). Bei geschlossenem Markt misst sie
        #       damit die Tick-Veraltung statt der Zeitzone (real −7,41 h statt +3 h)
        #       und das Alter hebt sich rechnerisch auf (Ergebnis: −347 s).
        # Verwendet wird daher der direkte Beleg: **wann hat sich der Kurs zuletzt
        # BEWEGT?** Kein Zeitzonen-, Kalender- oder Feiertagswissen nötig.
        # ⚠ NACHTRAG 2026-08-01: Punkt (2) galt nur, solange `_broker_offset_s()`
        # den Offset aus einem MÖGLICHERWEISE STALEN Tick ableitete. Seit dem Fix
        # dort (Offset nur aus frischem Tick, sonst letzter gültiger Wert) ist die
        # Rechnung nicht mehr zirkulär — deshalb dient das echte Tick-Alter jetzt
        # als STARTWERT der Stillstands-Uhr. Ohne ihn begann die Uhr bei jedem
        # Neustart bei null und der Bot brauchte 180 s, um ein längst geschlossenes
        # Wochenende zu bemerken (real: Reload direkt nach `restart_server.bat`
        # zeigte „KURS" statt „KURS · ZU" und den eingefrorenen Broker-G/V).
        # Laufender Betrieb bleibt bewusst bewegungs-basiert: das erkennt auch
        # einen eingefrorenen Feed, dessen Zeitstempel weiterlaufen.
        _now = time.time()
        try:
            _b = (market or {}).get("bid")
            if _b is not None:
                if self._last_bid is None:
                    self._last_bid = float(_b)
                    _srv = (market or {}).get("tick_server_ts")
                    _age0 = 0.0
                    if _srv:
                        _a = _now + self.trader._broker_offset_s() - float(_srv)
                        if 0.0 <= _a <= 14 * 86400:   # plausibel: bis ~2 Wochen Stillstand
                            _age0 = _a
                    self._last_bid_move_ts = _now - _age0
                elif abs(float(_b) - self._last_bid) > 1e-9:
                    self._last_bid = float(_b)
                    self._last_bid_move_ts = _now
        except Exception:
            pass
        _tick_age = (round(_now - self._last_bid_move_ts)
                     if self._last_bid_move_ts else None)
        _mkt_closed = bool(_tick_age is not None and _tick_age > _TICK_STALE_S)

        # HL-Kurs IMMER mitliefern (User: „blende den Hyperliquid-Kurs NEBEN den
        # Pepperstone-Kurs ein") — nicht nur bei geschlossenem Markt. So sieht man
        # laufend die Abweichung; am Wochenende ist es der einzige lebende Kurs.
        _hl_live = None
        try:
            _w = self.hl_walls.walls()
            if _w and _w.get("mid_mt5") is not None:
                _hl_live = {
                    "mid_mt5": _w["mid_mt5"], "hl_mid": _w.get("hl_mid"),
                    "basis": _w.get("basis"), "age_s": _w.get("age_s"),
                    # Basis auf dem letzten Stand mit lebendem Broker eingefroren
                    # (Fix 2026-08-02, s. `core/hl_walls.py`) — ohne das war die
                    # Umrechnung bei geschlossenem Markt zirkulär.
                    "basis_stale": _w.get("basis_stale"),
                    "bid": _w.get("bid"), "ask": _w.get("ask"),
                    "bid_sz": _w.get("bid_sz"), "ask_sz": _w.get("ask_sz"),
                    "imb5": _w.get("imb5"),
                    "trend": (_w.get("trend") or {}).get("dir"),
                    "slope_per_h": (_w.get("trend") or {}).get("slope_per_h"),
                    "vs_mt5": (round(_w["mid_mt5"] - float(market["bid"]), 3)
                               if (market or {}).get("bid") else None),
                }
        except Exception:
            pass

        # ── G/V mit HL-Kurs, wenn der Broker eingefroren ist (User 2026-08-01) ──
        # Bei geschlossenem Markt steht `position.pnl` still. Die Schätzung setzt den
        # HL-Kurs (basis-korrigiert, also MT5-Niveau) in `trader.live_pnl()` ein — die
        # BEREITS VORHANDENE, korrekte Umrechnung über `tick_size`/`tick_value` inkl.
        # Swap und Währungsumrechnung.
        # ⚠ Erster Versuch leitete den EUR-je-Punkt-Faktor aus `pnl / Kursbewegung`
        # ab — das ergab 155 statt ~86 EUR je 1,00 und Lot, weil `pnl` den über das
        # Wochenende aufgelaufenen SWAP enthält. Eine Kennzahl aus einer anderen
        # Kennzahl zurückzurechnen ist hier schlicht falsch, wenn zusätzliche Terme
        # drinstecken.
        # ⚠ Bleibt eine SCHÄTZUNG: HL ist ein anderer Kontrakt (Basis herausgerechnet,
        # aber nicht exakt), und der Spread am Montags-Open ist unbekannt.
        _pnl_hl = None
        try:
            if _mkt_closed and _hl_live and position and position.get("ticket"):
                _mid = float(_hl_live["mid_mt5"])
                _sp = float((market or {}).get("spread") or 0.0)
                _v = self.trader.live_pnl(_mid - _sp / 2.0, _mid + _sp / 2.0)
                if _v is not None:
                    _pnl_hl = round(_v, 2)
        except Exception:
            pass

        snap = {
            "ts":          time.time(),
            "connected":   self._connected,
            "running":     self._running,
            "error":       self._error,
            "symbol":      self.data.symbol,
            "wave_tf":     self._wave_tf_label,
            "min_conf":    _MIN_CONF_DISPLAY,
            "auth_required": self.require_token,
            "market":      market,
            # Dashboard-S/R = GLEICHE Quelle wie die Chart-Linien (`_draw_levels` =
            # rohe M5-Pivots), damit Kachel und Chart nicht mehr auseinanderlaufen.
            # `_sr_levels` (Misch-Set) bleibt intern für Strategie/Konfidenz.
            "sr_levels":   self._dash_sr(market),
            "session":     session_state(),
            "position":    position,
            "day_pl":      day_pl,
            "circuit_breaker": circuit_breaker,
            "emergency_loss":     self._emergency_loss,
            "emergency_remember": self._emergency_remember,
            "emergency_pct":      self._emergency_pct,
            "emergency_margin_pct": self._emergency_margin_pct,
            "wht_pct":            self._wht_pct,
            "takeprofit":          self._takeprofit,
            "takeprofit_remember": self._takeprofit_remember,
            "trail":       self.trail.snapshot(),
            "wave_signal": wave_signal,
            "wave":        wave_snap,
            "elliott":     elliott,
            "tu":          tu,
            "agent":       agent,
            # ⚠ `verdict` ist am 2026-08-08 aus dem Snapshot GEFLOGEN (die
            # Gesamtempfehlung wurde entfernt). `_verdict()` selbst LEBT WEITER —
            # es speist 1×/min die Telemetrie `verdict_votes` (User-Entscheidung:
            # weiter sammeln) und den optionalen MQL5-Konsens-Pfeil. Es hier im
            # 1-s-Pfad zu rechnen waere Arbeit fuer eine Anzeige, die es nicht
            # mehr gibt — genau der Fehler, der beim Konsens-Pfeil schon einmal
            # dokumentiert wurde.
            "daily_levels": self.daily.snapshot(),
            "gaps":        self.gaps.snapshot(),
            "structure":   self.structure.snapshot(),
            "patterns":    _pat_snap,
            # Kerzen-Anatomie (M5) — reine Anzeige, KEIN Verdict-Gewicht (gemessen:
            # Lehrbuch-Deutung invertiert, Handelssignal durchgefallen).
            "candle_anat": self.candle_anat.snapshot(),
            # Wahrscheinlichkeits-Kegel (Streuung, NICHT Richtung) — out-of-sample
            # kalibriert (`analyze_cone.py`). Reine Anzeige.
            "cone": _cone,
            "stats_compact": {"week": self._compact_stats("week"),
                              "all":  self._compact_stats("all")},
            "close_alert_count": self._close_alert_count,
            "news_storm": self.news.storm_state(),
            # News-Sentiment-Score (−1..+1) für den Konflikt-Chip (2026-07-24):
            # steht der Headline-Flow stark gegen Signal/Position, zeigt das
            # Frontend eine Warnung (reiner Kontext — Prädiktivität unbelegt,
            # wird via recommendations.news_score gesammelt und später gemessen).
            "news_sentiment": (lambda sc: round(float(sc), 2) if sc is not None else None)(
                                  (self.news.sentiment or {}).get("score")),
            "alignment":  self._alignment_cached(),
            # `block_mix` entfallen (2026-08-08): die Zeile `#vd-blocks` gehoerte
            # zur Gesamtempfehlung. `_block_mix_cached()` bleibt als Methode
            # stehen — die Abfrage ist fuer eine kuenftige Anzeige nuetzlich und
            # kostet ungenutzt nichts (sie laeuft nur beim Aufruf).
            "hl_ctx":     getattr(self, "_hl_ctx", None),
            "rec_track":  self._rec_track_cached(),
            # Kennzahlen der MANUELLEN Trades für die gleichnamige Karte
            # (2026-08-04). Rein deskriptiv; ~120 s gecacht, damit der heiße
            # Snapshot-Pfad nicht je Abruf die DB aggregiert.
            "manual_stats": self._manual_stats_cached(),
            # Manuell vorgegebene Einsatz-Margin (0 = automatisch, s. set_manual_margin)
            "manual_margin": getattr(self, "_manual_margin", 0.0),
            # Einsatz als % der freien Margin (`margin_buffer_pct`). Greift, solange
            # kein fester Betrag gesetzt ist — der hat Vorrang (s. set_margin_pct).
            "margin_pct": round(_cfg_margin_buffer() * 100.0, 1),
            # Live-Handelskosten relativ zur Vola (2026-07-24): Spread/ATR(M5).
            # Gemessen (`backtest_realcosts.py`): Ø 0,265×ATR, Nacht 0,32–0,50 =
            # Kostenfalle, 15–17 Uhr ~0,13 = günstig. Reine Anzeige (Chip) — die
            # informierende Alternative zum abgeschalteten Dead-Hours-Gate.
            "cost_ratio": (lambda b, a, atr: round((a - b) / max(atr, 0.06), 2)
                           if (b and a and atr) else None)(
                              (market or {}).get("bid"), (market or {}).get("ask"),
                              ((wave_snap or {}).get("pb_feats") or {}).get("atr")),
            # M15-SETUP-BEREITSCHAFT (2026-08-08) — Ersatz fuer die entfernte
            # Gesamtempfehlung. ⚠ KEINE Richtungsaussage: auf M15 traegt gemessen
            # keine (Squeeze n=33/Nachbarn kippen, VWAP-Baender ohne Edge).
            # Zeigt Bedingungen, nicht Prognosen.
            "m15_setup":   _m15,
            # Selbstmessung der Karte + Ausfuehrungsqualitaet (2026-08-08).
            "m15_track":   self._m15_track_cached(),
            "entry_gap":   self._entry_gap_cached(),
            "sr_close_hint": sr_close_hint,
            "stop_approach": stop_approach,
            "auto_sr_close": self._auto_sr_close,
            "sr_close_min_gain": self._sr_close_min_gain,
            "sr_close_pbreak": self._sr_close_pbreak,
            "sr_close_count": self._sr_close_count,
            "auto_squeeze": self._auto_squeeze,
            # Nacht-Fenster mitliefern: nach `restart_server.bat` ist ein NEUES
            # Snapshot-Feld der einzige verlässliche Beleg, dass wirklich der neue
            # Python-Code läuft (der Batch hat schon 2× still nicht neu gestartet).
            "squeeze_night_hours": list(self._squeeze_night_hours)
            if self._squeeze_skip_night else [],
            # Einstieg über ruhende Stop-Orders (2026-08-05) + die aktuell gesetzten
            # Trigger — macht im Snapshot prüfbar, ob wirklich Orders liegen.
            "squeeze_pending": self._squeeze_pending,
            "signal_pending": self._signal_pending,
            "pending_levels": (
                sorted(round(v, 3) for v in self._pending_levels.values())
                if self._pending_levels else []),
            "pending_quelle": self._pending_quelle,
            "squeeze_max_chase_atr": self._squeeze_max_chase,
            "squeeze_entry_count": self._squeeze_entry_count,
            "auto_signal": self._auto_signal,
            "auto_signal_min_conf": self._auto_signal_min_conf,
            "signal_entry_count": self._signal_entry_count,
            "adverse15_atr": self._adverse15_atr,
            "adverse15_count": self._adverse15_count,
            # Auto-Flip-Close (gemessen negativ, auf User-Wunsch gebaut) — für den
            # B4-Monitor sichtbar machen, wie oft er zuschlägt.
            "flip_close": self._flip_close,
            "flip_close_min_r": self._flip_close_min_r,
            "flip_close_count": self._flip_close_count,
            "last_trades": last_trades,
            # Wirtschaftskalender: {blackout, next, enabled, n} — Anzeige + Grund,
            # warum der Bot gerade keine autonome Order eröffnet.
            "calendar": self.calendar.snapshot(),
            # ── MARKT ZU + HYPERLIQUID-ERSATZKURS (User-Wunsch 2026-08-01) ──────
            # Pepperstone handelt WTI nicht am Wochenende; der Snapshot zeigt dann
            # den EINGEFRORENEN Freitags-Kurs, ohne dass man es sieht (der grüne
            # Punkt im Header ist die VERBINDUNG, nicht der Marktstatus). Hyperliquid
            # (`xyz:CL`) läuft dagegen 24/7 weiter.
            # `market_closed` wird NICHT aus dem Kalender abgeleitet, sondern aus dem
            # ALTER DES LETZTEN TICKS — das deckt Wochenende, Feiertage und
            # Broker-Ausfälle mit derselben Regel ab, ohne Kalenderpflege.
            # `hl_live.mid_mt5` = HL-Mid + gemessene Basis (HL notiert ~0,45 $ unter
            # dem CFD, anderer Kontrakt) → direkt mit dem MT5-Kurs vergleichbar.
            "market_closed": _mkt_closed,
            "tick_age_s": _tick_age,
            "hl_live": _hl_live,
            # G/V-Schaetzung auf HL-Basis, nur bei geschlossenem Markt (sonst None)
            "pnl_hl": _pnl_hl,
        }
        # ── Entry-Checkliste je Richtung (User-Vorgabe 2026-07-30: „blende einen
        # Hinweis ein, wenn die Checkliste gegen meine Eröffnung ist"). Wird im
        # Order-Dialog angezeigt; blockt NICHT. Nutzt nur bereits berechnete Teile
        # → kein zusätzlicher MT5-/DB-Zugriff im Snapshot-Pfad.
        try:
            _parts = {"wave": wave_snap, "market": market,
                      "news_sentiment": snap.get("news_sentiment"),
                      "cost_ratio": snap.get("cost_ratio"), "day_pl": day_pl}
            snap["checklist"] = {"long": self._entry_checklist("long", _parts),
                                 "short": self._entry_checklist("short", _parts)}
        except Exception as e:
            log.debug(f"entry_checklist: {e}")
            snap["checklist"] = None
        return snap

    def _sr_close_hint(self, market, position, wave_snap) -> dict | None:
        """S/R-Close-Empfehlung mit kalibriertem P(Durchbruch)-Modell (gemessen
        `backtest_srclose_prob.py`, Echtkosten, 2 Hälften): Kurs AM gegenüberliegenden
        Level → P(break) aus `_p_break` schätzen; ist P < `sr_close_pbreak` (Default
        0,60 = User-Regel „laufen lassen wenn >60 %"), prallt das Level wahrscheinlich
        ab → Close schlägt Laufenlassen deutlich (+6000/+7600 R vs. reines Trailing).
        Liefert IMMER die P(break)-Zahl (auch wenn ≥Schwelle → `close=False`) für die
        Live-Anzeige."""
        try:
            if not position.get("ticket"):
                self._pb_state = None
                return None
            is_long = position.get("order_type") == 0
            bid = (market or {}).get("bid")
            # Features FEST aus M5 (`wave.pb_feats`) — Modell wurde auf M5 trainiert;
            # die Wave-TF-Werte (bis M30) verschoben die Skala → P falsch (Bugfix).
            pf    = (wave_snap or {}).get("pb_feats") or {}
            atr   = pf.get("atr")
            mom6  = pf.get("mom6")
            mom3  = pf.get("mom3")
            ediff = pf.get("ema_diff")
            entry = position.get("entry_price") or bid
            # Level = EXAKT die gezeichnete Linie (`_draw_levels`, geclustert +
            # Hysterese) — für LONG die nächste Resistance, für SHORT die nächste
            # Support. So referenziert die Close-Meldung dasselbe Level, das im
            # Chart/Dashboard steht (vorher rohe pb_levels → Meldung ≠ Linie,
            # User-Feedback 2026-07-15). P(break) auf M5-Features unverändert.
            dl = self._draw_levels()
            if is_long:
                level = (dl.get("res") or [None])[0]
            else:
                level = (dl.get("sup") or [None])[0]
            if not (bid and atr and level) or mom6 is None or mom3 is None or ediff is None:
                self._pb_state = None
                return None
            d = 1 if is_long else -1
            gap = (level - bid) * d              # Abstand zum Level (in Preis)
            if gap > 0.6 * atr:                  # weit weg → gar kein Hinweis
                self._pb_state = None
                return None
            wt   = 1.0 if ediff * d > 0 else 0.0
            dist = abs(level - entry) / atr
            p_raw = _p_break(mom6 * d, mom3 * d, wt, dist)
            # ── Anti-Flattern (gemessen `analyze_pbreak_flicker.py`) ─────────────
            # (1) P über ~60 s glätten (Zeit-EMA) — mom3 der laufenden M5-Kerze ließ
            #     P sonst 7–15 Pp je Bar springen. Reset bei Level-Wechsel.
            # (2) Hysterese ±5 Pp um die Schwelle: close↔laufen wechselt erst, wenn
            #     das geglättete P die Schwelle klar durchstößt (kein Flip-Flop).
            import math as _m
            now = time.time()
            st = self._pb_state
            if not st or abs(st["level"] - level) > 1e-9:
                st = {"level": level, "p": p_raw, "ts": now, "zone": None}
            else:
                a = 1.0 - _m.exp(-max(0.0, now - st["ts"]) / 60.0)
                st["p"] += a * (p_raw - st["p"])
                st["ts"] = now
            p_s = st["p"]
            thr = self._sr_close_pbreak
            zone = st.get("zone")
            if zone is None:
                zone = "close" if p_s < thr else "run"
            elif zone == "close" and p_s >= thr + 0.05:
                zone = "run"
            elif zone == "run" and p_s < thr - 0.05:
                zone = "close"
            st["zone"] = zone
            at_level = gap <= 0.15 * atr         # Auslöse-Fenster (wie gemessen: Touch)
            # Bruch-BESTÄTIGUNGS-Preis (Fix 2026-07-22, User-Frage „genauer berechnen"):
            # dieselbe Definition wie beim TRAINING des Modells (`_BRK_ATR=0,5`,
            # `backtest_srclose_prob.py`/`analyze_srwaves.py`) — ein Kurs, der die reine
            # Levelzahl nur um wenige Cent überschreitet (Docht/Rauschen), zählt NICHT
            # als „Durchbruch"; erst level±0,5×ATR gilt als bestätigt. Reale Analyse
            # 2026-07-22: Trade bei Level 85,943 geschlossen, Kurs wischte kurz auf
            # 85,994 (< Bestätigung 86,017), fiel danach zurück → laut Modell-eigener
            # Definition eine ABLEHNUNG, kein Bruch — die Vorhersage war korrekt.
            confirm = round(level + d * 0.5 * atr, 3)   # Richtung Durchbruch
            reject  = round(level - d * 0.5 * atr, 3)   # Richtung Abprall (Gegenbestätigung)
            # Prognose-Logging (User-Wunsch 2026-07-23): EINMAL je frischem Touch
            # (at_level False→True) die aktuelle Abprall/Durchbruch-Vorhersage
            # protokollieren. Auswertung separat gegen `candles_m1`
            # (`_evaluate_pbreak_predictions`, periodisch im Trend-Loop) — dieselbe
            # confirm/reject-Definition wie beim Modell-Training, also fair verglichen.
            if at_level and not st.get("was_at_level"):
                try:
                    self.history.log_pbreak_prediction(
                        symbol=self.data.symbol or "",
                        direction=("LONG" if is_long else "SHORT"),
                        level=level, p_break=round(100 * p_s, 1),
                        predicted=("bounce" if zone == "close" else "break"),
                        price_at_pred=bid, confirm_price=confirm,
                        reject_price=reject, atr=atr)
                except Exception as le:
                    log.debug(f"pbreak_prediction log: {le}")
            st["was_at_level"] = at_level
            self._pb_state = st
            return {"level": round(level, 3), "p_break": round(100 * p_s),
                    "mom": round(mom3 * d, 2), "at_level": at_level,
                    "gap_atr": round(gap / atr, 2), "confirm": confirm,
                    # Auto-Close NUR exakt am Level; die Anzeige (0,15–0,6×ATR davor)
                    # ist reine Vorwarnung mit geglättetem P(break)
                    "close": at_level and zone == "close"}
        except Exception as e:
            log.debug(f"sr_close_hint: {e}")
            return None

    def _vola_regime(self, atr15) -> dict | None:
        """ΔATR = aktueller ATR_M15 / Median der letzten ~5 h.

        ⚠ KEIN zweiter MT5-Fetch: der ATR wird aus dem ohnehin laufenden
        Turn-Fetch gesammelt (`wave.tf_atr`), hier nur gepuffert. Ein extra
        Abruf fuer Zahlen, die schon da sind, war beim Konsens-Pfeil der Fehler.

        ⚠⚠ BELEGLAGE, ehrlich: gemessen (`analyze_slippage_vola.py`, 337
        SL-Closes) steigt die Exit-Slippage MONOTON ueber alle vier
        ΔATR-Quartile — 0,0200 → 0,0390 → 0,0645 → 0,0839 $, Faktor 4,19×.
        Die Slip-RATE bleibt dabei flach (20–23 %), die GROESSE waechst
        (0,094 → 0,396 $): es rutscht nicht oefter, sondern weiter.
        ABER: der Bootstrap auf die DIFFERENZ oben−unten ergibt
        [−0,012 … +0,183] — **enthaelt die Null**. Bei n≈85 je Quartil ist der
        Unterschied NICHT statistisch belegt. Deshalb reine ANZEIGE, kein Gate,
        und die Beschriftung sagt das auch.
        """
        try:
            if not atr15 or atr15 <= 0:
                return None
            buf = getattr(self, "_atr15_buf", None)
            if buf is None:
                from collections import deque
                buf = self._atr15_buf = deque(maxlen=1200)   # ~5 h bei 15-s-Takt
            buf.append(float(atr15))
            if len(buf) < 200:
                return {"datr": None, "stufe": None}
            import statistics as _st
            med = _st.median(buf)
            if med <= 0:
                return {"datr": None, "stufe": None}
            d = atr15 / med
            return {"datr": round(d, 2),
                    "stufe": "hoch" if d >= 1.26 else "normal" if d >= 0.91 else "ruhig"}
        except Exception:
            return None

    def _m15_setup(self, market, wave_snap, cone, alignment) -> dict | None:
        """SETUP-BEREITSCHAFT auf M15 — der Ersatz für die entfernte Gesamtempfehlung.

        ⚠⚠ BEWUSST KEINE RICHTUNGS-EMPFEHLUNG. Gemessen (2026-08-08) trägt auf
        M15 KEINE Richtungsquelle: der Squeeze fällt dort durch (n=33 in H1,
        Nachbarn kippen), VWAP-Bänder ebenso (Zufallslinie hält gleich gut, alle
        Konfidenzintervalle enthalten die Null), und 24 Signal-Eingriffe sind
        insgesamt gescheitert. Was BELEGT ist, sind Bedingungen — nicht Prognosen.
        Die Karte zeigt deshalb das Schema des Users (Bias → Zone → Reichweite →
        Veto) und überlässt den Auslöser dem Menschen, dessen Auswahl-Vorteil
        unabhängig belegt ist.

        Zusammengesetzt aus bereits berechneten Teilen — NEU gerechnet wird nur
        das Kosten-Verhältnis auf M15 und P(break) für das nächste Level. Der
        Konsens-Pfeil hat einmal ein zweites `_verdict()` gezogen; das ist die
        Lehre daraus.
        """
        try:
            bid = (market or {}).get("bid"); ask = (market or {}).get("ask")
            ws = wave_snap or {}
            atr15 = (ws.get("tf_atr") or {}).get("M15")
            out: dict = {"atr_m15": round(atr15, 4) if atr15 else None}

            # ── 1) VETO statt BIAS ────────────────────────────────────────
            # ⚠⚠ KORREKTUR 2026-08-08, nach dem Tagestest an 07.08.: der erste
            # Entwurf machte aus „M30+H1 einig" eine RICHTUNG („Bias LONG") und
            # erzeugte damit 13 LONG-Episoden an einem Tag, der 1,02 $ FIEL —
            # Trefferquote 0 %, ØR −0,753. Der Fehler ist strukturell, nicht
            # Pech: gemessen ist **„gegen den M30-Trend halbiert den Edge"**,
            # also eine VERBOTS-Aussage. Daraus einen Richtungsgeber zu machen
            # ist exakt der Fehler, wegen dem die Gesamtempfehlung entfernt
            # wurde (Richtung dort 48–51 % Treffer = Münzwurf).
            # Die nachlaufende EMA zeigt im Trendtag stur in die alte Richtung —
            # dokumentiert seit `analyze_signal_live.py` (06.08.).
            # Jetzt liefert das Feld nur noch, welche Richtung VERBOTEN ist.
            h30 = ws.get("htf_trend"); h1 = ws.get("h1_trend")
            verboten = None
            if h30:
                verboten = "SHORT" if h30 == "LONG" or h30 == 1 else "LONG"
            out["bias"] = {"m30": h30, "h1": h1,
                           "verboten": verboten,
                           "einig": bool(h30 and h1 and h30 == h1),
                           # ⚠ `richtung` bleibt None — bewusst KEINE
                           # Richtungsaussage mehr (s. o.).
                           "richtung": None}

            # ── 2) KOSTEN auf M15 — hier gewinnt M15 wirklich (gemessen 0,104
            #      gegen M5 0,193). Schwellen wie beim M5-Chip (0,20 / 0,32).
            kr = None
            if bid and ask and atr15 and atr15 > 0:
                kr = round((ask - bid) / atr15, 3)
            out["kosten"] = {"ratio": kr,
                             "stufe": (None if kr is None else
                                       "guenstig" if kr < 0.20 else
                                       "normal" if kr < 0.32 else "teuer")}

            # ── 3) ZONE — nächstes STEHENDES Level (M30-Pivots, dieselbe Quelle
            #      wie Chart und S/R-Close) + P(break). ⚠ Die P(break)-Merkmale
            #      kommen aus M5, weil das Modell darauf trainiert ist (Fix
            #      2026-07-13) — NICHT auf M15 umstellen.
            dl = self._draw_levels() or {}
            res = (dl.get("res") or [None])[0]
            sup = (dl.get("sup") or [None])[0]
            pf = ws.get("pb_feats") or {}
            a5 = pf.get("atr") or 0.2
            zonen = []
            for lvl, seite in ((res, "res"), (sup, "sup")):
                if not lvl or not bid or not atr15:
                    continue
                d = 1 if seite == "res" else -1
                gap = abs(lvl - bid)
                wt = 1.0 if (pf.get("ema_diff", 0.0) or 0.0) * d > 0 else 0.0
                p = _p_break(pf.get("mom6", 0.0) * d, pf.get("mom3", 0.0) * d,
                             wt, gap / max(a5, 0.06))
                zonen.append({"seite": seite, "level": round(lvl, 3),
                              "gap_atr15": round(gap / atr15, 2),
                              "p_break": round(100 * p)})
            out["zonen"] = zonen

            # ── 4) REICHWEITE — der Kegel (kalibriert: 80 %-Band trifft 77 %)
            lv = (cone or {}).get("levels") or []
            b80 = [x for x in lv if x.get("band") == 80]
            out["reichweite"] = [{"minutes": x.get("minutes"),
                                  "lo": x.get("lo"), "hi": x.get("hi")}
                                 for x in b80] or None

            # ── 4b) ZIEL-ERREICHBARKEIT — reine GEOMETRIE auf dem Kegel.
            #      Ziel eines Trades am nahen Level ist das GEGENÜBERLIEGENDE.
            #      Gefragt wird nur: passt dieser Abstand noch in das 80-%-Band
            #      des jeweiligen Horizonts? ⚠ KEINE Bruch-Annahme — die im
            #      Vorschlag mitgedachte „je länger, desto eher bricht es"-Regel
            #      ist gemessen NICHT robust (Touch-Zahl: umgekehrtes U auf 4
            #      Live-Tagen, im Backtest +0,010 AUC und nach dem Nachtrainieren
            #      gar nichts mehr). Hier steckt deshalb nur Arithmetik.
            if len(zonen) == 2 and bid and b80:
                nah = min(zonen, key=lambda x: x["gap_atr15"])
                fern = max(zonen, key=lambda x: x["gap_atr15"])
                strecke = abs(fern["level"] - bid)
                out["ziel"] = {
                    "level": fern["level"], "strecke": round(strecke, 3),
                    "horizonte": [{"minutes": x.get("minutes"),
                                   "drin": bool(x.get("lo") is not None
                                                and x.get("hi") is not None
                                                and x["lo"] <= fern["level"] <= x["hi"])}
                                  for x in b80],
                    "von": nah["level"]}
            else:
                out["ziel"] = None

            # ── 4c) VOLA-REGIME als Slippage-HINWEIS (kein Gate, s. Docstring)
            out["vola"] = self._vola_regime(atr15)

            # ── 5) VETO — die eigene Bilanz, je Lot (absolute Euro sind bei
            #      wechselnder Positionsgröße ungültig, Lehre vom 04.08.)
            out["veto"] = alignment or None
            return out
        except Exception as e:
            log.debug(f"m15_setup: {e}")
            return None

    def _stop_approach_hint(self, market, position, wave_snap) -> dict | None:
        """REINE ANZEIGE: P(Durchbruch) für das Level, dem sich der Kurs auf der
        **Gegen-/Stop-Seite** der offenen Position nähert (LONG → Support darunter,
        SHORT → Resistance darüber). Beantwortet die User-Frage „mein Trade läuft auf
        ein Level zu — bricht es durch (Verlust läuft) oder prallt es ab (erholt sich)?".
        NICHT der S/R-Auto-Close (der wirkt nur auf der Ziel-Seite im Plus) — hier wird
        NICHTS geschlossen. Kalibrierung der Gegen-Seite gemessen
        (`backtest_pbreak_calibration.py`, 2026-07-24): AUC 0,68/0,72 out-of-sample in
        beiden Hälften, im niedrigen P-Bereich sauber kalibriert; im hohen (≥0,5) gegen
        den Trend leicht KONSERVATIV (unterschätzt die Bruch-Rate ~10–13 Pp) → die Zahl
        ist eine belastbare, eher vorsichtige Schätzung. Feature-/Glättungs-Logik
        identisch zu `_sr_close_hint`, nur Level = Gegen-Level und Richtung = -d."""
        try:
            if not position.get("ticket"):
                self._stop_pb_state = None
                return None
            is_long = position.get("order_type") == 0
            bid = (market or {}).get("bid")
            pf    = (wave_snap or {}).get("pb_feats") or {}
            atr   = pf.get("atr"); mom6 = pf.get("mom6"); mom3 = pf.get("mom3")
            ediff = pf.get("ema_diff")
            entry = position.get("entry_price") or bid
            dl = self._draw_levels()
            # Gegen-Level: LONG → Support darunter, SHORT → Resistance darüber
            if is_long:
                level = (dl.get("sup") or [None])[0]
            else:
                level = (dl.get("res") or [None])[0]
            if not (bid and atr and level) or mom6 is None or mom3 is None or ediff is None:
                self._stop_pb_state = None
                return None
            dd = -1 if is_long else 1            # Break-Richtung GEGEN den Trade
            gap = (level - bid) * dd             # >0 solange Kurs noch vor dem Level
            if gap <= 0 or gap > 0.6 * atr:      # weit weg / schon durch → kein Hinweis
                self._stop_pb_state = None
                return None
            wt   = 1.0 if ediff * dd > 0 else 0.0
            dist = abs(level - entry) / atr
            p_raw = _p_break(mom6 * dd, mom3 * dd, wt, dist)
            import math as _m
            now = time.time(); st = self._stop_pb_state
            if not st or abs(st["level"] - level) > 1e-9:
                st = {"level": level, "p": p_raw, "ts": now}
            else:
                a = 1.0 - _m.exp(-max(0.0, now - st["ts"]) / 60.0)
                st["p"] += a * (p_raw - st["p"]); st["ts"] = now
            self._stop_pb_state = st
            p_s = st["p"]
            confirm = round(level + dd * 0.5 * atr, 3)   # Durchbruch bestätigt ab
            reject  = round(level - dd * 0.5 * atr, 3)   # Abprall bestätigt ab
            return {"level": round(level, 3),
                    "side": ("sup" if is_long else "res"),
                    "p_break": round(100 * p_s),
                    "at_level": gap <= 0.15 * atr,
                    "gap_atr": round(gap / atr, 2),
                    "confirm": confirm, "reject": reject}
        except Exception as e:
            log.debug(f"stop_approach_hint: {e}")
            return None