Entry-Checkliste im Order-Dialog + Liquiditaets-Pfeile rechtsbuendig (v=120, MQL5 v1.14)

1) Entry-Checkliste (User: "blende einen Hinweis ein wenn die Checkliste gegen
   meine Eroeffnung ist"): engine._entry_checklist prueft 7 Punkte mit Live-Daten
   -- Signal-Deckung, HTF-Trend M30+H1, Entry-Raum, News-Konflikt, Kosten,
   Verlust-Serie heute (Mental-Check), Nacht-Stunde. Snapshot checklist{long,short},
   Anzeige im Bestaetigungs-Dialog, blockt nicht. Kommt jetzt auch bei vorhandenem
   Signal (alter Dialog nur bei WARTEN/Gegen-Signal).
   Real beim Einbau: beide Richtungen "stop" (11 Verluste heute = 80% des Kontos).

2) MQL5 v1.14 (User: "blende die liquiditaetslinien aus, nur die Pfeile sollen
   rechtsbuendig angezeigt werden"): LQ-Linien + Text-Labels raus, nur noch der
   Pfeil auf dem Wand-Preis, rechtsbuendig am aktuellen Rand (in RepositionLabels
   nachgefuehrt, bleibt beim Scrollen rechts). Details im Tooltip. Pinke
   Liquiditaets-Trendlinie unveraendert. Kompiliert.

3) backtest_liquidity_sweep.py (SMC Equal Highs/Lows + Swing Liquidity, Multi-TF-
   und Session-Achse): faellt durch -- Details folgen in der Doku.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>

backtest_liquidity_sweep.py

