Deploy OHLC4 forecast line and Hugging Face runtime fixes

.gitattributes

@@ -1,3 +1,4 @@
 *.png filter=lfs diff=lfs merge=lfs -text
 *.jpg filter=lfs diff=lfs merge=lfs -text
 *.db filter=lfs diff=lfs merge=lfs -text
+frontend/favicon.svg filter=lfs diff=lfs merge=lfs -text

Dockerfile

@@ -5,6 +5,8 @@ WORKDIR /app
 COPY requirements.txt .
 RUN pip install --no-cache-dir -r requirements.txt
 
+ENV PORT=7860
+
 COPY . .
 
 EXPOSE 7860

README.md

@@ -4,6 +4,7 @@ emoji: 🚀
 colorFrom: blue
 colorTo: red
 sdk: docker
+app_port: 7860
 pinned: false
 ---
 # Kronos AI Analysis
@@ -52,19 +53,20 @@ The startup script now:
 2. repairs a broken virtual environment if needed
 3. installs the full runtime dependency set
 4. verifies Kronos can be imported
-5. starts the FastAPI server on `http://127.0.0.1:8000`
+5. starts the FastAPI server on a random free local port and opens the browser automatically
 
 ## Manual Start
 
 ```bat
 py -3.11 -m venv venv
 venv\Scripts\python.exe -m pip install -r requirements.txt
-venv\Scripts\python.exe -m uvicorn backend.main:app --host 127.0.0.1 --port 8000 --reload
+venv\Scripts\python.exe -m backend.launcher
 ```
 
 ## Important Notes
 
 - This project uses Kronos, not TimesFM.
+- Hugging Face Docker Spaces are pinned to port `7860`, while the local Windows launcher uses a random free port.
 - Kronos source code is loaded from `Kronos-master`.
 - Kronos weights are loaded from Hugging Face via:
   - `NeoQuasar/Kronos-base`

app.py

@@ -1,7 +1,47 @@
+from __future__ import annotations
+
 import os
+import socket
+
 import uvicorn
+
+def find_free_port(host: str = "127.0.0.1") -> int:
+    """Ask the OS for a currently available local TCP port."""
+    with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as server_socket:
+        server_socket.bind((host, 0))
+        server_socket.listen(1)
+        return int(server_socket.getsockname()[1])
+
+
+def is_huggingface_space() -> bool:
+    """Return True when running inside a Hugging Face Space runtime."""
+    return bool(os.getenv("SPACE_ID") or os.getenv("SPACE_HOST"))
+
+
+def bootstrap_runtime_port() -> None:
+    """Seed PORT early so backend imports cannot override the Hugging Face runtime port."""
+    if is_huggingface_space() and not os.getenv("PORT", "").strip():
+        os.environ["PORT"] = "7860"
+
+
+bootstrap_runtime_port()
+
 from backend.main import app
 
+
+def resolve_server_port() -> int:
+    """Use the runtime PORT when defined, keep Hugging Face on 7860, else pick a free local port."""
+    raw_port = os.getenv("PORT", "").strip()
+    if raw_port:
+        return int(raw_port)
+    if is_huggingface_space():
+        os.environ["PORT"] = "7860"
+        return 7860
+
+    port = find_free_port()
+    os.environ["PORT"] = str(port)
+    return port
+
+
 if __name__ == "__main__":
-    # Hugging Face Spaces yêu cầu ứng dụng phải chạy trên cổng 7860
-    uvicorn.run(app, host="0.0.0.0", port=7860)
+    uvicorn.run(app, host="0.0.0.0", port=resolve_server_port())

backend/launcher.py

@@ -1,71 +1,99 @@
-import sys
+from __future__ import annotations
+
+import logging
 import os
+import socket
+import sys
+import threading
 import time
 import webbrowser
-import threading
+from pathlib import Path
+from typing import Any
+
 import uvicorn
-import logging
 
-# Set up professional logging
 logging.basicConfig(
     level=logging.INFO,
     format="%(asctime)s | %(levelname)s | %(message)s",
 )
-logger = logging.getLogger("super-ai-launcher")
+logger = logging.getLogger("kronos-launcher")
+
+DEFAULT_HOST: str = "127.0.0.1"
+SERVER_BOOT_DELAY_SECONDS: float = 2.5
+PROJECT_ROOT: Path = Path(__file__).resolve().parent.parent
 
-# ASCII Art Header
 BANNER = r"""
-  ____  _   _ ____  _____ ____      _    ___      _    _   _    _    _  __   ______ ___ ____  
- / ___|| | | |  _ \| ____|  _ \    / \  |_ _|    / \  | \ | |  / \  | | \ \ / / ___|_ _/ ___| 
- \___ \| | | | |_) |  _| | |_) |  / _ \  | |    / _ \ |  \| | / _ \ | |  \ V /\___ \ | \___ \ 
-  ___) | |_| |  __/| |___|  _ <  / ___ \ | |   / ___ \| |\  |/ ___ \| |___| |  ___) | |  ___) |
- |____/ \___/|_|   |_____|_| \_\/_/   \_\___| /_/   \_\_| \_/_/   \_\_____|_| |____/___|____/ 
-
- ══════════════════════════════════════════════════════════════════════════════════════════════
-  TRADING INTELLIGENT TERMINAL - AI PHÂN TÍCH BIỂU ĐỒ NẾN SỐ 1 THẾ GIỚI
- ══════════════════════════════════════════════════════════════════════════════════════════════
+  _  ___                              _        _    ___
+ | |/ / | __ ___  _ __   ___  ___   / \      / \  |_ _|
+ | ' /| |/ _` \ \/ / '_ \ / _ \/ __| / _ \    / _ \  | |
+ | . \| | (_| |>  <| | | | (_) \__ \/ ___ \  / ___ \ | |
+ |_|\_\_|\__,_/_/\_\_| |_|\___/|___/_/   \_\/_/   \_\___|
 """
 
-def print_banner():
-    # Clear console for a clean startup
-    os.system('cls' if os.name == 'nt' else 'clear')
+
+def print_banner() -> None:
+    """Render a clean startup banner in the local console."""
+    os.system("cls" if os.name == "nt" else "clear")
     print("\033[96m" + BANNER + "\033[0m")
-    print(" [*] Đang khởi động hệ thống phân tích AI...")
-    print(" [*] Đang nạp cơ sở dữ liệu thị trường...")
-    print(" [*] Hệ thống sẽ tự động mở trình duyệt sau khi hoàn tất.")
-    print(" ══════════════════════════════════════════════════════════════════════════════════════════════\n")
-
-# Import the FastAPI app
-try:
-    from main import app
-except ImportError:
-    # If running from within the backend folder
-    sys.path.append(os.path.dirname(__file__))
-    from main import app
-
-def open_browser():
-    """Wait for the server to start and then open the browser."""
-    # Give the server a few seconds to initialize
-    time.sleep(2.5)
-    url = "http://127.0.0.1:8000"
-    logger.info(f"Kết nối thành công! Đang mở bảng điều khiển tại {url}...")
+    print(" [*] Dang khoi dong he thong phan tich AI...")
+    print(" [*] Dang nap du lieu thi truong...")
+    print(" [*] Trinh duyet se tu dong mo khi server san sang.")
+    print()
+
+
+def load_app() -> Any:
+    """Import the FastAPI app after runtime settings are in place."""
+    project_root = str(PROJECT_ROOT)
+    if project_root not in sys.path:
+        sys.path.insert(0, project_root)
+    from backend.main import app as fastapi_app
+    return fastapi_app
+
+
+def find_free_port(host: str = DEFAULT_HOST) -> int:
+    """Ask the OS for a currently available local TCP port."""
+    with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as server_socket:
+        server_socket.bind((host, 0))
+        server_socket.listen(1)
+        return int(server_socket.getsockname()[1])
+
+
+def resolve_server_port() -> int:
+    """Use PORT when defined, otherwise choose a random free local port."""
+    raw_port = os.getenv("PORT", "").strip()
+    if raw_port:
+        try:
+            return int(raw_port)
+        except ValueError as exc:
+            raise ValueError(f"Invalid PORT value: {raw_port}") from exc
+
+    port = find_free_port()
+    os.environ["PORT"] = str(port)
+    return port
+
+
+def open_browser(url: str) -> None:
+    """Wait briefly for the server to start, then open the dashboard."""
+    time.sleep(SERVER_BOOT_DELAY_SECONDS)
+    logger.info("Dang mo bang dieu khien tai %s", url)
     webbrowser.open(url)
 
+
 if __name__ == "__main__":
     print_banner()
-    
-    # Start the browser opener in a separate thread
-    threading.Thread(target=open_browser, daemon=True).start()
-    
-    # Run the uvicorn server
-    logger.info("Khởi động Backend Core...")
+
+    host = DEFAULT_HOST
+    port = resolve_server_port()
+    url = f"http://{host}:{port}"
+    app = load_app()
+
+    logger.info("Khoi dong Backend Core tren %s", url)
+    threading.Thread(target=open_browser, args=(url,), daemon=True).start()
+
     try:
-        # Hide the detailed uvicorn logs for a cleaner professional feel, 
-        # or keep them for transparency. Let's use 'warning' level for uvicorn 
-        # but keep our own logs at 'info'.
-        uvicorn.run(app, host="127.0.0.1", port=8000, log_level="warning")
-    except Exception as e:
-        logger.error(f"Lỗi khởi động hệ thống: {e}")
-        print("\n [!] Có lỗi xảy ra trong quá trình khởi động.")
-        print(" [!] Nhấn Enter để xem chi tiết lỗi và thoát...")
+        uvicorn.run(app, host=host, port=port, log_level="warning")
+    except Exception as exc:
+        logger.exception("Loi khoi dong he thong: %s", exc)
+        print("\n [!] Co loi xay ra trong qua trinh khoi dong.")
+        print(" [!] Nhan Enter de thoat...")
         input()

backend/main.py

@@ -141,7 +141,6 @@ class Settings(BaseModel):
     binance_api_secret: Optional[str] = os.getenv("BINANCE_API_SECRET")
     bybit_api_key:      Optional[str] = os.getenv("BYBIT_API_KEY")
     bybit_api_secret:   Optional[str] = os.getenv("BYBIT_API_SECRET")
-    gemini_api_key:     Optional[str] = os.getenv("GEMINI_API_KEY")
     alphavantage_api_key: Optional[str] = os.getenv("ALPHAVANTAGE_API_KEY")
     admin_token:        str           = os.getenv("ADMIN_TOKEN", DEFAULT_ADMIN_TOKEN)
 
@@ -379,6 +378,14 @@ class CircuitBreaker:
             self.state = "OPEN"
             logger.error("[CB] %s is now OPEN - circuit broken", self.name)
 
