fix: nouvelles modifications ajout de chatbot

Interface Graphique/.env

@@ -0,0 +1 @@
+GROQ_API_KEY=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

Interface Graphique/app.py

@@ -1,14 +1,28 @@
+import os
+# Doit être défini AVANT tout import de tensorflow/keras/protobuf
+os.environ.setdefault('PROTOCOL_BUFFERS_PYTHON_IMPLEMENTATION', 'python')
+os.environ.setdefault('TF_CPP_MIN_LOG_LEVEL', '3')
+
 import dash
 from dash import dcc, html, Input, Output, State
 import yfinance as yf
 import pandas as pd
-from flask import jsonify, request as flask_request
+from flask import jsonify, request as flask_request, Response, stream_with_context
 import requests
 from bs4 import BeautifulSoup
 from services.database import init_db
 import logging
 from concurrent.futures import ThreadPoolExecutor, as_completed
 
+# Charger les variables d'environnement depuis .env (chemin absolu)
+import os as _os
+try:
+    from dotenv import load_dotenv
+    _env_path = _os.path.join(_os.path.dirname(_os.path.abspath(__file__)), ".env")
+    load_dotenv(dotenv_path=_env_path, override=True)
+except ImportError:
+    pass  # python-dotenv non installé, les env vars système seront utilisées
+
 # Supprimer les logs trop bavards
 logging.getLogger('werkzeug').setLevel(logging.ERROR)
 
@@ -27,6 +41,9 @@ app = dash.Dash(
 
 app.title = "ENSIM - Predictions Boursieres"
 
+# Désactiver le cache navigateur pour les assets (force rechargement chatbot.js à chaque fois)
+app.server.config['SEND_FILE_MAX_AGE_DEFAULT'] = 0
+
 # === TICKERS ===
 TICKERS = {
     "BTC-USD": "BTC/USD",
@@ -91,7 +108,101 @@ app.layout = html.Div([
     html.Div(id="navbar-container"),
     
     # === PAGE CONTENT ===
-    dash.page_container
+    dash.page_container,
+
+    # === CHATBOT WIDGET ===
+    html.Button(
+        html.I(className="fa-solid fa-robot"),
+        id="chatbot-toggle",
+        title="Assistant IA"
+    ),
+    html.Div(
+        id="chatbot-panel",
+        className="chatbot-hidden",
+        children=[
+
+            # ── Header ──────────────────────────────────────────
+            html.Div(id="chatbot-header", children=[
+                html.Div(className="chatbot-header-left", children=[
+                    html.Div(className="chatbot-avatar", children=[
+                        html.I(className="fa-solid fa-robot")
+                    ]),
+                    html.Div(className="chatbot-header-info", children=[
+                        html.Span("Conseiller IA", className="chatbot-header-name"),
+                        html.Div(className="chatbot-header-status", children=[
+                            html.Span(className="chatbot-status-dot"),
+                            html.Span("En ligne"),
+                        ]),
+                    ]),
+                ]),
+                html.Div(className="chatbot-header-actions", children=[
+                    html.Button(
+                        html.I(className="fa-solid fa-clock-rotate-left"),
+                        id="chatbot-history-btn",
+                        title="Historique des conversations"
+                    ),
+                    html.Button(
+                        html.I(className="fa-solid fa-pen-to-square"),
+                        id="chatbot-new-btn",
+                        title="Nouvelle conversation"
+                    ),
+                    html.Button(
+                        html.I(className="fa-solid fa-xmark"),
+                        id="chatbot-close",
+                        title="Fermer"
+                    ),
+                ]),
+            ]),
+
+            # ── Vue Chat (par défaut) ────────────────────────────
+            html.Div(id="chatbot-chat-view", children=[
+                html.Div(id="chatbot-messages", children=[
+                    html.Div(
+                        id="chatbot-welcome",
+                        className="chatbot-msg chatbot-msg-bot",
+                        children=[
+                            html.Div(className="chatbot-bubble", children=[
+                                html.Strong("Bonjour !"),
+                                html.Br(),
+                                "Je suis votre assistant IA. Posez-moi vos questions sur la plateforme, les modèles de prédiction ou les actions disponibles."
+                            ])
+                        ]
+                    )
+                ]),
+                html.Div(id="chatbot-input-row", children=[
+                    html.Button(
+                        html.I(className="fa-solid fa-microphone"),
+                        id="chatbot-mic",
+                        title="Parler"
+                    ),
+                    html.Textarea(
+                        id="chatbot-input",
+                        placeholder="Posez votre question ou parlez…",
+                        rows=1
+                    ),
+                    html.Button(
+                        html.I(className="fa-solid fa-paper-plane"),
+                        id="chatbot-send",
+                        title="Envoyer"
+                    ),
+                ]),
+            ]),
+
+            # ── Vue Historique (cachée par défaut) ───────────────
+            html.Div(id="chatbot-history-view", className="cb-view-hidden", children=[
+                html.Div(id="chatbot-history-header", children=[
+                    html.Span("Conversations", className="cb-hist-title"),
+                    html.Button(
+                        [html.I(className="fa-solid fa-plus"), " Nouvelle"],
+                        id="chatbot-new-btn2",
+                        className="cb-new-btn"
+                    ),
+                ]),
+                html.Div(id="chatbot-history-list"),
+            ]),
+
+        ]
+    ),
 ])
 
 # === LISTE DES PAGES PROTÉGÉES ===
@@ -129,7 +240,7 @@ def update_layout(pathname, session):
         ])
 
         if session and session.get("is_admin"):
-            print(f"👑 Lien admin ajouté pour {session.get('email')}")
+            print(f"[ADMIN] Lien admin ajouté pour {session.get('email')}")
             nav_links.append(dcc.Link("Admin", href="/admin", className=nav_cls("/admin")))
 
         nav_links.append(html.Button("Déconnexion", id="logout-btn", className="nav-link"))
@@ -317,6 +428,334 @@ def api_prices():
     return jsonify(results)
 
 
+# === API TRANSCRIPTION VOCALE (Groq Whisper) ===
+@app.server.route('/api/transcribe', methods=['POST'])
+def api_transcribe():
+    from groq import Groq
+
+    audio_file = flask_request.files.get('audio')
+    if not audio_file:
+        return jsonify({'error': 'Aucun fichier audio'}), 400
+
+    api_key = os.environ.get("GROQ_API_KEY")
+    if not api_key:
+        return jsonify({'error': 'Clé API non configurée'}), 500
+
+    try:
+        client = Groq(api_key=api_key)
+        audio_bytes = audio_file.read()
+        transcription = client.audio.transcriptions.create(
+            file=("audio.webm", audio_bytes),
+            model="whisper-large-v3-turbo",
+            language="fr",
+            response_format="text",
+        )
+        return jsonify({'text': str(transcription).strip()})
+    except Exception as e:
+        return jsonify({'error': str(e)}), 500
+
+
+# === API INVESTISSEMENT CHATBOT ===
+@app.server.route('/api/chat-invest', methods=['POST'])
+def api_chat_invest():
+    from services.database import get_connection
+
+    data    = flask_request.get_json(force=True, silent=True) or {}
+    email   = data.get('email', '').strip()
+    symbol  = data.get('symbol', '').strip().upper()
+    model   = data.get('model', 'sentiment').strip().lower()
+    action  = data.get('action', 'ACHETER').strip().upper()
+    amount  = float(data.get('amount', 0) or 0)
+
+    print(f"[chat-invest] REÇU → email={email!r} symbol={symbol!r} model={model!r} action={action!r} amount={amount}")
+
+    ALLOWED_SYMBOLS = {'AAPL','MSFT','TSLA','NVDA','GOOGL','AMZN','META','BTC-USD'}
+    ALLOWED_MODELS  = {'sentiment','lstm','transformer'}
+
+    if not email or symbol not in ALLOWED_SYMBOLS or model not in ALLOWED_MODELS or amount <= 0:
+        print(f"[chat-invest] VALIDATION ÉCHOUÉE — email={email!r} symbol={symbol!r} model={model!r} amount={amount}")
+        return jsonify({'error': 'Données invalides', 'debug': {'email': email, 'symbol': symbol, 'model': model, 'amount': amount}}), 400
+
+    try:
+        # Prix actuel
+        h = yf.Ticker(symbol).history(period='2d', interval='1d')
+        price = float(h['Close'].iloc[-1]) if not h.empty else 0.0
+
+        # Mapper action → directions compatibles avec Mon Suivi
+        pred_dir   = 'up'   if action == 'ACHETER' else 'down'
+        actual_dir = 'up'   if action == 'ACHETER' else 'down'
+
+        conn = get_connection()
+        conn.execute("""
+            INSERT INTO user_trades
+                (user_email, symbol, entry_price, quantity,
+                 prediction_direction, actual_direction, pnl, pnl_percentage,
+                 model_type, status)
+            VALUES (?, ?, ?, ?, ?, ?, 0, 0, ?, 'open')
+        """, (email, symbol, price, amount, pred_dir, actual_dir, model))
+        conn.commit()
+        conn.close()
+
+        print(f"[chat-invest] Trade sauvegardé: {email} | {symbol} | {model} | {action} | {amount}€ à {price}$")
+
+        return jsonify({
+            'success': True,
+            'symbol':  symbol,
+            'price':   round(price, 2),
+            'amount':  amount,
+            'action':  action,
+            'model':   model,
+        })
+    except Exception as e:
+        print(f"[chat-invest] Erreur: {e}")
+        return jsonify({'error': str(e)}), 500
+
+
+# === API COMPARAISON MODÈLES PAR ACTION ===
+@app.server.route('/api/model-compare', methods=['GET'])
+def api_model_compare():
+    from services.database import get_connection
+
+    email  = flask_request.args.get('email', '').strip()
+    symbol = flask_request.args.get('symbol', '').strip().upper()
+
+    if not email or not symbol:
+        return jsonify({'error': 'Missing params'}), 400
+
+    MODEL_LABELS = {'lstm': 'LSTM', 'transformer': 'Transformer', 'sentiment': 'Actualités'}
+
+    try:
+        conn = get_connection()
+        # Résumé par modèle
+        rows = conn.execute("""
+            SELECT model_type,
+                   COUNT(*) as trades,
+                   SUM(CASE WHEN pnl > 0 THEN 1 ELSE 0 END) as wins,
+                   COALESCE(SUM(pnl), 0) as total_pnl,
+                   COALESCE(AVG(pnl_percentage), 0) as avg_pct
+            FROM user_trades
+            WHERE user_email = ? AND symbol = ? AND status = 'closed'
+            GROUP BY model_type
+        """, (email, symbol)).fetchall()
+
+        models = {}
+        for model_type, trades, wins, total_pnl, avg_pct in rows:
+            # Derniers trades de ce modèle
+            recent = conn.execute("""
+                SELECT entry_date, prediction_direction, quantity, pnl, pnl_percentage
+                FROM user_trades
+                WHERE user_email = ? AND symbol = ? AND model_type = ? AND status = 'closed'
+                ORDER BY entry_date DESC LIMIT 5
+            """, (email, symbol, model_type)).fetchall()
+
+            models[model_type] = {
+                'label':     MODEL_LABELS.get(model_type, model_type),
+                'trades':    trades,
+                'wins':      wins,
+                'losses':    trades - wins,
+                'win_rate':  round(wins / trades * 100, 1) if trades > 0 else 0.0,
+                'total_pnl': round(total_pnl, 2),
+                'avg_pct':   round(avg_pct, 2),
+                'recent':    [
+                    {
+                        'date':    str(r[0])[:10],
+                        'signal':  r[1],
+                        'amount':  r[2] or 0,
+                        'pnl':     round(r[3] or 0, 2),
+                        'pnl_pct': round(r[4] or 0, 2),
+                    }
+                    for r in recent
+                ],
+            }
+        conn.close()
+
+        best_model = None
+        if models:
+            best_model = max(models.items(), key=lambda x: x[1]['total_pnl'])[0]
+
+        return jsonify({'symbol': symbol, 'models': models, 'best_model': best_model})
+    except Exception as e:
+        print(f"[model-compare] Erreur: {e}")
+        return jsonify({'error': str(e)}), 500
+
+
+# === API COMPARAISON MODÈLES — SIMULATION BACKTESTS ===
+@app.server.route('/api/backtest-compare', methods=['GET'])
+def api_backtest_compare():
+    symbol = flask_request.args.get('symbol', '').strip().upper()
+    if not symbol:
+        return jsonify({'error': 'Missing symbol'}), 400
+
+    START = 500.0
+    DAYS  = 180
+
+    def _run_lstm():
+        try:
+            from pages.mon_suivi import _run_backtest_lstm
+            return 'lstm', _run_backtest_lstm(symbol, start_amount=START, days=DAYS)
+        except Exception as e:
+            print(f"[backtest-compare] lstm {symbol}: {e}")
+            return 'lstm', None
+
+    def _run_transformer():
+        try:
+            from services.transformer_service import predict_backtest as _bt
+            return 'transformer', _bt(symbol, start_amount=START, days=DAYS)
+        except Exception as e:
+            print(f"[backtest-compare] transformer {symbol}: {e}")
+            return 'transformer', None
+
+    def _run_sentiment():
+        try:
+            from pages.mon_suivi import _run_backtest
+            return 'sentiment', _run_backtest(symbol, start_amount=START, days=DAYS)
+        except Exception as e:
+            print(f"[backtest-compare] sentiment {symbol}: {e}")
+            return 'sentiment', None
+
+    def _ds(arr, n=30):
+        if not arr or len(arr) <= n:
+            return [round(v, 2) for v in arr]
+        step = len(arr) / n
+        pts = [arr[int(i * step)] for i in range(n)] + [arr[-1]]
+        return [round(v, 2) for v in pts]
+
+    results = {}
+    with ThreadPoolExecutor(max_workers=3) as ex:
+        futures = [ex.submit(_run_lstm), ex.submit(_run_transformer), ex.submit(_run_sentiment)]
+        for f in as_completed(futures):
+            key, bt = f.result()
+            if bt:
+                results[key] = {
+                    'label':      {'lstm': 'LSTM', 'transformer': 'Transformer', 'sentiment': 'Actualités'}[key],
+                    'start':      START,
+                    'final':      bt['final_value'],
+                    'return_pct': bt['total_return'],
+                    'bh_final':   round(bt['buy_hold'][-1], 2) if bt.get('buy_hold') else START,
+                    'bh_return':  bt['buy_hold_return'],
+                    'n_trades':   bt['n_trades'],
+                    'wins':       bt['wins'],
+                    'losses':     bt['losses'],
+                    'win_rate':   bt['win_rate'],
+                    'start_date': bt['start_date'],
+                    'series':     _ds(bt.get('portfolio', [])),
+                    'bh_series':  _ds(bt.get('buy_hold', [])),
+                }
+
+    if not results:
+        return jsonify({'error': f'Données insuffisantes pour {symbol}'}), 404
+
+    best = max(results.items(), key=lambda x: x[1]['return_pct'])[0]
+    return jsonify({'symbol': symbol, 'models': results, 'best_model': best, 'start': START})
+
+
+# === API DÉTECTION INVESTISSEMENT (post-streaming, fiable) ===
+@app.server.route('/api/chat-detect-invest', methods=['POST'])
+def api_chat_detect_invest():
+    """
+    Après le streaming, vérifie si la conversation contient un investissement à enregistrer.
+    Retourne {"invest": {...}} ou {"invest": null}.
+    Utilise un prompt dédié à l'extraction JSON — beaucoup plus fiable que le marqueur inline.
+    """
+    import json as _json
+    from groq import Groq
+
+    data       = flask_request.get_json(force=True, silent=True) or {}
+    messages   = data.get('messages', [])[-6:]   # derniers messages seulement
+
+    api_key = os.environ.get("GROQ_API_KEY")
+    if not api_key:
+        return jsonify({'invest': None})
+
+    EXTRACT_PROMPT = """Tu es un extracteur JSON. Analyse le dernier message de l'utilisateur et extrait les données d'un investissement à enregistrer.
+
+MAPPINGS OBLIGATOIRES — noms d'entreprises → symboles boursiers :
+Apple / AAPL → "AAPL"
+Microsoft / MSFT → "MSFT"
+Tesla / TSLA → "TSLA"
+Nvidia / NVDA → "NVDA"
+Google / Alphabet / GOOGL → "GOOGL"
+Amazon / AMZN → "AMZN"
+Meta / Facebook / META → "META"
+Bitcoin / BTC / crypto → "BTC-USD"
+
+MAPPINGS MODÈLES :
+LSTM / LST / lstm / réseau de neurones / prix → "lstm"
+Transformer / transformeur / hybride → "transformer"
+Sentiment / actualités / actualites / news → "sentiment"
+
+Si l'utilisateur dit qu'il a investi / mis de l'argent / suivi un conseil / acheté / vendu, extrais :
+{"symbol":"AAPL","model":"lstm","action":"ACHETER","amount":500}
+
+RÈGLES :
+- action = "ACHETER" si l'utilisateur a acheté ou suivi un conseil haussier, "VENDRE" sinon
+- amount = le montant en euros (nombre seul, ex: 500)
+- Réponds UNIQUEMENT avec le JSON brut, rien d'autre
+- Si une info manque ou si ce n'est PAS une intention d'enregistrement : réponds null"""
+
+    try:
+        client = Groq(api_key=api_key)
+        resp   = client.chat.completions.create(
+            model="llama-3.3-70b-versatile",
+            messages=[{"role": "system", "content": EXTRACT_PROMPT}] + messages,
+            max_tokens=80,
+            stream=False,
+            temperature=0,
+        )
+        raw = (resp.choices[0].message.content or "").strip()
+        print(f"[detect-invest] raw='{raw}'")
+        if raw == "null" or not raw.startswith("{"):
+            return jsonify({"invest": None})
+        invest = _json.loads(raw)
+        # Validation
+        ALLOWED_SYMBOLS = {"AAPL","MSFT","TSLA","NVDA","GOOGL","AMZN","META","BTC-USD"}
+        ALLOWED_MODELS  = {"sentiment","lstm","transformer"}
+        if (invest.get("symbol") in ALLOWED_SYMBOLS
+                and invest.get("model","").lower() in ALLOWED_MODELS
+                and invest.get("action") in {"ACHETER","VENDRE"}
+                and float(invest.get("amount", 0) or 0) > 0):
+            invest["model"] = invest["model"].lower()
+            return jsonify({"invest": invest})
+        return jsonify({"invest": None})
+    except Exception as e:
+        print(f"[detect-invest] erreur: {e}")
+        return jsonify({"invest": None})
+
+
+# === API CHATBOT (SSE streaming) ===
+@app.server.route('/api/chat', methods=['POST'])
+def api_chat():
+    from services.chat_service import stream_chat
+    import json
+
+    data = flask_request.get_json(force=True, silent=True) or {}
+    messages = data.get('messages', [])
+
+    # Validation basique
+    if not isinstance(messages, list):
+        return jsonify({'error': 'Invalid payload'}), 400
+
+    def generate():
+        try:
+            for chunk in stream_chat(messages):
+                payload = json.dumps({'text': chunk}, ensure_ascii=False)
+                yield f"data: {payload}\n\n"
+        except Exception as e:
+            payload = json.dumps({'error': str(e)}, ensure_ascii=False)
+            yield f"data: {payload}\n\n"
+        finally:
+            yield "data: [DONE]\n\n"
+
+    return Response(
+        stream_with_context(generate()),
+        content_type='text/event-stream',
+        headers={
+            'Cache-Control': 'no-cache',
+            'X-Accel-Buffering': 'no',
+        }
+    )
+
+
 # === LANCEMENT ===
 if __name__ == "__main__":
     import os

Interface Graphique/assets/chatbot.css