@@ -0,0 +1,316 @@
+#!/usr/bin/env python3
+"""backtest_liquidity_sweep.py — Liquiditäts-Sweeps (SMC/ICT) messen (B2).
+
+User-Vorgabe 2026-07-30 (mit Chart-Beispielen): die drei „wichtigsten Liquiditäts-
+muster" für WTI in die Gesamtempfehlung aufnehmen —
+  A) **Equal Highs → Sell-Side-Sweep**: zwei ~gleiche Hochs bilden eine Stop-Zone;
+     der Kurs schießt KURZ darüber (Sweep), schließt zurück darunter → SHORT.
+  B) **Equal Lows → Buy-Side-Sweep**: Spiegelbild → LONG.
+  C) **Swing Liquidity**: markanter Swing-Punkt wird gesweept/retestet, dann Trade
+     in Richtung des höheren Timeframe-Trends (hier M30-EMA12/50 als HTF-Proxy).
+
+⚠ WARUM das trotz 15 verworfener Signal-Ideen einen eigenen Test verdient: Der
+**Sweep ist ein FEHLAUSBRUCH** (Level kurz durchstochen, Schluss zurück im Bereich) —
+eine andere Mechanik als die bereits verworfenen Muster (`backtest_doubletop.py` misst
+den Nackenlinien-BRUCH, nicht den Fehlausbruch) und als die Struktur-/Volume-Profile-
+Klasse. Verwandt ist er mit dem validierten P(break)-Modell: ein Sweep ist genau der
+Fall „Level wird berührt/überschritten, hält aber" — dort ist die Vorhersage bereits
+belegt (AUC 0,72), allerdings nur als EXIT, nicht als Entry.
+
+Methodik (wie alle Tests hier): Signal-TF M5, sequentielle 1-Positions-Sim, Live-Exit
+(SL 2,0×ATR · Trail 1,5 ab 0,3 · Breakeven 1,3 · Time-Stop 120 min), Kosten = echter
+Bar-Spread/ATR, 2 Halbjahre. Zusätzlich wird der SMC-eigene Exit geprüft
+(Stop über/unter dem Sweep-Docht, Ziel = gegenüberliegende Liquidität), weil das
+Setup laut Lehre damit steht und fällt.
+
+Maßstab: der einzige validierte Auto-Entry (Squeeze) liefert ØR +0,14…+0,23 · PF>1
+in BEIDEN Hälften. Alles darunter ist kein Kandidat für die Gesamtempfehlung.
+
+Die vom User nachgereichten WTI-Praxisregeln sind als ACHSEN eingebaut, statt sie
+zu glauben:
+  · **Multi-TF** („Liquidität auf 4H/1H identifizieren, Entry auf 15M/5M") → die
+    Level-TF ist variabel (M5 / M30 / H1). Passt zum eigenen Befund von 2026-07-30
+    (`backtest_level_tf.py`): M30-Level schlagen M5-Level deutlich.
+  · **Session-Timing** („Sweeps um 8:30–10:30 NY = 14:30–16:30 Berlin, oder 2–4 Uhr
+    asiatische Liquiditätsjagd") → Session-Filter als eigene Variante.
+  · **„Nicht jeder Sweep dreht — warte auf den Close zurück"** → ist die harte
+    Bedingung dieses Tests (Close muss im selben Bar zurück in der Zone sein).
+  · **DXY-Korrelation** → NICHT eingebaut: die Inter-Market-Klasse (Brent/DXY) wurde
+    2026-07-19 gemessen und verworfen (`backtest_intermarket.py`, kippt zwischen den
+    Hälften). Ohne neuen Beleg keine zweite Runde.
+  · **„Sweep-Wick 0,50–1,00 $, kleiner sizen"** → im Test implizit über den
+    SMC-Exit (Stop am Docht) abgebildet; Sizing ist hier neutral (R-Rechnung).
+
+Aufruf:  python backtest_liquidity_sweep.py [n_bars]
+"""
+from __future__ import annotations
+import sys
+
+import MetaTrader5 as mt5
+
+# ── Muster-Parameter (bewusst wenige, sonst Overfitting) ─────────────────────
+_PIV_K     = 3      # Swing-Pivot-Fenster
+_EQ_TOL    = 0.15   # „gleich" = beide Hochs/Tiefs innerhalb x×ATR
+_EQ_MINGAP = 3      # min. Bars zwischen den beiden Pivots (sonst dieselbe Zacke)
+_EQ_MAXGAP = 60     # max. Bars — danach ist die Zone kalt
+_SWEEP_MIN = 0.05   # Sweep muss das Level um ≥ x×ATR überschießen (echter Stop-Grab)
+_SWEEP_MAX = 1.00   # aber nicht mehr als x×ATR (sonst echter Ausbruch, kein Sweep)
+_BACK_BARS = 3      # innerhalb so vieler Bars muss der Close zurück in die Zone
+_LOOKBACK  = 300    # Pivot-Suchfenster
+_COOL      = 12     # Cooldown zwischen Trades (Bars)
+# Session-Fenster in BERLIN-Stunden (Broker ist UTC+3 → Berlin = Broker − 1 h).
+# NY 8:30–10:30 ET ≈ 14:30–16:30 Berlin (EIA/Market-Open), Asia-Jagd 2–4 Uhr.
+_SESS = {"NY": (14, 15, 16), "Asia": (2, 3, 4), "NY+Asia": (2, 3, 4, 14, 15, 16)}
+_LEVEL_TFS = (("M5", 1), ("M30", 6), ("H1", 12))   # Level-Quelle (Multi-TF-Regel)
+
+# ── Exit (Live-Modell, identisch zu den anderen Backtests) ───────────────────
+_SL_ATR, _TRAIL, _TRAIL_ON, _BE_ON, _TIMESTOP, _MAXH = 2.0, 1.5, 0.3, 1.3, 24, 288
+_ATRMIN = 0.06
+
+
+def _atr_series(H, L, C, p=14):
+    tr = [0.0]
+    for i in range(1, len(C)):
+        tr.append(max(H[i] - L[i], abs(H[i] - C[i - 1]), abs(L[i] - C[i - 1])))
+    out = [None] * len(C); run = 0.0
+    for i in range(1, len(C)):
+        run += tr[i]
+        if i > p: run -= tr[i - p]
+        out[i] = run / min(i, p)
+    return out
+
+
+def _ema_series(v, p):
+    k = 2.0 / (p + 1); o = [v[0]]
+    for x in v[1:]:
+        o.append(x * k + o[-1] * (1 - k))
+    return o
+
+
+def _sim_live(entry, d, atr, H, L, C, j0):
+    """Live-Exit: SL 2×ATR, Trailing 1,5 ab 0,3, Breakeven 1,3, Time-Stop."""
+    eff = entry - d * _SL_ATR * atr; hw = entry; started = False
+    end = min(j0 + _MAXH, len(C) - 1); px = C[end]
+    for j in range(j0, end + 1):
+        if (L[j] <= eff) if d > 0 else (H[j] >= eff): px = eff; break
+        hw = max(hw, H[j]) if d > 0 else min(hw, L[j])
+        prof = (C[j] - entry) * d
+        if prof >= _TRAIL_ON * atr:
+            started = True
+            cand = hw - d * _TRAIL * atr
+            if prof >= _BE_ON * atr:
+                cand = max(cand, entry) if d > 0 else min(cand, entry)
+            eff = max(eff, cand) if d > 0 else min(eff, cand)
+        if not started and (j - j0) >= _TIMESTOP: px = C[j]; break
+    return (px - entry) * d / atr
+
+
+def _sim_smc(entry, d, atr, stop, target, H, L, C, j0):
+    """SMC-Exit laut Lehre: Stop über/unter dem Sweep-Docht, Ziel = gegenüber-
+    liegende Liquidität. Ohne Ziel → Live-Exit-Fallback."""
+    if target is None:
+        return _sim_live(entry, d, atr, H, L, C, j0)
+    end = min(j0 + _MAXH, len(C) - 1); px = C[end]
+    for j in range(j0, end + 1):
+        hit_stop = (L[j] <= stop) if d > 0 else (H[j] >= stop)
+        hit_tgt = (H[j] >= target) if d > 0 else (L[j] <= target)
+        # konservativ: bei beidem im selben Bar zählt der Stop
+        if hit_stop: px = stop; break
+        if hit_tgt: px = target; break
+    return (px - entry) * d / atr
+
+
+def _rep(name, Rs):
+    if not Rs or len(Rs) < 10:
+        print(f"  {name:<40} n={len(Rs):>4}  (zu wenige)"); return None
+    n = len(Rs); w = sum(1 for x in Rs if x > 0); s = sum(Rs)
+    up = sum(x for x in Rs if x > 0); dn = -sum(x for x in Rs if x < 0)
+    pf = up / dn if dn > 0 else 9.99
+    print(f"  {name:<40} n={n:>4} WR={100*w/n:>3.0f}% ØR={s/n:+.3f} "
+          f"PF={pf:.2f} ΣR={s:+.0f} worst={min(Rs):+.1f}")
+    return s / n
+
+
+def find_pivots(H, L, step=1):
+    """Pivots auf der aggregierten Level-TF; Index = M5-Index, ab dem der Pivot
+    BEKANNT ist (Bestätigung braucht k Bars danach) → kein Look-ahead."""
+    if step == 1:
+        ph = [(i, H[i]) for i in range(_PIV_K, len(H) - _PIV_K)
+              if H[i] == max(H[i - _PIV_K:i + _PIV_K + 1])]
+        pl = [(i, L[i]) for i in range(_PIV_K, len(L) - _PIV_K)
+              if L[i] == min(L[i - _PIV_K:i + _PIV_K + 1])]
+        return ph, pl
+    hh, ll = [], []
+    for s0 in range(0, len(H) - step + 1, step):
+        hh.append(max(H[s0:s0 + step])); ll.append(min(L[s0:s0 + step]))
+    ph, pl = [], []
+    for j in range(_PIV_K, len(hh) - _PIV_K):
+        avail = (j + _PIV_K + 1) * step
+        if hh[j] == max(hh[j - _PIV_K:j + _PIV_K + 1]): ph.append((avail, hh[j]))
+        if ll[j] == min(ll[j - _PIV_K:j + _PIV_K + 1]): pl.append((avail, ll[j]))
+    return ph, pl
+
+
+def scan(H, L, C, SP, A, EF30, ES30, lo_i, hi_i, mode, smc_exit,
+         step=1, hours=None, BH=None):
+    """mode: 'eqh' (Equal Highs→Short), 'eql' (Equal Lows→Long), 'swing' (HTF-Trend).
+    `step` = Level-TF (1=M5, 6=M30, 12=H1) · `hours` = erlaubte Berlin-Stunden
+    (None = alle). Ein Pivot ist erst ab (idx+k+1) bekannt → kein Look-ahead."""
+    ph, pl = find_pivots(H, L, step)
+    Rs = []
+    def cost(i, atr): return (SP[i] if SP[i] > 0 else 0.0225) / atr
+
+    i = max(lo_i, _LOOKBACK)
+    hi_i = min(hi_i, len(C) - _MAXH - 2)
+    while i < hi_i:
+        atr = A[i]
+        if not atr or atr < _ATRMIN: i += 1; continue
+        if hours is not None and BH is not None and BH[i] not in hours:
+            i += 1; continue
+        tol = _EQ_TOL * atr
+        # ── Liquiditätszone bestimmen ────────────────────────────────────────
+        level = None; d = 0; zone_lo = None
+        if mode in ("eqh", "swing"):
+            # bekannte Hoch-Pivots im Fenster (bestätigt vor i)
+            hs = [(ix, p) for ix, p in ph if i - _LOOKBACK <= ix <= i - _PIV_K - 1]
+            if mode == "eqh" and len(hs) >= 2:
+                # zwei ~gleiche Hochs mit passendem Abstand
+                for a in range(len(hs) - 1, 0, -1):
+                    for b in range(a - 1, -1, -1):
+                        gap = hs[a][0] - hs[b][0]
+                        if gap < _EQ_MINGAP: continue
+                        if gap > _EQ_MAXGAP: break
+                        if abs(hs[a][1] - hs[b][1]) <= tol:
+                            level = max(hs[a][1], hs[b][1]); d = -1; break
+                    if level is not None: break
+            elif mode == "swing" and hs:
+                level = hs[-1][1]; d = -1
+        if mode in ("eql", "swing") and level is None:
+            ls = [(ix, p) for ix, p in pl if i - _LOOKBACK <= ix <= i - _PIV_K - 1]
+            if mode == "eql" and len(ls) >= 2:
+                for a in range(len(ls) - 1, 0, -1):
+                    for b in range(a - 1, -1, -1):
+                        gap = ls[a][0] - ls[b][0]
+                        if gap < _EQ_MINGAP: continue
+                        if gap > _EQ_MAXGAP: break
+                        if abs(ls[a][1] - ls[b][1]) <= tol:
+                            level = min(ls[a][1], ls[b][1]); d = 1; break
+                    if level is not None: break
+            elif mode == "swing" and ls:
+                level = ls[-1][1]; d = 1
+        if level is None or d == 0: i += 1; continue
+
+        # ── Sweep prüfen: Bar i durchsticht das Level, Close kommt zurück ────
+        if d < 0:   # Equal Highs: High über Level, Close zurück darunter
+            over = H[i] - level
+            swept = (_SWEEP_MIN * atr <= over <= _SWEEP_MAX * atr) and C[i] < level
+            wick = H[i]
+        else:       # Equal Lows: Low unter Level, Close zurück darüber
+            over = level - L[i]
+            swept = (_SWEEP_MIN * atr <= over <= _SWEEP_MAX * atr) and C[i] > level
+            wick = L[i]
+        if not swept:
+            i += 1; continue
+        # „Close zurück in die Zone" darf auch 1–_BACK_BARS Bars dauern; hier ist er
+        # bereits im Sweep-Bar erfüllt (strengste, sauberste Variante).
+
+        # Swing-Modus: nur MIT dem HTF-Trend (M30-EMA12/50) handeln
+        if mode == "swing":
+            htf = 1 if EF30[i] > ES30[i] else -1 if EF30[i] < ES30[i] else 0
+            if htf != d: i += 1; continue
+
+        entry = C[i]
+        stop = wick + d * -1 * (0.05 * atr)   # knapp jenseits des Sweep-Dochts
+        stop = (wick - 0.05 * atr) if d > 0 else (wick + 0.05 * atr)
+        # Ziel = gegenüberliegende Liquidität (nächster Pivot in Trade-Richtung)
+        if d < 0:
+            cands = [p for ix, p in pl if i - _LOOKBACK <= ix <= i - _PIV_K - 1
+                     and p < entry - 0.3 * atr]
+            target = max(cands) if cands else None
+        else:
+            cands = [p for ix, p in ph if i - _LOOKBACK <= ix <= i - _PIV_K - 1
+                     and p > entry + 0.3 * atr]
+            target = min(cands) if cands else None
+
+        R = (_sim_smc(entry, d, atr, stop, target, H, L, C, i + 1) if smc_exit
+             else _sim_live(entry, d, atr, H, L, C, i + 1)) - cost(i, atr)
+        Rs.append(R)
+        i += _COOL
+    return Rs
+
+
+def main():
+    n = int(sys.argv[1]) if len(sys.argv) > 1 else 80000
+    mt5.initialize(); sym = None
+    for c in ("SpotCrude", "USOIL", "WTI", "XTIUSD"):
+        if mt5.symbol_info(c): sym = c; break
+    bars = mt5.copy_rates_from_pos(sym, mt5.TIMEFRAME_M5, 0, n)
+    si = mt5.symbol_info(sym); point = si.point
+    mt5.shutdown()
+    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]
+    A = _atr_series(H, L, C)
+    # HTF-Proxy für den Swing-Modus: M30 aus M5 aggregiert (6 Bars), auf M5 gemappt
+    c30 = [C[s + 5] for s in range(0, len(C) - 5, 6)]
+    e12 = _ema_series(c30, 12); e50 = _ema_series(c30, 50)
+    EF30 = [0.0] * len(C); ES30 = [0.0] * len(C)
+    for i in range(len(C)):
+        j = i // 6 - 1
+        if 0 <= j < len(e12): EF30[i] = e12[j]; ES30[i] = e50[j]
+    # Berlin-Stunde je Bar (Broker UTC+3 → Berlin = Broker − 1 h, Sommerzeit)
+    from datetime import datetime, timezone
+    BH = [(datetime.fromtimestamp(int(b["time"]), timezone.utc).hour - 1) % 24
+          for b in bars]
+    N = len(C); mid = N // 2
+
+    print("=" * 96)
+    print(f"  LIQUIDITÄTS-SWEEPS (SMC) — {sym} M5 ({N} Bars, 2 Halbjahre)")
+    print(f"  Sweep = Level um {_SWEEP_MIN}–{_SWEEP_MAX}×ATR durchstochen, Close zurück in der Zone")
+    print(f"  Maßstab: validierter Squeeze ØR +0,14…+0,23 · PF>1 in BEIDEN Hälften")
+    print("=" * 96)
+
+    verdict = {}
+    MODES = (("eqh", "A) Equal Highs -> SHORT"),
+             ("eql", "B) Equal Lows -> LONG"),
+             ("swing", "C) Swing-Liquidity (HTF)"))
+    # ── Achse 1: LEVEL-TF (Multi-TF-Regel „Liquidität auf höherem TF") × Exit ──
+    for tf_lbl, step in _LEVEL_TFS:
+        print("\n" + "=" * 96)
+        print(f"### LEVEL-TF {tf_lbl} — Liquidität auf {tf_lbl} identifiziert, Entry auf M5")
+        for exit_lbl, smc in (("Live-Exit", False), ("SMC-Exit", True)):
+            print(f"\n  --- EXIT: {exit_lbl} ---")
+            for mode, mlabel in MODES:
+                for hl, lo, hi in (("H1", _LOOKBACK, mid), ("H2", mid, N)):
+                    Rs = scan(H, L, C, SP, A, EF30, ES30, lo, hi, mode, smc, step)
+                    oR = _rep(f"{mlabel} [{hl}]", Rs)
+                    verdict.setdefault((f"{tf_lbl}/{exit_lbl}", mlabel), []).append(oR)
+    # ── Achse 2: SESSION-Filter (Level-TF M30, Live-Exit) ────────────────────
+    print("\n" + "=" * 96)
+    print("### SESSION-FILTER (Level-TF M30, Live-Exit) — „Sweeps passieren um 14–16 / 2–4 Uhr\"")
+    for sess, hours in _SESS.items():
+        print(f"\n  --- Session: {sess} (Berlin-Stunden {hours}) ---")
+        for mode, mlabel in MODES[:2]:
+            for hl, lo, hi in (("H1", _LOOKBACK, mid), ("H2", mid, N)):
+                Rs = scan(H, L, C, SP, A, EF30, ES30, lo, hi, mode, False, 6, hours, BH)
+                oR = _rep(f"{mlabel} [{hl}]", Rs)
+                verdict.setdefault((f"M30/Sess-{sess}", mlabel), []).append(oR)
+
+    print("\n" + "=" * 96)
+    print("  URTEIL (Kandidat für die Gesamtempfehlung nur, wenn ØR in BEIDEN Hälften")
+    print("  > 0 UND ≥ +0,14 = Squeeze-Band):")
+    any_ok = False
+    for (ex, m), vals in verdict.items():
+        if len(vals) != 2 or any(v is None for v in vals):
+            print(f"  {m:<38} {ex[:22]:<24} unvollständig"); continue
+        ok = all(v > 0 for v in vals); band = all(v >= 0.14 for v in vals)
+        mark = "✅ TRÄGT" if (ok and band) else ("⚠ positiv, unter Band" if ok else "❌ fällt durch")
+        if ok and band: any_ok = True
+        print(f"  {m:<38} {ex[:22]:<24} H1 {vals[0]:+.3f} · H2 {vals[1]:+.3f}  {mark}")
+    print("\n  " + ("→ Kandidat gefunden: Parameter-Robustheit prüfen, dann als Verdict-Modul."
+                    if any_ok else
+                    "→ KEINE Variante trägt beidhälftig im Squeeze-Band → nicht in die "
+                    "Gesamtempfehlung (höchstens als Anzeige)."))
+
+
+if __name__ == "__main__":
+    main()