+    def open_for(self, timeout: Optional[int] = None) -> None:
+        if timeout is not None:
+            self.timeout = max(self.timeout, timeout)
+        self.failures = max(self.failures, self.threshold)
+        self.last_failure_time = time.time()
+        self.state = "OPEN"
+        logger.error("[CB] %s is OPEN for %ss", self.name, self.timeout)
+
 # Instance per source
 source_breakers: Dict[str, CircuitBreaker] = {
     s: CircuitBreaker(s, settings.cb_failure_threshold, settings.cb_recovery_timeout)
@@ -465,10 +472,77 @@ persistent_cache = PersistentCache(
 # B-12: Global Configuration Instances
 CACHE_VERSION = settings.cache_version
 ADMIN_TOKEN = settings.admin_token
-TWELVEDATA_API_KEY = settings.twelvedata_api_key
-FINNHUB_API_KEY = settings.finnhub_api_key
 CORS_ALLOW_ORIGINS = parse_cors_origins(settings.cors_allow_origins_raw)
 CORS_ALLOW_CREDENTIALS = CORS_ALLOW_ORIGINS != ["*"]
+
+
+# ── API Key Pool (round-robin rotation for multi-pane) ────────────────────────
+class APIKeyPool:
+    """Round-robin key rotation to distribute API calls across multiple keys."""
+
+    def __init__(self, primary_key, pool_csv, name=""):
+        self._name = name
+        self._keys = []
+        self._index = 0
+        self._exhausted = set()
+
+        if pool_csv:
+            self._keys = [k.strip() for k in pool_csv.split(",") if k.strip()]
+        if not self._keys and primary_key:
+            self._keys = [primary_key]
+
+        logger.info("[APIKeyPool] %s: %d keys loaded", name, len(self._keys))
+
+    @property
+    def primary(self):
+        return self._keys[0] if self._keys else None
+
+    def next_key(self):
+        if not self._keys:
+            return None
+        available = [k for k in self._keys if k not in self._exhausted]
+        if not available:
+            self._exhausted.clear()
+            available = self._keys
+        key = available[self._index % len(available)]
+        self._index += 1
+        return key
+
+    def mark_exhausted(self, key):
+        self._exhausted.add(key)
+        remaining = len(self._keys) - len(self._exhausted)
+        logger.warning("[APIKeyPool] %s: key ...%s exhausted (%d remaining)",
+                       self._name, key[-8:], remaining)
+
+    def reset(self):
+        self._exhausted.clear()
+        self._index = 0
+
+    @property
+    def pool_size(self):
+        return len(self._keys)
+
+    @property
+    def available_count(self):
+        return len(self._keys) - len(self._exhausted)
+
+
+twelve_keys = [os.getenv(f"TWELVEDATA_API_KEY_{i}") for i in range(1, 9)]
+twelvedata_pool = APIKeyPool(
+    settings.twelvedata_api_key,
+    ",".join([k for k in twelve_keys if k]),
+    name="TwelveData",
+)
+finnhub_keys = [os.getenv(f"FINNHUB_API_KEY_{i}") for i in range(1, 9)]
+finnhub_pool = APIKeyPool(
+    settings.finnhub_api_key,
+    ",".join([k for k in finnhub_keys if k]),
+    name="Finnhub",
+)
+
+# Backward compat: keep single-key globals pointing to primary
+TWELVEDATA_API_KEY = twelvedata_pool.primary
+FINNHUB_API_KEY = finnhub_pool.primary
 # Binance, Bybit, CoinGecko, yfinance, FRED — no key or optional key required
 
 # ──────────────────────────────────────────────────────────────────────────────
@@ -509,7 +583,8 @@ STEP_SECONDS: Dict[str, int] = {
 # Source priority by asset category (first available mapping wins)
 CATEGORY_SOURCE_PRIORITY: Dict[str, List[str]] = {
     "Crypto":               ["binance", "bybit", "coingecko", "yfinance", "finnhub"],
-    "Cặp tiền":             ["binance", "twelvedata", "finnhub", "yfinance"],
+    "Cặp tiền":             ["twelvedata", "finnhub", "yfinance"],
+    "Real Strength":        ["yfinance", "twelvedata", "finnhub"],
     "Kim loại":             ["binance", "twelvedata", "yfinance", "finnhub"],
     "Năng lượng":           ["twelvedata", "yfinance", "finnhub"],
     "Nông sản":             ["twelvedata", "yfinance"],
@@ -556,11 +631,14 @@ class TokenBucket:
 
 
 # Per-source buckets (conservative — stays well within free limits)
+_TWELVEDATA_POOL_SIZE = max(1, twelvedata_pool.pool_size)
+_TWELVEDATA_RATE = min(1.0, 0.1 * _TWELVEDATA_POOL_SIZE)
+_TWELVEDATA_CAPACITY = max(2, min(8, _TWELVEDATA_POOL_SIZE))
 _rate_limiters: Dict[str, TokenBucket] = {
     "binance":     TokenBucket(rate=10.0, capacity=20),
     "bybit":       TokenBucket(rate=1.5,  capacity=5),
     "coingecko":   TokenBucket(rate=0.4,  capacity=3),
-    "twelvedata":  TokenBucket(rate=0.1,  capacity=2),   # 8/min free = ~0.13/s
+    "twelvedata":  TokenBucket(rate=_TWELVEDATA_RATE, capacity=_TWELVEDATA_CAPACITY),
     "finnhub":     TokenBucket(rate=1.0,  capacity=5),
     "yfinance":    TokenBucket(rate=5.0,  capacity=10),
     "alphavantage":TokenBucket(rate=0.02, capacity=1),   # 25/day
@@ -601,6 +679,25 @@ class SymbolConfig:
     description:  str = ""
 
 
+@dataclass(frozen=True)
+class SyntheticComponentSpec:
+    name: str
+    mode: str
+    left_symbol: str
+    right_symbol: Optional[str] = None
+    weight: float = 1.0
+    enabled: bool = True
+
+
+@dataclass(frozen=True)
+class SyntheticSymbolConfig:
+    symbol: str
+    scale: float
+    alpha: float
+    wick_shrink: float
+    components: Tuple[SyntheticComponentSpec, ...]
+
+
 # ─── Helper to build entry quickly ────────────────────────────────────────────
 def _s(sym: str, label: str, label_en: str, cat: str,
        mappings: Dict[str, str], cg_id: str = None, desc: str = "", 
@@ -697,17 +794,43 @@ SYMBOLS: Dict[str, SymbolConfig] = {
     # ══════════════════════════════════════════════════════════════════════
     # 6. CẶP TIỀN (Forex)
     # ══════════════════════════════════════════════════════════════════════
-    "DXY":    _s("DXY","Chỉ số USD (DXY)","USD Index","Cặp tiền",{"twelvedata":"DXY","yfinance":"DX-Y.NYB"}),
-    "EURUSD": _s("EURUSD","EUR/USD","EUR/USD","Cặp tiền",{"binance":"EURUSDT","twelvedata":"EUR/USD","yfinance":"EURUSD=X"}),
-    "GBPUSD": _s("GBPUSD","GBP/USD","GBP/USD","Cặp tiền",{"binance":"GBPUSDT","twelvedata":"GBP/USD","yfinance":"GBPUSD=X"}),
-    "USDJPY": _s("USDJPY","USD/JPY","USD/JPY","Cặp tiền",{"binance":"JPYUSDT","twelvedata":"USD/JPY","yfinance":"JPY=X"}),
+    "DXY":    _s("DXY","Chỉ số USD (DXY)","USD Index","Real Strength",{"twelvedata":"DXY","yfinance":"DX-Y.NYB"}),
+    "USDX":   _s("USDX","Sức mạnh USD (USDx)","USD Strength (USDx)","Real Strength",{"synthetic":"USDX"}, desc="Synthetic USD strength index built from weighted USD crosses."),
+    "EURX":   _s("EURX","Sức mạnh EUR (EURx)","EUR Strength (EURx)","Real Strength",{"synthetic":"EURX"}, desc="Synthetic EUR strength index built from weighted EUR crosses."),
+    "GBPX":   _s("GBPX","Sức mạnh GBP (GBPx)","GBP Strength (GBPx)","Real Strength",{"synthetic":"GBPX"}, desc="Synthetic GBP strength index built from weighted GBP crosses."),
+    "CHFX":   _s("CHFX","Sức mạnh CHF (CHFx)","CHF Strength (CHFx)","Real Strength",{"synthetic":"CHFX"}, desc="Synthetic CHF strength index built from weighted CHF crosses."),
+    "JPYX":   _s("JPYX","Sức mạnh JPY (JPYx)","JPY Strength (JPYx)","Real Strength",{"synthetic":"JPYX"}, desc="Synthetic JPY strength index built from weighted JPY crosses."),
+    "CADX":   _s("CADX","Sức mạnh CAD (CADx)","CAD Strength (CADx)","Real Strength",{"synthetic":"CADX"}, desc="Synthetic CAD strength index built from weighted CAD crosses."),
+    "AUDX":   _s("AUDX","Sức mạnh AUD (AUDx)","AUD Strength (AUDx)","Real Strength",{"synthetic":"AUDX"}, desc="Synthetic AUD strength index built from weighted AUD crosses."),
+    "NZDX":   _s("NZDX","Sức mạnh NZD (NZDx)","NZD Strength (NZDx)","Real Strength",{"synthetic":"NZDX"}, desc="Synthetic NZD strength index built from weighted NZD crosses."),
+    "EURUSD": _s("EURUSD","EUR/USD","EUR/USD","Cặp tiền",{"twelvedata":"EUR/USD","yfinance":"EURUSD=X"}),
+    "GBPUSD": _s("GBPUSD","GBP/USD","GBP/USD","Cặp tiền",{"twelvedata":"GBP/USD","yfinance":"GBPUSD=X"}),
+    "USDJPY": _s("USDJPY","USD/JPY","USD/JPY","Cặp tiền",{"twelvedata":"USD/JPY","yfinance":"JPY=X"}),
     "USDCHF": _s("USDCHF","USD/CHF","USD/CHF","Cặp tiền",{"twelvedata":"USD/CHF","yfinance":"CHF=X"}),
-    "AUDUSD": _s("AUDUSD","AUD/USD","AUD/USD","Cặp tiền",{"binance":"AUDUSDT","twelvedata":"AUD/USD","yfinance":"AUDUSD=X"}),
+    "AUDUSD": _s("AUDUSD","AUD/USD","AUD/USD","Cặp tiền",{"twelvedata":"AUD/USD","yfinance":"AUDUSD=X"}),
     "USDCAD": _s("USDCAD","USD/CAD","USD/CAD","Cặp tiền",{"twelvedata":"USD/CAD","yfinance":"CAD=X"}),
     "NZDUSD": _s("NZDUSD","NZD/USD","NZD/USD","Cặp tiền",{"twelvedata":"NZD/USD","yfinance":"NZDUSD=X"}),
+    "EURGBP": _s("EURGBP","EUR/GBP","EUR/GBP","Cặp tiền",{"twelvedata":"EUR/GBP","yfinance":"EURGBP=X"}),
+    "EURJPY": _s("EURJPY","EUR/JPY","EUR/JPY","Cặp tiền",{"twelvedata":"EUR/JPY","yfinance":"EURJPY=X"}),
+    "EURCHF": _s("EURCHF","EUR/CHF","EUR/CHF","Cặp tiền",{"twelvedata":"EUR/CHF","yfinance":"EURCHF=X"}),
+    "EURCAD": _s("EURCAD","EUR/CAD","EUR/CAD","Cặp tiền",{"twelvedata":"EUR/CAD","yfinance":"EURCAD=X"}),
+    "EURAUD": _s("EURAUD","EUR/AUD","EUR/AUD","Cặp tiền",{"twelvedata":"EUR/AUD","yfinance":"EURAUD=X"}),
+    "EURNZD": _s("EURNZD","EUR/NZD","EUR/NZD","Cặp tiền",{"twelvedata":"EUR/NZD","yfinance":"EURNZD=X"}),
     "GBPJPY": _s("GBPJPY","GBP/JPY","GBP/JPY","Cặp tiền",{"twelvedata":"GBP/JPY","yfinance":"GBPJPY=X"}),
-    "EURJPY": _s("EURJPY","EUR/JPY","EUR/JPY","Cặp tiền",{"binance":"EURJPY","twelvedata":"EUR/JPY"}),
-    "EURGBP": _s("EURGBP","EUR/GBP","EUR/GBP","Cặp tiền",{"binance":"EURGBP","twelvedata":"EUR/GBP"}),
+    "GBPCHF": _s("GBPCHF","GBP/CHF","GBP/CHF","Cặp tiền",{"twelvedata":"GBP/CHF","yfinance":"GBPCHF=X"}),
+    "GBPCAD": _s("GBPCAD","GBP/CAD","GBP/CAD","Cặp tiền",{"twelvedata":"GBP/CAD","yfinance":"GBPCAD=X"}),
+    "GBPAUD": _s("GBPAUD","GBP/AUD","GBP/AUD","Cặp tiền",{"twelvedata":"GBP/AUD","yfinance":"GBPAUD=X"}),
+    "GBPNZD": _s("GBPNZD","GBP/NZD","GBP/NZD","Cặp tiền",{"twelvedata":"GBP/NZD","yfinance":"GBPNZD=X"}),
+    "CHFJPY": _s("CHFJPY","CHF/JPY","CHF/JPY","Cặp tiền",{"twelvedata":"CHF/JPY","yfinance":"CHFJPY=X"}),
+    "CADCHF": _s("CADCHF","CAD/CHF","CAD/CHF","Cặp tiền",{"twelvedata":"CAD/CHF","yfinance":"CADCHF=X"}),
+    "AUDCHF": _s("AUDCHF","AUD/CHF","AUD/CHF","Cặp tiền",{"twelvedata":"AUD/CHF","yfinance":"AUDCHF=X"}),
+    "NZDCHF": _s("NZDCHF","NZD/CHF","NZD/CHF","Cặp tiền",{"twelvedata":"NZD/CHF","yfinance":"NZDCHF=X"}),
+    "CADJPY": _s("CADJPY","CAD/JPY","CAD/JPY","Cặp tiền",{"twelvedata":"CAD/JPY","yfinance":"CADJPY=X"}),
+    "AUDJPY": _s("AUDJPY","AUD/JPY","AUD/JPY","Cặp tiền",{"twelvedata":"AUD/JPY","yfinance":"AUDJPY=X"}),
+    "NZDJPY": _s("NZDJPY","NZD/JPY","NZD/JPY","Cặp tiền",{"twelvedata":"NZD/JPY","yfinance":"NZDJPY=X"}),
+    "AUDCAD": _s("AUDCAD","AUD/CAD","AUD/CAD","Cặp tiền",{"twelvedata":"AUD/CAD","yfinance":"AUDCAD=X"}),
+    "NZDCAD": _s("NZDCAD","NZD/CAD","NZD/CAD","Cặp tiền",{"twelvedata":"NZD/CAD","yfinance":"NZDCAD=X"}),
+    "AUDNZD": _s("AUDNZD","AUD/NZD","AUD/NZD","Cặp tiền",{"twelvedata":"AUD/NZD","yfinance":"AUDNZD=X"}),
     "USDVND": _s("USDVND","USD/VND","USD/VND","Cặp tiền",{"yfinance":"VND=X"}),
     "USDCNH": _s("USDCNH","USD/CNH","USD/CNH","Cặp tiền",{"twelvedata":"USD/CNH"}),
     "USDHKD": _s("USDHKD","USD/HKD","USD/HKD","Cặp tiền",{"twelvedata":"USD/HKD"}),
@@ -793,6 +916,129 @@ SYMBOLS: Dict[str, SymbolConfig] = {
 # TTL Cache (unchanged from v3, with improved stats)
 # ──────────────────────────────────────────────────────────────────────────────
 
+SYNTHETIC_SYMBOLS: Dict[str, SyntheticSymbolConfig] = {
+    "USDX": SyntheticSymbolConfig(
+        symbol="USDX",
+        scale=43.0,
+        alpha=1.0,
+        wick_shrink=0.8,
+        components=(
+            SyntheticComponentSpec(name="EURUSD", mode="inverse", left_symbol="EURUSD"),
+            SyntheticComponentSpec(name="GBPUSD", mode="inverse", left_symbol="GBPUSD"),
+            SyntheticComponentSpec(name="USDCHF", mode="direct", left_symbol="USDCHF"),
+            SyntheticComponentSpec(name="USDJPY", mode="direct", left_symbol="USDJPY"),
+            SyntheticComponentSpec(name="USDCAD", mode="direct", left_symbol="USDCAD"),
+            SyntheticComponentSpec(name="AUDUSD", mode="inverse", left_symbol="AUDUSD"),
+            SyntheticComponentSpec(name="NZDUSD", mode="inverse", left_symbol="NZDUSD"),
+        ),
+    ),
+    "EURX": SyntheticSymbolConfig(
+        symbol="EURX",
+        scale=43.0,
+        alpha=1.0,
+        wick_shrink=0.6,
+        components=(
+            SyntheticComponentSpec(name="EURUSD", mode="direct", left_symbol="EURUSD"),
+            SyntheticComponentSpec(name="EURGBP", mode="direct", left_symbol="EURGBP"),
+            SyntheticComponentSpec(name="EURCHF", mode="product", left_symbol="EURUSD", right_symbol="USDCHF"),
+            SyntheticComponentSpec(name="EURJPY", mode="direct", left_symbol="EURJPY"),
+            SyntheticComponentSpec(name="EURCAD", mode="product", left_symbol="EURUSD", right_symbol="USDCAD"),
+            SyntheticComponentSpec(name="EURAUD", mode="ratio", left_symbol="EURUSD", right_symbol="AUDUSD"),
+            SyntheticComponentSpec(name="EURNZD", mode="ratio", left_symbol="EURUSD", right_symbol="NZDUSD"),
+        ),
+    ),
+    "GBPX": SyntheticSymbolConfig(
+        symbol="GBPX",
+        scale=43.0,
+        alpha=1.0,
+        wick_shrink=0.6,
+        components=(
+            SyntheticComponentSpec(name="GBPUSD", mode="direct", left_symbol="GBPUSD"),
+            SyntheticComponentSpec(name="EURGBP", mode="inverse", left_symbol="EURGBP"),
+            SyntheticComponentSpec(name="GBPCHF", mode="product", left_symbol="GBPUSD", right_symbol="USDCHF"),
+            SyntheticComponentSpec(name="GBPJPY", mode="direct", left_symbol="GBPJPY"),
+            SyntheticComponentSpec(name="GBPCAD", mode="product", left_symbol="GBPUSD", right_symbol="USDCAD"),
+            SyntheticComponentSpec(name="GBPAUD", mode="ratio", left_symbol="GBPUSD", right_symbol="AUDUSD"),
+            SyntheticComponentSpec(name="GBPNZD", mode="ratio", left_symbol="GBPUSD", right_symbol="NZDUSD"),
+        ),
+    ),
+    "CHFX": SyntheticSymbolConfig(
+        symbol="CHFX",
+        scale=43.0,
+        alpha=1.0,
+        wick_shrink=0.8,
+        components=(
+            SyntheticComponentSpec(name="USDCHF", mode="inverse", left_symbol="USDCHF"),
+            SyntheticComponentSpec(name="EURCHF", mode="inverse", left_symbol="EURCHF"),
+            SyntheticComponentSpec(name="GBPCHF", mode="inverse", left_symbol="GBPCHF"),
+            SyntheticComponentSpec(name="CHFJPY", mode="direct", left_symbol="CHFJPY"),
+            SyntheticComponentSpec(name="CADCHF", mode="inverse", left_symbol="CADCHF"),
+            SyntheticComponentSpec(name="AUDCHF", mode="inverse", left_symbol="AUDCHF"),
+            SyntheticComponentSpec(name="NZDCHF", mode="inverse", left_symbol="NZDCHF"),
+        ),
+    ),
+    "JPYX": SyntheticSymbolConfig(
+        symbol="JPYX",
+        scale=43.0,
+        alpha=1.0,
+        wick_shrink=1.0,
+        components=(
+            SyntheticComponentSpec(name="USDJPY", mode="inverse", left_symbol="USDJPY"),
+            SyntheticComponentSpec(name="EURJPY", mode="inverse", left_symbol="EURJPY"),
+            SyntheticComponentSpec(name="GBPJPY", mode="inverse", left_symbol="GBPJPY"),
+            SyntheticComponentSpec(name="CHFJPY", mode="inverse", left_symbol="CHFJPY"),
+            SyntheticComponentSpec(name="CADJPY", mode="inverse", left_symbol="CADJPY"),
+            SyntheticComponentSpec(name="AUDJPY", mode="inverse", left_symbol="AUDJPY"),
+            SyntheticComponentSpec(name="NZDJPY", mode="inverse", left_symbol="NZDJPY"),
+        ),
+    ),
+    "CADX": SyntheticSymbolConfig(
+        symbol="CADX",
+        scale=44.0,
+        alpha=1.0,
+        wick_shrink=0.8,
+        components=(
+            SyntheticComponentSpec(name="USDCAD", mode="inverse", left_symbol="USDCAD"),
+            SyntheticComponentSpec(name="EURCAD", mode="inverse", left_symbol="EURCAD"),
+            SyntheticComponentSpec(name="GBPCAD", mode="inverse", left_symbol="GBPCAD"),
+            SyntheticComponentSpec(name="CADCHF", mode="direct", left_symbol="CADCHF"),
+            SyntheticComponentSpec(name="CADJPY", mode="direct", left_symbol="CADJPY"),
+            SyntheticComponentSpec(name="AUDCAD", mode="inverse", left_symbol="AUDCAD"),
+            SyntheticComponentSpec(name="NZDCAD", mode="inverse", left_symbol="NZDCAD"),
+        ),
+    ),
+    "AUDX": SyntheticSymbolConfig(
+        symbol="AUDX",
+        scale=44.0,
+        alpha=1.0,
+        wick_shrink=0.6,
+        components=(
+            SyntheticComponentSpec(name="AUDUSD", mode="direct", left_symbol="AUDUSD"),
+            SyntheticComponentSpec(name="EURAUD", mode="inverse", left_symbol="EURAUD"),
+            SyntheticComponentSpec(name="GBPAUD", mode="inverse", left_symbol="GBPAUD"),
+            SyntheticComponentSpec(name="AUDCHF", mode="direct", left_symbol="AUDCHF"),
+            SyntheticComponentSpec(name="AUDJPY", mode="direct", left_symbol="AUDJPY"),
+            SyntheticComponentSpec(name="AUDCAD", mode="direct", left_symbol="AUDCAD"),
+            SyntheticComponentSpec(name="AUDNZD", mode="direct", left_symbol="AUDNZD"),
+        ),
+    ),
+    "NZDX": SyntheticSymbolConfig(
+        symbol="NZDX",
+        scale=44.0,
+        alpha=1.0,
+        wick_shrink=0.8,
+        components=(
+            SyntheticComponentSpec(name="NZDUSD", mode="direct", left_symbol="NZDUSD"),
+            SyntheticComponentSpec(name="EURNZD", mode="inverse", left_symbol="EURNZD"),
+            SyntheticComponentSpec(name="GBPNZD", mode="inverse", left_symbol="GBPNZD"),
+            SyntheticComponentSpec(name="NZDCHF", mode="direct", left_symbol="NZDCHF"),
+            SyntheticComponentSpec(name="NZDJPY", mode="direct", left_symbol="NZDJPY"),
+            SyntheticComponentSpec(name="NZDCAD", mode="direct", left_symbol="NZDCAD"),
+            SyntheticComponentSpec(name="AUDNZD", mode="inverse", left_symbol="AUDNZD"),
+        ),
+    ),
+}
+
 def _get_canonical_symbol(sym: str) -> str:
     """Try to find the registry ID for a given symbol or alias."""
     s = sym.upper()
@@ -817,6 +1063,7 @@ forecast_cache   = TTLCache()
 ticker_cache     = TTLCache()
 ai_verdict_cache = TTLCache()
 indicators_cache = TTLCache()
+source_history_cache = TTLCache()
 
 _watchlist_ticker_semaphore = asyncio.Semaphore(WATCHLIST_TICKER_CONCURRENCY)
 _market_peer_ticker_semaphore = asyncio.Semaphore(MARKET_PEER_TICKER_CONCURRENCY)
@@ -827,6 +1074,7 @@ forecast_cache.clear()
 ticker_cache.clear()
 ai_verdict_cache.clear()
 indicators_cache.clear()
+source_history_cache.clear()
 
 
 def _cache_prefix(symbol: str, interval: str) -> str:
@@ -837,7 +1085,7 @@ def interval_ttl(interval: str) -> int:
     if interval in {"1m", "5m"}:    return 20
     if interval == "15m":           return 30
     if interval in {"1h", "4h"}:    return 60
-    return 300
+    return 900
 
 
 def forecast_ttl(interval: str) -> int:
@@ -895,6 +1143,7 @@ _HISTORICAL_INFLIGHT: Dict[str, "asyncio.Task[Tuple[List[Dict[str, Any]], str]]"
 _INDICATORS_INFLIGHT: Dict[str, "asyncio.Task[Dict[str, Any]]"] = {}
 _FORECAST_INFLIGHT: Dict[str, "asyncio.Task[Dict[str, Any]]"] = {}
 _TICKER_INFLIGHT: Dict[str, "asyncio.Task[Dict[str, Any]]"] = {}
+_SOURCE_HISTORY_INFLIGHT: Dict[str, "asyncio.Task[List[Dict[str, Any]]]"] = {}
 
 
 # ──────────────────────────────────────────────────────────────────────────────
@@ -1165,7 +1414,7 @@ async def fetch_twelvedata(symbol: str, interval: str, limit: int) -> List[Dict[
         "symbol":     endpoint_symbol,
         "interval":   TWELVE_INTERVAL_MAP[interval],
         "outputsize": min(max(limit, 30), 5000),
-        "apikey":     TWELVEDATA_API_KEY,
+        "apikey":     twelvedata_pool.next_key(),
         "format":     "JSON",
     }
     logger.info("[TwelveData] %s %s", symbol, interval)
@@ -1180,7 +1429,9 @@ async def fetch_twelvedata(symbol: str, interval: str, limit: int) -> List[Dict[
             resp = await client.get("https://api.twelvedata.com/time_series", params=params)
             if resp.status_code == 429:
                 cb.record_failure()
-                raise HTTPException(status_code=429, detail="TwelveData rate limit")
+                twelvedata_pool.mark_exhausted(params["apikey"])
+                cb.open_for(timeout=1800)
+                raise RuntimeError("TwelveData rate limit")
             if resp.status_code >= 500:
                 cb.record_failure()
                 raise HTTPException(status_code=resp.status_code, detail="TwelveData server error")
@@ -1192,7 +1443,10 @@ async def fetch_twelvedata(symbol: str, interval: str, limit: int) -> List[Dict[
             raise ex
 
     payload = await _retry(_fetch)
-    if "code" in payload and payload.get("code") in [429, 400]:
+    if payload.get("code") == 429:
+        cb.open_for(timeout=1800)
+        raise RuntimeError(f"TwelveData error: {payload}")
+    if "code" in payload and payload.get("code") == 400:
         raise RuntimeError(f"TwelveData error: {payload}")
     values = payload.get("values", [])
     parsed = [
@@ -1223,7 +1477,7 @@ async def fetch_finnhub(symbol: str, interval: str, limit: int) -> List[Dict[str
                 "symbol":   mappings["finnhub"],
                 "resolution": FINNHUB_RESOLUTION_MAP.get(interval, "D"),
                 "count":    limit,
-                "token":    FINNHUB_API_KEY,
+                "token":    finnhub_pool.next_key(),
             },
             timeout=10,
         )
@@ -1328,6 +1582,364 @@ async def fetch_alphavantage(symbol: str, interval: str, limit: int) -> List[Dic
         return _normalize_ohlcv(parsed, interval)[-limit:]
 
 
+async def _fetch_historical_from_source(
+    source: str,
+    symbol: str,
+    interval: str,
+    limit: int,
+) -> List[Dict[str, Any]]:
+    if source == "binance":
+        return await fetch_binance(symbol, interval, limit)
+    if source == "bybit":
+        return await fetch_bybit(symbol, interval, limit)
+    if source == "coingecko":
+        return await fetch_coingecko(symbol, interval, limit)
+    if source == "twelvedata":
+        return await fetch_twelvedata(symbol, interval, limit)
+    if source == "finnhub":
+        return await fetch_finnhub(symbol, interval, limit)
+    if source == "yfinance":
+        return await fetch_yfinance(symbol, interval, limit)
+    if source == "alphavantage":
+        return await fetch_alphavantage(symbol, interval, limit)
+    raise ValueError(f"Unsupported source fetcher: {source}")
+
+
+async def _fetch_historical_from_source_cached(
+    source: str,
+    symbol: str,
+    interval: str,
+    limit: int,
+) -> List[Dict[str, Any]]:
+    """
+    Deduplicate repeated component fetches used by synthetic symbols.
+
+    This keeps Real Strength baskets from re-downloading the same FX cross
+    multiple times across EURX/GBPX/CHFX/... within one refresh window.
+    """
+    cache_key = f"source_hist:{CACHE_VERSION}:{source}:{symbol}:{interval}:{limit}"
+    cached = source_history_cache.get(cache_key)
+    if cached is not None:
+        return cached
+
+    inflight_task = _SOURCE_HISTORY_INFLIGHT.get(cache_key)
+    if inflight_task is not None:
+        return await inflight_task
+
+    task = asyncio.create_task(
+        _fetch_historical_from_source(source, symbol, interval, limit),
+        name=f"source_hist:{source}:{symbol}:{interval}:{limit}",
+    )
+    _SOURCE_HISTORY_INFLIGHT[cache_key] = task
+    try:
+        data = await task
+        source_history_cache.set(cache_key, data, ttl_seconds=interval_ttl(interval))
+        return data
+    finally:
+        if _SOURCE_HISTORY_INFLIGHT.get(cache_key) is task:
+            _SOURCE_HISTORY_INFLIGHT.pop(cache_key, None)
+
+
+def _is_synthetic_symbol(symbol: str) -> bool:
+    return symbol in SYNTHETIC_SYMBOLS
+
+
+def _extract_candle_value(candle: Dict[str, Any], field_name: str) -> float:
+    return float(candle[field_name])
+
+
+def _combine_component_candles(
+    spec: SyntheticComponentSpec,
+    left_candle: Dict[str, Any],
+    right_candle: Optional[Dict[str, Any]] = None,
+    use_body_only_extrema: bool = False,
+) -> Dict[str, float]:
+    if spec.mode == "direct":
+        open_value = _extract_candle_value(left_candle, "open")
+        close_value = _extract_candle_value(left_candle, "close")
+        if use_body_only_extrema:
+            return {
+                "open": open_value,
+                "high": max(open_value, close_value),
+                "low": min(open_value, close_value),
+                "close": close_value,
+            }
+        return {
+            "open": open_value,
+            "high": _extract_candle_value(left_candle, "high"),
+            "low": _extract_candle_value(left_candle, "low"),
+            "close": close_value,
+        }
+
+    if spec.mode == "inverse":
+        lo = _extract_candle_value(left_candle, "open")
+        lh = _extract_candle_value(left_candle, "high")
+        ll = _extract_candle_value(left_candle, "low")
+        lc = _extract_candle_value(left_candle, "close")
+        if min(lo, lh, ll, lc) <= 0:
+            raise ValueError(f"Synthetic component {spec.name} has non-positive inverse values")
+        open_value = 1.0 / lo
+        close_value = 1.0 / lc
+        if use_body_only_extrema:
+            return {
+                "open": open_value,
+                "high": max(open_value, close_value),
+                "low": min(open_value, close_value),
+                "close": close_value,
+            }
+        return {
+            "open": open_value,
+            "high": 1.0 / ll,
+            "low": 1.0 / lh,
+            "close": close_value,
+        }
+
+    if right_candle is None:
+        raise ValueError(f"Synthetic component {spec.name} requires a right candle")
+
+    lo = _extract_candle_value(left_candle, "open")
+    lh = _extract_candle_value(left_candle, "high")
+    ll = _extract_candle_value(left_candle, "low")
+    lc = _extract_candle_value(left_candle, "close")
+
+    ro = _extract_candle_value(right_candle, "open")
+    rh = _extract_candle_value(right_candle, "high")
+    rl = _extract_candle_value(right_candle, "low")
+    rc = _extract_candle_value(right_candle, "close")
+
+    if spec.mode == "product":
+        open_value = lo * ro
+        close_value = lc * rc
+        if use_body_only_extrema:
+            return {
+                "open": open_value,
+                "high": max(open_value, close_value),
+                "low": min(open_value, close_value),
+                "close": close_value,
+            }
+        return {
+            "open": open_value,
+            "high": lh * rh,
+            "low": ll * rl,
+            "close": close_value,
+        }
+
+    if spec.mode == "ratio":
+        if min(ro, rh, rl, rc) <= 0:
+            raise ValueError(f"Synthetic component {spec.name} has non-positive divisor values")
+        open_value = lo / ro
+        close_value = lc / rc
+        if use_body_only_extrema:
+            return {
+                "open": open_value,
+                "high": max(open_value, close_value),
+                "low": min(open_value, close_value),
+                "close": close_value,
+            }
+        return {
+            "open": open_value,
+            "high": lh / rl,
+            "low": ll / rh,
+            "close": close_value,
+        }
+
+    raise ValueError(f"Unsupported synthetic component mode: {spec.mode}")
+
+
+def _weighted_geometric_mean(
+    values: List[Tuple[float, float]],
+    scale: float,
+    alpha: float,
+) -> float:
+    sum_ln = 0.0
+    sum_weight = 0.0
+    for value, weight in values:
+        if value <= 0 or weight <= 0:
+            continue
+        sum_ln += weight * math.log(value)
+        sum_weight += weight
+    if sum_weight <= 0:
+        raise ValueError("Synthetic symbol received no valid positive component values")
+    return scale * math.exp(alpha * (sum_ln / sum_weight))
+
+
+def _build_synthetic_ohlc(
+    component_values: Dict[str, Dict[str, float]],
+    config: SyntheticSymbolConfig,
+) -> Dict[str, float]:
+    open_value = _weighted_geometric_mean(
+        [(component_values[spec.name]["open"], spec.weight) for spec in config.components if spec.enabled],
+        config.scale,
+        config.alpha,
+    )
+    close_value = _weighted_geometric_mean(
+        [(component_values[spec.name]["close"], spec.weight) for spec in config.components if spec.enabled],
+        config.scale,
+        config.alpha,
+    )
+    high_raw = _weighted_geometric_mean(
+        [(component_values[spec.name]["high"], spec.weight) for spec in config.components if spec.enabled],
+        config.scale,
+        config.alpha,
+    )
+    low_raw = _weighted_geometric_mean(
+        [(component_values[spec.name]["low"], spec.weight) for spec in config.components if spec.enabled],
+        config.scale,
+        config.alpha,
+    )
+
+    midpoint = (open_value + close_value) / 2.0
+    high_value = midpoint + (high_raw - midpoint) * config.wick_shrink
+    low_value = midpoint + (low_raw - midpoint) * config.wick_shrink
+
+    return {
+        "open": open_value,
+        "high": max(high_value, open_value, close_value),
+        "low": min(low_value, open_value, close_value),
+        "close": close_value,
+    }
+
+
+async def _build_synthetic_symbol_history(
+    symbol: str,
+    interval: str,
+    fetch_limit: int,
+    cache_key: str,
+) -> Tuple[List[Dict[str, Any]], str]:
+    config = SYNTHETIC_SYMBOLS[symbol]
+    headroom = max(50, fetch_limit // 2)
+    component_limit = min(2000, fetch_limit + headroom)
+    required_symbols = {
+        spec.left_symbol
+        for spec in config.components
+        if spec.enabled
+    } | {
+        spec.right_symbol
+        for spec in config.components
+        if spec.enabled and spec.right_symbol
+    }
+
+    minimum_required = min(20, fetch_limit)
+    preferred_sources = (
+        ["yfinance", "twelvedata", "finnhub"]
+        if interval in {"1d", "1w"}
+        else ["twelvedata", "finnhub", "yfinance"]
+    )
+
+    component_rows: Dict[str, List[Dict[str, Any]]] = {}
+    component_sources: Dict[str, str] = {}
+    common_times: List[int] = []
+    last_error_messages: List[str] = []
+    use_body_only_extrema = interval not in {"1d", "1w"}
+
+    async def _load_component_rows(
+        source_name: str,
+        component_symbol: str,
+    ) -> Tuple[str, Optional[List[Dict[str, Any]]], Optional[str]]:
+        if source_name not in SYMBOLS[component_symbol].mappings:
+            return component_symbol, None, f"{component_symbol}: missing {source_name} mapping"
+
+        try:
+            rows = await _fetch_historical_from_source_cached(
+                source_name,
+                component_symbol,
+                interval,
+                component_limit,
+            )
+            return component_symbol, rows, None
+        except Exception as exc:
+            return component_symbol, None, f"{component_symbol}: {exc}"
+
+    for source in preferred_sources:
+        current_rows: Dict[str, List[Dict[str, Any]]] = {}
+        current_sources: Dict[str, str] = {}
+        source_errors: List[str] = []
+
+        component_results = await asyncio.gather(
+            *[
+                _load_component_rows(source, component_symbol)
+                for component_symbol in sorted(required_symbols)
+            ]
+        )
+        for component_symbol, rows, error_message in component_results:
+            if error_message:
+                source_errors.append(error_message)
+                continue
+            if rows is None:
+                source_errors.append(f"{component_symbol}: empty rows")
+                continue
+            current_rows[component_symbol] = rows
+            current_sources[component_symbol] = source
+
+        if source_errors:
+            last_error_messages = source_errors
+            continue
+
+        time_sets = [
+            {int(row["time"]) for row in rows}
+            for rows in current_rows.values()
+            if rows
+        ]
+        current_common_times = sorted(set.intersection(*time_sets)) if time_sets else []
+        if len(current_common_times) < minimum_required:
+            last_error_messages = [
+                f"{source}: aligned={len(current_common_times)} required>={minimum_required}"
+            ]
+            continue
+
+        component_rows = current_rows
+        component_sources = current_sources
+        common_times = current_common_times
+        break
+
+    if len(common_times) < minimum_required:
+        raise HTTPException(
+            status_code=502,
+            detail={
+                "message": f"Insufficient aligned candles to build synthetic symbol {symbol}",
+                "errors": last_error_messages,
+            },
+        )
+
+    candles_by_symbol = {
+        component_symbol: {int(row["time"]): row for row in rows}
+        for component_symbol, rows in component_rows.items()
+    }
+
+    synthetic_rows: List[Dict[str, Any]] = []
+    for timestamp in common_times[-fetch_limit:]:
+        component_values: Dict[str, Dict[str, float]] = {}
+        for spec in config.components:
+            if not spec.enabled:
+                continue
+            left_candle = candles_by_symbol[spec.left_symbol][timestamp]
+            right_candle = (
+                candles_by_symbol[spec.right_symbol][timestamp]
+                if spec.right_symbol
+                else None
+            )
+            component_values[spec.name] = _combine_component_candles(
+                spec,
+                left_candle,
+                right_candle,
+                use_body_only_extrema=use_body_only_extrema,
+            )
+
+        synthetic_ohlc = _build_synthetic_ohlc(component_values, config)
+        synthetic_rows.append(
+            {
+                "time": timestamp,
+                "open": round(float(synthetic_ohlc["open"]), 8),
+                "high": round(float(synthetic_ohlc["high"]), 8),
+                "low": round(float(synthetic_ohlc["low"]), 8),
+                "close": round(float(synthetic_ohlc["close"]), 8),
+                "volume": 0.0,
+            }
+        )
+
+    source = "synthetic:" + ",".join(sorted(set(component_sources.values())))
+    historical_cache.set(cache_key, (synthetic_rows, source), ttl_seconds=interval_ttl(interval))
+    return synthetic_rows, source
 
 
 def _get_source_priority(symbol: str) -> List[str]:
@@ -1342,6 +1954,9 @@ async def _run_historical_fetch(
     fetch_limit: int,
     cache_key: str,
 ) -> Tuple[List[Dict[str, Any]], str]:
+    if _is_synthetic_symbol(symbol):
+        return await _build_synthetic_symbol_history(symbol, interval, fetch_limit, cache_key)
+
     priority = _get_source_priority(symbol)
     errors: List[str] = []
 
@@ -1368,8 +1983,17 @@ async def _run_historical_fetch(
                 historical_cache.set(cache_key, (data, source), ttl_seconds=interval_ttl(interval))
                 return data, source
             errors.append(f"{source}: insufficient ({len(data)} candles)")
-        except HTTPException:
-            raise
+        except HTTPException as ex:
+            errors.append(f"{source}: HTTP {ex.status_code} {ex.detail}")
+            logger.warning(
+                "[fetch_historical] %s/%s %s HTTP %s: %s",
+                symbol,
+                interval,
+                source,
+                ex.status_code,
+                ex.detail,
+            )
+            continue
         except Exception as ex:
             errors.append(f"{source}: {ex}")
             logger.warning("[fetch_historical] %s/%s %s: %s", symbol, interval, source, ex)
@@ -1429,17 +2053,43 @@ async def fetch_historical(
 # ──────────────────────────────────────────────────────────────────────────────
 # Real-time Ticker (last price + 24h stats)
 # ──────────────────────────────────────────────────────────────────────────────
-async def fetch_ticker(symbol: str) -> Dict[str, Any]:
-    cached = ticker_cache.get(f"ticker:{symbol}")
+async def fetch_ticker(symbol: str, interval: Optional[str] = None) -> Dict[str, Any]:
+    interval_key = interval or "default"
+    cache_key = f"ticker:{symbol}:{interval_key}"
+    cached = ticker_cache.get(cache_key)
     if cached:
         return cached
 
-    inflight_key = f"ticker:{symbol}"
+    inflight_key = cache_key
     inflight_task = _TICKER_INFLIGHT.get(inflight_key)
     if inflight_task is not None:
         return await inflight_task
 
     async def _run() -> Dict[str, Any]:
+        if _is_synthetic_symbol(symbol):
+            synthetic_interval = interval or "1d"
+            rows, source = await fetch_historical(symbol, synthetic_interval, 2, min_context=2)
+            current_row = rows[-1]
+            previous_row = rows[-2] if len(rows) > 1 else current_row
+            current_price = float(current_row["close"])
+            previous_close = float(previous_row["close"])
+            high_24h = float(current_row["high"])
+            low_24h = float(current_row["low"])
+            change_value = current_price - previous_close
+            result = {
+                "symbol": symbol,
+                "price": current_price,
+                "change": change_value,
+                "change_pct": ((change_value / previous_close) * 100.0) if previous_close else 0.0,
+                "high_24h": high_24h,
+                "low_24h": low_24h,
+                "volume_24h": 0.0,
+                "source": source,
+                "timestamp": int(time.time()),
+            }
+            ticker_cache.set(cache_key, result, ttl_seconds=10)
+            return result
+
         cfg = SYMBOLS[symbol]
         priority = _get_source_priority(symbol)
         client = await GlobalHTTPClient.get_client()
@@ -1469,7 +2119,7 @@ async def fetch_ticker(symbol: str) -> Dict[str, Any]:
                     await _rate_limit("twelvedata")
                     r = await client.get(
                         "https://api.twelvedata.com/quote",
-                        params={"symbol": cfg.mappings["twelvedata"], "apikey": TWELVEDATA_API_KEY},
+                        params={"symbol": cfg.mappings["twelvedata"], "apikey": twelvedata_pool.next_key()},
                         timeout=10.0,
                     )
                     d = r.json()
@@ -1549,8 +2199,8 @@ async def fetch_ticker(symbol: str) -> Dict[str, Any]:
                     continue
 
                 res.update({"symbol": symbol, "timestamp": int(time.time())})
-                ttl = 5 if cfg.category == "Crypto" else (10 if cfg.category in ("C?p ti?n", "Ch? s?") else 30)
-                ticker_cache.set(f"ticker:{symbol}", res, ttl_seconds=ttl)
+                ttl = 5 if cfg.category == "Crypto" else (10 if cfg.category in ("Cặp tiền", "Chỉ số", "Real Strength") else 30)
+                ticker_cache.set(cache_key, res, ttl_seconds=ttl)
                 return res
             except Exception as ex:
                 logger.debug("[ticker] %s/%s failed: %s", symbol, source, ex)
@@ -1558,7 +2208,7 @@ async def fetch_ticker(symbol: str) -> Dict[str, Any]:
 
         raise HTTPException(status_code=502, detail=f"Ticker failed for {symbol} after trying {priority}")
 
-    task = asyncio.create_task(_run(), name=f"ticker:{symbol}")
+    task = asyncio.create_task(_run(), name=f"ticker:{symbol}:{interval_key}")
     _TICKER_INFLIGHT[inflight_key] = task
     try:
         return await task
@@ -3754,12 +4404,18 @@ class KronosForecaster:
         self._predictor: Optional[Any] = None
         self._loaded = False
         self._lock: Optional[asyncio.Lock] = None
+        self._predict_lock: Optional[asyncio.Lock] = None
 
     async def _get_lock(self) -> asyncio.Lock:
         if self._lock is None:
             self._lock = asyncio.Lock()
         return self._lock
 
+    async def _get_predict_lock(self) -> asyncio.Lock:
+        if self._predict_lock is None:
+            self._predict_lock = asyncio.Lock()
+        return self._predict_lock
+
     @property
     def is_ready(self) -> bool:
         return self._loaded
@@ -3774,6 +4430,45 @@ class KronosForecaster:
             return CLIP_DEFAULT
         return getattr(self._predictor, "clip", CLIP_DEFAULT)
 
+    @staticmethod
+    def _collapse_tokenizer_to_single_ohlc4_channel(tokenizer: Any) -> Any:
+        """
+        Convert the 6-channel public Kronos tokenizer into a true 1-channel
+        tokenizer for OHLC4 inference.
+
+        The encoder-side projection preserves the previous replicated-OHLC4
+        behaviour exactly by summing the O/H/L/C input weights, because the old
+        wrapper fed the same OHLC4 value into all four price channels.
+
+        The decoder-side projection emits a single OHLC4 channel by averaging
+        the original O/H/L/C output heads.
+        """
+        d_in = int(getattr(tokenizer, "d_in", 0) or 0)
+        if d_in == 1:
+            return tokenizer
+        if d_in != 6:
+            raise ValueError(f"Unsupported Kronos tokenizer d_in={d_in}; expected 6 for adapter collapse")
+
+        device = tokenizer.embed.weight.device
+        dtype = tokenizer.embed.weight.dtype
+
+        collapsed_embed = torch.nn.Linear(1, tokenizer.d_model, bias=tokenizer.embed.bias is not None).to(device=device, dtype=dtype)
+        collapsed_head = torch.nn.Linear(tokenizer.d_model, 1, bias=tokenizer.head.bias is not None).to(device=device, dtype=dtype)
+
+        with torch.no_grad():
+            collapsed_embed.weight.copy_(tokenizer.embed.weight[:, :4].sum(dim=1, keepdim=True))
+            if tokenizer.embed.bias is not None and collapsed_embed.bias is not None:
+                collapsed_embed.bias.copy_(tokenizer.embed.bias)
+
+            collapsed_head.weight.copy_(tokenizer.head.weight[:4].mean(dim=0, keepdim=True))
+            if tokenizer.head.bias is not None and collapsed_head.bias is not None:
+                collapsed_head.bias.copy_(tokenizer.head.bias[:4].mean().reshape(1))
+
+        tokenizer.embed = collapsed_embed
+        tokenizer.head = collapsed_head
+        tokenizer.d_in = 1
+        return tokenizer
+
     async def _lazy_load(self) -> None:
         if self._loaded:
             return
@@ -3789,6 +4484,7 @@ class KronosForecaster:
                           else "cpu")
                 logger.info("[Kronos] Loading on %s …", device)
                 tokenizer = await asyncio.to_thread(KronosTokenizer.from_pretrained, "NeoQuasar/Kronos-Tokenizer-base")
+                tokenizer = self._collapse_tokenizer_to_single_ohlc4_channel(tokenizer)
                 model     = await asyncio.to_thread(Kronos.from_pretrained, self.MODEL_NAME)
                 self._predictor = KronosPredictor(model, tokenizer, device=device, max_context=self.MAX_CONTEXT)
                 self._loaded = True
@@ -3798,12 +4494,27 @@ class KronosForecaster:
                 raise HTTPException(status_code=500, detail=f"Kronos init failed: {ex}")
 
     @staticmethod
-    def _safe_volume(df: pd.DataFrame) -> np.ndarray:
-        vol = df["volume"].values.astype(np.float32)
-        if vol.sum() == 0:
-            typical = ((df["high"] + df["low"] + df["close"]) / 3).values.astype(np.float32)
-            vol = np.full_like(typical, typical.mean())
-        return vol
+    def _prepare_feature_frame(df: pd.DataFrame) -> pd.DataFrame:
+        """
+        Prepare a true 1-channel OHLC4 frame for Kronos inference.
+        """
+        required_price_cols = ["open", "high", "low", "close"]
+        ohlc4 = df[required_price_cols].mean(axis=1).astype(np.float32)
+        return pd.DataFrame({"ohlc4": ohlc4}, index=df.index).astype(np.float32)
+
+    @staticmethod
+    def _normalize_feature_matrix(
+        x: np.ndarray,
+        clip: float,
+    ) -> Tuple[np.ndarray, np.ndarray, np.ndarray]:
+        """
+        Use the same normalization contract as KronosPredictor.predict():
+        std is stabilized by +1e-5 rather than replacing zero-std columns with 1.0.
+        """
+        x_mean = np.mean(x, axis=0).astype(np.float32)
+        x_scale = (np.std(x, axis=0) + 1e-5).astype(np.float32)
+        x_norm = np.clip((x - x_mean) / x_scale, -clip, clip).astype(np.float32)
+        return x_norm, x_mean, x_scale
 
     async def forecast(self, df: pd.DataFrame, x_timestamp: pd.Series,
                        y_timestamp: pd.Series, horizon: int,
@@ -3816,60 +4527,72 @@ class KronosForecaster:
             if not isinstance(y_timestamp, pd.Series):
                 y_timestamp = pd.Series(y_timestamp.values if hasattr(y_timestamp, "values") else y_timestamp)
 
-            vol = self._safe_volume(df)
-            if "amount" in df.columns and df["amount"].sum() != 0:
-                amount = df["amount"].values.astype(np.float32)
-            else:
-                typical = ((df["high"] + df["low"] + df["close"]) / 3).values.astype(np.float32)
-                amount = vol * typical
-
-            x = np.stack([df["open"].values, df["high"].values, df["low"].values,
-                          df["close"].values, vol, amount], axis=1).astype(np.float32)
+            prepared_df = self._prepare_feature_frame(df)
+            x = prepared_df[["ohlc4"]].values.astype(np.float32)
 
             x_stamp = calc_time_stamps(x_timestamp).values.astype(np.float32)
             y_stamp = calc_time_stamps(y_timestamp).values.astype(np.float32)
 
-            x_mean = np.mean(x, axis=0)
-            x_std  = np.std(x, axis=0)
-            x_std_safe = np.where(x_std < 1e-8, 1.0, x_std)
-            x_norm = np.clip((x - x_mean) / x_std_safe, -self._clip, self._clip)
+            x_norm, x_mean, x_scale = self._normalize_feature_matrix(x, self._clip)
 
             x_norm  = x_norm[np.newaxis, :]
             x_stamp = x_stamp[np.newaxis, :]
             y_stamp = y_stamp[np.newaxis, :]
 
             t0 = time.time()
-            samples = await asyncio.to_thread(
-                self._predictor.generate,
-                x=x_norm, x_stamp=x_stamp, y_stamp=y_stamp,
-                pred_len=horizon, T=1.0, top_k=0, top_p=0.9,
-                sample_count=sample_count, verbose=False, return_samples=True,
-            )
+            predict_lock = await self._get_predict_lock()
+            async with predict_lock:
+                samples = await asyncio.to_thread(
+                    self._predictor.generate,
+                    x=x_norm, x_stamp=x_stamp, y_stamp=y_stamp,
+                    pred_len=horizon, T=1.0, top_k=0, top_p=0.9,
+                    sample_count=sample_count, verbose=False, return_samples=True,
+                )
             logger.info("[Kronos] %.2fs | horizon=%d samples=%d ctx=%d",
                         time.time() - t0, horizon, sample_count, len(df))
 
             if "cuda" in self.device:
                 torch.cuda.empty_cache()
 
-            close_samples = np.asarray(samples[0, :, :, 3], dtype=float)
+            ohlc4_samples = np.asarray(samples[0, :, :, 0], dtype=float)
             # Some Kronos checkpoints return the full decoded sequence rather than
             # only the requested pred_len. Keep the most recent horizon window so
             # downstream logic always receives a forecast-length vector.
-            if close_samples.shape[-1] > horizon:
-                close_samples = close_samples[:, -horizon:]
-            elif close_samples.shape[-1] < horizon:
-                pad_width = horizon - close_samples.shape[-1]
-                close_samples = np.pad(close_samples, ((0, 0), (0, pad_width)), mode="edge")
+            if ohlc4_samples.shape[1] > horizon:
+                ohlc4_samples = ohlc4_samples[:, -horizon:]
+            elif ohlc4_samples.shape[1] < horizon:
+                pad_width = horizon - ohlc4_samples.shape[1]
+                ohlc4_samples = np.pad(ohlc4_samples, ((0, 0), (0, pad_width)), mode="edge")
 
-            close_samples = close_samples * x_std_safe[3] + x_mean[3]
+            ohlc4_samples = ohlc4_samples * float(x_scale[0]) + float(x_mean[0])
+            p10 = np.percentile(ohlc4_samples, 10, axis=0)
+            p50 = np.percentile(ohlc4_samples, 50, axis=0)
+            p90 = np.percentile(ohlc4_samples, 90, axis=0)
 
             return {
-                "p10": np.percentile(close_samples, 10, axis=0),
-                "p50": np.percentile(close_samples, 50, axis=0),
-                "p90": np.percentile(close_samples, 90, axis=0),
+                "p10": p10,
+                "p50": p50,
+                "p90": p90,
                 "model_name":     self.MODEL_NAME,
                 "context_length": len(df),
-                "output_horizon": int(close_samples.shape[-1]),
+                "output_horizon": int(ohlc4_samples.shape[1]),
+                "input_semantics": {
+                    "feature_channels": ["ohlc4"],
+                    "active_forecast_channels": ["ohlc4"],
+                    "ignored_channels": [],
+                    "price_mode": "ohlc4_single_channel",
+                    "base_signal": "ohlc4",
+                    "volume_mode": "omitted",
+                    "amount_mode": "omitted",
+                    "adapter_mode": "tokenizer_6ch_to_1ch_ohlc4",
+                    "normalization": "std_plus_epsilon_1e-5",
+                },
+                "output_semantics": {
+                    "forecast_channel": "ohlc4",
+                    "forecast_mode": "single_future_ohlc4_line",
+                    "quantile_fields": ["p10", "p50", "p90"],
+                    "candle_projection": "omitted",
+                },
             }
         except Exception as ex:
             logger.error("[Kronos] Forecast failed: %s", ex, exc_info=True)
@@ -3879,6 +4602,15 @@ class KronosForecaster:
 forecaster = KronosForecaster()
 
 
+def _is_kronos_shape_mismatch_error(exc: Exception) -> bool:
+    detail = getattr(exc, "detail", exc)
+    text = str(detail)
+    return (
+        "size of tensor" in text
+        and "must match" in text
+    )
+
+
 
 # MODULE: Analysis Engine v2.0 (Relocated and Activated)
 # Legacy placeholders removed to avoid duplication with logic at line 1884.
@@ -3944,6 +4676,7 @@ async def websocket_price(websocket: WebSocket, symbol: str):
     if symbol not in SYMBOLS:
         await websocket.close(code=1008, reason=f"Unknown symbol: {symbol}")
         return
+    interval = websocket.query_params.get("interval") or "1d"
 
     try:
         await ws_manager.connect(websocket, symbol)
@@ -3954,7 +4687,7 @@ async def websocket_price(websocket: WebSocket, symbol: str):
                     break
 
                 # 2. Fetch fresh price
-                ticker = await get_ticker(symbol)
+                ticker = await fetch_ticker(symbol, interval=interval)
                 
                 # 3. Final state check before send
                 if websocket.client_state == WebSocketState.CONNECTED:
@@ -4368,11 +5101,11 @@ async def get_local_ai_verdict(
 
 
 @app.get("/api/ticker/{symbol}")
-async def get_ticker(symbol: str) -> Dict[str, Any]:
+async def get_ticker(symbol: str, interval: Optional[str] = None) -> Dict[str, Any]:
     symbol = _get_canonical_symbol(symbol)
     if symbol not in SYMBOLS:
         raise HTTPException(404, f"Unknown symbol: {symbol}")
-    return await fetch_ticker(symbol)
+    return await fetch_ticker(symbol, interval=interval)
 
 
 # ── Watchlist (batch ticker) ──────────────────────────────────────────────────
@@ -4402,6 +5135,358 @@ async def get_watchlist_tickers(body: WatchlistRequest) -> Dict[str, Any]:
     }
 
 
+def _forecast_cache_key(symbol: str, interval: str, horizon: int) -> str:
+    return f"forecast_{_cache_prefix(symbol, interval)}{horizon}"
+
+
+def _forecast_payload_is_current(cached: Optional[Dict[str, Any]]) -> bool:
+    if not isinstance(cached, dict):
+        return False
+    if "forecast_candles" in cached:
+        return False
+
+    display = cached.get("display") or {}
+    if (
+        display.get("mode") != "raw_kronos_ohlc4_line"
+        or display.get("output_mode") != "single_future_ohlc4_line"
+        or display.get("channels") != ["ohlc4"]
+    ):
+        return False
+
+    model_meta = cached.get("model") or {}
+    semantics = model_meta.get("input_semantics") or {}
+    output_semantics = model_meta.get("output_semantics") or {}
+    return (
+        semantics.get("volume_mode") == "omitted"
+        and semantics.get("amount_mode") == "omitted"
+        and semantics.get("active_forecast_channels") == ["ohlc4"]
+        and semantics.get("feature_channels") == ["ohlc4"]
+        and semantics.get("price_mode") == "ohlc4_single_channel"
+        and semantics.get("base_signal") == "ohlc4"
+        and semantics.get("adapter_mode") == "tokenizer_6ch_to_1ch_ohlc4"
+        and output_semantics.get("forecast_channel") == "ohlc4"
+        and output_semantics.get("forecast_mode") == "single_future_ohlc4_line"
+        and output_semantics.get("candle_projection") == "omitted"
+    )
+
+
+def _load_cached_forecast_response(cache_key: str, interval: str) -> Optional[Dict[str, Any]]:
+    cached = forecast_cache.get(cache_key)
+    if cached is not None and _forecast_payload_is_current(cached):
+        cached["generated_at"] = int(time.time())
+        cached["cache"] = {"origin": "memory", "refresh_requested": False}
+        return cached
+
+    persisted = persistent_cache.get(cache_key)
+    if persisted is not None and _forecast_payload_is_current(persisted):
+        persisted["from_persistent_cache"] = True
+        forecast_cache.set(cache_key, persisted, ttl_seconds=forecast_ttl(interval))
+        persisted["generated_at"] = int(time.time())
+        persisted["cache"] = {"origin": "persistent", "refresh_requested": False}
+        return persisted
+
+    return None
+
+
+async def _prepare_forecast_response_payload(
+    symbol: str,
+    interval: str,
+    horizon: int,
+    refresh: bool,
+    cache_origin: str,
+) -> Dict[str, Any]:
+    data_list, source, indicators = await get_indicators_cached(
+        symbol,
+        interval,
+        FORECAST_CONTEXT,
+        refresh=refresh,
+        min_context=FORECAST_CONTEXT,
+    )
+    if not KRONOS_AVAILABLE:
+        last_ohlc4 = (
+            float(
+                np.mean(
+                    [
+                        float(data_list[-1]["open"]),
+                        float(data_list[-1]["high"]),
+                        float(data_list[-1]["low"]),
+                        float(data_list[-1]["close"]),
+                    ]
+                )
+            )
+            if data_list
+            else 0.0
+        )
+        return {
+            "symbol": symbol,
+            "interval": interval,
+            "forecast_rows": [],
+            "error": "AI Forecaster is currently offline or not found in bundle.",
+            "path_checked": KRONOS_PATH,
+            "ai_runtime": {"mode": "local_only", "model": "offline"},
+            "_data_list": data_list,
+            "indicators_snapshot": indicators,
+            "_blended": {"confidence": 0.0, "agreement": False, "scale": 1.0, "model_weight": 0.0, "anchor_weight": 1.0, "model_bias_pct": 0.0},
+            "source": source,
+            "horizon": horizon,
+            "last_close": last_ohlc4,
+            "model": {
+                "name": "offline",
+                "context_length": 0,
+                "quantiles": [0.1, 0.5, 0.9],
+                "cache_version": CACHE_VERSION,
+                "sample_count": 0,
+                "input_semantics": {
+                    "feature_channels": ["ohlc4"],
+                    "active_forecast_channels": ["ohlc4"],
+                    "ignored_channels": [],
+                    "price_mode": "ohlc4_single_channel",
+                    "base_signal": "ohlc4",
+                    "volume_mode": "omitted",
+                    "amount_mode": "omitted",
+                    "adapter_mode": "tokenizer_6ch_to_1ch_ohlc4",
+                },
+                "output_semantics": {
+                    "forecast_channel": "ohlc4",
+                    "forecast_mode": "single_future_ohlc4_line",
+                    "quantile_fields": ["p10", "p50", "p90"],
+                    "candle_projection": "omitted",
+                },
+            },
+            "_cache_origin": cache_origin,
+        }
+
+    if len(data_list) < 40:
+        raise HTTPException(422, "Insufficient historical data for forecasting")
+
+    df_hist = pd.DataFrame(data_list)
+    df_hist["timestamps"] = pd.to_datetime(df_hist["time"], unit="s", utc=True)
+
+    if "amount" not in df_hist.columns or df_hist["amount"].isna().all() or df_hist["amount"].sum() == 0:
+        typical = (df_hist["high"] + df_hist["low"] + df_hist["close"]) / 3
+        df_hist["amount"] = (df_hist["volume"] * typical).fillna(0)
+    else:
+        df_hist["amount"] = df_hist["amount"].fillna(0)
+
+    context_len = min(len(df_hist), KronosForecaster.MAX_CONTEXT)
+    df_context = df_hist.tail(context_len).reset_index(drop=True)
+
+    logger.info("[forecast] %s %s | ctx=%d/%d | horizon=%d", symbol, interval, context_len, len(df_hist), horizon)
+
+    last_time = int(df_hist["time"].iloc[-1])
+    step = STEP_SECONDS[interval]
+    y_timestamps = pd.Series(pd.to_datetime(
+        [last_time + step * (i + 1) for i in range(horizon)], unit="s", utc=True
+    ))
+
+    sample_count = 10 if forecaster.device in {"not_loaded", "cpu"} else 15
+
+    async def _run_model(model_df: pd.DataFrame) -> Dict[str, Any]:
+        return await forecaster.forecast(
+            df=model_df[["open", "high", "low", "close", "volume", "amount"]],
+            x_timestamp=model_df["timestamps"],
+            y_timestamp=y_timestamps,
+            horizon=horizon,
+            sample_count=sample_count,
+        )
+
+    try:
+        model_output = await _run_model(df_context)
+    except HTTPException as exc:
+        if not _is_kronos_shape_mismatch_error(exc) or context_len <= 504:
+            raise
+
+        fallback_context_len = min(context_len - 8, 504)
+        fallback_context_len = max(fallback_context_len, min(256, context_len))
+        if fallback_context_len >= context_len:
+            raise
+
+        logger.warning(
+            "[forecast] %s %s | Kronos shape mismatch at ctx=%d, retrying with ctx=%d",
+            symbol,
+            interval,
+            context_len,
+            fallback_context_len,
+        )
+        context_len = fallback_context_len
+        df_context = df_hist.tail(context_len).reset_index(drop=True)
+        model_output = await _run_model(df_context)
+
+    last_ohlc4 = float(df_hist[["open", "high", "low", "close"]].mean(axis=1).iloc[-1])
+    last_close = last_ohlc4
+    analysis_bundle = _build_raw_close_bundle(model_output, last_ohlc4)
+    logger.info(
+        "[forecast] raw-ohlc4-line | %s %s | confidence=%.1f agreement=%s",
+        symbol,
+        interval,
+        analysis_bundle["confidence"],
+        analysis_bundle["agreement"],
+    )
+
+    forecast_rows: List[Dict[str, Any]] = [
+        {"time": last_time, "p10": last_ohlc4, "p50": last_ohlc4, "p90": last_ohlc4, "is_actual": True}
+    ]
+    for i in range(horizon):
+        forecast_rows.append({
+            "time": int(last_time + step * (i + 1)),
+            "p10": round(float(analysis_bundle["p10"][i]), 6),
+            "p50": round(float(analysis_bundle["p50"][i]), 6),
+            "p90": round(float(analysis_bundle["p90"][i]), 6),
+        })
+
+    return {
+        "symbol": symbol,
+        "interval": interval,
+        "source": source,
+        "horizon": horizon,
+        "last_close": last_close,
+        "forecast_rows": forecast_rows,
+        "from_persistent_cache": False,
+        "model": {
+            "name": model_output.get("model_name", "Kronos-base"),
+            "context_length": int(model_output.get("context_length", context_len)),
+            "quantiles": [0.1, 0.5, 0.9],
+            "cache_version": CACHE_VERSION,
+            "sample_count": sample_count,
+            "input_semantics": model_output.get("input_semantics", {}),
+            "output_semantics": model_output.get("output_semantics", {}),
+        },
+        "indicators_snapshot": indicators,
+        "_data_list": data_list,
+        "_analysis_bundle": analysis_bundle,
+        "_model_output": model_output,
+        "_cache_origin": cache_origin,
+        "ai_runtime": {
+            "mode": "local_only",
+            "model": str(model_output.get("model_name", "Kronos-base")),
+            "device": forecaster.device,
+        },
+    }
+
+
+def _build_raw_close_bundle(
+    model_output: Dict[str, Any],
+    last_close: float,
+) -> Dict[str, Any]:
+    """Build the close-path bundle directly from raw Kronos output."""
+    raw_p10 = np.array(model_output["p10"], dtype=float)
+    raw_p50 = np.array(model_output["p50"], dtype=float)
+    raw_p90 = np.array(model_output["p90"], dtype=float)
+
+    path_metrics = _forecast_path_metrics(raw_p50, last_close)
+    avg_band_pct = float(
+        np.mean((raw_p90 - raw_p10) / np.maximum(np.abs(raw_p50), 1e-8)) * 100.0
+    ) if len(raw_p50) else 0.0
+    band_certainty = math.exp(-avg_band_pct / 4.0)
+    path_consistency = path_metrics["path_consistency"] / 100.0
+    monotonicity = path_metrics["monotonicity"] / 100.0
+    move_pct = abs(path_metrics["final_return_pct"])
+
+    confidence = (
+        28.0
+        + band_certainty * 34.0
+        + path_consistency * 18.0
+        + monotonicity * 12.0
+        + min(move_pct, 4.0) * 2.0
+    )
+    confidence = max(20.0, min(95.0, confidence))
+
+    final_sign = 0 if abs(path_metrics["final_return_pct"]) < 0.05 else (1 if path_metrics["final_return_pct"] > 0 else -1)
+    weighted_sign = 0 if abs(path_metrics["weighted_return_pct"]) < 0.05 else (1 if path_metrics["weighted_return_pct"] > 0 else -1)
+    agreement = final_sign == 0 or weighted_sign == 0 or final_sign == weighted_sign
+
+    return {
+        "p10": raw_p10,
+        "p50": raw_p50,
+        "p90": raw_p90,
+        "model_weight": 1.0,
+        "anchor_weight": 0.0,
+        "agreement": agreement,
+        "scale": 1.0,
+        "confidence": round(confidence, 2),
+        "model_bias_pct": 0.0,
+        "path_metrics": path_metrics,
+        "mode": "raw_kronos_ohlc4",
+    }
+
+
+async def _finalize_forecast_response_payload(payload: Dict[str, Any]) -> Dict[str, Any]:
+    if payload.get("error"):
+        response = {
+            "symbol": payload["symbol"],
+            "interval": payload["interval"],
+            "forecast": payload.get("forecast_rows", []),
+            "error": payload["error"],
+            "path_checked": payload.get("path_checked", KRONOS_PATH),
+            "display": {
+                "mode": "raw_kronos_ohlc4_line",
+                "channels": ["ohlc4"],
+                "output_mode": "single_future_ohlc4_line",
+                "uncertainty_source": "raw_kronos_ohlc4_quantiles",
+                "uses_anchor_blending": False,
+            },
+            "ai_runtime": payload.get("ai_runtime", {"mode": "local_only", "model": "offline"}),
+        }
+        return make_json_compatible(response)
+
+    analysis_bundle = payload["_analysis_bundle"]
+    analysis = await asyncio.to_thread(
+        _build_trade_analysis,
+        symbol=payload["symbol"],
+        interval=payload["interval"],
+        data=payload["_data_list"],
+        indicators=payload["indicators_snapshot"],
+        forecast_rows=payload["forecast_rows"],
+        confidence=float(analysis_bundle.get("confidence", 50.0)),
+        source=payload["source"],
+        blended=analysis_bundle,
+    )
+
+    response = {
+        "symbol": payload["symbol"],
+        "interval": payload["interval"],
+        "source": payload["source"],
+        "horizon": payload["horizon"],
+        "last_close": payload["last_close"],
+        "forecast": payload["forecast_rows"],
+        "from_persistent_cache": payload.get("from_persistent_cache", False),
+        "model": payload["model"],
+        "display": {
+            "mode": "raw_kronos_ohlc4_line",
+            "channels": ["ohlc4"],
+            "output_mode": "single_future_ohlc4_line",
+            "uncertainty_source": "raw_kronos_ohlc4_quantiles",
+            "uses_anchor_blending": False,
+        },
+        "ensemble": {
+            "mode": "raw_kronos_ohlc4",
+            "model_weight": analysis_bundle["model_weight"],
+            "anchor_weight": analysis_bundle["anchor_weight"],
+            "trend_agreement": analysis_bundle["agreement"],
+            "confidence": analysis_bundle["confidence"],
+            "model_bias_pct": analysis_bundle["model_bias_pct"],
+            "alignment_scale": analysis_bundle["scale"],
+            "used_for_display": True,
+        },
+        "model_diagnostics": {
+            "raw_last_p10": round(float(payload["_model_output"]["p10"][-1]), 6),
+            "raw_last_p50": round(float(payload["_model_output"]["p50"][-1]), 6),
+            "raw_last_p90": round(float(payload["_model_output"]["p90"][-1]), 6),
+            "display_last_p50": round(float(analysis_bundle["p50"][-1]), 6),
+        },
+        "indicators_snapshot": payload["indicators_snapshot"],
+        "analysis": analysis,
+        "generated_at": int(time.time()),
+        "cache": {
+            "origin": payload["_cache_origin"],
+            "refresh_requested": False,
+        },
+        "ai_runtime": payload["ai_runtime"],
+    }
+
+    return make_json_compatible(response)
+
+
 # ── Forecast ──────────────────────────────────────────────────────────────────
 @app.get("/api/forecast/{symbol}")
 async def get_forecast(
@@ -4416,23 +5501,13 @@ async def get_forecast(
     if interval not in SUPPORTED_INTERVALS:
         raise HTTPException(400, f"Unsupported interval: {interval}")
 
-    prefix = _cache_prefix(symbol, interval)
-    cache_key = f"forecast_{prefix}{horizon}"
+    cache_key = _forecast_cache_key(symbol, interval, horizon)
     cache_origin = "live"
 
     if not refresh:
-        cached = forecast_cache.get(cache_key)
+        cached = _load_cached_forecast_response(cache_key, interval)
         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"
@@ -4443,130 +5518,14 @@ async def get_forecast(
         return await inflight_task
 
     async def _build_forecast_response() -> Dict[str, Any]:
-        data_list, source, indicators = await get_indicators_cached(
-            symbol,
-            interval,
-            FORECAST_CONTEXT,
-            refresh=refresh,
-            min_context=FORECAST_CONTEXT,
-        )
-        if not KRONOS_AVAILABLE:
-            return {
-                "symbol": symbol,
-                "interval": interval,
-                "forecast": [],
-                "error": "AI Forecaster is currently offline or not found in bundle.",
-                "path_checked": KRONOS_PATH,
-                "ai_runtime": {"mode": "local_only", "model": "offline"},
-            }
-
-        if len(data_list) < 40:
-            raise HTTPException(422, "Insufficient historical data for forecasting")
-
-        df_hist = pd.DataFrame(data_list)
-        df_hist["timestamps"] = pd.to_datetime(df_hist["time"], unit="s", utc=True)
-
-        if "amount" not in df_hist.columns or df_hist["amount"].isna().all() or df_hist["amount"].sum() == 0:
-            typical = (df_hist["high"] + df_hist["low"] + df_hist["close"]) / 3
-            df_hist["amount"] = (df_hist["volume"] * typical).fillna(0)
-        else:
-            df_hist["amount"] = df_hist["amount"].fillna(0)
-
-        context_len = min(len(df_hist), KronosForecaster.MAX_CONTEXT)
-        df_context = df_hist.tail(context_len).reset_index(drop=True)
-
-        logger.info("[forecast] %s %s | ctx=%d/%d | horizon=%d", symbol, interval, context_len, len(df_hist), horizon)
-
-        last_time = int(df_hist["time"].iloc[-1])
-        step = STEP_SECONDS[interval]
-        y_timestamps = pd.Series(pd.to_datetime(
-            [last_time + step * (i + 1) for i in range(horizon)], unit="s", utc=True
-        ))
-
-        sample_count = 10 if forecaster.device in {"not_loaded", "cpu"} else 15
-        model_output = await forecaster.forecast(
-            df=df_context[["open", "high", "low", "close", "volume", "amount"]],
-            x_timestamp=df_context["timestamps"],
-            y_timestamp=y_timestamps,
-            horizon=horizon,
-            sample_count=sample_count,
-        )
-
-        last_close = float(df_hist["close"].iloc[-1])
-        anchor_output = _build_anchor_forecast(data_list, indicators, horizon, interval)
-        blended = _blend_forecasts(last_close, model_output, anchor_output, indicators)
-
-        logger.info(
-            "[forecast] ensemble | %s %s | model_weight=%.2f anchor_weight=%.2f confidence=%.1f agreement=%s",
-            symbol,
-            interval,
-            blended["model_weight"],
-            blended["anchor_weight"],
-            blended["confidence"],
-            blended["agreement"],
-        )
-
-        forecast_rows: List[Dict[str, Any]] = [
-            {"time": last_time, "p10": last_close, "p50": last_close, "p90": last_close, "is_actual": True}
-        ]
-        for i in range(horizon):
-            forecast_rows.append({
-                "time": int(last_time + step * (i + 1)),
-                "p10": round(float(blended["p10"][i]), 6),
-                "p50": round(float(blended["p50"][i]), 6),
-                "p90": round(float(blended["p90"][i]), 6),
-            })
-
-        analysis = await asyncio.to_thread(
-            _build_trade_analysis,
+        payload = await _prepare_forecast_response_payload(
             symbol=symbol,
             interval=interval,
-            data=data_list,
-            indicators=indicators,
-            forecast_rows=forecast_rows,
-            confidence=float(blended["confidence"]),
-            source=source,
-            blended=blended,
+            horizon=horizon,
+            refresh=refresh,
+            cache_origin=cache_origin,
         )
-
-        response = {
-            "symbol": symbol,
-            "interval": interval,
-            "source": source,
-            "horizon": horizon,
-            "last_close": last_close,
-            "forecast": forecast_rows,
-            "from_persistent_cache": False,
-            "model": {
-                "name": model_output.get("model_name", "Kronos-base"),
-                "context_length": int(model_output.get("context_length", context_len)),
-                "quantiles": [0.1, 0.5, 0.9],
-                "cache_version": CACHE_VERSION,
-                "sample_count": sample_count,
-            },
-            "ensemble": {
-                "mode": "kronos_plus_anchor",
-                "model_weight": blended["model_weight"],
-                "anchor_weight": blended["anchor_weight"],
-                "trend_agreement": blended["agreement"],
-                "confidence": blended["confidence"],
-                "model_bias_pct": blended["model_bias_pct"],
-                "alignment_scale": blended["scale"],
-            },
-            "indicators_snapshot": indicators,
-            "analysis": analysis,
-            "generated_at": int(time.time()),
-            "cache": {
-                "origin": cache_origin,
-                "refresh_requested": refresh,
-            },
-            "ai_runtime": {
-                "mode": "local_only",
-                "model": str(model_output.get("model_name", "Kronos-base")),
-                "device": forecaster.device,
-            },
-        }
-        response = make_json_compatible(response)
+        response = await _finalize_forecast_response_payload(payload)
         forecast_cache.set(cache_key, response, ttl_seconds=forecast_ttl(interval))
         persistent_cache.set(cache_key, response, ttl=forecast_ttl(interval) * 4)
         return response
@@ -4699,48 +5658,6 @@ async def get_ai_rules() -> Dict[str, Any]:
     return ai_rule_registry.snapshot()
 
 
-async def fetch_gemini_analysis(prompt: str, system_instruction: Optional[str] = None) -> str:
-    """Fetch AI analysis from Google Gemini."""
-    if not settings.gemini_api_key:
-        return "Gemini API key is not configured."
-    
-    url = "https://generativelanguage.googleapis.com/v1beta/models/gemini-flash-latest:generateContent"
-    headers = {"Content-Type": "application/json"}
-    payload = {
-        "contents": [{"parts": [{"text": prompt}]}]
-    }
-    if system_instruction:
-        payload["system_instruction"] = {
-            "parts": [{"text": system_instruction}]
-        }
-    
-    try:
-        client = await GlobalHTTPClient.get_client()
-        resp = await client.post(
-            url,
-            headers=headers,
-            params={"key": settings.gemini_api_key},
-            json=payload,
-            timeout=30.0,
-        )
-        if resp.status_code != 200:
-            if logger.error("[Gemini] Error: %d - %s", resp.status_code, resp.text) is None:
-                return "Phân tích AI không khả dụng"
-        
-        if True:
-            data = resp.json()
-            candidates = data.get("candidates", [])
-            if candidates and candidates[0].get("content", {}).get("parts"):
-                text = candidates[0]["content"]["parts"][0].get("text", "").strip()
-                # Ensure we only return the verdict text if it's a verdict call
-                # 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 e:
-        logger.error("[Gemini] Exception: %s", e, exc_info=True)
-        return "Lỗi phân tích AI"
-
-
 @app.get("/api/metrics")
 async def get_metrics(request: Request):
     """Export Prometheus-ready metrics (latencies, cache hits, CB states)."""
@@ -4842,6 +5759,23 @@ if os.path.exists(FRONTEND_PATH):
     INDEX_PATH = os.path.join(FRONTEND_PATH, "index.html")
     AIBG_PATH = os.path.join(FRONTEND_PATH, "AIBG.png")
     FAVICON_PATH = os.path.join(FRONTEND_PATH, "favicon.svg")
+    WORKSPACE_JS_PATH = os.path.join(FRONTEND_PATH, "workspace.js")
+    WORKSPACE_CSS_PATH = os.path.join(FRONTEND_PATH, "workspace.css")
+
+    def _frontend_asset_headers() -> Dict[str, str]:
+        return {
+            "Cache-Control": "no-store, no-cache, must-revalidate, max-age=0",
+            "Pragma": "no-cache",
+            "Expires": "0",
+        }
+
+    def _frontend_asset_version() -> str:
+        asset_paths = [INDEX_PATH, WORKSPACE_JS_PATH, WORKSPACE_CSS_PATH]
+        version_parts: List[str] = [APP_VERSION, CACHE_VERSION]
+        for asset_path in asset_paths:
+            if os.path.exists(asset_path):
+                version_parts.append(str(int(os.path.getmtime(asset_path))))
+        return "-".join(version_parts)
 
     @app.get("/", include_in_schema=False)
     @app.get("/index.html", include_in_schema=False)
@@ -4850,13 +5784,32 @@ if os.path.exists(FRONTEND_PATH):
             raise HTTPException(status_code=404, detail="Frontend index not found")
 
         html = Path(INDEX_PATH).read_text(encoding="utf-8")
-        headers = {
-            "Cache-Control": "no-store, no-cache, must-revalidate, max-age=0",
-            "Pragma": "no-cache",
-            "Expires": "0",
-        }
+        html = html.replace("__FRONTEND_ASSET_VERSION__", _frontend_asset_version())
+        headers = _frontend_asset_headers()
         return HTMLResponse(content=html, headers=headers)
 
+    @app.get("/workspace.js", include_in_schema=False)
+    async def serve_workspace_js() -> FileResponse:
+        if not os.path.exists(WORKSPACE_JS_PATH):
+            raise HTTPException(status_code=404, detail="Workspace JS asset not found")
+
+        return FileResponse(
+            WORKSPACE_JS_PATH,
+            media_type="application/javascript",
+            headers=_frontend_asset_headers(),
+        )
+
+    @app.get("/workspace.css", include_in_schema=False)
+    async def serve_workspace_css() -> FileResponse:
+        if not os.path.exists(WORKSPACE_CSS_PATH):
+            raise HTTPException(status_code=404, detail="Workspace CSS asset not found")
+
+        return FileResponse(
+            WORKSPACE_CSS_PATH,
+            media_type="text/css",
+            headers=_frontend_asset_headers(),
+        )
+
     @app.get("/AIBG.png", include_in_schema=False)
     async def serve_aibg() -> FileResponse:
         if not os.path.exists(AIBG_PATH):
@@ -4865,11 +5818,7 @@ if os.path.exists(FRONTEND_PATH):
         return FileResponse(
             AIBG_PATH,
             media_type="image/png",
-            headers={
-                "Cache-Control": "no-store, no-cache, must-revalidate, max-age=0",
-                "Pragma": "no-cache",
-                "Expires": "0",
-            },
+            headers=_frontend_asset_headers(),
         )
 
     @app.get("/favicon.svg", include_in_schema=False)
@@ -4881,11 +5830,7 @@ if os.path.exists(FRONTEND_PATH):
         return FileResponse(
             FAVICON_PATH,
             media_type="image/svg+xml",
-            headers={
-                "Cache-Control": "no-store, no-cache, must-revalidate, max-age=0",
-                "Pragma": "no-cache",
-                "Expires": "0",
-            },
+            headers=_frontend_asset_headers(),
         )
 
     app.mount("/", StaticFiles(directory=FRONTEND_PATH, html=True), name="frontend")

backend/test_api_regressions.py

@@ -1,11 +1,13 @@
 from __future__ import annotations
 
+import asyncio
 import os
 import tempfile
 import unittest
 from unittest.mock import patch
 
 from fastapi.testclient import TestClient
+from fastapi import HTTPException
 
 import backend.main as main
 
@@ -75,6 +77,48 @@ class ApiRegressionTests(unittest.TestCase):
         self.assertIn("X-Request-ID", response.headers)
         self.assertIn("X-Response-Time-Ms", response.headers)
 
+    def test_real_strength_catalog_groups_dxy_usdx_and_strength_indexes(self) -> None:
+        response = self.client.get("/api/symbols")
+        self.assertEqual(response.status_code, 200)
+        body = response.json()
+        self.assertIn("Real Strength", body["categories"])
+        symbols = {entry["symbol"]: entry for entry in body["symbols"]}
+        for symbol in ["DXY", "USDX", "EURX", "GBPX", "CHFX", "JPYX", "CADX", "AUDX", "NZDX"]:
+            self.assertIn(symbol, symbols)
+            self.assertEqual(symbols[symbol]["category"], "Real Strength")
+        for symbol in ["USDX", "EURX", "GBPX", "CHFX", "JPYX", "CADX", "AUDX", "NZDX"]:
+            self.assertEqual(symbols[symbol]["sources"], ["synthetic"])
+        self.assertEqual(symbols["DXY"]["sources"], ["twelvedata", "yfinance"])
+
+    def test_forex_source_priority_excludes_binance(self) -> None:
+        self.assertEqual(main._get_source_priority("EURUSD"), ["twelvedata", "yfinance"])
+        self.assertNotIn("binance", main._get_source_priority("EURUSD"))
+        self.assertEqual(main._get_source_priority("DXY"), ["yfinance", "twelvedata"])
+
+    def test_historical_fetch_falls_back_after_provider_http_error(self) -> None:
+        sample_rows = [
+            {"time": i, "open": 1.0, "high": 1.1, "low": 0.9, "close": 1.0, "volume": 0.0}
+            for i in range(1, 41)
+        ]
+
+        async def fake_twelvedata(symbol: str, interval: str, limit: int) -> list[dict[str, float]]:
+            raise HTTPException(status_code=429, detail="rate limit")
+
+        async def fake_yfinance(symbol: str, interval: str, limit: int) -> list[dict[str, float]]:
+            return sample_rows[-limit:]
+
+        with patch.object(main, "fetch_twelvedata", side_effect=fake_twelvedata), patch.object(
+            main,
+            "fetch_yfinance",
+            side_effect=fake_yfinance,
+        ):
+            rows, source = asyncio.run(
+                main._run_historical_fetch("EURUSD", "1d", 40, "hist_eurusd_1d_test")
+            )
+
+        self.assertEqual(source, "yfinance")
+        self.assertEqual(len(rows), 40)
+
     def test_clear_all_cache_rejects_unknown_target(self) -> None:
         with patch.object(main, "ADMIN_TOKEN", "test-admin-token"):
             response = self.client.delete(
@@ -197,6 +241,348 @@ class ApiRegressionTests(unittest.TestCase):
         self.assertEqual(summary["components"]["ai_weight"], 0.4)
         self.assertEqual(summary["components"]["technical_weight"], 0.6)
 
+    def test_synthetic_component_candles_support_product_and_ratio(self) -> None:
+        product = main._combine_component_candles(
+            main.SyntheticComponentSpec(name="EURCAD", mode="product", left_symbol="EURUSD", right_symbol="USDCAD"),
+            {"open": 1.1, "high": 1.2, "low": 1.0, "close": 1.15},
+            {"open": 1.3, "high": 1.4, "low": 1.2, "close": 1.35},
+        )
+        ratio = main._combine_component_candles(
+            main.SyntheticComponentSpec(name="EURAUD", mode="ratio", left_symbol="EURUSD", right_symbol="AUDUSD"),
+            {"open": 1.1, "high": 1.2, "low": 1.0, "close": 1.15},
+            {"open": 0.7, "high": 0.8, "low": 0.6, "close": 0.75},
+        )
+        inverse = main._combine_component_candles(
+            main.SyntheticComponentSpec(name="EURGBP", mode="inverse", left_symbol="EURGBP"),
+            {"open": 0.85, "high": 0.86, "low": 0.84, "close": 0.855},
+        )
+
+        self.assertAlmostEqual(product["open"], 1.43, places=6)
+        self.assertAlmostEqual(product["high"], 1.68, places=6)
+        self.assertAlmostEqual(product["low"], 1.2, places=6)
+        self.assertAlmostEqual(ratio["open"], 1.5714285714, places=6)
+        self.assertAlmostEqual(ratio["high"], 2.0, places=6)
+        self.assertAlmostEqual(ratio["low"], 1.25, places=6)
+        self.assertAlmostEqual(inverse["open"], 1 / 0.85, places=6)
+        self.assertAlmostEqual(inverse["high"], 1 / 0.84, places=6)
+        self.assertAlmostEqual(inverse["low"], 1 / 0.86, places=6)
+
+    def test_synthetic_component_candles_use_body_only_extrema_for_intraday_product_and_ratio(self) -> None:
+        direct = main._combine_component_candles(
+            main.SyntheticComponentSpec(name="EURUSD", mode="direct", left_symbol="EURUSD"),
+            {"open": 1.1, "high": 1.2, "low": 1.0, "close": 1.15},
+            use_body_only_extrema=True,
+        )
+        inverse = main._combine_component_candles(
+            main.SyntheticComponentSpec(name="EURGBP", mode="inverse", left_symbol="EURGBP"),
+            {"open": 0.85, "high": 0.86, "low": 0.84, "close": 0.855},
+            use_body_only_extrema=True,
+        )
+        product = main._combine_component_candles(
+            main.SyntheticComponentSpec(name="EURCAD", mode="product", left_symbol="EURUSD", right_symbol="USDCAD"),
+            {"open": 1.1, "high": 1.2, "low": 1.0, "close": 1.15},
+            {"open": 1.3, "high": 1.4, "low": 1.2, "close": 1.35},
+            use_body_only_extrema=True,
+        )
+        ratio = main._combine_component_candles(
+            main.SyntheticComponentSpec(name="EURAUD", mode="ratio", left_symbol="EURUSD", right_symbol="AUDUSD"),
+            {"open": 1.1, "high": 1.2, "low": 1.0, "close": 1.15},
+            {"open": 0.7, "high": 0.8, "low": 0.6, "close": 0.75},
+            use_body_only_extrema=True,
+        )
+
+        self.assertAlmostEqual(direct["open"], 1.1, places=6)
+        self.assertAlmostEqual(direct["close"], 1.15, places=6)
+        self.assertAlmostEqual(direct["high"], 1.15, places=6)
+        self.assertAlmostEqual(direct["low"], 1.1, places=6)
+        self.assertAlmostEqual(inverse["open"], 1 / 0.85, places=6)
+        self.assertAlmostEqual(inverse["close"], 1 / 0.855, places=6)
+        self.assertAlmostEqual(inverse["high"], 1 / 0.85, places=6)
+        self.assertAlmostEqual(inverse["low"], 1 / 0.855, places=6)
+        self.assertAlmostEqual(product["open"], 1.43, places=6)
+        self.assertAlmostEqual(product["close"], 1.5525, places=6)
+        self.assertAlmostEqual(product["high"], 1.5525, places=6)
+        self.assertAlmostEqual(product["low"], 1.43, places=6)
+        self.assertAlmostEqual(ratio["open"], 1.5714285714, places=6)
+        self.assertAlmostEqual(ratio["close"], 1.5333333333, places=6)
+        self.assertAlmostEqual(ratio["high"], 1.5714285714, places=6)
+        self.assertAlmostEqual(ratio["low"], 1.5333333333, places=6)
+
+    def test_synthetic_eurx_history_builds_from_component_series(self) -> None:
+        base_rows = {
+            "EURUSD": [
+                {"time": 1, "open": 1.10, "high": 1.11, "low": 1.09, "close": 1.105, "volume": 100.0},
+                {"time": 2, "open": 1.11, "high": 1.12, "low": 1.10, "close": 1.115, "volume": 100.0},
+                {"time": 3, "open": 1.12, "high": 1.13, "low": 1.11, "close": 1.125, "volume": 100.0},
+            ],
+            "EURGBP": [
+                {"time": 1, "open": 0.85, "high": 0.86, "low": 0.84, "close": 0.855, "volume": 100.0},
+                {"time": 2, "open": 0.855, "high": 0.865, "low": 0.845, "close": 0.86, "volume": 100.0},
+                {"time": 3, "open": 0.86, "high": 0.87, "low": 0.85, "close": 0.865, "volume": 100.0},
+            ],
+            "USDCHF": [
+                {"time": 1, "open": 0.90, "high": 0.91, "low": 0.89, "close": 0.905, "volume": 100.0},
+                {"time": 2, "open": 0.905, "high": 0.915, "low": 0.895, "close": 0.91, "volume": 100.0},
+                {"time": 3, "open": 0.91, "high": 0.92, "low": 0.90, "close": 0.915, "volume": 100.0},
+            ],
+            "EURJPY": [
+                {"time": 1, "open": 160.0, "high": 161.0, "low": 159.0, "close": 160.5, "volume": 100.0},
+                {"time": 2, "open": 160.5, "high": 161.5, "low": 159.5, "close": 161.0, "volume": 100.0},
+                {"time": 3, "open": 161.0, "high": 162.0, "low": 160.0, "close": 161.5, "volume": 100.0},
+            ],
+            "USDCAD": [
+                {"time": 1, "open": 1.35, "high": 1.36, "low": 1.34, "close": 1.355, "volume": 100.0},
+                {"time": 2, "open": 1.355, "high": 1.365, "low": 1.345, "close": 1.36, "volume": 100.0},
+                {"time": 3, "open": 1.36, "high": 1.37, "low": 1.35, "close": 1.365, "volume": 100.0},
+            ],
+            "AUDUSD": [
+                {"time": 1, "open": 0.66, "high": 0.67, "low": 0.65, "close": 0.665, "volume": 100.0},
+                {"time": 2, "open": 0.665, "high": 0.675, "low": 0.655, "close": 0.67, "volume": 100.0},
+                {"time": 3, "open": 0.67, "high": 0.68, "low": 0.66, "close": 0.675, "volume": 100.0},
+            ],
+            "NZDUSD": [
+                {"time": 1, "open": 0.61, "high": 0.62, "low": 0.60, "close": 0.615, "volume": 100.0},
+                {"time": 2, "open": 0.615, "high": 0.625, "low": 0.605, "close": 0.62, "volume": 100.0},
+                {"time": 3, "open": 0.62, "high": 0.63, "low": 0.61, "close": 0.625, "volume": 100.0},
+            ],
+        }
+
+        async def fake_fetch_from_source(
+            source: str,
+            symbol: str,
+            interval: str,
+            limit: int,
+        ) -> tuple[list[dict[str, float]], str]:
+            self.assertIn(source, {"twelvedata", "finnhub", "yfinance"})
+            return base_rows[symbol][-limit:]
+
+        with patch.object(main, "_fetch_historical_from_source", side_effect=fake_fetch_from_source):
+            rows, source = asyncio.run(
+                main._build_synthetic_symbol_history("EURX", "1h", 3, "test-cache-key")
+            )
+
+        self.assertEqual(len(rows), 3)
+        self.assertEqual(rows[-1]["time"], 3)
+        self.assertEqual(rows[-1]["volume"], 0.0)
+        self.assertEqual(source, "synthetic:twelvedata")
+        self.assertGreater(rows[-1]["close"], 0.0)
+
+    def test_synthetic_ticker_uses_requested_interval_instead_of_forcing_5m(self) -> None:
+        calls: list[tuple[str, str, int, int]] = []
+
+        async def fake_fetch_historical(
+            symbol: str,
+            interval: str,
+            limit: int,
+            min_context: int = 0,
+            **_: object,
+        ) -> tuple[list[dict[str, float]], str]:
+            calls.append((symbol, interval, limit, min_context))
+            rows = [
+                {"time": 1, "open": 1.0, "high": 1.1, "low": 0.9, "close": 1.0, "volume": 0.0},
+                {"time": 2, "open": 1.0, "high": 1.2, "low": 0.95, "close": 1.1, "volume": 0.0},
+            ]
+            return rows, "synthetic:test"
+
+        with patch.object(main, "fetch_historical", side_effect=fake_fetch_historical):
+            ticker = asyncio.run(main.fetch_ticker("CHFX", interval="1d"))
+
+        self.assertEqual(ticker["symbol"], "CHFX")
+        self.assertEqual(calls, [("CHFX", "1d", 2, 2)])
+
+    def test_synthetic_history_uses_single_source_and_requested_interval(self) -> None:
+        calls: list[tuple[str, str, str, int]] = []
+
+        async def fake_fetch_from_source(
+            source: str,
+            symbol: str,
+            interval: str,
+            limit: int,
+        ) -> list[dict[str, float]]:
+            calls.append((source, symbol, interval, limit))
+            return [
+                {"time": 1, "open": 1.0, "high": 1.1, "low": 0.9, "close": 1.0, "volume": 0.0},
+                {"time": 2, "open": 1.0, "high": 1.2, "low": 0.95, "close": 1.1, "volume": 0.0},
+                {"time": 3, "open": 1.1, "high": 1.25, "low": 1.0, "close": 1.15, "volume": 0.0},
+            ]
+
+        with patch.object(main, "_fetch_historical_from_source", side_effect=fake_fetch_from_source):
+            rows, source = asyncio.run(
+                main._build_synthetic_symbol_history("CHFX", "4h", 3, "synthetic-chfx-4h")
+            )
+
+        self.assertEqual(len(rows), 3)
+        self.assertEqual(source, "synthetic:twelvedata")
+        self.assertTrue(calls)
+        self.assertEqual({item[0] for item in calls}, {"twelvedata"})
+        self.assertEqual({item[2] for item in calls}, {"4h"})
+
+    def test_kronos_feature_prep_collapses_prices_to_ohlc4_and_zeroes_volume_channels(self) -> None:
+        df = main.pd.DataFrame(
+            [
+                {"open": 1.0, "high": 1.1, "low": 0.9, "close": 1.05, "volume": 0.0, "amount": 0.0},
+                {"open": 1.05, "high": 1.15, "low": 0.95, "close": 1.1, "volume": 0.0, "amount": 0.0},
+            ]
+        )
+
+        prepared = main.KronosForecaster._prepare_feature_frame(df)
+        expected_ohlc4 = df[["open", "high", "low", "close"]].mean(axis=1).astype(main.np.float32)
+
+        self.assertEqual(list(prepared.columns), ["ohlc4"])
+        self.assertTrue(main.np.allclose(prepared["ohlc4"].values, expected_ohlc4.values))
+
+    def test_kronos_feature_prep_ignores_upstream_volume_and_amount_noise(self) -> None:
+        df = main.pd.DataFrame(
+            [
+                {"open": 10.0, "high": 11.0, "low": 9.0, "close": 10.5, "volume": 100.0, "amount": 1050.0},
+                {"open": 11.0, "high": 12.0, "low": 10.0, "close": 11.5, "volume": 200.0, "amount": 2300.0},
+            ]
+        )
+
+        prepared = main.KronosForecaster._prepare_feature_frame(df)
+        expected_ohlc4 = df[["open", "high", "low", "close"]].mean(axis=1).astype(main.np.float32)
+
+        self.assertEqual(list(prepared.columns), ["ohlc4"])
+        self.assertTrue(main.np.allclose(prepared["ohlc4"].values, expected_ohlc4.values))
+
+    def test_kronos_normalization_uses_std_plus_epsilon_contract(self) -> None:
+        x = main.np.array(
+            [
+                [1.0, 1.1, 0.9, 1.0, 0.0, 0.0],
+                [1.1, 1.2, 1.0, 1.1, 0.0, 0.0],
+                [1.2, 1.3, 1.1, 1.2, 0.0, 0.0],
+            ],
+            dtype=main.np.float32,
+        )
+
+        x_norm, x_mean, x_scale = main.KronosForecaster._normalize_feature_matrix(x, clip=5.0)
+
+        expected_scale = main.np.std(x, axis=0).astype(main.np.float32) + 1e-5
+        expected_norm = main.np.clip((x - x_mean) / expected_scale, -5.0, 5.0)
+
+        self.assertTrue(main.np.allclose(x_scale, expected_scale))
+        self.assertTrue(main.np.allclose(x_norm, expected_norm))
+
+    def test_forecast_payload_schema_guard_rejects_legacy_blended_payload(self) -> None:
+        legacy_payload = {
+            "forecast": [{"time": 1, "p10": 1.0, "p50": 1.1, "p90": 1.2}],
+            "forecast_candles": [],
+            "display": {"mode": "raw_kronos_ohlc_p50"},
+            "ensemble": {"mode": "kronos_plus_anchor", "confidence": 55.0},
+            "model": {
+                "input_semantics": {
+                    "feature_channels": ["open", "high", "low", "close", "volume", "amount"],
+                    "price_mode": "ohlc4_replicated_across_ohlc",
+                    "base_signal": "ohlc4",
+                    "volume_mode": "forced_zero",
+                    "amount_mode": "forced_zero",
+                    "active_forecast_channels": ["ohlc4"],
+                }
+            },
+        }
+        self.assertFalse(main._forecast_payload_is_current(legacy_payload))
+
+    def test_forecast_payload_schema_guard_accepts_current_ohlc4_input_mode(self) -> None:
+        current_payload = {
+            "forecast": [{"time": 1, "p10": 1.0, "p50": 1.1, "p90": 1.2}],
+            "display": {
+                "mode": "raw_kronos_ohlc4_line",
+                "channels": ["ohlc4"],
+                "output_mode": "single_future_ohlc4_line",
+            },
+            "model": {
+                "input_semantics": {
+                    "feature_channels": ["ohlc4"],
+                    "price_mode": "ohlc4_single_channel",
+                    "base_signal": "ohlc4",
+                    "volume_mode": "omitted",
+                    "amount_mode": "omitted",
+                    "active_forecast_channels": ["ohlc4"],
+                    "adapter_mode": "tokenizer_6ch_to_1ch_ohlc4",
+                },
+                "output_semantics": {
+                    "forecast_channel": "ohlc4",
+                    "forecast_mode": "single_future_ohlc4_line",
+                    "candle_projection": "omitted",
+                }
+            },
+        }
+        self.assertTrue(main._forecast_payload_is_current(current_payload))
+
+    def test_forecast_payload_schema_guard_rejects_legacy_forecast_candles_field(self) -> None:
+        stale_payload = {
+            "forecast": [{"time": 1, "p10": 1.0, "p50": 1.1, "p90": 1.2}],
+            "forecast_candles": [],
+            "display": {
+                "mode": "raw_kronos_ohlc4_line",
+                "channels": ["ohlc4"],
+                "output_mode": "single_future_ohlc4_line",
+            },
+            "model": {
+                "input_semantics": {
+                    "feature_channels": ["ohlc4"],
+                    "price_mode": "ohlc4_single_channel",
+                    "base_signal": "ohlc4",
+                    "volume_mode": "omitted",
+                    "amount_mode": "omitted",
+                    "active_forecast_channels": ["ohlc4"],
+                    "adapter_mode": "tokenizer_6ch_to_1ch_ohlc4",
+                },
+                "output_semantics": {
+                    "forecast_channel": "ohlc4",
+                    "forecast_mode": "single_future_ohlc4_line",
+                    "candle_projection": "omitted",
+                },
+            },
+        }
+
+        self.assertFalse(main._forecast_payload_is_current(stale_payload))
+
+    def test_finalize_forecast_error_payload_omits_legacy_forecast_candles_field(self) -> None:
+        payload = {
+            "symbol": self.symbol_a,
+            "interval": "1h",
+            "forecast_rows": [],
+            "error": "offline",
+            "path_checked": "test-path",
+            "ai_runtime": {"mode": "local_only", "model": "offline"},
+        }
+
+        response = asyncio.run(main._finalize_forecast_response_payload(payload))
+
+        self.assertNotIn("forecast_candles", response)
+        self.assertEqual(response["display"]["output_mode"], "single_future_ohlc4_line")
+
+    def test_synthetic_component_history_reuses_source_cache(self) -> None:
+        calls: list[tuple[str, str, str, int]] = []
+
+        async def fake_fetch_from_source(
+            source: str,
+            symbol: str,
+            interval: str,
+            limit: int,
+        ) -> list[dict[str, float]]:
+            calls.append((source, symbol, interval, limit))
+            return [
+                {"time": 1, "open": 1.0, "high": 1.1, "low": 0.9, "close": 1.0, "volume": 0.0},
+                {"time": 2, "open": 1.0, "high": 1.2, "low": 0.95, "close": 1.1, "volume": 0.0},
+                {"time": 3, "open": 1.1, "high": 1.25, "low": 1.0, "close": 1.15, "volume": 0.0},
+            ]
+
+        main.source_history_cache.clear()
+        main._SOURCE_HISTORY_INFLIGHT.clear()
+        try:
+            with patch.object(main, "_fetch_historical_from_source", side_effect=fake_fetch_from_source):
+                asyncio.run(main._build_synthetic_symbol_history("EURX", "1d", 3, "synthetic-eurx-1"))
+                asyncio.run(main._build_synthetic_symbol_history("EURX", "1d", 3, "synthetic-eurx-2"))
+        finally:
+            main.source_history_cache.clear()
+            main._SOURCE_HISTORY_INFLIGHT.clear()
+
+        unique_component_symbols = {item[1] for item in calls}
+        self.assertEqual(len(calls), len(unique_component_symbols))
+        self.assertEqual(unique_component_symbols, {"AUDUSD", "EURGBP", "EURJPY", "EURUSD", "NZDUSD", "USDCAD", "USDCHF"})
+
     def test_ttl_cache_returns_defensive_copy(self) -> None:
         cache = main.TTLCache()
         payload = {"forecast": [{"price": 100.0}], "meta": {"source": "memory"}}

frontend/index.html

@@ -1,4 +1,4 @@
-<!doctype html>
+<!doctype html>
 <html lang="vi">
 
 <head>
@@ -21,6 +21,7 @@
     href="https://fonts.googleapis.com/css2?family=Chakra+Petch:ital,wght@0,400;0,500;0,600;0,700;1,400&family=Barlow:wght@300;400;500;600&family=Space+Mono:wght@400;700&display=swap"
     rel="stylesheet">
   <script src="https://unpkg.com/lightweight-charts@4.2.2/dist/lightweight-charts.standalone.production.js"></script>
+  <link rel="stylesheet" href="/workspace.css?v=__FRONTEND_ASSET_VERSION__">
   <style>
     /* ── Chart Transition (P2) ── */
     #chart {
@@ -3297,6 +3298,31 @@
           </select>
         </div>
 
+        <div class="layout-menu" id="layoutSwitcher">
+          <button class="layout-menu-button" id="layoutMenuBtn" type="button" aria-haspopup="true" aria-expanded="false" title="Chọn bố cục chart">
+            <span>Pane</span>
+            <span class="layout-menu-current" id="layoutMenuCurrent">1</span>
+          </button>
+          <div class="layout-menu-popup" id="layoutMenuPopup">
+            <button class="layout-menu-option active" type="button" data-layout="1" title="1 chart">
+              <strong>1 Pane</strong>
+              <span>Tập trung</span>
+            </button>
+            <button class="layout-menu-option" type="button" data-layout="2" title="2 charts">
+              <strong>2 Pane</strong>
+              <span>So sánh đôi</span>
+            </button>
+            <button class="layout-menu-option" type="button" data-layout="4" title="4 charts">
+              <strong>4 Pane</strong>
+              <span>Quan sát nhóm</span>
+            </button>
+            <button class="layout-menu-option" type="button" data-layout="8" title="8 charts">
+              <strong>8 Pane</strong>
+              <span>Toàn cảnh</span>
+            </button>
+          </div>
+        </div>
+
         <button class="btn-theme" id="themeToggleBtn" title="Chuyển đổi giao diện">
           <svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round"
             stroke-linejoin="round" class="sun-icon">
@@ -3312,7 +3338,7 @@
           </svg>
         </button>
 
-        <button class="btn-primary" id="refreshBtn">Phân tích</button>
+        <button class="btn-primary" id="refreshBtn" hidden aria-hidden="true" tabindex="-1">Phân tích</button>
 
 
         <button class="btn-icon" id="fitBtn" title="Khớp toàn bộ dữ liệu">
@@ -3359,10 +3385,28 @@
         <div class="chart-bg-overlay"></div>
         <div class="chart-logo-overlay">KRONOS AI</div>
 
-        <!-- Chart canvas -->
-        <div id="chart"></div>
+        <!-- Workspace Grid Container -->
+        <div id="workspaceGrid" class="workspace-grid layout-1">
+          <!-- Pane 0 (default) -->
+          <div class="chart-pane active" data-pane-id="pane-0">
+            <div class="pane-header-mini">
+              <span class="pane-symbol">XAUUSD</span>
+              <span class="pane-sep">·</span>
+              <span class="pane-interval">1d</span>
+              <span class="pane-price">--</span>
+            </div>
+            <button class="pane-analysis-btn" type="button" data-pane-analysis="pane-0" data-state="idle" aria-label="Phân tích AI chart hiện tại">
+              <span class="dot"></span>
+              <span>AI</span>
+            </button>
+            <div class="pane-chart" id="chart"></div>
+            <div class="pane-loader hidden"></div>
+            <div class="pane-gauges"></div>
+            <div class="pane-analysis-overlay"></div>
+          </div>
+        </div>
 
-        <!-- Compact Gauges Overlay (v6.0) -->
+        <!-- Compact Gauges Overlay (v6.0) — global, for active pane -->
         <div class="chart-gauges-container" id="chartGauges"></div>
 
         <aside class="analysis-panel hidden" id="analysisPanel"></aside>
@@ -3402,14 +3446,20 @@
     </div>
   </div>
 
+  <!-- ══════════════════════════════════════════════
+       WORKSPACE ENGINE (loaded first)
+  ══════════════════════════════════════════════ -->
+  <script src="/workspace.js?v=__FRONTEND_ASSET_VERSION__"></script>
+
   <!-- ══════════════════════════════════════════════
        JAVASCRIPT — all original logic preserved
   ══════════════════════════════════════════════ -->
   <script>
     const API_BASE = (window.location.origin && window.location.origin !== 'null')
       ? window.location.origin
-      : 'http://127.0.0.1:8000';
+      : '';
     const HEADER_VISIBILITY_KEY = 'kronos_header_visibility';
+    window.__KRONOS_API_BASE = API_BASE;
 
     /* ── DOM refs ──────────────────────────────── */
     /* ── DOM refs ──────────────────────────────── */
@@ -3621,14 +3671,21 @@
       });
     })();
 
-    function connectWS(symbol) {
+    function connectWS(symbol, interval = currentInterval || timeframeSelect.value) {
+      if (window.Workspace && Workspace.layoutPreset > 1) {
+        if (ws) {
+          ws.close();
+          ws = null;
+        }
+        return;
+      }
       if (ws) {
         ws.close();
         ws = null;
       }
 
       const wsProtocol = window.location.protocol === 'https:' ? 'wss:' : 'ws:';
-      const wsUrl = `${API_BASE.replace(/^https?:\/\//, wsProtocol)}/ws/price/${symbol}`;
+      const wsUrl = `${API_BASE.replace(/^https?:\/\//, wsProtocol)}/ws/price/${symbol}?interval=${encodeURIComponent(interval)}`;
 
       console.log(`[WS] Connecting to ${wsUrl}`);
       ws = new WebSocket(wsUrl);
@@ -3645,7 +3702,7 @@
 
         // Update current candle if price changed
         const lastCandle = lastCandleData;
-        if (lastCandle && data.price) {
+        if (lastCandle && data.price && shouldMutateRealtimeCandle(symbol)) {
           const update = {
             time: lastCandle.time,
             open: lastCandle.open,
@@ -3663,7 +3720,7 @@
         console.log('[WS] Disconnected');
         // Reconnect after 5s if still active
         setTimeout(() => {
-          if (currentSymbol === symbol) connectWS(symbol);
+          if ((!window.Workspace || Workspace.layoutPreset === 1) && currentSymbol === symbol) connectWS(symbol, interval);
         }, 5000);
       };
     }
@@ -3725,7 +3782,11 @@
     }
 
     /* ── Switch Logic ───────────────────────────── */
-    async function switchSymbol(symbol) {
+    async function switchSymbol(symbol, options = {}) {
+      if (window.Workspace && Workspace.layoutPreset > 1 && !options.forcePrimary) {
+        applySymbolToActivePane(symbol);
+        return;
+      }
       currentSymbol = symbol;
       symbolSearch.value = symbol;
       searchResults.classList.remove('visible');
@@ -3742,6 +3803,156 @@
     /* ── Chart init ────────────────────────────── */
     const chartEl = document.getElementById('chart');
 
+    const CHART_RIGHT_OFFSET = 20;
+    const FORECAST_PALETTE = {
+      up: {
+        line: '#16a34a',
+        lineSoft: 'rgba(22, 163, 74, 0.34)',
+        band: 'rgba(34, 197, 94, 0.34)',
+      },
+      down: {
+        line: '#f87171',
+        lineSoft: 'rgba(248, 113, 113, 0.32)',
+        band: 'rgba(248, 113, 113, 0.28)',
+      },
+      flat: {
+        line: '#eab308',
+        lineSoft: 'rgba(234, 179, 8, 0.34)',
+        band: 'rgba(250, 204, 21, 0.30)',
+      },
+    };
+
+    const LIVE_PRICE_ONLY_SYMBOLS = new Set([
+      'USDX',
+      'EURX',
+      'GBPX',
+      'CHFX',
+      'JPYX',
+      'CADX',
+      'AUDX',
+      'NZDX',
+    ]);
+
+    function shouldMutateRealtimeCandle(symbol) {
+      return !LIVE_PRICE_ONLY_SYMBOLS.has(String(symbol || '').toUpperCase());
+    }
+
+    function applyChartRightOffset(chartInstance, offset = CHART_RIGHT_OFFSET) {
+      if (!chartInstance || typeof chartInstance.timeScale !== 'function') return;
+      try {
+        chartInstance.applyOptions({
+          timeScale: {
+            rightOffset: offset,
+          },
+        });
+        if (typeof chartInstance.timeScale().scrollToPosition === 'function') {
+          chartInstance.timeScale().scrollToPosition(offset, false);
+        }
+      } catch (error) {
+        console.warn('[chart] applyChartRightOffset failed', error);
+      }
+    }
+
+    function fitChartWithOffset(chartInstance, offset = CHART_RIGHT_OFFSET) {
+      if (!chartInstance || typeof chartInstance.timeScale !== 'function') return;
+      chartInstance.timeScale().fitContent();
+      applyChartRightOffset(chartInstance, offset);
+    }
+
+    function getForecastRightOffset(points) {
+      const length = Array.isArray(points) ? points.length : 0;
+      return Math.max(CHART_RIGHT_OFFSET, Math.min(64, 18 + (length * 3)));
+    }
+
+    function getForecastSegmentColor(diff, epsilon = 0.0001) {
+      if (diff > epsilon) return FORECAST_PALETTE.up.line;
+      if (diff < -epsilon) return FORECAST_PALETTE.down.line;
+      return FORECAST_PALETTE.flat.line;
+    }
+
+    function getForecastTone(points) {
+      if (!Array.isArray(points) || points.length < 2) return 'flat';
+      const first = Number(points[0]?.value ?? 0);
+      const last = Number(points[points.length - 1]?.value ?? first);
+      const baseline = Math.max(Math.abs(first), 1);
+      const delta = last - first;
+      const epsilon = baseline * 0.0006;
+      if (delta > epsilon) return 'up';
+      if (delta < -epsilon) return 'down';
+      return 'flat';
+    }
+
+    function buildForecastCandleSeriesOptions(tone = 'flat') {
+      const palette = FORECAST_PALETTE[tone] || FORECAST_PALETTE.flat;
+      return {
+        upColor: tone === 'flat' ? 'rgba(234, 179, 8, 0.50)' : 'rgba(22, 163, 74, 0.50)',
+        downColor: tone === 'flat' ? 'rgba(250, 204, 21, 0.50)' : 'rgba(248, 113, 113, 0.50)',
+        borderVisible: false,
+        wickUpColor: tone === 'flat' ? 'rgba(234, 179, 8, 0.50)' : 'rgba(22, 163, 74, 0.50)',
+        wickDownColor: tone === 'flat' ? 'rgba(250, 204, 21, 0.50)' : 'rgba(248, 113, 113, 0.50)',
+        priceLineVisible: false,
+        lastValueVisible: false,
+        visible: false,
+      };
+    }
+
+    function normalizeForecastCandles(candles) {
+      if (!Array.isArray(candles)) return [];
+      return candles
+        .map((candle) => {
+          const time = Number(candle?.time);
+          const open = Number(candle?.open);
+          const high = Number(candle?.high);
+          const low = Number(candle?.low);
+          const close = Number(candle?.close);
+          if (![time, open, high, low, close].every(Number.isFinite)) return null;
+          const upper = Math.max(open, high, low, close);
+          const lower = Math.min(open, high, low, close);
+          return {
+            time,
+            open,
+            high: upper,
+            low: lower,
+            close,
+          };
+        })
+        .filter(Boolean);
+    }
+
+    function buildForecastClosePath(anchorPoint, candles) {
+      const futurePoints = normalizeForecastCandles(candles).map((candle) => ({
+        time: candle.time,
+        value: candle.close,
+      }));
+      return anchorPoint ? [anchorPoint, ...futurePoints] : futurePoints;
+    }
+
+    function buildForecastLineFromRows(rows, fallbackActualPoint = null) {
+      const points = Array.isArray(rows)
+        ? rows
+          .filter((row) => row && row.time !== undefined && row.p50 !== undefined)
+          .map((row) => ({
+            time: Number(row.time),
+            value: Number(row.p50),
+          }))
+          .filter((point) => Number.isFinite(point.time) && Number.isFinite(point.value))
+        : [];
+
+      if (!fallbackActualPoint) {
+        return points;
+      }
+      if (!points.length) {
+        return [fallbackActualPoint];
+      }
+      if (points[0].time === fallbackActualPoint.time) {
+        return points;
+      }
+      return [fallbackActualPoint, ...points];
+    }
+
+    window.normalizeForecastCandles = normalizeForecastCandles;
+    window.buildForecastLineFromRows = buildForecastLineFromRows;
+
     const chart = LightweightCharts.createChart(chartEl, {
       layout: {
         background: { type: 'solid', color: 'transparent' },
@@ -3764,6 +3975,7 @@
         secondsVisible: false,
         fixLeftEdge: false,
         fixRightEdge: false,
+        rightOffset: CHART_RIGHT_OFFSET,
       },
       crosshair: {
         mode: LightweightCharts.CrosshairMode.Normal,
@@ -3799,6 +4011,8 @@
       wickDownColor: '#e05560',
     });
 
+    const forecastCandleSeries = chart.addCandlestickSeries(buildForecastCandleSeriesOptions());
+
     const p50Series = chart.addLineSeries({
       color: '#66d9ff',
       lineWidth: 2,
@@ -3840,8 +4054,8 @@
         const prev = points[i - 1];
         const curr = points[i];
         const diff = (curr?.value ?? 0) - (prev?.value ?? 0);
-        // Tăng: xanh lá, Giảm: đỏ, Đi ngang: vàng nhạt
-        const color = diff > EPSILON ? '#10b981' : diff < -EPSILON ? '#f43f5e' : '#fef08a';
+        // Tăng: xanh lá rõ hơn, Giảm: đỏ dịu hơn, Đi ngang: vàng
+        const color = getForecastSegmentColor(diff, EPSILON);
         const segSeries = chart.addLineSeries({
           color,
           lineWidth: 2,
@@ -3865,9 +4079,9 @@
     });
 
     /* ── Indicator Series ──────────────────────── */
-    const bbMiddleSeries = chart.addLineSeries({ color: 'rgba(255, 255, 255, 0.2)', lineWidth: 1, priceLineVisible: false, lastValueVisible: false });
-    const bbUpperSeries = chart.addLineSeries({ color: 'rgba(34, 211, 238, 0.3)', lineWidth: 1, priceLineVisible: false, lastValueVisible: false });
-    const bbLowerSeries = chart.addLineSeries({ color: 'rgba(34, 211, 238, 0.3)', lineWidth: 1, priceLineVisible: false, lastValueVisible: false });
+    const bbMiddleSeries = chart.addLineSeries({ color: 'rgba(255, 255, 255, 0.2)', lineWidth: 1, priceLineVisible: false, lastValueVisible: false, visible: false });
+    const bbUpperSeries = chart.addLineSeries({ color: 'rgba(34, 211, 238, 0.3)', lineWidth: 1, priceLineVisible: false, lastValueVisible: false, visible: false });
+    const bbLowerSeries = chart.addLineSeries({ color: 'rgba(34, 211, 238, 0.3)', lineWidth: 1, priceLineVisible: false, lastValueVisible: false, visible: false });
 
     let rsiSeries = null;
 
@@ -3905,6 +4119,22 @@
       }
     }
 
+    function setGlobalStatusVisibility(visible) {
+      const statusWrap = statusPill ? statusPill.closest('.status-wrap') : null;
+      if (!statusWrap) return;
+      statusWrap.style.display = visible ? '' : 'none';
+    }
+
+    function setGlobalCompactGaugesVisibility(visible) {
+      const container = document.getElementById('chartGauges');
+      if (!container) return;
+      container.style.display = visible ? '' : 'none';
+      if (!visible) {
+        container.innerHTML = '';
+        container.classList.remove('combo-active');
+      }
+    }
+
     function dimChartForRefresh() {
       // Show loading placeholder on chart
       const chartContainer = document.getElementById('chart-container');
@@ -4056,6 +4286,7 @@
     function syncChartPriceFormat(symbol, candles = []) {
       currentPriceFormat = resolvePriceFormat(symbol, candles);
       applyPriceFormatToSeries(candleSeries);
+      applyPriceFormatToSeries(forecastCandleSeries);
       applyPriceFormatToSeries(p50Series);
       applyPriceFormatToSeries(p10Series);
       applyPriceFormatToSeries(p90Series);
@@ -4147,11 +4378,21 @@
 
     function renderCompactGauges(symbol, interval, payload) {
       const container = document.getElementById('chartGauges');
-      if (!container || !payload?.analysis) {
-        if (container) {
-          container.innerHTML = '';
-          container.classList.remove('combo-active');
-        }
+      if (!container) {
+        return;
+      }
+
+      if (window.Workspace && Workspace.layoutPreset > 1) {
+        container.innerHTML = '';
+        container.classList.remove('combo-active');
+        container.style.display = 'none';
+        return;
+      }
+
+      container.style.display = '';
+      if (!payload?.analysis) {
+        container.innerHTML = '';
+        container.classList.remove('combo-active');
         return;
       }
 
@@ -4419,12 +4660,14 @@
     }
 
     function setPrimaryForecastVisibility(visible) {
-      p50Series.applyOptions({ visible: false });
-      p10Series.applyOptions({ visible });
-      p90Series.applyOptions({ visible });
+      p50Series.applyOptions({ visible });
+      p10Series.applyOptions({ visible: false });
+      p90Series.applyOptions({ visible: false });
+      forecastCandleSeries.applyOptions({ visible: false });
     }
 
     function clearForecastVisuals() {
+      forecastCandleSeries.setData([]);
       p50Series.setData([]);
       p10Series.setData([]);
       p90Series.setData([]);
@@ -4433,15 +4676,166 @@
       activeForecastContext = { symbol: null, interval: null, ready: false };
     }
 
-    function commitForecastVisuals(symbol, interval, p50, p10, p90) {
+    function clearPrimaryForecastCandlesOnly() {
+      p50Series.setData([]);
+      p10Series.setData([]);
+      p90Series.setData([]);
+      clearForecastSegments();
+      forecastCandleSeries.setData([]);
+      setPrimaryForecastVisibility(false);
+      forecastCandleSeries.applyOptions({
+        ...buildForecastCandleSeriesOptions(),
+        visible: false,
+        priceFormat: buildSeriesPriceFormat(),
+      });
+    }
+
+    function commitForecastVisuals(symbol, interval, forecastLine = []) {
+      const points = Array.isArray(forecastLine) ? forecastLine : [];
+      const tone = getForecastTone(points);
+      const palette = FORECAST_PALETTE[tone] || FORECAST_PALETTE.flat;
+      forecastCandleSeries.setData([]);
+      forecastCandleSeries.applyOptions({
+        ...buildForecastCandleSeriesOptions(tone),
+        visible: false,
+        priceFormat: buildSeriesPriceFormat(),
+      });
+
       p50Series.setData([]);
-      p10Series.setData(p10);
-      p90Series.setData(p90);
-      setPrimaryForecastVisibility(true);
-      buildForecastSegmentSeries(p50);
+      p10Series.setData([]);
+      p90Series.setData([]);
+      clearForecastSegments();
+      p50Series.applyOptions({
+        color: palette.line,
+        lineWidth: 2,
+        priceFormat: buildSeriesPriceFormat(),
+        visible: points.length > 0,
+      });
+      setPrimaryForecastVisibility(points.length > 0);
+      p50Series.setData(points);
+      fitChartWithOffset(chart, getForecastRightOffset(points));
       activeForecastContext = { symbol, interval, ready: true };
     }
 
+    function clearPaneForecastSegments(pane) {
+      if (!pane?.chartInstance) return;
+      const segments = Array.isArray(pane.forecastSeries?.segments) ? pane.forecastSeries.segments : [];
+      if (!segments.length) {
+        if (pane?.forecastSeries) pane.forecastSeries.segments = [];
+        return;
+      }
+      for (const series of segments) {
+        try {
+          pane.chartInstance.removeSeries(series);
+        } catch (error) {
+          console.warn(`[Pane ${pane.paneId}] clear forecast segment failed`, error);
+        }
+      }
+      pane.forecastSeries.segments = [];
+    }
+
+    function clearPaneForecastVisuals(pane) {
+      if (!pane?.forecastSeries) return;
+      clearPaneForecastSegments(pane);
+      if (pane.forecastSeries.p50) {
+        pane.forecastSeries.p50.setData([]);
+        pane.forecastSeries.p50.applyOptions({
+          visible: false,
+          color: FORECAST_PALETTE.flat.line,
+        });
+      }
+      if (pane.forecastSeries.p10) {
+        pane.forecastSeries.p10.setData([]);
+        pane.forecastSeries.p10.applyOptions({ color: FORECAST_PALETTE.flat.band, visible: false });
+      }
+      if (pane.forecastSeries.p90) {
+        pane.forecastSeries.p90.setData([]);
+        pane.forecastSeries.p90.applyOptions({ color: FORECAST_PALETTE.flat.band, visible: false });
+      }
+      if (pane.forecastSeries.candles) {
+        pane.forecastSeries.candles.setData([]);
+        pane.forecastSeries.candles.applyOptions({ ...buildForecastCandleSeriesOptions(), visible: false });
+      }
+      pane.forecastContext = { symbol: null, interval: null, ready: false };
+    }
+
+    function clearPaneForecastCandlesOnly(pane) {
+      if (!pane?.forecastSeries) return;
+      clearPaneForecastVisuals(pane);
+    }
+
+    function resetPendingPaneAI(pane) {
+      if (!pane) return;
+      if (pane.analysisFetchController) {
+        pane.analysisFetchController.abort();
+        pane.analysisFetchController = null;
+      }
+      if (pane.analysisRetryTimer) {
+        clearTimeout(pane.analysisRetryTimer);
+        pane.analysisRetryTimer = null;
+      }
+      pane.analysisRequestPromise = null;
+      pane.analysisRequestKey = null;
+      clearPaneForecastCandlesOnly(pane);
+    }
+
+    function renderPaneForecastVisuals(pane, forecastLine = []) {
+      if (!pane?.forecastSeries || !pane?.chartInstance) return;
+
+      const points = Array.isArray(forecastLine) ? forecastLine : [];
+      const tone = getForecastTone(points);
+      const palette = FORECAST_PALETTE[tone] || FORECAST_PALETTE.flat;
+      clearPaneForecastSegments(pane);
+
+      if (pane.forecastSeries.p10) {
+        pane.forecastSeries.p10.setData([]);
+        pane.forecastSeries.p10.applyOptions({ color: palette.band, visible: false });
+      }
+      if (pane.forecastSeries.p90) {
+        pane.forecastSeries.p90.setData([]);
+        pane.forecastSeries.p90.applyOptions({ color: palette.band, visible: false });
+      }
+
+      if (pane.forecastSeries.candles) {
+        pane.forecastSeries.candles.setData([]);
+        pane.forecastSeries.candles.applyOptions({
+          ...buildForecastCandleSeriesOptions(tone),
+          visible: false,
+          priceFormat: {
+            type: 'price',
+            precision: pane.priceFormat?.precision ?? 2,
+            minMove: pane.priceFormat?.minMove ?? 0.01,
+          },
+        });
+      }
+
+      if (!points.length || !pane.forecastSeries.p50) {
+        fitChartWithOffset(pane.chartInstance);
+        return;
+      }
+
+      pane.forecastSeries.p50.setData(points);
+      pane.forecastSeries.p50.applyOptions({
+        color: palette.line,
+        visible: true,
+        lineWidth: 2,
+        lineStyle: 0,
+        priceLineVisible: false,
+        lastValueVisible: false,
+        crosshairMarkerVisible: true,
+        priceFormat: {
+          type: 'price',
+          precision: pane.priceFormat?.precision ?? 2,
+          minMove: pane.priceFormat?.minMove ?? 0.01,
+        },
+      });
+      fitChartWithOffset(pane.chartInstance, getForecastRightOffset(points));
+    }
+
+    window.clearPaneForecastVisuals = clearPaneForecastVisuals;
+    window.clearPaneForecastCandlesOnly = clearPaneForecastCandlesOnly;
+    window.renderPaneForecastVisuals = renderPaneForecastVisuals;
+
     function scheduleAnalysisRetry(symbol, interval) {
       if (analysisRetryTimer) return;
       analysisRetryTimer = setTimeout(() => {
@@ -4573,14 +4967,28 @@
         const indicators = indData.indicators || {};
         const series = indicators.series || {};
 
-        if (type === 'bb' || type === 'both') {
-          if (series.bb_upper) bbUpperSeries.setData(series.bb_upper);
-          if (series.bb_mid) bbMiddleSeries.setData(series.bb_mid);
-          if (series.bb_lower) bbLowerSeries.setData(series.bb_lower);
-        }
+        if (series.bb_upper) bbUpperSeries.setData(series.bb_upper);
+        if (series.bb_mid) bbMiddleSeries.setData(series.bb_mid);
+        if (series.bb_lower) bbLowerSeries.setData(series.bb_lower);
 
-        chart.timeScale().fitContent();
+        fitChartWithOffset(chart);
         activeChartContext = { symbol, interval };
+        if (window.Workspace && typeof Workspace.getPane === 'function') {
+          const pane0 = Workspace.getPane('pane-0');
+          if (pane0) {
+            pane0.symbol = symbol;
+            pane0.interval = interval;
+            pane0.lastCandleData = lastCandleData;
+            pane0.priceFormat = currentPriceFormat;
+            if (pane0.priceEl && lastCandleData) {
+              pane0.priceEl.textContent = Number(lastCandleData.close).toFixed(currentPriceFormat.precision);
+            }
+            renderPaneAnalysisUI(pane0);
+            if (typeof pane0.fetchAI === 'function') {
+              pane0.fetchAI({ force: true });
+            }
+          }
+        }
         hideLoader();
         updateStatus(
           hasLiveForecastFor(symbol, interval)
@@ -4588,7 +4996,6 @@
             : `${symbol} | ${interval} - Dang nap AI...`,
           'loading'
         );
-        fetchAIAnalysis(symbol, interval);
       } catch (e) {
         if (e.name === 'AbortError') return;
         console.error('Stage 1 Fetch Error:', e);
@@ -4602,6 +5009,8 @@
     }
 
     async function fetchAIAnalysis(symbol, interval, options = {}) {
+      // DISABLED: Handled per-pane by Workspace.PaneState.fetchAI
+      return null;
       if (currentSymbol !== symbol || timeframeSelect.value !== interval) return null;
 
       const panel = document.getElementById('analysisPanel');
@@ -4628,6 +5037,8 @@
         analysisFetchController.abort();
       }
 
+      clearPrimaryForecastCandlesOnly();
+
       const controller = new AbortController();
       analysisFetchController = controller;
       analysisRequestKey = requestKey;
@@ -4641,9 +5052,22 @@
 
           if (currentSymbol !== symbol || timeframeSelect.value !== interval) return null;
 
-          const hasForecast = Array.isArray(fData.forecast) && fData.forecast.length > 0;
+          const forecastPoints = Array.isArray(fData.forecast) ? fData.forecast : [];
           const hasAnalysis = Boolean(fData.analysis);
           const hadForecast = hasLiveForecastFor(symbol, interval);
+          const fallbackActualPoint = lastCandleData && lastCandleData.time
+            ? {
+              time: lastCandleData.time,
+              value: (
+                Number(lastCandleData.open ?? 0)
+                + Number(lastCandleData.high ?? 0)
+                + Number(lastCandleData.low ?? 0)
+                + Number(lastCandleData.close ?? 0)
+              ) / 4,
+            }
+            : null;
+          const forecastLine = buildForecastLineFromRows(forecastPoints, fallbackActualPoint);
+          const hasForecast = forecastLine.length > 1;
 
           if (!hasForecast || !lastCandleData || !lastCandleData.time) {
             if (!hadForecast) {
@@ -4664,27 +5088,16 @@
             return fData;
           }
 
-          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];
-          const p10 = [anchorPoint, ...forecastPoints
-            .filter(d => d && d.time !== undefined && d.p10 !== undefined && d.time !== lastCandleData.time)
-            .map(d => ({ time: d.time, value: d.p10 }))];
-          const p90 = [anchorPoint, ...forecastPoints
-            .filter(d => d && d.time !== undefined && d.p90 !== undefined && d.time !== lastCandleData.time)
-            .map(d => ({ time: d.time, value: d.p90 }))];
+          commitForecastVisuals(symbol, interval, forecastLine);
 
           renderAnalysisPanel(symbol, interval, fData);
           setTimeout(updateDashboardScale, 10);
           renderCompactGauges(symbol, interval, fData);
-          commitForecastVisuals(symbol, interval, p50, p10, p90);
 
           const currentPrice = lastCandleData?.close || 0;
-          const lastForecastVal = forecastPoints[forecastPoints.length - 1]?.p50 ?? anchorPoint.value;
-          const isBull = lastForecastVal >= anchorPoint.value;
+          const forecastBaseVal = Number(forecastLine[0]?.value ?? currentPrice);
+          const lastForecastVal = Number(forecastLine[forecastLine.length - 1]?.value ?? forecastBaseVal);
+          const isBull = lastForecastVal >= forecastBaseVal;
           const pctChange = currentPrice > 0 ? ((lastForecastVal - currentPrice) / currentPrice) * 100 : 0;
           const pctLabel = (pctChange >= 0 ? '+' : '') + pctChange.toFixed(2) + '%';
           const trend = isBull ? 'TANG' : 'GIAM';
@@ -4823,8 +5236,165 @@
     closeExplorerBtn.onclick = closeExplorer;
     toggleMarketBtn.onclick = openExplorer;
 
-    timeframeSelect.onchange = () => refreshChart({ forceContextReset: true });
-    indicatorSelect.onchange = () => refreshChart();
+    function setPaneAnalysisOpen(pane, isOpen) {
+      if (!pane) return;
+      pane.analysisOpen = Boolean(isOpen);
+      if (pane.analysisOverlayEl) pane.analysisOverlayEl.classList.toggle('active', pane.analysisOpen);
+      if (pane.analysisButtonEl) pane.analysisButtonEl.classList.toggle('active', pane.analysisOpen);
+    }
+
+    function buildPaneAnalysisMarkup(pane) {
+      const payload = pane?.lastAnalysis?.payload;
+      if (pane?.analysisFetchController && !payload) {
+        return `<div class="pane-analysis-loading">AI đang phân tích ${pane.symbol} ${pane.interval}...</div>`;
+      }
+      if (!payload || !payload.analysis) {
+        return `<div class="pane-analysis-empty">Chưa có dữ liệu phân tích cho ${pane?.symbol || '--'}.</div>`;
+      }
+
+      const analysis = payload.analysis;
+      const summary = analysis.dashboard?.summary || analysis.summary || {};
+      const technical = analysis.dashboard?.technical || analysis.technicals || {};
+      const ai = analysis.dashboard?.ai || analysis.ai_gauge || {};
+      const forecast = Array.isArray(payload.forecast) ? payload.forecast : [];
+      const lastPoint = forecast.length ? forecast[forecast.length - 1] : null;
+      const precision = pane.priceFormat?.precision ?? 2;
+
+      return `
+        <div class="pane-analysis-title">
+          <span>${pane.symbol} AI</span>
+          <div class="pane-analysis-meta">
+            <span class="pane-analysis-pill">${pane.interval.toUpperCase()} • H${pane.horizon || 10}</span>
+            <span class="pane-analysis-pill">${payload.verdict || summary.signal || 'NEUTRAL'}</span>
+          </div>
+        </div>
+        <div class="pane-analysis-grid">
+          <div class="pane-analysis-card">
+            <strong>Tổng quan</strong>
+            <div class="pane-analysis-body">${summary.narrative || summary.reason || analysis.summary_text || 'AI đang theo dõi diễn biến hiện tại của chart này.'}</div>
+          </div>
+          <div class="pane-analysis-card">
+            <strong>Dự báo</strong>
+            <div class="pane-analysis-body">${lastPoint ? `P50: ${Number(lastPoint.p50 ?? 0).toFixed(precision)} | P10: ${Number(lastPoint.p10 ?? 0).toFixed(precision)} | P90: ${Number(lastPoint.p90 ?? 0).toFixed(precision)}` : 'Chưa có dải dự báo.'}</div>
+          </div>
+          <div class="pane-analysis-card">
+            <strong>Technical</strong>
+            <div class="pane-analysis-body">Trend score: ${Math.round(Number(technical.score ?? technical.trend_score ?? 50))}</div>
+          </div>
+          <div class="pane-analysis-card">
+            <strong>AI Score</strong>
+            <div class="pane-analysis-body">Confidence: ${Math.round(Number(ai.score ?? ai.confidence ?? summary.confidence ?? 50))}</div>
+          </div>
+        </div>
+      `;
+    }
+
+    function renderPaneAnalysisUI(pane) {
+      if (!pane) return;
+      if (pane.analysisButtonEl) {
+        let state = 'idle';
+        if (pane.analysisFetchController) state = 'loading';
+        else if (pane.lastAnalysis && pane.lastAnalysis.payload) state = 'ready';
+        else if (pane.error) state = 'error';
+        pane.analysisButtonEl.dataset.state = state;
+        pane.analysisButtonEl.setAttribute('aria-label', `Phân tích ${pane.symbol} ${pane.interval}`);
+      }
+      if (pane.analysisOverlayEl) {
+        pane.analysisOverlayEl.innerHTML = buildPaneAnalysisMarkup(pane);
+        pane.analysisOverlayEl.classList.toggle('active', Boolean(pane.analysisOpen));
+      }
+    }
+
+    window.renderPaneAnalysisUI = renderPaneAnalysisUI;
+
+    function bindPaneAnalysisButton(pane) {
+      if (!pane?.analysisButtonEl) return;
+      pane.analysisButtonEl.onclick = (event) => {
+        event.stopPropagation();
+        if (window.Workspace && typeof Workspace.setActivePane === 'function') {
+          Workspace.setActivePane(pane.paneId);
+        }
+        const willOpen = !pane.analysisOpen;
+        if (window.Workspace && Workspace.panes) {
+          Workspace.panes.forEach((otherPane) => {
+            if (otherPane !== pane) {
+              setPaneAnalysisOpen(otherPane, false);
+              renderPaneAnalysisUI(otherPane);
+            }
+          });
+        }
+        setPaneAnalysisOpen(pane, willOpen);
+        renderPaneAnalysisUI(pane);
+        if (willOpen && (!pane.lastAnalysis || !pane.lastAnalysis.payload) && typeof pane.fetchAI === 'function') {
+          pane.fetchAI({ force: true });
+        }
+      };
+    }
+
+    timeframeSelect.onchange = () => {
+      const nextInterval = timeframeSelect.value;
+      if (window.Workspace && Workspace.layoutPreset > 1) {
+        const activePaneId = Workspace.activePaneId;
+        const promises = [];
+        currentInterval = nextInterval;
+
+        Workspace.panes.forEach((pane) => {
+          resetPendingPaneAI(pane);
+          pane.interval = nextInterval;
+          if (pane.paneHeaderEl) {
+            const intEl = pane.paneHeaderEl.querySelector('.pane-interval');
+            if (intEl) intEl.textContent = nextInterval;
+          }
+          StreamManager.unsubscribe(pane.paneId);
+          promises.push(loadPaneData(pane).then(() => connectPaneWS(pane)));
+        });
+
+        Promise.allSettled(promises).then(() => {
+          if (activePaneId && Workspace.panes.has(activePaneId)) {
+            syncToolbarToPane(activePaneId);
+          }
+        });
+        Workspace.save();
+        return;
+      }
+      refreshChart({ forceContextReset: true });
+      connectWS(currentSymbol);
+    };
+
+    horizonInput.onchange = () => {
+      const horizon = Math.max(5, Math.min(300, parseInt(horizonInput.value, 10) || 10));
+      if (window.Workspace && Workspace.panes) {
+        Workspace.panes.forEach((pane) => {
+          pane.horizon = horizon;
+          if (typeof pane.fetchAI === 'function') {
+            pane.fetchAI({ force: true });
+          }
+        });
+        Workspace.save();
+      }
+    };
+        indicatorSelect.onchange = () => {
+      const type = indicatorSelect.value;
+      const isBbVisible = (type === 'bb' || type === 'both');
+      
+      // Update global chart
+      if (typeof bbUpperSeries !== 'undefined') {
+        bbUpperSeries.applyOptions({ visible: isBbVisible });
+        bbMiddleSeries.applyOptions({ visible: isBbVisible });
+        bbLowerSeries.applyOptions({ visible: isBbVisible });
+      }
+
+      // Update all Workspace panes
+      if (window.Workspace && window.Workspace.panes) {
+        window.Workspace.panes.forEach(pane => {
+          if (pane.indicatorSeries) {
+            if (pane.indicatorSeries.bbUpper) pane.indicatorSeries.bbUpper.applyOptions({ visible: isBbVisible });
+            if (pane.indicatorSeries.bbMid) pane.indicatorSeries.bbMid.applyOptions({ visible: isBbVisible });
+            if (pane.indicatorSeries.bbLower) pane.indicatorSeries.bbLower.applyOptions({ visible: isBbVisible });
+          }
+        });
+      }
+    };
 
     // "Phân tích" button: toggle dashboard ON/OFF without reloading chart
     refreshBtn.onclick = () => {
@@ -4853,7 +5423,37 @@
       }
     };
 
-    fitBtn.onclick = () => chart.timeScale().fitContent();
+    refreshBtn.onclick = () => {
+      const pane = window.Workspace && typeof Workspace.getActivePane === 'function'
+        ? Workspace.getActivePane()
+        : null;
+      if (!pane) return;
+      const willOpen = !pane.analysisOpen;
+      if (window.Workspace && Workspace.panes) {
+        Workspace.panes.forEach((otherPane) => {
+          if (otherPane !== pane) {
+            setPaneAnalysisOpen(otherPane, false);
+            renderPaneAnalysisUI(otherPane);
+          }
+        });
+      }
+      setPaneAnalysisOpen(pane, willOpen);
+      renderPaneAnalysisUI(pane);
+      if (willOpen && typeof pane.fetchAI === 'function') {
+        pane.fetchAI({ force: !pane.lastAnalysis?.payload });
+      }
+    };
+
+        fitBtn.onclick = () => {
+      fitChartWithOffset(chart);
+      if (window.Workspace && window.Workspace.panes) {
+        window.Workspace.panes.forEach(pane => {
+          if (pane.chartInstance) {
+            fitChartWithOffset(pane.chartInstance);
+          }
+        });
+      }
+    };
 
     document.addEventListener('keydown', (e) => {
       const target = e.target;
@@ -5000,6 +5600,570 @@
       applyTheme(newTheme);
     };
 
+    /* ══════════════════════════════════════════════
+       MULTI-PANE WORKSPACE ENGINE
+    ══════════════════════════════════════════════ */
+    const workspaceGrid = document.getElementById('workspaceGrid');
+    const layoutSwitcher = document.getElementById('layoutSwitcher');
+
+    // Register pane-0 (already in DOM) into Workspace
+    Workspace.init(workspaceGrid);
+    const pane0 = Workspace.createPane('pane-0', 'XAUUSD', '1d');
+    {
+      const container = workspaceGrid.querySelector('.chart-pane[data-pane-id="pane-0"]');
+      pane0.containerEl = container;
+      pane0.chartEl = container.querySelector('.pane-chart');
+      pane0.loaderEl = container.querySelector('.pane-loader');
+      pane0.gaugesEl = container.querySelector('.pane-gauges');
+      pane0.paneHeaderEl = container.querySelector('.pane-header-mini');
+      pane0.priceEl = container.querySelector('.pane-price');
+      pane0.analysisButtonEl = container.querySelector('.pane-analysis-btn');
+      pane0.analysisOverlayEl = container.querySelector('.pane-analysis-overlay');
+      // Bind existing chart instance to pane-0
+      pane0.chartInstance = chart;
+      pane0.candleSeries = candleSeries;
+      pane0.forecastSeries = {
+        candles: forecastCandleSeries,
+        p50: p50Series,
+        p10: p10Series,
+        p90: p90Series,
+        segments: forecastSegmentSeries,
+      };
+      pane0.indicatorSeries = { bbUpper: bbUpperSeries, bbMid: bbMiddleSeries, bbLower: bbLowerSeries, rsi: rsiSeries };
+      pane0.horizon = Math.max(5, Math.min(300, parseInt(horizonInput.value, 10) || 10));
+      bindPaneAnalysisButton(pane0);
+      renderPaneAnalysisUI(pane0);
+      if (pane0.gaugesEl && Workspace.layoutPreset === 1) {
+        pane0.gaugesEl.innerHTML = '';
+        pane0.gaugesEl.style.display = 'none';
+      }
+      container.addEventListener('click', () => Workspace.setActivePane('pane-0'));
+    }
+
+    // Chart creation helper for new panes
+    function createPaneChart(pane) {
+      const isDark = document.body.classList.contains('dark-theme');
+      const chartInstance = LightweightCharts.createChart(pane.chartEl, {
+        layout: {
+          background: { type: 'solid', color: 'transparent' },
+          textColor: isDark ? 'rgba(100, 150, 200, 0.85)' : '#475569',
+          fontSize: 10,
+          fontFamily: "'Space Mono', 'Courier New', monospace",
+        },
+        grid: { vertLines: { visible: false }, horzLines: { visible: false } },
+        rightPriceScale: {
+          borderColor: 'rgba(40, 80, 140, 0.25)',
+          autoScale: true,
+          scaleMargins: { top: 0.08, bottom: 0.08 },
+        },
+        timeScale: {
+          borderColor: 'rgba(40, 80, 140, 0.25)',
+          timeVisible: true,
+          secondsVisible: false,
+          rightOffset: CHART_RIGHT_OFFSET,
+        },
+        crosshair: {
+          mode: LightweightCharts.CrosshairMode.Normal,
+          vertLine: { color: 'rgba(34, 211, 238, 0.35)', width: 1 },
+          horzLine: { color: 'rgba(34, 211, 238, 0.35)', width: 1 },
+        },
+        watermark: {
+          visible: true,
+          fontSize: 32,
+          horzAlign: 'center',
+          vertAlign: 'center',
+          color: isDark ? 'rgba(34, 211, 238, 0.06)' : 'rgba(15, 23, 42, 0.06)',
+          text: pane.symbol,
+        },
+        handleScroll: true,
+        handleScale: true,
+      });
+
+      pane.chartInstance = chartInstance;
+      pane.candleSeries = chartInstance.addCandlestickSeries({
+        upColor: '#1dba8a', downColor: '#e05560',
+        borderVisible: false, wickUpColor: '#1dba8a', wickDownColor: '#e05560',
+      });
+      pane.forecastSeries.candles = chartInstance.addCandlestickSeries(buildForecastCandleSeriesOptions());
+      pane.forecastSeries.p50 = chartInstance.addLineSeries({ color: '#7dd3fc', lineWidth: 2, lineStyle: 0, priceLineVisible: false, lastValueVisible: false, visible: false });
+      pane.forecastSeries.p10 = chartInstance.addLineSeries({ color: 'rgba(125,211,252,0.4)', lineWidth: 1, lineStyle: 2, priceLineVisible: false, lastValueVisible: false, visible: false });
+      pane.forecastSeries.p90 = chartInstance.addLineSeries({ color: 'rgba(125,211,252,0.4)', lineWidth: 1, lineStyle: 2, priceLineVisible: false, lastValueVisible: false, visible: false });
+      const isBbVisible = (document.getElementById('indicatorSelect') && (document.getElementById('indicatorSelect').value === 'bb' || document.getElementById('indicatorSelect').value === 'both'));
+      pane.indicatorSeries.bbMid = chartInstance.addLineSeries({ color: 'rgba(255,255,255,0.2)', lineWidth: 1, priceLineVisible: false, lastValueVisible: false, visible: isBbVisible });
+      pane.indicatorSeries.bbUpper = chartInstance.addLineSeries({ color: 'rgba(34,211,238,0.3)', lineWidth: 1, priceLineVisible: false, lastValueVisible: false, visible: isBbVisible });
+      pane.indicatorSeries.bbLower = chartInstance.addLineSeries({ color: 'rgba(34,211,238,0.3)', lineWidth: 1, priceLineVisible: false, lastValueVisible: false, visible: isBbVisible });
+
+      // ResizeObserver
+      const paneRo = new ResizeObserver(() => {
+        chartInstance.applyOptions({ width: pane.chartEl.clientWidth, height: pane.chartEl.clientHeight });
+      });
+      paneRo.observe(pane.chartEl);
+      pane._resizeObserver = paneRo;
+
+      return chartInstance;
+    }
+
+    // Load data for a specific pane
+    async function loadPaneData(pane) {
+      if (!pane || !pane.chartInstance) return;
+      const { symbol, interval } = pane;
+
+      // Show loader
+      if (pane.loaderEl) pane.loaderEl.classList.remove('hidden');
+      renderPaneAnalysisUI(pane);
+
+      // Abort previous
+      if (pane.fetchController) pane.fetchController.abort();
+      resetPendingPaneAI(pane);
+      pane.fetchController = new AbortController();
+      const signal = pane.fetchController.signal;
+
+      const sLabel = symbolMap.get(symbol) || symbol;
+      const tLabel = timeframeMap[interval] || interval;
+      const isDark = document.body.classList.contains('dark-theme');
+
+      pane.chartInstance.applyOptions({
+        watermark: {
+          text: `${sLabel} | ${tLabel}`,
+          color: isDark ? 'rgba(34, 211, 238, 0.15)' : 'rgba(15, 23, 42, 0.08)',
+          fontSize: Workspace.layoutPreset === 1 ? 72 : 28,
+        },
+      });
+
+      try {
+        const [histData, indData] = await Promise.all([
+          DataCoordinator.fetchHistorical(symbol, interval, CHART_HISTORY_LIMIT, signal),
+          DataCoordinator.fetchIndicators(symbol, interval, CHART_HISTORY_LIMIT, signal),
+        ]);
+
+        // Apply price format
+        const pf = resolvePriceFormat(symbol, histData.data);
+        pane.priceFormat = pf;
+        const pfOpts = { priceFormat: { type: 'price', precision: pf.precision, minMove: pf.minMove } };
+        pane.candleSeries.applyOptions(pfOpts);
+        if (pane.forecastSeries.candles) pane.forecastSeries.candles.applyOptions(pfOpts);
+        if (pane.indicatorSeries.bbUpper) pane.indicatorSeries.bbUpper.applyOptions(pfOpts);
+        if (pane.indicatorSeries.bbMid) pane.indicatorSeries.bbMid.applyOptions(pfOpts);
+        if (pane.indicatorSeries.bbLower) pane.indicatorSeries.bbLower.applyOptions(pfOpts);
+
+        if (histData.data.length > 0) {
+          pane.candleSeries.setData(histData.data);
+          pane.lastCandleData = histData.data[histData.data.length - 1];
+          if (pane.paneId === 'pane-0') {
+            lastCandleData = pane.lastCandleData;
+          }
+        }
+
+        // Indicators
+        const series = (indData.indicators || {}).series || {};
+        if (series.bb_upper) pane.indicatorSeries.bbUpper.setData(series.bb_upper);
+        if (series.bb_mid) pane.indicatorSeries.bbMid.setData(series.bb_mid);
+        if (series.bb_lower) pane.indicatorSeries.bbLower.setData(series.bb_lower);
+
+        fitChartWithOffset(pane.chartInstance);
+        pane.chartContext = { symbol, interval };
+        if (pane.paneId === 'pane-0') {
+          currentPriceFormat = pane.priceFormat;
+          activeChartContext = { symbol, interval };
+          currentSymbol = symbol;
+          currentInterval = interval;
+        }
+
+        // Start AI fetch for this pane
+        if (typeof pane.fetchAI === 'function') {
+           pane.fetchAI({ force: true });
+        }
+
+        // Update pane header with last price
+        if (pane.lastCandleData && pane.priceEl) {
+          const price = pane.lastCandleData.close;
+          const precision = pane.priceFormat.precision;
+          pane.priceEl.textContent = Number(price).toFixed(precision);
+        }
+
+      } catch (e) {
+        if (e.name === 'AbortError') return;
+        console.error(`[Pane ${pane.paneId}] Data load error:`, e);
+        pane.error = e.message;
+        renderPaneAnalysisUI(pane);
+      } finally {
+        if (pane.loaderEl) pane.loaderEl.classList.add('hidden');
+      }
+    }
+
+    // Connect WS for a pane
+    function connectPaneWS(pane) {
+      StreamManager.subscribe(pane.paneId, pane.symbol, pane.interval, (data) => {
+        if (!pane.lastCandleData || !data.price) return;
+        if (shouldMutateRealtimeCandle(pane.symbol)) {
+          const update = {
+            time: pane.lastCandleData.time,
+            open: pane.lastCandleData.open,
+            high: Math.max(pane.lastCandleData.high, data.price),
+            low: Math.min(pane.lastCandleData.low, data.price),
+            close: data.price,
+          };
+          if (pane.candleSeries) pane.candleSeries.update(update);
+          pane.lastCandleData = update;
+          if (pane.paneId === 'pane-0') {
+            lastCandleData = update;
+          }
+        }
+
+        // Update mini header price
+        if (pane.priceEl) {
+          pane.priceEl.textContent = Number(data.price).toFixed(pane.priceFormat.precision);
+        }
+      });
+    }
+
+    // Destroy a pane (cleanup resources)
+    function destroyPaneResources(pane) {
+      clearPaneForecastVisuals(pane);
+      StreamManager.unsubscribe(pane.paneId);
+      if (pane.fetchController) { pane.fetchController.abort(); pane.fetchController = null; }
+      if (pane._resizeObserver) { pane._resizeObserver.disconnect(); pane._resizeObserver = null; }
+      if (pane.chartInstance && pane.paneId !== 'pane-0') {
+        try { pane.chartInstance.remove(); } catch (_) {}
+        pane.chartInstance = null;
+      }
+    }
+
+    // Switch layout handler
+    async function switchLayout(preset, options = {}) {
+      if (preset === Workspace.layoutPreset) return;
+      const prevPreset = Workspace.layoutPreset;
+      const restoredPanes = Array.isArray(options.panes) ? options.panes : null;
+
+      // Destroy extra panes (keep pane-0)
+      for (const [id, pane] of Workspace.panes) {
+        if (id !== 'pane-0') {
+          destroyPaneResources(pane);
+        }
+      }
+
+      // Clear grid (keep pane-0 DOM)
+      const pane0Container = workspaceGrid.querySelector('[data-pane-id="pane-0"]');
+      workspaceGrid.innerHTML = '';
+      if (pane0Container) workspaceGrid.appendChild(pane0Container);
+
+      // Clear panes map except pane-0
+      for (const [id] of Workspace.panes) {
+        if (id !== 'pane-0') Workspace.panes.delete(id);
+      }
+
+      // Update layout
+      Workspace.layoutPreset = preset;
+      [1, 2, 4, 8].forEach(n => workspaceGrid.classList.remove(`layout-${n}`));
+      workspaceGrid.classList.add(`layout-${preset}`);
+
+      // Update switcher buttons
+      layoutSwitcher.querySelectorAll('button[data-layout]').forEach(btn => {
+        btn.classList.toggle('active', parseInt(btn.dataset.layout) === preset);
+      });
+      const layoutMenuCurrent = document.getElementById('layoutMenuCurrent');
+      const layoutMenuBtn = document.getElementById('layoutMenuBtn');
+      if (layoutMenuCurrent) layoutMenuCurrent.textContent = String(preset);
+      if (layoutMenuBtn) layoutMenuBtn.setAttribute('aria-expanded', 'false');
+      layoutSwitcher.classList.remove('open');
+
+      // Update pane-0 watermark size
+      const pane0 = Workspace.getPane('pane-0');
+      if (pane0 && pane0.chartInstance) {
+        pane0.chartInstance.applyOptions({
+          watermark: { fontSize: preset === 1 ? 72 : 28 },
+        });
+        pane0.chartInstance.applyOptions({
+          width: pane0.chartEl.clientWidth,
+          height: pane0.chartEl.clientHeight,
+        });
+      }
+
+      // Show/hide global overlays based on mode
+      const logoOverlay = document.querySelector('.chart-logo-overlay');
+      if (logoOverlay) logoOverlay.style.display = preset === 1 ? '' : 'none';
+      setGlobalStatusVisibility(preset === 1);
+      setGlobalCompactGaugesVisibility(preset === 1);
+
+      const realStrengthSymbols = ['DXY', 'EURX', 'GBPX', 'CHFX', 'JPYX', 'CADX', 'AUDX', 'NZDX'];
+
+      // Create new panes for multi-chart mode
+      if (preset > 1) {
+        const defaultSymbols = preset === 8
+          ? realStrengthSymbols
+          : ['EURUSD', 'GBPUSD', 'USDJPY', 'BTCUSD', 'XAGUSD', 'DXY', 'USDCHF'];
+        const loadPromises = [];
+        const restoredPane0 = restoredPanes && restoredPanes.length > 0
+          ? (restoredPanes.find((paneState) => paneState.id === 'pane-0') || restoredPanes[0])
+          : null;
+
+        if (ws) {
+          ws.close();
+          ws = null;
+        }
+
+        if (pane0) {
+          const pane0Symbol = restoredPane0?.symbol || defaultSymbols[0] || pane0.symbol;
+          const sharedInterval = restoredPane0?.interval || timeframeSelect.value || pane0.interval || '1d';
+          pane0.symbol = pane0Symbol;
+          pane0.interval = sharedInterval;
+          pane0.horizon = Math.max(5, Math.min(300, parseInt(restoredPane0?.horizon, 10) || parseInt(horizonInput.value, 10) || 10));
+          currentSymbol = pane0Symbol;
+          currentInterval = sharedInterval;
+          symbolSearch.value = pane0Symbol;
+          if (pane0.paneHeaderEl) {
+            const symEl = pane0.paneHeaderEl.querySelector('.pane-symbol');
+            const intEl = pane0.paneHeaderEl.querySelector('.pane-interval');
+            if (symEl) symEl.textContent = pane0Symbol;
+            if (intEl) intEl.textContent = sharedInterval;
+          }
+          StreamManager.unsubscribe(pane0.paneId);
+          if (pane0.candleSeries) pane0.candleSeries.setData([]);
+          clearForecastVisuals();
+          clearPaneForecastVisuals(pane0);
+          pane0.lastCandleData = null;
+          pane0.lastAnalysis = { payload: null, symbol: null, interval: null };
+          pane0.forecastContext = { symbol: null, interval: null, ready: false };
+          pane0.error = null;
+          renderPaneAnalysisUI(pane0);
+          loadPromises.push(loadPaneData(pane0).then(() => connectPaneWS(pane0)));
+        }
+
+        for (let i = 1; i < preset; i++) {
+          const paneId = `pane-${i}`;
+          const restoredPaneState = restoredPanes?.find((paneState) => paneState.id === paneId) || null;
+          const sym = restoredPaneState?.symbol || defaultSymbols[i % defaultSymbols.length];
+          const paneInterval = restoredPaneState?.interval || timeframeSelect.value || '1d';
+          const pane = Workspace.createPane(paneId, sym, paneInterval);
+
+          // Build DOM
+          const container = document.createElement('div');
+          container.className = 'chart-pane';
+          container.dataset.paneId = paneId;
+          container.innerHTML = `
+            <div class="pane-header-mini">
+              <span class="pane-symbol">${sym}</span>
+              <span class="pane-sep">·</span>
+              <span class="pane-interval">1d</span>
+              <span class="pane-price">--</span>
+            </div>
+            <button class="pane-analysis-btn" type="button" data-pane-analysis="${paneId}" data-state="idle" aria-label="Phân tích ${sym}">
+              <span class="dot"></span>
+              <span>AI</span>
+            </button>
+            <div class="pane-chart" id="pane-chart-${paneId}"></div>
+            <div class="pane-loader hidden"><div class="loader-ring"></div></div>
+            <div class="pane-gauges"></div>
+            <div class="pane-analysis-overlay"></div>
+          `;
+
+          pane.containerEl = container;
+          pane.chartEl = container.querySelector('.pane-chart');
+          pane.loaderEl = container.querySelector('.pane-loader');
+          pane.gaugesEl = container.querySelector('.pane-gauges');
+          pane.paneHeaderEl = container.querySelector('.pane-header-mini');
+          pane.priceEl = container.querySelector('.pane-price');
+          pane.analysisButtonEl = container.querySelector('.pane-analysis-btn');
+          pane.analysisOverlayEl = container.querySelector('.pane-analysis-overlay');
+          pane.horizon = Math.max(5, Math.min(300, parseInt(restoredPaneState?.horizon, 10) || parseInt(horizonInput.value, 10) || 10));
+          bindPaneAnalysisButton(pane);
+          renderPaneAnalysisUI(pane);
+
+          container.addEventListener('click', () => {
+            Workspace.setActivePane(paneId);
+            syncToolbarToPane(paneId);
+          });
+
+          workspaceGrid.appendChild(container);
+
+          // Create chart instance
+          createPaneChart(pane);
+
+          // Load data + WS
+          loadPromises.push(
+            loadPaneData(pane).then(() => connectPaneWS(pane))
+          );
+        }
+
+        // Load all panes in parallel (throttled by DataCoordinator)
+        await Promise.allSettled(loadPromises);
+      } else if (pane0) {
+        StreamManager.unsubscribe(pane0.paneId);
+        clearPaneForecastVisuals(pane0);
+        if (pane0.gaugesEl) {
+          pane0.gaugesEl.innerHTML = '';
+          pane0.gaugesEl.style.display = 'none';
+        }
+        currentSymbol = pane0.symbol;
+        currentInterval = pane0.interval;
+        symbolSearch.value = pane0.symbol;
+        timeframeSelect.value = pane0.interval;
+        connectWS(pane0.symbol, pane0.interval);
+      }
+
+      // Ensure active pane is valid
+      if (!Workspace.panes.has(Workspace.activePaneId)) {
+        Workspace.setActivePane('pane-0');
+      }
+      Workspace.setActivePane(Workspace.activePaneId);
+      if (pane0?.gaugesEl) {
+        pane0.gaugesEl.style.display = preset === 1 ? 'none' : '';
+        if (preset === 1) {
+          pane0.gaugesEl.innerHTML = '';
+        }
+      }
+
+      // Resize pane-0 chart after layout change
+      requestAnimationFrame(() => {
+        if (pane0 && pane0.chartInstance) {
+          pane0.chartInstance.applyOptions({
+            width: pane0.chartEl.clientWidth,
+            height: pane0.chartEl.clientHeight,
+          });
+        }
+      });
+
+      Workspace.save();
+    }
+
+    // Sync toolbar controls to the active pane's state
+    function syncToolbarToPane(paneId) {
+      const pane = Workspace.getPane(paneId);
+      if (!pane) return;
+
+      // Update toolbar to reflect pane state
+      symbolSearch.value = pane.symbol;
+      // Don't trigger change events — just update display
+      const tfOptions = timeframeSelect.options;
+      for (let i = 0; i < tfOptions.length; i++) {
+        if (tfOptions[i].value === pane.interval) {
+          timeframeSelect.selectedIndex = i;
+          break;
+        }
+      }
+
+      // Update active pane globals for backward compat
+      currentSymbol = pane.symbol;
+      currentInterval = pane.interval;
+    }
+
+    // Apply symbol to active pane (for multi-pane mode)
+    function applySymbolToActivePane(symbol) {
+      const pane = Workspace.getActivePane();
+      if (!pane) return;
+
+      if (Workspace.layoutPreset === 1) {
+        // Single pane mode — use original switchSymbol
+        switchSymbol(symbol);
+        return;
+      }
+
+      // Multi-pane mode: update the active pane
+      pane.symbol = symbol;
+      currentSymbol = symbol;
+      symbolSearch.value = symbol;
+
+      // Update pane header
+      if (pane.paneHeaderEl) {
+        const symEl = pane.paneHeaderEl.querySelector('.pane-symbol');
+        if (symEl) symEl.textContent = symbol;
+      }
+
+      // Disconnect old WS, clear data
+      resetPendingPaneAI(pane);
+      StreamManager.unsubscribe(pane.paneId);
+      if (pane.candleSeries) pane.candleSeries.setData([]);
+      if (typeof clearPaneForecastVisuals === 'function') {
+        clearPaneForecastVisuals(pane);
+      } else {
+        if (pane.forecastSeries?.candles) pane.forecastSeries.candles.setData([]);
+        if (pane.forecastSeries?.p50) pane.forecastSeries.p50.setData([]);
+        if (pane.forecastSeries?.p10) pane.forecastSeries.p10.setData([]);
+        if (pane.forecastSeries?.p90) pane.forecastSeries.p90.setData([]);
+      }
+      pane.lastCandleData = null;
+      pane.lastAnalysis = { payload: null, symbol: null, interval: null };
+      pane.error = null;
+      renderPaneAnalysisUI(pane);
+
+      // Reload
+      loadPaneData(pane).then(() => connectPaneWS(pane));
+      Workspace.save();
+    }
+
+    // Wire layout switcher buttons
+    if (layoutSwitcher) {
+      layoutSwitcher.addEventListener('click', (e) => {
+        const menuBtn = e.target.closest('#layoutMenuBtn');
+        if (menuBtn) {
+          e.stopPropagation();
+          const willOpen = !layoutSwitcher.classList.contains('open');
+          layoutSwitcher.classList.toggle('open', willOpen);
+          menuBtn.setAttribute('aria-expanded', willOpen ? 'true' : 'false');
+          return;
+        }
+        const btn = e.target.closest('button[data-layout]');
+        if (!btn) return;
+        e.stopPropagation();
+        const preset = parseInt(btn.dataset.layout);
+        if (!isNaN(preset)) switchLayout(preset);
+      });
+    }
+
+    document.addEventListener('click', (event) => {
+      if (!layoutSwitcher || layoutSwitcher.contains(event.target)) return;
+      layoutSwitcher.classList.remove('open');
+      const layoutMenuBtn = document.getElementById('layoutMenuBtn');
+      if (layoutMenuBtn) layoutMenuBtn.setAttribute('aria-expanded', 'false');
+    });
+
+    // Override explorer symbol selection for multi-pane
+    window._originalExplorerSelectSymbol = window.explorerSelectSymbol;
+    window.explorerSelectSymbol = function(sym) {
+      if (Workspace.layoutPreset > 1) {
+        applySymbolToActivePane(sym);
+        closeExplorer();
+      } else {
+        switchSymbol(sym);
+        closeExplorer();
+      }
+    };
+
+    // Wire Workspace active pane change callback
+    Workspace._onActivePaneChange = (paneId) => {
+      syncToolbarToPane(paneId);
+    };
+
+    async function refreshWorkspacePanes() {
+      if (!window.Workspace || !Workspace.panes || Workspace.layoutPreset <= 1) {
+        await refreshChart();
+        return;
+      }
+
+      const refreshTasks = [];
+      Workspace.panes.forEach((pane) => {
+        refreshTasks.push(
+          loadPaneData(pane).then(() => connectPaneWS(pane))
+        );
+      });
+
+      await Promise.allSettled(refreshTasks);
+      if (Workspace.activePaneId && Workspace.panes.has(Workspace.activePaneId)) {
+        syncToolbarToPane(Workspace.activePaneId);
+      }
+    }
+
+    // Add click handler to pane-0 for multi-pane mode
+    {
+      const p0Container = workspaceGrid.querySelector('[data-pane-id="pane-0"]');
+      if (p0Container) {
+        p0Container.addEventListener('click', () => {
+          Workspace.setActivePane('pane-0');
+          syncToolbarToPane('pane-0');
+        });
+      }
+    }
+
     /* ── Bootstrap ── */
     (async () => {
       // Restore theme preference (Default: light)
@@ -5013,32 +6177,397 @@
       // Start polling
       setInterval(refreshMarketStatus, 60000); // 1m
 
+      const restoredWorkspace = Workspace.restore();
+      if (
+        restoredWorkspace?.layoutPreset === 8 &&
+        Array.isArray(restoredWorkspace.panes) &&
+        restoredWorkspace.panes.some((pane) => pane?.symbol === 'USDX') &&
+        !restoredWorkspace.panes.some((pane) => pane?.symbol === 'DXY')
+      ) {
+        const symbols = new Set(restoredWorkspace.panes.map((pane) => pane?.symbol));
+        const usdxStrengthLayout = ['USDX', 'EURX', 'GBPX', 'CHFX', 'JPYX', 'CADX', 'AUDX', 'NZDX'];
+        if (usdxStrengthLayout.every((symbol) => symbols.has(symbol))) {
+          restoredWorkspace.panes = restoredWorkspace.panes.map((pane) => (
+            pane?.symbol === 'USDX'
+              ? { ...pane, symbol: 'DXY' }
+              : pane
+          ));
+        }
+      }
+      const restoredPane0State = restoredWorkspace?.panes?.find((pane) => pane.id === 'pane-0')
+        || restoredWorkspace?.panes?.[0]
+        || null;
+
+      if (restoredPane0State?.interval) {
+        timeframeSelect.value = restoredPane0State.interval;
+      }
+      if (restoredPane0State?.horizon) {
+        horizonInput.value = String(
+          Math.max(5, Math.min(300, parseInt(restoredPane0State.horizon, 10) || 10))
+        );
+      }
+      if (
+        restoredPane0State?.indicator &&
+        Array.from(indicatorSelect.options || []).some((option) => option.value === restoredPane0State.indicator)
+      ) {
+        indicatorSelect.value = restoredPane0State.indicator;
+      }
+
+      if (restoredWorkspace?.layoutPreset > 1) {
+        await switchLayout(restoredWorkspace.layoutPreset, { panes: restoredWorkspace.panes || [] });
+        if (restoredWorkspace.activePaneId && Workspace.panes.has(restoredWorkspace.activePaneId)) {
+          Workspace.setActivePane(restoredWorkspace.activePaneId);
+          syncToolbarToPane(restoredWorkspace.activePaneId);
+        }
+      } else if (restoredPane0State?.symbol) {
+        await switchSymbol(restoredPane0State.symbol);
+      } else {
+        await switchSymbol('XAUUSD');
+      }
 
-      // Default start
-      await switchSymbol('XAUUSD');
+      if (typeof indicatorSelect.onchange === 'function') {
+        indicatorSelect.onchange();
+      }
 
       // Setup auto-refresh (P1-10)
       let autoRefreshTimer = null;
       function scheduleAutoRefresh() {
         if (autoRefreshTimer) clearTimeout(autoRefreshTimer);
 
-        // Interval logic: 1m for 1m/5m, 5m for 15m/1h, etc.
+        // Interval logic: intraday refresh nhanh hơn, daily/weekly refresh chậm hơn để tránh tải thừa.
         const intv = timeframeSelect.value;
-        let delay = 300000; // 5m default
+        let delay = 900000; // 15m default for 1d
         if (intv === '1m' || intv === '5m') delay = 60000;
         else if (intv === '15m' || intv === '30m') delay = 180000;
         else if (intv === '1h' || intv === '4h') delay = 600000;
+        else if (intv === '1w') delay = 1800000;
 
         autoRefreshTimer = setTimeout(async () => {
           if (!document.hidden) {
             console.log('[AutoRefresh] Triggering...');
-            await refreshChart();
+            if (window.Workspace && Workspace.layoutPreset > 1) {
+              await refreshWorkspacePanes();
+            } else {
+              await refreshChart();
+            }
           }
           scheduleAutoRefresh();
         }, delay);
       }
       scheduleAutoRefresh();
     })();
+
+    function renderPaneCompactGauges(pane) {
+      if (Workspace.layoutPreset === 1 && pane?.paneId === 'pane-0') {
+        if (pane?.gaugesEl) {
+          pane.gaugesEl.innerHTML = '';
+          pane.gaugesEl.style.display = 'none';
+        }
+        return;
+      }
+      const payload = pane?.lastAnalysis?.payload;
+      if (!pane?.gaugesEl || !payload?.analysis) {
+        if (pane?.gaugesEl) pane.gaugesEl.innerHTML = '';
+        return;
+      }
+      pane.gaugesEl.style.display = '';
+
+      const a = payload.analysis;
+      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: '--' };
+      const comboActive = Boolean(summary.agreement || (Math.abs((technical.gauge ?? 50) - 50) > 6 && Math.abs((ai.gauge ?? 50) - 50) > 6 && Math.sign((technical.gauge ?? 50) - 50) === Math.sign((ai.gauge ?? 50) - 50)));
+
+      pane.gaugesEl.innerHTML = `
+        <div class="compact-gauge-card" style="cursor:pointer; --gauge-delay: 0s">
+          <div class="compact-gauge-title">Kỹ thuật</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" style="cursor:pointer; --gauge-delay: 0.08s">
+          <div class="compact-gauge-title">Dự báo AI</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 ${comboActive ? 'combo-strong' : ''}" style="cursor:pointer; --gauge-delay: 0.16s">
+          <div class="compact-gauge-title">Tổng kết</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>
+      `;
+
+      pane.gaugesEl.querySelectorAll('.compact-gauge-card').forEach((card) => {
+        card.addEventListener('click', (event) => {
+          event.stopPropagation();
+          if (pane.analysisButtonEl) pane.analysisButtonEl.click();
+        });
+      });
+    }
+
+    function paneActCls(act) {
+      return act === 'Mua' ? 'dt-act-buy' : act === 'Bán' ? 'dt-act-sell' : 'dt-act-neut';
+    }
+
+    buildPaneAnalysisMarkup = function buildPaneAnalysisMarkupOverride(pane) {
+      const payload = pane?.lastAnalysis?.payload;
+      if (pane?.analysisFetchController && !payload) {
+        return `<div class="pane-analysis-loading">AI đang phân tích ${pane.symbol} ${pane.interval}...</div>`;
+      }
+      if (!payload?.analysis) {
+        return `<div class="pane-analysis-empty">Chưa có dữ liệu phân tích cho ${pane?.symbol || '--'}.</div>`;
+      }
+
+      const a = payload.analysis;
+      if (!a.oscillators && !a.moving_averages) {
+        return `<div class="pane-analysis-loading">Đang tính toán phân tích kỹ thuật cho ${pane.symbol}...</div>`;
+      }
+
+      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 technicals = a.technicals || { gauge: 50, signal: '--', buy: 0, sell: 0, neutral: 0 };
+      const aiGauge = a.ai_gauge || { gauge: 50, signal: '--', certainty: 0, path_consistency: 0 };
+      const summary = a.summary || { signal: '--', gauge: 50 };
+      const dashboard = a.dashboard || {};
+      const pivots = (a.pivot_points || {}).data || [];
+      const comboActive = Boolean(summary.agreement || (Math.abs((technicals.gauge ?? 50) - 50) > 6 && Math.abs((aiGauge.gauge ?? 50) - 50) > 6 && Math.sign((technicals.gauge ?? 50) - 50) === Math.sign((aiGauge.gauge ?? 50) - 50)));
+      const forecastRows = payload.forecast || [];
+      const lastClose = payload.last_close || 0;
+      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);
+      const oscRows = osc.data.map(d => `<tr><td>${d.name}</td><td class="dt-val">${d.value !== null ? d.value : '—'}</td><td class="dt-act ${paneActCls(d.action)}">${d.action}</td></tr>`).join('');
+      const maRows = ma.data.map(d => `<tr><td>${d.name}</td><td class="dt-val">${d.value !== null ? d.value : '—'}</td><td class="dt-act ${paneActCls(d.action)}">${d.action}</td></tr>`).join('');
+      const pivotRows = pivots.map(p => `<tr><td>${p.level}</td><td>${p.classic ?? '—'}</td><td>${p.fibonacci ?? '—'}</td><td>${p.camarilla ?? '—'}</td><td>${p.woodie ?? '—'}</td><td>${p.dm ?? '—'}</td></tr>`).join('');
+      const sLabel = symbolMap.get(pane.symbol) || pane.symbol;
+      const tLabel = timeframeMap[pane.interval] || pane.interval;
+      const paneFormatPrice = (value) => {
+        if (value === null || value === undefined || Number.isNaN(Number(value))) return '--';
+        const precision = Math.max(0, Math.min(8, Number(pane.priceFormat?.precision ?? 2)));
+        return Number(value).toLocaleString('en-US', {
+          minimumFractionDigits: precision,
+          maximumFractionDigits: precision,
+        });
+      };
+
+      return `
+        <div class="pane-analysis-sheet">
+          <div class="pane-analysis-title">
+            <span>${sLabel} · ${tLabel}</span>
+            <div class="pane-analysis-meta">
+              <span class="pane-analysis-pill">${payload.source || 'N/A'}</span>
+              <span class="pane-analysis-pill">${payload.verdict || summary.signal || 'NEUTRAL'}</span>
+            </div>
+          </div>
+          <div class="dash-gauges-hero pane-dash-gauges ${comboActive ? 'combo-active' : ''}">
+            <div class="gauge-hero-card" style="--gauge-delay: 0s">
+              <div class="gauge-hero-title">PHÂN TÍCH KỸ THUẬT</div>
+              <div class="gauge-hero-svg-wrap">${buildGaugeSvg(gaugeToRawScore(technicals.gauge), 220, 150, true)}</div>
+              <div class="gauge-hero-signal ${getSignalClass(technicals.signal)}">${technicals.signal}</div>
+              <div class="gauge-hero-counts">
+                <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>
+            <div class="gauge-hero-card" style="--gauge-delay: 0.08s">
+              <div class="gauge-hero-title">DỰ BÁO AI</div>
+              <div class="gauge-hero-svg-wrap">${buildGaugeSvg(gaugeToRawScore(aiGauge.gauge), 220, 150, true)}</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">${paneFormatPrice(aiCurrentPrice)}</span></div>
+                <div class="gh-ai-row"><span class="gh-ai-label">Dự kiến:</span><span class="gh-ai-val">${paneFormatPrice(forecastEnd)}</span></div>
+                <div class="gh-ai-row"><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:</span><span class="gh-ai-val">${Number(aiGauge.path_consistency ?? 0).toFixed(1)}%</span></div>
+              </div>
+              <div class="gauge-hero-signal ${getSignalClass(aiGauge.signal)}">${aiGauge.signal}</div>
+            </div>
+            <div class="gauge-hero-card hero-total summary-derived ${comboActive ? 'combo-strong' : ''}" style="--gauge-delay: 0.16s">
+              <div class="gauge-hero-title title-total">⚡ TỔNG KẾT</div>
+              <div class="gauge-hero-svg-wrap">${buildGaugeSvg(gaugeToRawScore(summary.gauge), 220, 150, true)}</div>
+              <div class="gauge-hero-signal signal-total ${getSignalClass(summary.signal)}">${summary.signal}</div>
+            </div>
+          </div>
+          <div class="dash-tables-row pane-dash-tables">
+            <div class="dash-col">
+              <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>
+            <div class="dash-col">
+              <div class="dc-header">Trung bình trượt</div>
+              <div class="dash-table-wrap">
+                <table class="dt"><tbody>${maRows}</tbody></table>
+              </div>
+            </div>
+            <div class="dash-col col-pivots">
+              <div class="dc-header">Điểm xoay</div>
+              <div class="dash-table-wrap">
+                <table class="pivot-table">
+                  <thead><tr><th>Mức</th><th>CL</th><th>FB</th><th>CM</th><th>WD</th><th>DM</th></tr></thead>
+                  <tbody>${pivotRows}</tbody>
+                </table>
+              </div>
+            </div>
+          </div>
+          <div class="summary-disclaimer">
+            <strong>⚠ Cảnh báo</strong> — Thông tin phân tích kỹ thuật này không phải lời khuyên đầu tư. Hãy luôn quản lý rủi ro.
+          </div>
+        </div>
+      `;
+    };
+
+    renderPaneAnalysisUI = function renderPaneAnalysisUIOverride(pane) {
+      if (!pane) return;
+      if (pane.analysisButtonEl) {
+        let state = 'idle';
+        if (pane.analysisFetchController) state = 'loading';
+        else if (pane.lastAnalysis && pane.lastAnalysis.payload) state = 'ready';
+        else if (pane.error) state = 'error';
+        pane.analysisButtonEl.dataset.state = state;
+        pane.analysisButtonEl.setAttribute('aria-label', `Phân tích ${pane.symbol} ${pane.interval}`);
+      }
+      renderPaneCompactGauges(pane);
+      if (pane.analysisOverlayEl) {
+        pane.analysisOverlayEl.innerHTML = buildPaneAnalysisMarkup(pane);
+        pane.analysisOverlayEl.classList.toggle('active', Boolean(pane.analysisOpen));
+      }
+    };
+    window.renderPaneAnalysisUI = renderPaneAnalysisUI;
+    window.renderPaneCompactGauges = renderPaneCompactGauges;
+
+    bindPaneAnalysisButton = function bindPaneAnalysisButtonOverride(pane) {
+      if (!pane?.analysisButtonEl) return;
+      pane.analysisButtonEl.onclick = (event) => {
+        event.stopPropagation();
+        if (window.Workspace && typeof Workspace.setActivePane === 'function') {
+          Workspace.setActivePane(pane.paneId);
+        }
+        const willOpen = !pane.analysisOpen;
+        setPaneAnalysisOpen(pane, willOpen);
+        renderPaneAnalysisUI(pane);
+        if (willOpen && (!pane.lastAnalysis || !pane.lastAnalysis.payload) && typeof pane.fetchAI === 'function') {
+          pane.fetchAI({ force: true });
+        }
+      };
+    };
+
+    refreshBtn.onclick = () => {
+      const pane = window.Workspace && typeof Workspace.getActivePane === 'function'
+        ? Workspace.getActivePane()
+        : null;
+      if (!pane) return;
+      const willOpen = !pane.analysisOpen;
+      setPaneAnalysisOpen(pane, willOpen);
+      renderPaneAnalysisUI(pane);
+      if (willOpen && typeof pane.fetchAI === 'function') {
+        pane.fetchAI({ force: !pane.lastAnalysis?.payload });
+      }
+    };
+
+    if (window.Workspace && Workspace.panes) {
+      Workspace.panes.forEach((pane) => {
+        bindPaneAnalysisButton(pane);
+        renderPaneAnalysisUI(pane);
+      });
+    }
+
+    function clearFullscreenPaneSelection() {
+      if (!window.Workspace || !Workspace.panes) return;
+      Workspace.panes.forEach((pane) => {
+        pane.analysisOpen = false;
+        if (pane.analysisButtonEl) pane.analysisButtonEl.classList.remove('active');
+      });
+    }
+
+    function openPaneFullscreenAnalysis(pane, options = {}) {
+      if (!pane) return;
+      if (window.Workspace && typeof Workspace.setActivePane === 'function') {
+        Workspace.setActivePane(pane.paneId);
+      }
+
+      const showPayload = (payload) => {
+        if (!payload) return;
+        clearFullscreenPaneSelection();
+        pane.analysisOpen = true;
+        if (pane.analysisButtonEl) pane.analysisButtonEl.classList.add('active');
+        renderAnalysisPanel(pane.symbol, pane.interval, payload);
+        analysisPanel.classList.add('active');
+        setTimeout(updateDashboardScale, 10);
+      };
+
+      if (pane.lastAnalysis?.payload && !options.force) {
+        showPayload(pane.lastAnalysis.payload);
+        return;
+      }
+
+      analysisPanel.classList.add('active');
+      analysisPanel.innerHTML = `
+        <div class="dash-loading">
+          <div class="loader-ring" style="width:48px;height:48px;"></div>
+          <p>AI đang khởi tạo dữ liệu cho ${pane.symbol} ${pane.interval}...</p>
+        </div>
+      `;
+
+      if (typeof pane.fetchAI === 'function') {
+        pane.fetchAI({ force: true }).then((payload) => {
+          if (payload) showPayload(payload);
+        });
+      }
+    }
+
+    bindPaneAnalysisButton = function bindPaneAnalysisButtonFullscreen(pane) {
+      if (!pane?.analysisButtonEl) return;
+      pane.analysisButtonEl.onclick = (event) => {
+        event.stopPropagation();
+        openPaneFullscreenAnalysis(pane);
+      };
+    };
+
+    refreshBtn.onclick = () => {
+      const pane = window.Workspace && typeof Workspace.getActivePane === 'function'
+        ? Workspace.getActivePane()
+        : null;
+      if (!pane) return;
+      openPaneFullscreenAnalysis(pane);
+    };
+
+    renderPaneAnalysisUI = function renderPaneAnalysisUIFullscreen(pane) {
+      if (!pane) return;
+      if (pane.analysisButtonEl) {
+        let state = 'idle';
+        if (pane.analysisFetchController) state = 'loading';
+        else if (pane.lastAnalysis && pane.lastAnalysis.payload) state = 'ready';
+        else if (pane.error) state = 'error';
+        pane.analysisButtonEl.dataset.state = state;
+        pane.analysisButtonEl.setAttribute('aria-label', `Phân tích ${pane.symbol} ${pane.interval}`);
+        pane.analysisButtonEl.classList.toggle('active', Boolean(pane.analysisOpen));
+      }
+      renderPaneCompactGauges(pane);
+    };
+    window.renderPaneAnalysisUI = renderPaneAnalysisUI;
+
+    document.addEventListener('click', (event) => {
+      const closeBtn = event.target.closest('#dashCloseBtn');
+      if (!closeBtn) return;
+      clearFullscreenPaneSelection();
+    });
+
+    if (window.Workspace && Workspace.panes) {
+      Workspace.panes.forEach((pane) => {
+        bindPaneAnalysisButton(pane);
+        renderPaneAnalysisUI(pane);
+        if (pane.gaugesEl) {
+          pane.gaugesEl.querySelectorAll('.compact-gauge-card').forEach((card) => {
+            card.onclick = (event) => {
+              event.stopPropagation();
+              openPaneFullscreenAnalysis(pane);
+            };
+          });
+        }
+      });
+    }
   </script>
 </body>
 

frontend/workspace.css

@@ -0,0 +1,603 @@
+/* ═══════════════════════════════════════════════════════
+   KRONOS MULTI-CHART WORKSPACE — CSS
+   ═══════════════════════════════════════════════════════ */
+
+/* ── Layout Switcher (ultra-compact pill) ──────────── */
+.layout-menu {
+  position: relative;
+  flex: 0 0 auto;
+  min-width: 0;
+}
+
+.layout-menu-button {
+  height: var(--ctrl-h);
+  min-width: 78px;
+  padding: 0 12px;
+  display: inline-flex;
+  align-items: center;
+  justify-content: center;
+  gap: 8px;
+  border-radius: var(--radius);
+  border: 1px solid var(--bdr-base);
+  background: var(--bg-control);
+  color: var(--txt-secondary);
+  font-family: var(--ff-display);
+  font-size: 0.78rem;
+  font-weight: 700;
+  letter-spacing: 0.08em;
+  text-transform: uppercase;
+  cursor: pointer;
+  transition: all 0.2s ease;
+  white-space: nowrap;
+}
+
+.layout-menu-button:hover,
+.layout-menu.open .layout-menu-button {
+  border-color: rgba(88, 170, 255, 0.52);
+  box-shadow: 0 10px 24px rgba(34, 123, 255, 0.16);
+  color: var(--txt-primary);
+}
+
+.layout-menu-current {
+  display: inline-flex;
+  align-items: center;
+  justify-content: center;
+  min-width: 22px;
+  height: 22px;
+  padding: 0 6px;
+  border-radius: 999px;
+  background: rgba(34, 211, 238, 0.14);
+  color: var(--accent);
+  font-family: var(--ff-mono, 'Space Mono', monospace);
+  font-size: 0.68rem;
+}
+
+.layout-menu-popup {
+  position: absolute;
+  top: calc(100% + 10px);
+  right: 0;
+  min-width: 190px;
+  padding: 10px;
+  border-radius: 18px;
+  border: 1px solid rgba(255, 255, 255, 0.32);
+  background: linear-gradient(180deg, rgba(255, 255, 255, 0.92) 0%, rgba(241, 247, 255, 0.9) 100%);
+  box-shadow: 0 26px 56px rgba(28, 56, 108, 0.18);
+  backdrop-filter: blur(22px) saturate(175%);
+  -webkit-backdrop-filter: blur(22px) saturate(175%);
+  display: grid;
+  grid-template-columns: repeat(2, minmax(0, 1fr));
+  gap: 8px;
+  opacity: 0;
+  pointer-events: none;
+  transform: translateY(-6px) scale(0.98);
+  transform-origin: top right;
+  transition: opacity 0.18s ease, transform 0.18s ease;
+  z-index: 120;
+}
+
+.layout-menu.open .layout-menu-popup {
+  opacity: 1;
+  pointer-events: auto;
+  transform: translateY(0) scale(1);
+}
+
+.layout-menu-option {
+  min-height: 58px;
+  border: 1px solid rgba(120, 157, 218, 0.18);
+  border-radius: 14px;
+  background: rgba(255, 255, 255, 0.52);
+  color: var(--txt-secondary);
+  display: flex;
+  flex-direction: column;
+  align-items: flex-start;
+  justify-content: center;
+  gap: 3px;
+  padding: 10px 12px;
+  cursor: pointer;
+  transition: all 0.18s ease;
+}
+
+.layout-menu-option:hover,
+.layout-menu-option.active {
+  border-color: rgba(64, 154, 255, 0.46);
+  color: var(--txt-primary);
+  box-shadow: 0 12px 24px rgba(51, 110, 194, 0.14);
+}
+
+.layout-menu-option strong {
+  font-size: 0.88rem;
+  line-height: 1;
+}
+
+.layout-menu-option span {
+  font-size: 0.64rem;
+  opacity: 0.78;
+  letter-spacing: 0.04em;
+  text-transform: uppercase;
+}
+
+/* ── Workspace Grid ────────────────────────────────── */
+.workspace-grid {
+  display: grid;
+  width: 100%;
+  height: 100%;
+  gap: 2px;
+  padding: 0;
+  position: relative;
+}
+
+.workspace-grid.layout-1 {
+  grid-template-columns: 1fr;
+  grid-template-rows: 1fr;
+}
+
+.workspace-grid.layout-2 {
+  grid-template-columns: 1fr 1fr;
+  grid-template-rows: 1fr;
+}
+
+.workspace-grid.layout-4 {
+  grid-template-columns: 1fr 1fr;
+  grid-template-rows: 1fr 1fr;
+}
+
+.workspace-grid.layout-8 {
+  grid-template-columns: repeat(4, 1fr);
+  grid-template-rows: 1fr 1fr;
+}
+
+/* ── Chart Pane ────────────────────────────────────── */
+.chart-pane {
+  position: relative;
+  border: 1px solid var(--bdr-muted);
+  border-radius: 8px;
+  overflow: hidden;
+  background: var(--bg-depth);
+  transition: border-color 0.25s ease, box-shadow 0.25s ease;
+  min-height: 0;
+  min-width: 0;
+}
+
+.chart-pane:hover {
+  border-color: var(--bdr-subtle, rgba(34, 211, 238, 0.2));
+}
+
+.chart-pane.active {
+  border-color: var(--accent);
+  box-shadow:
+    0 0 0 1px var(--accent),
+    inset 0 0 20px rgba(34, 211, 238, 0.04);
+}
+
+/* ── Pane Mini Header ──────────────────────────────── */
+.pane-header-mini {
+  position: absolute;
+  top: 3px;
+  left: 6px;
+  z-index: 10;
+  display: flex;
+  align-items: center;
+  gap: 4px;
+  font-family: var(--ff-display);
+  font-size: 0.62rem;
+  opacity: 0.85;
+  pointer-events: none;
+  user-select: none;
+}
+
+.layout-1 .pane-header-mini {
+  display: none; /* single pane doesn't need mini header */
+}
+
+.pane-symbol {
+  font-weight: 700;
+  color: var(--accent);
+  letter-spacing: 0.03em;
+}
+
+.pane-sep {
+  color: var(--txt-muted);
+  opacity: 0.5;
+}
+
+.pane-interval {
+  font-weight: 500;
+  color: var(--txt-secondary);
+  text-transform: uppercase;
+}
+
+.pane-price {
+  font-weight: 600;
+  color: var(--txt-primary);
+  margin-left: 3px;
+  font-family: var(--ff-mono, 'Space Mono', monospace);
+  font-size: 0.6rem;
+}
+
+/* ── Pane Chart Container ──────────────────────────── */
+.pane-chart {
+  width: 100%;
+  height: 100%;
+  position: absolute;
+  top: 0;
+  left: 0;
+  right: 0;
+  bottom: 0;
+}
+
+/* ── Pane Loader ───────────────────────────────────── */
+.pane-loader {
+  position: absolute;
+  inset: 0;
+  display: flex;
+  align-items: center;
+  justify-content: center;
+  background: rgba(4, 13, 30, 0.5);
+  backdrop-filter: blur(4px);
+  z-index: 15;
+  transition: opacity 0.3s ease;
+}
+
+.pane-loader.hidden {
+  opacity: 0;
+  pointer-events: none;
+}
+
+.pane-loader .loader-ring {
+  width: 28px;
+  height: 28px;
+  border-radius: 50%;
+  border: 2px solid rgba(40, 80, 140, 0.15);
+  border-top-color: var(--accent);
+  animation: spin 0.8s linear infinite;
+}
+
+/* ── Pane Gauges ───────────────────────────────────── */
+.pane-gauges {
+  position: absolute;
+  top: 30px;
+  left: 6px;
+  right: auto;
+  z-index: 10;
+  display: flex;
+  gap: 5px;
+  flex-wrap: wrap;
+  justify-content: flex-start;
+  max-width: min(68%, 288px);
+  pointer-events: auto;
+}
+
+.layout-1 .pane-gauges {
+  top: 40px;
+  max-width: min(72%, 400px);
+}
+
+.pane-gauge-chip {
+  min-height: 22px;
+  padding: 0 8px;
+  border-radius: 999px;
+  border: 1px solid rgba(110, 156, 229, 0.24);
+  background: rgba(5, 17, 36, 0.78);
+  color: rgba(225, 236, 255, 0.92);
+  display: inline-flex;
+  align-items: center;
+  gap: 6px;
+  font-family: var(--ff-mono, 'Space Mono', monospace);
+  font-size: 0.62rem;
+  line-height: 1;
+  box-shadow: 0 10px 24px rgba(0, 0, 0, 0.16);
+  backdrop-filter: blur(10px);
+}
+
+.pane-gauge-chip b {
+  font-size: 0.66rem;
+}
+
+.pane-gauge-chip[data-tone="bull"] {
+  border-color: rgba(16, 185, 129, 0.34);
+  color: #c9ffe9;
+}
+
+.pane-gauge-chip[data-tone="bear"] {
+  border-color: rgba(244, 63, 94, 0.34);
+  color: #ffd2dc;
+}
+
+.pane-gauge-chip[data-tone="flat"] {
+  border-color: rgba(96, 165, 250, 0.3);
+  color: #d7e9ff;
+}
+
+.pane-gauge-verdict {
+  min-height: 22px;
+  padding: 0 9px;
+  border-radius: 999px;
+  background: rgba(34, 211, 238, 0.14);
+  border: 1px solid rgba(34, 211, 238, 0.28);
+  color: var(--accent);
+  display: inline-flex;
+  align-items: center;
+  font-family: var(--ff-display);
+  font-size: 0.6rem;
+  font-weight: 700;
+  letter-spacing: 0.08em;
+  text-transform: uppercase;
+  box-shadow: 0 10px 24px rgba(18, 87, 136, 0.18);
+}
+
+.pane-analysis-btn {
+  position: absolute;
+  top: 6px;
+  right: 6px;
+  z-index: 12;
+  min-width: 52px;
+  height: 22px;
+  padding: 0 7px;
+  border-radius: 999px;
+  border: 1px solid rgba(110, 156, 229, 0.26);
+  background: rgba(7, 18, 38, 0.84);
+  color: rgba(229, 239, 255, 0.92);
+  display: inline-flex;
+  align-items: center;
+  justify-content: center;
+  gap: 6px;
+  font-family: var(--ff-display);
+  font-size: 0.54rem;
+  font-weight: 700;
+  letter-spacing: 0.08em;
+  text-transform: uppercase;
+  cursor: pointer;
+  box-shadow: 0 10px 28px rgba(2, 8, 23, 0.28);
+  backdrop-filter: blur(10px);
+  transition: border-color 0.18s ease, transform 0.18s ease, box-shadow 0.18s ease;
+}
+
+.pane-analysis-btn:hover {
+  transform: translateY(-1px);
+  border-color: rgba(34, 211, 238, 0.42);
+  box-shadow: 0 12px 28px rgba(8, 47, 73, 0.28);
+}
+
+.pane-analysis-btn .dot {
+  width: 6px;
+  height: 6px;
+  border-radius: 50%;
+  background: rgba(148, 163, 184, 0.9);
+  box-shadow: 0 0 0 3px rgba(148, 163, 184, 0.14);
+}
+
+.pane-analysis-btn[data-state="loading"] .dot {
+  background: #f59e0b;
+  box-shadow: 0 0 0 3px rgba(245, 158, 11, 0.16);
+}
+
+.pane-analysis-btn[data-state="ready"] .dot {
+  background: #10b981;
+  box-shadow: 0 0 0 3px rgba(16, 185, 129, 0.16);
+}
+
+.pane-analysis-btn[data-state="error"] .dot {
+  background: #f43f5e;
+  box-shadow: 0 0 0 3px rgba(244, 63, 94, 0.16);
+}
+
+.pane-analysis-btn.active {
+  border-color: rgba(34, 211, 238, 0.48);
+  color: #effbff;
+  box-shadow: 0 12px 28px rgba(8, 47, 73, 0.36);
+}
+
+.pane-analysis-overlay {
+  display: none !important;
+}
+
+.pane-analysis-overlay.active {
+  display: none !important;
+}
+
+.pane-analysis-title {
+  display: flex;
+  align-items: center;
+  justify-content: space-between;
+  gap: 10px;
+  margin-bottom: 10px;
+  font-family: var(--ff-display);
+  font-size: 0.72rem;
+  font-weight: 700;
+  letter-spacing: 0.08em;
+  text-transform: uppercase;
+}
+
+.pane-analysis-meta {
+  display: inline-flex;
+  align-items: center;
+  gap: 8px;
+  flex-wrap: wrap;
+}
+
+.pane-analysis-pill {
+  min-height: 21px;
+  padding: 0 8px;
+  border-radius: 999px;
+  border: 1px solid rgba(110, 156, 229, 0.22);
+  background: rgba(255, 255, 255, 0.04);
+  display: inline-flex;
+  align-items: center;
+  font-size: 0.58rem;
+  letter-spacing: 0.04em;
+}
+
+.pane-analysis-grid {
+  display: grid;
+  grid-template-columns: repeat(2, minmax(0, 1fr));
+  gap: 8px;
+}
+
+.pane-analysis-card {
+  border-radius: 12px;
+  border: 1px solid rgba(110, 156, 229, 0.18);
+  background: rgba(255, 255, 255, 0.04);
+  padding: 9px 10px;
+}
+
+.pane-analysis-card strong {
+  display: block;
+  margin-bottom: 5px;
+  font-size: 0.62rem;
+  letter-spacing: 0.06em;
+  text-transform: uppercase;
+  color: rgba(180, 214, 255, 0.92);
+}
+
+.pane-analysis-body {
+  font-size: 0.72rem;
+  line-height: 1.45;
+  color: rgba(235, 244, 255, 0.92);
+}
+
+.pane-analysis-loading,
+.pane-analysis-empty {
+  min-height: 92px;
+  display: flex;
+  align-items: center;
+  justify-content: center;
+  text-align: center;
+  font-size: 0.74rem;
+  color: rgba(210, 224, 244, 0.86);
+}
+
+/* ── Multi-pane responsive ─────────────────────────── */
+.pane-gauges .compact-gauge-card {
+  min-width: 66px;
+  width: 66px;
+  min-height: 82px;
+  padding: 5px 4px 6px;
+  border-radius: 11px;
+}
+
+.pane-gauges .compact-gauge-title {
+  font-size: 0.5rem;
+}
+
+.pane-gauges .compact-gauge-signal {
+  font-size: 0.46rem;
+  line-height: 1.15;
+}
+
+.pane-analysis-sheet .dash-gauges-hero {
+  gap: 10px;
+  margin-bottom: 10px;
+}
+
+.pane-analysis-sheet .gauge-hero-card {
+  min-height: auto;
+  padding: 12px 10px 10px;
+  border-radius: 14px;
+}
+
+.pane-analysis-sheet .gauge-hero-title {
+  font-size: 0.62rem;
+}
+
+.pane-analysis-sheet .gauge-hero-signal {
+  font-size: 0.64rem;
+  padding: 6px 10px;
+}
+
+.pane-analysis-sheet .gauge-hero-counts {
+  gap: 8px;
+  font-size: 0.58rem;
+}
+
+.pane-analysis-sheet .gh-ai-row {
+  font-size: 0.6rem;
+}
+
+.pane-analysis-sheet .dash-tables-row {
+  gap: 10px;
+}
+
+.pane-analysis-sheet .dash-col {
+  min-height: 0;
+  max-height: 220px;
+}
+
+.pane-analysis-sheet .dash-table-wrap {
+  max-height: 170px;
+}
+
+.pane-analysis-sheet .dt,
+.pane-analysis-sheet .pivot-table {
+  font-size: 0.6rem;
+}
+
+.pane-analysis-sheet .dc-header {
+  font-size: 0.68rem;
+  margin-bottom: 8px;
+}
+
+.pane-analysis-sheet .summary-disclaimer {
+  margin-top: 10px;
+  padding: 10px 12px;
+  font-size: 0.66rem;
+}
+
+@media (max-width: 900px) {
+  .layout-menu-popup {
+    right: auto;
+    left: 0;
+    transform-origin: top left;
+  }
+
+  .workspace-grid.layout-8 {
+    grid-template-columns: repeat(2, 1fr);
+    grid-template-rows: repeat(4, 1fr);
+  }
+}
+
+@media (max-width: 600px) {
+  .layout-menu-button {
+    min-width: 62px;
+    padding: 0 10px;
+    gap: 6px;
+    font-size: 0.72rem;
+  }
+
+  .layout-menu-popup {
+    min-width: 168px;
+    grid-template-columns: 1fr;
+  }
+
+  .workspace-grid.layout-4 {
+    grid-template-columns: 1fr;
+    grid-template-rows: repeat(4, 1fr);
+  }
+
+  .workspace-grid.layout-2 {
+    grid-template-columns: 1fr;
+    grid-template-rows: 1fr 1fr;
+  }
+
+  .workspace-grid.layout-8 {
+    grid-template-columns: 1fr;
+    grid-template-rows: repeat(8, 1fr);
+  }
+
+  .pane-gauges,
+  .layout-1 .pane-gauges {
+    max-width: calc(100% - 16px);
+  }
+
+  .pane-analysis-grid {
+    grid-template-columns: 1fr;
+  }
+
+  .pane-analysis-overlay {
+    max-height: min(56%, 320px);
+  }
+
+  .pane-analysis-sheet .dash-gauges-hero,
+  .pane-analysis-sheet .dash-tables-row {
+    grid-template-columns: 1fr;
+  }
+}

frontend/workspace.js

@@ -0,0 +1,765 @@
+/**
+ * ═══════════════════════════════════════════════════════
+ *  KRONOS MULTI-CHART WORKSPACE ENGINE (V1)
+ *  Provides: PaneState, ChartPaneController, StreamManager,
+ *            DataCoordinator, WorkspaceController
+ * ═══════════════════════════════════════════════════════
+ */
+
+/* ── Constants ────────────────────────────────────── */
+const WORKSPACE_STORAGE_KEY = 'kronos_workspace';
+const CHART_HISTORY_LIMIT_WS = 500;
+const MAX_CONCURRENT_FETCHES = 4;
+const WS_RECONNECT_DELAY = 5000;
+const LAYOUT_PRESETS = [1, 2, 4, 8];
+const LAYOUT_GRID_MAP = {
+  1: { cols: 1, rows: 1 },
+  2: { cols: 2, rows: 1 },
+  4: { cols: 2, rows: 2 },
+  8: { cols: 4, rows: 2 },
+};
+
+/* ══════════════════════════════════════════════════════
+   PaneState — Per-pane data container
+   ══════════════════════════════════════════════════════ */
+class PaneState {
+  constructor(id, symbol = 'XAUUSD', interval = '1d') {
+    this.paneId = id;
+    this.symbol = symbol;
+    this.interval = interval;
+    this.indicatorMode = 'none';
+    this.horizon = 10;
+
+    // Chart instances (set by ChartPaneController)
+    this.chartInstance = null;
+    this.candleSeries = null;
+    this.forecastSeries = { candles: null, p50: null, p10: null, p90: null, segments: [] };
+    this.indicatorSeries = { bbUpper: null, bbMid: null, bbLower: null, rsi: null };
+
+    // Network
+    this.fetchController = null;
+    this.analysisFetchController = null;
+    this.analysisRequestPromise = null;
+    this.analysisRequestKey = null;
+    this.analysisRetryTimer = null;
+
+    // Data
+    this.lastCandleData = null;
+    this.lastAnalysis = { payload: null, symbol: null, interval: null };
+    this.chartContext = { symbol: null, interval: null };
+    this.forecastContext = { symbol: null, interval: null, ready: false };
+    this.priceFormat = { precision: 2, minMove: 0.01 };
+
+    // UI
+    this.loading = false;
+    this.error = null;
+
+    // DOM refs (set during mount)
+    this.containerEl = null;
+    this.chartEl = null;
+    this.loaderEl = null;
+    this.gaugesEl = null;
+    this.paneHeaderEl = null;
+    this.priceEl = null;
+    this.analysisButtonEl = null;
+    this.analysisOverlayEl = null;
+    this.analysisOpen = false;
+  }
+
+  hasMatchingAnalysis() {
+    return Boolean(
+      this.lastAnalysis &&
+      this.lastAnalysis.payload &&
+      this.lastAnalysis.symbol === this.symbol &&
+      this.lastAnalysis.interval === this.interval
+    );
+  }
+
+  hasMatchingForecast() {
+    return Boolean(
+      this.forecastContext &&
+      this.forecastContext.ready &&
+      this.forecastContext.symbol === this.symbol &&
+      this.forecastContext.interval === this.interval
+    );
+  }
+
+  
+  async fetchAI(options = {}) {
+    const horizon = this.horizon || 24;
+    const requestSymbol = this.symbol;
+    const requestInterval = this.interval;
+    const requestHorizon = horizon;
+    const requestKey = `${requestSymbol}|${requestInterval}|${requestHorizon}`;
+
+    if (!options.force && this.analysisRequestPromise && this.analysisRequestKey === requestKey) {
+      return this.analysisRequestPromise;
+    }
+
+    if (this.analysisRetryTimer) {
+      clearTimeout(this.analysisRetryTimer);
+      this.analysisRetryTimer = null;
+    }
+    if (this.analysisFetchController) {
+      this.analysisFetchController.abort();
+    }
+
+    if (typeof window.clearPaneForecastCandlesOnly === 'function') {
+      window.clearPaneForecastCandlesOnly(this);
+    } else if (this.forecastSeries?.candles?.setData) {
+      this.forecastSeries.candles.setData([]);
+      if (this.forecastSeries.candles.applyOptions) {
+        this.forecastSeries.candles.applyOptions({ visible: false });
+      }
+    }
+
+    const controller = new AbortController();
+    this.analysisFetchController = controller;
+    this.analysisRequestKey = requestKey;
+
+    // Show loading in mini gauges
+    const shouldRenderPaneGauges = !(window.Workspace?.layoutPreset === 1 && this.paneId === 'pane-0');
+    if (this.gaugesEl && shouldRenderPaneGauges && !this.hasMatchingAnalysis()) {
+      this.gaugesEl.innerHTML = '<div class="loader-ring" style="width:16px;height:16px;border:2px solid rgba(40,80,140,0.15);border-top-color:var(--accent);animation:spin 0.8s linear infinite;border-radius:50%;"></div>';
+    }
+
+    const requestPromise = (async () => {
+      try {
+        const fData = await DataCoordinator.fetchForecast(requestSymbol, requestInterval, requestHorizon, controller.signal);
+        if (controller.signal.aborted) return null;
+        if (
+          this.symbol !== requestSymbol
+          || this.interval !== requestInterval
+          || (this.horizon || 24) !== requestHorizon
+        ) {
+          return null;
+        }
+        
+        const hasAnalysis = Boolean(fData?.analysis);
+        if (hasAnalysis) {
+          this.lastAnalysis = { payload: fData, symbol: requestSymbol, interval: requestInterval };
+        }
+        
+        const forecastPoints = Array.isArray(fData.forecast) ? fData.forecast : [];
+        if (this.lastCandleData && this.forecastSeries?.p50) {
+          const fallbackActualPoint = {
+            time: this.lastCandleData.time,
+            value: (
+              Number(this.lastCandleData.open ?? 0)
+              + Number(this.lastCandleData.high ?? 0)
+              + Number(this.lastCandleData.low ?? 0)
+              + Number(this.lastCandleData.close ?? 0)
+            ) / 4,
+          };
+          const forecastLine = typeof window.buildForecastLineFromRows === 'function'
+            ? window.buildForecastLineFromRows(forecastPoints, fallbackActualPoint)
+            : [fallbackActualPoint, ...forecastPoints
+              .filter(d => d && d.time !== undefined && d.p50 !== undefined && d.time !== this.lastCandleData.time)
+              .map(d => ({ time: d.time, value: d.p50 }))];
+          const hasForecast = forecastLine.length > 1;
+
+          if (hasForecast) {
+            if (typeof window.renderPaneForecastVisuals === 'function') {
+              window.renderPaneForecastVisuals(this, forecastLine);
+            } else {
+              if (this.forecastSeries.candles?.setData) {
+                this.forecastSeries.candles.setData([]);
+              }
+              if (this.forecastSeries.p10?.setData) {
+                this.forecastSeries.p10.setData([]);
+              }
+              if (this.forecastSeries.p90?.setData) {
+                this.forecastSeries.p90.setData([]);
+              }
+              this.forecastSeries.p50.setData(forecastLine);
+            }
+            this.forecastContext = { symbol: requestSymbol, interval: requestInterval, ready: true };
+          }
+        }
+
+        if (typeof window.renderPaneAnalysisUI === 'function') {
+          window.renderPaneAnalysisUI(this);
+        }
+
+        if (
+          hasAnalysis &&
+          typeof window.Workspace !== 'undefined' &&
+          window.Workspace?.activePaneId === this.paneId &&
+          typeof window.renderCompactGauges === 'function'
+        ) {
+          window.renderCompactGauges(this.symbol, this.interval, fData);
+        }
+
+        if (
+          hasAnalysis &&
+          this.analysisOpen &&
+          typeof window.renderAnalysisPanel === 'function' &&
+          typeof document !== 'undefined'
+        ) {
+          const analysisPanel = document.getElementById('analysisPanel');
+          if (analysisPanel?.classList.contains('active')) {
+            window.renderAnalysisPanel(this.symbol, this.interval, fData);
+            if (typeof window.updateDashboardScale === 'function') {
+              setTimeout(window.updateDashboardScale, 10);
+            }
+          }
+        }
+
+        return fData;
+      } catch (e) {
+        if (e.name === 'AbortError') return null;
+        console.error(`[Pane ${this.paneId}] AI fetch error:`, e);
+        if (typeof window.renderPaneAnalysisUI === 'function') {
+          window.renderPaneAnalysisUI(this);
+        }
+        
+        // Retry
+        this.analysisRetryTimer = setTimeout(() => {
+          this.analysisRetryTimer = null;
+          this.fetchAI({ force: true });
+        }, 15000);
+        
+        return null;
+      } finally {
+        if (this.analysisFetchController === controller) {
+          this.analysisFetchController = null;
+        }
+      }
+    })();
+
+    this.analysisRequestPromise = requestPromise;
+    try {
+      return await requestPromise;
+    } finally {
+      if (this.analysisRequestPromise === requestPromise) {
+        this.analysisRequestPromise = null;
+        this.analysisRequestKey = null;
+      }
+    }
+  }
+
+  renderGauges() {
+    if (window.Workspace?.layoutPreset === 1 && this.paneId === 'pane-0') {
+       if (this.gaugesEl) {
+         this.gaugesEl.innerHTML = '';
+         this.gaugesEl.style.display = 'none';
+       }
+       return;
+    }
+    if (!this.gaugesEl || !this.lastAnalysis || !this.lastAnalysis.payload || !this.lastAnalysis.payload.analysis) {
+       if (this.gaugesEl) this.gaugesEl.innerHTML = '';
+       return;
+    }
+    this.gaugesEl.style.display = '';
+    const analysis = this.lastAnalysis.payload.analysis;
+    const technical = analysis.dashboard?.technical || analysis.technicals || {};
+    const ai = analysis.dashboard?.ai || analysis.ai_gauge || {};
+    const summary = analysis.dashboard?.summary || analysis.summary || {};
+    const verdict = this.lastAnalysis.payload.verdict || summary.signal || '--';
+    const tone = (score) => score > 60 ? 'bull' : score < 40 ? 'bear' : 'flat';
+
+    this.gaugesEl.innerHTML = `
+      <div style="width:18px;height:18px;border-radius:50%;border:2px solid ${cT};display:flex;align-items:center;justify-content:center;background:var(--bg-depth); title="Trend">
+         <span style="font-size:9px;font-weight:bold;color:${cT}">${tScore > 50 ? '↑' : '↓'}</span>
+      </div>
+      <div style="width:18px;height:18px;border-radius:50%;border:2px solid ${cS};display:flex;align-items:center;justify-content:center;background:var(--bg-depth); title="Strength">
+         <span style="font-size:9px;font-weight:bold;color:${cS}">S</span>
+      </div>
+    `;
+  }
+  toJSON() {
+    return {
+      id: this.paneId,
+      symbol: this.symbol,
+      interval: this.interval,
+      indicator: this.indicatorMode,
+      horizon: this.horizon,
+    };
+  }
+}
+
+/* ══════════════════════════════════════════════════════
+   StreamManager — WebSocket lifecycle & reuse
+   ══════════════════════════════════════════════════════ */
+const StreamManager = {
+  _streams: new Map(),   // key → { ws, callbacks: Map<paneId, fn>, symbol, interval }
+  _paneKeys: new Map(),  // paneId → key
+
+  _makeKey(symbol, interval) { return `${symbol}|${interval}`; },
+
+  subscribe(paneId, symbol, interval, onMessage) {
+    const key = this._makeKey(symbol, interval);
+    const currentKey = this._paneKeys.get(paneId);
+
+    if (currentKey === key && this._streams.has(key)) {
+      const existingEntry = this._streams.get(key);
+      existingEntry.callbacks.set(paneId, onMessage);
+      return existingEntry.ws;
+    }
+
+    this.unsubscribe(paneId);
+    this._paneKeys.set(paneId, key);
+
+    if (this._streams.has(key)) {
+      const entry = this._streams.get(key);
+      entry.callbacks.set(paneId, onMessage);
+      console.log(`[StreamManager] Reusing WS for ${key}, pane ${paneId} (total: ${entry.callbacks.size})`);
+      return entry.ws;
+    }
+
+    const apiBase = window.__KRONOS_API_BASE || '';
+    const wsProtocol = window.location.protocol === 'https:' ? 'wss:' : 'ws:';
+    const wsUrl = `${apiBase.replace(/^https?:\/\//, wsProtocol)}/ws/price/${symbol}?interval=${encodeURIComponent(interval)}`;
+    console.log(`[StreamManager] New WS: ${wsUrl} (pane ${paneId})`);
+
+    const ws = new WebSocket(wsUrl);
+    const entry = {
+      ws,
+      callbacks: new Map([[paneId, onMessage]]),
+      symbol,
+      interval,
+    };
+    this._streams.set(key, entry);
+
+    ws.onmessage = (event) => {
+      try {
+        const data = JSON.parse(event.data);
+        if (data.error) return;
+        if (data.type === 'ping') {
+          ws.send(JSON.stringify({ type: 'pong', ts: Date.now() }));
+          return;
+        }
+        for (const [, cb] of entry.callbacks) {
+          try { cb(data); } catch (e) { console.warn('[StreamManager] cb error', e); }
+        }
+      } catch (e) {
+        console.warn('[StreamManager] parse error', e);
+      }
+    };
+
+    ws.onclose = () => {
+      console.log(`[StreamManager] WS closed: ${key}`);
+      if (this._streams.get(key)?.ws === ws) {
+        this._streams.delete(key);
+        // Reconnect for remaining subscribers after delay
+        const remainingCallbacks = new Map(entry.callbacks);
+        if (remainingCallbacks.size > 0) {
+          setTimeout(() => {
+            for (const [pid, cb] of remainingCallbacks) {
+              const pane = Workspace.getPane(pid);
+              if (pane && pane.symbol === symbol && pane.interval === interval) {
+                this.subscribe(pid, symbol, interval, cb);
+              }
+            }
+          }, WS_RECONNECT_DELAY);
+        }
+      }
+    };
+
+    ws.onerror = (e) => {
+      console.warn(`[StreamManager] WS error: ${key}`, e);
+    };
+
+    return ws;
+  },
+
+  unsubscribe(paneId) {
+    const key = this._paneKeys.get(paneId);
+    if (!key) return;
+    this._paneKeys.delete(paneId);
+    const entry = this._streams.get(key);
+    if (!entry) return;
+    entry.callbacks.delete(paneId);
+    if (entry.callbacks.size === 0) {
+      try { entry.ws.close(); } catch (_) {}
+      this._streams.delete(key);
+      console.log(`[StreamManager] Closed WS ${key} (no subscribers)`);
+    }
+  },
+
+  unsubscribeAll() {
+    for (const [key, entry] of this._streams) {
+      try { entry.ws.close(); } catch (_) {}
+    }
+    this._streams.clear();
+    this._paneKeys.clear();
+  },
+
+  getActiveCount() {
+    return this._streams.size;
+  }
+};
+
+/* ══════════════════════════════════════════════════════
+   DataCoordinator — Request dedup & concurrency
+   ══════════════════════════════════════════════════════ */
+const DataCoordinator = {
+  _inflightCache: new Map(),
+  _concurrency: 0,
+  _queue: [],
+
+  async _throttled(fn) {
+    if (this._concurrency >= MAX_CONCURRENT_FETCHES) {
+      await new Promise(resolve => this._queue.push(resolve));
+    }
+    this._concurrency++;
+    try {
+      return await fn();
+    } finally {
+      this._concurrency--;
+      if (this._queue.length > 0) this._queue.shift()();
+    }
+  },
+
+  async fetch(path, signal) {
+    const cacheKey = path.split('&_t=')[0]; // strip cache buster for dedup
+    if (this._inflightCache.has(cacheKey)) {
+      return this._inflightCache.get(cacheKey);
+    }
+    const promise = this._throttled(() => {
+      if (typeof apiRequest === 'function') {
+        return apiRequest(path, { signal });
+      }
+      // Fallback if apiRequest not yet defined
+      const apiBase = window.__KRONOS_API_BASE || '';
+      const sep = path.includes('?') ? '&' : '?';
+      const url = `${apiBase}${path}${sep}_t=${Date.now()}`;
+      return fetch(url, { signal }).then(r => {
+        if (!r.ok) throw new Error(r.statusText);
+        return r.json();
+      });
+    });
+    this._inflightCache.set(cacheKey, promise);
+    try {
+      return await promise;
+    } finally {
+      this._inflightCache.delete(cacheKey);
+    }
+  },
+
+  async fetchHistorical(symbol, interval, limit, signal) {
+    return this.fetch(
+      `/api/historical/${encodeURIComponent(symbol)}?interval=${interval}&limit=${limit}`,
+      signal
+    );
+  },
+
+  async fetchIndicators(symbol, interval, limit, signal) {
+    return this.fetch(
+      `/api/indicators/${encodeURIComponent(symbol)}?interval=${interval}&limit=${limit}`,
+      signal
+    );
+  },
+
+  async fetchForecast(symbol, interval, horizon, signal) {
+    return this.fetch(
+      `/api/forecast/${encodeURIComponent(symbol)}?interval=${interval}&horizon=${horizon}`,
+      signal
+    );
+  }
+};
+
+/* ══════════════════════════════════════════════════════
+   WorkspaceController — Layout & pane orchestration
+   ══════════════════════════════════════════════════════ */
+const Workspace = {
+  layoutPreset: 1,
+  activePaneId: 'pane-0',
+  panes: new Map(),
+  _gridEl: null,
+  _onActivePaneChange: null, // callback(paneId)
+  _onPaneSymbolChange: null, // callback(paneId, symbol, interval)
+
+  /* ── Init ─────────────────────────────────── */
+  init(gridEl) {
+    this._gridEl = gridEl || document.getElementById('workspaceGrid');
+  },
+
+  /* ── Pane CRUD ─────────────────────────────── */
+  createPane(id, symbol, interval) {
+    const pane = new PaneState(id, symbol, interval);
+    this.panes.set(id, pane);
+    return pane;
+  },
+
+  getPane(id) {
+    return this.panes.get(id) || null;
+  },
+
+  getActivePane() {
+    return this.panes.get(this.activePaneId) || null;
+  },
+
+  destroyPane(id) {
+    const pane = this.panes.get(id);
+    if (!pane) return;
+
+    // Cleanup network
+    StreamManager.unsubscribe(id);
+    if (pane.fetchController) {
+      pane.fetchController.abort();
+      pane.fetchController = null;
+    }
+    if (pane.analysisFetchController) {
+      pane.analysisFetchController.abort();
+      pane.analysisFetchController = null;
+    }
+    if (pane.analysisRetryTimer) {
+      clearTimeout(pane.analysisRetryTimer);
+      pane.analysisRetryTimer = null;
+    }
+
+    // Cleanup chart
+    if (pane.chartInstance) {
+      try { pane.chartInstance.remove(); } catch (_) {}
+      pane.chartInstance = null;
+    }
+
+    // Cleanup DOM
+    if (pane.containerEl && pane.containerEl.parentNode) {
+      pane.containerEl.parentNode.removeChild(pane.containerEl);
+    }
+
+    this.panes.delete(id);
+  },
+
+  /* ── Active pane ───────────────────────────── */
+  setActivePane(id) {
+    if (!this.panes.has(id)) return;
+    const prevId = this.activePaneId;
+    this.activePaneId = id;
+
+    // Update highlight
+    if (this._gridEl) {
+      this._gridEl.querySelectorAll('.chart-pane').forEach(el => {
+        el.classList.toggle('active', el.dataset.paneId === id);
+      });
+    }
+
+
+    if (prevId !== id && this._onActivePaneChange) {
+      this._onActivePaneChange(id);
+    }
+
+    // Sync AI UI
+    if (window.renderAnalysisPanel && window.renderCompactGauges) {
+      const pane = this.panes.get(id);
+      if (pane && pane.lastAnalysis && pane.lastAnalysis.payload) {
+         window.renderAnalysisPanel(pane.symbol, pane.interval, pane.lastAnalysis.payload);
+         window.renderCompactGauges(pane.symbol, pane.interval, pane.lastAnalysis.payload);
+         if (window.updateDashboardScale) window.updateDashboardScale();
+      } else {
+         const panel = document.getElementById('analysisPanel');
+         if (panel) panel.innerHTML = '';
+         const gContainer = document.getElementById('chartGauges');
+         if (gContainer) { gContainer.innerHTML = ''; gContainer.classList.remove('combo-active'); }
+      }
+      // re-render mini gauges for all
+      for (const [pId, p] of this.panes) {
+         if (p.renderGauges) p.renderGauges();
+      }
+    }
+
+  },
+
+  /* ── Layout ────────────────────────────────── */
+  setLayout(preset) {
+    if (!LAYOUT_PRESETS.includes(preset)) return;
+    const prevPreset = this.layoutPreset;
+    this.layoutPreset = preset;
+
+    // Determine which panes to keep, create, or destroy
+    const targetCount = preset;
+    const currentIds = Array.from(this.panes.keys());
+
+    // Create new panes if needed
+    for (let i = currentIds.length; i < targetCount; i++) {
+      const id = `pane-${i}`;
+      this.createPane(id, 'XAUUSD', '1d');
+    }
+
+    // Destroy excess panes
+    for (let i = targetCount; i < currentIds.length; i++) {
+      this.destroyPane(currentIds[i]);
+    }
+
+    // Ensure active pane is valid
+    if (!this.panes.has(this.activePaneId)) {
+      this.activePaneId = `pane-0`;
+    }
+
+    // Update grid CSS
+    if (this._gridEl) {
+      LAYOUT_PRESETS.forEach(lp => this._gridEl.classList.remove(`layout-${lp}`));
+      this._gridEl.classList.add(`layout-${preset}`);
+    }
+
+    this.save();
+    return { created: targetCount - currentIds.length, destroyed: Math.max(0, currentIds.length - targetCount) };
+  },
+
+  /* ── Persistence ───────────────────────────── */
+  save() {
+    const data = {
+      version: 1,
+      layoutPreset: this.layoutPreset,
+      activePaneId: this.activePaneId,
+      panes: Array.from(this.panes.values()).map(p => p.toJSON()),
+    };
+    try {
+      localStorage.setItem(WORKSPACE_STORAGE_KEY, JSON.stringify(data));
+    } catch (_) {}
+  },
+
+  restore() {
+    try {
+      const raw = localStorage.getItem(WORKSPACE_STORAGE_KEY);
+      if (!raw) return null;
+      const data = JSON.parse(raw);
+      if (!data || data.version !== 1) return null;
+      return data;
+    } catch (_) {
+      return null;
+    }
+  },
+
+  /* ── Pane DOM builder ──────────────────────── */
+  buildPaneDOM(pane) {
+    const container = document.createElement('div');
+    container.className = 'chart-pane';
+    container.dataset.paneId = pane.paneId;
+    if (pane.paneId === this.activePaneId) container.classList.add('active');
+
+    container.innerHTML = `
+      <div class="pane-header-mini">
+        <span class="pane-symbol">${pane.symbol}</span>
+        <span class="pane-sep">·</span>
+        <span class="pane-interval">${pane.interval}</span>
+        <span class="pane-price">--</span>
+      </div>
+      <div class="pane-chart" id="pane-chart-${pane.paneId}"></div>
+      <div class="pane-loader hidden">
+        <div class="loader-ring"></div>
+      </div>
+      <div class="pane-gauges"></div>
+    `;
+
+    pane.containerEl = container;
+    pane.chartEl = container.querySelector('.pane-chart');
+    pane.loaderEl = container.querySelector('.pane-loader');
+    pane.gaugesEl = container.querySelector('.pane-gauges');
+    pane.paneHeaderEl = container.querySelector('.pane-header-mini');
+    pane.priceEl = container.querySelector('.pane-price');
+
+    // Click to activate
+    container.addEventListener('click', () => {
+      this.setActivePane(pane.paneId);
+    });
+
+    return container;
+  },
+
+  /* ── Render all panes into grid ────────────── */
+  renderGrid() {
+    if (!this._gridEl) return;
+
+    // Clear grid
+    this._gridEl.innerHTML = '';
+
+    // Set layout class
+    LAYOUT_PRESETS.forEach(lp => this._gridEl.classList.remove(`layout-${lp}`));
+    this._gridEl.classList.add(`layout-${this.layoutPreset}`);
+
+    // Build pane DOMs
+    for (const [, pane] of this.panes) {
+      const el = this.buildPaneDOM(pane);
+      this._gridEl.appendChild(el);
+    }
+  },
+
+  /* ── Update pane header info ───────────────── */
+  updatePaneHeader(paneId, symbol, interval, price) {
+    const pane = this.panes.get(paneId);
+    if (!pane || !pane.paneHeaderEl) return;
+    const symEl = pane.paneHeaderEl.querySelector('.pane-symbol');
+    const intEl = pane.paneHeaderEl.querySelector('.pane-interval');
+    if (symEl) symEl.textContent = symbol || pane.symbol;
+    if (intEl) intEl.textContent = interval || pane.interval;
+    if (price !== undefined && pane.priceEl) {
+      pane.priceEl.textContent = price;
+    }
+  },
+
+  /* ── Utility ───────────────────────────────── */
+  getAllPaneIds() {
+    return Array.from(this.panes.keys());
+  },
+
+  getPaneCount() {
+    return this.panes.size;
+  }
+};
+
+/* ── Expose to global scope ───────────────���───── */
+window.PaneState = PaneState;
+window.StreamManager = StreamManager;
+window.DataCoordinator = DataCoordinator;
+window.Workspace = Workspace;
+window.LAYOUT_PRESETS = LAYOUT_PRESETS;
+window.LAYOUT_GRID_MAP = LAYOUT_GRID_MAP;
+
+PaneState.prototype.renderGauges = function renderPaneGaugeOverride() {
+  if (typeof window.renderPaneCompactGauges === 'function') {
+    window.renderPaneCompactGauges(this);
+    return;
+  }
+  if (!this.gaugesEl) {
+    return;
+  }
+  if (!this.lastAnalysis || !this.lastAnalysis.payload || !this.lastAnalysis.payload.analysis) {
+    this.gaugesEl.innerHTML = '';
+    return;
+  }
+
+  const analysis = this.lastAnalysis.payload.analysis;
+  const technical = analysis.dashboard?.technical || analysis.technicals || {};
+  const ai = analysis.dashboard?.ai || analysis.ai_gauge || {};
+  const summary = analysis.dashboard?.summary || analysis.summary || {};
+  const verdict = this.lastAnalysis.payload.verdict || summary.signal || '--';
+  const trendScore = Number(technical.score ?? technical.trend_score ?? 50);
+  const strengthScore = Number(summary.confidence ?? summary.strength_score ?? ai.score ?? 50);
+  const aiScore = Number(ai.score ?? ai.confidence ?? summary.ai_score ?? 50);
+  const tone = (score) => score >= 60 ? 'bull' : score <= 40 ? 'bear' : 'flat';
+
+  this.gaugesEl.innerHTML = `
+    <div class="pane-gauge-chip" data-tone="${tone(trendScore)}"><span>T</span><b>${Math.round(trendScore)}</b></div>
+    <div class="pane-gauge-chip" data-tone="${tone(strengthScore)}"><span>S</span><b>${Math.round(strengthScore)}</b></div>
+    <div class="pane-gauge-chip" data-tone="${tone(aiScore)}"><span>AI</span><b>${Math.round(aiScore)}</b></div>
+    <div class="pane-gauge-verdict">${String(verdict).replace(/_/g, ' ')}</div>
+  `;
+};
+
+Workspace.setActivePane = function setActivePaneOverride(id) {
+  if (!this.panes.has(id)) return;
+  const prevId = this.activePaneId;
+  this.activePaneId = id;
+
+  if (this._gridEl) {
+    this._gridEl.querySelectorAll('.chart-pane').forEach((el) => {
+      el.classList.toggle('active', el.dataset.paneId === id);
+    });
+  }
+
+  if (prevId !== id && this._onActivePaneChange) {
+    this._onActivePaneChange(id);
+  }
+
+  this.panes.forEach((pane) => {
+    if (typeof pane.renderGauges === 'function') {
+      pane.renderGauges();
+    }
+    if (typeof window.renderPaneAnalysisUI === 'function') {
+      window.renderPaneAnalysisUI(pane);
+    }
+  });
+};

run.bat

@@ -6,18 +6,7 @@ echo ====================================================
 echo    KRONOS AI TRADING TERMINAL - STARTUP
 echo ====================================================
 
-:: Port to check
-set PORT=7860
-
-:: Check if port is already in use and try to free it
-echo [1/3] Checking port %PORT%...
-for /f "tokens=5" %%a in ('netstat -aon ^| findstr :%PORT% ^| findstr LISTENING') do (
-    if not "%%a"=="" (
-        echo [INFO] Port %PORT% is in use by PID %%a. Freeing port...
-        taskkill /F /PID %%a >nul 2>&1
-        timeout /t 2 >nul
-    )
-)
+echo [1/3] Preparing launcher...
 
 :: Check if virtual environment exists
 if not exist "venv\" (
@@ -34,11 +23,8 @@ echo [3/3] Launching AI Trading Terminal...
 echo [INFO] Application will open in your browser automatically.
 echo [INFO] Press CTRL+C in this window to stop the server.
 
-:: Open browser in background
-start http://localhost:%PORT%
-
-:: Run the app
-python app.py
+:: Run the app with dynamic port selection
+python -m backend.launcher
 
 if %ERRORLEVEL% neq 0 (
     echo.