Enger Stop fuer die ersten N Bars: keine Aenderung (backtest_sl_staged.py)

User-Idee: SL beim Eroeffnen sehr eng, damit falsch laufende Trades frueh
geschlossen werden; laeuft er richtig, etappenweise nachziehen. Der zweite Teil
ist laengst gebaut (Phasen-Ratsche); neu war allein der zeitlich befristete
enge Stop.

Ohne Exit-Nachbau gerechnet: Lauf A (sl_atr=eng) und B (sl_atr=weit) laufen auf
DEMSELBEN Pfad; innerhalb der ersten N Bars ist der einzige Unterschied der
SL-Abstand, jeder Nicht-SL-Ausstieg faellt identisch aus. Also exakt
R = R_A wenn A vor/bei Bar N aussteigt, sonst R_B. Keine fuenfte Exit-Kopie.

80k M5, Squeeze-Entries, ruhende Order am Level, kanonischer Exit, Echtkosten,
ein Slot. Basis = durchgehend 3,4xATR_M5 (der Live-Stop, aus 121 echten Trades
als Median gegengerechnet):

  Basis          H1 -0,248 / WR 37,0 % / worst -3,73   H2 -0,107 / 44,4 % / -3,74
  N=3,  eng 0,5  H1 -0,263 / WR 23,3 %                 H2 -0,043 / 30,4 %
  N=6,  eng 0,5  H1 -0,242 / WR 22,9 % / worst -0,89   H2 -0,045 / 30,1 % / -0,96
  N=12, eng 0,5  H1 -0,240                             H2 -0,044

DER ENTSCHEIDENDE BEFUND IST STRUKTURELL: die Staffelung hat keinen Raum. Bei
N=12 steigen 269 von 279 Trades schon in Phase 1 aus (96 %) -- die mittlere
Haltedauer ist 12-18 min, "die ersten 30-60 Minuten" sind der ganze Trade. Wo
die Staffelung ueberhaupt etwas anderes tut als ein dauerhaft enger Stop (N=3),
ist sie in H1 bei allen vier eng-Werten schlechter. Wo sie gewinnt (N=6/12), ist
sie kein gestaffelter Stop mehr, sondern ein permanent enger.

Regel verfehlt: die zwei nominell besseren Kombinationen liegen in H1 bei
+0,007/+0,008, also weit unter einem Standardfehler (~0,055 bei n=279), die
Nachbarn kippen, und alle Werte sind negativ (Verlustgrade, kein Edge).

WAS ECHT IST: der Tail. Worst-Case -3,73 -> -0,83/-0,96 = Faktor 4. Bezahlt mit
der Trefferquote (37,0 -> 22,9 %). Aber die Bar-Sim ueberschaetzt enge Stops
systematisch (Kipp ~0,3xATR) -- die Verzerrung geht zugunsten der Idee, das
Nein ist damit umso belastbarer.

Nichts am Live-System geaendert.

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

CLAUDE.md

@@ -5675,6 +5675,61 @@ Trades bei anderer Größe, was bei **manuellen** Trades eine starke Annahme ist
 und der Breaker wird auf **realisierte** Tagesverluste geprüft, während er live
 auch die offene Position kappt → die Sim **unterschätzt** ihn.
 