core/engine.py

@@ -2088,6 +2088,133 @@ class TradingEngine:
             self._align_ts = now
         return getattr(self, "_align_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
+        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 —
@@ -2309,7 +2436,7 @@ class TradingEngine:
         }
         sr_close_hint = self._sr_close_hint(market, position, wave_snap)
         stop_approach = self._stop_approach_hint(market, position, wave_snap)
-        return {
+        snap = {
             "ts":          time.time(),
             "connected":   self._connected,
             "running":     self._running,
@@ -2380,6 +2507,20 @@ class TradingEngine:
             "adverse15_count": self._adverse15_count,
             "last_trades": last_trades,
         }
+        # ── 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

mql5/SR_Levels.mq5

@@ -12,7 +12,13 @@
 //|  4) Der Bot muss laufen (schreibt die CSV alle ~5 s).             |
 //+------------------------------------------------------------------+
 #property copyright "Oil Trading Bot"
-#property version   "1.13"
+#property version   "1.14"
+// v1.14 (2026-07-30): Liquiditäts-LINIEN + Text-Labels ENTFERNT (User: „blende die
+//        liquiditätslinien aus, nur die Pfeile sollen rechtsbündig angezeigt werden").
+//        Es bleibt NUR der Pfeil auf dem Wand-Preis, RECHTSBÜNDIG am aktuellen Rand
+//        (wird in RepositionLabels() nachgeführt, bleibt beim Scrollen rechts).
+//        Details (Seite/Größe/Dominanz/Preis) jetzt im TOOLTIP statt im Chart.
+//        Die pinke Liquiditäts-Trendlinie bleibt unverändert.
 // v1.13 (2026-07-30): Liquiditäts-Wände bekommen einen PFEIL in ihrer Wirkrichtung
 //        (Lesart „die Wand hält" — Nachfrage stützt hoch, Angebot deckelt runter;
 //        die GRÖSSERE Wand wird dicker gezeichnet + "<<"). NEU: pinke
@@ -95,6 +101,17 @@ void RepositionLabels()
          ObjectMove(0, nm, 0, ct, pr);
       }
    }
