Update backend and frontend: Syncing latest changes to HuggingFace

.gitignore

@@ -6,3 +6,7 @@ __pycache__/
 *.db
 .tmp.*/
 .vscode/
+build/
+dist/
+scratch/
+*.spec

backend/main.py

@@ -1175,7 +1175,7 @@ def _get_source_priority(symbol: str) -> List[str]:
 
 
 async def fetch_historical(
-    symbol: str, interval: str, limit: int
+    symbol: str, interval: str, limit: int, refresh: bool = False
 ) -> Tuple[List[Dict[str, Any]], str]:
     """
     Fetch OHLCV data with fallback and caching.
@@ -1183,15 +1183,18 @@ async def fetch_historical(
     """
     prefix = _cache_prefix(symbol, interval)
     key    = f"hist_{prefix}"  # BUG-P1-03: No limit in key to increase cache hits
-    cached = historical_cache.get(key)
-    if cached is not None:
-        try:
-            # v6.1: Cache stores (data, source)
-            data_cached, source_cached = cached
-            return data_cached[-limit:], source_cached
-        except (ValueError, TypeError):
-            # Handle old cache format gracefully
-            historical_cache.delete(key)
+    if refresh:
+        historical_cache.delete(key)
+    else:
+        cached = historical_cache.get(key)
+        if cached is not None:
+            try:
+                # v6.1: Cache stores (data, source)
+                data_cached, source_cached = cached
+                return data_cached[-limit:], source_cached
+            except (ValueError, TypeError):
+                # Handle old cache format gracefully
+                historical_cache.delete(key)
 
     priority = _get_source_priority(symbol)
     errors: List[str] = []
@@ -1357,9 +1360,12 @@ def _rsi(close: np.ndarray, period: int = 14) -> np.ndarray:
     
     avg_gain = pd.Series(gain).ewm(alpha=1.0/period, adjust=False).mean()
     avg_loss = pd.Series(loss).ewm(alpha=1.0/period, adjust=False).mean()
-    
-    rs = avg_gain / avg_loss.replace(0, np.inf)
+
+    rs = avg_gain / avg_loss.replace(0, np.nan)
     rsi = 100 - (100 / (1 + rs))
+    rsi = rsi.where(avg_loss > 0, 100.0)
+    rsi = rsi.where(avg_gain > 0, 0.0)
+    rsi = rsi.where(~((avg_gain == 0) & (avg_loss == 0)), 50.0)
     # Prepend NaN to match original array length
     return np.concatenate([[np.nan], rsi.values])
 
@@ -1367,7 +1373,7 @@ def _bollinger(close: np.ndarray, period=20, k=2.0) -> Tuple[np.ndarray, np.ndar
     """Vectorized Bollinger Bands."""
     s = pd.Series(close)
     mid = s.rolling(window=period).mean()
-    std = s.rolling(window=period).std()
+    std = s.rolling(window=period).std(ddof=0)
     return (mid + k*std).values, mid.values, (mid - k*std).values
 
 
@@ -1452,6 +1458,62 @@ def _momentum(close: np.ndarray, period: int = 10) -> np.ndarray:
     return pd.Series(close).diff(period).values
 
 
+def _roc(close: np.ndarray, period: int = 12) -> np.ndarray:
+    """Rate of Change in percentage."""
+    base = pd.Series(close).shift(period)
+    return (pd.Series(close) / base.replace(0, np.nan) - 1.0).mul(100.0).values
+
+
+def _trix(close: np.ndarray, period: int = 18) -> np.ndarray:
+    """Triple EMA oscillator in percentage."""
+    ema1 = pd.Series(_ema(close, period))
+    ema2 = ema1.ewm(span=period, adjust=False).mean()
+    ema3 = ema2.ewm(span=period, adjust=False).mean()
+    return ema3.pct_change().mul(100.0).values
+
+
+def _ppo(close: np.ndarray, fast: int = 12, slow: int = 26) -> np.ndarray:
+    """Percentage Price Oscillator."""
+    ema_fast = _ema(close, fast)
+    ema_slow = _ema(close, slow)
+    return ((ema_fast - ema_slow) / np.where(np.abs(ema_slow) < 1e-8, np.nan, ema_slow) * 100.0)
+
+
+def _cmo(close: np.ndarray, period: int = 14) -> np.ndarray:
+    """Chande Momentum Oscillator."""
+    delta = pd.Series(close).diff()
+    up = delta.clip(lower=0.0).rolling(period).sum()
+    down = (-delta.clip(upper=0.0)).rolling(period).sum()
+    return ((up - down) / (up + down).replace(0, np.nan) * 100.0).values
+
+
+def _dpo(close: np.ndarray, period: int = 20) -> np.ndarray:
+    """Detrended Price Oscillator."""
+    offset = int(period / 2) + 1
+    sma = pd.Series(close).rolling(period).mean()
+    return (pd.Series(close) - sma.shift(offset)).values
+
+
+def _aroon_oscillator(high: np.ndarray, low: np.ndarray, period: int = 25) -> np.ndarray:
+    """Aroon Oscillator = Aroon Up - Aroon Down."""
+    hs = pd.Series(high)
+    ls = pd.Series(low)
+    aroon_up = hs.rolling(period).apply(lambda x: ((period - 1 - (len(x) - 1 - int(np.argmax(x)))) / (period - 1)) * 100.0, raw=True)
+    aroon_down = ls.rolling(period).apply(lambda x: ((period - 1 - (len(x) - 1 - int(np.argmin(x)))) / (period - 1)) * 100.0, raw=True)
+    return (aroon_up - aroon_down).values
+
+
+def _tsi(close: np.ndarray, long_period: int = 25, short_period: int = 13) -> np.ndarray:
+    """True Strength Index."""
+    delta = pd.Series(close).diff()
+    abs_delta = delta.abs()
+    ema1 = delta.ewm(span=long_period, adjust=False).mean()
+    ema2 = ema1.ewm(span=short_period, adjust=False).mean()
+    abs_ema1 = abs_delta.ewm(span=long_period, adjust=False).mean()
+    abs_ema2 = abs_ema1.ewm(span=short_period, adjust=False).mean()
+    return (ema2 / abs_ema2.replace(0, np.nan) * 100.0).values
+
+
 def _williams_r(high: np.ndarray, low: np.ndarray, close: np.ndarray,
                 period: int = 14) -> np.ndarray:
     """Vectorized Williams %R."""
@@ -1507,14 +1569,25 @@ def _vwma(close: np.ndarray, volume: np.ndarray, period: int = 20) -> np.ndarray
     return (cv.rolling(period).sum() / v.rolling(period).sum().replace(0, np.inf)).values
 
 
+def _wma(arr: np.ndarray, period: int) -> np.ndarray:
+    """Weighted moving average used by Hull MA."""
+    if len(arr) == 0:
+        return np.array([], dtype=float)
+    weights = np.arange(1, period + 1, dtype=float)
+    return pd.Series(arr).rolling(window=period).apply(
+        lambda x: float(np.dot(x, weights) / weights.sum()),
+        raw=True,
+    ).values
+
+
 def _hull_ma(close: np.ndarray, period: int = 9) -> np.ndarray:
     """Hull Moving Average."""
     half = max(period // 2, 1)
     sqrt_p = max(int(math.sqrt(period)), 1)
-    wma_half = _sma(close, half)
-    wma_full = _sma(close, period)
+    wma_half = _wma(close, half)
+    wma_full = _wma(close, period)
     diff = 2 * wma_half - wma_full
-    hull = _sma(np.where(np.isnan(diff), close, diff), sqrt_p)
+    hull = _wma(np.where(np.isnan(diff), close, diff), sqrt_p)
     return hull
 
 
@@ -1607,6 +1680,20 @@ def _osc_action(name: str, value: float, **kw) -> str:
     """Classify oscillator value as 'Mua' / 'Bán' / 'Trung lập'."""
     if value is None or math.isnan(value):
         return "Trung lập"
+    if name == "roc":
+        return "Mua" if value > 1.0 else "Bán" if value < -1.0 else "Trung lập"
+    if name == "trix":
+        return "Mua" if value > 0 else "Bán" if value < 0 else "Trung lập"
+    if name == "ppo":
+        return "Mua" if value > 0.35 else "Bán" if value < -0.35 else "Trung lập"
+    if name == "cmo":
+        return "Mua" if value > 20 else "Bán" if value < -20 else "Trung lập"
+    if name == "dpo":
+        return "Mua" if value > 0 else "Bán" if value < 0 else "Trung lập"
+    if name == "aroon":
+        return "Mua" if value > 25 else "Bán" if value < -25 else "Trung lập"
+    if name == "tsi":
+        return "Mua" if value > 5 else "Bán" if value < -5 else "Trung lập"
     if name == "rsi":
         return "Bán" if value > 70 else "Mua" if value < 30 else "Trung lập"
     if name == "stoch":
@@ -1644,6 +1731,49 @@ def _ma_action(price: float, ma_val: float) -> str:
     return "Mua" if price > ma_val else "Bán"
 
 
+def _osc_signal_score(name: str, value: float, **kw) -> float:
+    """Continuous oscillator score in [-1, 1] for weighting strength internally."""
+    if value is None or math.isnan(value):
+        return 0.0
+
+    scale = max(float(kw.get("scale", 1.0) or 1.0), 1e-8)
+
+    if name == "rsi":
+        return _clamp((50.0 - value) / 25.0, -1.0, 1.0)
+    if name in {"stoch", "stoch_rsi"}:
+        return _clamp((50.0 - value) / 30.0, -1.0, 1.0)
+    if name == "cci":
+        return _clamp(-value / 150.0, -1.0, 1.0)
+    if name == "adx":
+        plus_di = float(kw.get("plus_di", 0.0) or 0.0)
+        minus_di = float(kw.get("minus_di", 0.0) or 0.0)
+        strength = _clamp((value - 18.0) / 22.0, 0.0, 1.0)
+        direction = math.tanh((plus_di - minus_di) / max(plus_di + minus_di, 10.0) * 3.0)
+        return _clamp(direction * strength, -1.0, 1.0)
+    if name in {"ao", "momentum", "bbp", "dpo"}:
+        return _clamp(math.tanh(value / scale), -1.0, 1.0)
+    if name == "macd":
+        signal = float(kw.get("signal", 0.0) or 0.0)
+        return _clamp(math.tanh((value - signal) / scale), -1.0, 1.0)
+    if name == "williams":
+        return _clamp(((-50.0) - value) / 30.0, -1.0, 1.0)
+    if name == "ultimate":
+        return _clamp((50.0 - value) / 25.0, -1.0, 1.0)
+    if name == "roc":
+        return _clamp(math.tanh(value / 3.0), -1.0, 1.0)
+    if name == "trix":
+        return _clamp(math.tanh(value / 0.35), -1.0, 1.0)
+    if name == "ppo":
+        return _clamp(math.tanh(value / 0.8), -1.0, 1.0)
+    if name == "cmo":
+        return _clamp(value / 55.0, -1.0, 1.0)
+    if name == "aroon":
+        return _clamp(value / 65.0, -1.0, 1.0)
+    if name == "tsi":
+        return _clamp(value / 25.0, -1.0, 1.0)
+    return 0.0
+
+
 def compute_indicators(data: List[Dict[str, Any]]) -> Dict[str, Any]:
     """Compute a full suite of technical indicators on OHLCV data."""
     if len(data) < 30:
@@ -1677,6 +1807,13 @@ def compute_indicators(data: List[Dict[str, Any]]) -> Dict[str, Any]:
     bb_u, bb_m, bb_l       = _bollinger(closes)
     atr14  = _atr(highs, lows, closes, 14)
     stoch_k, stoch_d       = _stoch_rsi(closes)
+    roc12  = _roc(closes, 12)
+    trix18 = _trix(closes, 18)
+    ppo12  = _ppo(closes, 12, 26)
+    cmo14  = _cmo(closes, 14)
+    dpo20  = _dpo(closes, 20)
+    aroon25 = _aroon_oscillator(highs, lows, 25)
+    tsi25  = _tsi(closes, 25, 13)
 
     # Volume SMA 20 (Vectorized v6.0)
     vol_sma = _sma(vols, 20)
@@ -1726,6 +1863,34 @@ def compute_indicators(data: List[Dict[str, Any]]) -> Dict[str, Any]:
                 else "neutral"
             ),
         },