+### ⚠⚠ ENGER STOP FÜR DIE ERSTEN N BARS = KEINE ÄNDERUNG (`backtest_sl_staged.py`, 2026-08-13)
+
+User-Idee: „SL beim Eröffnen sehr eng, damit falsch laufende Trades früh
+geschlossen werden; läuft er richtig, den SL etappenweise nachziehen."
+⚠ Der **zweite** Teil ist längst gebaut (Phasen-Ratsche in `core/trailing.py`);
+neu und ungemessen war allein der **zeitlich befristete** enge Stop. Nicht zu
+verwechseln mit einem durchgehend engen Stop — der ist 2× gemessen
+(`backtest_sl_width.py`, `backtest_sl_basis.py`).
+✅ **Ohne Exit-Nachbau gerechnet:** Lauf A (`sl_atr=eng`) und Lauf B
+(`sl_atr=weit`) laufen auf DEMSELBEN Pfad; innerhalb der ersten N Bars ist der
+einzige Unterschied der SL-Abstand, jeder Nicht-SL-Ausstieg fällt identisch aus.
+Also exakt `R = R_A wenn A vor/bei Bar N aussteigt, sonst R_B`. Keine Näherung,
+keine fünfte Exit-Kopie.
+
+**80k M5, Squeeze-Entries, ruhende Order am Level, kanonischer Exit, Echtkosten,
+EIN Slot. Basis = durchgehend 3,4×ATR_M5 (= der Live-Stop 2,0×ATR_M15, aus 121
+echten Trades als Median gegengerechnet):**
+| Variante | H1 ØR / WR / worst | H2 ØR / WR / worst |
+|---|---|---|
+| **Basis (heute)** | −0,248 / 37,0 % / **−3,73** | −0,107 / 44,4 % / **−3,74** |
+| N=3, eng 0,5 | −0,263 / 23,3 % / −3,66 | −0,043 / 30,4 % / −0,96 |
+| **N=6, eng 0,5** | **−0,242** / 22,9 % / **−0,89** | **−0,045** / 30,1 % / **−0,96** |
+| N=12, eng 0,5 | −0,240 / 22,9 % / **−0,83** | −0,044 / 30,1 % / −0,96 |
+| N=6, eng 0,8 | −0,258 / 27,2 % / −3,15 | −0,066 / 35,0 % / −1,26 |
+
+⚠⚠ **DER ENTSCHEIDENDE BEFUND IST STRUKTURELL: die Staffelung hat gar keinen
+Raum.** Die Spalte „früh" zeigt, wie viele Trades schon in Phase 1 aussteigen —
+bei **N=12: 269 von 279 (96 %)**. Die mittlere Haltedauer liegt bei 12–18 min
+(2–4 M5-Bars); „die ersten 30–60 Minuten" sind also **der ganze Trade**. Wo die
+Staffelung überhaupt etwas anderes tut als ein dauerhaft enger Stop (N=3), ist
+sie in H1 bei **allen vier** eng-Werten schlechter. Wo sie „gewinnt" (N=6/12),
+ist sie **kein gestaffelter Stop mehr, sondern ein permanent enger** — und der
+war die Ausgangsfrage nicht.
+❌ **Regel verfehlt.** Zwei Kombinationen schlagen die Basis nominell in beiden
+Hälften (N=6/12 mit eng 0,5: Δ H1 **+0,007/+0,008**), aber (a) das liegt bei
+n≈279 **weit** unter einem Standardfehler (~0,055), (b) die **Nachbarn kippen**
+(N=3 gleiche Enge → −0,014; eng 0,8 → −0,009 in H1), (c) es ist der degenerierte
+Fall. Der ganze Ertrag steckt in H2 (+0,063), H1 ist ein Wash.
+⚠ Und: **alle** Werte sind negativ — verglichen werden Verlustgrade, kein Edge.
+
+✅ **WAS ECHT IST — der Tail.** Worst-Case **−3,73 → −0,83/−0,96**, also **Faktor
+4**. Genau das ist für unbeaufsichtigten Betrieb die relevante Größe. Bezahlt
+wird es mit der Trefferquote: **37,0 → 22,9 %** bzw. 44,4 → 30,1 %.
+⚠⚠ **Aber die Bar-Simulation ÜBERSCHÄTZT enge Stops systematisch** (Kipp-Punkt
+~0,3×ATR, `analyze_trail_resolution.py`) — die Verzerrung geht **zugunsten**
+dieser Idee. Ein ✅ wäre also abzuschlagen; das ❌ ist umso belastbarer.
+⚠ Nebenbefund: `durchgehend 2,0×ATR` schlägt die Basis in beiden Hälften
+(Δ +0,019/+0,029) und in H1 sogar die gestaffelten Varianten. Das widerspricht
+`backtest_sl_width.py` NICHT — dort war die Population die gegatete Wellen-Seite
+mit Bar-Close-Einstieg, hier sind es Level-Einstiege. Falls jemand die SL-Breite
+je anfasst, gehört diese Zelle nachgemessen, nicht die gestaffelte.
+⚠ **Gleiche Grenze wie beim S/R-Lauf:** die ABSOLUTEN Werte reproduzieren den
+dokumentierten Squeeze-Kontrollwert (+0,124/+0,292) nicht. Belastbar ist allein
+der **relative** Vergleich — alle Varianten laufen auf derselben Entry-Liste.
+
 ### ✅ S/R-AUTO-CLOSE WIEDER AN (User-Entscheidung 2026-08-11)
 
 Frage war: „sollten wir Trades bei einem S/R-Bounce automatisch schliessen?"

