Update app.py

app.py

@@ -2,447 +2,211 @@ import asyncio
 import json
 import logging
 import time
+import math
 import aiohttp
 import pandas as pd
 import numpy as np
 from aiohttp import web
-from sklearn.ensemble import GradientBoostingRegressor
-from sklearn.preprocessing import RobustScaler
-import warnings
-warnings.filterwarnings('ignore')
+from sklearn.ensemble import RandomForestRegressor
+from sklearn.metrics import mean_squared_error
 
-# --- CONFIGURATION ---
 SYMBOL_KRAKEN = "BTC/USD"
 PORT = 7860
 BROADCAST_RATE = 1.0
 PREDICTION_HORIZON = 100
 MAX_HISTORY = 5000
 TRAIN_INTERVAL = 300
-MIN_TRAINING_SAMPLES = 300
 
 logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(message)s')
 
-# Feature columns for ML model
-FEATURE_COLS = [
-    'rsi_norm', 'rsi_slope',
-    'macd_hist_norm', 'macd_slope',
-    'atr_pct',
-    'dist_ema20', 'dist_ema50', 'ema_cross',
-    'bb_width', 'bb_pos',
-    'vol_zscore',
-    'ret_1', 'ret_5', 'ret_10', 'ret_20',
-    'volatility_ratio',
-    'candle_body', 'upper_wick', 'lower_wick',
-    'trend_strength'
-]
-
-# Key horizons to predict (reduces noise vs predicting all 100)
-KEY_HORIZONS = [1, 3, 5, 10, 20, 35, 50, 75, 100]
-
 market_state = {
     "ohlc_history": [],
     "ready": False,
-    "models": {},           # Dictionary of models for each horizon
-    "scaler": None,
+    "model": None,
+    "model_residuals": None,
     "last_training_time": 0,
     "last_price": 0,
-    "price_change": 0,
-    "training_metrics": {}
+    "price_change": 0
 }
 
 connected_clients = set()
 
-
-def safe_divide(a, b, default=0.0):
-    """Safe division that handles zeros and NaN"""
-    with np.errstate(divide='ignore', invalid='ignore'):
-        result = np.where(b != 0, a / b, default)
-        result = np.where(np.isfinite(result), result, default)
-    return result
-
-
 def calculate_indicators(candles):
-    """Calculate technical indicators with robust normalization"""
-    if len(candles) < 60:
+    if len(candles) < 100:
         return None
     
-    df = pd.DataFrame(candles).copy()
+    df = pd.DataFrame(candles)
     cols = ['open', 'high', 'low', 'close', 'volume']
     for c in cols:
-        df[c] = pd.to_numeric(df[c], errors='coerce')
-    
-    df = df.dropna(subset=['open', 'high', 'low', 'close'])
-    if len(df) < 60:
-        return None
+        df[c] = df[c].astype(float)
 
-    close = df['close']
-    high = df['high']
-    low = df['low']
-    volume = df['volume'].fillna(0)
+    df['ema20'] = df['close'].ewm(span=20, adjust=False).mean()
+    df['ema50'] = df['close'].ewm(span=50, adjust=False).mean()
     
-    # --- EXPONENTIAL MOVING AVERAGES ---
-    df['ema20'] = close.ewm(span=20, adjust=False).mean()
-    df['ema50'] = close.ewm(span=50, adjust=False).mean()
-    
-    # --- BOLLINGER BANDS ---
-    df['sma20'] = close.rolling(window=20).mean()
-    df['std20'] = close.rolling(window=20).std()
-    df['bb_upper'] = df['sma20'] + (df['std20'] * 2)
-    df['bb_lower'] = df['sma20'] - (df['std20'] * 2)
+    df['std'] = df['close'].rolling(window=20).std()
+    df['bb_upper'] = df['ema20'] + (df['std'] * 2)
+    df['bb_lower'] = df['ema20'] - (df['std'] * 2)
 
-    # --- RSI ---
-    delta = close.diff()
-    gain = delta.where(delta > 0, 0).rolling(window=14).mean()
+    delta = df['close'].diff()
+    gain = (delta.where(delta > 0, 0)).rolling(window=14).mean()
     loss = (-delta.where(delta < 0, 0)).rolling(window=14).mean()
-    rs = safe_divide(gain.values, loss.values, 1.0)
+    rs = gain / loss
     df['rsi'] = 100 - (100 / (1 + rs))
-    df['rsi'] = df['rsi'].fillna(50).clip(0, 100)
-    
-    # Normalized RSI (centered at 0, range -1 to 1)
-    df['rsi_norm'] = (df['rsi'] - 50) / 50
-    df['rsi_slope'] = df['rsi'].diff(5).fillna(0) / 50  # 5-period RSI change
 
-    # --- MACD ---
-    ema12 = close.ewm(span=12, adjust=False).mean()
-    ema26 = close.ewm(span=26, adjust=False).mean()
-    df['macd'] = ema12 - ema26
+    k = df['close'].ewm(span=12, adjust=False).mean()
+    d = df['close'].ewm(span=26, adjust=False).mean()
+    df['macd'] = k - d
     df['macd_signal'] = df['macd'].ewm(span=9, adjust=False).mean()
     df['macd_hist'] = df['macd'] - df['macd_signal']
-    
-    # Normalize MACD by ATR to make it price-independent
-    atr_for_norm = close.rolling(20).std().replace(0, 1)
-    df['macd_hist_norm'] = df['macd_hist'] / atr_for_norm
-    df['macd_hist_norm'] = df['macd_hist_norm'].clip(-5, 5)
-    df['macd_slope'] = df['macd_hist_norm'].diff(3).fillna(0)
 
-    # --- ATR (Average True Range) ---
-    tr1 = abs(high - low)
-    tr2 = abs(high - close.shift())
-    tr3 = abs(low - close.shift())
-    df['tr'] = pd.concat([tr1, tr2, tr3], axis=1).max(axis=1)
+    df['tr0'] = abs(df['high'] - df['low'])
+    df['tr1'] = abs(df['high'] - df['close'].shift())
+    df['tr2'] = abs(df['low'] - df['close'].shift())
+    df['tr'] = df[['tr0', 'tr1', 'tr2']].max(axis=1)
     df['atr'] = df['tr'].rolling(window=14).mean()
-    
-    # ATR as percentage of price (volatility measure)
-    df['atr_pct'] = safe_divide(df['atr'].values, close.values) * 100
-
-    # --- NORMALIZED PRICE FEATURES ---
-    
-    # Distance from EMAs (percentage)
-    df['dist_ema20'] = safe_divide((close - df['ema20']).values, df['ema20'].values) * 100
-    df['dist_ema50'] = safe_divide((close - df['ema50']).values, df['ema50'].values) * 100
-    
-    # EMA cross strength
-    df['ema_cross'] = safe_divide((df['ema20'] - df['ema50']).values, df['ema50'].values) * 100
-    
-    # --- BOLLINGER BAND FEATURES ---
-    bb_range = df['bb_upper'] - df['bb_lower']
-    bb_range_safe = bb_range.replace(0, np.nan).fillna(close * 0.01)  # Fallback to 1% of price
-    
-    df['bb_width'] = safe_divide(bb_range.values, df['sma20'].values) * 100
-    df['bb_pos'] = safe_divide((close - df['bb_lower']).values, bb_range_safe.values)
-    df['bb_pos'] = df['bb_pos'].clip(-0.5, 1.5).fillna(0.5)  # Allow some overflow
 