+   // Liquiditäts-PFEILE rechtsbündig halten: die CSV ändert sich nicht bei jedem
+   // Tick, ohne Nachführung würden die Pfeile mit jeder neuen Kerze nach links
+   // wandern. Preis bleibt, nur die Zeit wird an den rechten Rand gezogen.
+   datetime rt = iTime(_Symbol, PERIOD_CURRENT, 0) + (datetime)(PeriodSeconds() * 2);
+   int na = ObjectsTotal(0, 0, OBJ_ARROW);
+   for(int i = 0; i < na; i++)
+   {
+      string nm = ObjectName(0, i, 0, OBJ_ARROW);
+      if(StringFind(nm, PFX + "ALQ_") == 0)
+         ObjectMove(0, nm, 0, rt, ObjectGetDouble(0, nm, OBJPROP_PRICE));
+   }
    ChartRedraw();
 }
 //+------------------------------------------------------------------+
@@ -277,54 +294,39 @@ void Redraw()
          if(lpx <= 0) continue;
          bool   isBid = (side == "B");
          color  lcol  = isBid ? InpWallBidColor : InpWallAskColor;
-         string nm = PFX + "LQ_" + side;
+         // ⚠ 2026-07-30 (User): KEINE waagerechte Linie und KEIN Text-Label mehr —
-         if(ObjectCreate(0, nm, OBJ_HLINE, 0, 0, lpx))
+         // der Chart war zu voll. Es bleibt NUR der Pfeil, RECHTSBÜNDIG am aktuellen
-         {
+         // Rand, auf dem Preisniveau der Wand. Die Details (Seite/Größe/Dominanz)
-            ObjectSetInteger(0, nm, OBJPROP_COLOR, lcol);
+         // stehen im TOOLTIP (Maus drüber) statt fest im Chart.
-            ObjectSetInteger(0, nm, OBJPROP_STYLE, STYLE_DASH);
-            ObjectSetInteger(0, nm, OBJPROP_WIDTH, 2);
-            ObjectSetInteger(0, nm, OBJPROP_BACK, true);
-            ObjectSetInteger(0, nm, OBJPROP_SELECTABLE, false);
-         }
-         else
-            ObjectMove(0, nm, 0, 0, lpx);
-         // Pfeil = Wirkrichtung der Wand (Feld 4: U/D). Lesart „die Wand HÄLT":
-         // Nachfrage-Wand stützt von unten (hoch), Angebots-Wand deckelt (runter).
-         // Feld 5 = 1 bei der GRÖSSEREN der beiden Wände → dickere Linie + "<<".
          string dirc  = (k > 4) ? p[4] : (isBid ? "U" : "D");
          bool   isDom = (k > 5 && p[5] == "1");