backtest_sl_staged.py

@@ -0,0 +1,178 @@
+#!/usr/bin/env python3
+"""ENGER Initial-Stop fuer die ersten N Bars, danach der normale — traegt das?
+
+USER-IDEE (2026-08-13): „beim Eroeffnen den SL sehr eng setzen, so dass Trades
+in die falsche Richtung schnell geschlossen werden. Laeuft der Trade richtig,
+den SL etappenweise nachziehen."
+
+⚠ Der zweite Teil ist bereits gebaut (die Phasen-Ratsche in `core/trailing.py`).
+Neu und ungemessen ist allein der erste: ein **zeitlich befristeter** enger Stop.
+Nicht zu verwechseln mit einem durchgehend engen Stop — DER ist zweimal gemessen
+(`backtest_sl_width.py` 04.08., `backtest_sl_basis.py` 05.08.) und schlaegt den
+Live-Stop in KEINER Variante beidhaelftig.
+
+⚠⚠ WIE ES OHNE EXIT-NACHBAU GEHT (die Kopiererei hat 4 divergierende Exit-
+Modelle erzeugt — das ist die dokumentierte Falle):
+  Lauf A = `simulate` mit sl_atr = ENG  ·  Lauf B = `simulate` mit sl_atr = WEIT
+  Beide laufen auf DEMSELBEN Kurspfad. Innerhalb der ersten N Bars ist der
+  EINZIGE Unterschied zwischen A und B der SL-Abstand; jeder Nicht-SL-Ausstieg
+  (TP, Time-Stop) faellt in beiden identisch aus. Also gilt exakt:
+        R_gestaffelt = R_A  wenn A vor/bei Bar N aussteigt, sonst R_B
+  Kein Nachbau, keine Naeherung.
+
+⚠⚠ DIE BINDENDE GRENZE — bitte vor der Interpretation lesen:
+  `analyze_trail_resolution.py` (05.08.) hat gemessen, dass eine BAR-Simulation
+  **enge Stops systematisch UEBERSCHAETZT** (Kipp-Punkt ~0,3xATR): das Modell
+  nimmt den Bar-Hochpunkt mit und steigt erst im naechsten Bar aus. Ein
+  POSITIVES Ergebnis fuer die enge Variante ist deshalb nach oben verzerrt und
+  muesste abgeschlagen werden. Ein NEGATIVES ist belastbar.
+  Dazu: die Exit-Slippage ist ABSOLUT (Median 0,017 $, Ø 0,234 $). In R gerechnet
+  trifft sie alle Varianten gleich stark — sie verschiebt das Niveau, nicht die
+  Rangfolge; die Spalte steht trotzdem dabei.
+
+Aufruf:  python backtest_sl_staged.py [bars]
+"""
+from __future__ import annotations
+
+import random
+import sys
+from dataclasses import replace
+
+import MetaTrader5 as mt5
+
+from core.exit_model import LIVE, simulate
+from core.squeeze_scan import atr_series, scan
+
+_SQ_N, _SQ_K, _SQ_MULT = 10, 0.1, 2.5
+_ATRMIN = 0.06          # ⚠ LIVE-Wert; der Modul-Default 0,12 waere eine andere Population
+_WARTE = 8
+# Live-Stop: 2,0xATR_M15 ~= 3,4xATR_M5 (Median ueber 121 echte Trades, 13.08.)
+_WEIT_LIVE = 3.4
+
+
+def entries(H, L, C, A, SP, point, lo, hi):
+    got = []
+    scan(H, L, C, A, SP, point, lo, hi, _SQ_MULT, box_n=_SQ_N, k=_SQ_K,
+         atr_min=_ATRMIN, exit_fn=lambda e, d, a, h, l, c, j: 0.0,
+         on_entry=lambda j, d, lvl, a, komp: (
+             got.append({"j": j, "d": d, "lvl": lvl, "atr": a}) if komp else None))
+    return got
+
+
+def lauf(ein, H, L, C, SP, eng, nbars, weit, slip=0.0):
+    """Sequentiell EIN Slot. `eng=None` → durchgehend `weit` (die Basis)."""
+    pW = replace(LIVE, sl_atr=weit)
+    pE = None if eng is None else replace(LIVE, sl_atr=eng)
+    Rs, n_frueh = [], 0
+    frei_ab, grenze = -1, len(C) - LIVE.max_hold - 2
+    for e in ein:
+        i, d, lvl, a = e["j"], e["d"], e["lvl"], e["atr"]
+        if i < frei_ab or i >= grenze or not a:
+            continue
+        fill = None
+        for k in range(i + 1, min(i + 1 + _WARTE, grenze)):
+            if L[k] <= lvl <= H[k]:
+                fill = k; break
+        if fill is None:
+            continue
+        RB, xbB = simulate(lvl, d, a, H, L, C, fill + 1, pW, ret_bar=True)
+        R, xb = RB, xbB
+        if pE is not None:
+            RA, xbA = simulate(lvl, d, a, H, L, C, fill + 1, pE, ret_bar=True)
+            if xbA <= fill + nbars:          # in Phase 1 ausgestiegen → A gilt
+                R, xb = RA, xbA
+                n_frueh += 1
+        Rs.append(R - SP[i] / a - (slip / a if slip else 0.0))
+        frei_ab = xb + 1
+    return Rs, n_frueh
+
+
+def ci(Rs, n=2500, seed=42):
+    if len(Rs) < 20:
+        return None, None
+    r = random.Random(seed); m = len(Rs)
+    b = sorted(sum(Rs[r.randrange(m)] for _ in range(m)) / m for _ in range(n))
+    return b[int(.025 * n)], b[int(.975 * n)]
+
+
+def kenn(Rs, frueh=0):
+    if not Rs:
+        return None
+    g = sum(x for x in Rs if x > 0); v = -sum(x for x in Rs if x < 0)
+    u, o = ci(Rs)
+    return {"n": len(Rs), "oer": sum(Rs) / len(Rs), "wr": 100 * sum(1 for x in Rs if x > 0) / len(Rs),
+            "pf": (g / v if v else float("inf")), "worst": min(Rs), "u": u, "o": o,
+            "fr": frueh}
+
+
+def zeig(name, k, basis=None):
+    if not k:
+        print(f"  {name:<32} —"); return
+    kib = "      —      " if k["u"] is None else f"[{k['u']:+.3f} … {k['o']:+.3f}]"
+    dl = "" if basis is None else f" Δ{k['oer']-basis['oer']:+.3f}"
+    print(f"  {name:<32} n={k['n']:>4} WR {k['wr']:>4.1f}% ØR {k['oer']:>+.3f} "
+          f"PF {k['pf']:>5.2f} worst {k['worst']:>+6.2f} früh {k['fr']:>4} {kib}{dl}")
+
+
+def main():
+    n = int(sys.argv[1]) if len(sys.argv) > 1 else 80000
+    mt5.initialize()
+    sym = next((c for c in ("SpotCrude", "USOIL", "WTI", "XTIUSD")
+                if mt5.symbol_info(c)), None)
+    bars = mt5.copy_rates_from_pos(sym, mt5.TIMEFRAME_M5, 0, n)
+    point = mt5.symbol_info(sym).point
+    mt5.shutdown()
+    if bars is None:
+        print("  keine Bars"); return 1
+    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)
+    mid = len(C) // 2
+    e1 = entries(H, L, C, A, SP, point, 60, mid)
+    e2 = entries(H, L, C, A, SP, point, mid, len(C))
+    print(f"\n  {sym} · {len(C)} M5-Bars · Squeeze-Entries H1 {len(e1)} · H2 {len(e2)}")
+    print(f"  Einstieg ruhend am Level · kanonischer Exit · Echtkosten · EIN Slot")
+    print(f"  Basis = durchgehend {_WEIT_LIVE}xATR_M5 (= der Live-Stop 2,0xATR_M15)")
+    print(f"  ⚠ Bar-Sim UEBERSCHAETZT enge Stops (Kipp ~0,3xATR) — ein ✅ waere "
+          f"nach oben verzerrt\n")
+
+    b1 = kenn(*lauf(e1, H, L, C, SP, None, 0, _WEIT_LIVE))
+    b2 = kenn(*lauf(e2, H, L, C, SP, None, 0, _WEIT_LIVE))
+    print("  ── BASIS (heute) ──────────────────────────────────────────────")
+    zeig("durchgehend 3,4xATR  H1", b1); zeig("durchgehend 3,4xATR  H2", b2)
+
+    print("\n  ── GESTAFFELT: eng fuer die ersten N Bars, dann 3,4xATR ───────")
+    besser = []
+    for nb in (3, 6, 12):
+        print(f"    ── N = {nb} Bars ({nb*5} min) ──")
+        for eng in (0.5, 0.8, 1.0, 1.5):
+            k1 = kenn(*lauf(e1, H, L, C, SP, eng, nb, _WEIT_LIVE))
+            k2 = kenn(*lauf(e2, H, L, C, SP, eng, nb, _WEIT_LIVE))
+            zeig(f"eng {eng:.1f}xATR  H1", k1, b1)
+            zeig(f"eng {eng:.1f}xATR  H2", k2, b2)
+            if k1 and k2 and k1["oer"] > b1["oer"] and k2["oer"] > b2["oer"]:
+                besser.append((nb, eng, k1["oer"] - b1["oer"], k2["oer"] - b2["oer"]))
+
+    print("\n  ── KONTROLLE: durchgehend eng (= der 2x gemessene Fall) ───────")
+    for eng in (0.8, 1.5, 2.0):
+        k1 = kenn(*lauf(e1, H, L, C, SP, None, 0, eng))
+        k2 = kenn(*lauf(e2, H, L, C, SP, None, 0, eng))
+        zeig(f"durchgehend {eng:.1f}xATR  H1", k1, b1)
+        zeig(f"durchgehend {eng:.1f}xATR  H2", k2, b2)
+
+    print("\n  ── URTEIL ─────────────────────────────────────────────────────")
+    if besser:
+        print(f"    {len(besser)} Kombination(en) schlagen die Basis in BEIDEN Haelften:")
+        for nb, eng, d1, d2 in besser:
+            print(f"      N={nb}, eng={eng}xATR   Δ H1 {d1:+.3f} · H2 {d2:+.3f}")
+        print("    ⚠ VOR einer Umsetzung: das Auflösungs-Artefakt verzerrt genau "
+              "diese Richtung\n      nach oben. Belastbar waere erst eine Tick-Simulation.")
+    else:
+        print("    KEINE Kombination schlaegt die Basis in beiden Haelften.")
+        print("    ⚠ Dieses Ergebnis ist belastbar: die Verzerrung der Bar-Sim geht "
+              "ZUGUNSTEN\n      der engen Stops — sie faellt trotzdem durch.")
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())