@@ -0,0 +1,921 @@
+/* ================================================================
+   CHATBOT.CSS — Widget assistant IA — Design premium + draggable
+   ================================================================ */
+
+/* ── Bouton flottant draggable ───────────────────────────────── */
+#chatbot-toggle {
+    position: fixed;
+    bottom: 28px;
+    right: 28px;
+    z-index: 9100;
+    width: 60px;
+    height: 60px;
+    border-radius: 50%;
+    border: none;
+    cursor: grab;
+    background: linear-gradient(135deg, #00f0ff 0%, #0055ff 100%);
+    box-shadow:
+        0 4px 20px rgba(0, 200, 255, 0.5),
+        0 0 0 0 rgba(0, 200, 255, 0.35),
+        inset 0 1px 1px rgba(255,255,255,0.25);
+    display: flex;
+    align-items: center;
+    justify-content: center;
+    transition: box-shadow 0.3s, transform 0.2s;
+    animation: cbPulse 3.5s ease-in-out infinite;
+    user-select: none;
+    touch-action: none;
+}
+#chatbot-toggle:active  { cursor: grabbing; }
+#chatbot-toggle:hover   {
+    box-shadow: 0 6px 30px rgba(0,200,255,0.65), inset 0 1px 1px rgba(255,255,255,0.2);
+    transform: scale(1.08);
+}
+#chatbot-toggle.cb-dragging {
+    animation: none;
+    transform: scale(1.12);
+    box-shadow: 0 8px 36px rgba(0,200,255,0.7);
+    cursor: grabbing;
+}
+#chatbot-toggle i {
+    font-size: 1.5rem;
+    color: #010214;
+    transition: transform 0.35s cubic-bezier(0.34,1.56,0.64,1);
+    pointer-events: none;
+}
+#chatbot-toggle.chatbot-toggle-active i { transform: rotate(20deg) scale(0.9); }
+
+@keyframes cbPulse {
+    0%,100% { box-shadow: 0 4px 20px rgba(0,200,255,.5), 0 0 0 0   rgba(0,200,255,.35), inset 0 1px 1px rgba(255,255,255,.25); }
+    50%      { box-shadow: 0 4px 20px rgba(0,200,255,.5), 0 0 0 14px rgba(0,200,255,0),   inset 0 1px 1px rgba(255,255,255,.25); }
+}
+
+/* ── Panel ───────────────────────────────────────────────────── */
+#chatbot-panel {
+    position: fixed;
+    z-index: 9099;
+    width: 380px;
+    max-height: 560px;
+    border-radius: 22px;
+    background: linear-gradient(160deg, rgba(6,10,35,0.97) 0%, rgba(3,6,22,0.98) 100%);
+    border: 1px solid rgba(0,210,255,0.15);
+    box-shadow:
+        0 20px 60px rgba(0,0,0,0.7),
+        0 0 0 1px rgba(0,180,255,0.05) inset,
+        0 1px 0 rgba(0,220,255,0.12) inset;
+    backdrop-filter: blur(24px);
+    -webkit-backdrop-filter: blur(24px);
+    display: flex;
+    flex-direction: column;
+    overflow: hidden;
+    /* Position par défaut (sera écrasée par le JS) */
+    bottom: 102px;
+    right: 28px;
+}
+#chatbot-panel.chatbot-hidden  { display: none; }
+#chatbot-panel.chatbot-open    { animation: cbSlideIn 0.3s cubic-bezier(0.22,1,0.36,1) both; }
+@keyframes cbSlideIn {
+    from { opacity:0; transform: scale(0.88) translateY(18px); }
+    to   { opacity:1; transform: scale(1)    translateY(0);    }
+}
+
+/* ── Header ──────────────────────────────────────────────────── */
+#chatbot-header {
+    display: flex;
+    align-items: center;
+    justify-content: space-between;
+    padding: 15px 18px 13px;
+    background: linear-gradient(135deg, rgba(0,180,255,0.1) 0%, rgba(0,80,255,0.07) 100%);
+    border-bottom: 1px solid rgba(0,200,255,0.1);
+    flex-shrink: 0;
+    position: relative;
+    cursor: grab;
+    user-select: none;
+}
+#chatbot-header:active { cursor: grabbing; }
+#chatbot-header::after {
+    content: '';
+    position: absolute;
+    bottom: 0; left: 18px; right: 18px;
+    height: 1px;
+    background: linear-gradient(90deg, transparent, rgba(0,220,255,0.25), transparent);
+}
+/* Poignée de drag — 6 points centrés en haut du header */
+#chatbot-header::before {
+    content: '⋮⋮';
+    position: absolute;
+    top: 5px; left: 50%; transform: translateX(-50%);
+    font-size: 0.65rem; letter-spacing: 3px;
+    color: rgba(0,200,255,0.25);
+    pointer-events: none;
+    line-height: 1;
+}
+.chatbot-header-left { display: flex; align-items: center; gap: 11px; }
+.chatbot-avatar {
+    width: 38px; height: 38px;
+    border-radius: 50%;
+    background: linear-gradient(135deg, #00d4ff, #0050ff);
+    display: flex; align-items: center; justify-content: center;
+    font-size: 1rem; color: #fff;
+    box-shadow: 0 2px 12px rgba(0,180,255,0.4);
+    flex-shrink: 0;
+    position: relative;
+}
+.chatbot-avatar::after {
+    content: '';
+    position: absolute;
+    inset: -2px;
+    border-radius: 50%;
+    background: linear-gradient(135deg, rgba(0,220,255,0.5), transparent);
+    z-index: -1;
+}
+.chatbot-header-info { display: flex; flex-direction: column; gap: 3px; }
+.chatbot-header-name {
+    font-size: 0.9rem; font-weight: 700;
+    color: #eaf6ff; letter-spacing: 0.025em;
+}
+.chatbot-header-status {
+    font-size: 0.7rem; color: #3ef5a0;
+    display: flex; align-items: center; gap: 5px;
+}
+.chatbot-status-dot {
+    width: 6px; height: 6px; border-radius: 50%;
+    background: #3ef5a0;
+    box-shadow: 0 0 6px rgba(62,245,160,0.8);
+    animation: cbStatusBlink 2.5s ease-in-out infinite;
+    flex-shrink: 0;
+}
+@keyframes cbStatusBlink {
+    0%,100% { opacity:1; }
+    50%      { opacity:0.5; }
+}
+.chatbot-header-actions {
+    display: flex;
+    align-items: center;
+    gap: 6px;
+}
+#chatbot-close,
+#chatbot-clear {
+    background: rgba(255,255,255,0.05);
+    border: 1px solid rgba(255,255,255,0.07);
+    color: rgba(184,223,240,0.45);
+    font-size: 0.82rem; cursor: pointer;
+    width: 30px; height: 30px;
+    border-radius: 8px;
+    display: flex; align-items: center; justify-content: center;
+    transition: all 0.2s;
+    flex-shrink: 0;
+}
+#chatbot-close:hover {
+    background: rgba(0,200,255,0.1);
+    border-color: rgba(0,200,255,0.2);
+    color: #00f0ff;
+    transform: rotate(90deg);
+}
+#chatbot-clear:hover {
+    background: rgba(255,80,80,0.1);
+    border-color: rgba(255,80,80,0.2);
+    color: #ff6060;
+}
+
+/* Badge utilisateur connecté */
+.chatbot-user-badge {
+    font-size: 0.68rem;
+    color: rgba(0,220,255,0.55);
+    background: rgba(0,200,255,0.07);
+    border: 1px solid rgba(0,200,255,0.1);
+    border-radius: 20px;
+    padding: 1px 8px;
+    margin-top: 2px;
+    letter-spacing: 0.02em;
+    max-width: 160px;
+    overflow: hidden;
+    text-overflow: ellipsis;
+    white-space: nowrap;
+}
+
+/* ── Zone messages ───────────────────────────────────────────── */
+#chatbot-messages {
+    flex: 1;
+    overflow-y: auto;
+    padding: 16px 14px 10px;
+    display: flex;
+    flex-direction: column;
+    gap: 10px;
+    scrollbar-width: thin;
+    scrollbar-color: rgba(0,200,255,0.15) transparent;
+}
+#chatbot-messages::-webkit-scrollbar { width: 3px; }
+#chatbot-messages::-webkit-scrollbar-thumb { background: rgba(0,200,255,0.2); border-radius: 3px; }
+
+/* ── Bulles ──────────────────────────────────────────────────── */
+.chatbot-msg {
+    display: flex;
+    max-width: 86%;
+    animation: cbMsgIn 0.22s cubic-bezier(0.22,1,0.36,1) both;
+}
+@keyframes cbMsgIn {
+    from { opacity:0; transform: translateY(10px) scale(0.96); }
+    to   { opacity:1; transform: translateY(0)    scale(1);    }
+}
+.chatbot-msg-user  { align-self: flex-end;  flex-direction: row-reverse; }
+.chatbot-msg-bot   { align-self: flex-start; }
+
+.chatbot-bubble {
+    padding: 10px 15px;
+    border-radius: 18px;
+    font-size: 0.84rem;
+    line-height: 1.6;
+    white-space: pre-wrap;
+    word-break: break-word;
+    position: relative;
+}
+.chatbot-msg-user .chatbot-bubble {
+    background: linear-gradient(135deg, #00b8e6 0%, #0044cc 100%);
+    color: #fff;
+    border-bottom-right-radius: 5px;
+    box-shadow: 0 3px 14px rgba(0,140,220,0.3);
+}
+.chatbot-msg-bot .chatbot-bubble {
+    background: rgba(255,255,255,0.04);
+    border: 1px solid rgba(0,200,255,0.1);
+    color: #cde8ff;
+    border-bottom-left-radius: 5px;
+    box-shadow: 0 2px 10px rgba(0,0,0,0.2);
+}
+
+/* Message de bienvenue */
+#chatbot-welcome { align-self: flex-start; max-width: 98%; }
+#chatbot-welcome .chatbot-bubble {
+    background: linear-gradient(135deg, rgba(0,180,255,0.08), rgba(0,60,200,0.06));
+    border: 1px solid rgba(0,200,255,0.13);
+    color: #a8d8f0;
+    font-size: 0.81rem;
+}
+#chatbot-welcome .chatbot-bubble strong { color: #00e5ff; }
+
+/* ── Typing dots ─────────────────────────────────────────────── */
+.chatbot-typing-bubble {
+    display: flex; align-items: center; gap: 5px;
+    padding: 12px 16px; min-width: 58px;
+}
+.chatbot-dot {
+    width: 7px; height: 7px; border-radius: 50%;
+    background: rgba(0,220,255,0.55);
+    animation: cbDot 1.4s ease-in-out infinite;
+}
+.chatbot-dot:nth-child(1) { animation-delay: 0s;    }
+.chatbot-dot:nth-child(2) { animation-delay: 0.2s;  }
+.chatbot-dot:nth-child(3) { animation-delay: 0.4s;  }
+@keyframes cbDot {
+    0%,60%,100% { transform: translateY(0);    opacity:0.45; }
+    30%          { transform: translateY(-7px); opacity:1;    }
+}
+
+/* ── Input row ───────────────────────────────────────────────── */
+#chatbot-input-row {
+    display: flex; align-items: flex-end; gap: 8px;
+    padding: 12px 14px 14px;
+    border-top: 1px solid rgba(0,200,255,0.07);
+    flex-shrink: 0;
+    background: rgba(0,0,0,0.25);
+    position: relative;
+}
+#chatbot-input-row::before {
+    content: '';
+    position: absolute;
+    top: 0; left: 14px; right: 14px; height: 1px;
+    background: linear-gradient(90deg, transparent, rgba(0,200,255,0.15), transparent);
+}
+#chatbot-input {
+    flex: 1;
+    background: rgba(255,255,255,0.05);
+    border: 1px solid rgba(0,200,255,0.13);
+    border-radius: 14px;
+    color: #dff0ff;
+    font-family: inherit;
+    font-size: 0.83rem;
+    padding: 10px 14px;
+    resize: none;
+    outline: none;
+    min-height: 40px;
+    max-height: 110px;
+    overflow-y: auto;
+    transition: border-color 0.25s, box-shadow 0.25s, background 0.25s;
+    line-height: 1.5;
+    scrollbar-width: thin;
+}
+#chatbot-input::placeholder { color: rgba(160,210,240,0.3); }
+#chatbot-input:focus {
+    border-color: rgba(0,200,255,0.38);
+    background: rgba(255,255,255,0.07);
+    box-shadow: 0 0 0 3px rgba(0,200,255,0.07);
+}
+#chatbot-send {
+    width: 40px; height: 40px;
+    border-radius: 12px; border: none;
+    background: linear-gradient(135deg, #00d4ff, #0050ff);
+    color: #010214;
+    font-size: 0.88rem; cursor: pointer;
+    display: flex; align-items: center; justify-content: center;
+    flex-shrink: 0;
+    transition: transform 0.15s, box-shadow 0.2s;
+    box-shadow: 0 3px 12px rgba(0,160,255,0.35);
+}
+#chatbot-send:hover  { transform: scale(1.08); box-shadow: 0 4px 18px rgba(0,160,255,0.55); }
+#chatbot-send:active { transform: scale(0.93); }
+
+/* ── Boutons header supplémentaires ─────────────────────────── */
+#chatbot-history-btn,
+#chatbot-new-btn {
+    background: rgba(255,255,255,0.05);
+    border: 1px solid rgba(255,255,255,0.07);
+    color: rgba(184,223,240,0.45);
+    font-size: 0.82rem; cursor: pointer;
+    width: 30px; height: 30px;
+    border-radius: 8px;
+    display: flex; align-items: center; justify-content: center;
+    transition: all 0.2s;
+    flex-shrink: 0;
+}
+#chatbot-history-btn:hover {
+    background: rgba(0,200,255,0.1);
+    border-color: rgba(0,200,255,0.2);
+    color: #00f0ff;
+}
+#chatbot-history-btn.cb-btn-active {
+    background: rgba(0,200,255,0.15);
+    border-color: rgba(0,200,255,0.3);
+    color: #00f0ff;
+}
+#chatbot-new-btn:hover {
+    background: rgba(60,255,160,0.1);
+    border-color: rgba(60,255,160,0.2);
+    color: #3ef5a0;
+}
+
+/* ── Vues toggle ─────────────────────────────────────────────── */
+#chatbot-chat-view {
+    display: flex;
+    flex-direction: column;
+    flex: 1;
+    overflow: hidden;
+    min-height: 0;
+}
+#chatbot-history-view {
+    display: flex;
+    flex-direction: column;
+    flex: 1;
+    overflow: hidden;
+    min-height: 0;
+}
+.cb-view-hidden { display: none !important; }
+
+/* ── Header vue historique ───────────────────────────────────── */
+#chatbot-history-header {
+    display: flex;
+    align-items: center;
+    justify-content: space-between;
+    padding: 14px 16px 10px;
+    border-bottom: 1px solid rgba(0,200,255,0.08);
+    flex-shrink: 0;
+}
+.cb-hist-title {
+    font-size: 0.85rem;
+    font-weight: 700;
+    color: #eaf6ff;
+    letter-spacing: 0.02em;
+}
+.cb-new-btn {
+    display: flex; align-items: center; gap: 6px;
+    background: linear-gradient(135deg, rgba(0,200,255,0.12), rgba(0,80,255,0.1));
+    border: 1px solid rgba(0,200,255,0.2);
+    color: #00e5ff;
+    font-size: 0.75rem; font-weight: 600;
+    padding: 5px 11px;
+    border-radius: 8px;
+    cursor: pointer;
+    transition: all 0.2s;
+}
+.cb-new-btn:hover {
+    background: linear-gradient(135deg, rgba(0,200,255,0.2), rgba(0,80,255,0.15));
+    box-shadow: 0 2px 10px rgba(0,180,255,0.2);
+}
+
+/* ── Liste des conversations ─────────────────────────────────── */
+#chatbot-history-list {
+    flex: 1;
+    overflow-y: auto;
+    padding: 8px 10px 12px;
+    display: flex;
+    flex-direction: column;
+    gap: 4px;
+    scrollbar-width: thin;
+    scrollbar-color: rgba(0,200,255,0.15) transparent;
+}
+#chatbot-history-list::-webkit-scrollbar { width: 3px; }
+#chatbot-history-list::-webkit-scrollbar-thumb { background: rgba(0,200,255,0.2); border-radius: 3px; }
+
+.cb-hist-section { margin-bottom: 6px; }
+
+.cb-hist-section-label {
+    font-size: 0.68rem;
+    font-weight: 600;
+    color: rgba(0,200,255,0.4);
+    text-transform: uppercase;
+    letter-spacing: 0.08em;
+    padding: 6px 6px 4px;
+}
+
+.cb-hist-item {
+    display: flex;
+    align-items: center;
+    gap: 8px;
+    padding: 9px 10px;
+    border-radius: 10px;
+    cursor: pointer;
+    border: 1px solid transparent;
+    transition: all 0.18s;
+    position: relative;
+}
+.cb-hist-item:hover {
+    background: rgba(0,180,255,0.07);
+    border-color: rgba(0,200,255,0.1);
+}
+.cb-hist-item-active {
+    background: rgba(0,180,255,0.1);
+    border-color: rgba(0,200,255,0.18);
+}
+.cb-hist-item-active::before {
+    content: '';
+    position: absolute;
+    left: 0; top: 20%; bottom: 20%;
+    width: 3px;
+    background: #00e5ff;
+    border-radius: 0 3px 3px 0;
+}
+.cb-hist-item-body {
+    flex: 1;
+    min-width: 0;
+}
+.cb-hist-item-title {
+    font-size: 0.8rem;
+    font-weight: 600;
+    color: #d4eeff;
+    white-space: nowrap;
+    overflow: hidden;
+    text-overflow: ellipsis;
+    margin-bottom: 2px;
+}
+.cb-hist-item-preview {
+    font-size: 0.71rem;
+    color: rgba(160,210,240,0.45);
+    white-space: nowrap;
+    overflow: hidden;
+    text-overflow: ellipsis;
+}
+.cb-hist-delete {
+    background: none;
+    border: none;
+    color: rgba(184,223,240,0.2);
+    font-size: 0.72rem;
+    cursor: pointer;
+    padding: 4px 5px;
+    border-radius: 6px;
+    opacity: 0;
+    transition: all 0.15s;
+    flex-shrink: 0;
+}
+.cb-hist-item:hover .cb-hist-delete { opacity: 1; }
+.cb-hist-delete:hover {
+    background: rgba(255,80,80,0.12);
+    color: #ff6060;
+}
+
+/* ── Empty state ─────────────────────────────────────────────── */
+.cb-hist-empty {
+    display: flex;
+    flex-direction: column;
+    align-items: center;
+    justify-content: center;
+    gap: 10px;
+    padding: 40px 20px;
+    color: rgba(160,210,240,0.3);
+    text-align: center;
+}
+.cb-hist-empty i { font-size: 2rem; }
+.cb-hist-empty p { font-size: 0.8rem; margin: 0; }
+
+/* ── État verrouillé (non connecté) ─────────────────────────── */
+.cb-locked-wrap {
+    display: flex;
+    flex-direction: column;
+    align-items: center;
+    justify-content: center;
+    text-align: center;
+    padding: 30px 24px 24px;
+    gap: 12px;
+    height: 100%;
+    min-height: 240px;
+}
+.cb-locked-icon {
+    width: 64px; height: 64px;
+    border-radius: 50%;
+    background: linear-gradient(135deg, rgba(0,200,255,0.08), rgba(0,60,200,0.06));
+    border: 1px solid rgba(0,200,255,0.15);
+    display: flex; align-items: center; justify-content: center;
+    font-size: 1.6rem;
+    color: rgba(0,200,255,0.5);
+    margin-bottom: 4px;
+}
+.cb-locked-title {
+    font-size: 0.95rem;
+    font-weight: 700;
+    color: #eaf6ff;
+}
+.cb-locked-desc {
+    font-size: 0.78rem;
+    color: rgba(160,210,240,0.5);
+    line-height: 1.6;
+    max-width: 260px;
+}
+.cb-locked-btn {
+    display: inline-flex;
+    align-items: center;
+    gap: 7px;
+    margin-top: 6px;
+    padding: 9px 22px;
+    border-radius: 12px;
+    background: linear-gradient(135deg, #00c4e0, #0050cc);
+    color: #fff;
+    font-size: 0.82rem;
+    font-weight: 600;
+    text-decoration: none;
+    transition: opacity 0.2s, transform 0.15s;
+    box-shadow: 0 3px 14px rgba(0,160,255,0.3);
+}
+.cb-locked-btn:hover { opacity: 0.88; transform: translateY(-1px); }
+
+/* Input désactivé */
+#chatbot-input:disabled {
+    opacity: 0.35;
+    cursor: not-allowed;
+}
+#chatbot-send:disabled {
+    opacity: 0.25;
+    cursor: not-allowed;
+    pointer-events: none;
+}
+#chatbot-mic:disabled {
+    opacity: 0.25;
+    cursor: not-allowed;
+    /* PAS de pointer-events:none → le clic doit toujours arriver à toggleVoice() */
+}
+
+/* ── Bouton micro ────────────────────────────────────────────── */
+#chatbot-mic {
+    width: 36px; height: 36px;
+    border-radius: 10px; border: none;
+    background: rgba(255,255,255,0.05);
+    border: 1px solid rgba(0,200,255,0.13);
+    color: rgba(160,210,240,0.5);
+    font-size: 0.85rem; cursor: pointer;
+    display: flex; align-items: center; justify-content: center;
+    flex-shrink: 0;
+    transition: all 0.2s;
+}
+#chatbot-mic:hover {
+    background: rgba(0,200,255,0.08);
+    border-color: rgba(0,200,255,0.25);
+    color: #00e5ff;
+}
+#chatbot-mic.cb-mic-active {
+    background: rgba(255,60,60,0.15);
+    border-color: rgba(255,80,80,0.4);
+    color: #ff5555;
+    animation: cbMicPulse 1s ease-in-out infinite;
+}
+@keyframes cbMicPulse {
+    0%,100% { box-shadow: 0 0 0 0   rgba(255,80,80,0.4); }
+    50%      { box-shadow: 0 0 0 6px rgba(255,80,80,0);   }
+}
+
+/* ── Carte confirmation investissement ───────────────────────── */
+.cb-invest-card {
+    margin: 8px 0 8px 10px;
+    border-radius: 14px;
+    border: 1.5px solid rgba(0,230,128,0.35);
+    background: linear-gradient(135deg, rgba(0,30,60,0.97), rgba(0,20,45,0.99));
+    box-shadow: 0 4px 24px rgba(0,0,0,0.5), 0 0 0 1px rgba(0,200,120,0.08) inset;
+    overflow: hidden;
+    animation: cbMsgIn 0.25s ease both;
+    max-width: 320px;
+}
+.cb-invest-card-pulse {
+    animation: cbMsgIn 0.25s ease both, cbInvestGlow 2s ease-in-out 0.3s 3;
+}
+@keyframes cbInvestGlow {
+    0%,100% { border-color: rgba(0,230,128,0.35); box-shadow: 0 4px 24px rgba(0,0,0,0.5); }
+    50%     { border-color: rgba(0,230,128,0.8);  box-shadow: 0 4px 32px rgba(0,200,100,0.3); }
+}
+.cb-invest-note {
+    margin: 0 12px 6px;
+    font-size: 0.7rem;
+    color: rgba(0,230,150,0.7);
+    text-align: center;
+}
+.cb-invest-header {
+    display: flex; align-items: center; gap: 8px;
+    padding: 8px 12px 6px;
+    background: linear-gradient(135deg, rgba(0,180,255,0.1), rgba(0,60,200,0.07));
+    border-bottom: 1px solid rgba(0,200,255,0.08);
+    font-size: 0.76rem; font-weight: 700;
+    color: #00e5ff; letter-spacing: 0.02em;
+}
+.cb-invest-details {
+    padding: 7px 12px;
+    display: flex; flex-direction: column; gap: 3px;
+}
+.cb-invest-row {
+    display: flex; justify-content: space-between; align-items: center;
+    font-size: 0.76rem;
+}
+.cb-invest-row span { color: rgba(160,210,240,0.5); }
+.cb-invest-row strong { color: #d4eeff; font-weight: 600; }
+.cb-invest-row .cb-buy  { color: #3ef5a0; }
+.cb-invest-row .cb-sell { color: #ff6060; }
+.cb-invest-actions {
+    display: flex; gap: 8px;
+    padding: 0 12px 10px;
+}
+.cb-invest-confirm {
+    flex: 1;
+    padding: 7px 10px;
+    border-radius: 9px; border: none;
+    background: linear-gradient(135deg, #00d084, #00a868);
+    color: #fff; font-size: 0.78rem; font-weight: 700;
+    cursor: pointer; transition: opacity 0.2s, transform 0.15s;
+    letter-spacing: 0.01em;
+}
+.cb-invest-confirm:hover   { opacity: 0.88; transform: translateY(-1px); }
+.cb-invest-confirm:disabled { opacity: 0.5; cursor: not-allowed; transform: none; }
+.cb-invest-cancel {
+    padding: 7px 12px;
+    border-radius: 9px;
+    border: 1px solid rgba(255,255,255,0.08);
+    background: rgba(255,255,255,0.04);
+    color: rgba(160,210,240,0.5);
+    font-size: 0.75rem; cursor: pointer;
+    transition: all 0.2s;
+}
+.cb-invest-cancel:hover {
+    background: rgba(255,80,80,0.08);
+    border-color: rgba(255,80,80,0.2);
+    color: #ff7070;
+}
+.cb-invest-success, .cb-invest-error {
+    padding: 12px 14px;
+    font-size: 0.78rem; line-height: 1.6;
+}
+.cb-invest-success { color: #3ef5a0; }
+.cb-invest-error   { color: #ff6060; }
+.cb-invest-link {
+    display: inline-block;
+    margin-top: 6px;
+    color: #00e5ff;
+    text-decoration: none;
+    font-weight: 600;
+    font-size: 0.76rem;
+}
+.cb-invest-link:hover { text-decoration: underline; }
+
+/* ── Modal comparaison modèles — fenêtre déplaçable ─────────── */
+#cb-compare-modal {
+    position: fixed;
+    z-index: 99999;
+    width: 440px;
+    max-height: 90vh;
+    background: linear-gradient(160deg, rgba(4,10,34,0.99), rgba(2,6,20,1));
+    border: 1px solid rgba(0,200,255,0.18);
+    border-radius: 18px;
+    box-shadow: 0 24px 80px rgba(0,0,0,0.75), 0 0 0 1px rgba(0,180,255,0.08) inset;
+    display: flex;
+    flex-direction: column;
+    overflow: hidden;
+    animation: cbModalIn 0.22s cubic-bezier(0.22,1,0.36,1) both;
+}
+@keyframes cbModalIn {
+    from { opacity: 0; transform: translateY(14px) scale(0.96); }
+    to   { opacity: 1; transform: translateY(0)    scale(1);    }
+}
+.cb-modal-header {
+    display: flex; align-items: center; justify-content: space-between;
+    padding: 11px 14px 10px;
+    background: rgba(0,180,255,0.08);
+    border-bottom: 1px solid rgba(0,200,255,0.13);
+    flex-shrink: 0;
+    user-select: none;
+}
+.cb-modal-title {
+    display: flex; align-items: center; gap: 8px;
+    font-size: 0.77rem; font-weight: 700; color: #00d4ff;
+    letter-spacing: 0.02em;
+}
+.cb-modal-drag-hint {
+    font-size: 0.72rem;
+    color: rgba(120,180,220,0.35);
+    pointer-events: none;
+}
+.cb-modal-close {
+    background: rgba(255,255,255,0.05);
+    border: 1px solid rgba(255,255,255,0.08);
+    cursor: pointer;
+    color: rgba(160,210,240,0.6);
+    font-size: 0.78rem;
+    padding: 4px 8px; border-radius: 6px;
+    transition: all 0.15s;
+}
+.cb-modal-close:hover { background: rgba(255,80,80,0.15); color: #ff6060; border-color: rgba(255,80,80,0.3); }
+.cb-modal-body {
+    flex: 1;
+    overflow-y: auto;
+    padding: 12px 14px 14px;
+    scrollbar-width: thin;
+    scrollbar-color: rgba(0,180,255,0.15) transparent;
+}
+.cb-modal-body::-webkit-scrollbar { width: 3px; }
+.cb-modal-body::-webkit-scrollbar-thumb { background: rgba(0,180,255,0.2); border-radius: 2px; }
+.cb-modal-subtitle {
+    font-size: 0.66rem;
+    color: rgba(120,180,220,0.4);
+    text-align: center;
+    margin-bottom: 12px;
+}
+.cb-modal-loading {
+    text-align: center;
+    padding: 50px 10px;
+    font-size: 0.82rem;
+    color: rgba(160,210,240,0.55);
+    line-height: 2;
+}
+.cb-modal-loading i { color: #00d4ff; font-size: 2rem; display: block; margin-bottom: 14px; }
+.cb-modal-loading small { color: rgba(120,180,220,0.3); font-size: 0.69rem; }
+.cb-modal-error {
+    text-align: center;
+    padding: 30px 10px;
+    font-size: 0.75rem;
+    color: rgba(255,150,150,0.65);
+    line-height: 1.7;
+}
+.cb-modal-model {
+    border-radius: 12px;
+    border: 1px solid rgba(255,255,255,0.06);
+    background: rgba(255,255,255,0.025);
+    padding: 11px 13px;
+    margin-bottom: 10px;
+}
+.cb-modal-model-best {
+    border-color: rgba(0,230,128,0.28);
+    background: rgba(0,230,128,0.035);
+    box-shadow: 0 0 0 1px rgba(0,230,128,0.08) inset;
+}
+.cb-modal-model-head {
+    display: flex; align-items: center; justify-content: space-between;
+    margin-bottom: 7px;
+}
+.cb-modal-explain {
+    font-size: 0.72rem;
+    color: rgba(160,210,240,0.65);
+    line-height: 1.65;
+    margin-bottom: 8px;
+    padding: 7px 10px;
+    background: rgba(0,0,0,0.2);
+    border-radius: 7px;
+    border-left: 2px solid rgba(0,200,255,0.2);
+}
+.cb-modal-explain strong { font-weight: 700; }
+.cb-modal-view-btn {
+    font-size: 0.62rem; font-weight: 600;
+    color: rgba(0,200,255,0.7);
+    background: rgba(0,200,255,0.08);
+    border: 1px solid rgba(0,200,255,0.2);
+    border-radius: 5px;
+    padding: 2px 7px;
+    text-decoration: none;
+    transition: all 0.15s;
+    white-space: nowrap;
+}
+.cb-modal-view-btn:hover { background: rgba(0,200,255,0.18); color: #00d4ff; }
+.cb-modal-footer {
+    text-align: center;
+    font-size: 0.71rem;
+    color: rgba(160,210,240,0.38);
+    padding: 8px 0 2px;
+    border-top: 1px solid rgba(255,255,255,0.05);
+    margin-top: 4px;
+}
+.cb-modal-footer strong { color: #00d4ff; }
+
+/* ── Shared compare styles ────────────────────────────────────── */
+.cb-cmp-name {
+    font-size: 0.78rem; font-weight: 700; color: #d4eeff;
+    display: flex; align-items: center; gap: 6px;
+}
+.cb-cmp-name i { color: #00d4ff; font-size: 0.74rem; }
+.cb-cmp-badge {
+    font-size: 0.61rem; font-weight: 700; letter-spacing: 0.05em;
+    background: rgba(0,230,128,0.18); color: #3ef5a0;
+    border: 1px solid rgba(0,230,128,0.35);
+    padding: 1px 7px; border-radius: 20px;
+}
+.cb-cmp-sim-summary {
+    font-size: 0.70rem; color: rgba(160,210,240,0.55);
+    margin-bottom: 4px; line-height: 1.5;
+}
+.cb-cmp-sim-summary strong { font-weight: 700; }
+.cb-cmp-spark {
+    margin: 3px 0 6px;
+    border-radius: 6px;
+    background: rgba(0,0,0,0.35);
+    padding: 3px 4px 2px;
+    overflow: hidden;
+}
+.cb-cmp-spark-legend {
+    display: flex; gap: 12px;
+    font-size: 0.59rem; color: rgba(120,180,220,0.45);
+    margin-top: 2px; padding-left: 2px;
+}
+.cb-cmp-spark-ai { color: #00d4ff; }
+.cb-cmp-spark-bh { color: rgba(255,255,255,0.28); }
+.cb-cmp-grid {
+    display: grid;
+    grid-template-columns: 1fr 1fr;
+    gap: 5px;
+    margin-top: 5px;
+}
+.cb-cmp-cell {
+    background: rgba(255,255,255,0.03);
+    border: 1px solid rgba(255,255,255,0.05);
+    border-radius: 7px;
+    padding: 5px 7px;
+    display: flex; flex-direction: column; gap: 2px;
+}
+.cb-cmp-lbl {
+    font-size: 0.60rem; color: rgba(120,180,220,0.45);
+    text-transform: uppercase; letter-spacing: 0.04em;
+}
+.cb-cmp-val { font-size: 0.72rem; font-weight: 600; color: #c8e4f8; }
+.cb-cmp-pos { color: #3ef5a0; }
+.cb-cmp-neg { color: #ff6060; }
+
+/* ── Badge "action en attente" sur le bouton toggle ──────────── */
+.cb-pending-badge {
+    position: absolute;
+    top: -4px;
+    right: -4px;
+    width: 18px;
+    height: 18px;
+    border-radius: 50%;
+    background: #ff4040;
+    color: #fff;
+    font-size: 0.65rem;
+    font-weight: 700;
+    display: flex;
+    align-items: center;
+    justify-content: center;
+    animation: cbPendingPulse 1s ease-in-out infinite;
+    pointer-events: none;
+}
+@keyframes cbPendingPulse {
+    0%, 100% { transform: scale(1); box-shadow: 0 0 0 0 rgba(255,64,64,0.5); }
+    50%       { transform: scale(1.15); box-shadow: 0 0 0 6px rgba(255,64,64,0); }
+}
+
+/* ── Loader détection investissement ────────────────────────── */
+.cb-detect-loader {
+    display: flex; align-items: center;
+    margin: 4px 0 4px 10px;
+    padding: 6px 12px;
+    border-radius: 10px;
+    background: rgba(0,200,255,0.06);
+    border: 1px solid rgba(0,200,255,0.12);
+    width: fit-content;
+    font-size: 0.72rem;
+    color: rgba(160,210,240,0.6);
+    animation: cbMsgIn 0.2s ease both;
+}
+.cb-detect-loader .chatbot-dot {
+    width: 5px; height: 5px;
+    border-radius: 50%;
+    background: rgba(0,200,255,0.5);
+    margin: 0 2px;
+    animation: cbTypingDot 1.2s infinite;
+}
+.cb-detect-loader .chatbot-dot:nth-child(2) { animation-delay: 0.2s; }
+.cb-detect-loader .chatbot-dot:nth-child(3) { animation-delay: 0.4s; }
+
+/* ── Mobile ──────────────────────────────────────────────────── */
+@media (max-width: 480px) {
+    #chatbot-panel { width: calc(100vw - 24px); right: 12px !important; left: 12px !important; }
+    #chatbot-toggle { right: 16px !important; bottom: 20px !important; }
+}

Interface Graphique/assets/chatbot.js

@@ -0,0 +1,1245 @@
+/* ================================================================
+   CHATBOT.JS — v6 — Extraction avec contexte historique
+   ================================================================ */
+console.log("[Chatbot] v6 chargé — extraction avec contexte historique");
+
+(function () {
+    "use strict";
+
+    // ── État global ──────────────────────────────────────────────
+    let _history      = [];      // messages de la conversation active
+    let _activeId     = null;    // id de la conversation active
+    let _isStreaming  = false;
+    let _bound        = false;
+    let _historyOpen  = false;
+    let _initialized  = false;
+
+    const POS_KEY       = "chatbot_btn_pos";
+    const PANEL_POS_KEY = "chatbot_panel_pos";
+    const MAX_MSG       = 60;    // messages max par conversation
+    const MAX_CONVS     = 30;    // conversations max à conserver
+
+    // ── Clés localStorage ────────────────────────────────────────
+
+    function _getUserEmail() {
+        try {
+            const raw = sessionStorage.getItem("session-store");
+            if (!raw) return null;
+            const d = JSON.parse(raw);
+            return d && d.email ? d.email : null;
+        } catch (_) { return null; }
+    }
+
+    function _storeKey() {
+        const email = _getUserEmail();
+        const hash  = email ? btoa(email).replace(/[^a-zA-Z0-9]/g, "") : "guest";
+        return "chatbot_convs_" + hash;
+    }
+
+    // ── Persistance conversations ────────────────────────────────
+
+    function _loadStore() {
+        try {
+            const raw = localStorage.getItem(_storeKey());
+            return raw ? JSON.parse(raw) : { activeId: null, list: [] };
+        } catch (_) { return { activeId: null, list: [] }; }
+    }
+
+    function _saveStore(store) {
+        try { localStorage.setItem(_storeKey(), JSON.stringify(store)); } catch (_) {}
+    }
+
+    // Génère un titre à partir du 1er message utilisateur
+    function _autoTitle(text) {
+        if (!text) return "Nouvelle conversation";
+        const t = text.trim().replace(/\s+/g, " ");
+        return t.length > 45 ? t.slice(0, 42) + "…" : t;
+    }
+
+    // Formate la date de façon relative
+    function _relDate(isoStr) {
+        try {
+            const d    = new Date(isoStr);
+            const now  = new Date();
+            const diff = Math.floor((now - d) / 86400000);
+            if (diff === 0)  return "Aujourd'hui";
+            if (diff === 1)  return "Hier";
+            if (diff < 7)    return "Il y a " + diff + " jours";
+            if (diff < 30)   return "Il y a " + Math.floor(diff / 7) + " sem.";
+            return d.toLocaleDateString("fr-FR", { day: "numeric", month: "short" });
+        } catch (_) { return ""; }
+    }
+
+    // ── Gestion des conversations ─────────────────────────────────
+
+    function _newConversation() {
+        _history   = [];
+        _activeId  = "conv_" + Date.now();
+
+        // Réinitialiser la zone messages
+        const container = $("#chatbot-messages");
+        if (container) {
+            container.innerHTML = "";
+            const wrap   = document.createElement("div");
+            wrap.id        = "chatbot-welcome";
+            wrap.className = "chatbot-msg chatbot-msg-bot";
+            wrap.innerHTML = `<div class="chatbot-bubble">
+                <strong> Bonjour !</strong><br>
+                Je suis votre assistant IA. Posez-moi vos questions sur la plateforme, les modèles de prédiction ou les actions disponibles.
+            </div>`;
+            container.appendChild(wrap);
+        }
+
+        // Passer à la vue chat
+        if (_historyOpen) _toggleHistoryView(false);
+
+        setTimeout(() => { const i = $("#chatbot-input"); if (i) { i.value = ""; i.focus(); } }, 100);
+    }
+
+    function _saveCurrentConversation() {
+        if (!_activeId || _history.length === 0) return;
+        const store = _loadStore();
+        const idx   = store.list.findIndex(c => c.id === _activeId);
+        const now   = new Date().toISOString();
+
+        const title = _autoTitle(
+            (_history.find(m => m.role === "user") || {}).content || ""
+        );
+
+        if (idx >= 0) {
+            store.list[idx].messages = _history.slice(-MAX_MSG);
+            store.list[idx].updated  = now;
+            store.list[idx].title    = title;
+        } else {
+            store.list.unshift({
+                id:       _activeId,
+                title:    title,
+                created:  now,
+                updated:  now,
+                messages: _history.slice(-MAX_MSG),
+            });
+            // Limiter le nombre de conversations
+            if (store.list.length > MAX_CONVS) {
+                store.list = store.list.slice(0, MAX_CONVS);
+            }
+        }
+        store.activeId = _activeId;
+        _saveStore(store);
+    }
+
+    function _loadConversation(id) {
+        const store = _loadStore();
+        const conv  = store.list.find(c => c.id === id);
+        if (!conv) return;
+
+        _activeId = id;
+        _history  = conv.messages || [];
+
+        // Rerendre les messages
+        const container = $("#chatbot-messages");
+        if (container) {
+            container.innerHTML = "";
+            _history.forEach(function (msg) {
+                const role   = msg.role === "assistant" ? "bot" : msg.role;
+                const wrap   = document.createElement("div");
+                wrap.className = "chatbot-msg chatbot-msg-" + role;
+                const bubble = document.createElement("div");
+                bubble.className   = "chatbot-bubble";
+                bubble.textContent = msg.content;
+                wrap.appendChild(bubble);
+                container.appendChild(wrap);
+            });
+        }
+        scrollBottom();
+
+        // Fermer l'historique, aller sur la vue chat
+        _toggleHistoryView(false);
+        setTimeout(() => { const i = $("#chatbot-input"); if (i) i.focus(); }, 200);
+    }
+
+    function _deleteConversation(id, e) {
+        e.stopPropagation();
+        const store = _loadStore();
+        store.list  = store.list.filter(c => c.id !== id);
+        if (store.activeId === id) store.activeId = null;
+        _saveStore(store);
+
+        // Si on vient de supprimer la conv active → nouvelle conv
+        if (_activeId === id) _newConversation();
+
+        // Rafraîchir la liste
+        _renderHistoryList();
+    }
+
+    // ── Vue historique ────────────────────────────────────────────
+
+    function _toggleHistoryView(forceState) {
+        _historyOpen = (forceState !== undefined) ? forceState : !_historyOpen;
+
+        const chatView = $("#chatbot-chat-view");
+        const histView = $("#chatbot-history-view");
+        const btn      = $("#chatbot-history-btn");
+        if (!chatView || !histView) return;
+
+        if (_historyOpen) {
+            chatView.classList.add("cb-view-hidden");
+            histView.classList.remove("cb-view-hidden");
+            btn && btn.classList.add("cb-btn-active");
+            _renderHistoryList();
+        } else {
+            histView.classList.add("cb-view-hidden");
+            chatView.classList.remove("cb-view-hidden");
+            btn && btn.classList.remove("cb-btn-active");
+            scrollBottom();
+        }
+    }
+
+    function _renderHistoryList() {
+        const list = $("#chatbot-history-list");
+        if (!list) return;
+
+        const store = _loadStore();
+        list.innerHTML = "";
+
+        if (store.list.length === 0) {
+            list.innerHTML = `<div class="cb-hist-empty">
+                <i class="fa-solid fa-comments"></i>
+                <p>Aucune conversation sauvegardée</p>
+            </div>`;
+            return;
+        }
+
+        // Grouper par date (Aujourd'hui / Hier / Cette semaine / Plus ancien)
+        const groups = {};
+        store.list.forEach(function (conv) {
+            const label = _relDate(conv.updated);
+            if (!groups[label]) groups[label] = [];
+            groups[label].push(conv);
+        });
+
+        Object.keys(groups).forEach(function (label) {
+            const section = document.createElement("div");
+            section.className = "cb-hist-section";
+
+            const heading = document.createElement("div");
+            heading.className   = "cb-hist-section-label";
+            heading.textContent = label;
+            section.appendChild(heading);
+
+            groups[label].forEach(function (conv) {
+                const item = document.createElement("div");
+                item.className = "cb-hist-item" + (conv.id === _activeId ? " cb-hist-item-active" : "");
+
+                const preview = (conv.messages.slice().reverse().find(m => m.role === "assistant") || {}).content || "";
+                const previewShort = preview.slice(0, 55) + (preview.length > 55 ? "…" : "");
+
+                item.innerHTML = `
+                    <div class="cb-hist-item-body">
+                        <div class="cb-hist-item-title">${_esc(conv.title)}</div>
+                        <div class="cb-hist-item-preview">${_esc(previewShort)}</div>
+                    </div>
+                    <button class="cb-hist-delete" title="Supprimer">
+                        <i class="fa-solid fa-trash-can"></i>
+                    </button>
+                `;
+
+                item.querySelector(".cb-hist-item-body").addEventListener("click", function () {
+                    _loadConversation(conv.id);
+                });
+                item.querySelector(".cb-hist-delete").addEventListener("click", function (e) {
+                    _deleteConversation(conv.id, e);
+                });
+
+                section.appendChild(item);
+            });
+
+            list.appendChild(section);
+        });
+    }
+
+    function _esc(str) {
+        return (str || "").replace(/&/g,"&amp;").replace(/</g,"&lt;").replace(/>/g,"&gt;").replace(/"/g,"&quot;");
+    }
+
+    // ── Helpers DOM ──────────────────────────────────────────────
+
+    function $(sel) { return document.querySelector(sel); }
+
+    function scrollBottom() {
+        const msgs = $("#chatbot-messages");
+        if (msgs) msgs.scrollTop = msgs.scrollHeight;
+    }
+
+    function addMessage(role, text, id) {
+        const msgs = $("#chatbot-messages");
+        if (!msgs) return null;
+        const wrap   = document.createElement("div");
+        wrap.className = "chatbot-msg chatbot-msg-" + role;
+        if (id) wrap.id = id;
+        const bubble = document.createElement("div");
+        bubble.className   = "chatbot-bubble";
+        bubble.textContent = text;
+        wrap.appendChild(bubble);
+        msgs.appendChild(wrap);
+        scrollBottom();
+        return bubble;
+    }
+
+    function showTyping() {
+        const msgs = $("#chatbot-messages");
+        if (!msgs) return;
+        const wrap = document.createElement("div");
+        wrap.className = "chatbot-msg chatbot-msg-bot";
+        wrap.id = "chatbot-typing";
+        wrap.innerHTML = `<div class="chatbot-bubble chatbot-typing-bubble">
+            <span class="chatbot-dot"></span><span class="chatbot-dot"></span><span class="chatbot-dot"></span>
+        </div>`;
+        msgs.appendChild(wrap);
+        scrollBottom();
+    }
+
+    function removeTyping() {
+        const t = $("#chatbot-typing");
+        if (t) t.remove();
+    }
+
+    // ── Voix : MediaRecorder + Groq Whisper ─────────────────────
+    // Fiable sur HTTP local — pas de dépendance Chrome Speech API
+
+    let _isListening   = false;
+    let _mediaRecorder = null;
+    let _audioChunks   = [];
+
+    function _setMicState(active) {
+        _isListening = active;
+        const btn = $("#chatbot-mic");
+        if (!btn) return;
+        if (active) {
+            btn.classList.add("cb-mic-active");
+            btn.title = "Arrêter";
+        } else {
+            btn.classList.remove("cb-mic-active");
+            btn.title = "Parler";
+        }
+    }
+
+    function toggleVoice() {
+        const input = $("#chatbot-input");
+
+        if (!_getUserEmail()) {
+            if (input) input.placeholder = "Connectez-vous pour utiliser l'assistant…";
+            return;
+        }
+
+        // Arrêter l'enregistrement
+        if (_isListening && _mediaRecorder) {
+            _mediaRecorder.stop();
+            return;
+        }
+
+        if (!navigator.mediaDevices || !navigator.mediaDevices.getUserMedia) {
+            addMessage("bot", "Accès au microphone non disponible sur ce navigateur.");
+            return;
+        }
+
+        navigator.mediaDevices.getUserMedia({ audio: true })
+            .then(function (stream) {
+                _audioChunks = [];
+
+                const mimeType = MediaRecorder.isTypeSupported('audio/webm;codecs=opus')
+                    ? 'audio/webm;codecs=opus'
+                    : MediaRecorder.isTypeSupported('audio/webm')
+                    ? 'audio/webm'
+                    : 'audio/ogg;codecs=opus';
+
+                _mediaRecorder = new MediaRecorder(stream, { mimeType });
+
+                _mediaRecorder.ondataavailable = function (e) {
+                    if (e.data && e.data.size > 0) _audioChunks.push(e.data);
+                };
+
+                _mediaRecorder.onstop = async function () {
+                    stream.getTracks().forEach(t => t.stop());
+                    _setMicState(false);
+                    if (_audioChunks.length === 0) return;
+
+                    const blob = new Blob(_audioChunks, { type: mimeType });
+                    _audioChunks = [];
+                    if (input) input.placeholder = "Transcription en cours…";
+
+                    try {
+                        const formData = new FormData();
+                        formData.append('audio', blob, 'audio.webm');
+                        const resp = await fetch('/api/transcribe', { method: 'POST', body: formData });
+                        const data = await resp.json();
+
+                        if (data.text && data.text.trim()) {
+                            if (input) {
+                                input.value = data.text.trim();
+                                input.placeholder = "Posez votre question ou parlez…";
+                            }
+                            setTimeout(sendMessage, 300);
+                        } else {
+                            if (input) input.placeholder = "Posez votre question ou parlez…";
+                            addMessage("bot", data.error ? data.error : "Aucune parole détectée, réessayez.");
+                        }
+                    } catch (err) {
+                        if (input) input.placeholder = "Posez votre question ou parlez…";
+                        addMessage("bot", "Erreur transcription : " + err.message);
+                    }
+                };
+
+                _setMicState(true);
+                if (input) input.placeholder = "Parlez… re-cliquez pour arrêter";
+                _mediaRecorder.start();
+            })
+            .catch(function (err) {
+                _setMicState(false);
+                if (err.name === 'NotAllowedError') {
+                    addMessage("bot", "Permission micro refusée.\nAutorisez le micro dans les paramètres du navigateur.");
+                } else {
+                    addMessage("bot", "Micro inaccessible : " + err.message);
+                }
+            });
+    }
+
+    // ── Comparaison modèles ──────────────────────────────────────
+
+    // Intention : "quel modèle pour Apple ?" / "compare les modèles sur TSLA" etc.
+    // Regex sans caractères spéciaux pour éviter les problèmes d'encodage
+    const _COMPARE_RE = /quel\s+mod.le|meilleur\s+mod.le|compare\s+.{0,15}mod.le|mod.le\s+.{0,20}conseill|recommand.{0,10}mod.le|quel\s+mod.l|si\s+j.avais\s+suivi|quel\s+algo|comparer\s+les\s+mod/i;
+
+    function _extractCompareSymbol(text, history) {
+        const lo = ' ' + text.toLowerCase() + ' ';
+        const ctxLo = lo + ' ' + (history || []).slice(-8).map(m => (m.content || '').toLowerCase()).join(' ') + ' ';
+        const sym = _findSymbol(lo) || _findSymbol(ctxLo);
+        console.log("[Chatbot] _extractCompareSymbol:", sym, "| lo:", lo.slice(0,60));
+        return sym;
+    }
+
+    function _makeSpark(series, bhSeries, W, H) {
+        W = W || 380; H = H || 80;
+        if (!series || series.length < 2) return '';
+        const all = [...series, ...(bhSeries || [])];
+        const mn = Math.min(...all), mx = Math.max(...all);
+        const rng = mx - mn || 1;
+        const PAD = { t: 6, b: 6, l: 4, r: 4 };
+        const iW = W - PAD.l - PAD.r, iH = H - PAD.t - PAD.b;
+        const vy = (v) => (PAD.t + (mx - v) / rng * iH).toFixed(1);
+        const vx = (i, len) => (PAD.l + i / (len - 1) * iW).toFixed(1);
+        const pts = (arr) => arr.map((v, i) => `${vx(i, arr.length)},${vy(v)}`).join(' ');
+        const bhLine = bhSeries && bhSeries.length > 1
+            ? `<polyline points="${pts(bhSeries)}" fill="none" stroke="rgba(255,255,255,0.22)" stroke-width="1.2" stroke-dasharray="4,3"/>`
+            : '';
+        // Coloring: green if final > start, red otherwise
+        const finalV = series[series.length - 1];
+        const startV = series[0];
+        const lineCol = finalV >= startV ? '#3ef5a0' : '#ff6060';
+        // Dashed line at start value (reference)
+        const refY = vy(startV);
+        const refLine = `<line x1="${PAD.l}" y1="${refY}" x2="${W - PAD.r}" y2="${refY}" stroke="rgba(255,255,255,0.1)" stroke-width="1" stroke-dasharray="2,4"/>`;
+        return `<svg viewBox="0 0 ${W} ${H}" preserveAspectRatio="none" style="width:100%;height:${H}px;display:block">
+            ${refLine}
+            ${bhLine}
+            <polyline points="${pts(series)}" fill="none" stroke="${lineCol}" stroke-width="2"/>
+        </svg>`;
+    }
+
+    function _makeDraggable(el, handle) {
+        let sx = 0, sy = 0, sl = 0, st = 0, drag = false;
+        handle.style.cursor = 'grab';
+        const clamp = (v, lo, hi) => Math.max(lo, Math.min(hi, v));
+        const onDown = (cx, cy) => {
+            drag = true;
+            const r = el.getBoundingClientRect();
+            sx = cx; sy = cy; sl = r.left; st = r.top;
+            handle.style.cursor = 'grabbing';
+            el.style.transition = 'none';
+        };
+        const onMove = (cx, cy) => {
+            if (!drag) return;
+            const nl = clamp(sl + cx - sx, 0, window.innerWidth  - el.offsetWidth);
+            const nt = clamp(st + cy - sy, 0, window.innerHeight - el.offsetHeight);
+            el.style.left = nl + 'px'; el.style.top = nt + 'px';
+            el.style.right = 'auto';   el.style.bottom = 'auto';
+        };
+        const onUp = () => { drag = false; handle.style.cursor = 'grab'; };
+        handle.addEventListener('mousedown', e => {
+            if (e.target.closest('.cb-modal-close')) return;
+            e.preventDefault(); onDown(e.clientX, e.clientY);
+        });
+        document.addEventListener('mousemove', e => onMove(e.clientX, e.clientY));
+        document.addEventListener('mouseup', onUp);
+        handle.addEventListener('touchstart', e => {
+            const t = e.touches[0]; onDown(t.clientX, t.clientY);
+        }, { passive: true });
+        handle.addEventListener('touchmove', e => {
+            const t = e.touches[0]; onMove(t.clientX, t.clientY);
+        }, { passive: true });
+        handle.addEventListener('touchend', onUp, { passive: true });
+    }
+
+    async function _loadAndShowCompare(symbol, bubble) {
+        if (!symbol) return;
+
+        console.log("[Chatbot] Ouverture modal comparaison pour:", symbol);
+        const modal = _openCompareModal(symbol);
+        if (!modal) { console.warn("[Chatbot] panel introuvable pour modal"); return; }
+
+        try {
+            const resp = await fetch(`/api/backtest-compare?symbol=${encodeURIComponent(symbol)}`);
+            const data = await resp.json();
+            const body = document.getElementById("cb-modal-body");
+            if (!body) return;
+            if (data.error) {
+                body.innerHTML = `<div class="cb-modal-error">Donnees insuffisantes pour ${symbol}.<br><small>Ce ticker n'est peut-etre pas supporte par nos modeles.</small></div>`;
+            } else {
+                _populateCompareModal(body, symbol, data);
+                // Ajouter un message chat avec les vrais résultats (corrige la reco générique du LLM)
+                _addBacktestSummaryToChat(symbol, data);
+            }
+        } catch (e) {
+            const body = document.getElementById("cb-modal-body");
+            if (body) body.innerHTML = `<div class="cb-modal-error">Erreur de connexion au serveur.</div>`;
+            console.warn("[Chatbot] backtest-compare fetch error:", e);
+        }
+    }
+
+    function _addBacktestSummaryToChat(symbol, data) {
+        const models = data.models || {};
+        const best   = data.best_model;
+        const start  = data.start || 500;
+        const keys   = Object.keys(models);
+        if (keys.length === 0) return;
+
+        const lines = keys.map(k => {
+            const m    = models[k];
+            const gain = m.final - start;
+            const sign = gain >= 0 ? '+' : '';
+            const isBest = k === best;
+            return `• ${m.label} : ${sign}${gain.toFixed(2)}€ (${sign}${m.return_pct}%) sur 500€${isBest ? ' ← meilleur' : ''}`;
+        }).join('\n');
+
+        const bestM     = models[best] || {};
+        const bestGain  = (bestM.final || start) - start;
+        const bestSign  = bestGain >= 0 ? '+' : '';
+        const bestLabel = bestM.label || best;
+
+        const msg = `Voici les resultats reels de la simulation sur les 180 derniers jours pour ${symbol} :\n${lines}\n\nSur la base des donnees historiques, le modele le plus performant pour ${symbol} est **${bestLabel}** (${bestSign}${bestGain.toFixed(2)}€ sur 500€ investis). C'est celui que je recommande pour ${symbol}.`;
+
+        addMessage("bot", msg);
+        _history.push({ role: "assistant", content: msg });
+        _saveCurrentConversation();
+        setTimeout(() => { const m = $("#chatbot-messages"); if (m) m.scrollTop = m.scrollHeight; }, 100);
+    }
+
+    function _openCompareModal(symbol) {
+        const old = document.getElementById("cb-compare-modal");
+        if (old) old.remove();
+
+        const modal = document.createElement("div");
+        modal.id = "cb-compare-modal";
+
+        // Position initiale : à gauche du chatbot panel
+        const panel = document.getElementById("chatbot-panel");
+        if (panel) {
+            const r = panel.getBoundingClientRect();
+            const mw = 440;
+            let left = r.left - mw - 14;
+            if (left < 10) left = Math.min(r.right + 14, window.innerWidth - mw - 10);
+            const top  = Math.max(10, r.top - 10);
+            modal.style.cssText = `left:${left}px;top:${top}px;`;
+        }
+
+        modal.innerHTML = `
+            <div class="cb-modal-header" id="cb-modal-drag-handle">
+                <div class="cb-modal-title">
+                    <i class="fas fa-chart-line"></i>
+                    <span>Si j'avais suivi les conseils — ${symbol}</span>
+                </div>
+                <div style="display:flex;align-items:center;gap:6px">
+                    <span class="cb-modal-drag-hint"><i class="fas fa-arrows-alt"></i></span>
+                    <button class="cb-modal-close" id="cb-modal-close-btn"><i class="fas fa-times"></i></button>
+                </div>
+            </div>
+            <div class="cb-modal-body" id="cb-modal-body">
+                <div class="cb-modal-loading">
+                    <i class="fas fa-spinner fa-spin"></i>
+                    Simulation en cours...<br>
+                    <small>Les 3 modeles sont calcules en parallele (~15s)</small>
+                </div>
+            </div>`;
+
+        document.body.appendChild(modal);
+        document.getElementById("cb-modal-close-btn").addEventListener("click", () => modal.remove());
+        _makeDraggable(modal, document.getElementById("cb-modal-drag-handle"));
+        return modal;
+    }
+
+    function _populateCompareModal(body, symbol, data) {
+        const MODEL_ICON = { lstm: 'fas fa-brain', transformer: 'fas fa-atom', sentiment: 'fas fa-newspaper' };
+        const models = data.models || {};
+        const best   = data.best_model;
+        const start  = data.start || 500;
+        const keys   = Object.keys(models);
+        if (keys.length === 0) {
+            body.innerHTML = `<div class="cb-modal-error">Aucun modele n'a pu simuler ${symbol}.</div>`;
+            return;
+        }
+        const rows = keys.map(k => {
+            const m       = models[k];
+            const isBest  = k === best;
+            const gain    = m.final - start;
+            const gainEur  = (gain >= 0 ? '+' : '') + gain.toFixed(2);
+            const gainCls  = gain >= 0 ? 'cb-cmp-pos' : 'cb-cmp-neg';
+            const retSign  = m.return_pct >= 0 ? '+' : '';
+            const bhSign   = m.bh_return  >= 0 ? '+' : '';
+            const vsPassif = m.final - m.bh_final;
+            const vsEur    = (vsPassif >= 0 ? '+' : '') + vsPassif.toFixed(2);
+            const vsCls    = vsPassif >= 0 ? 'cb-cmp-pos' : 'cb-cmp-neg';
+            const vsText   = vsPassif >= 0
+                ? `<span class="${vsCls}">${vsEur}€ de plus</span> qu'un simple achat sans IA`
+                : `<span class="${vsCls}">${vsEur}€ de moins</span> qu'un simple achat sans IA`;
+            const spark    = _makeSpark(m.series, m.bh_series, 400, 80);
+            return `
+            <div class="cb-modal-model${isBest ? ' cb-modal-model-best' : ''}">
+                <div class="cb-modal-model-head">
+                    <span class="cb-cmp-name"><i class="${MODEL_ICON[k] || 'fas fa-robot'}"></i> ${m.label}</span>
+                    <div style="display:flex;align-items:center;gap:7px">
+                        ${isBest ? '<span class="cb-cmp-badge">Recommande</span>' : ''}
+                        <a href="/mon-suivi?mode=${k}&ticker=${symbol}" class="cb-modal-view-btn" title="Voir dans Mon Suivi">
+                            <i class="fas fa-external-link-alt"></i> Mon Suivi
+                        </a>
+                    </div>
+                </div>
+                <div class="cb-modal-explain">
+                    Si vous aviez investi <strong>${start}€</strong> sur <strong>${symbol}</strong>
+                    depuis le <strong>${m.start_date}</strong> en suivant le modele <strong>${m.label}</strong>,
+                    vous auriez maintenant
+                    <strong class="${gainCls}">${m.final.toFixed(2)}€</strong> — soit
+                    <strong class="${gainCls}">${gainEur}€ (${retSign}${m.return_pct}%)</strong>.
+                    C'est ${vsText} (qui aurait donne <strong>${m.bh_final.toFixed(2)}€</strong>).
+                </div>
+                ${spark ? `<div class="cb-cmp-spark">${spark}<div class="cb-cmp-spark-legend"><span class="cb-cmp-spark-ai">— Modele IA</span><span class="cb-cmp-spark-bh">- - Sans IA (buy&amp;hold)</span></div></div>` : ''}
+                <div class="cb-cmp-grid">
+                    <div class="cb-cmp-cell">
+                        <span class="cb-cmp-lbl">Valeur finale</span>
+                        <span class="cb-cmp-val ${gainCls}">${m.final.toFixed(2)}€</span>
+                    </div>
+                    <div class="cb-cmp-cell">
+                        <span class="cb-cmp-lbl">Taux reussite</span>
+                        <span class="cb-cmp-val">${m.win_rate}%</span>
+                    </div>
+                    <div class="cb-cmp-cell">
+                        <span class="cb-cmp-lbl">Sans IA (buy&amp;hold)</span>
+                        <span class="cb-cmp-val">${m.bh_final.toFixed(2)}€ (${bhSign}${m.bh_return}%)</span>
+                    </div>
+                </div>
+            </div>`;
+        }).join('');
+        const bestLabel = best ? (models[best]?.label || best) : '—';
+        body.innerHTML = `
+            <div class="cb-modal-subtitle">Simulation sur 180 jours · investissement de reference : ${start}€</div>
+            ${rows}
+            <div class="cb-modal-footer">Recommandation : <strong>${bestLabel}</strong> — meilleur rendement sur la periode</div>`;
+    }
+
+    // _showCompareCard gardé pour compat (ne fait rien, modal gere tout)
+    function _showCompareCard() {}
+
+    // ── Détection marqueur investissement ───────────────────────
+
+    const INVEST_RE = /##INVEST##\s*(\{[\s\S]*?\})\s*##/;
+
+    function _parseInvestMarker(text) {
+        const m = text.match(INVEST_RE);
+        if (!m) return null;
+        try { return JSON.parse(m[1]); } catch(_) { return null; }
+    }
+
+    function _stripInvestMarker(text) {
+        return text.replace(INVEST_RE, "").trim();
+    }
+
+    function _showInvestConfirm(bubble, data) {
+        console.log("[Chatbot] _showInvestConfirm appelé:", data);
+        const MODEL_LABELS = { sentiment: "Actualités", lstm: "LSTM", transformer: "Transformer" };
+        const card = document.createElement("div");
+        card.className = "cb-invest-card cb-invest-card-pulse";
+        card.innerHTML = `
+            <div class="cb-invest-header">
+                <i class="fa-solid fa-briefcase"></i>
+                <span>Confirmez l'enregistrement</span>
+            </div>
+            <div class="cb-invest-details">
+                <div class="cb-invest-row"><span>Action</span><strong>${data.symbol}</strong></div>
+                <div class="cb-invest-row"><span>Modèle</span><strong>${MODEL_LABELS[data.model] || data.model}</strong></div>
+                <div class="cb-invest-row"><span>Sens</span><strong class="${data.action==='ACHETER'?'cb-buy':'cb-sell'}">${data.action}</strong></div>
+                <div class="cb-invest-row"><span>Montant</span><strong>${data.amount} €</strong></div>
+            </div>
+            <p class="cb-invest-note">Cliquez sur le bouton ci-dessous pour enregistrer dans Mon Suivi</p>
+            <div class="cb-invest-actions">
+                <button class="cb-invest-confirm">Enregistrer dans Mon Suivi</button>
+                <button class="cb-invest-cancel">Annuler</button>
+            </div>
+        `;
+
+        // Insérer après la bulle bot (avec fallback sur le container)
+        const wrap = bubble ? bubble.closest(".chatbot-msg") : null;
+        if (wrap && wrap.parentNode) {
+            wrap.parentNode.insertBefore(card, wrap.nextSibling);
+        } else {
+            const msgs = $("#chatbot-messages");
+            if (msgs) msgs.appendChild(card);
+        }
+
+        // Forcer l'ouverture du panel si fermé — ouvrir directement sans réinitialiser
+        const panel = $("#chatbot-panel");
+        if (panel && !panel.classList.contains("chatbot-open")) {
+            _positionPanel();
+            panel.classList.remove("chatbot-hidden");
+            panel.classList.add("chatbot-open");
+            const tb = $("#chatbot-toggle");
+            if (tb) tb.classList.add("chatbot-toggle-active");
+        }
+
+        // Badge rouge sur le bouton toggle pour signaler une action en attente
+        const toggleBtn = $("#chatbot-toggle");
+        if (toggleBtn && !toggleBtn.querySelector(".cb-pending-badge")) {
+            const badge = document.createElement("span");
+            badge.className = "cb-pending-badge";
+            badge.textContent = "!";
+            toggleBtn.appendChild(badge);
+        }
+
+        // Scroll précis : amener le bas de la carte dans la zone visible du panel
+        function _scrollCardIntoPanel() {
+            const msgs = $("#chatbot-messages");
+            if (!msgs) return;
+            const msgsRect = msgs.getBoundingClientRect();
+            const cardRect = card.getBoundingClientRect();
+            const overflow = cardRect.bottom - msgsRect.bottom;
+            if (overflow > 0) {
+                msgs.scrollTop += overflow + 16;
+            } else {
+                // Fallback si la carte est déjà dans la zone
+                msgs.scrollTop = msgs.scrollHeight;
+            }
+        }
+        setTimeout(_scrollCardIntoPanel, 100);
+        setTimeout(_scrollCardIntoPanel, 400);
+        setTimeout(_scrollCardIntoPanel, 800);
+
+        // Supprimer le badge quand l'utilisateur interagit avec la carte
+        card.addEventListener("click", function() {
+            const b = toggleBtn && toggleBtn.querySelector(".cb-pending-badge");
+            if (b) b.remove();
+        }, { once: true });
+
+        card.querySelector(".cb-invest-confirm").addEventListener("click", async function () {
+            this.disabled = true;
+            this.textContent = "Enregistrement…";
+            const email = _getUserEmail() || "";
+            console.log("[Chatbot] Enregistrer cliqué — email:", email, "data:", data);
+            try {
+                const resp = await fetch("/api/chat-invest", {
+                    method: "POST",
+                    headers: { "Content-Type": "application/json" },
+                    body: JSON.stringify({ ...data, email }),
+                });
+                const result = await resp.json();
+                console.log("[Chatbot] /api/chat-invest réponse:", resp.status, result);
+                const MODEL_TABS = { sentiment: "Actualités", lstm: "LSTM (prix)", transformer: "Transformer (hybride)" };
+                const tabLabel = MODEL_TABS[data.model] || data.model;
+                if (result.success) {
+                    card.innerHTML = `<div class="cb-invest-success">
+                        Investissement enregistré<br>
+                        <small>${data.symbol} · ${data.amount} € au prix de $${result.price}</small><br>
+                        <small style="color:rgba(0,230,150,0.6)">Retrouvez-le dans <strong>Mon Suivi</strong> › onglet <strong>${tabLabel}</strong></small>
+                        <br><a href="/mon-suivi?mode=${data.model}" class="cb-invest-link">Voir dans Mon Suivi</a>
+                    </div>`;
+                    // Injecter dans l'historique pour que le LLM régénère le marqueur la prochaine fois
+                    _history.push({
+                        role: "user",
+                        content: `[Système] Investissement ${data.symbol} (${data.amount}€, ${data.model}) enregistré avec succès via le marqueur ##INVEST##. Pour tout prochain investissement, vous devez obligatoirement générer un nouveau marqueur ##INVEST## — sans marqueur, rien n'est enregistré.`
+                    });
+                    _saveCurrentConversation();
+                } else {
+                    card.innerHTML = `<div class="cb-invest-error" style="font-size:0.85rem;padding:14px">
+                        Enregistrement échoué<br>
+                        <strong style="color:#ff8080">${result.error || 'données invalides'}</strong><br>
+                        <small>Vérifiez que vous êtes connecté et réessayez.</small>
+                        <br><button onclick="this.closest('.cb-invest-card').remove()" style="margin-top:8px;padding:4px 12px;border-radius:6px;border:1px solid rgba(255,100,100,0.3);background:none;color:#ff8080;cursor:pointer;font-size:0.75rem">Fermer</button>
+                    </div>`;
+                }
+            } catch(err) {
+                console.error("[Chatbot] Erreur fetch invest:", err);
+                card.innerHTML = `<div class="cb-invest-error" style="font-size:0.85rem;padding:14px">
+                    Impossible de contacter le serveur.<br>
+                    <small>Vérifiez votre connexion et réessayez.</small>
+                </div>`;
+            }
+            scrollBottom();
+        });
+
+        card.querySelector(".cb-invest-cancel").addEventListener("click", function () {
+            card.remove();
+        });
+    }
+
+    // ── Extraction investissement (100% client, sans API) ────────
+
+    const _SYMBOL_MAP = {
+        'apple':'AAPL', 'aapl':'AAPL',
+        'microsoft':'MSFT', 'msft':'MSFT',
+        'tesla':'TSLA', 'tsla':'TSLA',
+        'nvidia':'NVDA', 'nvda':'NVDA',
+        'google':'GOOGL', 'alphabet':'GOOGL', 'googl':'GOOGL',
+        'amazon':'AMZN', 'amzn':'AMZN',
+        'meta':'META', 'facebook':'META',
+        'bitcoin':'BTC-USD', 'btc':'BTC-USD', 'crypto':'BTC-USD',
+    };
+    const _MODEL_LIST = [
+        ['lstm','lstm'],['ltsm','lstm'],['bilstm','lstm'],['réseau de neurones','lstm'],
+        ['transformer','transformer'],['transformeur','transformer'],['hybride','transformer'],
+        ['sentiment','sentiment'],['actualit','sentiment'],['news','sentiment'],
+    ];
+
+    // Regex d'intention : .? entre j et ai couvre TOUTES les variantes d'apostrophe
+    const _INTENT_RE = /j.?ai\s*(investi|mis\b|achet|vendu|suivi|fait\b)|enregistr|vas-y/i;
+
+    // Cherche un symbole ou un modèle dans une chaîne basse
+    function _findSymbol(lo) {
+        for (const [k, v] of Object.entries(_SYMBOL_MAP)) {
+            if (lo.includes(k)) return v;
+        }
+        return null;
+    }
+    function _findModel(lo) {
+        for (const [k, v] of _MODEL_LIST) {
+            if (lo.includes(k)) return v;
+        }
+        return null;
+    }
+
+    // history = tableau de messages {role, content} — utilisé comme contexte si le
+    // symbole/modèle n'est pas dans le message actuel
+    function _extractInvestment(text, history) {
+        console.log("[Chatbot] _extractInvestment appelé sur:", text.slice(0,80));
+        if (!_INTENT_RE.test(text)) {
+            console.log("[Chatbot] aucune intention d'investissement détectée");
+            return null;
+        }
+
+        const lo = ' ' + text.toLowerCase() + ' ';
+
+        // Contexte: tous les messages récents (pour trouver le symbole si non répété)
+        const ctxLo = lo + ' ' + (history || []).slice(-10)
+            .map(m => (m.content || '').toLowerCase()).join(' ') + ' ';
+
+        // Symbol: d'abord dans le message actuel, puis dans le contexte
+        const symbol = _findSymbol(lo) || _findSymbol(ctxLo);
+
+        // Model: idem
+        const model = _findModel(lo) || _findModel(ctxLo);
+
+        // Amount : cherche un nombre + €/euro dans le message actuel
+        let amount = null;
+        const m1 = text.match(/(\d[\d\s]*(?:[.,]\d{1,2})?)\s*(?:€|euros?)/i);
+        if (m1) amount = parseFloat(m1[1].replace(/\s/g,'').replace(',','.'));
+        if (!amount) {
+            const m2 = text.match(/(?:€|euros?)\s*(\d[\d\s]*(?:[.,]\d{1,2})?)/i);
+            if (m2) amount = parseFloat(m2[1].replace(/\s/g,'').replace(',','.'));
+        }
+        if (!amount) {
+            // fallback : plus grand nombre dans le texte
+            const nums = text.match(/\b(\d{2,7}(?:[.,]\d{1,2})?)\b/g);
+            if (nums) amount = Math.max(...nums.map(n => parseFloat(n.replace(',','.'))));
+        }
+
+        const action = /vend|short|baissier|sold/i.test(text) ? 'VENDRE' : 'ACHETER';
+
+        console.log("[Chatbot] extraction →", {symbol, model, amount, action});
+        if (symbol && amount > 0) {
+            return { symbol, model: model || 'lstm', action, amount };
+        }
+        console.log("[Chatbot] extraction échouée — symbol:", symbol, "amount:", amount);
+        return null;
+    }
+
+    // ── Envoi du message ─────────────────────────────────────────
+
+    async function sendMessage() {
+        if (_isStreaming) return;
+        const input = $("#chatbot-input");
+        if (!input) return;
+        const text = input.value.trim();
+        if (!text) return;
+
+        console.log("[Chatbot] sendMessage appelé:", text.slice(0, 60));
+
+        const welcome = $("#chatbot-welcome");
+        if (welcome) welcome.remove();
+
+        input.value  = "";
+        _isStreaming = true;
+        addMessage("user", text);
+        _history.push({ role: "user", content: text });
+        showTyping();
+
+        // Extraction AVANT le fetch — message actuel + historique pour le contexte
+        const pendingInvest  = _extractInvestment(text, _history);
+        const isCompareQuery = _COMPARE_RE.test(text);
+        const compareSymbol  = isCompareQuery ? _extractCompareSymbol(text, _history) : null;
+        console.log("[Chatbot] pendingInvest:", pendingInvest, "| compareSymbol:", compareSymbol);
+
+        try {
+            const response = await fetch("/api/chat", {
+                method: "POST",
+                headers: { "Content-Type": "application/json" },
+                body: JSON.stringify({ messages: _history }),
+            });
+            if (!response.ok) throw new Error("Erreur serveur " + response.status);
+
+            removeTyping();
+            const botBubble = addMessage("bot", "");
+            if (!botBubble) return;
+
+            const reader  = response.body.getReader();
+            const decoder = new TextDecoder();
+            let fullText  = "";
+
+            while (true) {
+                const { done, value } = await reader.read();
+                if (done) break;
+                for (const line of decoder.decode(value, { stream: true }).split("\n")) {
+                    if (!line.startsWith("data: ")) continue;
+                    const chunk = line.slice(6).trim();
+                    if (chunk === "[DONE]") break;
+                    try {
+                        const p = JSON.parse(chunk);
+                        if (p.text)  { fullText += p.text; botBubble.textContent = fullText; scrollBottom(); }
+                        if (p.error) { botBubble.textContent = p.error; }
+                    } catch (_) {}
+                }
+            }
+
+            // Sauvegarder la réponse bot dans l'historique
+            const savedText = fullText || botBubble.textContent || "";
+            _history.push({ role: "assistant", content: savedText });
+            if (_history.length > 40) _history = _history.slice(-40);
+            _saveCurrentConversation();
+
+            // Toujours stripper le marqueur ##INVEST## du texte affiché (quel que soit l'intent)
+            botBubble.textContent = _stripInvestMarker(savedText);
+
+            // 1. Marqueur inline du LLM (prioritaire)
+            const markerData = _parseInvestMarker(savedText);
+            const hadInvestIntent = _INTENT_RE.test(text);
+            if (markerData && markerData.amount > 0) {
+                if (hadInvestIntent) {
+                    console.log("[Chatbot] Marqueur LLM détecté:", markerData);
+                    _showInvestConfirm(botBubble, markerData);
+                } else {
+                    console.log("[Chatbot] Marqueur ignoré — pas d'intention dans le message utilisateur");
+                }
+            } else if (markerData && markerData.amount <= 0) {
+                console.log("[Chatbot] Marqueur ignoré — montant nul ou manquant");
+            } else if (pendingInvest) {
+                // 2. Extraction client sur le message utilisateur (toujours fiable)
+                console.log("[Chatbot] Affichage carte confirmation (client):", pendingInvest);
+                _showInvestConfirm(botBubble, pendingInvest);
+            } else {
+                // 3. Détection d'un faux-positif : le bot prétend avoir enregistré sans marqueur
+                const falseSave = /enregistr|sauvegard|c.est fait|c.est not|confirm/i.test(savedText);
+                if (falseSave && pendingInvest === null && /investi|achet|vendu|mis\b|suivi/i.test(text)) {
+                    addMessage("bot", "Pour enregistrer votre investissement, j'ai besoin des détails complets : quelle action, quel modèle (LSTM / Transformer / Actualités) et quel montant ?");
+                }
+            }
+
+            // 4. Comparaison des modèles — afficher la carte après la réponse LLM
+            if (compareSymbol) {
+                _loadAndShowCompare(compareSymbol, botBubble);
+            }
+
+        } catch (err) {
+            removeTyping();
+            addMessage("bot", "Impossible de contacter l'assistant.");
+            console.error("[Chatbot]", err);
+        } finally {
+            _isStreaming = false;
+        }
+    }
+
+    // ── Toggle panel ─────────────────────────────────────────────
+
+    function togglePanel() {
+        const panel = $("#chatbot-panel");
+        const btn   = $("#chatbot-toggle");
+        if (!panel || !btn) return;
+
+        const isOpen = panel.classList.contains("chatbot-open");
+        if (isOpen) {
+            panel.classList.remove("chatbot-open");
+            panel.classList.add("chatbot-hidden");
+            btn.classList.remove("chatbot-toggle-active");
+        } else {
+            _positionPanel();
+            panel.classList.remove("chatbot-hidden");
+            panel.classList.add("chatbot-open");
+            btn.classList.add("chatbot-toggle-active");
+
+            // Re-init à chaque ouverture (re-vérifie la connexion)
+            if (!_initialized) {
+                _initialized = true;
+            }
+            _initSession();
+
+            scrollBottom();
+            setTimeout(_initPanelDrag, 50);
+            setTimeout(() => { const i = $("#chatbot-input"); if (i) i.focus(); }, 320);
+        }
+    }
+
+    // Charge la dernière conversation ou crée une nouvelle
+    function _initSession() {
+        // ── Vérification connexion ──────────────────────────────
+        if (!_getUserEmail()) {
+            _showLockedState();
+            return;
+        }
+
+        _updateUserBadge();
+        const store = _loadStore();
+
+        if (store.activeId) {
+            const conv = store.list.find(c => c.id === store.activeId);
+            if (conv && conv.messages.length > 0) {
+                _activeId = conv.id;
+                _history  = conv.messages;
+                const container = $("#chatbot-messages");
+                if (container) {
+                    const w = container.querySelector("#chatbot-welcome");
+                    if (w) w.remove();
+                    _history.forEach(function (msg) {
+                        const role   = msg.role === "assistant" ? "bot" : msg.role;
+                        const wrap   = document.createElement("div");
+                        wrap.className = "chatbot-msg chatbot-msg-" + role;
+                        const bubble = document.createElement("div");
+                        bubble.className   = "chatbot-bubble";
+                        bubble.textContent = msg.content;
+                        wrap.appendChild(bubble);
+                        container.appendChild(wrap);
+                    });
+                }
+                scrollBottom();
+                return;
+            }
+        }
+        _activeId = "conv_" + Date.now();
+    }
+
+    function _showLockedState() {
+        // Remplacer les messages par un message de verrouillage
+        const container = $("#chatbot-messages");
+        if (container) {
+            container.innerHTML = `
+                <div class="cb-locked-wrap">
+                    <div class="cb-locked-icon"><i class="fa-solid fa-lock"></i></div>
+                    <div class="cb-locked-title">Connexion requise</div>
+                    <div class="cb-locked-desc">
+                        Le Conseiller IA est réservé aux membres connectés.
+                        Connectez-vous pour accéder à l'assistant.
+                    </div>
+                    <a href="/login" class="cb-locked-btn">
+                        <i class="fa-solid fa-right-to-bracket"></i> Se connecter
+                    </a>
+                </div>
+            `;
+        }
+        // Désactiver l'input et les boutons
+        const input   = $("#chatbot-input");
+        const send    = $("#chatbot-send");
+        const mic     = $("#chatbot-mic");
+        const newBtn  = $("#chatbot-new-btn");
+        const histBtn = $("#chatbot-history-btn");
+        if (input)   { input.disabled   = true; input.placeholder = "Connectez-vous pour utiliser l'assistant…"; }
+        if (send)    send.disabled    = true;
+        if (mic)     mic.disabled     = true;
+        if (newBtn)  newBtn.disabled  = true;
+        if (histBtn) histBtn.disabled = true;
+    }
+
+    function _updateUserBadge() {
+        const email = _getUserEmail();
+        const info  = $(".chatbot-header-info");
+        if (!info || !email) return;
+        const old = info.querySelector(".chatbot-user-badge");
+        if (old) old.remove();
+        const badge = document.createElement("div");
+        badge.className   = "chatbot-user-badge";
+        badge.textContent = email.split("@")[0];
+        info.appendChild(badge);
+    }
+
+    // ── Drag panel ───────────────────────────────────────────────
+
+    function _positionPanel() {
+        const panel = $("#chatbot-panel");
+        const btn   = $("#chatbot-toggle");
+        if (!panel || !btn) return;
+        const saved = _loadPanelPos();
+        if (saved) { _applyPanelPos(saved.left, saved.top); return; }
+        const r = btn.getBoundingClientRect();
+        const panelW = 380, panelH = 580, m = 12;
+        const vw = window.innerWidth, vh = window.innerHeight;
+        let left = r.left + r.width / 2 - panelW / 2;
+        let top  = r.top - panelH - m;
+        if (top  < m)                  top  = r.bottom + m;
+        if (left + panelW > vw - m)    left = vw - panelW - m;
+        if (left < m)                  left = m;
+        if (top  + panelH > vh - m)    top  = vh - panelH - m;
+        _applyPanelPos(left, top);
+    }
+
+    function _applyPanelPos(l, t) {
+        const p = $("#chatbot-panel");
+        if (!p) return;
+        p.style.left = l+"px"; p.style.top = t+"px"; p.style.right = "auto"; p.style.bottom = "auto";
+    }
+    function _savePanelPos(l, t) { try { localStorage.setItem(PANEL_POS_KEY, JSON.stringify({left:l,top:t})); } catch(_){} }
+    function _loadPanelPos() {
+        try {
+            const raw = localStorage.getItem(PANEL_POS_KEY);
+            if (!raw) return null;
+            const p = JSON.parse(raw); const vw=window.innerWidth,vh=window.innerHeight;
+            if (p.left<0||p.top<0||p.left>vw-100||p.top>vh-100) return null; return p;
+        } catch(_){ return null; }
+    }
+
+    function _initPanelDrag() {
+        const panel = $("#chatbot-panel"), header = $("#chatbot-header");
+        if (!panel||!header||header._panelDragBound) return;
+        header._panelDragBound = true;
+        let sx,sy,sl,st,drag=false;
+        function onStart(e) {
+            if (e.target.closest("#chatbot-close")||e.target.closest("#chatbot-history-btn")||
+                e.target.closest("#chatbot-new-btn")) return;
+            const pt=e.touches?e.touches[0]:e; sx=pt.clientX; sy=pt.clientY;
+            const r=panel.getBoundingClientRect(); sl=r.left; st=r.top; drag=false;
+            document.addEventListener("mousemove",onMove); document.addEventListener("mouseup",onEnd);
+            document.addEventListener("touchmove",onMove,{passive:false}); document.addEventListener("touchend",onEnd);
+        }
+        function onMove(e) {
+            const pt=e.touches?e.touches[0]:e; const dx=pt.clientX-sx,dy=pt.clientY-sy;
+            if (!drag&&Math.hypot(dx,dy)>4){drag=true;panel.style.transition="none";panel.style.opacity="0.92";}
+            if (!drag) return; if (e.cancelable) e.preventDefault();
+            const vw=window.innerWidth,vh=window.innerHeight,pw=panel.offsetWidth,ph=panel.offsetHeight,m=8;
+            _applyPanelPos(Math.max(m,Math.min(sl+dx,vw-pw-m)),Math.max(m,Math.min(st+dy,vh-ph-m)));
+        }
+        function onEnd() {
+            document.removeEventListener("mousemove",onMove); document.removeEventListener("mouseup",onEnd);
+            document.removeEventListener("touchmove",onMove); document.removeEventListener("touchend",onEnd);
+            if (drag){drag=false;panel.style.transition="";panel.style.opacity="";
+                const r=panel.getBoundingClientRect(); _savePanelPos(r.left,r.top);}
+        }
+        header.addEventListener("mousedown",onStart); header.addEventListener("touchstart",onStart,{passive:true});
+    }
+
+    // ── Drag bouton ──────────────────────────────────────────────
+
+    function _initDrag() {
+        const btn = $("#chatbot-toggle");
+        if (!btn||btn._dragBound) return; btn._dragBound=true;
+        let sx,sy,sl,st,dragging=false;
+        const saved=_loadPos();
+        if (saved){_applyBtnPos(saved.left,saved.top);}
+        else{_applyBtnPos(window.innerWidth-88,window.innerHeight-88);}
+        function onStart(e){
+            const pt=e.touches?e.touches[0]:e; sx=pt.clientX;sy=pt.clientY;
+            const r=btn.getBoundingClientRect(); sl=r.left;st=r.top; dragging=false;
+            document.addEventListener("mousemove",onMove); document.addEventListener("mouseup",onEnd);
+            document.addEventListener("touchmove",onMove,{passive:false}); document.addEventListener("touchend",onEnd);
+        }
+        function onMove(e){
+            const pt=e.touches?e.touches[0]:e; const dx=pt.clientX-sx,dy=pt.clientY-sy;
+            if (!dragging&&Math.hypot(dx,dy)>5){dragging=true;btn.classList.add("cb-dragging");}
+            if (!dragging) return; if(e.cancelable)e.preventDefault();
+            const vw=window.innerWidth,vh=window.innerHeight,sz=btn.offsetWidth,m=8;
+            _applyBtnPos(Math.max(m,Math.min(sl+dx,vw-sz-m)),Math.max(m,Math.min(st+dy,vh-sz-m)));
+        }
+        function onEnd(){
+            document.removeEventListener("mousemove",onMove); document.removeEventListener("mouseup",onEnd);
+            document.removeEventListener("touchmove",onMove); document.removeEventListener("touchend",onEnd);
+            if(dragging){btn.classList.remove("cb-dragging");_snapToEdge();dragging=false;}
+            else{togglePanel();}
+        }
+        btn.addEventListener("mousedown",onStart); btn.addEventListener("touchstart",onStart,{passive:true});
+    }
+
+    function _snapToEdge(){
+        const btn=$("#chatbot-toggle"); if(!btn) return;
+        const r=btn.getBoundingClientRect(),vw=window.innerWidth,vh=window.innerHeight,sz=r.width,m=12;
+        const left=(r.left+sz/2<vw/2)?m:vw-sz-m, top=Math.max(m,Math.min(r.top,vh-sz-m));
+        btn.style.transition="left 0.35s cubic-bezier(0.22,1,0.36,1),top 0.2s ease";
+        _applyBtnPos(left,top); setTimeout(()=>{btn.style.transition="";},400); _savePos(left,top);
+        const panel=$("#chatbot-panel");
+        if(panel&&panel.classList.contains("chatbot-open")) setTimeout(_positionPanel,50);
+    }
+    function _applyBtnPos(l,t){const btn=$("#chatbot-toggle");if(!btn)return;btn.style.left=l+"px";btn.style.top=t+"px";btn.style.right="auto";btn.style.bottom="auto";}
+    function _savePos(l,t){try{localStorage.setItem(POS_KEY,JSON.stringify({left:l,top:t}));}catch(_){}}
+    function _loadPos(){
+        try{const raw=localStorage.getItem(POS_KEY);if(!raw)return null;const p=JSON.parse(raw);const vw=window.innerWidth,vh=window.innerHeight;
+            if(p.left<0||p.top<0||p.left>vw-40||p.top>vh-40)return null;return p;}catch(_){return null;}
+    }
+
+    // ── Event delegation ─────────────────────────────────────────
+
+    function attachGlobalListeners() {
+        // Utilise une propriété sur document pour éviter les doublons
+        // si le script est chargé deux fois (Dash debug/hot-reload)
+        if (document._chatbotBound) return;
+        document._chatbotBound = true;
+        _bound = true;
+
+        document.addEventListener("click", function (e) {
+            if (e.target.closest("#chatbot-close"))        { togglePanel(); return; }
+            if (e.target.closest("#chatbot-send"))         { sendMessage(); return; }
+            if (e.target.closest("#chatbot-mic"))          { toggleVoice(); return; }
+            if (e.target.closest("#chatbot-history-btn"))  { _toggleHistoryView(); return; }
+            if (e.target.closest("#chatbot-new-btn") ||
+                e.target.closest("#chatbot-new-btn2"))     { _newConversation(); return; }
+        });
+
+        document.addEventListener("keydown", function (e) {
+            if (e.target&&e.target.id==="chatbot-input"&&e.key==="Enter"&&!e.shiftKey) {
+                e.preventDefault(); sendMessage();
+            }
+        });
+
+        document.addEventListener("mousedown", function (e) {
+            const panel=$("#chatbot-panel"),btn=$("#chatbot-toggle");
+            if (!panel||panel.classList.contains("chatbot-hidden")) return;
+            if (!panel.contains(e.target)&&btn&&!btn.contains(e.target)) togglePanel();
+        });
+    }
+
+    // ── Init ─────────────────────────────────────────────────────
+
+    function init() { attachGlobalListeners(); _initDrag(); }
+
+    if (document.readyState==="loading") { document.addEventListener("DOMContentLoaded",init); }
+    else { init(); }
+
+    const _obs = new MutationObserver(function(){const btn=$("#chatbot-toggle");if(btn&&!btn._dragBound)_initDrag();});
+    _obs.observe(document.body,{childList:true,subtree:true});
+
+    window.addEventListener("resize",function(){
+        const btn=$("#chatbot-toggle"); if(!btn)return;
+        const r=btn.getBoundingClientRect(),vw=window.innerWidth,vh=window.innerHeight,sz=btn.offsetWidth,m=12;
+        _applyBtnPos(Math.max(m,Math.min(r.left,vw-sz-m)),Math.max(m,Math.min(r.top,vh-sz-m)));
+        const panel=$("#chatbot-panel");
+        if(panel&&panel.classList.contains("chatbot-open"))_positionPanel();
+    });
+
+})();

Interface Graphique/pages/admin/testimonials.py

@@ -36,8 +36,8 @@ def refresh_pending(n):
                 html.Span(f"Gain: +{gain}€" if gain else ""),
             ]),
             html.Div(className="testimonial-actions", children=[
-                html.Button("✅ Approuver", id=f"approve-{t_id}", className="approve-btn"),
-                html.Button("❌ Rejeter", id=f"reject-{t_id}", className="reject-btn"),
+                html.Button("Approuver", id=f"approve-{t_id}", className="approve-btn"),
+                html.Button("Rejeter", id=f"reject-{t_id}", className="reject-btn"),
             ]),
         ])
         cards.append(card)

Interface Graphique/pages/analyse_page.py

@@ -531,7 +531,6 @@ def update_news_feed(data, filter_ticker, filter_sentiment):
     items = []
     for _, row in df.iterrows():
         sentiment = row.get('sentiment', 'neutral')
-        score = row.get('score_sentiment', 0)
         ticker = row.get('symbol', '?')
         title = str(row.get('titre', ''))[:200]
         source = str(row.get('source', 'Unknown'))
@@ -571,8 +570,6 @@ def update_news_feed(data, filter_ticker, filter_sentiment):
                         html.Div(title, className="analyse-news-title"),
                         html.Div(className="analyse-news-source-row", children=[
                             html.Span(source, className="analyse-news-source"),
-                            html.Span(" · "),
-                            html.Span(f"Score IA: {score:+.3f}", className="analyse-news-score"),
                         ])
                     ]),
                     html.Div(className="analyse-news-badge-col", children=[

Interface Graphique/pages/face_login.py

@@ -19,7 +19,7 @@ layout = html.Div(className="auth-page login-page", children=[
             
             # Message explicatif
             html.Div(style={"text-align": "center", "margin-bottom": "20px", "color": "var(--accent-2)"}, 
-                    children="📸 Regarde la caméra pour te connecter automatiquement"),
+                    children="Regarde la caméra pour te connecter automatiquement"),
             
             # Zone caméra
             html.Div(className="camera-container", children=[
@@ -30,13 +30,13 @@ layout = html.Div(className="auth-page login-page", children=[
                     
                 ),
                 html.Div(id="face-login-status", className="camera-status no-face", 
-                        children="⏳ Initialisation..."),
+                        children="Initialisation..."),
                 html.Div(className="camera-overlay")  # Guide ovale
             ]),
             
             # Bouton d'annulation
             html.Button(
-                "⬅️ RETOUR", 
+                "RETOUR",
                 id="face-login-back-btn",
                 className="auth-btn",
                 style={"margin-top": "20px", "background": "linear-gradient(135deg, #8be9ff, #00f0ff)"}
@@ -65,7 +65,7 @@ def get_all_users_with_faces():
     cursor.execute("SELECT email, face_image FROM users WHERE face_image IS NOT NULL AND face_image != ''")
     results = cursor.fetchall()
     conn.close()
-    print(f"📊 {len(results)} utilisateurs avec image faciale trouvés")
+    print(f"{len(results)} utilisateurs avec image faciale trouvés")
     for email, img in results:
         print(f"  - {email}: {len(img) if img else 0} caractères")
     return results
@@ -76,15 +76,15 @@ clientside_callback(
     """
     function(n_intervals) {
         if (window.videoStream) {
-            return "📸 Caméra déjà active";
+            return "Caméra déjà active";
         }
-        
+
         var videoElement = document.getElementById('face-login-camera');
         if (videoElement && window.startCamera) {
             window.startCamera('face-login-camera');
-            return "📸 Caméra activée - Recherche de visage...";
+            return "Caméra activée - Recherche de visage...";
         }
-        return "⏳ Initialisation...";
+        return "Initialisation...";
     }
     """,
     Output("face-login-status", "children"),
@@ -123,14 +123,14 @@ def process_face_login(face_data):
         return no_update, no_update, no_update, no_update, no_update, no_update
     
     try:
-        print(f"🔍 Image capturée reçue ({len(face_data)} caractères)")
+        print(f"Image capturée reçue ({len(face_data)} caractères)")
         
         # Récupérer tous les utilisateurs avec images
         users = get_all_users_with_faces()
         
         if len(users) == 0:
             return (no_update, no_update, no_update,
-                   "❌ Aucun visage enregistré", "camera-status no-face",
+                   "Aucun visage enregistré", "camera-status no-face",
                    no_update)
         
         # Chercher le meilleur match
@@ -144,7 +144,7 @@ def process_face_login(face_data):
                 # Comparer les images
                 match, score = compare_faces(face_data, stored_image, threshold=SIMILARITY_THRESHOLD)
                 
-                print(f"📊 Similarité avec {email}: {score:.2%}")
+                print(f"Similarité avec {email}: {score:.2%}")
                 
                 if score > best_score:
                     best_score = score
@@ -152,28 +152,28 @@ def process_face_login(face_data):
                     
                     if match:
                         best_match = email
-                        print(f"  ✅ MATCH TROUVÉ!")
+                        print(f"  MATCH TROUVÉ!")
         
         if best_match or best_score > SIMILARITY_THRESHOLD:
             email_to_use = best_match if best_match else best_email
-            print(f"🎉 Connexion réussie pour {email_to_use} (score: {best_score:.2%})")
+            print(f"Connexion réussie pour {email_to_use} (score: {best_score:.2%})")
             
             return ({"email": email_to_use}, 
-                   f"✅ Bienvenue {email_to_use.split('@')[0]} !", "auth-message success",
-                   f"✅ Visage reconnu ({best_score:.0%})", "camera-status face-detected",
+                   f"Bienvenue {email_to_use.split('@')[0]} !", "auth-message success",
+                   f"Visage reconnu ({best_score:.0%})", "camera-status face-detected",
                    "/")
         else:
-            print(f"❌ Aucun match trouvé (meilleur score: {best_score:.2%})")
+            print(f"Aucun match trouvé (meilleur score: {best_score:.2%})")
             return (no_update, no_update, no_update,
-                   f"❌ Visage non reconnu ({best_score:.0%})", "camera-status no-face",
+                   f"Visage non reconnu ({best_score:.0%})", "camera-status no-face",
                    no_update)
             
     except Exception as e:
-        print(f"❌ Erreur analyse faciale: {e}")
+        print(f"Erreur analyse faciale: {e}")
         import traceback
         traceback.print_exc()
-        return (no_update, f"❌ Erreur: {str(e)}", "auth-message error",
-               "❌ Erreur de scan", "camera-status no-face",
+        return (no_update, f"Erreur: {str(e)}", "auth-message error",
+               "Erreur de scan", "camera-status no-face",
                no_update)
 
 # Callback pour le bouton retour

Interface Graphique/pages/home.py

@@ -247,9 +247,9 @@ def _transformer_card(ticker, company, pred, target_href="/mon-suivi"):
     dir_str    = f"{dir_prob*100:.1f}%" if dir_prob is not None else "N/A"
     direction  = "monter" if rec == 'ACHETER' else "baisser"
     tip_body   = (
-        f"Notre Transformer hybride combine {60} jours d'historique de prix et les dernières "
+        f"Notre Transformer hybride combine 60 jours d'historique de prix et les dernières "
         f"actualités financières sur {company}. "
-        f"Il prédit que le cours va {direction} de {abs(return_pct):.3f}% avec une probabilité directionnelle de {dir_str}."
+        f"Il prédit que le cours va {direction} de {abs(return_pct):.3f}% dans les prochains jours."
     ) if return_pct is not None else f"Données insuffisantes pour {company} — le modèle Transformer n'a pas pu produire de signal."
 
     return html.Div(className=f"home-pred-card {_REC_CARD.get(rec, 'home-pred-watch')}", children=[
@@ -282,7 +282,7 @@ def _transformer_card(ticker, company, pred, target_href="/mon-suivi"):
                 html.P(tip_body, className="home-pred-tooltip-body"),
                 html.Div(className="home-pred-tooltip-footer", children=[
                     html.I(className="fas fa-atom"),
-                    html.Span(f" Prob. directionnelle : {dir_str} · {ret_str}"),
+                    html.Span(f" Rendement prédit : {ret_str} · Transformer hybride"),
                 ]),
             ]),
         ]),

Interface Graphique/pages/login.py

@@ -189,7 +189,7 @@ def login(n_clicks, email, password, remember):
         return no_update, no_update, no_update, no_update, no_update
 
     if not email or not password:
-        return no_update, "❌ Email et mot de passe requis", "auth-message error", no_update, no_update
+        return no_update, "Email et mot de passe requis", "auth-message error", no_update, no_update
 
     user = verify_user(email, password)
 
@@ -200,9 +200,9 @@ def login(n_clicks, email, password, remember):
             if (remember and "remember" in remember)
             else {}
         )
-        return session_data, "✅ Connexion réussie !", "auth-message success", "/", remember_data
+        return session_data, "Connexion réussie !", "auth-message success", "/", remember_data
 
-    return no_update, "❌ Email ou mot de passe incorrect", "auth-message error", no_update, no_update
+    return no_update, "Email ou mot de passe incorrect", "auth-message error", no_update, no_update
 
 # ── Pré-remplir l'email si redirigé depuis le signup ──
 @callback(

Interface Graphique/pages/mon_suivi.py

@@ -868,6 +868,7 @@ layout = html.Div(className="suivi-page", children=[
     dcc.Store(id="suivi-modal-action", data="ACHAT"),
     dcc.Store(id="suivi-refresh", data=0),
     dcc.Store(id="suivi-backtest-ticker-store", data="AAPL"),
+    dcc.Store(id="suivi-url-ticker"),
     dcc.Download(id="suivi-report-download"),
     dcc.Interval(id="suivi-init", interval=300, n_intervals=0, max_intervals=1),
     dcc.Interval(id="suivi-auto", interval=5 * 60 * 1000, n_intervals=0),
@@ -1163,7 +1164,7 @@ def toggle_suivi_mode(_s, _l, _t):
     Output("suivi-mode",            "data",       allow_duplicate=True),
     Output("suivi-section01-sub",   "children",   allow_duplicate=True),
     Input("url", "search"),
-    prevent_initial_call=True,
+    prevent_initial_call="initial_duplicate",
 )
 def sync_mode_from_url(search):
     active = "home-mode-btn home-mode-active"
@@ -1177,14 +1178,52 @@ def sync_mode_from_url(search):
     return no_update, no_update, no_update, no_update, no_update
 
 
+@callback(
+    Output("suivi-url-ticker", "data"),
+    Input("url", "search"),
+    prevent_initial_call=False,
+)
+def read_ticker_from_url(search):
+    if not search:
+        return None
+    try:
+        from urllib.parse import parse_qs
+        params = parse_qs(search.lstrip('?'))
+        t = params.get('ticker', [None])[0]
+        return t.upper() if t else None
+    except Exception:
+        return None
+
+
+@callback(
+    Output("suivi-backtest-bg",           "className",  allow_duplicate=True),
+    Output("suivi-backtest-ticker-store", "data",       allow_duplicate=True),
+    Input("suivi-pred-store", "data"),
+    State("suivi-url-ticker", "data"),
+    prevent_initial_call=True,
+)
+def auto_open_backtest_from_url(pred_data, url_ticker):
+    if not url_ticker or not pred_data:
+        return no_update, no_update
+    if url_ticker not in pred_data:
+        return no_update, no_update
+    return "suivi-modal-visible", url_ticker
+
+
 @callback(
     Output("suivi-pred-store", "data"),
     Input("suivi-init",  "n_intervals"),
     Input("suivi-auto",  "n_intervals"),
     Input("suivi-mode",  "data"),
+    State("url",         "search"),
 )
-def load_pred_data(_init, _auto, mode):
+def load_pred_data(_init, _auto, mode, url_search):
     from concurrent.futures import ThreadPoolExecutor, as_completed as _as_completed
+    # L'URL est prioritaire sur le store (évite le flash "sentiment" au chargement)
+    if url_search:
+        if "mode=lstm"        in url_search: mode = "lstm"
+        elif "mode=transformer" in url_search: mode = "transformer"
+        elif "mode=sentiment"   in url_search: mode = "sentiment"
     mode = mode or "sentiment"
 
     if mode == "lstm":
@@ -1305,9 +1344,9 @@ def render_predictions(pred_data, session):
         'NEUTRE': "Pas encore — attendez",
     }
     _tip_body = {
-        'HAUSSIER': "Notre IA a analysé les dernières actualités et les signaux sont positifs. Les investisseurs réagissent bien — c'est un bon moment pour investir.",
-        'BAISSIER': "Les actualités récentes sont mauvaises pour cette entreprise. Notre IA a repéré des signaux négatifs — le cours risque de baisser. Mieux vaut attendre.",
-        'NEUTRE': "Les signaux sont encore flous. Notre IA n'est pas assez sûre pour te donner un conseil clair. Reviens dans quelques heures.",
+        'HAUSSIER': "Notre IA a analysé l'historique de prix et les actualités récentes. Les signaux sont positifs — c'est un bon moment pour investir.",
+        'BAISSIER': "Notre IA a analysé l'historique de prix et les actualités récentes. Les signaux sont négatifs — le cours risque de baisser. Mieux vaut attendre.",
+        'NEUTRE': "Les signaux sont encore flous. Notre IA n'est pas assez sûre pour donner un conseil clair. Reviens dans quelques heures.",
     }
 
     # Itérer sur COMPANIES (ordre fixe) plutôt que pred_data
@@ -1400,7 +1439,7 @@ def render_predictions(pred_data, session):
                     html.Div(className="suivi-pred-tooltip-footer", children=[
                         html.I(className=date_icon),
                         html.Span(
-                            f" Prob. directionnelle : {data.get('dir_prob', 0)*100:.0f}%" if is_transformer
+                            f" Rendement prédit : {return_pct:+.3f}%" if is_transformer and return_pct is not None
                             else (f" Rendement prédit : {return_pct:+.3f}%" if is_lstm and return_pct is not None
                             else f" Valable jusqu'au {data.get('signal_valid_to', '—')}")
                         ),
@@ -1500,7 +1539,7 @@ def _action_hint(action, signal):
     else:
         label = "Vous vendez — vous misez sur une baisse du prix"
     icon_cls = "fas fa-circle-check suivi-hint-ok" if follows else "fas fa-triangle-exclamation suivi-hint-warn"
-    suffix = " (suit le conseil IA ✓)" if follows else " (à l'opposé du conseil IA)"
+    suffix = " (suit le conseil IA)" if follows else " (à l'opposé du conseil IA)"
     return html.Span([html.I(className=icon_cls), f"  {label}{suffix}"], className="suivi-action-hint-inner")
 
 
@@ -2128,7 +2167,7 @@ def render_perf_chart(ticker, _refresh, mode, session):
             + f"<br><b>Résultat : {'+' if pnl >= 0 else ''}{pnl:,.2f} € ({pnl_pct:+.2f}%)</b>"
         )
 
-        label = f"{'✓ Gagné' if pnl >= 0 else '✗ Perdu'} {pnl:+.0f}€"
+        label = f"{'Gagné' if pnl >= 0 else 'Perdu'} {pnl:+.0f}€"
         color = '#00ff87' if pnl >= 0 else '#ff4d6d'
 
         # Ligne verticale au moment de l'investissement
@@ -2168,7 +2207,7 @@ def render_perf_chart(ticker, _refresh, mode, session):
         fig.add_trace(go.Scatter(
             x=win_x, y=win_y,
             mode='markers',
-            name='✓ Vous avez gagné',
+            name='Vous avez gagné',
             marker=dict(color='#00ff87', size=14, symbol='triangle-up',
                         line=dict(color='#010214', width=1.5)),
             hovertemplate='%{customdata}<extra></extra>',
@@ -2179,7 +2218,7 @@ def render_perf_chart(ticker, _refresh, mode, session):
         fig.add_trace(go.Scatter(
             x=loss_x, y=loss_y,
             mode='markers',
-            name='✗ Vous avez perdu',
+            name='Vous avez perdu',
             marker=dict(color='#ff4d6d', size=14, symbol='triangle-down',
                         line=dict(color='#010214', width=1.5)),
             hovertemplate='%{customdata}<extra></extra>',

Interface Graphique/pages/profil.py

@@ -325,7 +325,7 @@ def load_profil(_init, pathname, session):
         _sec_item(
             "fas fa-camera" if face else "fas fa-camera-slash",
             "Connexion faciale",
-            "Activée ✓" if face else "Non configurée",
+            "Activée" if face else "Non configurée",
             color="#00ff87" if face else None,
         ),
         _sec_item("fas fa-lock", "Mot de passe", "••••••••", note="Modifiable depuis la page de connexion"),

Interface Graphique/pages/signup.py

@@ -117,7 +117,7 @@ layout = html.Div(className="auth-page", style={"paddingTop": "100px"}, children
                         html.Strong("Reconnaissance faciale"),
                         html.Span("Recommandé", className="signup-badge-rec"),
                     ]),
-                    html.P("Connexion instantanée sans mot de passe, 100 % en local",
+                    html.P("Connexion instantanée sans mot de passe",
                            className="signup-face-card-desc"),
                 ]),
                 html.Label(className="signup-face-toggle-wrap", children=[
@@ -431,11 +431,11 @@ def process_face_image(face_data):
             gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
             faces = face_cascade.detectMultiScale(gray, 1.1, 4)
             if len(faces) > 0:
-                return face_data, "✅ Visage détecté !", "camera-status face-detected"
-            return no_update, "❌ Aucun visage détecté", "camera-status no-face"
+                return face_data, "Visage détecté !", "camera-status face-detected"
+            return no_update, "Aucun visage détecté", "camera-status no-face"
     except Exception as e:
         print(f"Erreur: {e}")
-        return no_update, "❌ Erreur", "camera-status no-face"
+        return no_update, "Erreur", "camera-status no-face"
     return no_update, no_update, no_update
 
 

Interface Graphique/services/chat_service.py

@@ -0,0 +1,156 @@
+"""
+Service Chatbot — Assistant IA utilisant Groq (LLaMA 3.3 70B).
+Gratuit, ultra-rapide, streaming SSE.
+"""
+
+import os
+
+SYSTEM_PROMPT = """Tu es l'assistant virtuel de StockPredict AI, une plateforme de prédictions boursières intelligente.
+Tu aides les utilisateurs à comprendre et utiliser la plateforme. Réponds toujours dans la langue de l'utilisateur (français ou anglais).
+Sois clair, simple et bienveillant — l'utilisateur n'est pas forcément expert en finance ou en IA.
+
+## CE QUE FAIT LA PLATEFORME
+
+StockPredict AI prédit la direction des prix de 8 actions : Apple (AAPL), Microsoft (MSFT), Tesla (TSLA), NVIDIA (NVDA), Google (GOOGL), Amazon (AMZN), Meta (META), et Bitcoin (BTC-USD).
+
+## LES 3 MODÈLES DE PRÉDICTION
+
+### 1. Modèle Actualités (Sentiment)
+- Analyse les derniers articles de presse sur chaque action
+- Détecte si le ton des actualités est positif ou négatif
+- Donne un signal : HAUSSIER (prix devrait monter), BAISSIER (prix devrait baisser), ou NEUTRE
+- Idéal pour comprendre l'ambiance du marché
+
+### 2. Modèle LSTM (Intelligence Artificielle sur les prix)
+- Un réseau de neurones BiLSTM analysé 30 jours d'historique de prix
+- Calcule 14 indicateurs techniques (RSI, tendances, momentum, volatilité...)
+- Prédit la direction probable du prochain jour
+- Donne une probabilité directionnelle
+
+### 3. Modèle Transformer Hybride
+- Le plus avancé : combine les prix ET les actualités
+- Utilise une architecture Transformer (comme les LLMs) sur 60 jours
+- Analyse 44 indicateurs (prix + sentiment des news)
+- Donne une probabilité directionnelle + une amplitude estimée
+
+## COMMENT LIRE LES SIGNAUX
+
+- HAUSSIER : l'IA pense que le prix va monter. Action suggérée : ACHETER
+- BAISSIER : l'IA pense que le prix va baisser. Action suggérée : VENDRE (ou ne rien faire)
+- NEUTRE : signal incertain, mieux vaut attendre
+
+IMPORTANT : Ce sont des prédictions, pas des garanties. Les marchés sont imprévisibles.
+
+## LES PAGES DE L'APPLICATION
+
+### Accueil (/)
+- Voir les prédictions en temps réel pour les 8 actions
+- Choisir le modèle (boutons en haut : Actualités / LSTM / Transformer)
+- Cliquer "Calculer mon gain" pour aller dans Mon Suivi avec le même modèle
+
+### Mon Suivi (/mon-suivi)
+- Voir toutes les prédictions détaillées par modèle
+- Simuler un investissement (entrer un montant, choisir ACHAT ou VENTE)
+- "Juste voir le résultat" : simulation sans sauvegarder
+- "J'ai fait cet investissement" : enregistre dans votre historique
+- "Voir si j'avais suivi les conseils" : backtest sur 6 mois
+
+### Analyse (/analysis)
+- Dashboard complet des actualités et du sentiment par action
+- Graphiques d'évolution du sentiment dans le temps
+- Liste des derniers articles analysés
+
+### Marchés (/actions_page)
+- Graphiques de cours en temps réel (chandeliers)
+- Historique des prix des 8 actions
+
+### Mon Profil (/profil)
+- Modifier vos informations personnelles
+- Activer/désactiver la reconnaissance faciale
+- Voir vos statistiques
+
+## S'INSCRIRE / SE CONNECTER
+
+- Inscription : aller sur /signup, remplir le formulaire (prénom, nom, email, mot de passe)
+- Le mot de passe doit avoir min. 8 caractères, une majuscule et un chiffre
+- Connexion faciale optionnelle : connexion instantanée en se positionnant face à la caméra
+
+## QUESTIONS FRÉQUENTES
+
+Q: Comment gagner de l'argent avec la plateforme ?
+R: Simulez d'abord avec "Juste voir le résultat" pour comprendre. Si le modèle dit HAUSSIER et vous achetez, vous gagnez si le prix monte. Si BAISSIER et vous vendez (short), vous gagnez si le prix baisse. Commencez toujours par simuler.
+
+Q: Quel modèle est le meilleur ?
+R: Le Transformer Hybride est le plus sophistiqué car il combine prix et actualités. Mais chaque modèle a ses points forts selon le contexte de marché.
+
+Q: Mes données sont-elles sécurisées ?
+R: Oui, les mots de passe sont chiffrés (bcrypt), les données biométriques restent locales et ne sont jamais partagées.
+
+Q: Qu'est-ce que le backtest ?
+R: C'est une simulation : "si j'avais investi 500€ il y a 6 mois en suivant les conseils de l'IA, j'aurais gagné/perdu X€". Cela permet d'évaluer la fiabilité du modèle sur des données passées réelles.
+
+Réponds de façon concise et claire. Si tu ne sais pas quelque chose sur la plateforme, dis-le honnêtement.
+
+## ENREGISTREMENT D'INVESTISSEMENT (RÈGLE ABSOLUE — NE JAMAIS ENFREINDRE)
+
+TU N'AS AUCUN ACCÈS À LA BASE DE DONNÉES. Tu ne peux PAS enregistrer quoi que ce soit toi-même.
+Le seul et unique mécanisme d'enregistrement est le marqueur ##INVEST##. Sans ce marqueur, RIEN n'est sauvegardé.
+
+DONC : ne dis JAMAIS "j'ai enregistré", "c'est sauvegardé", "c'est fait", "votre investissement est confirmé" — car ce serait un MENSONGE. L'utilisateur verrait un message de confirmation mais rien ne serait enregistré.
+
+Quand l'utilisateur indique avoir fait un investissement (exemples : "j'ai suivi le LSTM et mis 500€ sur AAPL", "enregistre mon investissement", "j'ai acheté TSLA avec le transformer pour 300€", "vas-y enregistre") :
+
+1. Répondre en UNE SEULE phrase courte : "Voici le récapitulatif de votre investissement :"
+2. Terminer IMMÉDIATEMENT par le marqueur sur sa propre ligne — RIEN après :
+##INVEST##{"symbol":"AAPL","model":"lstm","action":"ACHETER","amount":500}##
+
+RÈGLE D'OR : Si tu as toutes les infos → génère le marqueur. Si une info manque → demande-la. C'est la seule alternative. Il n'existe pas de troisième option.
+
+Règles du marqueur :
+- symbol : l'un de AAPL, MSFT, TSLA, NVDA, GOOGL, AMZN, META, BTC-USD
+- model  : l'un de sentiment, lstm, transformer (en minuscules)
+- action : ACHETER ou VENDRE
+- amount : nombre (euros investis, ex: 500)
+
+EXEMPLE CORRECT — utilisateur : "j'ai suivi le lstm sur AAPL avec 500€" :
+"Voici le récapitulatif de votre investissement :
+##INVEST##{"symbol":"AAPL","model":"lstm","action":"ACHETER","amount":500}##"
+
+EXEMPLES INTERDITS (provoquent un bug grave) :
+"Je vais enregistrer votre investissement."  ← INTERDIT
+"Votre investissement a été enregistré !"   ← INTERDIT
+"C'est fait, j'ai sauvegardé."              ← INTERDIT
+"Parfait, c'est noté !"                    ← INTERDIT sans marqueur
+"""
+
+
+def stream_chat(messages: list):
+    """
+    Génère une réponse en streaming via Groq (LLaMA 3.3 70B).
+    Yields: chunks de texte
+    """
+    from groq import Groq
+
+    api_key = os.environ.get("GROQ_API_KEY")
+    if not api_key:
+        yield "Clé API non configurée. Ajoutez GROQ_API_KEY dans vos variables d'environnement."
+        return
+
+    client = Groq(api_key=api_key)
+
+    # Injection du system prompt en tête de liste
+    full_messages = [{"role": "system", "content": SYSTEM_PROMPT}] + messages
+
+    try:
+        stream = client.chat.completions.create(
+            model="llama-3.3-70b-versatile",
+            messages=full_messages,
+            max_tokens=1024,
+            stream=True,
+        )
+        for chunk in stream:
+            delta = chunk.choices[0].delta
+            if delta.content:
+                yield delta.content
+    except Exception as e:
+        yield f"Désolé, une erreur est survenue : {str(e)}"

Interface Graphique/services/database.py

@@ -1,7 +1,13 @@
 import sqlite3
 import bcrypt
+import os
 
-DB_NAME = "users.db"
+# Chemin absolu basé sur __file__ : remonter 3 niveaux depuis services/database.py
+# → toujours <racine_projet>/users.db, peu importe le répertoire de lancement
+_HERE = os.path.dirname(os.path.abspath(__file__))          # .../Interface Graphique/services
+_APP_DIR = os.path.dirname(_HERE)                            # .../Interface Graphique
+_ROOT_DIR = os.path.dirname(_APP_DIR)                        # .../Projet4A_PredictionsBoursieres-main
+DB_NAME = os.path.join(_ROOT_DIR, "users.db")
 
 def get_connection():
     return sqlite3.connect(DB_NAME)
@@ -16,7 +22,7 @@ def init_db():
     table_exists = cursor.fetchone()
     
     if not table_exists:
-        print("🆕 Création de la table users...")
+        print("Création de la table users...")
         cursor.execute("""
         CREATE TABLE users (
             id INTEGER PRIMARY KEY AUTOINCREMENT,
@@ -31,7 +37,7 @@ def init_db():
         )
         """)
         conn.commit()
-        print("✅ Table users créée avec succès")
+        print("Table users créée avec succès")
         
         # Créer un admin par défaut
         create_default_admin(conn)
@@ -41,51 +47,51 @@ def init_db():
         columns = [col[1] for col in cursor.fetchall()]
         
         if 'is_admin' not in columns:
-            print("🔄 Migration: ajout de la colonne is_admin...")
+            print("Migration: ajout de la colonne is_admin...")
             cursor.execute("ALTER TABLE users ADD COLUMN is_admin INTEGER DEFAULT 0")
             conn.commit()
-            print("✅ Migration is_admin réussie")
-        
+            print("Migration is_admin réussie")
+
         if 'face_image' not in columns:
-            print("🔄 Migration: ajout de la colonne face_image...")
+            print("Migration: ajout de la colonne face_image...")
             cursor.execute("ALTER TABLE users ADD COLUMN face_image TEXT")
             conn.commit()
-            print("✅ Migration face_image réussie")
-        
+            print("Migration face_image réussie")
+
         if 'created_at' not in columns:
-            print("🔄 Migration: ajout de la colonne created_at...")
+            print("Migration: ajout de la colonne created_at...")
             cursor.execute("ALTER TABLE users ADD COLUMN created_at DATETIME")
             conn.commit()
             cursor.execute("UPDATE users SET created_at = CURRENT_TIMESTAMP WHERE created_at IS NULL")
             conn.commit()
-            print("✅ Migration created_at réussie")
+            print("Migration created_at réussie")
 
         if 'prenom' not in columns:
             cursor.execute("ALTER TABLE users ADD COLUMN prenom TEXT")
             conn.commit()
-            print("✅ Migration prenom réussie")
+            print("Migration prenom réussie")
 
         if 'nom' not in columns:
             cursor.execute("ALTER TABLE users ADD COLUMN nom TEXT")
             conn.commit()
-            print("✅ Migration nom réussie")
+            print("Migration nom réussie")
 
         if 'telephone' not in columns:
             cursor.execute("ALTER TABLE users ADD COLUMN telephone TEXT")
             conn.commit()
-            print("✅ Migration telephone réussie")
+            print("Migration telephone réussie")
 
         if 'public_stats' not in columns:
             cursor.execute("ALTER TABLE users ADD COLUMN public_stats INTEGER DEFAULT 0")
             conn.commit()
-            print("✅ Migration public_stats réussie")
+            print("Migration public_stats réussie")
 
         if 'is_online' not in columns:
             cursor.execute("ALTER TABLE users ADD COLUMN is_online INTEGER DEFAULT 0")
             conn.commit()
-            print("✅ Migration is_online réussie")
+            print("Migration is_online réussie")
 
-        print("📦 Table users déjà existante, conservation des données")
+        print("Table users déjà existante, conservation des données")
         ensure_admin_exists(conn)
 
     # === TABLE USER_TRADES ===
@@ -108,7 +114,7 @@ def init_db():
         FOREIGN KEY (user_email) REFERENCES users(email)
     )
     """)
-    print("✅ Table user_trades vérifiée/créée")
+    print("Table user_trades vérifiée/créée")
 
     # Migration: model_type column (for existing databases)
     cursor.execute("PRAGMA table_info(user_trades)")
@@ -116,7 +122,7 @@ def init_db():
     if 'model_type' not in trade_columns:
         cursor.execute("ALTER TABLE user_trades ADD COLUMN model_type TEXT DEFAULT 'sentiment'")
         conn.commit()
-        print("✅ Migration model_type réussie")
+        print("Migration model_type réussie")
 
     # === TABLE PREDICTIONS_LOG ===
     cursor.execute("""
@@ -134,7 +140,7 @@ def init_db():
         created_at DATETIME DEFAULT CURRENT_TIMESTAMP
     )
     """)
-    print("✅ Table predictions_log vérifiée/créée")
+    print("Table predictions_log vérifiée/créée")
 
     # === TABLE TESTIMONIALS ===
     cursor.execute("""
@@ -153,11 +159,11 @@ def init_db():
         FOREIGN KEY (user_email) REFERENCES users(email)
     )
     """)
-    print("✅ Table testimonials vérifiée/créée")
+    print("Table testimonials vérifiée/créée")
 
     conn.commit()
     conn.close()
-    print("🎯 Toutes les tables sont initialisées avec succès")
+    print("Toutes les tables sont initialisées avec succès")
 
 def create_default_admin(conn):
     """Crée un admin par défaut"""
@@ -174,12 +180,12 @@ def create_default_admin(conn):
             (default_email, hashed, 1)
         )
         conn.commit()
-        print("👑 Admin par défaut créé: admin@ensim.com / Admin123!")
-        print("⚠️  CHANGE CE MOT DE PASSE DÈS QUE POSSIBLE !")
+        print("Admin par défaut créé: admin@ensim.com / Admin123!")
+        print("CHANGE CE MOT DE PASSE DÈS QUE POSSIBLE !")
     except sqlite3.IntegrityError:
-        print("ℹ️ Admin par défaut déjà existant")
+        print("Admin par défaut déjà existant")
     except Exception as e:
-        print(f"❌ Erreur création admin: {e}")
+        print(f"Erreur création admin: {e}")
 
 def ensure_admin_exists(conn):
     """S'assure qu'il y a au moins un admin"""
@@ -188,7 +194,7 @@ def ensure_admin_exists(conn):
     count = cursor.fetchone()[0]
     
     if count == 0:
-        print("⚠️ Aucun admin trouvé, création d'un admin par défaut...")
+        print("Aucun admin trouvé, création d'un admin par défaut...")
         create_default_admin(conn)
     else:
-        print(f"👥 {count} administrateur(s) trouvé(s)")
+        print(f"{count} administrateur(s) trouvé(s)")

Interface Graphique/services/face_auth.py

@@ -21,13 +21,13 @@ try:
         test_window = cv2.namedWindow("test", cv2.WINDOW_NORMAL)
         cv2.destroyWindow("test")
         GUI_AVAILABLE = True
-        print("✅ OpenCV disponible (mode graphique)")
+        print("OpenCV disponible (mode graphique)")
     except:
         GUI_AVAILABLE = False
-        print("⚠️ Interface graphique OpenCV non disponible (mode console)")
-        
+        print("Interface graphique OpenCV non disponible (mode console)")
+
 except ImportError as e:
-    print(f"⚠️ OpenCV non disponible: {e}")
+    print(f"OpenCV non disponible: {e}")
     print("  Pour l'activer: pip install opencv-python")
     OPENCV_AVAILABLE = False
     GUI_AVAILABLE = False
@@ -42,7 +42,7 @@ FACE_DATA_DIR = Path("face_data")
 try:
     FACE_DATA_DIR.mkdir(exist_ok=True)
 except:
-    print(f"⚠️ Impossible de créer le dossier {FACE_DATA_DIR}")
+    print(f"Impossible de créer le dossier {FACE_DATA_DIR}")
 
 def get_face_hash_from_image(frame):
     """
@@ -65,7 +65,7 @@ def get_face_hash_from_image(frame):
         
         return face_hash
     except Exception as e:
-        print(f"❌ Erreur création hash: {e}")
+        print(f"Erreur création hash: {e}")
         return None
 
 def detect_face(frame):
@@ -94,33 +94,33 @@ def detect_face(frame):
         
         return face_roi
     except Exception as e:
-        print(f"❌ Erreur détection visage: {e}")
+        print(f"Erreur détection visage: {e}")
         return None
 
     """
     Capture un visage depuis la webcam (version avec fallback console)
     """
     if not OPENCV_AVAILABLE:
-        print("❌ OpenCV non disponible")
+        print("OpenCV non disponible")
         return None
-    
+
     try:
         # Initialiser la webcam
         video_capture = cv2.VideoCapture(0)
         if not video_capture.isOpened():
-            print("❌ Impossible d'ouvrir la webcam")
+            print("Impossible d'ouvrir la webcam")
             return None
         
         print("\n" + "="*50)
-        print("🔵 CAPTURE FACIALE - ENSIM")
+        print("CAPTURE FACIALE - ENSIM")
         print("="*50)
-        
+
         if GUI_AVAILABLE:
-            print("📸 Fenêtre de capture va s'ouvrir...")
+            print("Fenêtre de capture va s'ouvrir...")
             print("   [ESPACE] pour capturer")
             print("   [Q] pour annuler")
         else:
-            print("📸 Mode console - regarde la caméra")
+            print("Mode console - regarde la caméra")
             print("   Capture automatique dans 3 secondes...")
             time.sleep(1)
             print("   3...")
@@ -163,55 +163,55 @@ def detect_face(frame):
                            (10, 30), cv2.FONT_HERSHEY_SIMPLEX, 0.7, (0, 255, 0), 2)
                 
                 if face_roi is None:
-                    cv2.putText(display_frame, "⚠️ AUCUN VISAGE DETECTE", 
+                    cv2.putText(display_frame, "AUCUN VISAGE DETECTE",
                                (10, 60), cv2.FONT_HERSHEY_SIMPLEX, 0.7, (0, 0, 255), 2)
-                
+
                 cv2.imshow('Capture Visage - ENSIM', display_frame)
                 key = cv2.waitKey(1) & 0xFF
-                
+
                 if key == ord(' '):
                     if face_roi is not None:
                         face_hash = get_face_hash_from_image(face_roi)
                         face_image = face_roi
                         captured = True
-                        print("\n✅ Visage capturé avec succès!")
+                        print("\nVisage capturé avec succès!")
                     else:
-                        print("\n❌ Aucun visage détecté, réessaie")
-                        
+                        print("\nAucun visage détecté, réessaie")
+
                 elif key == ord('q'):
-                    print("\n❌ Capture annulée")
+                    print("\nCapture annulée")
                     break
             
             # Mode console (sans GUI)
             else:
                 console_attempts += 1
-                print(f"\r📸 Tentative {console_attempts}/{max_console_attempts}... ", end="", flush=True)
-                
+                print(f"\rTentative {console_attempts}/{max_console_attempts}... ", end="", flush=True)
+
                 if face_roi is not None:
                     face_hash = get_face_hash_from_image(face_roi)
                     face_image = face_roi
                     captured = True
-                    print("\n✅ Visage capturé avec succès!")
+                    print("\nVisage capturé avec succès!")
                 elif console_attempts >= max_console_attempts:
-                    print("\n❌ Échec capture - aucun visage détecté")
+                    print("\nÉchec capture - aucun visage détecté")
                     break
                 else:
                     time.sleep(0.5)  # Pause entre les tentatives
-        
+
         # Nettoyer
         video_capture.release()
         if GUI_AVAILABLE:
             cv2.destroyAllWindows()
-        
+
         if face_hash:
-            print("✅ Données faciales enregistrées")
+            print("Données faciales enregistrées")
             return {"hash": face_hash, "image": face_image}
-        
-        print("❌ Aucune donnée faciale capturée")
+
+        print("Aucune donnée faciale capturée")
         return None
-        
+
     except Exception as e:
-        print(f"\n❌ Erreur capture: {e}")
+        print(f"\nErreur capture: {e}")
         return None
 def capture_face_from_webcam():
     """

PIPELINE_SCHEMA.md

@@ -0,0 +1,202 @@
+# Demande de schéma — Pipeline de prédictions boursières
+
+## Contexte pour le designer
+
+Génère un **schéma de pipeline clair et professionnel** (style diagramme de flux / architecture ML) pour un projet de prédictions boursières qui implémente **3 modes de prédiction distincts**.
+
+---
+
+## Clarification de l'architecture (réponse au prof)
+
+### Question du prof : Que signifie « Transformer hybride » ?
+
+**Réponse précise :**
+Le mot « hybride » qualifie les **sources de données**, pas les modèles.
+
+| Mode | Sources de données | Modèle | Nature du "hybride" |
+|------|-------------------|--------|---------------------|
+| Actualités | Articles de presse uniquement | Analyse de sentiment (règles) | ✗ Non hybride |
+| LSTM | Historique des prix uniquement | BiLSTM + Embedding symbole | ✗ Non hybride |
+| Transformer | **Prix + Actualités (combinés)** | Transformer Encoder | ✓ Hybride (2 sources) |
+
+---
+
+## Les 3 pipelines complets
+
+---
+
+### MODE 1 — Analyse des Actualités (Sentiment)
+
+```
+SOURCE          PRÉTRAITEMENT           MODÈLE              SORTIE
+─────           ─────────────           ──────              ──────
+
+Articles        Score de               Agrégation          Signal
+de presse  ──►  sentiment         ──►  temporelle    ──►   HAUSSIER
+(CSV GitHub)    [-1, +1]               (moyenne           BAISSIER
+                par article            glissante)          NEUTRE
+                                       + seuils
+```
+
+**Détails techniques :**
+- Source : fichier CSV hébergé sur GitHub (mis à jour automatiquement)
+- Scoring : score de sentiment par article (colonne `score_sentiment`)
+- Agrégation : moyenne des scores sur une fenêtre temporelle par ticker
+- Signal : HAUSSIER si score > seuil+, BAISSIER si score < seuil-, NEUTRE sinon
+- Sortie : signal directionnel + score de confiance
+
+---
+
+### MODE 2 — LSTM (Historique des prix)
+
+```
+SOURCE          FEATURE ENGINEERING     NORMALISATION       MODÈLE              SORTIE
+─────           ───────────────────     ─────────────       ──────              ──────
+
+Prix OHLCV      14 indicateurs          RobustScaler        BiLSTM              Probabilité
+(yfinance)  ──► techniques         ──►  clip [-5, 5]   ──►  (30 × 14)     ──►  directionnelle
+90 jours        ret1, ret3, ret5        (sauvegardé)        + Embedding         → ACHETER
+                trend_s, trend_l                            symbole (8 dim)      VENDRE
+                mom3, mom10                                 ↓
+                vol10, vol_ratio                            Dense → Sigmoid
+                rsi14, rsi7
+                atr, bb, volr
+```
+
+**Détails techniques :**
+- Fenêtre temporelle : 30 jours (SEQ_LEN = 30)
+- Features : 14 indicateurs techniques calculés sur l'historique OHLCV
+- Normalisation : RobustScaler (résistant aux outliers) + clipping ±5
+- Architecture : Bidirectional LSTM (64 unités) → LSTM (32) → Dense → Sigmoid
+- Embedding symbole : 8 dimensions (pour AAPL, TSLA, MSFT, GOOGL, NVDA, AMZN, META, BTC-USD)
+- Sortie : probabilité ∈ [0,1] → signal + rendement estimé (prob × volatilité récente)
+
+---
+
+### MODE 3 — Transformer Hybride (Prix + Actualités)
+
+```
+SOURCE 1        FEATURE ENG.           FUSION              NORMALISATION
+─────────       ────────────           ──────              ─────────────
+Prix OHLCV ──►  16 features       ──►                ──►  StandardScaler
+(yfinance)      techniques             44 features         (feature_scaler)
+                                       combinées
+SOURCE 2        FEATURE ENG.           ↓
+─────────       ────────────
+Articles    ──►  28 features      ──►
+de presse        sentiment-dérivées
+(GitHub CSV)     (lags, moyennes,
+                 EMA, sommes)
+
+                                       MODÈLE              SORTIE
+                                       ──────              ──────
+                                       Transformer    ──►  Dir. prob. (sigmoid)
+                                       Encoder             + Amplitude (tanh)
+                                       (60 × 44)           ↓
+                                       d_model=64          log-rendement
+                                       nhead=4             = (2p-1) × |amp| × max_lr
+                                       2 couches           ↓
+                                                           ACHETER / VENDRE
+                                                           + prix prédit demain
+```
+
+**Détails techniques :**
+- Fenêtre temporelle : 60 jours (window = 60)
+- Features prix (16) : OHLCV, close_lag1, MA5, volatilité, RSI, MACD, BB, returns, log-return, ratio SMA, range HL
+- Features sentiment (28) : score_sentiment, articles_count, has_news, lags [1,2,3,5], moyennes [3,5,7,14j], sommes, EMA [5,10], signaux forts
+- Total : 44 features
+- Architecture : Linear(44→64) → Positional Encoding → TransformerEncoder × 2 → LayerNorm → tête direction (sigmoid) + tête amplitude (tanh)
+- Sortie finale : log-rendement signé → prix prédit + signal directionnel
+
+---
+
+## Schéma global comparatif à générer
+
+```
+┌─────────────────────────────────────────────────────────────────────────────┐
+│                     APPLICATION DE PRÉDICTIONS BOURSIÈRES                   │
+│                           (8 tickers : US + Crypto)                         │
+└───────────────────────────┬─────────────────────────────────────────────────┘
+                            │
+        ┌───────────────────┼──────────────────────┐
+        ▼                   ▼                       ▼
+ ┌─────────────┐    ┌──────────────┐    ┌─────────────────────┐
+ │   MODE 1    │    │   MODE 2     │    │       MODE 3        │
+ │ Actualités  │    │    LSTM      │    │  Transformer Hybride│
+ └──────┬──────┘    └──────┬───────┘    └──────────┬──────────┘
+        │                  │                        │
+        ▼                  ▼                        ▼
+   Articles de         Prix OHLCV           Prix OHLCV
+   presse (CSV)        90 jours             + Articles
+        │                  │                   (2 sources)
+        ▼                  ▼                        ▼
+   Sentiment           14 features             44 features
+   scoring             techniques              (16 prix +
+                       (30 jours)               28 sentiment)
+                                               (60 jours)
+        │                  │                        │
+        ▼                  ▼                        ▼
+   Agrégation          RobustScaler          StandardScaler
+   + seuils            + clip ±5
+        │                  │                        │
+        ▼                  ▼                        ▼
+   Règles de          BiLSTM (30×14)        Transformer
+   décision           + Embedding            Encoder (60×44)
+   (seuils)           symbole               d_model=64, 2L
+        │                  │                        │
+        ▼                  ▼                        ▼
+   Score              Probabilité           Dir.prob + Amplitude
+   sentiment          [0,1]                 → log-rendement
+        │                  │                        │
+        └──────────────────┴────────────────────────┘
+                            │
+                            ▼
+              ┌─────────────────────────┐
+              │       SIGNAL FINAL      │
+              │  HAUSSIER / BAISSIER /  │
+              │        NEUTRE           │
+              │  + Prix prédit demain   │
+              │  + Rendement estimé %   │
+              └─────────────────────────┘
+```
+
+---
+
+## Instructions pour le schéma visuel
+
+Génère un **diagramme de pipeline vertical** avec :
+
+1. **3 colonnes** (une par mode), chacune de couleur distincte :
+   - Mode 1 (Actualités) : violet/mauve
+   - Mode 2 (LSTM) : bleu/cyan
+   - Mode 3 (Transformer) : vert/teal
+
+2. **5 rangées** (couches du pipeline) :
+   - Sources de données
+   - Feature engineering
+   - Normalisation
+   - Modèle
+   - Sortie
+
+3. **Flèches de flux** entre chaque étape
+
+4. **Zone de convergence** en bas des 3 colonnes vers un bloc "Sortie unifiée"
+
+5. Style : professionnel, dark background, adapté rapport académique
+
+6. Mentionner dans chaque colonne : nombre de features, taille de fenêtre temporelle, architecture du modèle
+
+---
+
+## Ce qui différencie les 3 modes (réponse directe au prof)
+
+| Critère | Mode 1 | Mode 2 | Mode 3 |
+|---------|--------|--------|--------|
+| **Sources** | Actualités uniquement | Prix uniquement | **Prix + Actualités** |
+| **Modèle** | Règles (pas de NN) | BiLSTM | Transformer Encoder |
+| **Features** | Sentiment [-1,+1] | 14 indicateurs techniques | 44 features (hybrides) |
+| **Fenêtre** | Variable (articles) | 30 jours | 60 jours |
+| **Sortie brute** | Score sentiment | Probabilité sigmoid | Prob. + Amplitude |
+| **"Hybride" ?** | ✗ | ✗ | ✓ (données hybrides) |
+
+**Conclusion :** « Transformer hybride » = architecture Transformer appliquée à une **entrée hybride** (fusion de données de prix et de sentiment d'actualités). Le mot « hybride » qualifie les données d'entrée, non l'architecture du modèle.

requirements.txt

@@ -13,4 +13,6 @@ beautifulsoup4
 scikit-learn
 joblib
 tensorflow
-torch
+torch
+groq
+python-dotenv