-         string arrow = (dirc == "U" ? CharToString(94) : CharToString(118)); // ^ / v
-         if(isDom)
-            ObjectSetInteger(0, nm, OBJPROP_WIDTH, 3);
-         string llbl = arrow + " " + (isBid ? "Liquidität NACHFRAGE " : "Liquidität ANGEBOT ")
-                     + DoubleToString(lsz, 0) + (isDom ? " <<" : "");
-         string ltn = PFX + "TLQ_" + side;
-         if(ObjectCreate(0, ltn, OBJ_TEXT, 0, CenterTime(), lpx))
-         {
-            ObjectSetString (0, ltn, OBJPROP_TEXT, llbl);
-            ObjectSetInteger(0, ltn, OBJPROP_COLOR, lcol);
-            ObjectSetInteger(0, ltn, OBJPROP_FONTSIZE, 9);
-            ObjectSetInteger(0, ltn, OBJPROP_ANCHOR, ANCHOR_LOWER);
-            ObjectSetInteger(0, ltn, OBJPROP_SELECTABLE, false);
-         }
-         else
-         {
-            ObjectMove(0, ltn, 0, CenterTime(), lpx);
-            ObjectSetString(0, ltn, OBJPROP_TEXT, llbl);
-         }
-         // Echtes Pfeil-Objekt am rechten Rand (Wingdings 233 hoch / 234 runter) —
-         // deutlicher sichtbar als das Textzeichen im Label.
          string an = PFX + "ALQ_" + side;
