feat: trade lifecycle management — close, archive, target/stop alerts

- DB: 9 new columns on trade_entry_prices (status, closed_at, close_reason,
  close_note, pnl_realized, close_price, target_pct, stop_loss_pct, signal_threshold)
  via ALTER TABLE migration; close_trade(), get_closed_trades(),
  update_trade_exit_params() helpers; exit_defaults config key
- Backend: PATCH /trades/{id}/close, PATCH /trades/{id}/exit-params,
  GET/PUT /exit-defaults, GET /closed-trades with win-rate/avg-PnL stats;
  trade-mtm now computes alert_type (target_reached|stop_loss) per trade
- Journal: new "Fermés" tab with closed trades table + stats banner (win rate,
  avg PnL, total PnL, best trade); open trades show Cible/Stop progress bar +
  🎯/🛑 alert badges + 1-click close modal (price, reason, note)
- Config: new "Paramètres de sortie" panel — target_pct, stop_loss_pct,
  signal_reversal_mode, signal_reversal_threshold with live sliders

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>

backend/routers/journal.py

@@ -1,7 +1,14 @@
-from fastapi import APIRouter
-from typing import Any, Dict, List
+from fastapi import APIRouter, HTTPException
+from typing import Any, Dict, List, Optional
 import math
-from services.database import get_macro_regime_history, get_geo_alert_history, get_trade_entry_prices, reset_journal_history, _fetch_live_prices, _trade_maturity
+from pydantic import BaseModel
+from services.database import (
+    get_macro_regime_history, get_geo_alert_history, get_trade_entry_prices,
+    get_closed_trades, close_trade, update_trade_exit_params,
+    get_trade_entry_by_id, get_config, set_config, reset_journal_history,
+    _fetch_live_prices, _trade_maturity,
+)
+import json
 
 
 def _sanitize(obj: Any) -> Any:
@@ -69,6 +76,17 @@ def trade_mtm(days: int = 30):
         horizon = e.get("horizon_days") or 90
         maturity = _trade_maturity(days_held or 0, horizon)
 
+        defaults = _get_exit_defaults()
+        target = e.get("target_pct") if e.get("target_pct") is not None else defaults.get("target_pct", 30.0)
+        stop = e.get("stop_loss_pct") if e.get("stop_loss_pct") is not None else defaults.get("stop_loss_pct", -50.0)
+
+        alert_type = None
+        if pnl_pct is not None:
+            if pnl_pct >= target:
+                alert_type = "target_reached"
+            elif pnl_pct <= stop:
+                alert_type = "stop_loss"
+
         result.append({
             **e,
             "current_price": current_price,
@@ -76,11 +94,121 @@ def trade_mtm(days: int = 30):
             "days_held": days_held,
             "direction": "bearish" if _is_bearish(e.get("strategy", "")) else "bullish",
             "maturity": maturity,
+            "alert_type": alert_type,
+            "target_pct": target,
+            "stop_loss_pct": stop,
         })
 
     return _sanitize({"trades": result, "days": days, "tickers_fetched": len(current_prices)})
 
 
+def _get_exit_defaults() -> Dict[str, Any]:
+    raw = get_config("exit_defaults")
+    if raw:
+        try:
+            return json.loads(raw)
+        except Exception:
+            pass
+    return {"target_pct": 30.0, "stop_loss_pct": -50.0,
+            "signal_reversal_mode": "badge_only", "signal_reversal_threshold": 25}
+
+
+@router.get("/exit-defaults")
+def exit_defaults():
+    return _get_exit_defaults()
+
+
+class ExitDefaultsRequest(BaseModel):
+    target_pct: Optional[float] = None
+    stop_loss_pct: Optional[float] = None
+    signal_reversal_mode: Optional[str] = None
+    signal_reversal_threshold: Optional[float] = None
+
+
+@router.put("/exit-defaults")
+def save_exit_defaults(body: ExitDefaultsRequest):
+    current = _get_exit_defaults()
+    if body.target_pct is not None:
+        current["target_pct"] = body.target_pct
+    if body.stop_loss_pct is not None:
+        current["stop_loss_pct"] = body.stop_loss_pct
+    if body.signal_reversal_mode is not None:
+        current["signal_reversal_mode"] = body.signal_reversal_mode
+    if body.signal_reversal_threshold is not None:
+        current["signal_reversal_threshold"] = body.signal_reversal_threshold
+    set_config("exit_defaults", json.dumps(current))
+    return current
+
+
+@router.get("/closed-trades")
+def closed_trades(days: int = 180):
+    trades = get_closed_trades(days)
+    if not trades:
+        return _sanitize({"trades": [], "days": days, "stats": {}})
+    pnls = [t["pnl_realized"] for t in trades if t.get("pnl_realized") is not None]
+    wins = [p for p in pnls if p >= 0]
+    losses = [p for p in pnls if p < 0]
+    stats = {
+        "total": len(trades),
+        "with_pnl": len(pnls),
+        "win_rate": round(len(wins) / len(pnls) * 100, 1) if pnls else None,
+        "avg_pnl": round(sum(pnls) / len(pnls), 2) if pnls else None,
+        "total_pnl": round(sum(pnls), 2) if pnls else None,
+        "avg_win": round(sum(wins) / len(wins), 2) if wins else None,
+        "avg_loss": round(sum(losses) / len(losses), 2) if losses else None,
+        "best": max(pnls, default=None),
+        "worst": min(pnls, default=None),
+    }
+    return _sanitize({"trades": trades, "days": days, "stats": stats})
+
+
+class CloseTradeRequest(BaseModel):
+    close_price: float
+    pnl_realized: Optional[float] = None
+    close_reason: str = "manual"
+    close_note: str = ""
+
+
+class ExitParamsRequest(BaseModel):
+    target_pct: Optional[float] = None
+    stop_loss_pct: Optional[float] = None
+    signal_threshold: Optional[float] = None
+
+
+@router.patch("/trades/{trade_id}/exit-params")
+def set_exit_params(trade_id: int, body: ExitParamsRequest):
+    ok = update_trade_exit_params(
+        trade_id,
+        target_pct=body.target_pct,
+        stop_loss_pct=body.stop_loss_pct,
+        signal_threshold=body.signal_threshold,
+    )
+    if not ok:
+        raise HTTPException(404, "Trade non trouvé")
+    return {"updated": True}
+
+
+@router.patch("/trades/{trade_id}/close")
+def close_trade_endpoint(trade_id: int, body: CloseTradeRequest):
+    trade = get_trade_entry_by_id(trade_id)
+    if not trade:
+        raise HTTPException(404, "Trade non trouvé")
+    if trade.get("status") == "closed":
+        raise HTTPException(409, "Trade déjà clôturé")
+
+    pnl = body.pnl_realized
+    if pnl is None and trade.get("entry_price") and body.close_price > 0:
+        raw = (body.close_price - trade["entry_price"]) / trade["entry_price"] * 100
+        is_bearish = any(kw in (trade.get("strategy") or "").lower()
+                         for kw in _BEARISH_KEYWORDS)
+        pnl = round(-raw if is_bearish else raw, 2)
+
+    ok = close_trade(trade_id, body.close_price, pnl, body.close_reason, body.close_note)
+    if not ok:
+        raise HTTPException(409, "Impossible de clôturer ce trade")
+    return {"closed": True, "trade_id": trade_id, "pnl_realized": pnl}
+
+
 @router.delete("/reset")
 def reset_journal():
     """Truncate all journal history (trades, macro, geo, cycles). Irreversible."""