-    # --- VOLUME FEATURES ---
-    vol_mean = volume.rolling(window=20).mean().replace(0, 1)
-    vol_std = volume.rolling(window=20).std().replace(0, 1)
-    df['vol_zscore'] = safe_divide((volume - vol_mean).values, vol_std.values)
-    df['vol_zscore'] = df['vol_zscore'].clip(-3, 3).fillna(0)
-
-    # --- RETURN FEATURES (momentum) ---
-    df['ret_1'] = close.pct_change(1).fillna(0) * 100
-    df['ret_5'] = close.pct_change(5).fillna(0) * 100
-    df['ret_10'] = close.pct_change(10).fillna(0) * 100
-    df['ret_20'] = close.pct_change(20).fillna(0) * 100
-    
-    # Clip extreme returns
-    for col in ['ret_1', 'ret_5', 'ret_10', 'ret_20']:
-        df[col] = df[col].clip(-10, 10)
+    df['dist_ema20'] = (df['close'] - df['ema20']) / df['ema20']
+    df['dist_ema50'] = (df['close'] - df['ema50']) / df['ema50']
+    df['bb_width'] = (df['bb_upper'] - df['bb_lower']) / df['ema20']
+    df['bb_pos'] = (df['close'] - df['bb_lower']) / (df['bb_upper'] - df['bb_lower'])
+    df['vol_change'] = df['volume'].pct_change()
+    df['log_ret'] = np.log(df['close'] / df['close'].shift(1))
 
-    # --- VOLATILITY FEATURES ---
-    vol_short = df['ret_1'].rolling(5).std().fillna(0)
-    vol_long = df['ret_1'].rolling(20).std().replace(0, 1)
-    df['volatility_ratio'] = safe_divide(vol_short.values, vol_long.values).clip(0, 3)
+    for lag in [1, 2, 3]:
+        df[f'rsi_lag{lag}'] = df['rsi'].shift(lag)
+        df[f'macd_hist_lag{lag}'] = df['macd_hist'].shift(lag)
+        df[f'log_ret_lag{lag}'] = df['log_ret'].shift(lag)
+        df[f'vol_change_lag{lag}'] = df['vol_change'].shift(lag)
 
-    # --- CANDLESTICK FEATURES ---
-    candle_range = (high - low).replace(0, 0.01)
-    df['candle_body'] = safe_divide((close - df['open']).values, candle_range.values)
-    df['upper_wick'] = safe_divide((high - pd.concat([close, df['open']], axis=1).max(axis=1)).values, candle_range.values)
-    df['lower_wick'] = safe_divide((pd.concat([close, df['open']], axis=1).min(axis=1) - low).values, candle_range.values)
-
-    # --- TREND STRENGTH ---
-    # Compare current price to 20-period high/low range
-    rolling_high = high.rolling(20).max()
-    rolling_low = low.rolling(20).min()
-    rolling_range = (rolling_high - rolling_low).replace(0, 1)
-    df['trend_strength'] = safe_divide((close - rolling_low).values, rolling_range.values) * 2 - 1  # -1 to 1
-
-    # Replace any remaining infinities or NaN
-    df = df.replace([np.inf, -np.inf], np.nan)
-    
     return df
 
-
-def prepare_training_data(df):
-    """Prepare features and multi-horizon targets for training"""
-    data = df.copy()
-    
-    # Create target: future return at each key horizon
-    target_cols = []
-    for h in KEY_HORIZONS:
-        col_name = f'target_{h}'
-        future_price = data['close'].shift(-h)
-        current_price = data['close']
-        # Target is percentage return
-        data[col_name] = safe_divide((future_price - current_price).values, current_price.values) * 100
-        target_cols.append(col_name)
-    
-    # Drop rows with NaN in features or targets
-    required_cols = FEATURE_COLS + target_cols
-    data = data.dropna(subset=required_cols)
-    
-    if len(data) < MIN_TRAINING_SAMPLES:
-        return None, None
-    
-    X = data[FEATURE_COLS].values
-    y_dict = {h: data[f'target_{h}'].values for h in KEY_HORIZONS}
-    
-    return X, y_dict
-
-
 def train_model(df):
-    """Train separate models for each prediction horizon"""
-    logging.info(f"Training ML Models on {len(df)} candles...")
-    
-    X, y_dict = prepare_training_data(df)
-    
-    if X is None:
-        logging.warning("Not enough training data")
+    logging.info(f"Training ML Model on {len(df)} candles...")
+    
+    feature_cols = [
+        'rsi', 'macd_hist', 'atr', 
+        'dist_ema20', 'dist_ema50', 
+        'bb_width', 'bb_pos', 
+        'vol_change', 'log_ret',
+        'rsi_lag1', 'rsi_lag2', 'rsi_lag3',
+        'macd_hist_lag1', 'macd_hist_lag2', 'macd_hist_lag3',
+        'log_ret_lag1', 'log_ret_lag2', 'log_ret_lag3',
+        'vol_change_lag1', 'vol_change_lag2', 'vol_change_lag3'
+    ]
+    
+    data = df.dropna().copy()
+    targets = []
+    
+    for i in range(1, PREDICTION_HORIZON + 1):
+        col_name = f'target_return_{i}'
+        data[col_name] = (data['close'].shift(-i) - data['close']) / data['close']
+        targets.append(col_name)
+        
+    data = data.dropna()
+
+    if len(data) < 200:
         return None, None
-    
-    logging.info(f"Training data: {len(X)} samples, {len(FEATURE_COLS)} features")
-    
-    # Robust scaling handles outliers better than StandardScaler
-    scaler = RobustScaler()
-    X_scaled = scaler.fit_transform(X)
-    
-    models = {}
-    metrics = {}
-    
-    for h in KEY_HORIZONS:
-        y = y_dict[h]
-        
-        # Gradient Boosting with regularization to prevent overfitting
-        model = GradientBoostingRegressor(
-            n_estimators=150,
-            max_depth=4,
-            learning_rate=0.05,
-            min_samples_split=30,
-            min_samples_leaf=15,
-            subsample=0.8,
-            max_features='sqrt',
-            validation_fraction=0.15,
-            n_iter_no_change=10,
-            random_state=42,
-            verbose=0
-        )
-        
-        model.fit(X_scaled, y)
-        models[h] = model
-        
-        # Calculate training R² score
-        train_score = model.score(X_scaled, y)
-        metrics[h] = {'r2': round(train_score, 3)}
-        
-        logging.info(f"  Horizon {h:3d}: R² = {train_score:.3f}")
-    
-    # Log feature importance (from longest horizon model)
-    if 100 in models:
-        importance = dict(zip(FEATURE_COLS, models[100].feature_importances_))
-        top_5 = sorted(importance.items(), key=lambda x: x[1], reverse=True)[:5]
-        logging.info(f"Top features: {[f'{k}:{v:.3f}' for k,v in top_5]}")
-    
-    market_state['training_metrics'] = metrics
-    logging.info("Model training complete")
-    
-    return models, scaler
-
-
-def interpolate_predictions(horizon_preds, target_horizon):
-    """Interpolate between key horizon predictions for smooth curve"""
-    horizons = sorted(horizon_preds.keys())
-    
-    if target_horizon <= horizons[0]:
-        return horizon_preds[horizons[0]]
-    if target_horizon >= horizons[-1]:
-        return horizon_preds[horizons[-1]]
-    
-    # Find surrounding horizons
-    lower_h = max([h for h in horizons if h <= target_horizon])
-    upper_h = min([h for h in horizons if h >= target_horizon])
-    
-    if lower_h == upper_h:
-        return horizon_preds[lower_h]
-    
-    # Cubic interpolation weight for smoother curves
-    t = (target_horizon - lower_h) / (upper_h - lower_h)
-    t_smooth = t * t * (3 - 2 * t)  # Smoothstep function
-    
-    return horizon_preds[lower_h] + (horizon_preds[upper_h] - horizon_preds[lower_h]) * t_smooth
-
 