-         datetime atime = CenterTime() + (datetime)(PeriodSeconds() * 6);
+         // Rechter Rand = aktuelle (rechteste) Kerze + kleiner Versatz, damit der
+         // Pfeil frei neben dem Kursverlauf steht und beim Scrollen rechts bleibt.
+         datetime atime = iTime(_Symbol, PERIOD_CURRENT, 0)
+                        + (datetime)(PeriodSeconds() * 2);
          if(ObjectCreate(0, an, OBJ_ARROW, 0, atime, lpx))
          {
             ObjectSetInteger(0, an, OBJPROP_ARROWCODE, (dirc == "U" ? 233 : 234));
             ObjectSetInteger(0, an, OBJPROP_COLOR, lcol);
-            ObjectSetInteger(0, an, OBJPROP_WIDTH, (isDom ? 3 : 2));
+            ObjectSetInteger(0, an, OBJPROP_WIDTH, (isDom ? 4 : 2));
+            ObjectSetInteger(0, an, OBJPROP_ANCHOR, ANCHOR_LEFT);
             ObjectSetInteger(0, an, OBJPROP_SELECTABLE, false);
          }
          else
+         {
             ObjectMove(0, an, 0, atime, lpx);
+            ObjectSetInteger(0, an, OBJPROP_WIDTH, (isDom ? 4 : 2));
+            ObjectSetInteger(0, an, OBJPROP_COLOR, lcol);
+            ObjectSetInteger(0, an, OBJPROP_ARROWCODE, (dirc == "U" ? 233 : 234));
+         }
+         ObjectSetString(0, an, OBJPROP_TOOLTIP,
+                         (isBid ? "Liquiditaet NACHFRAGE " : "Liquiditaet ANGEBOT ")
+                         + DoubleToString(lsz, 0) + (isDom ? " (dominant)" : "")
+                         + "  @ " + DoubleToString(lpx, (int)_Digits));
+         // evtl. noch vorhandene Alt-Objekte (Linie/Label aus v1.13) entfernen
+         ObjectDelete(0, PFX + "LQ_" + side);
+         ObjectDelete(0, PFX + "TLQ_" + side);
          continue;
       }
       // Liquiditäts-TRENDLINIE: LT;t1;p1;t2;p2;<U|D>  (pink, nach rechts verlängert).

