From 437ab56598cbad70a3465c9b4752bc4141404c1a Mon Sep 17 00:00:00 2001 From: Axel Hocks Date: Thu, 20 Aug 2026 19:36:30 +0200 Subject: [PATCH] Trailing tat nichts - beide Gruende waren richtig, nur unsichtbar (v=203) MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit User: "trailing scheint nicht zu funktionieren wenn man es einmal manuell aktiviert hat und dann wieder einschaltet." AM LOG UND AM ZUSTAND NACHGEPRUEFT - es lief die ganze Zeit: 19:30:52 Manuelle SL/TP-Aenderung erkannt (SL 87.297) -> Trailing abgeschaltet 19:31:01 AKTIVIERT ATR=0.5689 (M30) mult=1.0x danach phase=Init, HW 87.39, enabled=true, trail_mult=1.0 `toggle()` setzt alles sauber zurueck (High-Water, Phase, _last_sl/_last_tp, TF und Mult werden neu eingefroren). Es war KEIN Defekt. WARUM ES TROTZDEM NICHTS TAT - zwei Gruende, beide korrekt: (a) Phase "Init": der Trail springt erst ab `trail_start` an, und der steht seit HEUTE auf 1,3xATR (war 0,3). Der Gewinn lag bei 0,13xATR - also Faktor 10 zu frueh. Wer die alte Einstellung gewohnt ist, erwartet den Trail zehnmal frueher als er kommt. (b) Er lockert einen Stop NIE. Nach der Handeingabe lag der SL bei 87.300, der Trail haette HW-1,0xATR = 86.821 gewollt - deutlich schlechter. Also zu Recht keine Aenderung. Um 87.300 zu schlagen, braeuchte es HW >= 87.869. DER EIGENTLICHE MANGEL WAR DIE SICHTBARKEIT: die Trailing-KARTE ist seit dem 22.07. ausgeblendet (User-Vorgabe). Damit gab es KEINE Stelle mehr, an der man Phase, High-Water oder den gewollten Stop sehen konnte - "es tut nichts" und "es wartet zu Recht" sahen identisch aus. GEBAUT: `engine._trail_info()` -> Snapshot `trail_info` -> Zeile `#trail-note` in der Meldungen-Karte. Live: "Trailing wartet - springt ab 1.3xATR Gewinn an (jetzt 0.38x, also ab Kurs 88.054)." Drei weitere Zustaende: "Trailing AUS - nur der Broker-SL schuetzt", "laeuft, zieht aber NICHT nach: sein Stop waere X, der gesetzte Y ist enger", und "laeuft - zieht den Stop auf X nach". ⚠ Nur ZUSAMMENGESETZT aus dem, was der Snapshot ohnehin enthaelt - kein zweiter Rechenweg (der Konsens-Pfeil-Fehler). ⚠⚠ BEINAHE-FEHLER beim Bau, gefangen: der Block landete in `renderKontext(snap)`, mein Code las aber `d.trail_info`. Ein ReferenceError haette den GESAMTEN Render abgebrochen (Dashboard friert auf Altwerten ein) - genau die Klasse, die am 01.08. schon einmal zugeschlagen hat. `node --check` sieht das NICHT. Gefunden, weil ich die umgebende Funktion nachgelesen habe, und danach mit einem Minimal-DOM gegengeprueft (snap / leer / null - alle drei laufen durch). NEBENBEI: der Kommentar an `_TRAIL_START_ATR` sagte weiterhin "0,3", der Wert ist 1,3. Genau diese Zahl macht den Unterschied, um den es hier geht. Co-Authored-By: Claude Opus 5 --- core/engine.py | 55 ++++++++++++++++++++++++++++++++++++++++++++++++ core/trailing.py | 6 +++++- web/app.js | 13 +++++++++++- web/index.html | 10 ++++++--- 4 files changed, 79 insertions(+), 5 deletions(-) diff --git a/core/engine.py b/core/engine.py index 903340f..a0e568b 100644 --- a/core/engine.py +++ b/core/engine.py @@ -3033,6 +3033,49 @@ class TradingEngine: fehler.append(f"{name}: {ex}") return "; ".join(fehler) if fehler else None + def _trail_info(self, position: dict, market: dict) -> str | None: + """Ein Satz: was macht das Trailing gerade, und warum nicht mehr? + + ⚠ Rein zusammengesetzt aus dem, was der Snapshot ohnehin enthaelt — + kein zweiter Rechenweg (der Konsens-Pfeil-Fehler). Fail-safe: bei + fehlenden Werten None, die Zeile bleibt dann leer. + """ + try: + if not (position or {}).get("ticket"): + return None + t = self.trail.snapshot() or {} + if not t.get("enabled"): + return "Trailing AUS — nur der Broker-SL schützt." + atr = float(t.get("atr") or 0.0) + hw = t.get("high_water") + if not atr or hw is None: + return "Trailing an — wartet auf den ersten Tick." + mult = float(t.get("trail_mult") or 1.0) + lng = position.get("order_type") == 0 + ent = float(position.get("entry_price") or 0.0) + cur = float((market or {}).get("bid" if lng else "ask") or 0.0) + if not ent or not cur: + return None + gewinn = (cur - ent) if lng else (ent - cur) + r = gewinn / atr + ziel = float(hw) - mult * atr if lng else float(hw) + mult * atr + sl = float(position.get("sl") or 0.0) + if t.get("phase") == "Init": + # Was muesste der Kurs erreichen, damit der Trail ueberhaupt anspringt? + from core.exit_model import LIVE as _EX + start = _EX.trail_start + noetig = ent + start * atr if lng else ent - start * atr + return (f"Trailing wartet — springt ab {start:.1f}×ATR Gewinn an " + f"(jetzt {r:.2f}×, also ab Kurs {noetig:.3f}).") + # Trail laeuft: zieht er nach, oder haelt der (engere) Stop? + if sl and ((ziel <= sl) if lng else (ziel >= sl)): + return (f"Trailing läuft, zieht aber NICHT nach: sein Stop wäre " + f"{ziel:.3f}, der gesetzte {sl:.3f} ist enger. Es lockert " + f"einen Stop nie.") + return f"Trailing läuft — zieht den Stop auf {ziel:.3f} nach." + except Exception: + return None + def toggle_trail(self) -> bool: """TRAIL-Knopf — trifft den Slot, der tatsaechlich eine Position haelt. @@ -4915,6 +4958,18 @@ class TradingEngine: "wht_pct": self._wht_pct, "takeprofit": self._takeprofit, "takeprofit_remember": self._takeprofit_remember, + # ⚠⚠ WARUM tut das Trailing gerade nichts? (User-Frage 2026-08-20: + # "trailing scheint nicht zu funktionieren, wenn man es einmal + # manuell aktiviert hat und dann wieder einschaltet") + # Es TAT nichts, und beide Gruende waren richtig — nur unsichtbar: + # (a) Phase "Init": der Trail startet erst ab `trail_start`, und + # der steht seit dem 20.08. auf 1,3xATR (war 0,3). Wer die + # alte Einstellung gewohnt ist, erwartet ihn 10x frueher. + # (b) Er ZIEHT NIE ZURUECK. Nach einer Handeingabe liegt der SL + # oft enger als HW-mult*ATR — dann bleibt er zu Recht stehen. + # Die Trailing-Karte ist seit dem 22.07. ausgeblendet, es gab also + # KEINE Stelle, an der das sichtbar wurde. Reine Anzeige. + "trail_info": self._trail_info(position, market), "trail": self.trail.snapshot(), "wave_signal": wave_signal, "wave": wave_snap, diff --git a/core/trailing.py b/core/trailing.py index 58fd526..5d3ea95 100644 --- a/core/trailing.py +++ b/core/trailing.py @@ -63,7 +63,11 @@ _ATR_MIN = 0.06 # Untergrenze ATR. 0,12→0,06 gesenkt (gemessen, # jemand dort, ändern sich Live-Verhalten UND Messung gemeinsam. from core.exit_model import LIVE as _EXIT -_TRAIL_START_ATR = _EXIT.trail_start # 0,3 — Phase 1→2: ab hier HW-Trailing +_TRAIL_START_ATR = _EXIT.trail_start # 1,3 (war 0,3 bis 2026-08-20) — Phase 1→2: + # ab hier HW-Trailing. ⚠ Der Wert lebt in + # `exit_model.LIVE`, hier steht nur der + # Verweis — die Zahl im Kommentar war + # nach der Aenderung stale. _BREAKEVEN_ATR = _EXIT.be # 1,3 — Entry-Floor (Breakeven). 0,6 war zu # eng: 21 % der Trades wurden auf Breakeven gescratcht # (backtest_exit.py be). 1,3 = gemessenes Plateau-Optimum: diff --git a/web/app.js b/web/app.js index f15c8a9..21e0bc3 100644 --- a/web/app.js +++ b/web/app.js @@ -710,6 +710,17 @@ function renderKontext(snap) { // ── HL-Kontext (Funding / OI / Premium) — reine Anzeige ─────────────── // ⚠ Gemessen ohne Prognosewert (analyze_hl_funding.py): entüberlappt hält // kein Bucket die 2-Stichproben-Regel. Schreibt in die MELDUNGEN-Karte. + // Trailing-Zustand im Klartext (User-Frage 2026-08-20: "trailing scheint + // nicht zu funktionieren, wenn man es einmal manuell aktiviert hat und + // dann wieder einschaltet"). Der Text kommt FERTIG aus dem Backend + // (`trail_info`) — ihn hier nachzubauen waere die Divergenz-Falle, die im + // Projekt dreimal zugeschlagen hat. + const trN = $streng("trail-note"); + if (trN) { + const trTxt = snap && snap.trail_info; + trN.textContent = trTxt || ""; + trN.classList.toggle("hidden", !trTxt); + } const hlEl = $("hl-note"); const h = snap && snap.hl_ctx; if (h && h.premium != null) { @@ -2386,7 +2397,7 @@ async function closeSlot(slot, label, pnl) { // und der Browser zeigte Altes. Statt das jedes Mal von Hand zu diagnostizieren, // sagt die Seite es jetzt selbst. // ⚠ Bewusst SICHTBAR statt nur Konsole: die Konsole sieht am Handy niemand. -const _JS_V = "202"; +const _JS_V = "203"; { const htmlV = document.body && document.body.dataset ? document.body.dataset.htmlV : null; diff --git a/web/index.html b/web/index.html index 24eea01..a7210f1 100644 --- a/web/index.html +++ b/web/index.html @@ -12,9 +12,9 @@ ⚠ LOKAL eingebunden, kein CDN: die PWA laeuft ueber WireGuard und muss offline funktionieren. --> - + - +