diff --git a/CLAUDE.md b/CLAUDE.md index 13e9fd5..cce3b6d 100644 --- a/CLAUDE.md +++ b/CLAUDE.md @@ -747,6 +747,46 @@ dort bereits nachvalidiert, ØR +0,305.) **Eine** Oberfläche: (+118 €/WR 56 %, `analyze_entries`-Auswertung 2026-07-30): **menschliche AUSWAHL** unter den Signalen (Kontext/Tageszeit/Marktlage), nicht „alle nehmen" — die Grundgesamtheit ALLER Signale ist der Verlierer. **14. verworfener Signal-Eingriff.** +- **Auto-Signal-Entry = TROTZDEM GEBAUT auf ausdrücklichen User-Wunsch (2026-07-30, + „probieren wir es trotzdem mal"), `[trading] auto_signal`, Default FALSE.** ⚠ **Der + Backtest direkt darüber sagt NEIN** (H1 durchgehend negativ) — der User hat das nach + vollständiger Information (inkl. Live-Dry-Run-Historie WR 29 %/PF 0,64) bewusst + entschieden. Gebaut mit den **gemessen BESTEN** Parametern, nicht mit Default-Raten: + `auto_signal_min_conf=75` (mit Nacht-Sperre H1 −0,053 = mildester Verlust, H2 +0,141 + = bestes Netto; ⚠ NICHT weil „mehr Konfidenz besser" — conf_pct ist unkalibriert, 75 + ist empirisch) und `auto_signal_skip_night=true` (verbessert JEDE Variante). + **Mechanik** (`engine._check_auto_signal` im `_pos_loop`, 1 s, NACH den Close-Checks): + eröffnet nur **FLAT**, nur bei `wave.signal()` LONG/SHORT mit `conf_pct ≥ min_conf`, + **1× je Signal-Episode** (Dedup `_signal_last_sig`, re-armt bei WARTEN/Flip — nicht + über den Preis wie beim Squeeze, weil das Signal keine Level-Marke hat); erbt die + Squeeze-Guards: Circuit-Breaker, Nacht-Sperre, S/R-Close-Cooldown, allgemeine + Wiedereinstiegs-Sperre. **Kein Nachkauf** bei gleichgerichteter Position, **kein + Drehen** einer Gegen-Position (unbelegt, wie Squeeze-Reverse). Log `🎯 AUTO-SIGNAL- + ENTRY` + Telegram, Setup-Tag `AUTOSIG_` (macht die Trades in der DB separierbar + → B4-Monitor). Snapshot `auto_signal`/`auto_signal_min_conf`/`signal_entry_count`, + Toggle `POST /api/autosignal` = Dashboard-Button **🎯 SIG** (bernstein statt blau, + weil gemessen nicht tragfähig; zeigt die Schwelle an), neustart-fest via + `runtime_state.json`. **B5-Pflicht:** Live-ØR/PF gegen die Backtest-Erwartung halten + (H2-Regime +0,14 vs H1-Regime −0,05) — driftet es weg, **zurückbauen** (`=false`). +- **15-Minuten-Regel (`[trading] adverse_15min_atr=0.5`, AKTIV, User-Wunsch 2026-07-30 + „wenn der Trade nach 15 Minuten gegen die Richtung läuft schließe ihn"):** steht ein + **vom BOT eröffneter** Trade 15 min nach Entry ≥ X×ATR_M5 gegen die Richtung → + schließen (`engine._check_adverse15`, `closed_by=adverse15`, Log ⏱ + Telegram). + ⚠ **Schwelle GEMESSEN kalibriert, NICHT die ursprüngliche Vorgabe** (`backtest_auto_ + signal.py`, 15-Min-Achse): „sobald im Minus" (0,0) ist die **SCHLECHTESTE** Variante + (WR bricht 39→31 %, Netto-ØR −0,067 vs +0,026 ohne Regel) — sie kappt Trades, die + sich erholt hätten. **0,5×ATR ist die beste Regel-Variante** (H1 −0,111→−0,079). + Netto über beide Hälften bringt die Regel ~nichts (+0,001 vs +0,026 **ohne**) → sie + ist ein **REGIME-Schutz** (hilft im schlechten Regime, kostet im guten), bewusst als + Sicherheit akzeptiert. **2. unabhängige Bestätigung** von `backtest_adverse_nosignal.py` + (dort fiel der Adverse-Exit bei JEDER Schwelle durch). Greift **NICHT bei manuellen + Trades** (`_bot_open_ticket`-Marker — dort bleibt die Diskretion beim User, gemessen + sein Vorteil) und nicht in der Startup-Schonfrist; **1× je Ticket** geprüft + (`_adverse15_done_ticket`) genau beim 15-min-Zeitpunkt. Snapshot `adverse15_atr`/ + `adverse15_count`. 0 = aus. Mit **18 synthetischen Szenarien getestet** (9 Entry: + Konf-Gate, Dedup, WARTEN-Re-Arm, Nachkauf, Gegen-Position, Cooldown, Toggle, + Nacht-Sperre · 9 Adverse: über/unter Schwelle, zu früh, im Plus, SHORT-Richtung, + manueller Trade, aus, 1×-je-Ticket, Startup-Grace) — alle korrekt. - **Auto-Squeeze-Entry = LIVE AUTONOM (User-Vorgabe 2026-07-16, `[trading] auto_squeeze=true`, Default FALSE):** der Bot eröffnet **selbständig eine echte Order**, sobald der **gemessen-validierte** Squeeze-Ausbruch feuert (`wave.squeeze. @@ -1331,7 +1371,7 @@ dort bereits nachvalidiert, ØR +0,305.) **Eine** Oberfläche: Signal → **Hinweis-Dialog „trotzdem eröffnen?"** (überschreibbar). CLOSE bei **negativem** P&L → Sicherheitsabfrage; im Plus/Breakeven direkt. Sonst keine Token-Dialoge (`require_token=false`). Audio braucht 1× Nutzer-Tap. -- Asset-Version aktuell **v=118** (in `web/index.html` hochzählen, siehe Workflows). +- Asset-Version aktuell **v=119** (in `web/index.html` hochzählen, siehe Workflows). Schriftgrößen 2026-07-24 global **+4px** (2× je +2px auf User-Wunsch; Body-Basis 14→18px). ⚠ Betrifft in `style.css` sowohl `font-size:Npx` (71×) ALS AUCH die `font: Npx/…`-**Shorthand** (3×: `.ms-chip`/`.ms-bos-lbl`/`.sqm-badge` — @@ -1341,7 +1381,7 @@ dort bereits nachvalidiert, ØR +0,305.) **Eine** Oberfläche: ## Web-API (server.py) `GET /api/snapshot` (inkl. `verdict`-Aggregat) `/api/health` `/api/logs` `/api/stats` `/api/news` `/api/bars?tf=&n=` (Charts, read-only) `/api/squeeze_monitor` (B4-Monitor, read-only, Engine-Cache 60 s) · `WS /ws` · -`POST /api/order|auto|trail|emergency|takeprofit|sltp|srclose|srclose_min|auth/check`. +`POST /api/order|auto|trail|emergency|takeprofit|sltp|srclose|srclose_min|autosqueeze|autosignal|auth/check`. `/api/sltp {sl,tp}` = manuelles SL/TP der offenen Position → `engine.set_sltp` → `trader.modify_sltp` (TRADE_ACTION_SLTP, prüft Seite/Mindestabstand) **und deaktiviert das Trailing** (`trail.deactivate` — sonst zöge es SL/TP beim nächsten Tick zurück, diff --git a/backtest_auto_signal.py b/backtest_auto_signal.py index 00b7ec2..e036960 100644 --- a/backtest_auto_signal.py +++ b/backtest_auto_signal.py @@ -50,6 +50,7 @@ _TIMESTOP = 24 # Time-Stop: 120 min = 24 M5-Bars in Phase „Init" _MAXH = 288 # Sim-Horizont (24 h auf M5) _ATRMIN = 0.06 # ATR-Floor wie live (_ATR_MIN in trailing.py) _NIGHT = (0, 1, 2, 3, 4, 5, 6, 7) # Berlin-Stunden = gemessene Kostenfalle +_ADV_BARS = 3 # 15-Min-Regel: 3 M5-Bars = 15 min nach Entry prüfen _HTF_N = 6 # 6 M5-Bars = 1 M30-Bar _H1_N = 12 # 12 M30-Bars … (H1 = 12 M5-Bars) @@ -110,9 +111,13 @@ def _htf_signs(H, L, C, step): return out -def _sim(entry, d, atr, H, L, C, j0): +def _sim(entry, d, atr, H, L, C, j0, adv15=None): """Live-Exit-Modell. Rückgabe R = Profit/ATR (brutto, ohne Kosten). - Phasen-Ratsche wie live: Time-Stop greift nur, solange nie Trail-Start erreicht.""" + Phasen-Ratsche wie live: Time-Stop greift nur, solange nie Trail-Start erreicht. + + `adv15` = 15-Minuten-Regel (User-Wunsch 2026-07-30): steht der Trade nach + _ADV_BARS (3 M5-Bars = 15 min) mehr als adv15×ATR im Minus → schließen. + None = aus. adv15=0.0 bedeutet „schließen wenn überhaupt im Minus".""" eff = entry - d * _SL_ATR * atr hw = entry trail_started = False @@ -125,6 +130,11 @@ def _sim(entry, d, atr, H, L, C, j0): exit_px = eff; break hw = max(hw, hi) if d > 0 else min(hw, lo) prof = (C[j] - entry) * d + # 15-Minuten-Regel: EINMALIGE Prüfung genau beim Bar _ADV_BARS nach Entry. + # Läuft der Trade dann gegen mich → raus (Einstieg war falsch). + if adv15 is not None and (j - j0) == _ADV_BARS - 1: + if prof <= -adv15 * atr: + exit_px = C[j]; break if prof >= _TRAIL_ON * atr: trail_started = True cand = hw - d * _TRAIL * atr @@ -149,7 +159,7 @@ def _rep(name, Rs, ref=None): return s / n -def scan(bars, H, L, C, SP, A, HTF, H1, EF, ES, w, lo_i, hi_i, min_conf, skip_night): +def scan(bars, H, L, C, SP, A, HTF, H1, EF, ES, w, lo_i, hi_i, min_conf, skip_night, adv15=None): """Sequentielle 1-Positions-Simulation: nimmt das ERSTE Signal, wenn flat.""" Rs = [] i = max(lo_i, _EMA_SLOW + 20) @@ -172,7 +182,7 @@ def scan(bars, H, L, C, SP, A, HTF, H1, EF, ES, w, lo_i, hi_i, min_conf, skip_ni d = 1 if sig == "LONG" else -1 entry = C[i] cost = (SP[i] if SP[i] > 0 else 0.0225) / atr - R = _sim(entry, d, atr, H, L, C, i + 1) - cost + R = _sim(entry, d, atr, H, L, C, i + 1, adv15) - cost Rs.append(R) # nach dem Trade weiterspringen: der Exit fand irgendwo in [i+1, i+_MAXH] # statt — konservativ mit dem Time-Stop-Fenster weiterrücken (kein Overlap) @@ -215,8 +225,17 @@ def main(): print("=" * 92) verdict = {} + # 15-Minuten-Regel (User-Wunsch): welche Schwelle ist die beste? Basis = + # Konf>=55 + Nacht-Sperre, damit nur die Regel selbst variiert. + ADV = [(None, "OHNE 15-Min-Regel (Basis)"), (0.0, "15min raus wenn im Minus"), + (0.15, "15min raus wenn < -0,15xATR"), (0.3, "15min raus wenn < -0,3xATR"), + (0.5, "15min raus wenn < -0,5xATR"), (0.8, "15min raus wenn < -0,8xATR")] for label, lo, hi in (("H1 (alt)", 0, mid), ("H2 (neu)", mid, N)): - print(f"\n{label}:") + print(f"\n{label} — 15-MIN-REGEL (Basis Konf>=55 + Nacht-Sperre):") + for a, alab in ADV: + Rs = scan(bars, H, L, C, SP, A, HTF, H1, EF, ES, w, lo, hi, 55, True, a) + verdict.setdefault(("adv", a), []).append(_rep(alab, Rs)) + print(f"\n{label} — Konfidenz-Achse (ohne 15-Min-Regel):") for mc in (55, 65, 70, 75): for night in (False, True): tag = f"Konf>={mc}" + (" · Nacht-Sperre" if night else "") @@ -227,7 +246,8 @@ def main(): print("\n" + "=" * 92) print(" URTEIL (trägt nur, wenn ØR in BEIDEN Hälften > 0 UND im Squeeze-Band):") any_ok = False - for (mc, night), vals in sorted(verdict.items()): + for key, vals in sorted(verdict.items(), key=lambda kv: str(kv[0])): + mc, night = key if len(vals) != 2 or any(v is None for v in vals): continue ok = all(v > 0 for v in vals) @@ -235,7 +255,10 @@ def main(): mark = "✅ TRÄGT" if (ok and band) else ("⚠ positiv, unter Squeeze-Band" if ok else "❌ fällt durch") if ok and band: any_ok = True - tag = f"Konf>={mc}" + (" +Nacht-Sperre" if night else "") + if mc == "adv": + tag = "15Min-Regel " + (str(night) if night is not None else "AUS") + else: + tag = f"Konf>={mc}" + (" +Nacht-Sperre" if night else "") print(f" {tag:<28} H1 ØR {vals[0]:+.3f} · H2 ØR {vals[1]:+.3f} {mark}") print("\n " + ("→ mindestens eine Variante trägt: Einbau vertretbar (klein starten, B4-Monitor)." if any_ok else diff --git a/core/config.py b/core/config.py index 87451ca..eb42950 100644 --- a/core/config.py +++ b/core/config.py @@ -357,6 +357,33 @@ DEFAULT_CONFIG = { # B4-Wochenmonitor prüfen, ob Nacht-Squeezes tragen. Code (`_SQUEEZE_NIGHT`, # `_squeeze_skip_night`) bleibt dormant/reaktivierbar (true = wieder an). "auto_squeeze_skip_night": "true", + # ── Autonomer Entry auf die EMPFEHLUNG (Wave-Signal) — User-Wunsch 2026-07-30 + # („probieren wir es trotzdem mal"). ⚠ GEMESSEN NICHT TRAGFÄHIG + # (`backtest_auto_signal.py`, 80k M5, 2 Halbjahre): H1 durchgehend NEGATIV + # (ØR −0,05…−0,18, PF 0,78–0,93), H2 positiv (+0,06…+0,15) = Regime-Kippen; + # deckt sich mit dem Live-Dry-Run von 2026-07-23 (WR 29 %/PF 0,64). Default AUS. + # Der User hat das nach vollständiger Information bewusst gewollt → Schalter + # existiert, aber mit den gemessen BESTEN Parametern und Live-Monitor (B4/B5: + # driftet es weg → zurückbauen). + "auto_signal": "false", + # Mindest-Konfidenz für den Auto-Signal-Entry. 75 = gemessen beste Kombi + # (mit Nacht-Sperre: H1 −0,053 = mildester Verlust, H2 +0,141). ⚠ conf_pct ist + # NICHT kalibriert (`analyze_verdict_calibration.py`) — höher ist nicht monoton + # besser, 75 ist empirisch, nicht „mehr ist mehr". + "auto_signal_min_conf": "75", + # Nacht-Sperre 0–7 Uhr Berlin für den Auto-Signal-Entry (gemessene Kostenfalle, + # verbessert JEDE Variante: H1 −0,157→−0,111 bzw. −0,127→−0,053). true = an. + "auto_signal_skip_night": "true", + # 15-Minuten-Regel (User-Wunsch 2026-07-30 „wenn der Trade nach 15 Minuten + # gegen die Richtung läuft schließe ihn"): steht ein BOT-eröffneter Trade + # 15 min nach Entry mehr als X×ATR im Minus → schließen (`closed_by=adverse15`). + # ⚠ Wert GEMESSEN kalibriert (`backtest_auto_signal.py`): „sobald im Minus" + # (=0,0) ist die SCHLECHTESTE Variante (WR bricht 39→31 %, ØR-Netto −0,067); + # **0,5 ist die beste Regel-Variante** (H1 −0,111→−0,079). Netto über beide + # Hälften bringt die Regel ~nichts (+0,001 vs +0,026 ohne) — sie ist ein + # REGIME-Schutz (hilft im schlechten, kostet im guten). 2. Bestätigung von + # `backtest_adverse_nosignal.py`. 0 = aus. + "adverse_15min_atr": "0.5", }, # (Der frühere `[setups]`-Block — Per-Setup-Toggles für den Dry-Run-Auto-Trader — # ist entfernt, 2026-07-23: verwaist seit dem Entfernen des Dry-Run-Traders, wurde diff --git a/core/engine.py b/core/engine.py index 8317798..7f8ee06 100644 --- a/core/engine.py +++ b/core/engine.py @@ -222,6 +222,26 @@ class TradingEngine: self._squeeze_last_sig = None # Dedup Entry (flat) self._squeeze_reverse_sig = None # Dedup Reverse-Close (Gegen-Trade) self._squeeze_entry_count = 0 + # ── Autonomer Entry auf die EMPFEHLUNG (User-Wunsch 2026-07-30) ─────────── + # ⚠ GEMESSEN NICHT tragfähig (H1 negativ, s. backtest_auto_signal.py) — auf + # ausdrücklichen User-Wunsch gebaut, Default AUS, mit den besten Parametern. + _t = self.cfg["trading"] + self._auto_signal = _t.get("auto_signal", "false").lower() == "true" + try: + self._auto_signal_min_conf = int(float(_t.get("auto_signal_min_conf", "75"))) + except (TypeError, ValueError): + self._auto_signal_min_conf = 75 + self._auto_signal_skip_night = _t.get("auto_signal_skip_night", "true").lower() == "true" + self._signal_last_sig = None # Dedup: (dir, Signal-Episode) 1× handeln + self._signal_entry_count = 0 + # 15-Minuten-Regel für BOT-eröffnete Trades (gemessen kalibriert: 0,5×ATR) + try: + self._adverse15_atr = max(0.0, float(_t.get("adverse_15min_atr", "0.5"))) + except (TypeError, ValueError): + self._adverse15_atr = 0.5 + self._bot_open_ticket = None # Ticket, das der Bot selbst eröffnet hat + self._adverse15_done_ticket = None # 15-Min-Prüfung je Ticket nur 1× + self._adverse15_count = 0 self._sr_close_ts = 0.0 # Zeit + Richtung des letzten S/R-Closes self._sr_close_dir = None # → Cooldown gegen Gleichrichtungs-Roundtrip self._open_pos_dir = None # Richtung der aktuell offenen Position (LONG/SHORT) @@ -505,8 +525,10 @@ class TradingEngine: self.trader.refresh(self.data.symbol) self._check_circuit_breaker() # Tagesverlust-Stopp (Überleben zuerst) self._check_auto_close() + self._check_adverse15() # 15-Min-Regel (nur Bot-Trades) self._check_sr_close() self._check_auto_squeeze() # autonomer Entry auf Squeeze-Ausbruch + self._check_auto_signal() # autonomer Entry auf die Empfehlung except Exception as e: log.error(f"_pos_loop: {e}", exc_info=True) self._sleep(_POS_S) @@ -994,6 +1016,150 @@ class TradingEngine: self._save_runtime_state() return self._auto_squeeze + def _check_auto_signal(self): + """Autonomer Entry auf die EMPFEHLUNG (Wave-Signal), nur wenn FLAT. + ⚠ GEMESSEN NICHT tragfähig (`backtest_auto_signal.py`: H1 ØR −0,05…−0,18 in + BEIDEN Konfidenz-Stufen, H2 positiv = Regime-Kippen; Live-Dry-Run 2026-07-23 + WR 29 %/PF 0,64). Auf ausdrücklichen User-Wunsch (2026-07-30) gebaut, Default + AUS, mit den gemessen besten Parametern (Konf≥75 + Nacht-Sperre) und dem + 15-Min-Adverse-Schutz. B4/B5: Live-Perf. gegen die Erwartung halten — driftet + es weg, zurückbauen. Dedup: 1× je Signal-Episode (re-armt bei WARTEN/Flip).""" + if not self._auto_signal: + return + if self._circuit_halted(): # Tagesverlust-Stopp → heute keine Auto-Trades + return + try: + sig_snap = self.wave.signal() or {} + d = sig_snap.get("signal") + if d not in ("LONG", "SHORT"): + self._signal_last_sig = None # WARTEN → Episode zu Ende, re-armen + return + conf = sig_snap.get("conf_pct") or 0 + if conf < self._auto_signal_min_conf: + return # zu schwach (Dedup NICHT setzen) + # Nacht-Sperre (gemessene Kostenfalle 0–7 Uhr Berlin) — kein Dedup-Marker, + # damit das Signal nach 08:00 noch feuern kann, falls es dann noch steht. + if self._auto_signal_skip_night and datetime.now(_BERLIN).hour in _SQUEEZE_NIGHT: + return + ps = self.trader.snapshot() + if ps.get("ticket"): + # Position offen: läuft sie in Signalrichtung, gilt die Episode als + # „schon dabei" (kein Nachkauf); Gegen-Position wird NICHT gedreht + # (unbelegt — dieselbe Begründung wie beim Squeeze-Reverse). + pos_dir = "LONG" if ps.get("order_type") == 0 else "SHORT" + if pos_dir == d: + self._signal_last_sig = d + return + if d == self._signal_last_sig: + return # diese Episode schon gehandelt + # Wiedereinstiegs-Sperren (wie beim Squeeze): nach S/R-Close bzw. nach + # JEDEM Close nicht sofort gleichgerichtet neu eröffnen. + now = time.time() + if (d == self._sr_close_dir and now - self._sr_close_ts < _SQUEEZE_SR_COOLDOWN_S): + return + if (d == self._pos_close_dir and now - self._pos_close_ts < _SQUEEZE_REENTRY_COOLDOWN_S): + return + self._signal_last_sig = d + if isinstance(self._last_rec, dict): + self._last_rec["setup"] = f"AUTOSIG_{d}" + log.info(f"🎯 AUTO-SIGNAL-ENTRY: {d} (Konfidenz {conf}% ≥ " + f"{self._auto_signal_min_conf}%) — eröffne selbständig") + err = (self.open_long(source="auto_signal") if d == "LONG" + else self.open_short(source="auto_signal")) + sym = self.data.symbol or "" + tg = self.cfg["telegram"] + tg_on = (tg.get("enabled", "false").lower() == "true" and tg.get("bot_token")) + if err: + log.error(f"Auto-Signal-Entry fehlgeschlagen: {err}") + self._signal_last_sig = None # Fehlschlag → nächster Tick erneut + if tg_on: + try: send_telegram(f"⚠ Auto-Signal-Entry FEHLGESCHLAGEN\n" + f"{sym} {d} (Konf {conf}%) — {err}", + tg["bot_token"], tg["chat_id"]) + except Exception as e: log.warning(f"Signal-Telegram (Fehler): {e}") + return + self._signal_entry_count += 1 + if tg_on: + try: send_telegram(f"🎯 Auto-Signal-Entry\n{sym} {d} selbständig " + f"eröffnet (Empfehlung, Konfidenz {conf}%).", + tg["bot_token"], tg["chat_id"]) + except Exception as e: log.warning(f"Signal-Telegram: {e}") + except Exception as e: + log.error(f"_check_auto_signal: {e}", exc_info=True) + + def set_auto_signal(self, on: bool) -> bool: + """Autonomen Signal-Entry an/aus (UI/Config). Rückgabe = neuer Zustand.""" + self._auto_signal = bool(on) + self._signal_last_sig = None + log.info(f"Auto-Signal-Entry {'AN' if self._auto_signal else 'AUS'} " + f"(Konf≥{self._auto_signal_min_conf}%" + f"{', Nacht-Sperre' if self._auto_signal_skip_night else ''})") + self._save_runtime_state() + return self._auto_signal + + def _check_adverse15(self): + """15-Minuten-Regel (User-Wunsch 2026-07-30): steht ein **vom Bot eröffneter** + Trade 15 min nach Entry mehr als `adverse_15min_atr`×ATR im Minus → schließen + (der Einstieg war falsch; gemessen: Gewinner nehmen Ø 0,19 $ Hitze, Verlierer + 0,41 $). ⚠ Schwelle GEMESSEN kalibriert = **0,5×ATR**; „sobald im Minus" wäre + die schlechteste Variante (WR 39→31 %). Netto bringt die Regel über beide + Halbjahre ~nichts (Regime-Schutz: hilft im schlechten, kostet im guten) — + bewusst als Sicherheit eingebaut. Greift NICHT bei manuellen Trades (dort + bleibt die Diskretion beim User) und nicht in der Startup-Schonfrist.""" + if self._adverse15_atr <= 0: + return + if self._in_startup_grace(): + return + ps = self.trader.snapshot() + ticket = ps.get("ticket") + if not ticket: + return + if ticket != self._bot_open_ticket: # nur Bot-eröffnete Trades + return + if ticket == self._adverse15_done_ticket: # je Ticket nur 1× prüfen + return + ot = ps.get("open_time") or 0 + if not ot: + return + age = time.time() - float(ot) + if age < 15 * 60: + return # noch keine 15 min alt + self._adverse15_done_ticket = ticket # Prüfzeitpunkt erreicht → 1× bewerten + # Verlust in ATR messen (M5-ATR wie im Backtest, Floor wie live) + try: + atr = float(((self.wave.snapshot() or {}).get("pb_feats") or {}).get("atr") or 0.0) + except Exception: + atr = 0.0 + atr = max(atr, 0.06) + entry = float(ps.get("entry_price") or 0.0) + cur = float(ps.get("cur_price") or 0.0) + if not entry or not cur: + return + d = 1 if ps.get("order_type") == 0 else -1 + adverse_atr = (entry - cur) * d / atr # >0 = läuft gegen die Position + if adverse_atr < self._adverse15_atr: + log.info(f"15-Min-Check (Pos {ticket}): {adverse_atr:+.2f}×ATR gegen die " + f"Position — unter Schwelle {self._adverse15_atr:.2f}, läuft weiter") + return + pnl = ps.get("pnl") + log.warning(f"⏱ 15-MIN-ADVERSE-CLOSE: Pos {ticket} läuft {adverse_atr:.2f}×ATR " + f"gegen die Richtung (≥ {self._adverse15_atr:.2f}) — P&L " + f"{(pnl if pnl is not None else 0):+.2f} → Einstieg war falsch, schließen") + err = self.trader.close(reason="adverse15") + tg = self.cfg["telegram"] + tg_on = (tg.get("enabled", "false").lower() == "true" and tg.get("bot_token")) + if err: + log.error(f"15-Min-Adverse-Close fehlgeschlagen: {err}") + self._adverse15_done_ticket = None # Fehlschlag → nächster Tick erneut + return + self._adverse15_count += 1 + if tg_on: + try: send_telegram(f"⏱ 15-Min-Regel\n{self.data.symbol or ''} nach 15 min " + f"{adverse_atr:.2f}×ATR gegen die Richtung (P&L " + f"{(pnl if pnl is not None else 0):+.2f}) → geschlossen.", + tg["bot_token"], tg["chat_id"]) + except Exception as e: log.warning(f"Adverse15-Telegram: {e}") + def set_sr_autoclose(self, on: bool) -> bool: """Automatischen S/R-Close an/aus (UI/Config). Rückgabe = neuer Zustand.""" self._auto_sr_close = bool(on) @@ -1306,6 +1472,8 @@ class TradingEngine: st = json.load(f) if "auto_squeeze" in st: self._auto_squeeze = bool(st["auto_squeeze"]) + if "auto_signal" in st: + self._auto_signal = bool(st["auto_signal"]) if "auto_sr_close" in st: self._auto_sr_close = bool(st["auto_sr_close"]) if "sr_close_min_gain" in st: @@ -1324,6 +1492,7 @@ class TradingEngine: tmp = self._runtime_state_path + ".tmp" with open(tmp, "w", encoding="utf-8") as f: json.dump({"auto_squeeze": self._auto_squeeze, + "auto_signal": self._auto_signal, "auto_sr_close": self._auto_sr_close, "sr_close_min_gain": self._sr_close_min_gain}, f) os.replace(tmp, self._runtime_state_path) @@ -1562,6 +1731,9 @@ class TradingEngine: if source == "auto_squeeze": log.info(f"[ORDER] {want} — autonom vom Auto-Squeeze eröffnet " f"(Signal={sig})") + elif source == "auto_signal": + log.info(f"[ORDER] {want} — autonom auf die Empfehlung eröffnet " + f"(Signal={sig})") elif sig != want: log.info(f"[ORDER] {want} ohne passende Empfehlung (Signal={sig}) " f"— vom User bestätigt, wird eröffnet") @@ -1569,6 +1741,14 @@ class TradingEngine: err = fn(sym) if err: return err + # Vom BOT eröffnete Trades markieren → nur für die greift die 15-Min-Regel + # (manuelle Trades bleiben in der Diskretion des Users, User-Vorgabe). + if source in ("auto_squeeze", "auto_signal"): + try: + self._bot_open_ticket = self.trader.snapshot().get("ticket") + self._adverse15_done_ticket = None + except Exception: + pass # Trailing automatisch aktivieren (wie _after_trade im Widget) if not self.trail.enabled: self.trail.set_setup(self._last_rec.get("setup")) @@ -2147,6 +2327,11 @@ class TradingEngine: "sr_close_count": self._sr_close_count, "auto_squeeze": self._auto_squeeze, "squeeze_entry_count": self._squeeze_entry_count, + "auto_signal": self._auto_signal, + "auto_signal_min_conf": self._auto_signal_min_conf, + "signal_entry_count": self._signal_entry_count, + "adverse15_atr": self._adverse15_atr, + "adverse15_count": self._adverse15_count, "last_trades": last_trades, } diff --git a/server.py b/server.py index af4f01d..ff53caa 100644 --- a/server.py +++ b/server.py @@ -337,6 +337,18 @@ async def toggle_autosqueeze(x_auth_token: str | None = Header(default=None)): return {"ok": True, "enabled": state} +@app.post("/api/autosignal") +async def toggle_autosignal(x_auth_token: str | None = Header(default=None)): + """Autonomen Entry auf die EMPFEHLUNG an/aus (User-Wunsch 2026-07-30). + ⚠ Gemessen NICHT tragfähig (backtest_auto_signal.py: H1 negativ) — bewusst + vom User gewollt, Default aus, mit 15-Min-Adverse-Schutz.""" + _require_auth(x_auth_token) + eng = app.state.engine + state = eng.set_auto_signal(not eng._auto_signal) + get_logger("server").info(f"[WEB] Auto-Signal-Entry {'AN' if state else 'AUS'}") + return {"ok": True, "enabled": state} + + @app.post("/api/srclose_min") async def srclose_min(payload: dict = Body(...), x_auth_token: str | None = Header(default=None)): diff --git a/web/app.js b/web/app.js index d51ae84..381ec58 100644 --- a/web/app.js +++ b/web/app.js @@ -543,6 +543,14 @@ function render(d) { shortBtn.disabled = hasPos; closeBtn.disabled = !hasPos; $("btn-squeeze").classList.toggle("on", !!d.auto_squeeze); + // Auto-Signal-Entry: bernstein-„warn" statt grün — er ist gemessen NICHT + // tragfähig (H1 negativ) und läuft nur auf ausdrücklichen Wunsch. + const asBtn = $("btn-autosig"); + if (asBtn) { + asBtn.classList.toggle("warn-on", !!d.auto_signal); + asBtn.textContent = d.auto_signal + ? `🎯 SIG ${d.auto_signal_min_conf || 75}%` : "🎯 SIG"; + } $("btn-trail").classList.toggle("on", !!(d.trail || {}).enabled); // Empfehlungs-Blinken: LONG/SHORT-Button blinkt, sobald die Welle eine @@ -961,6 +969,7 @@ _updateMuteBtn(); // Toggle-Buttons (AUTO/TRAIL/S-R-Close) — ohne Bestätigung $("btn-squeeze").onclick = () => toggle("api/autosqueeze", "Auto-Squeeze (autonom!)"); +$("btn-autosig").onclick = () => toggle("api/autosignal", "Auto-Signal-Entry (autonom!)"); $("btn-trail").onclick = () => toggle("api/trail", "Trailing"); $("srclose-btn").onclick = () => toggle("api/srclose", "Auto-S/R-Close"); diff --git a/web/index.html b/web/index.html index 67b3442..f321f09 100644 --- a/web/index.html +++ b/web/index.html @@ -6,7 +6,7 @@ Oil · MT5 - + @@ -209,6 +209,7 @@ + @@ -228,6 +229,6 @@ - + diff --git a/web/style.css b/web/style.css index 6b02b08..1650773 100644 --- a/web/style.css +++ b/web/style.css @@ -274,6 +274,9 @@ main{padding-bottom:74px} /* Platz für die fixe Leiste */ .btn.close {background:#2d2000; color:var(--accent)} .btn.tog {flex:.8; font-size:16px} .btn.tog.on{background:#1f6feb; color:#fff} +/* Auto-Signal-Entry: bernstein statt blau — gemessen NICHT tragfähig (H1 negativ), + läuft nur auf ausdrücklichen User-Wunsch → Farbe signalisiert „Achtung, aktiv". */ +.btn.tog.warn-on{background:#9e6a03; color:#fff} .btn:disabled{opacity:.32; cursor:default} /* Empfehlungs-Blinken der LONG/SHORT-Buttons */