web/app.js

@@ -874,8 +874,37 @@ document.querySelectorAll(".btn[data-side]").forEach(btn => {
     if (btn.disabled) return;
     const side = btn.dataset.side;
     if (side === "long" || side === "short") {
-      const info = recInfo(side);            // WARTEN/Gegen-Signal → Hinweis, der
+      // ── Entry-Checkliste (User-Vorgabe 2026-07-30): zeigt VOR der Eröffnung,
-      if (info.danger) {                     // bestätigt werden muss (kein Block)
+      // was dagegen spricht — auch dann, wenn ein Signal da ist (der alte Dialog
+      // kam nur bei WARTEN/Gegen-Signal). Blockt nicht, macht nur sichtbar.
+      const cl = (lastSnap.checklist || {})[side];
+      const info = recInfo(side);
+      if (cl && (cl.fails > 0 || cl.warns > 0)) {
+        const ICON = { fail: "❌", warn: "⚠", ok: "✅" };
+        const bad = cl.items.filter(x => x.state !== "ok");
+        const good = cl.items.filter(x => x.state === "ok");
+        let body = bad.map(x => `${ICON[x.state]} ${x.label}`
+          + (x.detail ? `\n     ${x.detail}` : "")).join("\n");
+        if (good.length) body += `\n\n${good.map(x => `✅ ${x.label}`).join("\n")}`;
+        // Eigene Zahlen zur Ausrichtung ergänzen (gemessene Kern-Leckage)
+        const al = lastSnap.alignment || null;
+        const sigNow = (lastSnap.wave_signal || {}).signal || "WARTEN";
+        const isWait0 = (sigNow === "WARTEN" || sigNow === "—");
+        if (al && cl.items.some(x => x.key === "signal" && x.state === "fail")) {
+          const grp = isWait0 ? al.none : al.against, ref = al.with;
+          const f = g => (g && g.n >= 5)
+            ? `${g.wr}% Treffer · ${g.pnl >= 0 ? "+" : ""}${fmt(g.pnl, 0)} € (n${g.n})` : null;
+          const own = f(grp), rf = f(ref);
+          if (own) body += `\n\n📊 Deine Trades ${isWait0 ? "OHNE" : "GEGEN"} Signal: ${own}`;
+          if (rf)  body += `\n📊 Mit Signal: ${rf}`;
+        }
+        const head = cl.verdict === "stop"
+          ? `🛑 Checkliste sagt NEIN (${cl.fails} Punkte dagegen)`
+          : `⚠ Checkliste: ${cl.fails} dagegen, ${cl.warns} Vorsicht`;
+        const ok = await modal(head, body + `\n\n${side.toUpperCase()} trotzdem eröffnen?`,
+                               "confirm", true);
+        if (!ok) return;
+      } else if (info.danger) {              // Fallback: alter Hinweis (kein Block)
         const sig = (lastSnap.wave_signal || {}).signal || "WARTEN";
         const isWait = (sig === "WARTEN" || sig === "—");
         const head = isWait

web/index.html

@@ -6,7 +6,7 @@
   <meta name="theme-color" content="#0d1117">
   <title>Oil · MT5</title>
   <link rel="manifest" href="manifest.json">
-  <link rel="stylesheet" href="style.css?v=119">
+  <link rel="stylesheet" href="style.css?v=120">
 </head>
 <body>
   <!-- Modul-Menü (ganz oben) -->
@@ -229,6 +229,6 @@
   <div id="toast" class="toast hidden"></div>
 
   <script src="lightweight-charts.standalone.production.js?v=114"></script>
-  <script src="app.js?v=119"></script>
+  <script src="app.js?v=120"></script>
 </body>
 </html>