Apply all bug fixes from BUGFIX_AUFTRAG.md, implement dashboard enhancements (trade history, equity curve, stats, events), fix screener double calculation, update AI provider to Ollama with Nemotron-3-Super, and include all changes from previous session

ai/entry_prompt.py

@@ -42,7 +42,7 @@ def build_entry_prompt(
     ohlcv_data: list,
     indicators: dict,
     screener_reason: str,
-    btc_context: dict
+    btc_context: dict,
 ) -> tuple[str, str]:
     """
     Baut den Entry-Prompt.
@@ -82,19 +82,19 @@ TECHNISCHE DATEN (Letzte 10 Kerzen, OHLCV):
 {ohlcv_table}
 
 INDIKATOREN:
-- RSI (14): {indicators.get('rsi', 'N/A')}
-- MACD: Line={indicators.get('macd', {}).get('line', 'N/A')}, Signal={indicators.get('macd', {}).get('signal', 'N/A')}, Histogram={indicators.get('macd', {}).get('histogram', 'N/A')}
-- EMA: 9={indicators.get('ema9', 'N/A')}, 21={indicators.get('ema21', 'N/A')}, 50={indicators.get('ema50', 'N/A')}
-- Volume Ratio (vs. 20-Candle-Avg): {indicators.get('volume_ratio_20', 'N/A')}x
-- Volume Ratio (vs. 5-Candle-Avg): {indicators.get('volume_ratio_5', 'N/A')}x
-- ATR (14, 15min): {indicators.get('atr', 'N/A')} USD
+- RSI (14): {indicators.get("rsi", "N/A")}
+- MACD: Line={indicators.get("macd", {}).get("line", "N/A")}, Signal={indicators.get("macd", {}).get("signal", "N/A")}, Histogram={indicators.get("macd", {}).get("histogram", "N/A")}
+- EMA: 9={indicators.get("ema9", "N/A")}, 21={indicators.get("ema21", "N/A")}, 50={indicators.get("ema50", "N/A")}
+- Volume Ratio (vs. 20-Candle-Avg): {indicators.get("volume_ratio_20", "N/A")}x
+- Volume Ratio (vs. 5-Candle-Avg): {indicators.get("volume_ratio_5", "N/A")}x
+- ATR (14, 15min): {indicators.get("atr", "N/A")} USD
 
 SCREENER-BEGRÜNDUNG:
 {screener_reason}
 
 MARKTKONTEXT:
-- BTC 4h Change: {btc_context.get('btc_4h_pct', 'N/A')}%
-- BTC über EMA 50 (4h): {btc_context.get('btc_above_ema50', 'N/A')}
+- BTC 4h Change: {btc_context.get("btc_4h_pct", "N/A")}%
+- BTC über EMA 50 (4h): {btc_context.get("btc_above_ema50", "N/A")}
 
 Antworte AUSSCHLIESSLICH in diesem JSON-Format, kein Text davor/danach:
 {{
@@ -123,7 +123,7 @@ def get_entry_decision(
     ohlcv_data: list,
     indicators: dict,
     screener_reason: str,
-    btc_context: dict
+    btc_context: dict,
 ) -> dict:
     """
     Ruft KI für Entry-Entscheidung auf.