-def apply_trend_smoothing(predictions, window=5):
-    """Apply exponential moving average smoothing to predictions"""
-    if len(predictions) < window:
-        return predictions
-    
-    smoothed = []
-    alpha = 2 / (window + 1)
-    
-    # Initialize with first value
-    ema = predictions[0]
-    smoothed.append(ema)
+    X = data[feature_cols].values
+    y = data[targets].values
+
+    model = RandomForestRegressor(
+        n_estimators=150, 
+        max_depth=20, 
+        min_samples_split=4,
+        min_samples_leaf=2,
+        max_features='sqrt',
+        n_jobs=-1, 
+        random_state=42
+    )
+    model.fit(X, y)
     
-    for i in range(1, len(predictions)):
-        ema = alpha * predictions[i] + (1 - alpha) * ema
-        smoothed.append(ema)
+    predictions = model.predict(X)
+    residuals = y - predictions
+    residual_std = np.std(residuals, axis=0)
     
-    return smoothed
-
+    return model, residual_std
 
-def get_prediction(df, models, scaler):
-    """Generate price predictions for the next N candles"""
-    if not models or scaler is None:
+def get_prediction(df, model, residual_std):
+    if model is None or residual_std is None:
         return []
     
-    # Check if we have valid features
-    last_row = df.iloc[-1:].copy()
+    feature_cols = [
+        'rsi', 'macd_hist', 'atr', 
+        'dist_ema20', 'dist_ema50', 
+        'bb_width', 'bb_pos', 
+        'vol_change', 'log_ret',
+        'rsi_lag1', 'rsi_lag2', 'rsi_lag3',
+        'macd_hist_lag1', 'macd_hist_lag2', 'macd_hist_lag3',
+        'log_ret_lag1', 'log_ret_lag2', 'log_ret_lag3',
+        'vol_change_lag1', 'vol_change_lag2', 'vol_change_lag3'
+    ]
     
-    # Validate features
-    missing_features = [col for col in FEATURE_COLS if col not in last_row.columns]
-    if missing_features:
-        logging.error(f"Missing features: {missing_features}")
-        return []
+    last_row = df.iloc[[-1]][feature_cols]
     
-    feature_values = last_row[FEATURE_COLS]
-    if feature_values.isnull().values.any():
-        logging.warning("NaN in prediction features")
+    if last_row.isnull().values.any():
         return []
+
+    predicted_returns = model.predict(last_row.values)[0]
     
-    try:
-        X = feature_values.values
-        X_scaled = scaler.transform(X)
-        
-        current_price = float(df.iloc[-1]['close'])
-        current_time = int(df.iloc[-1]['time'])
-        
-        # Get predictions at key horizons
-        horizon_preds = {}
-        for h in KEY_HORIZONS:
-            if h in models:
-                pred_return = models[h].predict(X_scaled)[0]
-                # Clip extreme predictions
-                pred_return = np.clip(pred_return, -15, 15)  # Max ±15% move
-                horizon_preds[h] = pred_return
-        
-        if not horizon_preds:
-            return []
-        
-        # Interpolate for all time steps
-        raw_returns = []
-        for i in range(1, PREDICTION_HORIZON + 1):
-            pct_return = interpolate_predictions(horizon_preds, i)
-            raw_returns.append(pct_return)
-        
-        # Apply trend smoothing
-        smoothed_returns = apply_trend_smoothing(raw_returns, window=7)
-        
-        # Convert to prices with momentum continuation
-        predictions = []
-        prev_price = current_price
-        
-        for i, pct_return in enumerate(smoothed_returns):
-            # Price = current * (1 + cumulative_return%)
-            future_price = current_price * (1 + pct_return / 100)
-            
-            # Add slight momentum continuation (reduces jumps)
-            if i > 0:
-                momentum = (future_price - prev_price) * 0.1
-                future_price = future_price + momentum
-            
-            predictions.append({
-                "time": current_time + ((i + 1) * 60),
-                "value": round(float(future_price), 2)
-            })
-            prev_price = future_price
-        
-        return predictions
+    current_price = df.iloc[-1]['close']
+    current_time = int(df.iloc[-1]['time'])
+    
+    pred_data = []
+    confidence_multiplier = 1.96 
+
+    for i, pct_change in enumerate(predicted_returns):
+        future_price = current_price * (1 + pct_change)
         
-    except Exception as e:
-        logging.error(f"Prediction error: {e}")
-        return []
+        sigma = residual_std[i]
+        upper_bound = future_price * (1 + (sigma * confidence_multiplier))
+        lower_bound = future_price * (1 - (sigma * confidence_multiplier))
 
+        pred_data.append({
+            "time": current_time + ((i + 1) * 60),
+            "value": float(future_price),
+            "upper": float(upper_bound),
+            "lower": float(lower_bound)
+        })
+    
+    return pred_data
 
 def process_market_data():
-    """Process market data and generate predictions"""
     if not market_state['ready'] or not market_state['ohlc_history']:
         return {"error": "Initializing..."}
 
-    # 1. Calculate Indicators
     df = calculate_indicators(market_state['ohlc_history'])
-    if df is None or len(df) < 60:
+    if df is None or len(df) < 100:
         return {"error": "Not enough data"}
 
-    # 2. Train Model Periodically
-    current_time = time.time()
-    should_train = (
-        market_state['models'] is None or 
-        len(market_state['models']) == 0 or
-        (current_time - market_state['last_training_time'] > TRAIN_INTERVAL)
-    )
-    
-    if should_train:
+    if market_state['model'] is None or (time.time() - market_state['last_training_time'] > TRAIN_INTERVAL):
         try:
-            models, scaler = train_model(df)
-            if models:
-                market_state['models'] = models
-                market_state['scaler'] = scaler
-                market_state['last_training_time'] = current_time
+            model, res_std = train_model(df)
+            if model is not None:
+                market_state['model'] = model
+                market_state['model_residuals'] = res_std
+                market_state['last_training_time'] = time.time()
         except Exception as e:
             logging.error(f"Training failed: {e}")
