15-Minuten-Regel ganz abgeschaltet (adverse_15min_atr = 0)

User-Frage "vielleicht die auto close auf 30 min setzen?" -> Zeit-Achse
mitgemessen (backtest_adverse15_squeeze.py um Zeitpunkt und zweite
Population erweitert): 15/30/45/60 min x 0,5/0,8xATR, Squeeze- UND
Wave-Signal-Entries, kanonischer Exit, Echtkosten, 2 Halbjahre.

    Zeit  Schwelle   Squeeze H1/H2    Wave H1/H2
    15    0,5        -18 / -34        -25 / -41    (war live)
    30    0,5        -20 / -35        -22 / -13
    45    0,8        -12 / -18         -3 /  -7
    60    0,8         -8 / -10         -3 /  -3

ALLE 16 Kombinationen sind in BEIDEN Haelften negativ. Die Regel wird nur
monoton weniger schaedlich, je spaeter und lockerer sie prueft - die
"beste" Variante ist praktisch die, die nie feuert. 30 min haette den
Schaden halbiert, nicht beendet.

Damit ist auch meine Einschaetzung von vor einer Stunde korrigiert ("auf
dem Auto-Signal-Pfad ~neutral"): sie stuetzte sich auf
backtest_auto_signal.py mit eigenem Exit-Modell (+0,001 vs +0,026); mit dem
kanonischen Exit sind es -25/-41. Sechster Fall desselben Musters an einem
Tag.

Schutz-Stack bleibt vollstaendig: Broker-SL 2xATR + Trailing + Time-Stop
120 min. Die Squeeze-Ausnahme bleibt im Code, falls die Regel je wieder
eingeschaltet wird.

Config-Waechter-Anker auf 0 gezogen, mit Begruendung im Eintrag.

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

backtest_adverse15_squeeze.py

@@ -66,8 +66,9 @@ def squeeze_signals(H, L, C, AT, lo, hi):
     return out
 
 
-def run(sig, H, L, C, SP, adverse=None):
-    """`adverse` = Schwelle in ×ATR (None = Regel aus)."""
+def run(sig, H, L, C, SP, adverse=None, minutes=15):
+    """`adverse` = Schwelle in ×ATR (None = Regel aus), `minutes` = Prüfzeitpunkt."""
+    bars = max(1, minutes // 5)
     Rs = []
     for (j, d, atr, lvl) in sig:
         cost = (SP[j] if SP[j] > 0 else 0.0225) / atr
@@ -75,13 +76,41 @@ def run(sig, H, L, C, SP, adverse=None):
         if adverse is not None:
             j0 = j + 1
 
-            def hook(k, prof_atr, _j0=j0, _x=adverse):
-                # 1× genau beim 15-Min-Zeitpunkt prüfen (wie live)
-                return (k - _j0) == _BARS_15MIN - 1 and prof_atr <= -_x
+            def hook(k, prof_atr, _j0=j0, _x=adverse, _b=bars):
+                # 1× genau zum Prüfzeitpunkt (wie live: einmal je Ticket)
+                return (k - _j0) == _b - 1 and prof_atr <= -_x
         Rs.append(simulate(lvl, d, atr, H, L, C, j + 1, LIVE, stop_when=hook) - cost)
     return Rs
 
 
+def wave_signals(H, L, C, AT, lo, hi, step=6):
+    """WAVE-Signal-Entries — die Population, auf der die Regel kalibriert WURDE
+    und auf der sie live noch gilt (Auto-Signal-Pfad)."""
+    from core.analysis import calc_trend_angle
+    from core.wave_rec import (_EMA_FAST, _EMA_SLOW, _ANGLE_LR, _ANGLE_DEAD,
+                               _REVERSAL_STRETCH, _STRETCH_MAX)
+    def ema(v, p):
+        k = 2.0 / (p + 1); o = []; e = v[0]
+        for i, x in enumerate(v):
+            e = x if i == 0 else x * k + e * (1 - k); o.append(e)
+        return o
+    EF = ema(C, _EMA_FAST); ES = ema(C, _EMA_SLOW)
+    out = []
+    for i in range(max(lo, _N_BARS), min(hi, len(C) - LIVE.max_hold - 1), step):
+        atr = AT[i]
+        if not atr or atr < _ATRMIN:
+            continue
+        stretch = (C[i] - ES[i]) / atr
+        ang = calc_trend_angle(C[i - _ANGLE_LR - 2:i], _ANGLE_LR) - 90.0
+        d = 0
+        if stretch <= -_REVERSAL_STRETCH and ang >= _ANGLE_DEAD: d = 1
+        elif stretch >= _REVERSAL_STRETCH and ang <= -_ANGLE_DEAD: d = -1
+        elif abs(stretch) < _STRETCH_MAX: d = 1 if EF[i] > ES[i] else -1 if EF[i] < ES[i] else 0
+        if d:
+            out.append((i, d, atr, C[i]))
+    return out
+
+
 def st(Rs):
     if not Rs:
         return "  —"
@@ -115,17 +144,31 @@ def main():
     for lbl, _, _ in halves:
         print(f"  {lbl}: {len(SIG[lbl])} Squeeze-Entries")
 
-    base = {}
-    for name, adv in (("OHNE Regel", None), ("0,3×ATR", 0.3),
-                      ("0,5×ATR  ← live", 0.5), ("0,8×ATR", 0.8), ("1,2×ATR", 1.2)):
-        print(f"\n{name}")
+    WAV = {lbl: wave_signals(H, L, C, AT, a, b) for lbl, a, b in halves}
+    for lbl, _, _ in halves:
+        print(f"  {lbl}: {len(WAV[lbl])} Wave-Signal-Entries")
+
+    # ZEIT-Achse mitmessen (User-Frage 2026-07-31 „vielleicht die auto close auf
+    # 30 min setzen?"): nicht nur WIE WEIT gegen die Richtung, sondern auch WANN
+    # geprüft wird. Beide Populationen, weil die Regel auf der einen kalibriert
+    # wurde und auf der anderen (bis heute) angewandt.
+    for pop, SETS in (("SQUEEZE-Entries", SIG), ("WAVE-SIGNAL-Entries", WAV)):
+        print(f"\n{'=' * 92}\n  {pop}\n{'=' * 92}")
+        base = {}
         for lbl, _, _ in halves:
-            Rs = run(SIG[lbl], H, L, C, SP, adverse=adv)
-            s = sum(Rs)
-            if adv is None:
-                base[lbl] = s
-            d = f"   Δ ohne Regel {s - base.get(lbl, 0):+.0f}" if adv is not None else ""
-            print(f"   {lbl}  {st(Rs)}{d}")
+            Rs0 = run(SETS[lbl], H, L, C, SP, adverse=None)
+            base[lbl] = sum(Rs0)
+            print(f"   {lbl}  OHNE Regel   {st(Rs0)}")
+        print(f"\n   {'Zeitpunkt':<12}{'Schwelle':<12}"
+              + "".join(f"{l[:2]:>11}" for l, _, _ in halves) + "   (Δ gegen OHNE Regel)")
+        for mins in (15, 30, 45, 60):
+            for adv in (0.5, 0.8):
+                cells = []
+                for lbl, _, _ in halves:
+                    tot = sum(run(SETS[lbl], H, L, C, SP, adverse=adv, minutes=mins))
+                    cells.append(f"{tot - base[lbl]:>+11.0f}")
+                mark = "   ← live" if (mins == 15 and adv == 0.5) else ""
+                print(f"   {mins:>4} min    {adv:>5.1f}×ATR " + "".join(cells) + mark)
 
 
 if __name__ == "__main__":