@@ -142,8 +142,7 @@ def get_entry_decision(
         Bei Fehler: {"decision": "SKIP", "reason": "..."}
     """
     system_prompt, user_prompt = build_entry_prompt(
-        symbol, price, position_size_usd, ohlcv_data,
-        indicators, screener_reason, btc_context
+        symbol, price, position_size_usd, ohlcv_data, indicators, screener_reason, btc_context
     )
 
     try:
@@ -155,23 +154,12 @@ def get_entry_decision(
         result["decision"] = result.get("decision", "SKIP").upper()
         result["confidence"] = int(result.get("confidence", 0))
 
-        logger.info(
-            f"KI Entry {symbol}: {result['decision']} "
-            f"(Confidence: {result['confidence']})"
-        )
+        logger.info(f"KI Entry {symbol}: {result['decision']} (Confidence: {result['confidence']})")
         return result
 
     except AIProviderError as e:
         logger.error(f"KI Entry Fehler für {symbol}: {e}")
-        return {
-            "decision": "SKIP",
-            "confidence": 0,
-            "reason": f"KI_ERROR: {e}"
-        }
+        return {"decision": "SKIP", "confidence": 0, "reason": f"KI_ERROR: {e}"}
     except ValueError as e:
         logger.error(f"KI Entry JSON-Fehler für {symbol}: {e}")
-        return {
-            "decision": "SKIP",
-            "confidence": 0,
-            "reason": f"JSON_PARSE_ERROR: {e}"
-        }
+        return {"decision": "SKIP", "confidence": 0, "reason": f"JSON_PARSE_ERROR: {e}"}

ai/exit_prompt.py

@@ -44,7 +44,7 @@ def build_exit_prompt(
     ohlcv_data: list,
     indicators: dict,
     sell_reason: str,
-    btc_context: dict
+    btc_context: dict,
 ) -> tuple[str, str]:
     """
     Baut den Exit-Prompt.
@@ -85,18 +85,18 @@ TECHNISCHE DATEN (Letzte 10 Kerzen, 15min):
 {ohlcv_table}
 
 INDIKATOREN:
-- RSI (14): {indicators.get('rsi', 'N/A')}
-- MACD: Line={indicators.get('macd', {}).get('line', 'N/A')}, Signal={indicators.get('macd', {}).get('signal', 'N/A')}, Histogram={indicators.get('macd', {}).get('histogram', 'N/A')}
-- EMA 9: {indicators.get('ema9', 'N/A')} | Preis vs. EMA 9: {'über' if current_price > indicators.get('ema9', 0) else 'unter'}
-- Volume Ratio (vs. 20-Candle-Avg): {indicators.get('volume_ratio_20', 'N/A')}x
-- ATR (14, 15min): {indicators.get('atr', 'N/A')} USD
+- RSI (14): {indicators.get("rsi", "N/A")}
+- MACD: Line={indicators.get("macd", {}).get("line", "N/A")}, Signal={indicators.get("macd", {}).get("signal", "N/A")}, Histogram={indicators.get("macd", {}).get("histogram", "N/A")}
+- EMA 9: {indicators.get("ema9", "N/A")} | Preis vs. EMA 9: {"über" if current_price > indicators.get("ema9", 0) else "unter"}
+- Volume Ratio (vs. 20-Candle-Avg): {indicators.get("volume_ratio_20", "N/A")}x
+- ATR (14, 15min): {indicators.get("atr", "N/A")} USD
 
 SCREENER-WARNUNG:
 {sell_reason}
 
 MARKTKONTEXT:
-- BTC 15min Change: {btc_context.get('btc_15min_pct', 'N/A')}%
-- BTC 1h Change: {btc_context.get('btc_1h_pct', 'N/A')}%
+- BTC 15min Change: {btc_context.get("btc_15min_pct", "N/A")}%
+- BTC 1h Change: {btc_context.get("btc_1h_pct", "N/A")}%
 
 Antworte AUSSCHLIESSLICH in diesem JSON-Format, kein Text davor/danach:
 {{
@@ -128,7 +128,7 @@ def get_exit_decision(
     ohlcv_data: list,
     indicators: dict,
     sell_reason: str,
-    btc_context: dict
+    btc_context: dict,
 ) -> dict:
     """
     Ruft KI für Exit-Entscheidung auf.
@@ -138,10 +138,19 @@ def get_exit_decision(
         Bei Fehler: {"decision": "HOLD", "reason": "..."}
     """
     system_prompt, user_prompt = build_exit_prompt(
-        symbol, entry_price, current_price, pnl_percent,
-        duration_minutes, initial_stop, current_trailing_stop,
-        tp1_hit, hold_count, ohlcv_data, indicators,
-        sell_reason, btc_context
+        symbol,
+        entry_price,
+        current_price,
+        pnl_percent,
+        duration_minutes,
+        initial_stop,
+        current_trailing_stop,
+        tp1_hit,
+        hold_count,
+        ohlcv_data,
+        indicators,
+        sell_reason,
+        btc_context,
     )
 
     try:
@@ -153,23 +162,12 @@ def get_exit_decision(
         result["decision"] = result.get("decision", "HOLD").upper()
         result["confidence"] = int(result.get("confidence", 0))
 
-        logger.info(
-            f"KI Exit {symbol}: {result['decision']} "
-            f"(Confidence: {result['confidence']})"
-        )
+        logger.info(f"KI Exit {symbol}: {result['decision']} (Confidence: {result['confidence']})")
         return result
 
     except AIProviderError as e:
         logger.error(f"KI Exit Fehler für {symbol}: {e}")
-        return {
-            "decision": "HOLD",
-            "confidence": 0,
-            "reason": f"KI_ERROR: {e}"
-        }
+        return {"decision": "HOLD", "confidence": 0, "reason": f"KI_ERROR: {e}"}
     except ValueError as e:
         logger.error(f"KI Exit JSON-Fehler für {symbol}: {e}")
-        return {
-            "decision": "HOLD",
-            "confidence": 0,
-            "reason": f"JSON_PARSE_ERROR: {e}"
-        }
+        return {"decision": "HOLD", "confidence": 0, "reason": f"JSON_PARSE_ERROR: {e}"}

ai/provider.py

@@ -150,8 +150,7 @@ def get_provider() -> AIProvider:
         return OllamaProvider()
     else:
         raise AIProviderError(
-            f"Unbekannter AI_PROVIDER: '{provider_type}'. "
-            f"Erlaubt: 'anthropic', 'openai', 'ollama'"
+            f"Unbekannter AI_PROVIDER: '{provider_type}'. Erlaubt: 'anthropic', 'openai', 'ollama'"
         )
 
 

ai/validator.py

@@ -45,7 +45,16 @@ def validate_entry_decision(decision: dict, current_price: float) -> tuple[bool,
     # Risk-Reward Check
     sl_distance = entry_price - stop_loss
     tp1 = decision.get("take_profit_1", 0)
+    tp2 = decision.get("take_profit_2", 0)
+
+    # TP1 muss > entry sein
     tp1_distance = tp1 - entry_price
+    if tp1 <= 0 or tp1_distance <= 0:
+        return False, "INVALID_TAKE_PROFIT_1"
+
+    # TP2 muss > TP1 sein (falls vorhanden)
+    if tp2 is not None and tp2 > 0 and tp2 <= tp1:
+        return False, f"TP2_MUST_BE_ABOVE_TP1: TP2={tp2} <= TP1={tp1}"
 
     if sl_distance <= 0:
         return False, "INVALID_SL_DISTANCE"

app.py

@@ -84,6 +84,18 @@ async def scan():
     except Exception as e:
         logger.error(f"CRITICAL: Scan cycle failed: {e}")
         logger.error(traceback.format_exc())
+        # Selbst im Fehlerfall scan_log schreiben, damit es im Dashboard sichtbar wird
+        if db_configured():
+            log_scan(
+                {
+                    "market_gate_passed": False,
+                    "market_gate_reason": "CRASH",
+                    "errors": [str(e)],
+                    "candidates_found": 0,
+                    "trades_opened": 0,
+                    "trades_closed": 0,
+                }
+            )
         return JSONResponse(content={"status": "error", "message": str(e)}, status_code=500)
 
 
@@ -109,35 +121,80 @@ async def _run_scan_cycle() -> dict:
         logger.warning(f"BTC-Preis konnte nicht geladen werden: {e}")
         btc_price = 0
 
-    # ── Stage 0: Market Gate ──
+    # ── Stage 0: Market Gate (nur für neue Entrys relevant) ──
     gate_result = market_gate_check()
     result["market_gate_passed"] = gate_result.passed
     result["market_gate_reason"] = gate_result.reason
 
-    if not gate_result.passed:
-        logger.info(f"Market Gate BLOCKED: {gate_result.reason}")
-        if db_configured():
-            log_scan(result)
-        return result
+    # ── Stage 4 (vorab): Exit-Check für OFFENE Positionen (unabhängig vom Gate!)
+    # ── WICHTIG: Wird VOR neuen Entries gemacht, falls Market Gate nicht passed
+    trades_closed = 0
+    open_positions = get_all_open_positions()
 
-    # ── Stage 1: Universe + Screener ──
-    try:
-        universe = get_top100_universe()
-    except Exception as e:
-        result["errors"].append(f"Universe Fehler: {e}")
-        if db_configured():
-            log_scan(result)
-        return result
+    for position in open_positions:
+        try:
+            current_price = get_current_price(position["symbol"])
+
+            # BTC-Kontext für Exit-KI aus DB berechnen
+            btc_15min_price = get_btc_price_minutes_ago(15) if db_configured() else None
+            btc_1h_price = get_btc_price_minutes_ago(60) if db_configured() else None
+            btc_context = {
+                "btc_15min_pct": round(((btc_price - btc_15min_price) / btc_15min_price) * 100, 2)
+                if btc_15min_price and btc_price > 0
+                else 0,
+                "btc_1h_pct": round(((btc_price - btc_1h_price) / btc_1h_price) * 100, 2)
+                if btc_1h_price and btc_price > 0
+                else 0,
+            }
+
+            exit_decision = process_exit(position, current_price, btc_context)
 
-    # Blacklist aus DB laden (Coins nach Stop-Loss-Cooldown ausschließen)
+            if exit_decision == "SELL":
+                exit_reason = position.get("exit_reason", "AutoExit")
+                success = close_position(
+                    trade_id=position["id"],
+                    exit_price=current_price,
+                    exit_reason=exit_reason,
+                    symbol=position["symbol"],
+                )
+                if success:
+                    trades_closed += 1
+
+            elif exit_decision == "PARTIAL_SELL":
+                exit_reason = position.get("exit_reason", "TP1_Partial_Exit")
+                success = close_partial_position(
+                    trade_id=position["id"],
+                    exit_price=current_price,
+                    exit_reason=exit_reason,
+                    symbol=position["symbol"],
+                )
+                if success:
+                    trades_closed += 1
+
+        except Exception as e:
+            logger.error(f"Exit-Check Fehler für {position['symbol']}: {e}")
+
+    result["trades_closed"] = trades_closed
+
+    # ── Stage 1: Universe + Screener (nur wenn Gate passed) ──
+    universe = []
     blacklist = set()
-    if db_configured():
-        blacklist = {coin.symbol for coin in universe if is_blacklisted(coin.symbol)}
-        if blacklist:
-            logger.info(f"Blacklist aktiv: {blacklist}")
+    candidates = []
+
+    if gate_result.passed:
+        try:
+            universe = get_top100_universe()
+        except Exception as e:
+            result["errors"].append(f"Universe Fehler: {e}")
+
+        # Blacklist aus DB laden (Coins nach Stop-Loss-Cooldown ausschließen)
+        if db_configured():
+            blacklist = {coin.symbol for coin in universe if is_blacklisted(coin.symbol)}
+            if blacklist:
+                logger.info(f"Blacklist aktiv: {blacklist}")
 
-    candidates = run_screener(universe, blacklist=blacklist)
-    result["candidates_found"] = len(candidates)
+        candidates = run_screener(universe, blacklist=blacklist)
+        result["candidates_found"] = len(candidates)
 
     # ── Stage 2+3: KI Entry + Validation ──
     trades_opened = 0
@@ -168,6 +225,7 @@ async def _run_scan_cycle() -> dict:
             )
         except Exception as e:
             logger.error(f"KI Entry Fehler für {candidate.symbol}: {e}")
+            result["errors"].append(f"KI Entry Fehler {candidate.symbol}: {e}")
             continue
 
         # Validation
@@ -189,13 +247,28 @@ async def _run_scan_cycle() -> dict:
             continue
 
         # Position öffnen
+        stop_loss = decision.get("stop_loss", 0)
+        take_profit_1 = decision.get("take_profit_1", 0)
+        take_profit_2 = decision.get("take_profit_2", 0)
+
+        # Validierung: Alle TP/SL Werte müssen vorhanden und > 0 sein
+        if stop_loss <= 0 or take_profit_1 <= 0:
+            logger.warning(
+                f"Entry übersprungen für {candidate.symbol}: "
+                f"stop_loss={stop_loss}, take_profit_1={take_profit_1}, take_profit_2={take_profit_2}"
+            )
+            result["errors"].append(
+                f"{candidate.symbol}: Ungültige TP/SL Werte (SL={stop_loss}, TP1={take_profit_1}, TP2={take_profit_2})"
+            )
+            continue
+
         trade_id = open_position(
             symbol=candidate.symbol,
             entry_price=decision.get("entry_price", candidate.price),
             position_size_usd=decision.get("position_size_usd", position_size),
-            stop_loss=decision["stop_loss"],
-            take_profit_1=decision["take_profit_1"],
-            take_profit_2=decision["take_profit_2"],
+            stop_loss=stop_loss,
+            take_profit_1=take_profit_1,
+            take_profit_2=take_profit_2,
             entry_atr=candidate.atr,
             risk_reward_ratio=decision.get("risk_reward_ratio", 0),
             learning_tags=decision.get("learning_tags", []),
@@ -206,55 +279,6 @@ async def _run_scan_cycle() -> dict:
 
     result["trades_opened"] = trades_opened
 
-    # ── Exit-Check für offene Positionen ──
-    trades_closed = 0
-    open_positions = get_all_open_positions()
-
-    for position in open_positions:
-        try:
-            current_price = get_current_price(position["symbol"])
-
-            # BTC-Kontext für Exit-KI aus DB berechnen
-            btc_15min_price = get_btc_price_minutes_ago(15) if db_configured() else None
-            btc_1h_price = get_btc_price_minutes_ago(60) if db_configured() else None
-            btc_context = {
-                "btc_15min_pct": round(((btc_price - btc_15min_price) / btc_15min_price) * 100, 2)
-                if btc_15min_price and btc_price > 0
-                else 0,
-                "btc_1h_pct": round(((btc_price - btc_1h_price) / btc_1h_price) * 100, 2)
-                if btc_1h_price and btc_price > 0
-                else 0,
-            }
-
-            exit_decision = process_exit(position, current_price, btc_context)
-
-            if exit_decision == "SELL":
-                exit_reason = position.get("exit_reason", "AutoExit")
-                success = close_position(
-                    trade_id=position["id"],
-                    exit_price=current_price,
-                    exit_reason=exit_reason,
-                    symbol=position["symbol"],
-                )
-                if success:
-                    trades_closed += 1
-
-            elif exit_decision == "PARTIAL_SELL":
-                exit_reason = position.get("exit_reason", "TP1_Partial_Exit")
-                success = close_partial_position(
-                    trade_id=position["id"],
-                    exit_price=current_price,
-                    exit_reason=exit_reason,
-                    symbol=position["symbol"],
-                )
-                if success:
-                    trades_closed += 1
-
-        except Exception as e:
-            logger.error(f"Exit-Check Fehler für {position['symbol']}: {e}")
-
-    result["trades_closed"] = trades_closed
-
     # ── Scan loggen ──
     if db_configured():
         log_scan(result)

config.py

@@ -57,8 +57,8 @@ COOLDOWN_AFTER_SL_HOURS = 4
 # ATR-Multiplikatoren
 # ──────────────────────────────────────────────
 ATR_STOP_LOSS_MULT = 1.5
-ATR_TP1_MULT = 3.0       # R:R 1:2
-ATR_TP2_MULT = 5.25      # R:R 1:3.5
+ATR_TP1_MULT = 3.0  # R:R 1:2
+ATR_TP2_MULT = 5.25  # R:R 1:3.5
 ATR_TRAILING_ACTIVATION_MULT = 1.5
 ATR_TRAILING_DISTANCE_MULT = 1.5
 
@@ -82,8 +82,8 @@ MAX_HOLD_COUNT = 3
 # ──────────────────────────────────────────────
 BTC_FILTER_4H_DROP = -2.5
 BTC_FILTER_4H_PUMP = 4.0
-BTC_CRASH_FAST_PCT = -1.5      # 15min Change
-BTC_CRASH_CONFIRM_PCT = -2.5   # 1h Change
+BTC_CRASH_FAST_PCT = -1.5  # 15min Change
+BTC_CRASH_CONFIRM_PCT = -2.5  # 1h Change
 
 
 # ──────────────────────────────────────────────
@@ -98,7 +98,7 @@ TIME_STOP_B_HOURS = 2
 # KI Provider (austauschbar)
 # ──────────────────────────────────────────────
 AI_PROVIDER = os.getenv("AI_PROVIDER", "anthropic")  # "anthropic", "openai", "ollama"
-AI_MODEL_NAME = os.getenv("AI_MODEL_NAME", "")      # Leer = Provider-Default
+AI_MODEL_NAME = os.getenv("AI_MODEL_NAME", "")  # Leer = Provider-Default
 
 
 # ──────────────────────────────────────────────

dashboard/dashboard.py

@@ -36,17 +36,21 @@ st.subheader("📈 Offene Positionen")
 positions = get_open_positions()
 if positions:
     df = pd.DataFrame(positions)
-    df = df[
-        [
+    # Fixed: DB column is "entry_learning_tags", not "learning_tags"
+    available_cols = [
+        c
+        for c in [
             "symbol",
             "entry_price",
             "position_size_usd",
             "stop_loss",
             "take_profit_1",
             "opened_at",
-            "learning_tags",
+            "entry_learning_tags",
         ]
+        if c in df.columns
     ]
+    df = df[available_cols]
     st.dataframe(df, use_container_width=True)
 else:
     info = st.info("Keine offenen Positionen")

data/universe.py

@@ -39,8 +39,23 @@ def _is_stablecoin(symbol: str) -> bool:
 
 
 def _is_leveraged_token(symbol: str) -> bool:
-    """Prüft ob Symbol ein Leveraged Token ist."""
-    return any(pattern in symbol.upper() for pattern in config.LEVERAGED_TOKEN_PATTERNS)
+    """
+    Prüft ob Symbol ein Leveraged Token ist.
+
+    Leveraged Tokens wie BTCUP, ETH3L, BTCBULL haben das Muster als Suffix
+    im BASE-Asset, nicht als Teilstring. JUPUSDT enthält "UP" als Teilstring
+    aber ist KEIN Leveraged Token.
+    """
+    # Extrahiere Base-Asset (ohne Quote)
+    base = symbol
+    for quote in ("USDT", "USDC", "USD", "DAI", "TUSD", "BUSD", "GUSD"):
+        if symbol.endswith(quote):
+            base = symbol[: -len(quote)]
+            break
+
+    # Prüfe ob BASE-Asset mit einem Pattern endet (Suffix, nicht Teilstring)
+    base_upper = base.upper()
+    return any(base_upper.endswith(pattern) for pattern in config.LEVERAGED_TOKEN_PATTERNS)
 
 
 def _is_usdt_pair(symbol: str) -> bool:

db/supabase_client.py

@@ -282,19 +282,25 @@ def get_btc_price_minutes_ago(minutes: int = 15) -> float | None:
 
     try:
         client = _get_client()
+        # Fixed: Limit anpassen, um auch 60min vergangenheit abzudecken
+        # Wir brauchen mindestens minutes/5 + 2 Einträge (mit Puffer)
+        required_entries = minutes // 5 + 2
+        # Max 50 Einträge für größere Zeitspannen
+        limit = max(10, min(required_entries, 50))
+
         result = (
             client.table("btc_price_log")
             .select("price")
             .order("logged_at", desc=True)
-            .limit(10)
+            .limit(limit)
             .execute()
         )
 
         if not result.data:
             return None
 
-        # Nimm den ältesten Eintrag der letzten ~20 Minuten
-        # (da wir nur alle 5 Min loggen, ist der 3. Eintrag ca. 15 Min alt)
+        # Nimm den Eintrag für die angeforderte Zeitspanne
+        # (da wir nur alle 5 Min loggen, ist index = minutes//5 der richtige Eintrag)
         index = min(minutes // 5, len(result.data) - 1)
         return result.data[index]["price"]
 
@@ -416,3 +422,106 @@ def get_portfolio_value() -> float:
     except Exception as e:
         logger.error(f"Fehler bei Portfolio-Berechnung: {e}")
         return config.PORTFOLIO_VALUE_USD
+
+
+def get_all_trades(limit: int = 50) -> list[dict]:
+    """
+    Gibt alle Trades zurück (offen + geschlossen).
+
+    Args:
+        limit: Anzahl der Einträge
+
+    Returns:
+        Liste von Trade-Dicts sortiert nach opened_at absteigend
+    """
+    if not is_configured():
+        return []
+
+    try:
+        client = _get_client()
+        result = (
+            client.table("trades").select("*").order("opened_at", desc=True).limit(limit).execute()
+        )
+        return result.data
+
+    except Exception as e:
+        logger.error(f"Fehler beim Laden aller Trades: {e}")
+        return []
+
+
+def get_closed_trades(limit: int = 50) -> list[dict]:
+    """
+    Gibt alle geschlossenen Trades zurück.
+
+    Args:
+        limit: Anzahl der Einträge
+
+    Returns:
+        Liste von Trade-Dicts sortiert nach closed_at aufsteigend
+    """
+    if not is_configured():
+        return []
+
+    try:
+        client = _get_client()
+        result = (
+            client.table("trades")
+            .select("*")
+            .eq("status", "closed")
+            .order("closed_at", asc=True)
+            .limit(limit)
+            .execute()
+        )
+        return result.data
+
+    except Exception as e:
+        logger.error(f"Fehler beim Laden geschlossener Trades: {e}")
+        return []
+
+
+def get_trade_stats() -> dict:
+    """
+    Berechnet Zusammenfassungskennzahlen.
+
+    Returns:
+        Dict mit open_count, closed_count, win_rate, total_pnl
+    """
+    if not is_configured():
+        return {
+            "open_count": 0,
+            "closed_count": 0,
+            "win_rate": 0.0,
+            "total_pnl": 0.0,
+        }
+
+    try:
+        client = _get_client()
+
+        # Offene Positionen zählen
+        open_result = client.table("trades").select("id").eq("status", "open").execute()
+        open_count = len(open_result.data)
+
+        # Geschlossene Trades abrufen
+        closed_result = client.table("trades").select("pnl_usd").eq("status", "closed").execute()
+        closed_count = len(closed_result.data)
+
+        pnls = [p.get("pnl_usd", 0) or 0 for p in closed_result.data]
+        winning = sum(1 for pnl in pnls if pnl > 0)
+        win_rate = (winning / closed_count * 100) if closed_count > 0 else 0.0
+        total_pnl = sum(pnls)
+
+        return {
+            "open_count": open_count,
+            "closed_count": closed_count,
+            "win_rate": round(win_rate, 1),
+            "total_pnl": round(total_pnl, 2),
+        }
+
+    except Exception as e:
+        logger.error(f"Fehler bei Trade-Statistiken: {e}")
+        return {
+            "open_count": 0,
+            "closed_count": 0,
+            "win_rate": 0.0,
+            "total_pnl": 0.0,
+        }

positions/manager.py

@@ -65,7 +65,7 @@ def open_position(
         "take_profit_2": take_profit_2,
         "entry_atr": entry_atr,
         "risk_reward_ratio": risk_reward_ratio,
-        "learning_tags": learning_tags or [],
+        "entry_learning_tags": learning_tags or [],  # Fixed: DB column name
     }
 
     trade_id = log_trade(position_data)
@@ -111,9 +111,12 @@ def close_position(
     if position:
         entry_price = position["entry_price"]
         size = position["position_size_usd"]
+        # PnL aus TP1-Partial (wird in realized_pnl_usd gespeichert)
+        realized_pnl_usd = position.get("realized_pnl_usd", 0) or 0
         if entry_price > 0:
+            # Gesamtes PnL = Realisiert (TP1) + nicht-realisiert (Rest)
             pnl_pct = ((exit_price - entry_price) / entry_price) * 100
-            pnl_usd = size * (pnl_pct / 100)
+            pnl_usd = size * (pnl_pct / 100) + realized_pnl_usd
 
     success = close_trade(
         trade_id=trade_id,
@@ -130,8 +133,8 @@ def close_position(
             f"(P&L: {pnl_pct:.2f}%, ${pnl_usd:.2f}) — Grund: {exit_reason}"
         )
 
-        # Bei Stop Loss → Blacklist
-        if ("Stop" in exit_reason or "Stop_Loss" in exit_reason) and symbol:
+        # Nur bei Hard Stop Loss → Blacklist (nicht bei Trailing/Gewinn-Exits!)
+        if exit_reason == "Hit_Hard_Stop" and symbol:
             add_to_blacklist(symbol, exit_reason)
 
     return success
@@ -165,6 +168,9 @@ def close_partial_position(
     size = position["position_size_usd"]
     pnl_pct = ((exit_price - entry_price) / entry_price) * 100 if entry_price > 0 else 0
     pnl_usd = size * (pnl_pct / 100)
+    realized_pnl_usd = position.get("realized_pnl_usd", 0) or 0
+    # Addiere PnL der verkauften Hälfte zu realized_pnl_usd (nicht überschreiben!)
+    realized_pnl_usd += pnl_usd / 2
 
     # 50% verkaufen → position_size halbieren
     new_size = size / 2
@@ -174,8 +180,7 @@ def close_partial_position(
         "position_size_usd": new_size,
         "stop_loss": entry_price * 1.001,  # Break-Even + 0.1%
         "tp1_hit": True,
-        "pnl_pct": round(pnl_pct, 2),
-        "pnl_usd": round(pnl_usd / 2, 2),
+        "realized_pnl_usd": round(realized_pnl_usd, 2),
     }
 
     success = update_position(trade_id, updates)
@@ -183,7 +188,7 @@ def close_partial_position(
     if success:
         logger.info(
             f"Partial Exit (50%): {symbol} @ ${exit_price:.4f} "
-            f"(P&L: {pnl_pct:.2f}%) — Stop auf Break-Even"
+            f"(Realisiertes PnL: ${realized_pnl_usd:.2f}) — Stop auf Break-Even"
         )
 
     return success

schema.sql

@@ -16,6 +16,7 @@ CREATE TABLE IF NOT EXISTS trades (
     entry_atr FLOAT NOT NULL DEFAULT 0,
     pnl_pct FLOAT,
     pnl_usd FLOAT,
+    realized_pnl_usd FLOAT DEFAULT 0,
     risk_reward_ratio FLOAT,
     entry_learning_tags TEXT[],
     exit_learning_tags TEXT[],

screener/screener.py

@@ -15,7 +15,6 @@ from data.binance import get_klines, BinanceAPIError
 from screener.indicators import (
     calculate_rsi,
     calculate_ema,
-    calculate_macd,
     calculate_macd_series,
     calculate_atr,
     calculate_volume_ratio,
@@ -67,19 +66,20 @@ def _check_fomo(closes: list[float]) -> bool:
     return change_pct >= config.FOMO_PRICE_RISE_PCT
 
 
-def calculate_score(symbol: str, klines: list) -> tuple[int, list[str]]:
+def calculate_score(symbol: str, klines: list) -> tuple[int, list[str], dict]:
     """
-    Berechnet den Score für einen Coin.
+    Berechnet den Score für einen Coin und liefert auch die verwendeten Indikatoren.
 
     Args:
         symbol: Coin Symbol (z.B. "ETHUSDT")
         klines: OHLCV-Kerzen von Binance
 
     Returns:
-        Tuple von (score, reasons_liste)
+        Tuple von (score, reasons_liste, indicators_dict)
     """
     score = 0
     reasons = []
+    indicators = {}
 
     ohlcv = _extract_ohlcv(klines)
     closes = ohlcv["closes"]
@@ -87,11 +87,11 @@ def calculate_score(symbol: str, klines: list) -> tuple[int, list[str]]:
 
     # K.O.: Zu wenig Daten
     if len(closes) < 50:
-        return 0, ["TOO_LITTLE_DATA"]
+        return 0, ["TOO_LITTLE_DATA"], {}
 
     # FOMO-Schutz
     if _check_fomo(closes):
-        return 0, ["FOMO_PROTECTION"]
+        return 0, ["FOMO_PROTECTION"], {}
 
     # ── Volume Spike (3 Punkte) ──
     vol_ratio_20 = calculate_volume_ratio(volumes, 20)
@@ -100,6 +100,8 @@ def calculate_score(symbol: str, klines: list) -> tuple[int, list[str]]:
     if vol_ratio_20 > config.VOLUME_SPIKE_THRESHOLD and vol_ratio_5 > config.VOLUME_SPIKE_THRESHOLD:
         score += 3
         reasons.append(f"Volume_Spike_{vol_ratio_20:.1f}x")
+        indicators["volume_ratio_20"] = vol_ratio_20
+        indicators["volume_ratio_5"] = vol_ratio_5
 
     # ── MACD Crossover (2 Punkte) ──
     macd_series = calculate_macd_series(closes)
@@ -109,12 +111,19 @@ def calculate_score(symbol: str, klines: list) -> tuple[int, list[str]]:
         if prev["line"] <= prev["signal"] and curr["line"] > curr["signal"]:
             score += 2
             reasons.append("MACD_Cross")
+            indicators["macd"] = {
+                "line": curr["line"],
+                "signal": curr["signal"],
+                "histogram": curr["histogram"],
+            }
+            indicators["macd_series"] = macd_series[-2:]  # keep last two for reference
 
     # ── RSI Momentum (1 Punkte) ──
     rsi = calculate_rsi(closes)
     if 50 <= rsi <= 65:
         score += 1
         reasons.append(f"RSI_Momentum_{rsi:.0f}")
+        indicators["rsi"] = rsi
 
     # ── RSI Reversal (1 Punkte) ──
     # RSI war < 30, in letzten 2 Kerzen nach oben durchbrochen
@@ -127,6 +136,7 @@ def calculate_score(symbol: str, klines: list) -> tuple[int, list[str]]:
         if len(rsi_values) >= 3 and rsi_values[-3] < 30 and rsi_values[-1] > 30:
             score += 1
             reasons.append(f"RSI_Reversal_{rsi:.0f}")
+            indicators["rsi_reversal"] = True
 
     # ── EMA Alignment (1 Punkte) ──
     ema9 = calculate_ema(closes, 9)
@@ -136,6 +146,9 @@ def calculate_score(symbol: str, klines: list) -> tuple[int, list[str]]:
     if ema9 > ema21 > ema50:
         score += 1
         reasons.append("EMA_Alignment")
+        indicators["ema9"] = ema9
+        indicators["ema21"] = ema21
+        indicators["ema50"] = ema50
 
     # ── Momentum (1 Punkte) ──
     if len(closes) >= config.MOMENTUM_LOOKBACK_CANDLES:
@@ -146,8 +159,17 @@ def calculate_score(symbol: str, klines: list) -> tuple[int, list[str]]:
             if config.MOMENTUM_MIN_PCT <= momentum_pct <= config.MOMENTUM_MAX_PCT:
                 score += 1
                 reasons.append(f"Momentum_{momentum_pct:.1f}%")
+                indicators["momentum_pct"] = momentum_pct
 
-    return score, reasons
+    # ATR (always needed for position sizing)
+    atr = calculate_atr(
+        [float(k[2]) for k in klines],
+        [float(k[3]) for k in klines],
+        [float(k[4]) for k in klines],
+    )
+    indicators["atr"] = atr
+
+    return score, reasons, indicators
 
 
 def run_screener(universe: list, blacklist: set[str] | None = None) -> list[Candidate]:
@@ -179,30 +201,16 @@ def run_screener(universe: list, blacklist: set[str] | None = None) -> list[Cand
             logger.debug(f"Screener: {symbol} übersprungen — {e}")
             continue
 
-        score, reasons = calculate_score(symbol, klines)
+        score, reasons, indicators = calculate_score(symbol, klines)
 
         if score >= config.SCREENER_PASS_SCORE:
-            atr = calculate_atr(
-                [float(k[2]) for k in klines],
-                [float(k[3]) for k in klines],
-                [float(k[4]) for k in klines],
-            )
-
             candidate = Candidate(
                 symbol=symbol,
                 score=score,
                 reasons=reasons,
                 price=coin.price,
-                atr=atr,
-                indicators={
-                    "rsi": calculate_rsi([float(k[4]) for k in klines]),
-                    "macd": calculate_macd([float(k[4]) for k in klines]),
-                    "ema9": calculate_ema([float(k[4]) for k in klines], 9),
-                    "ema21": calculate_ema([float(k[4]) for k in klines], 21),
-                    "ema50": calculate_ema([float(k[4]) for k in klines], 50),
-                    "volume_ratio_20": calculate_volume_ratio([float(k[5]) for k in klines], 20),
-                    "volume_ratio_5": calculate_volume_ratio([float(k[5]) for k in klines], 5),
-                },
+                atr=indicators.get("atr", 0.0),
+                indicators=indicators,
             )
             candidates.append(candidate)
             logger.info(f"Screener: {symbol} → Score {score} | {', '.join(reasons)}")

tests/test_indicators.py

@@ -79,9 +79,9 @@ class TestRSI:
         rsi_7 = calculate_rsi(closes, period=7)
         rsi_21 = calculate_rsi(closes, period=21)
         # Kürzere Periode reagiert stärker → weiter vom Neutralpunkt weg
-        assert abs(rsi_7 - 50.0) >= abs(
-            rsi_21 - 50.0
-        ), f"Kürzere Periode sollte sensitiver sein: rsi_7={rsi_7}, rsi_21={rsi_21}"
+        assert abs(rsi_7 - 50.0) >= abs(rsi_21 - 50.0), (
+            f"Kürzere Periode sollte sensitiver sein: rsi_7={rsi_7}, rsi_21={rsi_21}"
+        )
 
 
 # ──────────────────────────────────────────────

tests/test_validator.py

@@ -41,9 +41,9 @@ class TestEntryValidation:
                 "position_size_usd": 50.0,
             }
             is_valid, reason = validate_entry_decision(decision, CURRENT_PRICE)
-            assert (
-                is_valid is False
-            ), f"Entscheidung '{decision_type}' hätte abgelehnt werden sollen"
+            assert is_valid is False, (
+                f"Entscheidung '{decision_type}' hätte abgelehnt werden sollen"
+            )
             assert "NOT_BUY" in reason
 
     def test_low_confidence_rejected(self, valid_entry_decision):
@@ -184,9 +184,9 @@ class TestExitValidation:
             decision=decision, current_price=current_price, current_trailing_stop=None, hold_count=0
         )
         # Nach Validation muss der ungültige Stop gelöscht sein
-        assert (
-            decision["new_trailing_stop_usd"] is None
-        ), "Trailing Stop über Preis hätte gelöscht werden müssen"
+        assert decision["new_trailing_stop_usd"] is None, (
+            "Trailing Stop über Preis hätte gelöscht werden müssen"
+        )
 
     def test_trailing_stop_lower_than_current_ignored(self):
         """Neuer Trailing Stop darf nicht schlechter als aktueller sein."""
@@ -200,9 +200,9 @@ class TestExitValidation:
             current_trailing_stop=current_trailing,
             hold_count=0,
         )
-        assert (
-            decision["new_trailing_stop_usd"] is None
-        ), "Schlechterer Trailing Stop hätte ignoriert werden müssen"
+        assert decision["new_trailing_stop_usd"] is None, (
+            "Schlechterer Trailing Stop hätte ignoriert werden müssen"
+        )
 
     def test_valid_improved_trailing_stop_kept(self):
         """Verbesserter Trailing Stop (höher, unter Preis) soll behalten werden."""
@@ -214,9 +214,9 @@ class TestExitValidation:
         validate_exit_decision(
             decision=decision, current_price=2000.0, current_trailing_stop=1950.0, hold_count=0
         )
-        assert (
-            decision["new_trailing_stop_usd"] == 1980.0
-        ), "Gültiger Trailing Stop-Verbesserung hätte behalten werden sollen"
+        assert decision["new_trailing_stop_usd"] == 1980.0, (
+            "Gültiger Trailing Stop-Verbesserung hätte behalten werden sollen"
+        )
 
 
 # ──────────────────────────────────────────────