-            import traceback
-            traceback.print_exc()
 
-    # 3. Generate Predictions
     predictions = []
     try:
-        predictions = get_prediction(df, market_state['models'], market_state['scaler'])
+        predictions = get_prediction(df, market_state['model'], market_state['model_residuals'])
     except Exception as e:
         logging.error(f"Prediction failed: {e}")
 
-    # 4. Prepare Display Data
     df_clean = df.replace([np.inf, -np.inf], np.nan)
     df_clean = df_clean.astype(object).where(pd.notnull(df_clean), None)
     
-    # Calculate stats
     last_close = float(df['close'].iloc[-1]) if len(df) > 0 else 0
-    first_close = float(df['close'].iloc[0]) if len(df) > 0 else last_close
+    first_close = float(df['close'].iloc[0]) if len(df) > 0 else 0
     price_change = ((last_close - first_close) / first_close * 100) if first_close > 0 else 0
     
     market_state['last_price'] = last_close
     market_state['price_change'] = price_change
     
-    # Only send last 500 candles to client
     display_data = df_clean.tail(500).to_dict('records')
-    
-    # Extract last row stats safely
-    last_row = df.iloc[-1]
-    
-    def safe_get(series, key, default=0):
-        try:
-            val = series[key] if key in series.index else default
-            return float(val) if pd.notna(val) and np.isfinite(val) else default
-        except:
-            return default
+    last_row = df.iloc[-1] if len(df) > 0 else {}
     
     return {
         "data": display_data,
@@ -450,17 +214,13 @@ def process_market_data():
         "stats": {
             "price": last_close,
             "change": round(price_change, 2),
-            "rsi": round(safe_get(last_row, 'rsi'), 1),
-            "macd": round(safe_get(last_row, 'macd'), 2),
-            "atr": round(safe_get(last_row, 'atr'), 2),
-            "volume": round(safe_get(last_row, 'volume'), 2),
-            "candles": len(market_state['ohlc_history']),
-            "model_ready": len(market_state.get('models', {})) > 0
+            "rsi": round(float(last_row.get('rsi', 0)), 1) if pd.notna(last_row.get('rsi')) else 0,
+            "macd": round(float(last_row.get('macd', 0)), 2) if pd.notna(last_row.get('macd')) else 0,
+            "atr": round(float(last_row.get('atr', 0)), 2) if pd.notna(last_row.get('atr')) else 0,
+            "volume": round(float(last_row.get('volume', 0)), 2) if pd.notna(last_row.get('volume')) else 0
         }
     }
 
-
-# --- FRONTEND HTML ---
 HTML_PAGE = """
 <!DOCTYPE html>
 <html lang="en">
@@ -472,7 +232,6 @@ HTML_PAGE = """
     <link href="https://fonts.googleapis.com/css2?family=Inter:wght@300;400;500;600;700&display=swap" rel="stylesheet">
     <style>
         * { margin: 0; padding: 0; box-sizing: border-box; }