+        "roc": {
+            "value": _last(roc12),
+            "signal": "bullish" if (_last(roc12) or 0) > 1.0 else "bearish" if (_last(roc12) or 0) < -1.0 else "neutral",
+        },
+        "trix": {
+            "value": _last(trix18),
+            "signal": "bullish" if (_last(trix18) or 0) > 0 else "bearish" if (_last(trix18) or 0) < 0 else "neutral",
+        },
+        "ppo": {
+            "value": _last(ppo12),
+            "signal": "bullish" if (_last(ppo12) or 0) > 0.35 else "bearish" if (_last(ppo12) or 0) < -0.35 else "neutral",
+        },
+        "cmo": {
+            "value": _last(cmo14),
+            "signal": "bullish" if (_last(cmo14) or 0) > 20 else "bearish" if (_last(cmo14) or 0) < -20 else "neutral",
+        },
+        "dpo": {
+            "value": _last(dpo20),
+            "signal": "bullish" if (_last(dpo20) or 0) > 0 else "bearish" if (_last(dpo20) or 0) < 0 else "neutral",
+        },
+        "aroon": {
+            "value": _last(aroon25),
+            "signal": "bullish" if (_last(aroon25) or 0) > 25 else "bearish" if (_last(aroon25) or 0) < -25 else "neutral",
+        },
+        "tsi": {
+            "value": _last(tsi25),
+            "signal": "bullish" if (_last(tsi25) or 0) > 5 else "bearish" if (_last(tsi25) or 0) < -5 else "neutral",
+        },
         "volume": {
             "last":       round(float(vols[-1]), 2),
             "sma20":      round(float(vol_sma[-1]), 2),
@@ -1881,26 +2046,24 @@ def _blend_forecasts(
 
     bias_pct = abs((scale - 1.0) * 100.0)
     
-    # Refined confidence score
-    confidence = 60.0
-    confidence += 15.0 if agreement else -10.0
-    
-    # Trend alignment (Bull/Bear stack)
-    if indicators["trend"].get("ema_bullish_stack") and model_dir > 0:
-        confidence += 10.0
-    elif not indicators["trend"].get("ema_bullish_stack") and model_dir < 0:
-         # Bearish stack + down forecast
-         confidence += 5.0
-         
-    # Penalty for high uncertainty (wide bands)
-    confidence -= min(25.0, band_width_pct * 150.0)
-    # Penalty for extreme bias/scaling corrections
-    confidence -= min(15.0, bias_pct * 0.5)
-    # Penalty for low volume relative to average
-    if not indicators["volume"].get("above_avg"):
-        confidence -= 5.0
-        
-    confidence = _clamp(confidence, 10.0, 95.0)
+    # B-2: Advanced confidence (v6.1 Rework)
+    # We use a simplified version of the new AI scoring logic here to keep blended dict consistent
+    forecast_ret_pct = abs((blend_p50[-1] - last_close) / last_close * 100) if last_close else 0
+    atr_pct = float(indicators["atr"].get("pct") or 1.0)
+    
+    # Certainty (band width)
+    band_pct = abs(blend_p90[-1] - blend_p10[-1]) / abs(blend_p50[-1]) if abs(blend_p50[-1]) > 1e-8 else 0.1
+    certainty = math.exp(-band_pct * 3.0)
+    
+    # Confidence: derived from agreement, magnitude (vs ATR), and certainty
+    base_conf = 65.0 if agreement else 45.0
+    magnitude_bonus = min(20.0, (forecast_ret_pct / max(atr_pct, 0.1)) * 5.0)
+    
+    confidence = (base_conf + magnitude_bonus) * certainty
+    
+    # Penalize scale bias
+    bias_penalty = min(15.0, abs(scale - 1.0) * 30.0)
+    confidence = max(10.0, min(95.0, confidence - bias_penalty))
 
     return {
         "p10": blend_p10,
@@ -2019,7 +2182,7 @@ def _build_signals(
     signals.append(Signal("ai_forecast", _clamp(forecast_return_pct / 3.0, -1, 1) * (confidence/100.0), 2.0, f"AI {forecast_return_pct:+.2f}%"))
 
     # ── 11: EMA Cross (9 vs 21) ──
-    signals.append(Signal("ema_cross_9_21", 1.0 if ema9 > ema21 else -1.0, 1.2, f"EMA9 {'>' if ema9>ema21 else '<'} EMA21"))
+    signals.append(Signal("ema_cross_9_21", 1.0 if ema9 > ema21 else -1.0, 0.6, f"EMA9 {'>' if ema9>ema21 else '<'} EMA21"))
 
     # ── 12: RSI Extremes ──
     rsi_ext = 1.0 if rsi < 20 else -1.0 if rsi > 80 else 0.0
@@ -2377,17 +2540,490 @@ def _build_reasoning(
     return reasons, warnings, opportunities
 
 
+# ── Technical Analysis Weights & Constants (Dashboard Rework v6.1) ────────────
+OSC_WEIGHTS = {
+    "rsi":       2.5,   # Leading indicator, battle-tested
+    "macd":      2.2,   # Trend + momentum hybrid
+    "stoch_rsi": 1.8,   # High sensitivity
+    "stoch":     1.3,   # Classic momentum
+    "cci":       1.5,   # Good for extreme detection
+    "adx":       1.5,   # Trend strength (direction via DI)
+    "williams":  1.3,   # Complement to RSI
+    "ultimate":  1.2,   # Multi-period, less noise
+    "bbp":       1.0,   # Trend-following
+    "ao":        0.9,   # Noisy, short-term only
+    "momentum":  0.8,   # Lagging, lowest weight
+    "roc":       1.4,   # Clean rate-of-change confirmation
+    "trix":      1.2,   # Smoothed trend momentum
+    "ppo":       1.6,   # Percentage trend acceleration
+    "cmo":       1.3,   # Momentum regime strength
+    "dpo":       1.0,   # Mean-reversion / cycle context
+    "aroon":     1.5,   # Trend freshness / breakout context
+    "tsi":       1.4,   # Smoothed momentum quality
+}
+
+MA_WEIGHT_MAP = {
+    "ema_200": 3.0, "sma_200": 2.8,
+    "ema_100": 2.3, "sma_100": 2.1,
+    "ema_50":  1.8, "sma_50":  1.6,
+    "ema_30":  1.3, "sma_30":  1.2,
+    "ema_20":  1.1, "sma_20":  1.0,
+    "ema_10":  0.8, "sma_10":  0.7,
+    "vwma_20": 1.5, "ichimoku": 1.4, "hull_9": 1.3
+}
+
+def _extract_osc_key(label: str) -> str:
+    l = label.lower()
+    if "rsi" in l and "nhanh" not in l: return "rsi"
+    if "macd" in l: return "macd"
+    if "stochastic %k" in l: return "stoch"
+    if "nhanh" in l or "stoch_rsi" in l: return "stoch_rsi"
+    if "cci" in l: return "cci"
+    if "định hướng" in l or "adx" in l: return "adx"
+    if "williams" in l: return "williams"
+    if "ultimate" in l: return "ultimate"
+    if "bbp" in l or "sức mạnh giá" in l: return "bbp"
+    if "ao" in l: return "ao"
+    if "xung lượng" in l or "momentum" in l: return "momentum"
+    if "roc" in l: return "roc"
+    if "trix" in l: return "trix"
+    if "ppo" in l: return "ppo"
+    if "cmo" in l: return "cmo"
+    if "dpo" in l: return "dpo"
+    if "aroon" in l: return "aroon"
+    if "tsi" in l: return "tsi"
+    return "unknown"
+
+def _get_ma_weight(label: str) -> float:
+    l = label.lower()
+    if "hàm mũ" in l: 
+        p = re.findall(r"\d+", l)
+        if p: return MA_WEIGHT_MAP.get(f"ema_{p[0]}", 1.0)
+    if "đơn giản" in l:
+        p = re.findall(r"\d+", l)
+        if p: return MA_WEIGHT_MAP.get(f"sma_{p[0]}", 1.0)
+    if "ichimoku" in l: return MA_WEIGHT_MAP["ichimoku"]
+    if "vwma" in l or "tỷ trọng tuyến tính" in l: return MA_WEIGHT_MAP["vwma_20"]
+    if "hull" in l: return MA_WEIGHT_MAP["hull_9"]
+    return 1.0
+
+def _gauge_to_signal(gauge: float) -> str:
+    """Unified 5-level signal converter."""
+    if gauge >= 75:   return "Mua mạnh"
+    elif gauge >= 58: return "Mua"
+    elif gauge >= 42: return "Trung lập"
+    elif gauge >= 25: return "Bán"
+    else:             return "Bán mạnh"
+
+
+def _gauge_to_normalized_score(gauge: float) -> float:
+    """Convert a 0..100 gauge into a -1..1 frontend-friendly scale."""
+    return _clamp((float(gauge) - 50.0) / 50.0, -1.0, 1.0)
+
+
+def _forecast_path_metrics(p50_path: np.ndarray, last_close: float) -> Dict[str, float]:
+    """Measure forecast quality from the full path, not only the final endpoint."""
+    if len(p50_path) == 0 or abs(last_close) <= 1e-8:
+        return {
+            "weighted_return_pct": 0.0,
+            "final_return_pct": 0.0,
+            "path_consistency": 50.0,
+            "monotonicity": 50.0,
+            "max_adverse_excursion_pct": 0.0,
+            "mean_step_return_pct": 0.0,
+        }
+
+    ret_path = ((p50_path / last_close) - 1.0) * 100.0
+    step_weights = np.linspace(1.0, 0.65, len(ret_path))
+    weighted_ret_pct = float(np.average(ret_path, weights=step_weights))
+    final_ret_pct = float(ret_path[-1])
+    final_sign = 0 if abs(final_ret_pct) < 0.05 else (1 if final_ret_pct > 0 else -1)
+
+    if len(ret_path) > 1 and final_sign != 0:
+        signed_steps = [
+            1.0 if np.sign(curr - prev) == final_sign else 0.0
+            for prev, curr in zip(ret_path[:-1], ret_path[1:])
+            if abs(curr - prev) >= 0.02
+        ]
+        path_consistency = float(sum(signed_steps) / len(signed_steps)) if signed_steps else 0.5
+    else:
+        path_consistency = 0.5
+
+    if len(ret_path) > 1:
+        monotonicity = float(np.mean(np.diff(ret_path) >= 0)) if final_sign >= 0 else float(np.mean(np.diff(ret_path) <= 0))
+    else:
+        monotonicity = 0.5
+
+    if final_sign > 0:
+        adverse = abs(float(np.min(ret_path)))
+    elif final_sign < 0:
+        adverse = abs(float(np.max(ret_path)))
+    else:
+        adverse = max(abs(float(np.min(ret_path))), abs(float(np.max(ret_path))))
+
+    mean_step_return_pct = float(np.mean(np.diff(ret_path))) if len(ret_path) > 1 else final_ret_pct
+    return {
+        "weighted_return_pct": round(weighted_ret_pct, 2),
+        "final_return_pct": round(final_ret_pct, 2),
+        "path_consistency": round(path_consistency * 100.0, 1),
+        "monotonicity": round(monotonicity * 100.0, 1),
+        "max_adverse_excursion_pct": round(adverse, 2),
+        "mean_step_return_pct": round(mean_step_return_pct, 3),
+    }
+
+def _calc_osc_score(osc_data: list) -> dict:
+    """MODULE 1: Weighted scoring for oscillators."""
+    total_weight = 0.0
+    weighted_score = 0.0
+    buy = sell = neutral = 0
+    
+    for item in osc_data:
+        key = _extract_osc_key(item["name"])
+        w = OSC_WEIGHTS.get(key, 1.0)
+        v = float(item.get("score", 0.0) or 0.0)
+        # Robust case-insensitive check
+        act = str(item.get("action", "")).strip().lower()
+        if act == "mua":
+            buy += 1
+        elif act == "bán":
+            sell += 1
+        else:
+            neutral += 1
+            
+        weighted_score += w * v
+        total_weight += w
+    
+    normalized = weighted_score / total_weight if total_weight else 0.0
+    gauge = 50.0 + normalized * 50.0
+    return {
+        "gauge": round(gauge, 1),
+        "normalized_score": round(normalized, 4),
+        "signal": _gauge_to_signal(gauge),
+        "buy": buy, "sell": sell, "neutral": neutral
+    }
+
+def _calc_ma_score(ma_data: list, closes: np.ndarray) -> dict:
+    """MODULE 2: Period-weighted scoring for MAs + Cross Bonus."""
+    total_weight = 0.0
+    weighted_score = 0.0
+    buy = sell = neutral = 0
+    
+    for item in ma_data:
+        w = _get_ma_weight(item["name"])
+        v = 0.0
+        act = str(item.get("action", "")).strip().lower()
+        if act == "mua":
+            v = 1.0
+            buy += 1
+        elif act == "bán":
+            v = -1.0
+            sell += 1
+        else:
+            neutral += 1
+            
+        weighted_score += w * v
+        total_weight += w
+    
+    # Golden Cross / Death Cross Bonus (±0.10 normalized score)
+    cross_bonus = 0.0
+    if len(closes) >= 200:
+        ema50 = _ema(closes, 50)[-1]
+        ema200 = _ema(closes, 200)[-1]
+        if not math.isnan(ema50) and not math.isnan(ema200):
+            if ema50 > ema200: cross_bonus = 0.10
+            else: cross_bonus = -0.10
+            
+    normalized = (weighted_score / total_weight) + cross_bonus if total_weight else 0.0
+    normalized = max(-1.0, min(1.0, normalized))
+    gauge = 50.0 + normalized * 50.0
+    
+    return {
+        "gauge": round(gauge, 1),
+        "normalized_score": round(normalized, 4),
+        "signal": _gauge_to_signal(gauge),
+        "buy": buy, "sell": sell, "neutral": neutral,
+        "golden_cross": cross_bonus > 0,
+        "death_cross": cross_bonus < 0
+    }
+
+def _calc_ai_forecast_score(
+    blended: dict,
+    forecast_rows: List[Dict[str, Any]],
+    last_close: float,
+    indicators: dict,
+    horizon: int,
+    interval: str,
+) -> dict:
+    """MODULE 3: AI score from path quality, trend alignment, magnitude, and certainty."""
+    trend = indicators.get("trend", {})
+    atr_pct = max(float(indicators.get("atr", {}).get("pct") or 0.0), 0.1)
+    rsi = float(indicators.get("rsi", {}).get("value") or 50.0)
+
+    p50_path = np.array(blended.get("p50", []), dtype=float)
+    p10_path = np.array(blended.get("p10", []), dtype=float)
+    p90_path = np.array(blended.get("p90", []), dtype=float)
+
+    if not len(p50_path):
+        p50_path = np.array([last_close], dtype=float)
+    if not len(p10_path):
+        p10_path = np.array([last_close], dtype=float)
+    if not len(p90_path):
+        p90_path = np.array([last_close], dtype=float)
+
+    path_len = len(p50_path)
+    path_metrics = _forecast_path_metrics(p50_path, last_close)
+    forecast_ret_path = ((p50_path / max(last_close, 1e-8)) - 1.0) * 100.0
+    final_ret_pct = path_metrics["final_return_pct"]
+    weighted_ret_pct = path_metrics["weighted_return_pct"]
+    directional_edge_pct = (weighted_ret_pct * 0.60) + (final_ret_pct * 0.40)
+    direction_norm = math.tanh(directional_edge_pct / max(atr_pct * 1.35, 0.35))
+    final_sign = 0 if abs(final_ret_pct) < 0.05 else (1 if final_ret_pct > 0 else -1)
+
+    path_consistency = path_metrics["path_consistency"] / 100.0
+    monotonicity = path_metrics["monotonicity"] / 100.0
+    adverse_excursion_pct = path_metrics["max_adverse_excursion_pct"]
+
+    avg_band_pct = float(np.mean((p90_path - p10_path) / np.maximum(np.abs(p50_path), 1e-8)) * 100.0)
+    band_certainty = math.exp(-avg_band_pct / 4.0)
+    ensemble_conf = max(0.0, min(1.0, float(blended.get("confidence", 50.0)) / 100.0))
+    scale_penalty = min(0.18, abs(float(blended.get("scale", 1.0)) - 1.0) * 0.35)
+    stability_penalty = min(0.20, adverse_excursion_pct / max(atr_pct * 5.0, 1.0) * 0.12)
+    certainty_score = (
+        ensemble_conf * 0.45 +
+        band_certainty * 0.35 +
+        path_consistency * 0.12 +
+        monotonicity * 0.08
+    ) - scale_penalty - stability_penalty
+    certainty_score = max(0.08, min(0.98, certainty_score))
+
+    move_in_atr = abs(final_ret_pct) / atr_pct
+    magnitude_score = math.tanh(move_in_atr / 1.6)
+    horizon_decay = max(0.70, 1.0 - max(horizon - 12, 0) * 0.012)
+    magnitude_score *= horizon_decay
+
+    ema_stack = bool(trend.get("ema_bullish_stack", False))
+    above_200 = bool(trend.get("above_ema200", False))
+    trend_alignment = 0.0
+    if final_sign > 0 and ema_stack and above_200:
+        trend_alignment = 0.10
+    elif final_sign < 0 and (not ema_stack) and (not above_200):
+        trend_alignment = -0.10
+    elif final_sign > 0 and not above_200:
+        trend_alignment = -0.07
+    elif final_sign < 0 and above_200:
+        trend_alignment = 0.07
+
+    exhaustion_penalty = 0.0
+    if final_sign > 0 and rsi >= 74:
+        exhaustion_penalty = min(0.12, (rsi - 74.0) / 100.0)
+    elif final_sign < 0 and rsi <= 26:
+        exhaustion_penalty = -min(0.12, (26.0 - rsi) / 100.0)
+
+    path_strength = 0.55 + 0.25 * path_consistency + 0.20 * monotonicity
+    effective_strength = direction_norm * path_strength * (0.45 + 0.55 * certainty_score)
+    directional_push = effective_strength * (22.0 + 18.0 * magnitude_score)
+    alignment_push = trend_alignment * 35.0
+    exhaustion_push = -exhaustion_penalty * 35.0
+    gauge = max(8.0, min(92.0, 50.0 + directional_push + alignment_push + exhaustion_push))
+
+    confidence_pct = 35.0 + certainty_score * 55.0 + min(move_in_atr, 1.5) * 6.0
+    confidence_pct = max(20.0, min(95.0, confidence_pct))
+    direction_label = "bullish" if gauge >= 58 else "bearish" if gauge <= 42 else "neutral"
+
+    return {
+        "gauge": round(gauge, 1),
+        "normalized_score": round(_gauge_to_normalized_score(gauge), 4),
+        "confidence_pct": round(confidence_pct, 1),
+        "forecast_return_pct": round(final_ret_pct, 2),
+        "weighted_return_pct": round(weighted_ret_pct, 2),
+        "direction": direction_label,
+        "magnitude_vs_atr": round(move_in_atr, 2),
+        "band_uncertainty_pct": round(avg_band_pct, 2),
+        "certainty": round(certainty_score * 100.0, 1),
+        "path_consistency": round(path_consistency * 100.0, 1),
+        "monotonicity": round(monotonicity * 100.0, 1),
+        "max_adverse_excursion_pct": round(adverse_excursion_pct, 2),
+        "path_metrics": path_metrics,
+        "signal": _gauge_to_signal(gauge)
+    }
+
+def _calc_summary_score(osc_score: dict, ma_score: dict, ai_score: dict) -> dict:
+    """MODULE 4: Normalize + Weighted combine with compatibility fields."""
+    W_OSC = 0.35
+    W_MA  = 0.35
+    W_AI  = 0.30
+    
+    composite = (osc_score["gauge"] * W_OSC + ma_score["gauge"] * W_MA + ai_score["gauge"] * W_AI)
+    
+    # Confidence multiplier: pull towards neutral if AI certainty is low
+    certainty_factor = ai_score["certainty"] / 100.0
+    pulled_to_neutral = composite + (50.0 - composite) * (1.0 - certainty_factor) * 0.20
+    final_gauge = max(5.0, min(95.0, pulled_to_neutral))
+    
+    dist = abs(final_gauge - 50.0)
+    conviction = "Rất mạnh" if dist >= 25 else "Mạnh" if dist >= 15 else "Trung bình" if dist >= 8 else "Yếu"
+    
+    # Compatibility fields for legacy frontend (Total votes)
+    buy = osc_score["buy"] + ma_score["buy"]
+    sell = osc_score["sell"] + ma_score["sell"]
+    neutral = osc_score["neutral"] + ma_score["neutral"]
+    
+    bias = "neutral"
+    if final_gauge >= 58: bias = "bullish"
+    elif final_gauge <= 42: bias = "bearish"
+    
+    return {
+        "gauge": round(final_gauge, 1),
+        "signal": _gauge_to_signal(final_gauge),
+        "conviction": conviction,
+        "bias": bias,
+        "buy": buy, "sell": sell, "neutral": neutral,
+        "components": {
+            "oscillators": round(osc_score["gauge"], 1),
+            "moving_averages": round(ma_score["gauge"], 1),
+            "ai_forecast": round(ai_score["gauge"], 1)
+        }
+    }
+
+def _calc_technical_score_v2(osc_score: dict, ma_score: dict) -> dict:
+    """Blend oscillators and moving averages into a single technical gauge."""
+    base = (osc_score["gauge"] * 0.42) + (ma_score["gauge"] * 0.58)
+    osc_delta = osc_score["gauge"] - 50.0
+    ma_delta = ma_score["gauge"] - 50.0
+    osc_dir = math.copysign(1.0, osc_delta) if abs(osc_delta) >= 1.0 else 0.0
+    ma_dir = math.copysign(1.0, ma_delta) if abs(ma_delta) >= 1.0 else 0.0
+
+    agreement_boost = 0.0
+    if osc_dir != 0.0 and ma_dir != 0.0:
+        if osc_dir == ma_dir:
+            agreement_boost = 4.0 * osc_dir
+        else:
+            agreement_boost = -0.18 * (base - 50.0)
+
+    structure_boost = 2.5 if ma_score.get("golden_cross") else -2.5 if ma_score.get("death_cross") else 0.0
+    final_gauge = max(5.0, min(95.0, base + agreement_boost + structure_boost))
+
+    return {
+        "gauge": round(final_gauge, 1),
+        "normalized_score": round(_gauge_to_normalized_score(final_gauge), 4),
+        "signal": _gauge_to_signal(final_gauge),
+        "buy": osc_score["buy"] + ma_score["buy"],
+        "sell": osc_score["sell"] + ma_score["sell"],
+        "neutral": osc_score["neutral"] + ma_score["neutral"],
+        "alignment": osc_dir == ma_dir and osc_dir != 0.0,
+        "components": {
+            "oscillators": round(osc_score["gauge"], 1),
+            "moving_averages": round(ma_score["gauge"], 1),
+        }
+    }
+
+def _calc_summary_score_v2(tech_score: dict, ai_score: dict) -> dict:
+    """Final decision score defined as the simple mean of technical and AI gauges."""
+    composite = (float(tech_score["gauge"]) + float(ai_score["gauge"])) / 2.0
+    final_gauge = max(5.0, min(95.0, composite))
+    dist = abs(final_gauge - 50.0)
+    conviction = "Rất mạnh" if dist >= 25 else "Mạnh" if dist >= 15 else "Trung bình" if dist >= 8 else "Yếu"
+
+    bias = "neutral"
+    if final_gauge >= 58:
+        bias = "bullish"
+    elif final_gauge <= 42:
+        bias = "bearish"
+
+    return {
+        "gauge": round(final_gauge, 1),
+        "normalized_score": round(_gauge_to_normalized_score(final_gauge), 4),
+        "signal": _gauge_to_signal(final_gauge),
+        "conviction": conviction,
+        "bias": bias,
+        "buy": tech_score["buy"],
+        "sell": tech_score["sell"],
+        "neutral": tech_score["neutral"],
+        "components": {
+            "technical": round(tech_score["gauge"], 1),
+            "oscillators": round(tech_score["components"]["oscillators"], 1),
+            "moving_averages": round(tech_score["components"]["moving_averages"], 1),
+            "ai_forecast": round(ai_score["gauge"], 1)
+        }
+    }
+
+
+def _build_dashboard_payload(
+    last_close: float,
+    forecast_rows: List[Dict[str, Any]],
+    technical_score: Dict[str, Any],
+    ai_score: Dict[str, Any],
+    summary: Dict[str, Any],
+) -> Dict[str, Any]:
+    """Single source of truth for hero gauges consumed by the frontend."""
+    forecast_end = last_close
+    if forecast_rows:
+        forecast_end = float(forecast_rows[-1].get("p50") or last_close)
+
+    return {
+        "technical": {
+            "gauge": technical_score["gauge"],
+            "normalized_score": technical_score["normalized_score"],
+            "signal": technical_score["signal"],
+            "buy": technical_score["buy"],
+            "sell": technical_score["sell"],
+            "neutral": technical_score["neutral"],
+        },
+        "ai": {
+            "gauge": ai_score["gauge"],
+            "normalized_score": ai_score["normalized_score"],
+            "signal": ai_score["signal"],
+            "forecast_return_pct": ai_score["forecast_return_pct"],
+            "weighted_return_pct": ai_score["weighted_return_pct"],
+            "confidence_pct": ai_score["confidence_pct"],
+            "certainty": ai_score["certainty"],
+            "path_consistency": ai_score["path_consistency"],
+            "monotonicity": ai_score.get("monotonicity", 50.0),
+            "max_adverse_excursion_pct": ai_score.get("max_adverse_excursion_pct", 0.0),
+            "current_price": round(float(last_close), 6),
+            "forecast_price": round(float(forecast_end), 6),
+        },
+        "summary": {
+            "gauge": summary["gauge"],
+            "normalized_score": summary["normalized_score"],
+            "signal": summary["signal"],
+            "conviction": summary["conviction"],
+            "bias": summary["bias"],
+        },
+    }
+
+
+def _rebuild_blended_from_forecast_payload(cached_forecast: Optional[Dict[str, Any]], last_close: float) -> Optional[Dict[str, Any]]:
+    """Reconstruct the minimum blended payload needed by the analysis engine."""
+    if not cached_forecast:
+        return None
+
+    rows = cached_forecast.get("forecast") or []
+    future_rows = [row for row in rows if not row.get("is_actual")]
+    if not future_rows:
+        return None
+
+    ensemble = cached_forecast.get("ensemble", {})
+    return {
+        "p10": np.array([float(row.get("p10") or last_close) for row in future_rows], dtype=float),
+        "p50": np.array([float(row.get("p50") or last_close) for row in future_rows], dtype=float),
+        "p90": np.array([float(row.get("p90") or last_close) for row in future_rows], dtype=float),
+        "agreement": bool(ensemble.get("trend_agreement", True)),
+        "scale": float(ensemble.get("alignment_scale", 1.0) or 1.0),
+        "confidence": float(ensemble.get("confidence", 50.0) or 50.0),
+    }
+
 def _build_trade_analysis(
     symbol: str, interval: str, data: List[Dict[str, Any]], indicators: Dict[str, Any],
     forecast_rows: List[Dict[str, Any]], confidence: float, source: str,
+    blended: Optional[Dict[str, Any]] = None
 ) -> Dict[str, Any]:
     """
-    TradingView-style technical analysis dashboard.
-    Returns pure numerical data: oscillators, moving averages, pivot points.
-    No trade setups, no entry/SL/TP, no reasoning text.
+    TradingView-style technical analysis dashboard (v6.1 Rework).
+    Implements weighted scoring for Oscillators, MAs, and AI Forecast.
     """
     if not data or len(data) < 30:
-        return {"oscillators": {"data": []}, "moving_averages": {"data": []}, "pivot_points": {"data": []}, "summary": {"signal": "Trung lập", "sell": 0, "neutral": 0, "buy": 0}}
+        return {"oscillators": {"data": []}, "moving_averages": {"data": []}, "summary": {"signal": "Trung lập", "buy": 0, "sell": 0, "neutral": 0}}
 
     closes = np.array([float(d["close"]) for d in data], dtype=float)
     highs  = np.array([float(d["high"])  for d in data], dtype=float)
@@ -2396,151 +3032,117 @@ def _build_trade_analysis(
     last_close = closes[-1]
 
     def _lv(arr):
-        if isinstance(arr, pd.Series):
-            arr = arr.values
+        if isinstance(arr, pd.Series): arr = arr.values
         v = arr[-1] if len(arr) else float('nan')
         return None if (v is None or (isinstance(v, float) and math.isnan(v))) else round(float(v), 2)
 
-    # ── Compute all oscillators ──
-    rsi14 = _rsi(closes, 14)
-    stoch_k_arr, stoch_d_arr = _stoch_rsi(closes, 14, 14, 3, 3)
-    cci20 = _cci(highs, lows, closes, 20)
-    adx14, plus_di14, minus_di14 = _adx(highs, lows, closes, 14)
-    ao = _awesome_oscillator(highs, lows)
-    mom10 = _momentum(closes, 10)
-    macd_l, macd_s, macd_h = _macd(closes, 12, 26, 9)
-    stoch_rsi_k, stoch_rsi_d = _stoch_rsi(closes, 14, 14, 3, 3)
-    wr14 = _williams_r(highs, lows, closes, 14)
-    bbp = _bull_bear_power(highs, lows, closes, 13)
-    uo = _ultimate_oscillator(highs, lows, closes, 7, 14, 28)
-
+    # ── 1. Oscillators ──
     osc_data = []
-    osc_buy = osc_sell = osc_neutral = 0
-
+    atr_scale = max(float(indicators.get("atr", {}).get("value") or last_close * 0.01), max(last_close * 0.0015, 1e-6))
     def _add_osc(label, val, action_name, **kw):
-        nonlocal osc_buy, osc_sell, osc_neutral
-        # Handle scalar, Series or ndarray
-        if isinstance(val, (np.ndarray, pd.Series, list)):
-            v = _lv(val)
-        else:
-            v = round(float(val), 2) if val is not None else None
+        if isinstance(val, (np.ndarray, pd.Series, list)): v = _lv(val)
+        else: v = round(float(val), 2) if val is not None else None
         act = _osc_action(action_name, v if v is not None else 0, **kw)
-        osc_data.append({"name": label, "value": v, "action": act})
-        if act == "Mua": osc_buy += 1
-        elif act == "Bán": osc_sell += 1
-        else: osc_neutral += 1
-
-    _add_osc("Chỉ số Sức mạnh tương đối (14)", rsi14, "rsi")
-    _add_osc("Stochastic %K (14, 3, 3)", stoch_k_arr, "stoch")
-    _add_osc("Chỉ số Kênh hàng hóa (20)", cci20, "cci")
-    _add_osc("Chỉ số Định hướng Trung bình (14)", adx14, "adx",
-             plus_di=_lv(plus_di14) or 0, minus_di=_lv(minus_di14) or 0)
-    _add_osc("Chỉ số Dao động AO", ao, "ao")
-    _add_osc("Xung lượng (10)", mom10, "momentum")
-    _add_osc("Cấp độ MACD (12, 26)", macd_l, "macd", signal=_lv(macd_s) or 0)
-    _add_osc("Đường RSI Nhanh (3, 3, 14, 14)", stoch_rsi_k, "stoch_rsi")
-    _add_osc("Vùng Phần trăm Williams (14)", wr14, "williams")
-    _add_osc("Sức Mạnh Giá Lên và Giá Xuống", bbp, "bbp")
-    _add_osc("Dao động Ultimate (7, 14, 28)", uo, "ultimate")
-
-    osc_total = osc_buy + osc_sell + osc_neutral
-    if osc_buy > osc_sell + 2:
-        osc_signal = "Mua"
-    elif osc_sell > osc_buy + 2:
-        osc_signal = "Bán"
-    else:
-        osc_signal = "Trung lập"
-
-    # ── Compute all Moving Averages ──
+        score = _osc_signal_score(action_name, v if v is not None else 0.0, **kw)
+        osc_data.append({"name": label, "value": v, "action": act, "score": round(score, 4)})
+
+    _add_osc("Chỉ số Sức mạnh tương đối (14)", _rsi(closes, 14), "rsi")
+    _add_osc("Stochastic %K (14, 3, 3)", _stoch_rsi(closes, 14, 14, 3, 3)[0], "stoch")
+    _add_osc("Chỉ số Kênh hàng hóa (20)", _cci(highs, lows, closes, 20), "cci")
+    adx_vals = _adx(highs, lows, closes, 14)
+    _add_osc("Chỉ số Định hướng Trung bình (14)", adx_vals[0], "adx", plus_di=_lv(adx_vals[1]) or 0, minus_di=_lv(adx_vals[2]) or 0)
+    _add_osc("Chỉ số Dao động AO", _awesome_oscillator(highs, lows), "ao", scale=atr_scale * 0.8)
+    _add_osc("Xung lượng (10)", _momentum(closes, 10), "momentum", scale=atr_scale * 1.15)
+    macd_vals = _macd(closes, 12, 26, 9)
+    _add_osc("Cấp độ MACD (12, 26)", macd_vals[0], "macd", signal=_lv(macd_vals[1]) or 0, scale=atr_scale * 0.18)
+    _add_osc("Đường RSI Nhanh (3, 3, 14, 14)", _stoch_rsi(closes, 14, 14, 3, 3)[0], "stoch_rsi")
+    _add_osc("Vùng Phần trăm Williams (14)", _williams_r(highs, lows, closes, 14), "williams")
+    _add_osc("Sức Mạnh Giá Lên và Giá Xuống", _bull_bear_power(highs, lows, closes, 13), "bbp", scale=atr_scale * 0.9)
+    _add_osc("Dao động Ultimate (7, 14, 28)", _ultimate_oscillator(highs, lows, closes, 7, 14, 28), "ultimate")
+    _add_osc("Tốc độ biến động ROC (12)", _roc(closes, 12), "roc")
+    _add_osc("TRIX (18)", _trix(closes, 18), "trix")
+    _add_osc("PPO (12, 26)", _ppo(closes, 12, 26), "ppo")
+    _add_osc("CMO (14)", _cmo(closes, 14), "cmo")
+    _add_osc("DPO (20)", _dpo(closes, 20), "dpo", scale=atr_scale * 0.75)
+    _add_osc("Aroon Oscillator (25)", _aroon_oscillator(highs, lows, 25), "aroon")
+    _add_osc("TSI (25, 13)", _tsi(closes, 25, 13), "tsi")
+
+    osc_score = _calc_osc_score(osc_data)
+
+    # ── 2. Moving Averages ──
     ma_data = []
-    ma_buy = ma_sell = ma_neutral = 0
-
     def _add_ma(label, val_arr):
-        nonlocal ma_buy, ma_sell, ma_neutral
         v = _lv(val_arr)
         act = _ma_action(last_close, v if v is not None else last_close)
         ma_data.append({"name": label, "value": v, "action": act})
-        if act == "Mua": ma_buy += 1
-        elif act == "Bán": ma_sell += 1
-        else: ma_neutral += 1
 
-    # EMA periods
     for p in [10, 20, 30, 50, 100, 200]:
         _add_ma(f"Trung bình Trượt Hàm mũ ({p})", _ema(closes, p))
         _add_ma(f"Đường Trung bình trượt Đơn giản ({p})", _sma(closes, p))
+    _add_ma("Đường cơ sở Ichimoku (9, 26, 52, 26)", _ichimoku_base(highs, lows, 26))
+    _add_ma("Đường Trung bình di động Tỷ trọng tuyến tính (20)", _vwma(closes, vols, 20))
+    _add_ma("Đường trung bình trượt Hull (9)", _hull_ma(closes, 9))
+
+    ma_score = _calc_ma_score(ma_data, closes)
+
+    # ── 3. AI Forecast Gauge ──
+    if not blended:
+        # Fallback to simple blended if no forecast available
+        blended = {
+            "p50": [last_close * (1 + (confidence-50)/1000)],
+            "p10": [last_close * 0.98], "p90": [last_close * 1.02],
+            "agreement": True, "scale": 1.0
+        }
+    
+    ai_score = _calc_ai_forecast_score(
+        blended,
+        forecast_rows,
+        last_close,
+        indicators,
+        len(forecast_rows) or 10,
+        interval,
+    )
 
-    # Ichimoku
-    ichi = _ichimoku_base(highs, lows, 26)
-    _add_ma("Đường cơ sở Ichimoku (9, 26, 52, 26)", ichi)
-
-    # VWMA
-    vwma_arr = _vwma(closes, vols, 20)
-    _add_ma("Đường Trung bình di động Tỷ trọng tuyến tính (20)", vwma_arr)
-
-    # Hull MA
-    hull = _hull_ma(closes, 9)
-    _add_ma("Đường trung bình trượt Hull (9)", hull)
-
-    if ma_buy > ma_sell + 2:
-        ma_signal = "Mua"
-    elif ma_sell > ma_buy + 2:
-        ma_signal = "Bán"
-    else:
-        ma_signal = "Trung lập"
-
-    # Summary (Total) ──
-    total_buy = osc_buy + ma_buy
-    total_sell = osc_sell + ma_sell
-    total_neutral = osc_neutral + ma_neutral
-    
-    # Derive bias from signal
-    if total_buy > total_sell + 3:
-        summary_bias = "bullish"
-    elif total_sell > total_buy + 3:
-        summary_bias = "bearish"
-    else:
-        summary_bias = "neutral"
-
-    # B-8: Integrated Summary Signals (v6.0)
-    # Combine TV style with ensemble confidence
-    if total_buy > total_sell + 6 and confidence > 65:
-        total_signal = "Mua mạnh (Cực độ)"
-    elif total_buy > total_sell + 3 and confidence > 55:
-        total_signal = "Mua"
-    elif total_sell > total_buy + 6 and confidence > 65:
-        total_signal = "Bán mạnh (Cực độ)"
-    elif total_sell > total_buy + 3 and confidence > 55:
-        total_signal = "Bán"
-    else:
-        total_signal = "Trung lập (Thận trọng)"
+    # ── 4. Summary ──
+    technical_score = _calc_technical_score_v2(osc_score, ma_score)
+    summary = _calc_summary_score_v2(technical_score, ai_score)
 
-    # B-4: Use last COMPLETED candle for pivot calculation to avoid flickering
+    # Pivot Points
     last_h = float(highs[-2]) if len(highs) > 1 else float(highs[-1])
     last_l = float(lows[-2]) if len(lows) > 1 else float(lows[-1])
     last_c = float(closes[-2]) if len(closes) > 1 else float(closes[-1])
     pivots = _calc_pivot_points(last_h, last_l, last_c)
+    dashboard = _build_dashboard_payload(last_close, forecast_rows, technical_score, ai_score, summary)
 
     return {
         "style": "tradingview",
-        "summary": {
-            "sell": total_sell, "neutral": total_neutral, "buy": total_buy,
-            "signal": total_signal,
-            "bias": summary_bias,
-        },
+        "dashboard": dashboard,
+        "summary": summary,
+        "technicals": technical_score,
         "oscillators": {
-            "sell": osc_sell, "neutral": osc_neutral, "buy": osc_buy,
-            "signal": osc_signal,
-            "data": osc_data,
+            "gauge": osc_score["gauge"],
+            "signal": osc_score["signal"],
+            "buy": osc_score["buy"],
+            "sell": osc_score["sell"],
+            "neutral": osc_score["neutral"],
+            "data": osc_data
         },
         "moving_averages": {
-            "sell": ma_sell, "neutral": ma_neutral, "buy": ma_buy,
-            "signal": ma_signal,
-            "data": ma_data,
+            "gauge": ma_score["gauge"],
+            "signal": ma_score["signal"],
+            "buy": ma_score["buy"],
+            "sell": ma_score["sell"],
+            "neutral": ma_score["neutral"],
+            "golden_cross": ma_score["golden_cross"],
+            "death_cross": ma_score["death_cross"],
+            "data": ma_data
         },
-        "pivot_points": pivots,
+        "ai_gauge": ai_score,
+        "pivot_points": pivots
     }
 
 
+
 START_TIME = time.time()
 
 async def _background_cleanup():
@@ -3149,15 +3751,18 @@ async def get_historical(
     symbol:   str,
     interval: str = Query("1h"),
     limit:    int = Query(500, ge=50, le=2000),
+    refresh:  bool = Query(False),
 ) -> Dict[str, Any]:
     symbol = _get_canonical_symbol(symbol)
     if symbol not in SYMBOLS:
         raise HTTPException(404, f"Unknown symbol: {symbol}")
     if interval not in SUPPORTED_INTERVALS:
         raise HTTPException(400, f"Unsupported interval: {interval}")
-    data, source = await fetch_historical(symbol, interval, limit)
+    data, source = await fetch_historical(symbol, interval, limit, refresh=refresh)
     return {"symbol": symbol, "interval": interval, "source": source,
-            "count": len(data), "data": data}
+            "count": len(data), "data": data,
+            "generated_at": int(time.time()),
+            "cache": {"refresh_requested": refresh}}
 
 
 # ── Technical Indicators ──────────────────────────────────────────────────────
@@ -3166,6 +3771,7 @@ async def get_indicators(
     symbol:   str,
     interval: str = Query("1h"),
     limit:    int = Query(300, ge=50, le=1000),
+    refresh:  bool = Query(False),
 ) -> Dict[str, Any]:
     symbol = _get_canonical_symbol(symbol)
     if symbol not in SYMBOLS:
@@ -3173,13 +3779,15 @@ async def get_indicators(
     if interval not in SUPPORTED_INTERVALS:
         raise HTTPException(400, f"Unsupported interval: {interval}")
 
-    data, source = await fetch_historical(symbol, interval, limit)
+    data, source = await fetch_historical(symbol, interval, limit, refresh=refresh)
     indicators   = compute_indicators(data)
     return {
         "symbol":   symbol,
         "interval": interval,
         "source":   source,
         "candles":  len(data),
+        "generated_at": int(time.time()),
+        "cache": {"refresh_requested": refresh},
         "indicators": indicators,
     }
 
@@ -3189,6 +3797,8 @@ async def get_indicators(
 async def get_analysis(
     symbol:   str,
     interval: str = Query("1h"),
+    refresh:  bool = Query(False),
+    include_snapshot: bool = Query(False),
 ) -> Dict[str, Any]:
     """
     A-5: Direct access to the comprehensive Analysis Engine.
@@ -3199,7 +3809,7 @@ async def get_analysis(
         raise HTTPException(404, f"Unknown symbol: {symbol}")
 
     # Fetch main context
-    data, source = await fetch_historical(symbol, interval, 500)
+    data, source = await fetch_historical(symbol, interval, 500, refresh=refresh)
     if len(data) < 50:
         raise HTTPException(422, "Insufficient data for full analysis")
 
@@ -3208,7 +3818,7 @@ async def get_analysis(
     htf_bias = "neutral"
     if htf_interval:
         try:
-            htf_data, _ = await fetch_historical(symbol, htf_interval, 200)
+            htf_data, _ = await fetch_historical(symbol, htf_interval, 200, refresh=refresh)
             htf_inds = compute_indicators(htf_data)
             htf_bias = "bullish" if htf_inds["trend"].get("above_ema200") else "bearish"
         except Exception:
@@ -3217,16 +3827,20 @@ async def get_analysis(
     # Compute Indicators
     indicators = compute_indicators(data)
     
-    # We need a mock forecast return if no forecast is available
+    # Reuse cached forecast when available so /analysis and /forecast stay consistent.
     forecast_ret = 0.0
     confidence = 50.0
+    forecast_rows: List[Dict[str, Any]] = []
+    blended: Optional[Dict[str, Any]] = None
     try:
-        # Try to get from cache to avoid heavy re-computation
         f_prefix = _cache_prefix(symbol, interval)
         f_cache = forecast_cache.get(f"forecast_{f_prefix}10")
         if f_cache:
-            forecast_ret = _pct(f_cache["forecast"][-1]["p50"], f_cache["last_close"])
-            confidence = f_cache["ensemble"]["confidence"]
+            forecast_rows = f_cache.get("forecast") or []
+            if forecast_rows:
+                forecast_ret = _pct(float(forecast_rows[-1]["p50"]), float(f_cache.get("last_close") or data[-1]["close"]))
+            confidence = float(f_cache.get("ensemble", {}).get("confidence") or 50.0)
+            blended = _rebuild_blended_from_forecast_payload(f_cache, float(data[-1]["close"]))
     except Exception:
         pass
 
@@ -3236,9 +3850,10 @@ async def get_analysis(
         interval=interval,
         data=data,
         indicators=indicators,
-        forecast_rows=[], # Optional here
+        forecast_rows=forecast_rows,
         confidence=confidence,
         source=source,
+        blended=blended,
     )
     
     # Inject MTF into analysis
@@ -3255,7 +3870,8 @@ async def get_analysis(
         "timestamp": int(time.time()),
         "analysis": analysis,
         "verdict": await get_gemini_verdict(symbol, analysis, forecast_ret),
-        "indicators_snapshot": indicators if Query(False) else None # Save bandwidth
+        "cache": {"refresh_requested": refresh},
+        "indicators_snapshot": indicators if include_snapshot else None
     }
 
 
@@ -3320,6 +3936,7 @@ async def get_forecast(
     symbol:   str,
     interval: str = Query("1h"),
     horizon:  int = Query(10, ge=5, le=300),
+    refresh:  bool = Query(False)
 ) -> Dict[str, Any]:
     symbol = _get_canonical_symbol(symbol)
     if symbol not in SYMBOLS:
@@ -3329,21 +3946,27 @@ async def get_forecast(
 
     prefix    = _cache_prefix(symbol, interval)
     cache_key = f"forecast_{prefix}{horizon}"
+    cache_origin = "live"
     
-    # L1: RAM Cache
-    cached = forecast_cache.get(cache_key)
-    if cached is not None:
-        return cached
-
-    # L2: Persistent SQLite Cache (A-4)
-    p_cached = persistent_cache.get(cache_key)
-    if p_cached is not None:
-        p_cached["from_persistent_cache"] = True
-        # Backfill L1
-        forecast_cache.set(cache_key, p_cached, ttl_seconds=forecast_ttl(interval))
-        return p_cached
+    # L1/L2 Caches (Bypass if refresh=True)
+    if not refresh:
+        cached = forecast_cache.get(cache_key)
+        if cached is not None:
+            cached["generated_at"] = int(time.time())
+            cached["cache"] = {"origin": "memory", "refresh_requested": False}
+            return cached
+        p_cached = persistent_cache.get(cache_key)
+        if p_cached is not None:
+            p_cached["from_persistent_cache"] = True
+            forecast_cache.set(cache_key, p_cached, ttl_seconds=forecast_ttl(interval))
+            p_cached["generated_at"] = int(time.time())
+            p_cached["cache"] = {"origin": "persistent", "refresh_requested": False}
+            return p_cached
+    else:
+        logger.info("[forecast] Refresh requested for %s %s. Bypassing caches.", symbol, interval)
+        cache_origin = "live_refresh"
 
-    data_list, source = await fetch_historical(symbol, interval, 1500)
+    data_list, source = await fetch_historical(symbol, interval, 1500, refresh=refresh)
     if not KRONOS_AVAILABLE:
         # Return graceful empty forecast so UI doesn't break
         return {
@@ -3421,6 +4044,7 @@ async def get_forecast(
         forecast_rows=forecast_rows,
         confidence=float(blended["confidence"]),
         source=source,
+        blended=blended
     )
 
     response = {
@@ -3447,6 +4071,11 @@ async def get_forecast(
         },
         "indicators_snapshot": indicators,
         "analysis": analysis,
+        "generated_at": int(time.time()),
+        "cache": {
+            "origin": cache_origin,
+            "refresh_requested": refresh,
+        },
     }
 
     # L1: RAM
@@ -3600,8 +4229,8 @@ async def fetch_gemini_analysis(prompt: str) -> str:
                 # We'll rely on the prompt to enforce this, but can sanitize here
                 return text
             return "Không có phản hồi từ AI"
-    except Exception as ex:
-        logger.error("[Gemini] Exception: %s", ex)
+    except Exception as e:
+        logger.error("[Gemini] Exception: %s", e, exc_info=True)
         return "Lỗi phân tích AI"
 
 

frontend/index.html

@@ -1,4 +1,4 @@
-<!doctype html>
+<!doctype html>
 <html lang="vi">
 
 <head>
@@ -82,6 +82,7 @@
       --sidebar-w: 280px;
       --radius: 8px;
       --radius-lg: 18px;
+      --radius-xl: 24px;
       --ctrl-h: 38px;
       --ok-glow: rgba(16, 185, 129, 0.3);
       --err-glow: rgba(244, 63, 94, 0.3);
@@ -94,6 +95,13 @@
       --neon-pink: #ec4899;
       --neon-green: #10b981;
       --neon-blue: #3b82f6;
+
+      /* Logo Colors */
+      --logo-primary: #0ea5e9;
+      --logo-secondary: #8b5cf6;
+      --logo-glow: rgba(14, 165, 233, 0.3);
+      --light-bg-image: url("Light_BG.png?v=3");
+      --dark-bg-image: url("Dark_BG.png?v=3");
     }
 
     body.dark-theme {
@@ -132,6 +140,11 @@
       --glow-accent: 0 0 20px rgba(34, 211, 238, 0.4);
       --glass-cyan: rgba(6, 18, 42, 0.85);
       --shadow-lg: 0 30px 60px rgba(0, 0, 0, 0.8), 0 0 0 1px var(--bdr-accent);
+
+      /* Logo Colors */
+      --logo-primary: #22d3ee;
+      --logo-secondary: #ec4899;
+      --logo-glow: rgba(34, 211, 238, 0.6);
     }
 
     /* ═══════════════════════════════════════════════
@@ -167,16 +180,17 @@
       position: fixed;
       inset: 0;
       z-index: -1;
-      background: url("Light_BG.png");
+      background: var(--light-bg-image);
       background-size: cover;
       background-position: center;
       background-repeat: no-repeat;
-      opacity: 0.01; /* 1% opacity for the image as requested */
+      opacity: 0.01;
+      /* 1% opacity for the image as requested */
       transition: background 0.3s ease, opacity 0.3s ease;
     }
 
     body.dark-theme::before {
-      background: url("Dark_BG.png");
+      background: var(--dark-bg-image);
       background-size: cover;
       background-position: center;
       background-repeat: no-repeat;
@@ -277,7 +291,7 @@
     .logo-mark svg {
       width: 100%;
       height: 100%;
-      filter: drop-shadow(0 0 6px var(--accent-glow));
+      filter: drop-shadow(0 0 8px var(--accent-glow));
     }
 
     .logo-text {
@@ -291,7 +305,7 @@
       font-size: 1.45rem;
       font-weight: 700;
       letter-spacing: 0.12em;
-      color: #ffffff;
+      color: var(--txt-bright);
       line-height: 1;
       background: linear-gradient(90deg, #ffffff 0%, #a8f4ff 60%, #ffffff 100%);
       -webkit-background-clip: text;
@@ -310,7 +324,7 @@
       font-family: var(--ff-ui);
       font-weight: 400;
       letter-spacing: 0.05em;
-      color: #ffffff;
+      color: var(--txt-bright);
       line-height: 1.2;
     }
 
@@ -333,10 +347,10 @@
       /* Keep tight, but handle overflow via media queries */
     }
 
-    /* Search Omnibox */
+    /* Search Omnibox (Shrunk 50% horizontally from original 320px) */
     .omnibox {
       position: relative;
-      width: 320px;
+      width: 160px;
     }
 
     .omnibox input {
@@ -466,7 +480,7 @@
       font-size: 0.78rem;
       font-weight: 500;
       letter-spacing: 0.18em;
-      color: #ffffff;
+      color: var(--txt-muted);
       text-transform: uppercase;
       padding-left: 2px;
       line-height: 1;
@@ -729,7 +743,10 @@
       flex: 1;
       display: flex;
       flex-direction: column;
-      overflow: hidden;
+      overflow-x: hidden;
+      overflow-y: auto;
+      min-height: 0;
+      overscroll-behavior: contain;
     }
 
     /* ── TOP: 3 Big Gauges Row ── */
@@ -890,7 +907,8 @@
     }
 
     .gauge-hero-signal.neutral {
-      color: #cbd5e1;
+      color: #facc15;
+      text-shadow: 0 0 16px rgba(250, 204, 21, 0.28);
     }
 
     .gauge-hero-signal.signal-total {
@@ -901,7 +919,7 @@
       display: flex;
       gap: 20px;
       font-size: 0.8rem;
-      color: rgba(255, 255, 255, 0.4);
+      color: var(--txt-muted);
       letter-spacing: 0.02em;
     }
 
@@ -914,18 +932,19 @@
       font-family: var(--ff-mono);
       font-weight: 900;
       font-size: 1.1rem;
-      color: #ffffff;
+      color: var(--txt-bright);
       display: block;
       margin-top: 2px;
     }
 
     /* ── BOTTOM: Data Tables Grid ── */
     .dash-tables-row {
-      flex: 1;
+      flex: 0 0 auto;
       display: grid;
       overflow: hidden;
       grid-template-columns: 1fr 1fr 1fr;
       gap: 0;
+      align-items: start;
     }
 
     .dash-col {
@@ -933,6 +952,8 @@
       flex-direction: column;
       border-right: 1px solid var(--bdr-dim);
       overflow: hidden;
+      min-height: 0;
+      align-self: start;
     }
 
     .dash-col:last-child {
@@ -1055,7 +1076,7 @@
     }
 
     .summary-disclaimer strong {
-      color: rgba(255, 255, 255, 0.4);
+      color: var(--txt-muted);
     }
 
     /* ── Loading state ── */
@@ -1066,7 +1087,7 @@
       justify-content: center;
       height: 100%;
       gap: 16px;
-      color: rgba(255, 255, 255, 0.4);
+      color: var(--txt-muted);
     }
 
     .dash-loading .loader-ring {
@@ -1129,7 +1150,7 @@
       pointer-events: none;
       z-index: 1;
       opacity: 0.12;
-      background-image: url('Light_BG.png');
+      background-image: var(--light-bg-image);
       background-size: contain;
       background-repeat: no-repeat;
       background-position: left bottom;
@@ -1139,7 +1160,7 @@
     }
 
     body.dark-theme .chart-bg-overlay {
-      background-image: url('Dark_BG.png');
+      background-image: var(--dark-bg-image);
       opacity: 0.18;
     }
 
@@ -1509,8 +1530,15 @@
     }
 
     @keyframes gauges-fade-in {
-      from { opacity: 0; transform: translateX(-10px); }
-      to { opacity: 1; transform: translateX(0); }
+      from {
+        opacity: 0;
+        transform: translateX(-10px);
+      }
+
+      to {
+        opacity: 1;
+        transform: translateX(0);
+      }
     }
 
     .compact-gauge-card {
@@ -1756,10 +1784,870 @@
       text-transform: uppercase;
       letter-spacing: 0.05em;
     }
+
+    /* Premium Liquid Glass Override */
+    :root {
+      --bg-base: #edf4ff;
+      --bg-depth: rgba(255, 255, 255, 0.72);
+      --bg-panel: rgba(246, 250, 255, 0.72);
+      --bg-glass: rgba(255, 255, 255, 0.56);
+      --bg-glass-light: rgba(255, 255, 255, 0.42);
+      --bg-control: rgba(255, 255, 255, 0.46);
+      --bg-control-hov: rgba(255, 255, 255, 0.7);
+      --bg-active: rgba(39, 126, 255, 0.12);
+      --bg-sidebar: rgba(240, 246, 255, 0.58);
+      --bdr-dim: rgba(255, 255, 255, 0.34);
+      --bdr-base: rgba(107, 143, 198, 0.2);
+      --bdr-muted: rgba(99, 131, 193, 0.34);
+      --bdr-accent: rgba(54, 124, 255, 0.4);
+      --txt-bright: #07111f;
+      --txt-primary: #132238;
+      --txt-secondary: #41566f;
+      --txt-muted: #6d8198;
+      --accent: #1f7aff;
+      --accent-lo: rgba(31, 122, 255, 0.1);
+      --accent-mid: rgba(31, 122, 255, 0.24);
+      --accent-glow: rgba(31, 122, 255, 0.3);
+      --ok: #00b894;
+      --err: #ff5470;
+      --warn: #ffaf38;
+      --bull: #00c58e;
+      --bear: #ff5a76;
+      --ff-display: 'Chakra Petch', 'Barlow', sans-serif;
+      --radius: 18px;
+      --radius-lg: 28px;
+      --radius-xl: 36px;
+      --shadow-lg: 0 30px 80px rgba(31, 55, 104, 0.12), 0 10px 26px rgba(80, 117, 180, 0.14), inset 0 1px 0 rgba(255, 255, 255, 0.72);
+      --glass-cyan: rgba(255, 255, 255, 0.62);
+      --neon-cyan: #3ea6ff;
+      --neon-pink: #ff6bb2;
+      --neon-green: #00d68f;
+      --neon-blue: #5b8cff;
+      --logo-primary: #2e8dff;
+      --logo-secondary: #5dd4ff;
+      --logo-glow: rgba(46, 141, 255, 0.36);
+    }
+
+    body.dark-theme {
+      --bg-base: #040915;
+      --bg-depth: rgba(7, 13, 29, 0.72);
+      --bg-panel: rgba(6, 14, 30, 0.72);
+      --bg-glass: rgba(10, 18, 39, 0.5);
+      --bg-glass-light: rgba(15, 24, 48, 0.38);
+      --bg-control: rgba(14, 24, 49, 0.46);
+      --bg-control-hov: rgba(20, 35, 67, 0.72);
+      --bg-active: rgba(59, 130, 246, 0.14);
+      --bg-sidebar: rgba(7, 14, 28, 0.58);
+      --bdr-dim: rgba(150, 197, 255, 0.08);
+      --bdr-base: rgba(120, 168, 255, 0.18);
+      --bdr-muted: rgba(126, 176, 255, 0.3);
+      --bdr-accent: rgba(79, 181, 255, 0.46);
+      --txt-bright: #f8fbff;
+      --txt-primary: #d9e8ff;
+      --txt-secondary: #9eb6d4;
+      --txt-muted: #6a81a6;
+      --accent: #4fb5ff;
+      --accent-lo: rgba(79, 181, 255, 0.12);
+      --accent-mid: rgba(79, 181, 255, 0.26);
+      --accent-glow: rgba(79, 181, 255, 0.44);
+      --logo-primary: #59bdff;
+      --logo-secondary: #71f0ff;
+      --logo-glow: rgba(89, 189, 255, 0.52);
+      --shadow-lg: 0 36px 100px rgba(1, 6, 18, 0.62), 0 18px 40px rgba(7, 18, 44, 0.4), inset 0 1px 0 rgba(151, 205, 255, 0.08);
+    }
+
+    html {
+      cursor: default;
+    }
+
+    body {
+      background:
+        radial-gradient(circle at 12% 18%, rgba(123, 213, 255, 0.34), transparent 26%),
+        radial-gradient(circle at 85% 12%, rgba(255, 150, 198, 0.22), transparent 24%),
+        radial-gradient(circle at 76% 82%, rgba(68, 212, 173, 0.18), transparent 22%),
+        linear-gradient(145deg, #eef5ff 0%, #edf3fb 42%, #e7eefc 100%);
+      background-attachment: fixed;
+    }
+
+    body.dark-theme {
+      background:
+        radial-gradient(circle at 14% 18%, rgba(54, 119, 255, 0.28), transparent 25%),
+        radial-gradient(circle at 84% 18%, rgba(31, 214, 255, 0.18), transparent 24%),
+        radial-gradient(circle at 72% 84%, rgba(0, 214, 143, 0.12), transparent 22%),
+        linear-gradient(160deg, #030714 0%, #07101f 52%, #091428 100%);
+      background-attachment: fixed;
+    }
+
+    body::after {
+      content: "";
+      position: fixed;
+      inset: 0;
+      z-index: -1;
+      pointer-events: none;
+      background:
+        linear-gradient(rgba(255, 255, 255, 0.03) 1px, transparent 1px),
+        linear-gradient(90deg, rgba(255, 255, 255, 0.03) 1px, transparent 1px);
+      background-size: 32px 32px;
+      mask-image: radial-gradient(circle at center, black 45%, transparent 100%);
+      -webkit-mask-image: radial-gradient(circle at center, black 45%, transparent 100%);
+      opacity: 0.55;
+    }
+
+    #app {
+      isolation: isolate;
+      position: relative;
+      z-index: 1;
+    }
+
+    .liquid-orb {
+      position: fixed;
+      border-radius: 999px;
+      pointer-events: none;
+      filter: blur(18px);
+      mix-blend-mode: screen;
+      opacity: 0.55;
+      z-index: 0;
+      animation: orb-float 16s ease-in-out infinite;
+    }
+
+    .liquid-orb.orb-a {
+      top: 78px;
+      left: 42px;
+      width: 220px;
+      height: 220px;
+      background: radial-gradient(circle at 30% 30%, rgba(129, 211, 255, 0.75), rgba(129, 211, 255, 0.12) 55%, transparent 75%);
+    }
+
+    .liquid-orb.orb-b {
+      top: 92px;
+      right: 120px;
+      width: 280px;
+      height: 280px;
+      background: radial-gradient(circle at 50% 50%, rgba(255, 144, 203, 0.42), rgba(255, 144, 203, 0.1) 58%, transparent 76%);
+      animation-duration: 19s;
+    }
+
+    .liquid-orb.orb-c {
+      bottom: 66px;
+      right: 22%;
+      width: 240px;
+      height: 240px;
+      background: radial-gradient(circle at 50% 50%, rgba(54, 255, 204, 0.24), rgba(54, 255, 204, 0.08) 58%, transparent 78%);
+      animation-duration: 22s;
+    }
+
+    @keyframes orb-float {
+
+      0%,
+      100% {
+        transform: translate3d(0, 0, 0) scale(1);
+      }
+
+      50% {
+        transform: translate3d(18px, -14px, 0) scale(1.06);
+      }
+    }
+
+    .cursor-aura,
+    .cursor-dot {
+      position: fixed;
+      top: 0;
+      left: 0;
+      pointer-events: none;
+      z-index: 9999;
+      transform: translate3d(-50%, -50%, 0);
+      transition: opacity 0.25s ease, transform 0.25s ease, width 0.25s ease, height 0.25s ease, background 0.25s ease;
+      opacity: 0;
+    }
+
+    .cursor-aura {
+      width: 92px;
+      height: 92px;
+      border-radius: 50%;
+      background: radial-gradient(circle, rgba(200, 242, 255, 0.84) 0%, rgba(143, 219, 255, 0.54) 34%, rgba(90, 189, 255, 0.24) 58%, rgba(90, 189, 255, 0.08) 72%, transparent 80%);
+      filter: blur(12px);
+      mix-blend-mode: screen;
+    }
+
+    .cursor-dot {
+      width: 30px;
+      height: 30px;
+      display: flex;
+      align-items: center;
+      justify-content: center;
+      border-radius: 999px;
+      font-family: var(--ff-display);
+      font-size: 0.76rem;
+      font-weight: 800;
+      letter-spacing: 0.12em;
+      color: #127ed4;
+      text-shadow: 0 0 14px rgba(255, 255, 255, 0.9);
+      background: radial-gradient(circle, rgba(255, 255, 255, 0.96) 0%, rgba(216, 243, 255, 0.9) 58%, rgba(111, 202, 255, 0.28) 78%, transparent 82%);
+      border: 1px solid rgba(86, 176, 255, 0.4);
+      box-shadow: 0 0 26px rgba(71, 184, 255, 0.3);
+    }
+
+    body.dark-theme .cursor-aura {
+      width: 220px;
+      height: 220px;
+      background: radial-gradient(circle, rgba(202, 245, 255, 0.28) 0%, rgba(133, 225, 255, 0.18) 24%, rgba(76, 201, 255, 0.08) 44%, rgba(24, 96, 130, 0.03) 62%, transparent 74%);
+      filter: blur(14px);
+      mix-blend-mode: screen;
+    }
+
+    body.dark-theme .cursor-dot {
+      width: 30px;
+      height: 30px;
+      color: #f4fdff;
+      text-shadow: 0 0 18px rgba(114, 226, 255, 0.95);
+      background: radial-gradient(circle, rgba(255, 255, 255, 1) 0%, rgba(180, 239, 255, 0.96) 36%, rgba(86, 214, 255, 0.3) 70%, transparent 82%);
+      border-color: rgba(133, 224, 255, 0.56);
+      box-shadow: 0 0 26px rgba(76, 213, 255, 0.72);
+    }
+
+    body.cursor-active .cursor-aura,
+    body.cursor-active .cursor-dot {
+      opacity: 1;
+    }
+
+    body.cursor-press .cursor-aura {
+      width: 120px;
+      height: 120px;
+      opacity: 0.8;
+    }
+
+    body.dark-theme.cursor-press .cursor-aura {
+      width: 250px;
+      height: 250px;
+    }
+
+    body.cursor-press .cursor-dot {
+      transform: translate3d(-50%, -50%, 0) scale(0.82);
+    }
+
+    body.cursor-hover .cursor-aura {
+      width: 112px;
+      height: 112px;
+      background: radial-gradient(circle, rgba(214, 246, 255, 0.9) 0%, rgba(163, 227, 255, 0.58) 34%, rgba(97, 188, 255, 0.24) 58%, rgba(97, 188, 255, 0.08) 74%, transparent 82%);
+    }
+
+    body.dark-theme.cursor-hover .cursor-aura {
+      width: 250px;
+      height: 250px;
+      background: radial-gradient(circle, rgba(220, 247, 255, 0.32) 0%, rgba(144, 231, 255, 0.2) 26%, rgba(86, 214, 255, 0.09) 48%, rgba(24, 96, 130, 0.03) 66%, transparent 76%);
+    }
+
+    .hdr,
+    .analysis-panel,
+    .explorer-window,
+    .status-pill,
+    .compact-gauge-card,
+    .search-results,
+    .gauge-hero-ai-details {
+      box-shadow: var(--shadow-lg);
+    }
+
+    .hdr {
+      margin: 14px 14px 0;
+      border-radius: 30px;
+      border: 1px solid rgba(255, 255, 255, 0.42);
+      background: linear-gradient(135deg, rgba(255, 255, 255, 0.62) 0%, rgba(255, 255, 255, 0.34) 48%, rgba(218, 231, 255, 0.2) 100%);
+      backdrop-filter: blur(28px) saturate(180%);
+      -webkit-backdrop-filter: blur(28px) saturate(180%);
+      box-shadow: 0 20px 50px rgba(64, 98, 154, 0.12), inset 0 1px 0 rgba(255, 255, 255, 0.72);
+    }
+
+    body.dark-theme .hdr {
+      background: linear-gradient(135deg, rgba(13, 22, 43, 0.7) 0%, rgba(13, 22, 43, 0.48) 52%, rgba(13, 29, 61, 0.3) 100%);
+      border-color: rgba(156, 211, 255, 0.12);
+      box-shadow: 0 24px 60px rgba(2, 8, 22, 0.5), inset 0 1px 0 rgba(140, 205, 255, 0.08);
+    }
+
+    .logo-name {
+      background: linear-gradient(90deg, var(--txt-bright) 0%, var(--logo-primary) 38%, var(--logo-secondary) 80%, var(--txt-bright) 100%);
+      background-size: 200% auto;
+      animation: logo-sheen 7s linear infinite;
+    }
+
+    @keyframes logo-sheen {
+      0% {
+        background-position: 0% center;
+      }
+
+      100% {
+        background-position: 200% center;
+      }
+    }
+
+    .market-status-bar {
+      padding: 8px 12px;
+      border-radius: 999px;
+      background: rgba(255, 255, 255, 0.22);
+      border: 1px solid rgba(255, 255, 255, 0.34);
+      box-shadow: inset 0 1px 0 rgba(255, 255, 255, 0.56);
+    }
+
+    .omnibox {
+      width: 250px;
+    }
+
+    .omnibox input,
+    .k-select,
+    .k-input,
+    .btn-icon,
+    .btn-theme,
+    .btn-primary,
+    .dash-close,
+    .explorer-search input,
+    .explorer-symbol-card,
+    .explorer-cat-item {
+      position: relative;
+      overflow: hidden;
+    }
+
+    .omnibox input,
+    .k-select,
+    .k-input,
+    .btn-icon,
+    .btn-theme,
+    .btn-primary,
+    .dash-close,
+    .explorer-search input {
+      background: linear-gradient(180deg, rgba(255, 255, 255, 0.52) 0%, rgba(255, 255, 255, 0.28) 100%);
+      border: 1px solid rgba(255, 255, 255, 0.44);
+      box-shadow: inset 0 1px 0 rgba(255, 255, 255, 0.72), 0 14px 28px rgba(58, 92, 146, 0.08);
+      backdrop-filter: blur(18px) saturate(175%);
+      -webkit-backdrop-filter: blur(18px) saturate(175%);
+    }
+
+    body.dark-theme .omnibox input,
+    body.dark-theme .k-select,
+    body.dark-theme .k-input,
+    body.dark-theme .btn-icon,
+    body.dark-theme .btn-theme,
+    body.dark-theme .btn-primary,
+    body.dark-theme .dash-close,
+    body.dark-theme .explorer-search input {
+      background: linear-gradient(180deg, rgba(18, 30, 58, 0.64) 0%, rgba(13, 23, 44, 0.4) 100%);
+      border-color: rgba(136, 191, 255, 0.16);
+      box-shadow: inset 0 1px 0 rgba(181, 224, 255, 0.08), 0 16px 34px rgba(0, 0, 0, 0.18);
+    }
+
+    .omnibox input::placeholder,
+    .explorer-search input::placeholder {
+      color: color-mix(in srgb, var(--txt-muted) 78%, white 22%);
+    }
+
+    .omnibox input:hover,
+    .k-select:hover,
+    .k-input:hover,
+    .btn-icon:hover,
+    .btn-theme:hover,
+    .dash-close:hover,
+    .explorer-search input:hover {
+      transform: translateY(-1px);
+      border-color: rgba(107, 173, 255, 0.52);
+      box-shadow: inset 0 1px 0 rgba(255, 255, 255, 0.84), 0 18px 34px rgba(64, 104, 176, 0.12), 0 0 0 6px rgba(78, 156, 255, 0.06);
+    }
+
+    .btn-primary {
+      background: linear-gradient(135deg, rgba(18, 120, 255, 0.98) 0%, rgba(72, 173, 255, 0.88) 55%, rgba(111, 223, 255, 0.86) 100%);
+      color: #f7fbff;
+      border: 1px solid rgba(255, 255, 255, 0.4);
+      box-shadow: 0 16px 34px rgba(34, 123, 255, 0.26), inset 0 1px 0 rgba(255, 255, 255, 0.4);
+      letter-spacing: 0.18em;
+    }
+
+    .btn-primary:hover {
+      transform: translateY(-2px);
+      box-shadow: 0 24px 44px rgba(34, 123, 255, 0.34), 0 0 0 7px rgba(78, 156, 255, 0.08), inset 0 1px 0 rgba(255, 255, 255, 0.48);
+      filter: saturate(1.08);
+    }
+
+    .btn-icon::before,
+    .btn-theme::before,
+    .btn-primary::before,
+    .explorer-symbol-card::before {
+      content: "";
+      position: absolute;
+      inset: 0;
+      background: linear-gradient(115deg, transparent 20%, rgba(255, 255, 255, 0.42) 48%, transparent 76%);
+      transform: translateX(-130%);
+      transition: transform 0.7s ease;
+      pointer-events: none;
+    }
+
+    .btn-icon:hover::before,
+    .btn-theme:hover::before,
+    .btn-primary:hover::before,
+    .explorer-symbol-card:hover::before {
+      transform: translateX(130%);
+    }
+
+    .main {
+      margin: 14px;
+      border-radius: 34px;
+      border: 1px solid rgba(255, 255, 255, 0.42);
+      background:
+        radial-gradient(circle at top left, rgba(255, 255, 255, 0.3), transparent 30%),
+        linear-gradient(180deg, rgba(255, 255, 255, 0.28) 0%, rgba(255, 255, 255, 0.12) 100%);
+      box-shadow: 0 36px 90px rgba(31, 57, 102, 0.16), inset 0 1px 0 rgba(255, 255, 255, 0.78);
+      backdrop-filter: blur(22px) saturate(180%);
+      -webkit-backdrop-filter: blur(22px) saturate(180%);
+      isolation: isolate;
+    }
+
+    body.dark-theme .main {
+      border-color: rgba(124, 179, 255, 0.1);
+      background:
+        radial-gradient(circle at top left, rgba(130, 177, 255, 0.08), transparent 30%),
+        linear-gradient(180deg, rgba(9, 16, 34, 0.52) 0%, rgba(7, 14, 29, 0.32) 100%);
+      box-shadow: 0 38px 100px rgba(1, 8, 20, 0.5), inset 0 1px 0 rgba(179, 224, 255, 0.08);
+    }
+
+    .chart-bg-overlay {
+      inset: 0;
+      opacity: 1;
+      background-image:
+        linear-gradient(90deg, rgba(236, 246, 255, 0.9) 0%, rgba(236, 246, 255, 0.74) 24%, rgba(236, 246, 255, 0.34) 54%, rgba(236, 246, 255, 0.12) 100%),
+        radial-gradient(circle at 24% 58%, rgba(104, 225, 255, 0.22), transparent 24%),
+        radial-gradient(circle at 76% 14%, rgba(255, 171, 217, 0.16), transparent 20%),
+        linear-gradient(180deg, rgba(134, 219, 255, 0.08) 0%, rgba(134, 219, 255, 0) 42%, rgba(124, 168, 255, 0.04) 100%);
+      background-size: auto, auto, auto, auto;
+      background-position: center, 24% 58%, 76% 14%, center;
+      background-repeat: no-repeat;
+      mask-image: linear-gradient(to right, rgba(0, 0, 0, 0.98) 0%, rgba(0, 0, 0, 0.96) 62%, rgba(0, 0, 0, 0.78) 82%, rgba(0, 0, 0, 0.42) 100%);
+      -webkit-mask-image: linear-gradient(to right, rgba(0, 0, 0, 0.98) 0%, rgba(0, 0, 0, 0.96) 62%, rgba(0, 0, 0, 0.78) 82%, rgba(0, 0, 0, 0.42) 100%);
+    }
+
+    .chart-logo-overlay {
+      bottom: 28px;
+      right: 108px;
+      font-size: 3rem;
+      letter-spacing: 0.35em;
+      opacity: 0.16;
+      z-index: 3;
+    }
+
+    .chart-bg-overlay::before,
+    .chart-bg-overlay::after {
+      content: "";
+      position: absolute;
+      inset: 0;
+      pointer-events: none;
+    }
+
+    .chart-bg-overlay::before {
+      background:
+        linear-gradient(90deg, rgba(235, 246, 255, 0.28) 0%, rgba(235, 246, 255, 0.16) 35%, rgba(235, 246, 255, 0.06) 62%, transparent 100%),
+        radial-gradient(circle at 31% 65%, rgba(92, 212, 255, 0.16), transparent 16%),
+        radial-gradient(circle at 29% 34%, rgba(107, 173, 255, 0.12), transparent 18%),
+        linear-gradient(90deg, transparent 0%, rgba(79, 179, 255, 0.08) 18%, transparent 36%, transparent 100%),
+        var(--light-bg-image);
+      background-size: auto, auto, auto, auto, cover;
+      background-position: center, 31% 65%, 29% 34%, center, left center;
+      background-repeat: no-repeat;
+      mix-blend-mode: screen;
+      opacity: 0.3;
+      animation: hologram-drift 20s ease-in-out infinite;
+    }
+
+    .chart-bg-overlay::after {
+      background:
+        linear-gradient(180deg, rgba(255, 255, 255, 0.12) 0%, rgba(255, 255, 255, 0.02) 38%, rgba(113, 225, 255, 0.04) 100%),
+        radial-gradient(circle at 46% 58%, rgba(82, 221, 255, 0.12), transparent 7%),
+        radial-gradient(circle at 72% 46%, rgba(126, 168, 255, 0.08), transparent 10%),
+        repeating-linear-gradient(90deg, rgba(96, 182, 255, 0.06) 0 1px, transparent 1px 110px),
+        repeating-linear-gradient(180deg, rgba(96, 182, 255, 0.04) 0 1px, transparent 1px 78px);
+      opacity: 0.34;
+      mask-image: linear-gradient(to right, rgba(0, 0, 0, 0.92) 0%, rgba(0, 0, 0, 0.6) 64%, transparent 100%);
+      -webkit-mask-image: linear-gradient(to right, rgba(0, 0, 0, 0.92) 0%, rgba(0, 0, 0, 0.6) 64%, transparent 100%);
+      animation: data-grid-drift 18s linear infinite, scan-sweep 8s ease-in-out infinite;
+    }
+
+    body.dark-theme .chart-bg-overlay {
+      background-image:
+        linear-gradient(90deg, rgba(7, 15, 32, 0.76) 0%, rgba(7, 15, 32, 0.44) 28%, rgba(7, 15, 32, 0.14) 56%, rgba(7, 15, 32, 0.04) 100%),
+        radial-gradient(circle at 22% 58%, rgba(71, 196, 255, 0.18), transparent 24%),
+        radial-gradient(circle at 74% 16%, rgba(110, 146, 255, 0.12), transparent 18%),
+        var(--dark-bg-image);
+      background-size: auto, auto, auto, cover;
+      background-position: center, 22% 58%, 74% 16%, left center;
+    }
+
+    body.dark-theme .chart-bg-overlay::before {
+      background:
+        linear-gradient(90deg, rgba(18, 32, 64, 0.24) 0%, rgba(18, 32, 64, 0.12) 35%, rgba(18, 32, 64, 0.04) 62%, transparent 100%),
+        radial-gradient(circle at 31% 65%, rgba(92, 212, 255, 0.16), transparent 16%),
+        radial-gradient(circle at 29% 34%, rgba(107, 173, 255, 0.12), transparent 18%),
+        linear-gradient(90deg, transparent 0%, rgba(79, 179, 255, 0.08) 18%, transparent 36%, transparent 100%),
+        var(--dark-bg-image);
+      background-size: auto, auto, auto, auto, cover;
+      background-position: center, 31% 65%, 29% 34%, center, left center;
+      background-repeat: no-repeat;
+      opacity: 0.76;
+      animation: hologram-drift 20s ease-in-out infinite;
+    }
+
+    body.dark-theme .chart-bg-overlay::after {
+      opacity: 0.28;
+    }
+
+    @keyframes hologram-drift {
+
+      0%,
+      100% {
+        transform: translate3d(0, 0, 0) scale(1);
+        filter: saturate(1) brightness(1);
+      }
+
+      50% {
+        transform: translate3d(10px, -6px, 0) scale(1.018);
+        filter: saturate(1.04) brightness(1.02);
+      }
+    }
+
+    @keyframes data-grid-drift {
+      0% {
+        background-position: center, 46% 58%, 72% 46%, 0 0, 0 0;
+      }
+
+      100% {
+        background-position: center, 47% 57%, 71% 47%, 110px 0, 0 78px;
+      }
+    }
+
+    @keyframes scan-sweep {
+
+      0%,
+      100% {
+        box-shadow: inset 0 0 0 rgba(95, 210, 255, 0);
+      }
+
+      50% {
+        box-shadow: inset 0 -120px 120px rgba(95, 210, 255, 0.05), inset 0 120px 120px rgba(255, 255, 255, 0.03);
+      }
+    }
+
+    .status-pill {
+      border-radius: 999px;
+      padding: 10px 18px 10px 12px;
+      background: linear-gradient(180deg, rgba(255, 255, 255, 0.55) 0%, rgba(255, 255, 255, 0.26) 100%);
+      border: 1px solid rgba(255, 255, 255, 0.52);
+      box-shadow: inset 0 1px 0 rgba(255, 255, 255, 0.82), 0 16px 32px rgba(42, 74, 129, 0.12);
+    }
+
+    .chart-gauges-container {
+      top: 54px;
+      left: 20px;
+      gap: 12px;
+    }
+
+    .compact-gauge-card {
+      min-width: 128px;
+      padding: 12px 16px;
+      border-radius: 22px;
+      border: 1px solid rgba(255, 255, 255, 0.45);
+      background: linear-gradient(180deg, rgba(255, 255, 255, 0.44) 0%, rgba(255, 255, 255, 0.18) 100%);
+      box-shadow: inset 0 1px 0 rgba(255, 255, 255, 0.76), 0 20px 36px rgba(56, 87, 138, 0.14);
+    }
+
+    .compact-gauge-card:hover {
+      transform: translateY(-4px) scale(1.015);
+    }
+
+    .compact-gauge-card.hero {
+      background: linear-gradient(135deg, rgba(255, 255, 255, 0.46) 0%, rgba(56, 148, 255, 0.2) 55%, rgba(111, 223, 255, 0.14) 100%);
+      border-color: rgba(104, 181, 255, 0.5);
+    }
+
+    .analysis-panel {
+      inset: 14px;
+      width: auto;
+      height: auto;
+      border-radius: 34px;
+      border: 1px solid rgba(255, 255, 255, 0.44);
+      background: linear-gradient(180deg, rgba(245, 249, 255, 0.7) 0%, rgba(234, 241, 251, 0.52) 100%);
+      box-shadow: 0 36px 100px rgba(33, 56, 98, 0.18), inset 0 1px 0 rgba(255, 255, 255, 0.84);
+      overflow: hidden;
+    }
+
+    body.dark-theme .analysis-panel {
+      border-color: rgba(148, 208, 255, 0.12);
+      background: linear-gradient(180deg, rgba(8, 15, 30, 0.78) 0%, rgba(8, 15, 30, 0.6) 100%);
+    }
+
+    .dash-header {
+      padding: 24px 34px;
+      background: linear-gradient(180deg, rgba(255, 255, 255, 0.32) 0%, rgba(255, 255, 255, 0.12) 100%);
+      border-bottom: 1px solid rgba(255, 255, 255, 0.26);
+    }
+
+    .dash-gauges-hero {
+      gap: 18px;
+      padding: 18px 18px 0;
+      border-bottom: none;
+    }
+
+    .gauge-hero-card {
+      border-right: none;
+      border-radius: 28px;
+      margin-bottom: 18px;
+      border: 1px solid rgba(255, 255, 255, 0.34);
+      background: linear-gradient(180deg, rgba(255, 255, 255, 0.22) 0%, rgba(255, 255, 255, 0.12) 100%);
+      box-shadow: inset 0 1px 0 rgba(255, 255, 255, 0.65), 0 22px 38px rgba(52, 86, 143, 0.12);
+    }
+
+    .gauge-hero-card:hover {
+      transform: translateY(-6px) scale(1.01);
+      border-color: rgba(108, 180, 255, 0.4);
+      box-shadow: inset 0 1px 0 rgba(255, 255, 255, 0.8), 0 30px 46px rgba(49, 87, 152, 0.18), 0 0 0 7px rgba(103, 178, 255, 0.06);
+    }
+
+    .gauge-hero-card.hero-total {
+      background: linear-gradient(160deg, rgba(255, 255, 255, 0.28) 0%, rgba(57, 144, 255, 0.18) 58%, rgba(111, 223, 255, 0.14) 100%);
+    }
+
+    .gauge-hero-title,
+    .dc-header,
+    .explorer-title {
+      letter-spacing: 0.18em;
+    }
+
+    .gauge-hero-ai-details,
+    .dc-header,
+    .dash-col,
+    .explorer-sidebar,
+    .explorer-main,
+    .explorer-symbol-card,
+    .search-results {
+      background: linear-gradient(180deg, rgba(255, 255, 255, 0.28) 0%, rgba(255, 255, 255, 0.14) 100%);
+      backdrop-filter: blur(18px) saturate(170%);
+      -webkit-backdrop-filter: blur(18px) saturate(170%);
+    }
+
+    .dash-tables-row {
+      padding: 0 18px 18px;
+      gap: 18px;
+      background: transparent;
+      transition: grid-template-columns 0.32s ease, opacity 0.24s ease, gap 0.24s ease;
+    }
+
+    .dash-col {
+      border-right: none;
+      border-radius: 24px;
+      border: 1px solid rgba(255, 255, 255, 0.34);
+      overflow: visible;
+      box-shadow: inset 0 1px 0 rgba(255, 255, 255, 0.65), 0 20px 36px rgba(55, 86, 138, 0.1);
+      transition: transform 0.28s ease, opacity 0.28s ease, box-shadow 0.28s ease, border-color 0.28s ease, filter 0.28s ease;
+      cursor: pointer;
+    }
+
+    .dash-col:hover {
+      transform: translateY(-3px);
+      border-color: rgba(104, 176, 255, 0.44);
+      box-shadow: inset 0 1px 0 rgba(255, 255, 255, 0.72), 0 24px 42px rgba(55, 92, 150, 0.16);
+    }
+
+    .dash-col.is-focus {
+      transform: translateY(-6px);
+      border-color: rgba(95, 171, 255, 0.56);
+      box-shadow: inset 0 1px 0 rgba(255, 255, 255, 0.84), 0 30px 54px rgba(48, 89, 160, 0.2), 0 0 0 8px rgba(100, 175, 255, 0.08);
+      filter: saturate(1.06);
+      z-index: 2;
+    }
+
+    .dash-tables-row.has-focus {
+      grid-template-columns: minmax(0, 1fr);
+      gap: 0;
+      overflow: visible;
+    }
+
+    .dash-tables-row.has-focus .dash-col:not(.is-focus) {
+      opacity: 0;
+      filter: blur(6px) saturate(0.8);
+      transform: scale(0.96);
+      pointer-events: none;
+      max-width: 0;
+      min-width: 0;
+      border-width: 0;
+      margin: 0;
+      padding: 0;
+      height: 0;
+    }
+
+    .dash-tables-row.has-focus .dash-col.is-focus {
+      width: 100%;
+    }
+
+    .dash-tables-row.has-focus .dash-table-wrap {
+      overflow: visible;
+    }
+
+    .dt td,
+    .pivot-table td,
+    .pivot-table th {
+      border-bottom-color: rgba(140, 173, 219, 0.16);
+    }
+
+    .dt tr:hover td,
+    .pivot-table tr:hover td {
+      background: rgba(102, 176, 255, 0.06);
+    }
+
+    .dc-header::after {
+      content: "Click để làm rõ";
+      float: right;
+      font-size: 0.62rem;
+      letter-spacing: 0.12em;
+      color: var(--txt-muted);
+      opacity: 0.85;
+    }
+
+    .dash-col.is-focus .dc-header::after {
+      content: "Đang tập trung";
+      color: var(--accent);
+    }
+
+    .dt-act-neut,
+    .compact-gauge-signal.neutral {
+      color: #facc15 !important;
+      text-shadow: 0 0 14px rgba(250, 204, 21, 0.18);
+    }
+
+    .dash-col.is-focus .dc-header::after {
+      content: "Nh\1EA5n l\1EA7n n\1EEF a \0111\1EC3 thu g\1ECDn";
+    }
+
+    .explorer-overlay {
+      background: rgba(9, 14, 28, 0.34);
+      backdrop-filter: blur(28px) saturate(155%);
+    }
+
+    .explorer-window {
+      max-width: 1220px;
+      max-height: 780px;
+      border-radius: 34px;
+      background: linear-gradient(180deg, rgba(245, 249, 255, 0.72) 0%, rgba(233, 239, 250, 0.56) 100%);
+      border: 1px solid rgba(255, 255, 255, 0.46);
+      box-shadow: 0 40px 110px rgba(18, 34, 66, 0.22), inset 0 1px 0 rgba(255, 255, 255, 0.84);
+      backdrop-filter: blur(26px) saturate(180%);
+      -webkit-backdrop-filter: blur(26px) saturate(180%);
+    }
+
+    body.dark-theme .explorer-window {
+      background: linear-gradient(180deg, rgba(9, 16, 34, 0.76) 0%, rgba(8, 15, 30, 0.62) 100%);
+      border-color: rgba(144, 198, 255, 0.12);
+    }
+
+    .explorer-head,
+    .explorer-main {
+      background: transparent;
+    }
+
+    .explorer-sidebar {
+      background: linear-gradient(180deg, rgba(255, 255, 255, 0.22) 0%, rgba(255, 255, 255, 0.12) 100%);
+    }
+
+    .explorer-cat-item {
+      margin: 0 12px 8px;
+      border-radius: 16px;
+      border: 1px solid transparent;
+      border-left: 1px solid transparent;
+    }
+
+    .explorer-cat-item.active {
+      border-color: rgba(107, 177, 255, 0.35);
+      box-shadow: inset 0 1px 0 rgba(255, 255, 255, 0.7), 0 10px 20px rgba(59, 118, 196, 0.12);
+    }
+
+    .explorer-grid {
+      gap: 16px;
+    }
+
+    .explorer-symbol-card {
+      border-radius: 22px;
+      border: 1px solid rgba(255, 255, 255, 0.38);
+      background: linear-gradient(180deg, rgba(255, 255, 255, 0.34) 0%, rgba(255, 255, 255, 0.14) 100%);
+      box-shadow: inset 0 1px 0 rgba(255, 255, 255, 0.74), 0 18px 34px rgba(52, 84, 136, 0.12);
+      transition: transform 0.28s ease, box-shadow 0.28s ease, border-color 0.28s ease;
+    }
+
+    .explorer-symbol-card:hover {
+      transform: translateY(-6px) rotateX(3deg);
+      border-color: rgba(98, 172, 255, 0.44);
+      box-shadow: inset 0 1px 0 rgba(255, 255, 255, 0.82), 0 28px 44px rgba(39, 95, 174, 0.18), 0 0 0 8px rgba(90, 165, 255, 0.06);
+    }
+
+    @media (max-width: 1024px) {
+      .hdr {
+        margin: 10px 10px 0;
+        border-radius: 24px;
+      }
+
+      .main,
+      .analysis-panel {
+        margin: 10px;
+        border-radius: 26px;
+      }
+
+      .omnibox {
+        width: 180px;
+      }
+
+      .chart-gauges-container {
+        flex-wrap: wrap;
+        right: 18px;
+        top: 62px;
+      }
+    }
+
+    @media (max-width: 800px) {
+
+      .cursor-aura,
+      .cursor-dot,
+      .liquid-orb {
+        display: none;
+      }
+
+      .hdr {
+        padding: 0 12px;
+      }
+
+      .main,
+      .analysis-panel {
+        margin: 8px;
+        border-radius: 22px;
+      }
+
+      .dash-gauges-hero,
+      .dash-tables-row {
+        padding-left: 12px;
+        padding-right: 12px;
+      }
+
+      .compact-gauge-card {
+        min-width: 112px;
+      }
+
+      .chart-logo-overlay {
+        font-size: 1.8rem;
+        right: 72px;
+      }
+
+      .chart-gauges-container {
+        top: 68px;
+      }
+    }
   </style>
 </head>
 
 <body>
+  <div class="liquid-orb orb-a" aria-hidden="true"></div>
+  <div class="liquid-orb orb-b" aria-hidden="true"></div>
+  <div class="liquid-orb orb-c" aria-hidden="true"></div>
+  <div class="cursor-aura" id="cursorAura" aria-hidden="true"></div>
+  <div class="cursor-dot" id="cursorDot" aria-hidden="true">AI</div>
   <div id="app">
 
     <!-- ── HEADER ───────────────────────────────── -->
@@ -1768,20 +2656,82 @@
       <!-- Logo -->
       <div class="logo">
         <div class="logo-mark">
-          <!-- Stylised K hexagon mark -->
-          <svg viewBox="0 0 32 32" fill="none" xmlns="http://www.w3.org/2000/svg">
-            <polygon points="16,2 28,9 28,23 16,30 4,23 4,9" stroke="rgba(34,211,238,0.55)" stroke-width="1"
-              fill="rgba(34,211,238,0.06)" />
-            <polygon points="16,6 24,11 24,21 16,26 8,21 8,11" stroke="rgba(34,211,238,0.22)" stroke-width="0.5"
+          <svg viewBox="0 0 100 100" fill="none" xmlns="http://www.w3.org/2000/svg">
+            <defs>
+              <linearGradient id="logoGrad" x1="0%" y1="0%" x2="100%" y2="100%">
+                <stop offset="0%" stop-color="var(--logo-primary)" />
+                <stop offset="100%" stop-color="var(--logo-secondary)" />
+              </linearGradient>
+              <filter id="logoGlow" x="-20%" y="-20%" width="140%" height="140%">
+                <feGaussianBlur stdDeviation="2" result="blur" />
+                <feComposite in="SourceGraphic" in2="blur" operator="over" />
+              </filter>
+            </defs>
+
+            <!-- Circuit Lines (Outer) -->
+            <g stroke="url(#logoGrad)" stroke-width="1.2" stroke-linecap="round" opacity="0.8">
+              <!-- Top -->
+              <path d="M50 25 V10" />
+              <circle cx="50" cy="8" r="2.5" fill="none" stroke="url(#logoGrad)" stroke-width="1" />
+              <circle cx="50" cy="8" r="1.2" fill="url(#logoGrad)" />
+
+              <path d="M42 28 V15 H35" />
+              <circle cx="33" cy="15" r="1.5" fill="url(#logoGrad)" />
+
+              <path d="M58 28 V15 H65" />
+              <circle cx="67" cy="15" r="1.5" fill="url(#logoGrad)" />
+
+              <!-- Bottom -->
+              <path d="M50 75 V90" />
+              <circle cx="50" cy="92" r="2.5" fill="none" stroke="url(#logoGrad)" stroke-width="1" />
+              <circle cx="50" cy="92" r="1.2" fill="url(#logoGrad)" />
+
+              <path d="M42 72 V85 H35" />
+              <circle cx="33" cy="85" r="1.5" fill="url(#logoGrad)" />
+
+              <path d="M58 72 V85 H65" />
+              <circle cx="67" cy="85" r="1.5" fill="url(#logoGrad)" />
+
+              <!-- Left -->
+              <path d="M25 50 H10" />
+              <circle cx="8" cy="50" r="2" fill="url(#logoGrad)" />
+
+              <path d="M28 42 H15 V35" />
+              <circle cx="15" cy="33" r="1.5" fill="url(#logoGrad)" />
+
+              <path d="M28 58 H15 V65" />
+              <circle cx="15" cy="67" r="1.5" fill="url(#logoGrad)" />
+
+              <!-- Right -->
+              <path d="M75 50 H90" />
+              <circle cx="92" cy="50" r="2" fill="url(#logoGrad)" />
+
+              <path d="M72 42 H85 V35" />
+              <circle cx="85" cy="33" r="1.5" fill="url(#logoGrad)" />
+
+              <path d="M72 58 H85 V65" />
+              <circle cx="85" cy="67" r="1.5" fill="url(#logoGrad)" />
+            </g>
+
+            <!-- Central Chip Background Glow -->
+            <rect x="28" y="28" width="44" height="44" rx="10" fill="var(--logo-glow)" opacity="0.15"
+              filter="url(#logoGlow)" />
+
+            <!-- Central Chip Frame -->
+            <rect x="30" y="30" width="40" height="40" rx="8" stroke="url(#logoGrad)" stroke-width="2.5"
+              fill="var(--bg-depth)" />
+            <rect x="34" y="34" width="32" height="32" rx="4" stroke="url(#logoGrad)" stroke-width="0.8" opacity="0.3"
               fill="none" />
-            <!-- AI shape -->
-            <path d="M9,22 L13,10 L17,22 M10.5,18 L15.5,18" stroke="#22d3ee" stroke-width="1.8" stroke-linecap="round"
-              stroke-linejoin="round" />
-            <line x1="22" y1="10" x2="22" y2="22" stroke="#22d3ee" stroke-width="1.8" stroke-linecap="round" />
-            <!-- corner accents -->
-            <circle cx="16" cy="2" r="1" fill="rgba(34,211,238,0.5)" />
-            <circle cx="28" cy="9" r="1" fill="rgba(34,211,238,0.3)" />
-            <circle cx="4" cy="23" r="1" fill="rgba(34,211,238,0.3)" />
+
+            <!-- "AI" Text -->
+            <text x="50" y="57" text-anchor="middle" fill="url(#logoGrad)" font-family="var(--ff-display)"
+              font-weight="900" font-size="22" style="letter-spacing: 0.05em;">AI</text>
+
+            <!-- Connectors -->
+            <path d="M30 40 H25 M30 50 H25 M30 60 H25" stroke="url(#logoGrad)" stroke-width="1.2" />
+            <path d="M70 40 H75 M70 50 H75 M70 60 H75" stroke="url(#logoGrad)" stroke-width="1.2" />
+            <path d="M40 30 V25 M50 30 V25 M60 30 V25" stroke="url(#logoGrad)" stroke-width="1.2" />
+            <path d="M40 70 V75 M50 70 V75 M60 70 V75" stroke="url(#logoGrad)" stroke-width="1.2" />
           </svg>
         </div>
         <!-- Market Status -->
@@ -1816,6 +2766,7 @@
         <div class="ctrl-unit">
           <span class="ctrl-label">Khung thời gian</span>
           <select class="k-select" id="timeframeSelect">
+            <option disabled selected hidden>TimeFrame</option>
             <option>1m</option>
             <option>5m</option>
             <option>15m</option>
@@ -1828,12 +2779,13 @@
 
         <div class="ctrl-unit">
           <span class="ctrl-label">Dự báo (nến)</span>
-          <input class="k-input" id="horizonInput" type="number" min="5" max="300" value="10" />
+          <input class="k-input" id="horizonInput" type="number" min="5" max="300" value="10" placeholder="Forecast" />
         </div>
 
         <div class="ctrl-unit">
           <span class="ctrl-label">Chỉ báo</span>
           <select class="k-select" id="indicatorSelect" style="width: 140px;">
+            <option disabled selected hidden>Indicator</option>
             <option value="none">Không có</option>
             <option value="bb">Bollinger Bands</option>
             <option value="rsi">RSI (14)</option>
@@ -1963,6 +2915,8 @@
     const analysisPanel = document.getElementById('analysisPanel');
     const marketStatusBar = document.getElementById('marketStatusBar');
     const indicatorSelect = document.getElementById('indicatorSelect');
+    const cursorAura = document.getElementById('cursorAura');
+    const cursorDot = document.getElementById('cursorDot');
 
     /* ── State ─────────────────────────────────── */
     let currentSymbol = 'XAUUSD';
@@ -1977,6 +2931,49 @@
 
     /* ── Indicator Calculation Helpers ────────── */
     /* ── WebSocket Management ────────────────────── */
+    (() => {
+      if (!cursorAura || !cursorDot || window.matchMedia('(pointer: coarse)').matches) return;
+
+      let mouseX = window.innerWidth / 2;
+      let mouseY = window.innerHeight / 2;
+      let auraX = mouseX;
+      let auraY = mouseY;
+      let rafId = 0;
+      const interactiveSelector = 'button, input, select, .search-item, .compact-gauge-card, .explorer-symbol-card, .explorer-cat-item, .dash-close, .dash-col';
+
+      function renderCursor() {
+        auraX += (mouseX - auraX) * 0.14;
+        auraY += (mouseY - auraY) * 0.14;
+        cursorAura.style.transform = `translate3d(${auraX}px, ${auraY}px, 0) translate(-50%, -50%)`;
+        cursorDot.style.transform = `translate3d(${mouseX}px, ${mouseY}px, 0) translate(-50%, -50%)`;
+        rafId = requestAnimationFrame(renderCursor);
+      }
+
+      document.addEventListener('mousemove', (event) => {
+        mouseX = event.clientX;
+        mouseY = event.clientY;
+        document.body.classList.add('cursor-active');
+        if (!rafId) rafId = requestAnimationFrame(renderCursor);
+      }, { passive: true });
+
+      document.addEventListener('mouseleave', () => {
+        document.body.classList.remove('cursor-active');
+      });
+
+      document.addEventListener('mousedown', () => {
+        document.body.classList.add('cursor-press');
+      });
+
+      document.addEventListener('mouseup', () => {
+        document.body.classList.remove('cursor-press');
+      });
+
+      document.addEventListener('mouseover', (event) => {
+        const target = event.target instanceof Element ? event.target.closest(interactiveSelector) : null;
+        document.body.classList.toggle('cursor-hover', Boolean(target));
+      });
+    })();
+
     function connectWS(symbol) {
       if (ws) {
         ws.close();
@@ -2159,26 +3156,62 @@
     });
 
     const p50Series = chart.addLineSeries({
-      color: '#22d3ee',
+      color: '#66d9ff',
       lineWidth: 2,
       title: 'Dự báo AI',
       priceLineVisible: false,
-      lastValueVisible: true,
+      lastValueVisible: false,
       visible: false,
     });
 
     const p10Series = chart.addLineSeries({
-      color: 'rgba(34, 211, 238, 0.22)',
-      lineWidth: 1,
+      color: 'rgba(102, 217, 255, 0.18)',
+      lineWidth: 2,
       lineStyle: LightweightCharts.LineStyle.Dashed,
       priceLineVisible: false,
       lastValueVisible: false,
       visible: false,
     });
 
+    let forecastSegmentSeries = [];
+
+    function clearForecastSegments() {
+      if (!forecastSegmentSeries.length) return;
+      for (const series of forecastSegmentSeries) {
+        try {
+          chart.removeSeries(series);
+        } catch (e) {
+          console.warn('[forecastSegments] remove failed', e);
+        }
+      }
+      forecastSegmentSeries = [];
+    }
+
+    function buildForecastSegmentSeries(points) {
+      clearForecastSegments();
+      if (!Array.isArray(points) || points.length < 2) return;
+
+      const EPSILON = 0.0001;
+      for (let i = 1; i < points.length; i += 1) {
+        const prev = points[i - 1];
+        const curr = points[i];
+        const diff = (curr?.value ?? 0) - (prev?.value ?? 0);
+        const color = diff > EPSILON ? '#45a9ff' : diff < -EPSILON ? '#ff6b7a' : '#f6c94a';
+        const segSeries = chart.addLineSeries({
+          color,
+          lineWidth: 2,
+          priceLineVisible: false,
+          lastValueVisible: false,
+          crosshairMarkerVisible: false,
+        });
+        segSeries.setData([prev, curr]);
+        forecastSegmentSeries.push(segSeries);
+      }
+    }
+
     const p90Series = chart.addLineSeries({
-      color: 'rgba(34, 211, 238, 0.22)',
-      lineWidth: 1,
+      color: 'rgba(102, 217, 255, 0.18)',
+      lineWidth: 2,
       lineStyle: LightweightCharts.LineStyle.Dashed,
       priceLineVisible: false,
       lastValueVisible: false,
@@ -2258,16 +3291,20 @@
       const angle = score * 135;
       const cx = w / 2, cy = h * 0.65, r = (w / 2) * 0.62;
       const strokeW = w > 150 ? 16 : 8;
-      
+
       function arc(s, e, col) {
         const sa = (s - 90) * Math.PI / 180, ea = (e - 90) * Math.PI / 180;
         const x1 = cx + r * Math.cos(sa), y1 = cy + r * Math.sin(sa), x2 = cx + r * Math.cos(ea), y2 = cy + r * Math.sin(ea);
         return `<path d="M${x1},${y1} A${r},${r} 0 ${(e - s) > 180 ? 1 : 0} 1 ${x2},${y2}" fill="none" stroke="${col}" stroke-width="${strokeW}" stroke-linecap="round" opacity="0.8"/>`;
       }
-      
+
       const na = (angle - 90) * Math.PI / 180, nl = r + 2;
       const nx = cx + nl * Math.cos(na), ny = cy + nl * Math.sin(na);
-      const needleColor = score > 0.3 ? '#4ade80' : score > 0.1 ? '#bbf7d0' : score < -0.3 ? '#f87171' : score < -0.1 ? '#fecaca' : '#f1f5f9';
+
+      // Color logic: Red -> Yellow -> Green
+      let needleColor = '#facc15'; // Yellow (Neutral/Default)
+      if (displayValue > 70) needleColor = '#22c55e'; // Green
+      else if (displayValue < 40) needleColor = '#ef4444'; // Red
 
       let valueHtml = '';
       if (showValue) {
@@ -2297,7 +3334,14 @@
       `;
     }
 
+    function gaugeToRawScore(gauge) {
+      const value = Number(gauge);
+      if (!Number.isFinite(value)) return 0;
+      return Math.max(-1, Math.min(1, (value - 50) / 50));
+    }
+
     function getSignalClass(signal) {
+      if (!signal) return 'neutral';
       if (signal.includes('Mua mạnh')) return 'strong-buy';
       if (signal.includes('Mua')) return 'buy';
       if (signal.includes('Bán mạnh')) return 'strong-sell';
@@ -2313,47 +3357,26 @@
       }
 
       const a = payload.analysis;
-      const summary = a.summary || { sell: 0, neutral: 0, buy: 0, signal: '--' };
-      
-      // Re-calculate scores (logic mirrored from renderAnalysisPanel)
-      const lastClose = payload.last_close || 0;
-      const forecastRows = payload.forecast || [];
-      let forecastEnd = lastClose;
-      if (forecastRows.length > 1) forecastEnd = forecastRows[forecastRows.length - 1]?.p50 ?? lastClose;
-      const forecastPctChange = lastClose > 0 ? ((forecastEnd - lastClose) / lastClose) * 100 : 0;
-
-      const techTotal = (summary.buy + summary.sell + summary.neutral) || 1;
-      const techScore = (summary.buy - summary.sell) / techTotal;
-      const aiScore = Math.max(-1, Math.min(1, forecastPctChange / 2));
-      const combinedScore = (techScore + aiScore) / 2;
-
-      let aiSignal = 'Trung lập';
-      if (forecastPctChange > 2) aiSignal = 'Mua mạnh';
-      else if (forecastPctChange > 0.5) aiSignal = 'Mua';
-      else if (forecastPctChange < -2) aiSignal = 'Bán mạnh';
-      else if (forecastPctChange < -0.5) aiSignal = 'Bán';
-
-      let totalSignal = 'Trung lập';
-      if (combinedScore > 0.4) totalSignal = 'Mua mạnh';
-      else if (combinedScore > 0.1) totalSignal = 'Mua';
-      else if (combinedScore < -0.4) totalSignal = 'Bán mạnh';
-      else if (combinedScore < -0.1) totalSignal = 'Bán';
+      const dashboard = a.dashboard || {};
+      const technical = dashboard.technical || a.technicals || { gauge: 50, signal: '--', buy: 0, sell: 0, neutral: 0 };
+      const ai = dashboard.ai || a.ai_gauge || { gauge: 50, signal: '--' };
+      const summary = dashboard.summary || a.summary || { gauge: 50, signal: '--' };
 
       container.innerHTML = `
-        <div class="compact-gauge-card">
+        <div class="compact-gauge-card" onclick="refreshBtn.click()" style="cursor:pointer">
           <div class="compact-gauge-title">Kỹ thuật</div>
-          <div class="compact-gauge-svg-wrap">${buildGaugeSvg(techScore, 80, 50, false)}</div>
-          <div class="compact-gauge-signal ${getSignalClass(summary.signal)}">${summary.signal}</div>
+          <div class="compact-gauge-svg-wrap">${buildGaugeSvg(gaugeToRawScore(technical.gauge), 80, 50, false)}</div>
+          <div class="compact-gauge-signal ${getSignalClass(technical.signal)}">${technical.signal}</div>
         </div>
-        <div class="compact-gauge-card">
+        <div class="compact-gauge-card" onclick="refreshBtn.click()" style="cursor:pointer">
           <div class="compact-gauge-title">Dự báo AI</div>
-          <div class="compact-gauge-svg-wrap">${buildGaugeSvg(aiScore, 80, 50, false)}</div>
-          <div class="compact-gauge-signal ${getSignalClass(aiSignal)}">${aiSignal}</div>
+          <div class="compact-gauge-svg-wrap">${buildGaugeSvg(gaugeToRawScore(ai.gauge), 80, 50, false)}</div>
+          <div class="compact-gauge-signal ${getSignalClass(ai.signal)}">${ai.signal}</div>
         </div>
-        <div class="compact-gauge-card hero">
+        <div class="compact-gauge-card hero" onclick="refreshBtn.click()" style="cursor:pointer">
           <div class="compact-gauge-title">Tổng kết</div>
-          <div class="compact-gauge-svg-wrap">${buildGaugeSvg(combinedScore, 80, 50, false)}</div>
-          <div class="compact-gauge-signal ${getSignalClass(totalSignal)}">${totalSignal}</div>
+          <div class="compact-gauge-svg-wrap">${buildGaugeSvg(gaugeToRawScore(summary.gauge), 80, 50, false)}</div>
+          <div class="compact-gauge-signal ${getSignalClass(summary.signal)}">${summary.signal}</div>
         </div>
       `;
     }
@@ -2391,54 +3414,16 @@
       const osc = a.oscillators || { sell: 0, neutral: 0, buy: 0, signal: '--', data: [] };
       const ma = a.moving_averages || { sell: 0, neutral: 0, buy: 0, signal: '--', data: [] };
       const summary = a.summary || { sell: 0, neutral: 0, buy: 0, signal: '--' };
+      const technicals = a.technicals || { gauge: 50, signal: '--', buy: 0, sell: 0, neutral: 0 };
+      const aiGauge = a.ai_gauge || { gauge: 50, signal: '--', confidence_pct: 0, certainty: 0, path_consistency: 50 };
+      const dashboard = a.dashboard || {};
       const pivots = (a.pivot_points || {}).data || [];
 
-      // ── AI Forecast calculation ──
-      const confidence = payload.ensemble?.confidence ?? 0;
       const forecastRows = payload.forecast || [];
       const lastClose = payload.last_close || 0;
-      let forecastEnd = lastClose;
-      if (forecastRows.length > 1) {
-        forecastEnd = forecastRows[forecastRows.length - 1]?.p50 ?? lastClose;
-      }
-      const forecastPctChange = lastClose > 0 ? ((forecastEnd - lastClose) / lastClose) * 100 : 0;
-
-      // ── Compute AI Forecast as Buy/Sell gauge ──
-      // Map forecast % change to a score: >0 = buy, <0 = sell
-      // Strength determines strong/weak
-      const absChange = Math.abs(forecastPctChange);
-      let aiBuy = 0, aiSell = 0, aiNeutral = 0;
-      if (forecastPctChange > 0.5) {
-        aiBuy = absChange > 2 ? 2 : 1;
-        aiNeutral = absChange > 2 ? 0 : 1;
-      } else if (forecastPctChange < -0.5) {
-        aiSell = absChange > 2 ? 2 : 1;
-        aiNeutral = absChange > 2 ? 0 : 1;
-      } else {
-        aiNeutral = 1;
-      }
-      const aiTotal = aiBuy + aiSell + aiNeutral;
-      let aiSignal = 'Trung lập';
-      if (forecastPctChange > 2) aiSignal = 'Mua mạnh';
-      else if (forecastPctChange > 0.5) aiSignal = 'Mua';
-      else if (forecastPctChange < -2) aiSignal = 'Bán mạnh';
-      else if (forecastPctChange < -0.5) aiSignal = 'Bán';
-
-      // ── TỔNG KẾT = (Phân tích kỹ thuật + Dự báo AI) / 2 ──
-      const techTotal = (summary.buy + summary.sell + summary.neutral) || 1;
-      const techScore = (summary.buy - summary.sell) / techTotal; // -1 to +1
-
-      // Normalized AI Score: Map forecast change to -1 to +1 range
-      // We'll consider 2% change as the "strong" threshold
-      const aiScore = Math.max(-1, Math.min(1, forecastPctChange / 2));
-
-      const combinedScore = (techScore + aiScore) / 2; // -1 to +1
-
-      let totalSignal = 'Trung lập';
-      if (combinedScore > 0.4) totalSignal = 'Mua mạnh';
-      else if (combinedScore > 0.1) totalSignal = 'Mua';
-      else if (combinedScore < -0.4) totalSignal = 'Bán mạnh';
-      else if (combinedScore < -0.1) totalSignal = 'Bán';
+      const aiCurrentPrice = dashboard.ai?.current_price ?? lastClose;
+      const forecastEnd = dashboard.ai?.forecast_price ?? (forecastRows.length > 1 ? (forecastRows[forecastRows.length - 1]?.p50 ?? lastClose) : lastClose);
+      const forecastPctChange = dashboard.ai?.forecast_return_pct ?? (lastClose > 0 ? ((forecastEnd - lastClose) / lastClose) * 100 : 0);
 
       // ── Big SVG Gauge builder (Refactored to buildGaugeSvg) ──
 
@@ -2483,13 +3468,13 @@
             <div class="gauge-hero-card">
               <div class="gauge-hero-title">PHÂN TÍCH KỸ THUẬT</div>
               <div class="gauge-hero-svg-wrap">
-                ${buildGaugeSvg(techScore)}
+                ${buildGaugeSvg(gaugeToRawScore(technicals.gauge))}
               </div>
-              <div class="gauge-hero-signal ${signalClass(summary.signal)}">${summary.signal}</div>
+              <div class="gauge-hero-signal ${signalClass(technicals.signal)}">${technicals.signal}</div>
               <div class="gauge-hero-counts">
-                <span><span class="ghc-label">Bán</span><span class="ghc-value">${summary.sell}</span></span>
-                <span><span class="ghc-label">Trung lập</span><span class="ghc-value">${summary.neutral}</span></span>
-                <span><span class="ghc-label">Mua</span><span class="ghc-value">${summary.buy}</span></span>
+                <span><span class="ghc-label">Bán</span><span class="ghc-value">${technicals.sell}</span></span>
+                <span><span class="ghc-label">Trung lập</span><span class="ghc-value">${technicals.neutral}</span></span>
+                <span><span class="ghc-label">Mua</span><span class="ghc-value">${technicals.buy}</span></span>
               </div>
             </div>
 
@@ -2497,12 +3482,12 @@
             <div class="gauge-hero-card">
               <div class="gauge-hero-title">DỰ BÁO AI</div>
               <div class="gauge-hero-svg-wrap">
-                ${buildGaugeSvg(aiScore)}
+                ${buildGaugeSvg(gaugeToRawScore(aiGauge.gauge))}
               </div>
               <div class="gauge-hero-ai-details">
                 <div class="gh-ai-row">
                   <span class="gh-ai-label">Hiện tại:</span>
-                  <span class="gh-ai-val">${formatPrice(lastClose)}</span>
+                  <span class="gh-ai-val">${formatPrice(aiCurrentPrice)}</span>
                 </div>
                 <div class="gh-ai-row">
                   <span class="gh-ai-label">Dự kiến:</span>
@@ -2512,17 +3497,25 @@
                   <span class="gh-ai-label">Biến động:</span>
                   <span class="gh-ai-val ${forecastPctChange >= 0 ? 'up' : 'down'}">${forecastPctChange >= 0 ? '↑' : '↓'} ${Math.abs(forecastPctChange).toFixed(2)}%</span>
                 </div>
+                <div class="gh-ai-row">
+                  <span class="gh-ai-label">Độ chắc chắn:</span>
+                  <span class="gh-ai-val">${Number(aiGauge.certainty ?? 0).toFixed(1)}%</span>
+                </div>
+                <div class="gh-ai-row">
+                  <span class="gh-ai-label">Độ ổn định đường đi:</span>
+                  <span class="gh-ai-val">${Number(aiGauge.path_consistency ?? 0).toFixed(1)}%</span>
+                </div>
               </div>
-              <div class="gauge-hero-signal ${signalClass(aiSignal)}">${aiSignal}</div>
+              <div class="gauge-hero-signal ${signalClass(aiGauge.signal)}">${aiGauge.signal}</div>
             </div>
 
             <!-- Gauge 3: TỔNG KẾT -->
             <div class="gauge-hero-card hero-total">
               <div class="gauge-hero-title title-total">⚡ TỔNG KẾT</div>
               <div class="gauge-hero-svg-wrap">
-                ${buildGaugeSvg(combinedScore)}
+                ${buildGaugeSvg(gaugeToRawScore(summary.gauge))}
               </div>
-              <div class="gauge-hero-signal signal-total ${signalClass(totalSignal)}">${totalSignal}</div>
+              <div class="gauge-hero-signal signal-total ${signalClass(summary.signal)}">${summary.signal}</div>
             </div>
 
           </div>
@@ -2531,15 +3524,15 @@
           <div class="dash-tables-row">
 
             <!-- Oscillators -->
-            <div class="dash-col">
-              <div class="dc-header">Chỉ số Dao động</div>
+            <div class="dash-col" data-focus-panel="osc">
+              <div class="dc-header">Chỉ báo Kỹ thuật</div>
               <div class="dash-table-wrap">
                 <table class="dt"><tbody>${oscRows}</tbody></table>
               </div>
             </div>
 
             <!-- Moving Averages -->
-            <div class="dash-col">
+            <div class="dash-col" data-focus-panel="ma">
               <div class="dc-header">Trung bình trượt</div>
               <div class="dash-table-wrap">
                 <table class="dt"><tbody>${maRows}</tbody></table>
@@ -2547,7 +3540,7 @@
             </div>
 
             <!-- Pivot Points -->
-            <div class="dash-col col-pivots">
+            <div class="dash-col col-pivots" data-focus-panel="pivots">
               <div class="dc-header">Điểm xoay</div>
               <div class="dash-table-wrap">
                 <table class="pivot-table">
@@ -2569,6 +3562,22 @@
       // Close logic
       const closeBtn = document.getElementById('dashCloseBtn');
       if (closeBtn) closeBtn.onclick = () => analysisPanel.classList.remove('active');
+
+      const tablesRow = analysisPanel.querySelector('.dash-tables-row');
+      const focusCols = Array.from(analysisPanel.querySelectorAll('.dash-col[data-focus-panel]'));
+      focusCols.forEach((col) => {
+        col.onclick = () => {
+          const key = col.getAttribute('data-focus-panel');
+          const alreadyFocused = col.classList.contains('is-focus');
+          focusCols.forEach((item) => item.classList.remove('is-focus'));
+          tablesRow?.classList.remove('has-focus', 'focus-osc', 'focus-ma', 'focus-pivots');
+          if (!alreadyFocused && key && tablesRow) {
+            col.classList.add('is-focus');
+            tablesRow.classList.add('has-focus', `focus-${key}`);
+            requestAnimationFrame(() => col.scrollIntoView({ behavior: 'smooth', block: 'nearest' }));
+          }
+        };
+      });
     }
 
 
@@ -2579,6 +3588,7 @@
       p50Series.setData([]);
       p10Series.setData([]);
       p90Series.setData([]);
+      clearForecastSegments();
 
       p50Series.applyOptions({ visible: false });
       p10Series.applyOptions({ visible: false });
@@ -2738,6 +3748,13 @@
         let lastForecastVal = 0;
 
         if (fData.error || !fData.forecast || fData.forecast.length === 0) {
+          clearForecastSegments();
+          p50Series.setData([]);
+          p50Series.applyOptions({ visible: false });
+          p10Series.setData([]);
+          p90Series.setData([]);
+          p10Series.applyOptions({ visible: false });
+          p90Series.applyOptions({ visible: false });
           updateStatus('AI: ' + (fData.error || 'Thiếu dữ liệu dự báo'), 'warning');
         } else {
           // Safeguard: Ensure we have candle data before aligning
@@ -2746,27 +3763,25 @@
             return;
           }
 
-          const forecastPoints = fData.forecast; // Backend already has anchor point is_actual
-
-          // Filter correctly: use is_actual as connection point
-          const p50 = forecastPoints.map(d => ({ time: d.time, value: d.p50 }));
-          const p10 = forecastPoints.map(d => ({ time: d.time, value: d.p10 }));
-          const p90 = forecastPoints.map(d => ({ time: d.time, value: d.p90 }));
-
-          p50Series.setData(p50);
-          p10Series.setData(p10);
-          p90Series.setData(p90);
-
-          const anchorVal = forecastPoints[0]?.p50 ?? lastCandleData.close;
+          const forecastPoints = fData.forecast;
+          const anchorPoint = { time: lastCandleData.time, value: lastCandleData.close };
+          const futurePoints = forecastPoints
+            .filter(d => d && d.time !== undefined && d.p50 !== undefined && d.time !== lastCandleData.time)
+            .map(d => ({ time: d.time, value: d.p50 }));
+          const p50 = [anchorPoint, ...futurePoints];
+
+          p50Series.setData([]);
+          p50Series.applyOptions({ visible: false });
+          p10Series.setData([]);
+          p90Series.setData([]);
+          p10Series.applyOptions({ visible: false });
+          p90Series.applyOptions({ visible: false });
+          buildForecastSegmentSeries(p50);
+
+          const anchorVal = anchorPoint.value;
           lastForecastVal = forecastPoints[forecastPoints.length - 1]?.p50 ?? anchorVal;
           isBull = lastForecastVal >= anchorVal;
 
-          const aiMain = isBull ? '#1dba8a' : '#e05560';
-          const aiBand = isBull ? 'rgba(29,186,138,0.1)' : 'rgba(224,85,96,0.1)';
-
-          p50Series.applyOptions({ color: aiMain, visible: true });
-          p10Series.applyOptions({ color: aiBand, visible: true });
-          p90Series.applyOptions({ color: aiBand, visible: true });
         }
 
         const currentPrice = lastCandleData?.close || 0;
@@ -3008,4 +4023,4 @@
   </script>
 </body>
 
-</html>
+</html>