Beide offenen Vorschlaege umgesetzt: Trail 1,0 + Legacy-Recheck

VORSCHLAG 1 - Trail-Multiplikator 1,5 -> 1,0 (core/exit_model.py LIVE.mult),
live verifiziert ("AKTIVIERT ... mult=1.0x").
Voller Sweep mit FIXEM SL 2,0 (backtest_trailmult.py, 8 Werte 0,5-3,0):
enger ist MONOTON besser. Wave-Signal H1/H2 SigmaR:
    0,5 +1258/+2418 · 0,8 +852/+1668 · 1,0 +80/+1360
    1,5 -220/+1305 · 2,0 -394/+1198 · 2,5 -1072/+1327
Optimum am RAND = Warnsignal, deshalb Gegentest auf SQUEEZE-Entries mit
Echtkosten (--squeeze): das Setup lebt von Laeufern, muesste also
dagegenhalten - tut es NICHT (1,0: H1 -0,202/H2 +0,010 · 1,5:
-0,219/-0,032). Deshalb 1,0 (besser als 1,5 in beiden Haelften auf BEIDEN
Signalmengen), aber NICHT 0,5: Randwert, und die Sim modelliert keine
Exit-Slippage - ein engerer Trail loest viel haeufiger aus und ist davon
staerker betroffen (real bis 0,75xATR ueber den Stop).

VORSCHLAG 2 - backtest_legacy_recheck.py (NEU): die beiden Legacy-Befunde
nachgerechnet, die live ECHTE Gates steuern.
  EIA-Blackout BESTAETIGT: auch mit echtem Exit + Echtkosten in BEIDEN
  Haelften schlechter als der Rest (-0,097 / -0,119). Gate ist gedeckt.
  DEAD-HOURS reproduzieren NICHT als selektiver Befund: 19 von 22 Stunden
  sind in beiden Haelften negativ, keine robust positive Stunde. Die alte
  Auswahl (0-7, 12, 16) ist damit nicht mehr gestuetzt. Praktisch folgenlos
  (dead_hours ist leer), aber eine Reaktivierung auf der alten Begruendung
  waere nicht gedeckt.

Einschraenkung selbst benannt: der Recheck handelt die UNGEGATETE
EMA-Richtung (ohne min_conf, Breakout-Bestaetigung, HTF-Filter, Raum-Gate).
Fuer den Vergleich neutral, die absoluten Werte sind nicht das Live-Signal.

Konsequenz fuer den TF-Churn-Fix: "WARTEN Richtung 43 %" ist eine
Haeufigkeits-, keine Ertragsgroesse - mehr Signale sind nur dann besser,
wenn die freigegebenen Setups auch tragen.

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

backtest_trailmult.py

@@ -81,17 +81,50 @@ def signals(H, L, C, ES, EF, AT, lo, hi, step):
     return out
 
 
+def squeeze_signals(H, L, C, AT, lo, hi):
+    """Nur SQUEEZE-Ausbrüche — der EINZIGE Setup mit belegtem Edge, und er lebt von
+    LÄUFERN (43 % Treffer, Ertrag im Tail). Gegentest zum Wave-Signal: ein enger
+    Trail, der dort gewinnt, muss hier verlieren, wenn er nur „früher aussteigen"
+    belohnt. Regel exakt wie live (`wave._squeeze_one`)."""
+    from core.wave_rec import _SQ_N, _SQ_MULT, _SQ_K
+    _W = 24; _COOL = 12
+    out = []
+    i = max(lo, _N_BARS, _SQ_N + 15)
+    while i < min(hi, len(C) - LIVE.max_hold - 1):
+        atr = AT[i]
+        if not atr or atr < 0.06:
+            i += 1; continue
+        boxHi = max(H[i - _SQ_N:i]); boxLo = min(L[i - _SQ_N:i])
+        if (boxHi - boxLo) > _SQ_MULT * atr:
+            i += 1; continue
+        hit = None
+        for j in range(i, min(i + _W, len(C) - LIVE.max_hold - 1)):
+            up = boxHi + _SQ_K * atr; dn = boxLo - _SQ_K * atr
+            if H[j] >= up: hit = (j, 1, up); break
+            if L[j] <= dn: hit = (j, -1, dn); break
+        if hit is None:
+            i += 1; continue
+        j, d, lvl = hit
+        out.append((j, d, atr, lvl))
+        i = j + _COOL
+    return out
+
+
 def main():
-    n = int(sys.argv[1]) if len(sys.argv) > 1 else 80000
-    step = int(sys.argv[2]) if len(sys.argv) > 2 else 2
+    squeeze = "--squeeze" in sys.argv
+    args = [a for a in sys.argv[1:] if not a.startswith("--")]
+    n = int(args[0]) if args else 80000
+    step = int(args[1]) if len(args) > 1 else 2
     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]
     EF = _ema_series(C, _EMA_FAST); ES = _ema_series(C, _EMA_SLOW); AT = _atr_series(H, L, C)
     mid = len(C) // 2
     halves = [("H1 (alt)", _N_BARS, mid), ("H2 (neu)", mid, len(C))]
@@ -99,16 +132,27 @@ def main():
     print(f"  TRAIL-MULTIPLIKATOR — {sym} M5 ({len(C)} Bars)")
     print(f"  Initial-SL FEST {LIVE.sl_atr}×ATR (wie live) · nur der Trail variiert")
     print(f"  Exit aus core/exit_model.py · Time-Stop {LIVE.timestop_bars} Bars · BE {LIVE.be}")
+    if squeeze:
+        print("  Signal-Set: NUR SQUEEZE-Ausbrueche (laeuferabhaengig) · ECHTKOSTEN")
     print("=" * 92)
-    SIG = {lbl: signals(H, L, C, ES, EF, AT, a, b, step) for lbl, a, b in halves}
+    if squeeze:
+        SIG = {lbl: [(i, d, atr) for (i, d, atr, _lv)
+                     in squeeze_signals(H, L, C, AT, a, b)] for lbl, a, b in halves}
+    else:
+        SIG = {lbl: signals(H, L, C, ES, EF, AT, a, b, step) for lbl, a, b in halves}
     for lbl, _, _ in halves:
         print(f"  {lbl}: {len(SIG[lbl])} Signale")
-    for mult in (1.0, 1.5, 2.0, 2.5, 3.0):
+    # ⚠ Auch die kleinen Werte prüfen: läuft es nach unten monoton weiter besser,
+    # liegt das „Optimum" am Rand des getesteten Bereichs = Warnsignal (dann misst
+    # man womöglich nur „macht weniger" statt „macht es besser").
+    for mult in (0.5, 0.75, 1.0, 1.25, 1.5, 2.0, 2.5, 3.0):
         tag = "  ← live (nach Stufe 1)" if abs(mult - 1.5) < 1e-9 else ""
         print(f"\nTrail {mult:.1f}×ATR{tag}")
         for lbl, _, _ in halves:
             p = LIVE.with_(mult=mult)
-            Rs = [simulate(C[i], d, atr, H, L, C, i + 1, p) for (i, d, atr) in SIG[lbl]]
+            Rs = [simulate(C[i], d, atr, H, L, C, i + 1, p)
+                  - ((SP[i] if SP[i] > 0 else 0.0225) / atr if squeeze else 0.0)
+                  for (i, d, atr) in SIG[lbl]]
             print(f"   {lbl}  {st(Rs)}")