-        
         body {
             font-family: 'Inter', -apple-system, BlinkMacSystemFont, sans-serif;
             background: linear-gradient(135deg, #0a0a0f 0%, #1a1a2e 100%);
@@ -482,7 +241,6 @@ HTML_PAGE = """
             flex-direction: column;
             overflow: hidden;
         }
-        
         .header {
             background: rgba(15, 15, 25, 0.95);
             backdrop-filter: blur(20px);
@@ -493,22 +251,14 @@ HTML_PAGE = """
             justify-content: space-between;
             z-index: 100;
         }
-        
-        .logo-section {
-            display: flex;
-            align-items: center;
-            gap: 16px;
-        }
-        
+        .logo-section { display: flex; align-items: center; gap: 16px; }
         .logo {
             font-size: 24px;
             font-weight: 700;
             background: linear-gradient(135deg, #00ff88 0%, #00d4ff 100%);
             -webkit-background-clip: text;
             -webkit-text-fill-color: transparent;
-            letter-spacing: -0.5px;
         }
-        
         .symbol-badge {
             background: rgba(0, 255, 136, 0.1);
             border: 1px solid rgba(0, 255, 136, 0.3);
@@ -518,77 +268,20 @@ HTML_PAGE = """
             font-weight: 600;
             color: #00ff88;
         }
-        
-        .model-badge {
-            background: rgba(191, 90, 242, 0.1);
-            border: 1px solid rgba(191, 90, 242, 0.3);
-            padding: 4px 10px;
-            border-radius: 12px;
-            font-size: 11px;
-            color: #bf5af2;
-        }
-        
-        .model-badge.ready {
-            background: rgba(0, 255, 136, 0.1);
-            border-color: rgba(0, 255, 136, 0.3);
-            color: #00ff88;
-        }
-        
-        .stats-row {
-            display: flex;
-            gap: 24px;
-            align-items: center;
-        }
-        
-        .stat-item {
-            display: flex;
-            flex-direction: column;
-            align-items: flex-end;
-        }
-        
-        .stat-label {
-            font-size: 10px;
-            color: #666;
-            text-transform: uppercase;
-            letter-spacing: 0.5px;
-        }
-        
-        .stat-value {
-            font-size: 15px;
-            font-weight: 600;
-            font-variant-numeric: tabular-nums;
-        }
-        
+        .stats-row { display: flex; gap: 24px; align-items: center; }
+        .stat-item { display: flex; flex-direction: column; align-items: flex-end; }
+        .stat-label { font-size: 10px; color: #666; text-transform: uppercase; }
+        .stat-value { font-size: 15px; font-weight: 600; font-variant-numeric: tabular-nums; }
         .stat-value.positive { color: #00ff88; }
         .stat-value.negative { color: #ff4757; }
         .stat-value.neutral { color: #ffd700; }
-        
-        .status-indicator {
-            display: flex;
-            align-items: center;
-            gap: 8px;
-            font-size: 12px;
-            color: #888;
-        }
-        
-        .status-dot {
-            width: 8px;
-            height: 8px;
-            border-radius: 50%;
-            background: #00ff88;
-            animation: pulse 2s infinite;
-        }
-        
-        .status-dot.disconnected {
-            background: #ff4757;
-            animation: none;
-        }
-        
+        .status-indicator { display: flex; align-items: center; gap: 8px; font-size: 12px; color: #888; }
+        .status-dot { width: 8px; height: 8px; border-radius: 50%; background: #00ff88; animation: pulse 2s infinite; }
+        .status-dot.disconnected { background: #ff4757; animation: none; }
         @keyframes pulse {
             0%, 100% { opacity: 1; box-shadow: 0 0 0 0 rgba(0, 255, 136, 0.4); }
             50% { opacity: 0.8; box-shadow: 0 0 0 8px rgba(0, 255, 136, 0); }
         }
-        
         .indicator-panel {
             background: rgba(15, 15, 25, 0.8);
             border-bottom: 1px solid rgba(255, 255, 255, 0.05);
@@ -597,123 +290,42 @@ HTML_PAGE = """
             gap: 32px;
             overflow-x: auto;
         }
-        
-        .indicator-group {
-            display: flex;
-            align-items: center;
-            gap: 12px;
-        }
-        
-        .indicator-label {
-            font-size: 11px;
-            color: #666;
-            text-transform: uppercase;
-        }
-        
-        .indicator-value {
-            font-size: 13px;
-            font-weight: 500;
-            font-variant-numeric: tabular-nums;
-        }
-        
+        .indicator-group { display: flex; align-items: center; gap: 12px; }
+        .indicator-label { font-size: 11px; color: #666; text-transform: uppercase; }
+        .indicator-value { font-size: 13px; font-weight: 500; font-variant-numeric: tabular-nums; }
         .charts-container {
             flex: 1;
             display: flex;
             flex-direction: column;
             position: relative;
         }
-        
-        .chart-wrapper {
-            position: relative;
-            border-bottom: 1px solid rgba(255, 255, 255, 0.05);
-        }
-        
+        .chart-wrapper { position: relative; border-bottom: 1px solid rgba(255, 255, 255, 0.05); }
         #main-chart { flex: 5; }
         #volume-chart { flex: 1; min-height: 60px; }
         #osc-chart { flex: 1.5; min-height: 80px; }
-        
         .chart-label {
-            position: absolute;
-            top: 12px;
-            left: 16px;
-            z-index: 10;
-            display: flex;
-            gap: 16px;
-            font-size: 11px;
-            pointer-events: none;
-        }
-        
-        .chart-label span {
-            display: flex;
-            align-items: center;
-            gap: 6px;
+            position: absolute; top: 12px; left: 16px; z-index: 10;
+            display: flex; gap: 16px; font-size: 11px; pointer-events: none;
         }
-        
-        .chart-label .dot {
-            width: 8px;
-            height: 8px;
-            border-radius: 50%;
-        }
-        
+        .chart-label span { display: flex; align-items: center; gap: 6px; }
+        .chart-label .dot { width: 8px; height: 8px; border-radius: 50%; }
         .loading-overlay {
-            position: absolute;
-            top: 0;
-            left: 0;
-            right: 0;
-            bottom: 0;
+            position: absolute; top: 0; left: 0; right: 0; bottom: 0;
             background: rgba(10, 10, 15, 0.95);
-            display: flex;
-            flex-direction: column;
-            align-items: center;
-            justify-content: center;
-            z-index: 1000;
-            transition: opacity 0.5s ease;
-        }
-        
-        .loading-overlay.hidden {
-            opacity: 0;
-            pointer-events: none;
+            display: flex; flex-direction: column; align-items: center; justify-content: center;
+            z-index: 1000; transition: opacity 0.5s ease;
         }
-        
+        .loading-overlay.hidden { opacity: 0; pointer-events: none; }
         .loader {
-            width: 50px;
-            height: 50px;
-            border: 3px solid rgba(0, 255, 136, 0.1);
-            border-top-color: #00ff88;
-            border-radius: 50%;
-            animation: spin 1s linear infinite;
-        }
-        
-        @keyframes spin {
-            to { transform: rotate(360deg); }
+            width: 50px; height: 50px; border: 3px solid rgba(0, 255, 136, 0.1);
+            border-top-color: #00ff88; border-radius: 50%; animation: spin 1s linear infinite;
         }
-        
-        .loading-text {
-            margin-top: 20px;
-            font-size: 14px;
-            color: #666;
-        }
-        
+        @keyframes spin { to { transform: rotate(360deg); } }
+        .loading-text { margin-top: 20px; font-size: 14px; color: #666; }
         .prediction-badge {
-            position: absolute;
-            top: 12px;
-            right: 16px;
-            background: rgba(191, 90, 242, 0.15);
-            border: 1px solid rgba(191, 90, 242, 0.3);
-            padding: 4px 10px;
-            border-radius: 12px;
-            font-size: 10px;
-            color: #bf5af2;
-            z-index: 10;
-        }
-        
-        .candle-count {
-            position: absolute;
-            bottom: 12px;
-            right: 16px;
-            font-size: 10px;
-            color: #444;
-            z-index: 10;
+            position: absolute; top: 12px; right: 16px;
+            background: rgba(191, 90, 242, 0.15); border: 1px solid rgba(191, 90, 242, 0.3);
+            padding: 4px 10px; border-radius: 12px; font-size: 10px; color: #bf5af2; z-index: 10;
         }
     </style>
 </head>
@@ -722,9 +334,7 @@ HTML_PAGE = """
         <div class="logo-section">
             <div class="logo">QuantAI</div>
             <div class="symbol-badge">BTC/USD</div>
-            <div id="model-status" class="model-badge">Model: Training...</div>
         </div>
-        
         <div class="stats-row">
             <div class="stat-item">
                 <span class="stat-label">Price</span>
@@ -743,58 +353,35 @@ HTML_PAGE = """
                 <span id="atr" class="stat-value">--</span>
             </div>
         </div>
-        
         <div class="status-indicator">
             <div id="status-dot" class="status-dot"></div>
             <span id="status-text">Connecting...</span>
         </div>
     </div>
-    
     <div class="indicator-panel">
-        <div class="indicator-group">
-            <span class="indicator-label">EMA 20</span>
-            <span id="ema-val" class="indicator-value" style="color: #2962FF">--</span>
-        </div>
-        <div class="indicator-group">
-            <span class="indicator-label">BB Upper</span>
-            <span id="bb-upper" class="indicator-value" style="color: #26a69a">--</span>
-        </div>
-        <div class="indicator-group">
-            <span class="indicator-label">BB Lower</span>
-            <span id="bb-lower" class="indicator-value" style="color: #ef5350">--</span>
-        </div>
-        <div class="indicator-group">
-            <span class="indicator-label">MACD</span>
-            <span id="macd-val" class="indicator-value">--</span>
-        </div>
-        <div class="indicator-group">
-            <span class="indicator-label">Volume</span>
-            <span id="vol-val" class="indicator-value" style="color: #888">--</span>
-        </div>
+        <div class="indicator-group"><span class="indicator-label">EMA 20</span><span id="ema-val" class="indicator-value" style="color: #2962FF">--</span></div>
+        <div class="indicator-group"><span class="indicator-label">BB Upper</span><span id="bb-upper" class="indicator-value" style="color: #26a69a">--</span></div>
+        <div class="indicator-group"><span class="indicator-label">BB Lower</span><span id="bb-lower" class="indicator-value" style="color: #ef5350">--</span></div>
+        <div class="indicator-group"><span class="indicator-label">MACD</span><span id="macd-val" class="indicator-value">--</span></div>
+        <div class="indicator-group"><span class="indicator-label">Volume</span><span id="vol-val" class="indicator-value" style="color: #888">--</span></div>
     </div>
-
     <div class="charts-container">
         <div class="loading-overlay" id="loading">
             <div class="loader"></div>
             <div class="loading-text">Loading market data...</div>
         </div>
-        
         <div id="main-chart" class="chart-wrapper">
             <div class="chart-label">
                 <span><div class="dot" style="background: #00ff88"></div>Price</span>
                 <span><div class="dot" style="background: #2962FF"></div>EMA 20</span>
                 <span><div class="dot" style="background: #26a69a; opacity: 0.5"></div>Bollinger</span>
+                <span><div class="dot" style="background: #bf5af2"></div>AI + 95% Conf</span>
             </div>
             <div class="prediction-badge">AI Forecast: 100 candles</div>
-            <div id="candle-count" class="candle-count">Candles: --</div>
         </div>
-        
         <div id="volume-chart" class="chart-wrapper">
-            <div class="chart-label">
-                <span><div class="dot" style="background: #5c6bc0"></div>Volume</span>
-            </div>
+            <div class="chart-label"><span><div class="dot" style="background: #5c6bc0"></div>Volume</span></div>
         </div>
-        
         <div id="osc-chart" class="chart-wrapper">
             <div class="chart-label">
                 <span><div class="dot" style="background: #9C27B0"></div>RSI</span>
@@ -802,7 +389,6 @@ HTML_PAGE = """
             </div>
         </div>
     </div>
-
 <script>
 document.addEventListener('DOMContentLoaded', () => {
     const mainEl = document.getElementById('main-chart');
@@ -811,32 +397,14 @@ document.addEventListener('DOMContentLoaded', () => {
     const loading = document.getElementById('loading');
 
     const chartOptions = {
-        layout: {
-            background: { type: 'solid', color: 'transparent' },
-            textColor: '#666'
-        },
-        grid: {
-            vertLines: { color: 'rgba(255,255,255,0.03)' },
-            horzLines: { color: 'rgba(255,255,255,0.03)' }
-        },
-        timeScale: {
-            timeVisible: true,
-            secondsVisible: false,
-            borderColor: 'rgba(255,255,255,0.1)'
-        },
-        rightPriceScale: {
-            borderColor: 'rgba(255,255,255,0.1)'
-        },
+        layout: { background: { type: 'solid', color: 'transparent' }, textColor: '#666' },
+        grid: { vertLines: { color: 'rgba(255,255,255,0.03)' }, horzLines: { color: 'rgba(255,255,255,0.03)' } },
+        timeScale: { timeVisible: true, secondsVisible: false, borderColor: 'rgba(255,255,255,0.1)' },
+        rightPriceScale: { borderColor: 'rgba(255,255,255,0.1)' },
         crosshair: {
             mode: LightweightCharts.CrosshairMode.Normal,
-            vertLine: {
-                color: 'rgba(255,255,255,0.2)',
-                labelBackgroundColor: '#1a1a2e'
-            },
-            horzLine: {
-                color: 'rgba(255,255,255,0.2)',
-                labelBackgroundColor: '#1a1a2e'
-            }
+            vertLine: { color: 'rgba(255,255,255,0.2)', labelBackgroundColor: '#1a1a2e' },
+            horzLine: { color: 'rgba(255,255,255,0.2)', labelBackgroundColor: '#1a1a2e' }
         }
     };
 
@@ -845,117 +413,51 @@ document.addEventListener('DOMContentLoaded', () => {
     const oscChart = LightweightCharts.createChart(oscEl, chartOptions);
 
     const candles = mainChart.addCandlestickSeries({
-        upColor: '#00ff88',
-        downColor: '#ff4757',
-        borderUpColor: '#00ff88',
-        borderDownColor: '#ff4757',
-        wickUpColor: '#00ff88',
-        wickDownColor: '#ff4757'
+        upColor: '#00ff88', downColor: '#ff4757',
+        borderUpColor: '#00ff88', borderDownColor: '#ff4757',
+        wickUpColor: '#00ff88', wickDownColor: '#ff4757'
     });
 
-    const ema = mainChart.addLineSeries({
-        color: '#2962FF',
-        lineWidth: 2,
-        crosshairMarkerVisible: false
-    });
-
-    const bbUpper = mainChart.addLineSeries({
-        color: 'rgba(38, 166, 154, 0.4)',
-        lineWidth: 1,
-        crosshairMarkerVisible: false
-    });
-
-    const bbLower = mainChart.addLineSeries({
-        color: 'rgba(239, 83, 80, 0.4)',
-        lineWidth: 1,
-        crosshairMarkerVisible: false
-    });
+    const ema = mainChart.addLineSeries({ color: '#2962FF', lineWidth: 2, crosshairMarkerVisible: false });
+    const bbUpper = mainChart.addLineSeries({ color: 'rgba(38, 166, 154, 0.4)', lineWidth: 1, crosshairMarkerVisible: false });
+    const bbLower = mainChart.addLineSeries({ color: 'rgba(239, 83, 80, 0.4)', lineWidth: 1, crosshairMarkerVisible: false });
 
     const predLine = mainChart.addLineSeries({
-        color: '#bf5af2',
-        lineWidth: 2,
-        lineStyle: LightweightCharts.LineStyle.Dashed,
-        crosshairMarkerVisible: false,
-        title: 'Forecast'
+        color: '#bf5af2', lineWidth: 2, lineStyle: LightweightCharts.LineStyle.Dashed,
+        crosshairMarkerVisible: false, title: 'Forecast'
     });
     
-    // Prediction confidence band (optional visual)
     const predUpper = mainChart.addLineSeries({
-        color: 'rgba(191, 90, 242, 0.15)',
-        lineWidth: 1,
-        lineStyle: LightweightCharts.LineStyle.Dotted,
+        color: 'rgba(191, 90, 242, 0.3)', lineWidth: 1, lineStyle: LightweightCharts.LineStyle.Dotted,
         crosshairMarkerVisible: false
     });
     
     const predLower = mainChart.addLineSeries({
-        color: 'rgba(191, 90, 242, 0.15)',
-        lineWidth: 1,
-        lineStyle: LightweightCharts.LineStyle.Dotted,
+        color: 'rgba(191, 90, 242, 0.3)', lineWidth: 1, lineStyle: LightweightCharts.LineStyle.Dotted,
         crosshairMarkerVisible: false
     });
 
-    const volumeSeries = volChart.addHistogramSeries({
-        priceFormat: { type: 'volume' },
-        priceScaleId: ''
-    });
-    volChart.priceScale('').applyOptions({
-        scaleMargins: { top: 0.1, bottom: 0 }
-    });
+    const volumeSeries = volChart.addHistogramSeries({ priceFormat: { type: 'volume' }, priceScaleId: '' });
+    volChart.priceScale('').applyOptions({ scaleMargins: { top: 0.1, bottom: 0 } });
 
-    const rsi = oscChart.addLineSeries({
-        color: '#9C27B0',
-        lineWidth: 2,
-        priceScaleId: 'rsi'
-    });
-    
-    // RSI overbought/oversold lines
-    const rsiUpper = oscChart.addLineSeries({
-        color: 'rgba(239, 83, 80, 0.3)',
-        lineWidth: 1,
-        lineStyle: LightweightCharts.LineStyle.Dashed,
-        priceScaleId: 'rsi'
-    });
-    
-    const rsiLower = oscChart.addLineSeries({
-        color: 'rgba(38, 166, 154, 0.3)',
-        lineWidth: 1,
-        lineStyle: LightweightCharts.LineStyle.Dashed,
-        priceScaleId: 'rsi'
-    });
-    
-    oscChart.priceScale('rsi').applyOptions({
-        scaleMargins: { top: 0.1, bottom: 0.1 }
-    });
+    const rsi = oscChart.addLineSeries({ color: '#9C27B0', lineWidth: 2, priceScaleId: 'rsi' });
+    oscChart.priceScale('rsi').applyOptions({ scaleMargins: { top: 0.1, bottom: 0.1 } });
 
-    const macdHist = oscChart.addHistogramSeries({
-        priceScaleId: 'macd'
-    });
-    oscChart.priceScale('macd').applyOptions({
-        scaleMargins: { top: 0.6, bottom: 0 }
-    });
+    const macdHist = oscChart.addHistogramSeries({ priceScaleId: 'macd' });
+    oscChart.priceScale('macd').applyOptions({ scaleMargins: { top: 0.6, bottom: 0 } });
 
     function resizeCharts() {
-        const mainH = mainEl.clientHeight;
-        const volH = volEl.clientHeight;
-        const oscH = oscEl.clientHeight;
-        const w = mainEl.clientWidth;
-
-        mainChart.applyOptions({ width: w, height: mainH });
-        volChart.applyOptions({ width: w, height: volH });
-        oscChart.applyOptions({ width: w, height: oscH });
+        mainChart.applyOptions({ width: mainEl.clientWidth, height: mainEl.clientHeight });
+        volChart.applyOptions({ width: mainEl.clientWidth, height: volEl.clientHeight });
+        oscChart.applyOptions({ width: mainEl.clientWidth, height: oscEl.clientHeight });
     }
-
     new ResizeObserver(resizeCharts).observe(document.body);
     setTimeout(resizeCharts, 100);
 
     function syncTimeScales(charts) {
         charts.forEach((chart, i) => {
             chart.timeScale().subscribeVisibleLogicalRangeChange(range => {
-                if (range) {
-                    charts.forEach((c, j) => {
-                        if (i !== j) c.timeScale().setVisibleLogicalRange(range);
-                    });
-                }
+                if (range) charts.forEach((c, j) => { if (i !== j) c.timeScale().setVisibleLogicalRange(range); });
             });
         });
     }
@@ -963,45 +465,26 @@ document.addEventListener('DOMContentLoaded', () => {
 
     function updateStats(stats, lastData) {
         if (stats) {
-            document.getElementById('price').textContent = '$' + stats.price.toLocaleString('en-US', {minimumFractionDigits: 2, maximumFractionDigits: 2});
-            
+            document.getElementById('price').textContent = '$' + stats.price.toLocaleString('en-US', {minimumFractionDigits: 2});
             const changeEl = document.getElementById('change');
             changeEl.textContent = (stats.change >= 0 ? '+' : '') + stats.change + '%';
             changeEl.className = 'stat-value ' + (stats.change > 0 ? 'positive' : stats.change < 0 ? 'negative' : 'neutral');
-            
             const rsiVal = stats.rsi;
             const rsiEl = document.getElementById('rsi');
             rsiEl.textContent = rsiVal;
             rsiEl.className = 'stat-value ' + (rsiVal > 70 ? 'negative' : rsiVal < 30 ? 'positive' : 'neutral');
-            
             document.getElementById('atr').textContent = stats.atr;
-            
-            // Update model status
-            const modelBadge = document.getElementById('model-status');
-            if (stats.model_ready) {
-                modelBadge.textContent = 'Model: Active';
-                modelBadge.className = 'model-badge ready';
-            } else {
-                modelBadge.textContent = 'Model: Training...';
-                modelBadge.className = 'model-badge';
-            }
-            
-            // Update candle count
-            document.getElementById('candle-count').textContent = 'Candles: ' + (stats.candles || '--');
         }
-        
         if (lastData) {
             document.getElementById('ema-val').textContent = lastData.ema20 ? lastData.ema20.toFixed(2) : '--';
             document.getElementById('bb-upper').textContent = lastData.bb_upper ? lastData.bb_upper.toFixed(2) : '--';
             document.getElementById('bb-lower').textContent = lastData.bb_lower ? lastData.bb_lower.toFixed(2) : '--';
-            
             const macdVal = lastData.macd;
             const macdEl = document.getElementById('macd-val');
             if (macdVal !== null && macdVal !== undefined) {
                 macdEl.textContent = macdVal.toFixed(2);
                 macdEl.style.color = macdVal >= 0 ? '#26a69a' : '#ef5350';
             }
-            
             document.getElementById('vol-val').textContent = lastData.volume ? lastData.volume.toFixed(2) : '--';
         }
     }
@@ -1009,126 +492,59 @@ document.addEventListener('DOMContentLoaded', () => {
     function setStatus(connected) {
         const dot = document.getElementById('status-dot');
         const text = document.getElementById('status-text');
-        if (connected) {
-            dot.className = 'status-dot';
-            text.textContent = 'Live';
-        } else {
-            dot.className = 'status-dot disconnected';
-            text.textContent = 'Reconnecting...';
-        }
+        if (connected) { dot.className = 'status-dot'; text.textContent = 'Live'; } 
+        else { dot.className = 'status-dot disconnected'; text.textContent = 'Reconnecting...'; }
     }
 
     let hasData = false;
-
     function connect() {
         const protocol = location.protocol === 'https:' ? 'wss' : 'ws';
         const ws = new WebSocket(protocol + '://' + location.host + '/ws');
-        
         ws.onopen = () => setStatus(true);
-        
         ws.onmessage = (e) => {
             try {
                 const payload = JSON.parse(e.data);
                 if (!payload.data || payload.data.length === 0) return;
-                
                 const d = payload.data;
-                
-                const safeMap = (arr, key) => arr
-                    .filter(x => x && x.time && x[key] !== null && x[key] !== undefined && !isNaN(x[key]))
-                    .map(x => ({ time: x.time, value: x[key] }));
-
-                const candleData = d
-                    .filter(x => x && x.time && x.open && x.high && x.low && x.close)
-                    .map(x => ({
-                        time: x.time,
-                        open: x.open,
-                        high: x.high,
-                        low: x.low,
-                        close: x.close
-                    }));
-
+                const safeMap = (arr, key) => arr.filter(x => x && x.time && x[key] !== null).map(x => ({ time: x.time, value: x[key] }));
+                const candleData = d.filter(x => x && x.time && x.open).map(x => ({
+                    time: x.time, open: x.open, high: x.high, low: x.low, close: x.close
+                }));
                 if (candleData.length > 0) {
                     candles.setData(candleData);
+                    ema.setData(safeMap(d, 'ema20'));
+                    bbUpper.setData(safeMap(d, 'bb_upper'));
+                    bbLower.setData(safeMap(d, 'bb_lower'));
+                    volumeSeries.setData(d.filter(x => x && x.time).map(x => ({
+                        time: x.time, value: x.volume, color: x.close >= x.open ? 'rgba(0, 255, 136, 0.5)' : 'rgba(255, 71, 87, 0.5)'
+                    })));
+                    rsi.setData(safeMap(d, 'rsi'));
+                    macdHist.setData(d.filter(x => x && x.time).map(x => ({
+                        time: x.time, value: x.macd_hist, color: x.macd_hist >= 0 ? '#26a69a' : '#ef5350'
+                    })));
                     
-                    const emaData = safeMap(d, 'ema20');
-                    if (emaData.length > 0) ema.setData(emaData);
-                    
-                    const bbUpperData = safeMap(d, 'bb_upper');
-                    if (bbUpperData.length > 0) bbUpper.setData(bbUpperData);
-                    
-                    const bbLowerData = safeMap(d, 'bb_lower');
-                    if (bbLowerData.length > 0) bbLower.setData(bbLowerData);
-                    
-                    const volData = d
-                        .filter(x => x && x.time && x.volume !== null && x.volume !== undefined)
-                        .map(x => ({
-                            time: x.time,
-                            value: x.volume,
-                            color: x.close >= x.open ? 'rgba(0, 255, 136, 0.5)' : 'rgba(255, 71, 87, 0.5)'
-                        }));
-                    if (volData.length > 0) volumeSeries.setData(volData);
-                    
-                    const rsiData = safeMap(d, 'rsi');
-                    if (rsiData.length > 0) {
-                        rsi.setData(rsiData);
-                        // Set RSI reference lines
-                        const times = rsiData.map(x => x.time);
-                        rsiUpper.setData(times.map(t => ({time: t, value: 70})));
-                        rsiLower.setData(times.map(t => ({time: t, value: 30})));
-                    }
-                    
-                    const macdData = d
-                        .filter(x => x && x.time && x.macd_hist !== null && x.macd_hist !== undefined && !isNaN(x.macd_hist))
-                        .map(x => ({
-                            time: x.time,
-                            value: x.macd_hist,
-                            color: x.macd_hist >= 0 ? '#26a69a' : '#ef5350'
-                        }));
-                    if (macdData.length > 0) macdHist.setData(macdData);
-                    
-                    // Handle predictions with confidence bands
                     if (payload.prediction && payload.prediction.length > 0) {
                         const lastCandle = candleData[candleData.length - 1];
-                        const predData = [
-                            { time: lastCandle.time, value: lastCandle.close },
-                            ...payload.prediction.filter(p => p && p.time && p.value !== null && !isNaN(p.value))
-                        ];
-                        predLine.setData(predData);
+                        const predData = [{ time: lastCandle.time, value: lastCandle.close }, ...payload.prediction.map(p => ({ time: p.time, value: p.value }))];
+                        const upperData = [{ time: lastCandle.time, value: lastCandle.close }, ...payload.prediction.map(p => ({ time: p.time, value: p.upper }))];
+                        const lowerData = [{ time: lastCandle.time, value: lastCandle.close }, ...payload.prediction.map(p => ({ time: p.time, value: p.lower }))];
                         
-                        // Add confidence bands (±1% expanding over time)
-                        const upperBand = predData.map((p, i) => ({
-                            time: p.time,
-                            value: p.value * (1 + 0.002 * Math.sqrt(i))
-                        }));
-                        const lowerBand = predData.map((p, i) => ({
-                            time: p.time,
-                            value: p.value * (1 - 0.002 * Math.sqrt(i))
-                        }));
-                        predUpper.setData(upperBand);
-                        predLower.setData(lowerBand);
+                        predLine.setData(predData);
+                        predUpper.setData(upperData);
+                        predLower.setData(lowerData);
                     }
-                    
                     updateStats(payload.stats, d[d.length - 1]);
-                    
                     if (!hasData) {
                         hasData = true;
                         loading.classList.add('hidden');
                         mainChart.timeScale().fitContent();
                     }
                 }
-            } catch (err) {
-                console.error("Chart error:", err);
-            }
+            } catch (err) { console.error("Chart error:", err); }
         };
-        
-        ws.onclose = () => {
-            setStatus(false);
-            setTimeout(connect, 2000);
-        };
-        
+        ws.onclose = () => { setStatus(false); setTimeout(connect, 2000); };
         ws.onerror = () => ws.close();
     }
-    
     connect();
 });
 </script>
@@ -1136,9 +552,7 @@ document.addEventListener('DOMContentLoaded', () => {
 </html>
 """
 
-
 async def fetch_initial_data():
-    """Fetch initial OHLC data from Kraken"""
     try:
         async with aiohttp.ClientSession() as session:
             url = "https://api.kraken.com/0/public/OHLC?pair=XBTUSD&interval=1"
@@ -1167,9 +581,7 @@ async def fetch_initial_data():
         logging.error(f"Initial data fetch error: {e}")
     return False
 
-
 async def kraken_rest_worker():
-    """Background worker to fetch and update OHLC data"""
     await fetch_initial_data()
     
     while True:
@@ -1192,7 +604,7 @@ async def kraken_rest_worker():
                                             'close': float(c[4]),
                                             'volume': float(c[6])
                                         }
-                                        for c in raw[-20:]  # Get last 20 candles for merging
+                                        for c in raw[-10:]
                                     ]
                                     
                                     if market_state['ohlc_history']:
@@ -1218,9 +630,7 @@ async def kraken_rest_worker():
         
         await asyncio.sleep(5)
 
-
 async def broadcast_worker():
-    """Broadcast market data to connected clients"""
     while True:
         if connected_clients and market_state['ready']:
             payload = process_market_data()
@@ -1235,42 +645,24 @@ async def broadcast_worker():
                 connected_clients.difference_update(disconnected)
         await asyncio.sleep(BROADCAST_RATE)
 
-
 async def websocket_handler(request):
-    """Handle WebSocket connections"""
     ws = web.WebSocketResponse()
     await ws.prepare(request)
     connected_clients.add(ws)
-    logging.info(f"Client connected. Total: {len(connected_clients)}")
     try:
         async for msg in ws:
             pass
     finally:
         connected_clients.discard(ws)
-        logging.info(f"Client disconnected. Total: {len(connected_clients)}")
     return ws
 
-
 async def handle_index(request):
     return web.Response(text=HTML_PAGE, content_type='text/html')
 
-
-async def handle_health(request):
-    return web.json_response({
-        "status": "ok",
-        "ready": market_state['ready'],
-        "candles": len(market_state['ohlc_history']),
-        "clients": len(connected_clients),
-        "model_ready": len(market_state.get('models', {})) > 0,
-        "training_metrics": market_state.get('training_metrics', {})
-    })
-
-
 async def main():
     app = web.Application()
     app.router.add_get('/', handle_index)
     app.router.add_get('/ws', websocket_handler)
-    app.router.add_get('/health', handle_health)
     
     asyncio.create_task(kraken_rest_worker())
     asyncio.create_task(broadcast_worker())
@@ -1284,9 +676,8 @@ async def main():
     
     await asyncio.Event().wait()
 
-
 if __name__ == "__main__":
     try:
         asyncio.run(main())
     except KeyboardInterrupt:
-        logging.info("Shutting down...")
+        pass