Deploy v6.0: Dashboard Scoring Fix, UI Refinement, and Auto-Scaling

.gitignore

@@ -10,3 +10,4 @@ build/
 dist/
 scratch/
 *.spec
+data/

SOURCES_AND_SYMBOLS.md

@@ -1,242 +0,0 @@
-# NGUỒN DỮ LIỆU MIỄN PHÍ — XÁC NHẬN & PHÂN LOẠI MÃ GIAO DỊCH
-# Free Data Sources — Confirmed & Symbol Classification v4.0
-
-═══════════════════════════════════════════════════════════════════════
-## A. BẢNG NGUỒN DỮ LIỆU MIỄN PHÍ (Confirmed Free Sources)
-═══════════════════════════════════════════════════════════════════════
-
-| Nguồn        | URL cơ sở                              | API Key? | Giới hạn miễn phí        | Tốt nhất cho              |
-|--------------|----------------------------------------|----------|--------------------------|---------------------------|
-| Binance      | api.binance.com/api/v3                 | Không    | 1200 req/min             | Crypto OHLCV (tốt nhất)   |
-| Bybit V5     | api.bybit.com/v5/market                | Không    | 120 req/min              | Crypto backup             |
-| CoinGecko    | api.coingecko.com/api/v3               | Không    | 30 req/min               | Crypto OHLCV + market cap |
-| yfinance     | (scrapes finance.yahoo.com)            | Không    | Không giới hạn chính thức| Stocks, ETF, Forex, Chỉ số|
-| Finnhub      | finnhub.io/api/v1                      | Có (free)| 60 req/min               | Forex (OANDA), Stock, Crypto|
-| Twelvedata   | api.twelvedata.com                     | Có (free)| 800 credits/ngày, 8/phút | Forex, Stock, Crypto      |
-| Alpha Vantage| alphavantage.co/query                  | Có (free)| 25 req/ngày              | Forex fallback (hạn chế)  |
-| FRED         | fred.stlouisfed.org/graph/fredgraph    | Không    | Không giới hạn           | Macro (lãi suất, DXY...)  |
-
-### Ưu tiên nguồn theo loại tài sản:
-- **Crypto**:       Binance → Bybit → CoinGecko → yfinance → Finnhub
-- **Forex**:        Twelvedata → Finnhub (OANDA) → yfinance
-- **Kim loại**:     yfinance (futures =F) → Twelvedata → Finnhub
-- **Năng lượng**:   yfinance (futures =F) → Twelvedata → Finnhub
-- **Nông sản**:     yfinance (futures =F) → Twelvedata
-- **Chỉ số**:       yfinance (^SYMBOL) → Twelvedata → Finnhub
-- **Cổ phiếu Mỹ**:  yfinance → Finnhub → Twelvedata
-- **Cổ phiếu VN**:  yfinance (.VN suffix)
-- **Trái phiếu**:   yfinance (^TNX, ^TYX...)
-
-═══════════════════════════════════════════════════════════════════════
-## B. PHÂN LOẠI MÃ GIAO DỊCH CHUẨN
-═══════════════════════════════════════════════════════════════════════
-
-### 1. KIM LOẠI (Metals) — 13 mã
-| Mã           | Tên VN              | Ticker yfinance | Nguồn tốt nhất      |
-|--------------|---------------------|-----------------|---------------------|
-| XAUUSD       | Vàng                | GC=F            | Twelvedata, Finnhub  |
-| XAGUSD       | Bạc                 | SI=F            | Twelvedata, Finnhub  |
-| XPTUSD       | Bạch kim            | PL=F            | Twelvedata, yfinance |
-| XPDUSD       | Palladium           | PA=F            | Twelvedata, yfinance |
-| COPPER       | Đồng COMEX          | HG=F            | yfinance, Twelvedata |
-| COPPER_LME   | Đồng LME            | HG=F            | Twelvedata           |
-| ALUMINUM     | Nhôm COMEX          | ALI=F           | yfinance             |
-| ALUMINUM_LME | Nhôm LME            | LMAHDS03        | Twelvedata           |
-| NICKEL_LME   | Niken LME           | NI1             | Twelvedata           |
-| ZINC_LME     | Kẽm LME             | ZN1             | Twelvedata           |
-| IRON_ORE     | Quặng sắt           | TIO=F           | yfinance             |
-| STEEL_HRC    | Thép cuộn cán nóng  | HRC=F           | yfinance             |
-| LITHIUM      | Lithium (proxy ALB) | ALB             | yfinance             |
-
-### 2. NĂNG LƯỢNG (Energy) — 8 mã
-| Mã           | Tên VN              | Ticker yfinance | Ghi chú              |
-|--------------|---------------------|-----------------|----------------------|
-| WTI          | Dầu thô WTI         | CL=F            | Chuẩn Mỹ             |
-| BRENT        | Dầu Brent           | BZ=F            | Chuẩn quốc tế        |
-| NATURAL_GAS  | Khí tự nhiên        | NG=F            |                      |
-| GASOLINE_RBOB| Xăng RBOB           | RB=F            |                      |
-| HEATING_OIL  | Dầu sưởi            | HO=F            |                      |
-| LNG          | Khí hoá lỏng proxy  | LNG             | Cổ phiếu Cheniere    |
-| COAL         | Than Newcastle      | MTF=F           |                      |
-| URANIUM      | Uranium             | UX=F            |                      |
-
-### 3. NÔNG SẢN (Agricultural) — 7 mã
-| Mã           | Tên VN              | Ticker yfinance |
-|--------------|---------------------|-----------------|
-| CORN         | Ngô                 | ZC=F            |
-| WHEAT        | Lúa mì              | ZW=F            |
-| SOYBEAN      | Đậu tương           | ZS=F            |
-| SOYBEAN_OIL  | Dầu đậu tương       | ZL=F            |
-| SOYBEAN_MEAL | Khô đậu tương       | ZM=F            |
-| RICE         | Gạo thô             | ZR=F            |
-| OATS         | Yến mạch            | ZO=F            |
-
-### 4. NGUYÊN LIỆU CÔNG NGHIỆP (Soft Commodities) — 10 mã
-| Mã             | Tên VN              | Ticker yfinance |
-|----------------|---------------------|-----------------|
-| COFFEE_ARABICA | Cà phê Arabica      | KC=F            |
-| COFFEE_ROBUSTA | Cà phê Robusta      | RC=F            |
-| COCOA          | Ca cao              | CC=F            |
-| SUGAR_11       | Đường 11            | SB=F            |
-| WHITE_SUGAR    | Đường trắng         | LSW=F           |
-| COTTON         | Bông                | CT=F            |
-| ORANGE_JUICE   | Nước cam            | OJ=F            |
-| LUMBER         | Gỗ xẻ              | LBS=F           |
-| RUBBER_RSS3    | Cao su RSS3         | JRU=F           |
-| PALM_OIL       | Dầu cọ thô          | FCPO=F          |
-
-### 5. CRYPTO — 25 mã (Top by market cap)
-| Mã       | Tên            | Binance      | CoinGecko ID        |
-|----------|----------------|--------------|---------------------|
-| BTCUSD   | Bitcoin        | BTCUSDT      | bitcoin             |
-| ETHUSD   | Ethereum       | ETHUSDT      | ethereum            |
-| BNBUSD   | BNB            | BNBUSDT      | binancecoin         |
-| SOLUSD   | Solana         | SOLUSDT      | solana              |
-| XRPUSD   | Ripple         | XRPUSDT      | ripple              |
-| ADAUSD   | Cardano        | ADAUSDT      | cardano             |
-| AVAXUSD  | Avalanche      | AVAXUSDT     | avalanche-2         |
-| DOTUSD   | Polkadot       | DOTUSDT      | polkadot            |
-| MATICUSD | Polygon        | MATICUSDT    | matic-network       |
-| LINKUSD  | Chainlink      | LINKUSDT     | chainlink           |
-| LTCUSD   | Litecoin       | LTCUSDT      | litecoin            |
-| UNIUSD   | Uniswap        | UNIUSDT      | uniswap             |
-| ATOMUSD  | Cosmos         | ATOMUSDT     | cosmos              |
-| NEARUSD  | NEAR Protocol  | NEARUSDT     | near                |
-| APTUSD   | Aptos          | APTUSDT      | aptos               |
-| SUIUSD   | Sui            | SUIUSDT      | sui                 |
-| ARBUSD   | Arbitrum       | ARBUSDT      | arbitrum            |
-| OPUSD    | Optimism       | OPUSDT       | optimism            |
-| INJUSD   | Injective      | INJUSDT      | injective-protocol  |
-| TONUSD   | Toncoin        | TONUSDT      | the-open-network    |
-| TRXUSD   | Tron           | TRXUSDT      | tron                |
-| XMRUSD   | Monero         | (Bybit only) | monero              |
-| DOGEUSD  | Dogecoin       | DOGEUSDT     | dogecoin            |
-| SHIBAUSD | Shiba Inu      | SHIBUSDT     | shiba-inu           |
-| PEPE     | PEPE Coin      | PEPEUSDT     | pepe                |
-
-### 6. CẶP TIỀN (Forex) — 19 mã
-| Mã       | Tên           | Twelvedata   | Finnhub          | yfinance     |
-|----------|---------------|--------------|------------------|--------------|
-| DXY      | Chỉ số USD    | —            | —                | DX-Y.NYB     |
-| EURUSD   | EUR/USD       | EUR/USD      | OANDA:EUR_USD    | EURUSD=X     |
-| GBPUSD   | GBP/USD       | GBP/USD      | OANDA:GBP_USD    | GBPUSD=X     |
-| USDJPY   | USD/JPY       | USD/JPY      | OANDA:USD_JPY    | JPY=X        |
-| USDCHF   | USD/CHF       | USD/CHF      | OANDA:USD_CHF    | CHF=X        |
-| AUDUSD   | AUD/USD       | AUD/USD      | OANDA:AUD_USD    | AUDUSD=X     |
-| USDCAD   | USD/CAD       | USD/CAD      | OANDA:USD_CAD    | CAD=X        |
-| NZDUSD   | NZD/USD       | NZD/USD      | OANDA:NZD_USD    | NZDUSD=X     |
-| GBPJPY   | GBP/JPY       | GBP/JPY      | OANDA:GBP_JPY    | GBPJPY=X     |
-| EURJPY   | EUR/JPY       | EUR/JPY      | OANDA:EUR_JPY    | EURJPY=X     |
-| EURGBP   | EUR/GBP       | EUR/GBP      | OANDA:EUR_GBP    | EURGBP=X     |
-| CADCHF   | CAD/CHF       | CAD/CHF      | OANDA:CAD_CHF    | CADCHF=X     |
-| AUDNZD   | AUD/NZD       | AUD/NZD      | OANDA:AUD_NZD    | AUDNZD=X     |
-| USDVND   | USD/VND       | —            | —                | VND=X        |
-| USDHKD   | USD/HKD       | USD/HKD      | —                | HKD=X        |
-| USDSGD   | USD/SGD       | USD/SGD      | —                | SGD=X        |
-| USDCNY   | USD/CNY       | USD/CNH      | —                | CNY=X        |
-| USDINR   | USD/INR       | —            | —                | INR=X        |
-| USDBRL   | USD/BRL       | —            | —                | BRL=X        |
-
-### 7. CHỈ SỐ (Stock Indices) — 20 mã
-| Mã         | Tên                  | yfinance   | Ghi chú         |
-|------------|----------------------|------------|-----------------|
-| SP500      | S&P 500              | ^GSPC      | Chuẩn Mỹ        |
-| NASDAQ     | Nasdaq Composite     | ^IXIC      |                 |
-| NASDAQ100  | Nasdaq 100           | ^NDX       |                 |
-| DOW30      | Dow Jones 30         | ^DJI       |                 |
-| RUSSELL2000| Russell 2000         | ^RUT       | Small-cap Mỹ   |
-| VIX        | VIX Fear Index       | ^VIX       |                 |
-| VNINDEX    | VN-Index (HOSE)      | ^VNINDEX   | Việt Nam        |
-| HNX30      | HNX 30               | ^HNX30     | Việt Nam        |
-| UK100      | FTSE 100             | ^FTSE      | Anh             |
-| DAX40      | DAX 40               | ^GDAXI     | Đức             |
-| EU50       | Euro Stoxx 50        | ^STOXX50E  | Châu Âu         |
-| CAC40      | CAC 40               | ^FCHI      | Pháp            |
-| NIKKEI225  | Nikkei 225           | ^N225      | Nhật Bản        |
-| HSI        | Hang Seng            | ^HSI       | Hong Kong       |
-| SSE50      | SSE 50               | 000016.SS  | Trung Quốc      |
-| CSI300     | CSI 300              | 000300.SS  | Trung Quốc      |
-| ASX200     | ASX 200              | ^AXJO      | Úc              |
-| SENSEX     | BSE Sensex           | ^BSESN     | Ấn Độ           |
-| KOSPI      | KOSPI                | ^KS11      | Hàn Quốc        |
-| SGX        | Straits Times        | ^STI       | Singapore       |
-
-### 8. CỔ PHIẾU MỸ (US Stocks) — 21 mã
-AAPL, MSFT, NVDA, GOOGL, AMZN, META, TSLA, AVGO, JPM, V, MA,
-XOM, WMT, BAC, GS, AMD, INTC, NFLX, DIS, COIN, MSTR
-→ Tất cả dùng yfinance + Finnhub + Twelvedata (ticker trực tiếp)
-
-### 9. CỔ PHIẾU VIỆT NAM (VN Stocks) — 25 mã (yfinance .VN suffix)
-Ngân hàng: VCB, BID, CTG, TCB, MBB, VPB, ACB, HDB, SHB, STB
-Công nghệ: FPT
-Bất động sản: VIC, VHM
-FMCG: VNM, MSN, SAB
-Năng lượng/CN: GAS, PLX, POW, HPG, DGC
-Tiêu dùng: MWG
-Chứng khoán: SSI, VND, HCM
-
-### 10. TRÁI PHIẾU & LÃI SUẤT (Bonds & Rates) — 5 mã
-| Mã     | Tên                  | yfinance     | Ghi chú                |
-|--------|----------------------|--------------|------------------------|
-| US10Y  | Trái phiếu Mỹ 10 năm | ^TNX        | Chuẩn lãi suất toàn cầu|
-| US02Y  | Trái phiếu Mỹ 2 năm  | ^IRX        |                        |
-| US30Y  | Trái phiếu Mỹ 30 năm | ^TYX        |                        |
-| DE10Y  | Bund Đức 10 năm      | ^DE10YT=RR  |                        |
-| JP10Y  | JGB Nhật 10 năm      | ^JP10YT=RR  |                        |
-
-═══════════════════════════════════════════════════════════════════════
-## C. API ENDPOINTS v4.0
-═══════════════════════════════════════════════════════════════════════
-
-### Dữ liệu lịch sử
-GET  /api/symbols               → Danh sách tất cả mã (có thể lọc theo category)
-GET  /api/search?q=gold         → Tìm kiếm mờ (fuzzy search)
-GET  /api/historical/{symbol}   → Nến OHLCV (interval, limit)
-GET  /api/indicators/{symbol}   → Chỉ báo kỹ thuật (RSI, MACD, BB, EMA, ATR)
-
-### Giá thực tế
-GET  /api/ticker/{symbol}       → Giá cuối + 24h stats
-POST /api/watchlist/tickers     → Batch ticker cho danh mục
-GET  /api/crypto/market         → Top N crypto theo vốn hoá (CoinGecko)
-WS   /ws/price/{symbol}         → WebSocket stream giá thực tế (5s)
-
-### AI Forecast
-GET  /api/forecast/{symbol}     → Dự báo Kronos (horizon, quantiles 10/50/90)
-
-### Thị trường
-GET  /api/market-status         → Trạng thái mở/đóng cửa các sàn thế giới
-
-### Cache & Admin
-POST   /api/switch              → Xoá cache khi đổi symbol/interval
-DELETE /api/cache/{sym}/{iv}    → Xoá cache cụ thể
-DELETE /api/cache               → Xoá tất cả cache
-GET    /api/cache/stats         → Thống kê cache
-GET    /api/health              → Trạng thái server
-
-═══════════════════════════════════════════════════════════════════════
-## D. CÀI ĐẶT & CHẠY
-═══════════════════════════════════════════════════════════════════════
-
-# 1. Cài đặt dependencies
-pip install -r requirements.txt
-
-# 2. Cài pytz (cần cho market-status)
-pip install pytz
-
-# 3. Chạy server
-uvicorn main:app --host 0.0.0.0 --port 8000 --reload
-
-# 4. Xem API docs
-http://localhost:8000/docs
-
-# 5. Kiểm tra health
-curl http://localhost:8000/api/health
-
-# 6. Test lấy giá vàng
-curl "http://localhost:8000/api/historical/XAUUSD?interval=1h&limit=100"
-
-# 7. Test chỉ báo kỹ thuật BTC
-curl "http://localhost:8000/api/indicators/BTCUSD?interval=4h"
-
-# 8. Test thị trường đang mở
-curl http://localhost:8000/api/market-status

all_symbols_final.txt

@@ -1,643 +0,0 @@
-0GUSDT
-1000000BABYDOGEUSDT
-1000000CHEEMSUSDT
-1000000MOGUSDT
-10000QUBICUSDT
-10000SATSUSDT
-1000BONKPERP
-1000BONKUSDT
-1000BTTUSDT
-1000CATUSDT
-1000FLOKIUSDT
-1000LUNCUSDT
-1000NEIROCTOPERP
-1000NEIROCTOUSDT
-1000PEPEPERP
-1000PEPEUSDT
-1000RATSUSDT
-1000TAGUSDT
-1000TOSHIUSDT
-1000TURBOUSDT
-1000XECUSDT
-1INCHUSDT
-2ZUSDT
-4USDT
-AAVEPERP
-AAVEUSDT
-ACEUSDT
-ACHUSDT
-ACTUSDT
-ACUUSDT
-ACXUSDT
-ADAUSDT
-AERGOUSDT
-AEROUSDT
-AEVOPERP
-AEVOUSDT
-AGIUSDT
-AGLDUSDT
-AIOUSDT
-AIOZUSDT
-AIXBTUSDT
-AKEUSDT
-AKTUSDT
-ALCHUSDT
-ALGOUSDT
-ALICEUSDT
-ALLOUSDT
-ALPINEUSDT
-ALTUSDT
-ANIMEUSDT
-ANKRUSDT
-APEUSDT
-APEXUSDT
-API3USDT
-APRUSDT
-APTUSDT
-ARBPERP
-ARBUSDT
-ARCUSDT
-ARIAUSDT
-ARKMUSDT
-ARKUSDT
-ARPAUSDT
-ARUSDT
-ASPUSDT
-ASRUSDT
-ASTERPERP
-ASTERUSDT
-ASTRUSDT
-ATHUSDT
-ATOMUSDT
-ATUSDT
-AUCTIONUSDT
-AUSDT
-AVAAIUSDT
-AVAUSDT
-AVAXUSDT
-AVNTPERP
-AVNTUSDT
-AWEUSDT
-AXLUSDT
-AXSUSDT
-AZTECUSDT
-B2USDT
-B3USDT
-BABYUSDT
-BANANAS31USDT
-BANANAUSDT
-BANDUSDT
-BANKUSDT
-BANUSDT
-BARDUSDT
-BASEDUSDT
-BATUSDT
-BBUSDT
-BCHPERP
-BCHUSDT
-BEAMUSDT
-BEATUSDT
-BELUSDT
-BERAUSDT
-BICOUSDT
-BIGTIMEUSDT
-BIOUSDT
-BIRBUSDT
-BLASTUSDT
-BLESSUSDT
-BLUAIUSDT
-BLURUSDT
-BMTUSDT
-BNBPERP
-BNBUSDT
-BNTUSDT
-BOBAUSDT
-BOBBOBUSDT
-BOMEUSDT
-BRETTUSDT
-BREVUSDT
-BROCCOLIUSDT
-BRUSDT
-BSBUSDT
-BSUUSDT
-BSVUSDT
-BTCPERP
-BTCUSDT
-BTCUSDT-01MAY26
-BTCUSDT-08MAY26
-BTCUSDT-24APR26
-BTCUSDT-25DEC26
-BTCUSDT-25SEP26
-BTCUSDT-26JUN26
-BTCUSDT-26MAR27
-BTCUSDT-29MAY26
-BTRUSDT
-BUSDT
-C98USDT
-CAKEUSDT
-CARVUSDT
-CATIUSDT
-CCUSDT
-CELOUSDT
-CETUSUSDT
-CFGUSDT
-CFXUSDT
-CGPTUSDT
-CHILLGUYUSDT
-CHIPUSDT
-CHRUSDT
-CHZUSDT
-CKBUSDT
-CLANKERUSDT
-CLOUDUSDT
-CLOUSDT
-CLUSDT
-COAIUSDT
-COMPUSDT
-COOKIEUSDT
-COREUSDT
-COTIUSDT
-COWUSDT
-CROSSUSDT
-CROUSDT
-CRVPERP
-CRVUSDT
-CTCUSDT
-CUSDT
-CVCUSDT
-CVXUSDT
-CYBERUSDT
-CYSUSDT
-DASHUSDT
-DBRUSDT
-DEEPUSDT
-DEGENUSDT
-DEXEUSDT
-DIAUSDT
-DOGEPERP
-DOGEUSDT
-DOGEUSDT-01MAY26
-DOGEUSDT-08MAY26
-DOGEUSDT-24APR26
-DOGEUSDT-29MAY26
-DOGUSDT
-DOLOUSDT
-DOODUSDT
-DOTPERP
-DOTUSDT
-DRIFTUSDT
-DUSKUSDT
-DYDXUSDT
-DYMUSDT
-EDENUSDT
-EDGEUSDT
-EDUUSDT
-EGLDUSDT
-EIGENPERP
-EIGENUSDT
-ELSAUSDT
-ENAPERP
-ENAUSDT
-ENJUSDT
-ENSOUSDT
-ENSUSDT
-EPICUSDT
-ERAUSDT
-ESPORTSUSDT
-ESPUSDT
-ESUSDT
-ETCPERP
-ETCUSDT
-ETHBTCUSDT
-ETHFIPERP
-ETHFIUSDT
-ETHPERP
-ETHUSDT
-ETHUSDT-01MAY26
-ETHUSDT-08MAY26
-ETHUSDT-24APR26
-ETHUSDT-25DEC26
-ETHUSDT-25SEP26
-ETHUSDT-26JUN26
-ETHUSDT-26MAR27
-ETHUSDT-29MAY26
-EULUSDT
-EVAAUSDT
-FARTCOINPERP
-FARTCOINUSDT
-FFUSDT
-FHEUSDT
-FIDAUSDT
-FIGHTUSDT
-FILPERP
-FILUSDT
-FIOUSDT
-FLOCKUSDT
-FLOWUSDT
-FLRUSDT
-FLUIDUSDT
-FLUXUSDT
-FOGOUSDT
-FOLKSUSDT
-FORMUSDT
-FUSDT
-GALAUSDT
-GASUSDT
-GENIUSUSDT
-GIGAUSDT
-GIGGLEUSDT
-GLMUSDT
-GMTUSDT
-GMXUSDT
-GNOUSDT
-GOATUSDT
-GODSUSDT
-GPSUSDT
-GRASSUSDT
-GRIFFAINUSDT
-GRTUSDT
-GUNUSDT
-HAEDALUSDT
-HANAUSDT
-HBARPERP
-HBARUSDT
-HEIUSDT
-HEMIUSDT
-HFTUSDT
-HIGHUSDT
-HIVEUSDT
-HMSTRUSDT
-HNTUSDT
-HOLOUSDT
-HOMEUSDT
-HOODUSDT
-HPERP
-HPOS10IUSDT
-HUMAUSDT
-HUSDT
-HYPEPERP
-HYPERUSDT
-HYPEUSDT
-ICNTPERP
-ICNTUSDT
-ICPPERP
-ICPUSDT
-ICXUSDT
-IDUSDT
-ILVUSDT
-IMXUSDT
-INITUSDT
-INJPERP
-INJUSDT
-INTCUSDT
-INUSDT
-INXUSDT
-IOSTUSDT
-IOTAUSDT
-IOTXUSDT
-IOUSDT
-IPPERP
-IPUSDT
-IRYSUSDT
-JASMYUSDT
-JCTUSDT
-JELLYJELLYUSDT
-JSTUSDT
-JTOUSDT
-JUPUSDT
-KAIAUSDT
-KAITOUSDT
-KASPERP
-KASUSDT
-KATUSDT
-KAVAUSDT
-KERNELUSDT
-KGENUSDT
-KITEUSDT
-KMNOUSDT
-KNCUSDT
-KSMUSDT
-LABUSDT
-LAUSDT
-LDOUSDT
-LIGHTUSDT
-LINEAUSDT
-LINKPERP
-LINKUSDT
-LITUSDT
-LPTUSDT
-LQTYUSDT
-LRCUSDT
-LSKUSDT
-LTCPERP
-LTCUSDT
-LUMIAUSDT
-LUNA2USDT
-LYNUSDT
-MAGICUSDT
-MAGMAUSDT
-MANAUSDT
-MANTAUSDT
-MASKUSDT
-MAVIAUSDT
-MAVUSDT
-MBOXUSDT
-MELANIAUSDT
-MEMEUSDT
-MERLPERP
-MERLUSDT
-METISUSDT
-METUSDT
-MEUSDT
-MEWUSDT
-MINAUSDT
-MIRAUSDT
-MITOUSDT
-MLNUSDT
-MMTUSDT
-MNTPERP
-MNTUSDT
-MNTUSDT-01MAY26
-MNTUSDT-08MAY26
-MNTUSDT-24APR26
-MNTUSDT-29MAY26
-MOCAUSDT
-MONUSDT
-MOODENGPERP
-MOODENGUSDT
-MORPHOUSDT
-MOVEUSDT
-MOVRUSDT
-MTLUSDT
-MUBARAKUSDT
-MUSDT
-MYXUSDT
-NAORISUSDT
-NEARUSDT
-NEOUSDT
-NEWTUSDT
-NIGHTPERP
-NIGHTUSDT
-NILUSDT
-NMRUSDT
-NOMUSDT
-NOTPERP
-NOTUSDT
-NXPCUSDT
-OGNUSDT
-OGUSDT
-OKBUSDT
-OLUSDT
-ONDOPERP
-ONDOUSDT
-ONGUSDT
-ONTUSDT
-OPENUSDT
-OPNUSDT
-OPPERP
-OPUSDT
-ORBSUSDT
-ORCAUSDT
-ORDERUSDT
-ORDIPERP
-ORDIUSDT
-OXTUSDT
-PARTIUSDT
-PAXGPERP
-PAXGUSDT
-PEAQUSDT
-PENDLEPERP
-PENDLEUSDT
-PENGUPERP
-PENGUUSDT
-PEOPLEUSDT
-PHAUSDT
-PIEVERSEUSDT
-PIPPINUSDT
-PIXELUSDT
-PLAYSOUTUSDT
-PLUMEUSDT
-PNUTPERP
-PNUTUSDT
-POLPERP
-POLUSDT
-POLYXUSDT
-POPCATPERP
-POPCATUSDT
-PORTALUSDT
-POWERUSDT
-POWRUSDT
-PRLUSDT
-PROMPTUSDT
-PROVEUSDT
-PTBUSDT
-PUFFERUSDT
-PUMPBTCUSDT
-PUMPFUNPERP
-PUMPFUNUSDT
-PUNDIXUSDT
-PYRUSDT
-PYTHUSDT
-QNTUSDT
-QTUMUSDT
-QUSDT
-RAREUSDT
-RAVEUSDT
-RAYDIUMUSDT
-RDNTUSDT
-RECALLUSDT
-REDUSDT
-RENDERUSDT
-REQUSDT
-RESOLVPERP
-RESOLVUSDT
-REZUSDT
-RIVERUSDT
-RLCUSDT
-RLUSDUSDT
-ROAMUSDT
-ROBOUSDT
-RONINUSDT
-ROSEUSDT
-RPLUSDT
-RSRUSDT
-RUNEUSDT
-RVNUSDT
-SAFEUSDT
-SAGAUSDT
-SAHARAPERP
-SAHARAUSDT
-SANDUSDT
-SAPIENUSDT
-SCRTUSDT
-SCRUSDT
-SCUSDT
-SEIPERP
-SEIUSDT
-SENTUSDT
-SHELLUSDT
-SHIB1000PERP
-SHIB1000USDT
-SIGNUSDT
-SIRENUSDT
-SKLUSDT
-SKRUSDT
-SKYUSDT
-SLPUSDT
-SNTUSDT
-SNXUSDT
-SOLAYERUSDT
-SOLPERP
-SOLUSDT
-SOLUSDT-01MAY26
-SOLUSDT-08MAY26
-SOLUSDT-24APR26
-SOLUSDT-29MAY26
-SOLVUSDT
-SOMIUSDT
-SONICUSDT
-SOONUSDT
-SOPHUSDT
-SOSOUSDT
-SPACEUSDT
-SPKUSDT
-SPORTFUNUSDT
-SPXPERP
-SPXUSDT
-SQDUSDT
-SSVUSDT
-STABLEUSDT
-STBLUSDT
-STEEMUSDT
-STGUSDT
-STORJUSDT
-STOUSDT
-STRKPERP
-STRKUSDT
-STXUSDT
-SUIPERP
-SUIUSDT
-SUNUSDT
-SUPERUSDT
-SUSDT
-SUSHIUSDT
-SWARMSUSDT
-SXTUSDT
-SYNUSDT
-SYRUPUSDT
-TACUSDT
-TAIKOUSDT
-TAOPERP
-TAOUSDT
-TAUSDT
-THETAUSDT
-THEUSDT
-TIAPERP
-TIAUSDT
-TLMUSDT
-TNSRUSDT
-TONPERP
-TONUSDT
-TOWNSUSDT
-TRBUSDT
-TREEUSDT
-TRIAUSDT
-TRUMPPERP
-TRUMPUSDT
-TRUSTUSDT
-TRUTHUSDT
-TRUUSDT
-TRXPERP
-TRXUSDT
-TSLAUSDT
-TSMUSDT
-TSTBSCUSDT
-TURTLEUSDT
-TUSDT
-TUTUSDT
-TWTPERP
-TWTUSDT
-UAIUSDT
-UBUSDT
-UMAUSDT
-UNIPERP
-UNIUSDT
-USD1USDT
-USDCUSDT
-USDEUSDT
-USELESSUSDT
-USTCUSDT
-USUALUSDT
-USUSDT
-VANAUSDT
-VANRYUSDT
-VELODROMEUSDT
-VELOUSDT
-VELVETUSDT
-VETUSDT
-VINEUSDT
-VIRTUALPERP
-VIRTUALUSDT
-VVVUSDT
-WALUSDT
-WAVESUSDT
-WAXPUSDT
-WCTUSDT
-WETUSDT
-WHITEWHALEUSDT
-WIFPERP
-WIFUSDT
-WLDPERP
-WLDUSDT
-WLFIPERP
-WLFIUSDT
-WOOUSDT
-WUSDT
-XAGUSDT
-XAIUSDT
-XANUSDT
-XAUTPERP
-XAUTUSDT
-XAUTUSDT-01MAY26
-XAUTUSDT-08MAY26
-XAUTUSDT-24APR26
-XAUTUSDT-29MAY26
-XAUUSDT
-XCNUSDT
-XDCUSDT
-XIONUSDT
-XLMPERP
-XLMUSDT
-XMRPERP
-XMRUSDT
-XNYUSDT
-XPINUSDT
-XPLPERP
-XPLUSDT
-XRPPERP
-XRPUSDT
-XRPUSDT-01MAY26
-XRPUSDT-08MAY26
-XRPUSDT-24APR26
-XRPUSDT-29MAY26
-XTZUSDT
-XVGUSDT
-XVSUSDT
-YBUSDT
-YFIUSDT
-YGGUSDT
-YZYUSDT
-ZAMAUSDT
-ZBCNUSDT
-ZBTUSDT
-ZECUSDT
-ZENUSDT
-ZEREBROUSDT
-ZETAUSDT
-ZILUSDT
-ZKCUSDT
-ZKPUSDT
-ZKUSDT
-ZORAUSDT
-ZROUSDT
-ZRXUSDT

backend/check_eurusd.py

@@ -1,14 +0,0 @@
-import httpx
-import asyncio
-
-async def check_eurusd_no_plus():
-    symbol = "EURUSD"
-    category = "linear"
-    url = f"https://api.bybit.com/v5/market/instruments-info?category={category}&symbol={symbol}"
-    async with httpx.AsyncClient() as client:
-        resp = await client.get(url)
-        data = resp.json()
-        print(f"Result for {symbol} in {category}: {data}")
-
-if __name__ == "__main__":
-    asyncio.run(check_eurusd_no_plus())

backend/check_wallet.py

@@ -1,39 +0,0 @@
-import httpx
-import asyncio
-import os
-import time
-import hmac
-import hashlib
-from dotenv import load_dotenv
-
-load_dotenv()
-
-async def check_wallet():
-    api_key = os.getenv("BYBIT_API_KEY")
-    api_secret = os.getenv("BYBIT_API_SECRET")
-    
-    url = "https://api.bybit.com/v5/account/wallet-balance"
-    params = {"accountType": "UNIFIED"}
-    
-    timestamp = str(int(time.time() * 1000))
-    recv_window = "5000"
-    sorted_params = "&".join([f"{k}={v}" for k, v in sorted(params.items())])
-    raw_str = timestamp + api_key + recv_window + sorted_params
-    signature = hmac.new(api_secret.encode('utf-8'), 
-                        raw_str.encode('utf-8'), hashlib.sha256).hexdigest()
-    
-    headers = {
-        'X-BAPI-API-KEY': api_key,
-        'X-BAPI-TIMESTAMP': timestamp,
-        'X-BAPI-SIGN-TYPE': '2',
-        'X-BAPI-RECV-WINDOW': recv_window,
-        'X-BAPI-SIGN': signature
-    }
-
-    async with httpx.AsyncClient() as client:
-        resp = await client.get(url, params=params, headers=headers)
-        data = resp.json()
-        print(f"Wallet Balance: {data}")
-
-if __name__ == "__main__":
-    asyncio.run(check_wallet())

backend/check_wallet_sync.py

@@ -1,44 +0,0 @@
-import httpx
-import asyncio
-import os
-import time
-import hmac
-import hashlib
-from dotenv import load_dotenv
-
-load_dotenv()
-
-async def check_wallet_fixed():
-    api_key = os.getenv("BYBIT_API_KEY")
-    api_secret = os.getenv("BYBIT_API_SECRET")
-    
-    # Get server time first
-    async with httpx.AsyncClient() as client:
-        time_resp = await client.get("https://api.bybit.com/v5/market/time")
-        server_time = time_resp.json()["result"]["timeNano"][:13]
-    
-    url = "https://api.bybit.com/v5/account/wallet-balance"
-    params = {"accountType": "UNIFIED"}
-    
-    timestamp = server_time
-    recv_window = "20000" # Larger window
-    sorted_params = "&".join([f"{k}={v}" for k, v in sorted(params.items())])
-    raw_str = timestamp + api_key + recv_window + sorted_params
-    signature = hmac.new(api_secret.encode('utf-8'), 
-                        raw_str.encode('utf-8'), hashlib.sha256).hexdigest()
-    
-    headers = {
-        'X-BAPI-API-KEY': api_key,
-        'X-BAPI-TIMESTAMP': timestamp,
-        'X-BAPI-SIGN-TYPE': '2',
-        'X-BAPI-RECV-WINDOW': recv_window,
-        'X-BAPI-SIGN': signature
-    }
-
-    async with httpx.AsyncClient() as client:
-        resp = await client.get(url, params=params, headers=headers)
-        data = resp.json()
-        print(f"Wallet Balance: {data}")
-
-if __name__ == "__main__":
-    asyncio.run(check_wallet_fixed())

backend/discover_bybit.py

@@ -1,26 +0,0 @@
-import httpx
-import asyncio
-
-async def list_bybit_instruments():
-    categories = ["spot", "linear", "inverse", "option"]
-    async with httpx.AsyncClient() as client:
-        for cat in categories:
-            url = f"https://api.bybit.com/v5/market/instruments-info?category={cat}"
-            print(f"Fetching category: {cat}...")
-            try:
-                resp = await client.get(url)
-                data = resp.json()
-                if data.get("retCode") == 0:
-                    symbols = [i["symbol"] for i in data["result"]["list"]]
-                    print(f"Found {len(symbols)} symbols in {cat}")
-                    # Look for anything non-crypto
-                    tradfi_like = [s for s in symbols if "+" in s or any(x in s for x in ["EUR", "GBP", "JPY", "XAU", "XAG", "WTI", "UKO"])]
-                    if tradfi_like:
-                        print(f"TradFi-like symbols in {cat}: {tradfi_like[:20]}...")
-                else:
-                    print(f"Failed to fetch {cat}: {data.get('retMsg')}")
-            except Exception as e:
-                print(f"Error fetching {cat}: {e}")
-
-if __name__ == "__main__":
-    asyncio.run(list_bybit_instruments())

backend/find_any_suffix.py

@@ -1,36 +0,0 @@
-import httpx
-import asyncio
-import os
-import time
-import hmac
-import hashlib
-from dotenv import load_dotenv
-
-load_dotenv()
-
-async def find_any_dot_s():
-    api_key = os.getenv("BYBIT_API_KEY")
-    api_secret = os.getenv("BYBIT_API_SECRET")
-    
-    url = "https://api.bybit.com/v5/market/instruments-info"
-    params = {"category": "linear", "limit": 1000}
-    
-    async with httpx.AsyncClient() as client:
-        resp = await client.get(url, params=params)
-        data = resp.json()
-        if data.get("retCode") == 0:
-            symbols = [item["symbol"] for item in data["result"]["list"]]
-            dot_s = [s for s in symbols if ".s" in s]
-            plus = [s for s in symbols if "+" in s]
-            print(f"Total symbols: {len(symbols)}")
-            print(f"Symbols with .s: {dot_s}")
-            print(f"Symbols with +: {plus}")
-            
-            # Search for XAU specifically
-            xau = [s for s in symbols if "XAU" in s]
-            print(f"XAU matches: {xau}")
-        else:
-            print(f"Error: {data}")
-
-if __name__ == "__main__":
-    asyncio.run(find_any_dot_s())

backend/list_linear.py

@@ -1,14 +0,0 @@
-import httpx
-import asyncio
-
-async def list_bybit_linear():
-    url = f"https://api.bybit.com/v5/market/instruments-info?category=linear"
-    async with httpx.AsyncClient() as client:
-        resp = await client.get(url)
-        data = resp.json()
-        if data.get("retCode") == 0:
-            symbols = [i["symbol"] for i in data["result"]["list"]]
-            print(f"First 50 linear symbols: {symbols[:50]}")
-            
-if __name__ == "__main__":
-    asyncio.run(list_bybit_linear())

backend/list_pybit_final.py

@@ -1,38 +0,0 @@
-from pybit.unified_trading import HTTP
-import os
-from dotenv import load_dotenv
-
-load_dotenv()
-
-def list_linear_pybit():
-    api_key = os.getenv("BYBIT_API_KEY")
-    api_secret = os.getenv("BYBIT_API_SECRET")
-    
-    session = HTTP(
-        api_key=api_key,
-        api_secret=api_secret,
-    )
-
-    try:
-        data = session.get_instruments_info(
-            category="linear",
-            limit=1000
-        )
-        if data.get("retCode") == 0:
-            symbols = [item["symbol"] for item in data["result"]["list"]]
-            print(f"Found {len(symbols)} symbols.")
-            with open("all_symbols_final.txt", "w") as f:
-                for s in symbols:
-                    f.write(s + "\n")
-            
-            # Search for specific substrings
-            for search in ["XAU", "EUR", "SPX", "AAPL", "TSLA"]:
-                matches = [s for s in symbols if search in s]
-                print(f"Matches for {search}: {matches}")
-        else:
-            print(f"Error: {data}")
-    except Exception as e:
-        print(f"Error: {e}")
-
-if __name__ == "__main__":
-    list_linear_pybit()

backend/main.py

@@ -64,6 +64,8 @@ from dotenv import load_dotenv
 
 # D-1: Load environment variables from .env file (v6.0)
 load_dotenv()
+os.environ["HF_HUB_DISABLE_SYMLINKS_WARNING"] = "1"
+os.environ["HF_HUB_DISABLE_TELEMETRY"] = "1"
 import re
 import sys
 import time
@@ -201,7 +203,7 @@ else:
     PROJECT_ROOT = os.path.dirname(CURRENT_DIR)
     logger.info("Running in DEV mode. PROJECT_ROOT: %s", PROJECT_ROOT)
 
-KRONOS_PATH = os.path.join(PROJECT_ROOT, "Kronos-master")
+KRONOS_PATH = os.path.join(CURRENT_DIR, "kronos_core")
 
 if KRONOS_PATH not in sys.path:
     sys.path.append(KRONOS_PATH)
@@ -314,7 +316,7 @@ class PersistentCache:
         except Exception as ex:
             logger.error("[Persistence] Eviction error: %s", ex)
 
-persistent_cache = PersistentCache(os.path.join(PROJECT_ROOT, "kronos_v5.db"))
+persistent_cache = PersistentCache(os.path.join(PROJECT_ROOT, "data", "kronos_v5.db"))
 
 
 # B-12: Global Configuration Instances
@@ -1409,6 +1411,26 @@ def _stoch_rsi(close: np.ndarray, rsi_period=14, stoch_period=14,
     return k_smooth.values, d_smooth.values
 
 
+def _stoch_kd(
+    high: np.ndarray,
+    low: np.ndarray,
+    close: np.ndarray,
+    k_period: int = 14,
+    smooth_k: int = 3,
+    d_period: int = 3,
+) -> Tuple[np.ndarray, np.ndarray]:
+    """Standard stochastic oscillator computed from price high/low/close."""
+    high_s = pd.Series(high)
+    low_s = pd.Series(low)
+    close_s = pd.Series(close)
+    hh = high_s.rolling(window=k_period).max()
+    ll = low_s.rolling(window=k_period).min()
+    raw_k = 100.0 * (close_s - ll) / (hh - ll).replace(0, np.nan)
+    k = raw_k.rolling(window=smooth_k).mean()
+    d = k.rolling(window=d_period).mean()
+    return k.values, d.values
+
+
 def _sma(arr: np.ndarray, period: int) -> np.ndarray:
     """Vectorized Simple Moving Average."""
     if len(arr) == 0: return np.array([], dtype=float)
@@ -1562,6 +1584,22 @@ def _ichimoku_base(high: np.ndarray, low: np.ndarray, period: int = 26) -> np.nd
     return ((hh + ll) / 2.0).values
 
 
+def _ichimoku_cloud(high: np.ndarray, low: np.ndarray) -> Dict[str, np.ndarray]:
+    """Basic Ichimoku lines for cloud-position scoring."""
+    hs = pd.Series(high)
+    ls = pd.Series(low)
+    tenkan = ((hs.rolling(9).max() + ls.rolling(9).min()) / 2.0).values
+    kijun = ((hs.rolling(26).max() + ls.rolling(26).min()) / 2.0).values
+    span_a = ((pd.Series(tenkan) + pd.Series(kijun)) / 2.0).values
+    span_b = ((hs.rolling(52).max() + ls.rolling(52).min()) / 2.0).values
+    return {
+        "tenkan": tenkan,
+        "kijun": kijun,
+        "span_a": span_a,
+        "span_b": span_b,
+    }
+
+
 def _vwma(close: np.ndarray, volume: np.ndarray, period: int = 20) -> np.ndarray:
     """Vectorized Volume Weighted Moving Average."""
     cv = pd.Series(close * volume)
@@ -1680,6 +1718,11 @@ def _osc_action(name: str, value: float, **kw) -> str:
     """Classify oscillator value as 'Mua' / 'Bán' / 'Trung lập'."""
     if value is None or math.isnan(value):
         return "Trung lập"
+    last_close = float(kw.get("last_close", 0.0) or 0.0)
+    ema50 = float(kw.get("ema50", last_close) or last_close)
+    ema200 = float(kw.get("ema200", last_close) or last_close)
+    ema50_prev = float(kw.get("ema50_prev", ema50) or ema50)
+    atr = max(float(kw.get("atr", 0.0) or 0.0), 1e-8)
     if name == "roc":
         return "Mua" if value > 1.0 else "Bán" if value < -1.0 else "Trung lập"
     if name == "trix":
@@ -1689,13 +1732,19 @@ def _osc_action(name: str, value: float, **kw) -> str:
     if name == "cmo":
         return "Mua" if value > 20 else "Bán" if value < -20 else "Trung lập"
     if name == "dpo":
-        return "Mua" if value > 0 else "Bán" if value < 0 else "Trung lập"
+        return "Trung lập"
     if name == "aroon":
         return "Mua" if value > 25 else "Bán" if value < -25 else "Trung lập"
     if name == "tsi":
         return "Mua" if value > 5 else "Bán" if value < -5 else "Trung lập"
     if name == "rsi":
-        return "Bán" if value > 70 else "Mua" if value < 30 else "Trung lập"
+        ema50_rising = ema50 >= ema50_prev
+        above_ema200 = last_close >= ema200
+        if value > 70:
+            return "Trung lập" if above_ema200 and ema50_rising else "Bán"
+        if value < 30:
+            return "Mua" if above_ema200 else "Trung lập"
+        return "Mua" if value >= 50 else "Bán"
     if name == "stoch":
         return "Bán" if value > 80 else "Mua" if value < 20 else "Trung lập"
     if name == "cci":
@@ -1707,7 +1756,12 @@ def _osc_action(name: str, value: float, **kw) -> str:
             return "Trung lập"
         return "Mua" if plus_di > minus_di else "Bán"
     if name == "ao":
-        return "Mua" if value > 0 else "Bán" if value < 0 else "Trung lập"
+        prev = float(kw.get("prev", value) or value)
+        if value > 0 and value > prev:
+            return "Mua"
+        if value < 0 and value < prev:
+            return "Bán"
+        return "Trung lập"
     if name == "momentum":
         return "Mua" if value > 0 else "Bán" if value < 0 else "Trung lập"
     if name == "macd":
@@ -1718,17 +1772,52 @@ def _osc_action(name: str, value: float, **kw) -> str:
     if name == "williams":
         return "Mua" if value < -80 else "Bán" if value > -20 else "Trung lập"
     if name == "bbp":
-        return "Mua" if value > 0 else "Bán" if value < 0 else "Trung lập"
+        bbp_norm = float(kw.get("bbp_norm", value / atr))
+        return "Mua" if bbp_norm > 0.5 else "Bán" if bbp_norm < -0.5 else "Trung lập"
     if name == "ultimate":
         return "Bán" if value > 70 else "Mua" if value < 30 else "Trung lập"
     return "Trung lập"
 
 
-def _ma_action(price: float, ma_val: float) -> str:
-    """Classify MA as 'Mua' (price > MA) or 'Bán' (price < MA)."""
+def _ma_action(price: float, ma_val: float, threshold_pct: float = 0.3) -> str:
+    """Classify MA with a neutral zone when price is too close to the average."""
     if ma_val is None or math.isnan(ma_val):
         return "Trung lập"
-    return "Mua" if price > ma_val else "Bán"
+    dist_pct = _pct(price, ma_val)
+    if abs(dist_pct) < threshold_pct:
+        return "Trung lập"
+    return "Mua" if dist_pct > 0 else "Bán"
+
+
+def _ma_threshold_pct(ma_key: str) -> float:
+    thresholds = {
+        "ema_200": 3.0, "sma_200": 3.0,
+        "ema_100": 2.2, "sma_100": 2.2,
+        "ema_50": 1.5, "sma_50": 1.5,
+        "ema_30": 1.2, "sma_30": 1.2,
+        "ema_20": 1.0, "sma_20": 1.0,
+        "ema_10": 0.8, "sma_10": 0.8,
+        "ichimoku": 1.5, "hull_9": 1.0,
+    }
+    return thresholds.get(ma_key, 1.2)
+
+
+def _ma_signal_score(price: float, ma_val: float, ma_prev: Optional[float], threshold_pct: float) -> float:
+    if ma_val is None or math.isnan(ma_val):
+        return 0.0
+    dist_pct = _pct(price, ma_val)
+    score = math.tanh(dist_pct / max(threshold_pct, 0.1))
+    if ma_prev is not None and not math.isnan(ma_prev):
+        slope_pct = _pct(ma_val, ma_prev)
+        if score > 0 and slope_pct > 0:
+            score *= 1.2
+        elif score > 0 and slope_pct < 0:
+            score *= 0.8
+        elif score < 0 and slope_pct < 0:
+            score *= 1.2
+        elif score < 0 and slope_pct > 0:
+            score *= 0.8
+    return _clamp(score, -1.0, 1.0)
 
 
 def _osc_signal_score(name: str, value: float, **kw) -> float:
@@ -1739,7 +1828,12 @@ def _osc_signal_score(name: str, value: float, **kw) -> float:
     scale = max(float(kw.get("scale", 1.0) or 1.0), 1e-8)
 
     if name == "rsi":
-        return _clamp((50.0 - value) / 25.0, -1.0, 1.0)
+        trend_bias = 0.0
+        if kw.get("last_close", 0.0) >= kw.get("ema200", kw.get("last_close", 0.0)):
+            trend_bias = 0.15 if value >= 50 else -0.05
+        else:
+            trend_bias = -0.15 if value <= 50 else 0.05
+        return _clamp((value - 50.0) / 25.0 + trend_bias, -1.0, 1.0)
     if name in {"stoch", "stoch_rsi"}:
         return _clamp((50.0 - value) / 30.0, -1.0, 1.0)
     if name == "cci":
@@ -1750,13 +1844,18 @@ def _osc_signal_score(name: str, value: float, **kw) -> float:
         strength = _clamp((value - 18.0) / 22.0, 0.0, 1.0)
         direction = math.tanh((plus_di - minus_di) / max(plus_di + minus_di, 10.0) * 3.0)
         return _clamp(direction * strength, -1.0, 1.0)
-    if name in {"ao", "momentum", "bbp", "dpo"}:
+    if name in {"ao", "momentum"}:
         return _clamp(math.tanh(value / scale), -1.0, 1.0)
+    if name == "bbp":
+        bbp_norm = float(kw.get("bbp_norm", value / max(float(kw.get("atr", scale) or scale), 1e-8)))
+        return _clamp(math.tanh(bbp_norm / 1.0), -1.0, 1.0)
+    if name == "dpo":
+        return 0.0
     if name == "macd":
         signal = float(kw.get("signal", 0.0) or 0.0)
         return _clamp(math.tanh((value - signal) / scale), -1.0, 1.0)
     if name == "williams":
-        return _clamp(((-50.0) - value) / 30.0, -1.0, 1.0)
+        return _clamp(((-value) - 50.0) / 30.0, -1.0, 1.0)
     if name == "ultimate":
         return _clamp((50.0 - value) / 25.0, -1.0, 1.0)
     if name == "roc":
@@ -2542,43 +2641,43 @@ def _build_reasoning(
 
 # ── Technical Analysis Weights & Constants (Dashboard Rework v6.1) ────────────
 OSC_WEIGHTS = {
-    "rsi":       2.5,   # Leading indicator, battle-tested
-    "macd":      2.2,   # Trend + momentum hybrid
-    "stoch_rsi": 1.8,   # High sensitivity
+    "rsi":       2.0,
+    "macd":      2.5,
+    "stoch_rsi": 1.2,
     "stoch":     1.3,   # Classic momentum
-    "cci":       1.5,   # Good for extreme detection
-    "adx":       1.5,   # Trend strength (direction via DI)
-    "williams":  1.3,   # Complement to RSI
+    "cci":       1.6,
+    "adx":       1.8,
+    "williams":  1.4,
     "ultimate":  1.2,   # Multi-period, less noise
     "bbp":       1.0,   # Trend-following
     "ao":        0.9,   # Noisy, short-term only
     "momentum":  0.8,   # Lagging, lowest weight
-    "roc":       1.4,   # Clean rate-of-change confirmation
-    "trix":      1.2,   # Smoothed trend momentum
-    "ppo":       1.6,   # Percentage trend acceleration
+    "roc":       1.3,
+    "trix":      1.6,
+    "ppo":       1.5,
     "cmo":       1.3,   # Momentum regime strength
-    "dpo":       1.0,   # Mean-reversion / cycle context
-    "aroon":     1.5,   # Trend freshness / breakout context
-    "tsi":       1.4,   # Smoothed momentum quality
+    "dpo":       0.3,
+    "aroon":     1.6,
+    "tsi":       1.8,
 }
 
 MA_WEIGHT_MAP = {
-    "ema_200": 3.0, "sma_200": 2.8,
+    "ema_200": 2.5, "sma_200": 2.3,
     "ema_100": 2.3, "sma_100": 2.1,
-    "ema_50":  1.8, "sma_50":  1.6,
+    "ema_50":  2.0, "sma_50":  1.8,
     "ema_30":  1.3, "sma_30":  1.2,
-    "ema_20":  1.1, "sma_20":  1.0,
+    "ema_20":  1.4, "sma_20":  1.2,
     "ema_10":  0.8, "sma_10":  0.7,
-    "vwma_20": 1.5, "ichimoku": 1.4, "hull_9": 1.3
+    "ichimoku": 1.6, "hull_9": 1.3
 }
 
 def _extract_osc_key(label: str) -> str:
     l = label.lower()
-    if "rsi" in l and "nhanh" not in l: return "rsi"
+    if "sức mạnh tương đối" in l or ("rsi" in l and "nhanh" not in l): return "rsi"
     if "macd" in l: return "macd"
     if "stochastic %k" in l: return "stoch"
     if "nhanh" in l or "stoch_rsi" in l: return "stoch_rsi"
-    if "cci" in l: return "cci"
+    if "kênh hàng hóa" in l or "cci" in l: return "cci"
     if "định hướng" in l or "adx" in l: return "adx"
     if "williams" in l: return "williams"
     if "ultimate" in l: return "ultimate"
@@ -2596,6 +2695,8 @@ def _extract_osc_key(label: str) -> str:
 
 def _get_ma_weight(label: str) -> float:
     l = label.lower()
+    if l in MA_WEIGHT_MAP:
+        return MA_WEIGHT_MAP[l]
     if "hàm mũ" in l: 
         p = re.findall(r"\d+", l)
         if p: return MA_WEIGHT_MAP.get(f"ema_{p[0]}", 1.0)
@@ -2603,17 +2704,26 @@ def _get_ma_weight(label: str) -> float:
         p = re.findall(r"\d+", l)
         if p: return MA_WEIGHT_MAP.get(f"sma_{p[0]}", 1.0)
     if "ichimoku" in l: return MA_WEIGHT_MAP["ichimoku"]
-    if "vwma" in l or "tỷ trọng tuyến tính" in l: return MA_WEIGHT_MAP["vwma_20"]
     if "hull" in l: return MA_WEIGHT_MAP["hull_9"]
     return 1.0
 
-def _gauge_to_signal(gauge: float) -> str:
-    """Unified 5-level signal converter."""
-    if gauge >= 75:   return "Mua mạnh"
-    elif gauge >= 58: return "Mua"
-    elif gauge >= 42: return "Trung lập"
-    elif gauge >= 25: return "Bán"
-    else:             return "Bán mạnh"
+def _gauge_to_signal(gauge: float, interval: str = "1h") -> str:
+    """Interval-aware 5-level signal converter."""
+    thresholds = {
+        "1m": (80, 62, 38, 20),
+        "5m": (80, 62, 38, 20),
+        "15m": (77, 60, 40, 23),
+        "1h": (77, 60, 40, 23),
+        "4h": (75, 58, 42, 25),
+        "1d": (75, 58, 42, 25),
+        "1w": (72, 56, 44, 28),
+    }
+    strong_buy, buy, sell, strong_sell = thresholds.get(interval, thresholds["1h"])
+    if gauge >= strong_buy: return "Mua mạnh"
+    if gauge >= buy: return "Mua"
+    if gauge > sell: return "Trung lập"
+    if gauge > strong_sell: return "Bán"
+    return "Bán mạnh"
 
 
 def _gauge_to_normalized_score(gauge: float) -> float:
@@ -2671,24 +2781,28 @@ def _forecast_path_metrics(p50_path: np.ndarray, last_close: float) -> Dict[str,
         "mean_step_return_pct": round(mean_step_return_pct, 3),
     }
 
-def _calc_osc_score(osc_data: list) -> dict:
+def _calc_osc_score(osc_data: list, interval: str = "1h") -> dict:
     """MODULE 1: Weighted scoring for oscillators."""
     total_weight = 0.0
     weighted_score = 0.0
     buy = sell = neutral = 0
+    buy_weight = sell_weight = neutral_weight = 0.0
     
     for item in osc_data:
-        key = _extract_osc_key(item["name"])
+        key = item.get("key") or _extract_osc_key(item["name"])
         w = OSC_WEIGHTS.get(key, 1.0)
         v = float(item.get("score", 0.0) or 0.0)
         # Robust case-insensitive check
         act = str(item.get("action", "")).strip().lower()
         if act == "mua":
             buy += 1
+            buy_weight += w
         elif act == "bán":
             sell += 1
+            sell_weight += w
         else:
             neutral += 1
+            neutral_weight += w
             
         weighted_score += w * v
         total_weight += w
@@ -2698,28 +2812,33 @@ def _calc_osc_score(osc_data: list) -> dict:
     return {
         "gauge": round(gauge, 1),
         "normalized_score": round(normalized, 4),
-        "signal": _gauge_to_signal(gauge),
-        "buy": buy, "sell": sell, "neutral": neutral
+        "signal": _gauge_to_signal(gauge, interval),
+        "buy": buy, "sell": sell, "neutral": neutral,
+        "buy_weight": round(buy_weight, 2),
+        "sell_weight": round(sell_weight, 2),
+        "neutral_weight": round(neutral_weight, 2),
     }
 
-def _calc_ma_score(ma_data: list, closes: np.ndarray) -> dict:
+def _calc_ma_score(ma_data: list, closes: np.ndarray, interval: str = "1h") -> dict:
     """MODULE 2: Period-weighted scoring for MAs + Cross Bonus."""
     total_weight = 0.0
     weighted_score = 0.0
     buy = sell = neutral = 0
+    buy_weight = sell_weight = neutral_weight = 0.0
     
     for item in ma_data:
-        w = _get_ma_weight(item["name"])
-        v = 0.0
+        w = _get_ma_weight(item.get("key") or item["name"])
+        v = float(item.get("score", 0.0) or 0.0)
         act = str(item.get("action", "")).strip().lower()
         if act == "mua":
-            v = 1.0
             buy += 1
+            buy_weight += w
         elif act == "bán":
-            v = -1.0
             sell += 1
+            sell_weight += w
         else:
             neutral += 1
+            neutral_weight += w
             
         weighted_score += w * v
         total_weight += w
@@ -2740,8 +2859,11 @@ def _calc_ma_score(ma_data: list, closes: np.ndarray) -> dict:
     return {
         "gauge": round(gauge, 1),
         "normalized_score": round(normalized, 4),
-        "signal": _gauge_to_signal(gauge),
+        "signal": _gauge_to_signal(gauge, interval),
         "buy": buy, "sell": sell, "neutral": neutral,
+        "buy_weight": round(buy_weight, 2),
+        "sell_weight": round(sell_weight, 2),
+        "neutral_weight": round(neutral_weight, 2),
         "golden_cross": cross_bonus > 0,
         "death_cross": cross_bonus < 0
     }
@@ -2844,7 +2966,7 @@ def _calc_ai_forecast_score(
         "monotonicity": round(monotonicity * 100.0, 1),
         "max_adverse_excursion_pct": round(adverse_excursion_pct, 2),
         "path_metrics": path_metrics,
-        "signal": _gauge_to_signal(gauge)
+        "signal": _gauge_to_signal(gauge, interval)
     }
 
 def _calc_summary_score(osc_score: dict, ma_score: dict, ai_score: dict) -> dict:
@@ -2885,9 +3007,18 @@ def _calc_summary_score(osc_score: dict, ma_score: dict, ai_score: dict) -> dict
         }
     }
 
-def _calc_technical_score_v2(osc_score: dict, ma_score: dict) -> dict:
-    """Blend oscillators and moving averages into a single technical gauge."""
-    base = (osc_score["gauge"] * 0.42) + (ma_score["gauge"] * 0.58)
+def _calc_technical_score_v2(osc_score: dict, ma_score: dict, regime: str = "sideways", interval: str = "1h") -> dict:
+    """Blend oscillators and moving averages using regime-aware weighting."""
+    if regime in {"stable_bull", "stable_bear"}:
+        osc_weight, ma_weight = 0.45, 0.55
+    elif regime in {"tight_range", "sideways"}:
+        osc_weight, ma_weight = 0.60, 0.40
+    elif regime in {"overextended_bull", "capitulation"}:
+        osc_weight, ma_weight = 0.55, 0.45
+    else:
+        osc_weight, ma_weight = 0.50, 0.50
+
+    base = (osc_score["gauge"] * osc_weight) + (ma_score["gauge"] * ma_weight)
     osc_delta = osc_score["gauge"] - 50.0
     ma_delta = ma_score["gauge"] - 50.0
     osc_dir = math.copysign(1.0, osc_delta) if abs(osc_delta) >= 1.0 else 0.0
@@ -2906,10 +3037,13 @@ def _calc_technical_score_v2(osc_score: dict, ma_score: dict) -> dict:
     return {
         "gauge": round(final_gauge, 1),
         "normalized_score": round(_gauge_to_normalized_score(final_gauge), 4),
-        "signal": _gauge_to_signal(final_gauge),
+        "signal": _gauge_to_signal(final_gauge, interval),
         "buy": osc_score["buy"] + ma_score["buy"],
         "sell": osc_score["sell"] + ma_score["sell"],
         "neutral": osc_score["neutral"] + ma_score["neutral"],
+        "buy_weight": round(osc_score.get("buy_weight", 0.0) + ma_score.get("buy_weight", 0.0), 2),
+        "sell_weight": round(osc_score.get("sell_weight", 0.0) + ma_score.get("sell_weight", 0.0), 2),
+        "neutral_weight": round(osc_score.get("neutral_weight", 0.0) + ma_score.get("neutral_weight", 0.0), 2),
         "alignment": osc_dir == ma_dir and osc_dir != 0.0,
         "components": {
             "oscillators": round(osc_score["gauge"], 1),
@@ -2917,10 +3051,12 @@ def _calc_technical_score_v2(osc_score: dict, ma_score: dict) -> dict:
         }
     }
 
-def _calc_summary_score_v2(tech_score: dict, ai_score: dict) -> dict:
-    """Final decision score defined as the simple mean of technical and AI gauges."""
-    composite = (float(tech_score["gauge"]) + float(ai_score["gauge"])) / 2.0
-    final_gauge = max(5.0, min(95.0, composite))
+def _calc_summary_score_v2(tech_score: dict, ai_score: dict, interval: str = "1h") -> dict:
+    """Final decision score: simple average of Technical and AI gauges."""
+    # TỔNG KẾT = (PHÂN TÍCH KỸ THUẬT + DỰ BÁO AI)/2
+    ai_weight, tech_weight = 0.5, 0.5
+    final_gauge = (float(tech_score["gauge"]) + float(ai_score["gauge"])) / 2.0
+    final_gauge = max(5.0, min(95.0, final_gauge))
     dist = abs(final_gauge - 50.0)
     conviction = "Rất mạnh" if dist >= 25 else "Mạnh" if dist >= 15 else "Trung bình" if dist >= 8 else "Yếu"
 
@@ -2933,17 +3069,22 @@ def _calc_summary_score_v2(tech_score: dict, ai_score: dict) -> dict:
     return {
         "gauge": round(final_gauge, 1),
         "normalized_score": round(_gauge_to_normalized_score(final_gauge), 4),
-        "signal": _gauge_to_signal(final_gauge),
+        "signal": _gauge_to_signal(final_gauge, interval),
         "conviction": conviction,
         "bias": bias,
         "buy": tech_score["buy"],
         "sell": tech_score["sell"],
         "neutral": tech_score["neutral"],
+        "buy_weight": tech_score.get("buy_weight", 0.0),
+        "sell_weight": tech_score.get("sell_weight", 0.0),
+        "neutral_weight": tech_score.get("neutral_weight", 0.0),
         "components": {
             "technical": round(tech_score["gauge"], 1),
             "oscillators": round(tech_score["components"]["oscillators"], 1),
             "moving_averages": round(tech_score["components"]["moving_averages"], 1),
-            "ai_forecast": round(ai_score["gauge"], 1)
+            "ai_forecast": round(ai_score["gauge"], 1),
+            "ai_weight": round(ai_weight, 2),
+            "technical_weight": round(tech_weight, 2),
         }
     }
 
@@ -2968,6 +3109,9 @@ def _build_dashboard_payload(
             "buy": technical_score["buy"],
             "sell": technical_score["sell"],
             "neutral": technical_score["neutral"],
+            "buy_weight": technical_score.get("buy_weight", 0.0),
+            "sell_weight": technical_score.get("sell_weight", 0.0),
+            "neutral_weight": technical_score.get("neutral_weight", 0.0),
         },
         "ai": {
             "gauge": ai_score["gauge"],
@@ -2989,6 +3133,9 @@ def _build_dashboard_payload(
             "signal": summary["signal"],
             "conviction": summary["conviction"],
             "bias": summary["bias"],
+            "buy_weight": summary.get("buy_weight", 0.0),
+            "sell_weight": summary.get("sell_weight", 0.0),
+            "neutral_weight": summary.get("neutral_weight", 0.0),
         },
     }
 
@@ -3032,58 +3179,89 @@ def _build_trade_analysis(
     last_close = closes[-1]
 
     def _lv(arr):
+        if arr is None: return None
+        if isinstance(arr, (float, int)): return round(float(arr), 2)
         if isinstance(arr, pd.Series): arr = arr.values
-        v = arr[-1] if len(arr) else float('nan')
-        return None if (v is None or (isinstance(v, float) and math.isnan(v))) else round(float(v), 2)
+        v = arr[-1] if (hasattr(arr, '__len__') and len(arr) > 0) else float('nan')
+        if v is None or (isinstance(v, float) and math.isnan(v)): return None
+        return round(float(v), 2)
+
+    regime, regime_label = _classify_regime(indicators, last_close, _safe(indicators.get("atr", {}).get("pct"), 1.0))
 
     # ── 1. Oscillators ──
     osc_data = []
     atr_scale = max(float(indicators.get("atr", {}).get("value") or last_close * 0.01), max(last_close * 0.0015, 1e-6))
-    def _add_osc(label, val, action_name, **kw):
+    def _add_osc(label, val, action_name, key=None, **kw):
         if isinstance(val, (np.ndarray, pd.Series, list)): v = _lv(val)
         else: v = round(float(val), 2) if val is not None else None
-        act = _osc_action(action_name, v if v is not None else 0, **kw)
-        score = _osc_signal_score(action_name, v if v is not None else 0.0, **kw)
-        osc_data.append({"name": label, "value": v, "action": act, "score": round(score, 4)})
-
-    _add_osc("Chỉ số Sức mạnh tương đối (14)", _rsi(closes, 14), "rsi")
-    _add_osc("Stochastic %K (14, 3, 3)", _stoch_rsi(closes, 14, 14, 3, 3)[0], "stoch")
-    _add_osc("Chỉ số Kênh hàng hóa (20)", _cci(highs, lows, closes, 20), "cci")
+        osc_key = key or action_name
+        osc_kwargs = {
+            "last_close": last_close,
+            "ema50": _lv(indicators["ema"].get("ema50")) or last_close,
+            "ema200": _lv(indicators["ema"].get("ema200")) or last_close,
+            "ema50_prev": float(_ema(closes, 50)[-6]) if len(closes) >= 6 and not math.isnan(_ema(closes, 50)[-6]) else (_lv(indicators["ema"].get("ema50")) or last_close),
+            "atr": atr_scale,
+            **kw,
+        }
+        act = _osc_action(action_name, v if v is not None else 0, **osc_kwargs)
+        score = _osc_signal_score(action_name, v if v is not None else 0.0, **osc_kwargs)
+        osc_data.append({"key": osc_key, "name": label, "value": v, "action": act, "score": round(score, 4)})
+
+    stoch_price_k, stoch_price_d = _stoch_kd(highs, lows, closes, 14, 3, 3)
+    stoch_rsi_k, stoch_rsi_d = _stoch_rsi(closes, 14, 14, 3, 3)
+    _add_osc("Chỉ số Sức mạnh tương đối (14)", _rsi(closes, 14), "rsi", key="rsi")
+    _add_osc("Stochastic %K (14, 3, 3)", stoch_price_k, "stoch", key="stoch")
+    _add_osc("Chỉ số Kênh hàng hóa (20)", _cci(highs, lows, closes, 20), "cci", key="cci")
     adx_vals = _adx(highs, lows, closes, 14)
-    _add_osc("Chỉ số Định hướng Trung bình (14)", adx_vals[0], "adx", plus_di=_lv(adx_vals[1]) or 0, minus_di=_lv(adx_vals[2]) or 0)
-    _add_osc("Chỉ số Dao động AO", _awesome_oscillator(highs, lows), "ao", scale=atr_scale * 0.8)
-    _add_osc("Xung lượng (10)", _momentum(closes, 10), "momentum", scale=atr_scale * 1.15)
+    _add_osc("Chỉ số Định hướng Trung bình (14)", adx_vals[0], "adx", key="adx", plus_di=_lv(adx_vals[1]) or 0, minus_di=_lv(adx_vals[2]) or 0)
+    ao_vals = _awesome_oscillator(highs, lows)
+    ao_prev = _lv(ao_vals[:-1]) if len(ao_vals) > 1 else _lv(ao_vals)
+    _add_osc("Chỉ số Dao động AO", ao_vals, "ao", key="ao", scale=atr_scale * 0.8, prev=ao_prev or 0.0)
+    _add_osc("Xung lượng (10)", _momentum(closes, 10), "momentum", key="momentum", scale=atr_scale * 1.15)
     macd_vals = _macd(closes, 12, 26, 9)
-    _add_osc("Cấp độ MACD (12, 26)", macd_vals[0], "macd", signal=_lv(macd_vals[1]) or 0, scale=atr_scale * 0.18)
-    _add_osc("Đường RSI Nhanh (3, 3, 14, 14)", _stoch_rsi(closes, 14, 14, 3, 3)[0], "stoch_rsi")
-    _add_osc("Vùng Phần trăm Williams (14)", _williams_r(highs, lows, closes, 14), "williams")
-    _add_osc("Sức Mạnh Giá Lên và Giá Xuống", _bull_bear_power(highs, lows, closes, 13), "bbp", scale=atr_scale * 0.9)
-    _add_osc("Dao động Ultimate (7, 14, 28)", _ultimate_oscillator(highs, lows, closes, 7, 14, 28), "ultimate")
-    _add_osc("Tốc độ biến động ROC (12)", _roc(closes, 12), "roc")
-    _add_osc("TRIX (18)", _trix(closes, 18), "trix")
-    _add_osc("PPO (12, 26)", _ppo(closes, 12, 26), "ppo")
-    _add_osc("CMO (14)", _cmo(closes, 14), "cmo")
-    _add_osc("DPO (20)", _dpo(closes, 20), "dpo", scale=atr_scale * 0.75)
-    _add_osc("Aroon Oscillator (25)", _aroon_oscillator(highs, lows, 25), "aroon")
-    _add_osc("TSI (25, 13)", _tsi(closes, 25, 13), "tsi")
-
-    osc_score = _calc_osc_score(osc_data)
+    _add_osc("Cấp độ MACD (12, 26)", macd_vals[0], "macd", key="macd", signal=_lv(macd_vals[1]) or 0, scale=atr_scale * 0.18)
+    _add_osc("Đường RSI Nhanh (3, 3, 14, 14)", stoch_rsi_k, "stoch_rsi", key="stoch_rsi")
+    _add_osc("Vùng Phần trăm Williams (14)", _williams_r(highs, lows, closes, 14), "williams", key="williams")
+    bbp_vals = _bull_bear_power(highs, lows, closes, 13)
+    _add_osc("Sức Mạnh Giá Lên và Giá Xuống", bbp_vals, "bbp", key="bbp", scale=atr_scale * 0.9, bbp_norm=(_lv(bbp_vals) or 0.0) / atr_scale)
+    _add_osc("Dao động Ultimate (7, 14, 28)", _ultimate_oscillator(highs, lows, closes, 7, 14, 28), "ultimate", key="ultimate")
+    _add_osc("Tốc độ biến động ROC (12)", _roc(closes, 12), "roc", key="roc")
+    _add_osc("TRIX (18)", _trix(closes, 18), "trix", key="trix")
+    _add_osc("PPO (12, 26)", _ppo(closes, 12, 26), "ppo", key="ppo")
+    _add_osc("CMO (14)", _cmo(closes, 14), "cmo", key="cmo")
+    _add_osc("DPO (20)", _dpo(closes, 20), "dpo", key="dpo", scale=atr_scale * 0.75)
+    _add_osc("Aroon Oscillator (25)", _aroon_oscillator(highs, lows, 25), "aroon", key="aroon")
+    _add_osc("TSI (25, 13)", _tsi(closes, 25, 13), "tsi", key="tsi")
+
+    osc_score = _calc_osc_score(osc_data, interval)
 
     # ── 2. Moving Averages ──
     ma_data = []
-    def _add_ma(label, val_arr):
+    def _add_ma(label, val_arr, key=None, threshold_pct=None):
         v = _lv(val_arr)
-        act = _ma_action(last_close, v if v is not None else last_close)
-        ma_data.append({"name": label, "value": v, "action": act})
+        ma_key = key or label.lower()
+        threshold = threshold_pct if threshold_pct is not None else _ma_threshold_pct(ma_key)
+        prev_val = None
+        if isinstance(val_arr, (np.ndarray, list, pd.Series)) and len(val_arr) >= 6:
+            prev_raw = val_arr[-6]
+            prev_val = None if prev_raw is None or (isinstance(prev_raw, float) and math.isnan(prev_raw)) else float(prev_raw)
+        act = _ma_action(last_close, v if v is not None else last_close, min(0.5, threshold * 0.25))
+        score = _ma_signal_score(last_close, v if v is not None else last_close, prev_val, threshold)
+        ma_data.append({"key": ma_key, "name": label, "value": v, "action": act, "score": round(score, 4)})
 
     for p in [10, 20, 30, 50, 100, 200]:
-        _add_ma(f"Trung bình Trượt Hàm mũ ({p})", _ema(closes, p))
-        _add_ma(f"Đường Trung bình trượt Đơn giản ({p})", _sma(closes, p))
-    _add_ma("Đường cơ sở Ichimoku (9, 26, 52, 26)", _ichimoku_base(highs, lows, 26))
-    _add_ma("Đường Trung bình di động Tỷ trọng tuyến tính (20)", _vwma(closes, vols, 20))
-    _add_ma("Đường trung bình trượt Hull (9)", _hull_ma(closes, 9))
-
-    ma_score = _calc_ma_score(ma_data, closes)
+        _add_ma(f"Trung bình Trượt Hàm mũ ({p})", _ema(closes, p), key=f"ema_{p}")
+        _add_ma(f"Đường Trung bình trượt Đơn giản ({p})", _sma(closes, p), key=f"sma_{p}")
+    cloud = _ichimoku_cloud(highs, lows)
+    span_a = _lv(cloud["span_a"])
+    span_b = _lv(cloud["span_b"])
+    cloud_top = max(span_a or last_close, span_b or last_close)
+    cloud_bot = min(span_a or last_close, span_b or last_close)
+    cloud_proxy = cloud_top if last_close >= cloud_top else cloud_bot if last_close <= cloud_bot else last_close
+    _add_ma("Đám mây Ichimoku (9, 26, 52, 26)", np.array([cloud_proxy]), key="ichimoku", threshold_pct=1.5)
+    _add_ma("Đường trung bình trượt Hull (9)", _hull_ma(closes, 9), key="hull_9")
+
+    ma_score = _calc_ma_score(ma_data, closes, interval)
 
     # ── 3. AI Forecast Gauge ──
     if not blended:
@@ -3104,8 +3282,8 @@ def _build_trade_analysis(
     )
 
     # ── 4. Summary ──
-    technical_score = _calc_technical_score_v2(osc_score, ma_score)
-    summary = _calc_summary_score_v2(technical_score, ai_score)
+    technical_score = _calc_technical_score_v2(osc_score, ma_score, regime, interval)
+    summary = _calc_summary_score_v2(technical_score, ai_score, interval)
 
     # Pivot Points
     last_h = float(highs[-2]) if len(highs) > 1 else float(highs[-1])
@@ -3116,6 +3294,7 @@ def _build_trade_analysis(
 
     return {
         "style": "tradingview",
+        "regime": {"key": regime, "label": regime_label},
         "dashboard": dashboard,
         "summary": summary,
         "technicals": technical_score,
@@ -3125,6 +3304,9 @@ def _build_trade_analysis(
             "buy": osc_score["buy"],
             "sell": osc_score["sell"],
             "neutral": osc_score["neutral"],
+            "buy_weight": osc_score.get("buy_weight", 0.0),
+            "sell_weight": osc_score.get("sell_weight", 0.0),
+            "neutral_weight": osc_score.get("neutral_weight", 0.0),
             "data": osc_data
         },
         "moving_averages": {
@@ -3133,6 +3315,9 @@ def _build_trade_analysis(
             "buy": ma_score["buy"],
             "sell": ma_score["sell"],
             "neutral": ma_score["neutral"],
+            "buy_weight": ma_score.get("buy_weight", 0.0),
+            "sell_weight": ma_score.get("sell_weight", 0.0),
+            "neutral_weight": ma_score.get("neutral_weight", 0.0),
             "golden_cross": ma_score["golden_cross"],
             "death_cross": ma_score["death_cross"],
             "data": ma_data
@@ -3581,7 +3766,7 @@ async def _source_selftest():
         ("bybit",      "https://api.bybit.com/v5/market/time"),
         ("coingecko",  "https://api.coingecko.com/api/v3/ping"),
         ("twelvedata", f"https://api.twelvedata.com/api_usage?apikey={TWELVEDATA_API_KEY}"),
-        ("finnhub",    f"https://finnhub.io/api/v1/status?token={FINNHUB_API_KEY}"),
+        ("finnhub",    f"https://finnhub.io/api/v1/quote?symbol=AAPL&token={FINNHUB_API_KEY}"),
     ]
     async with httpx.AsyncClient(timeout=8) as c:
         for name, url in tests:

backend/recovery.py

@@ -1,129 +0,0 @@
-import sys
-import os
-
-# RECOVERY SCRIPT FOR KRONOS BACKEND v6.0
-# Restores the missing functions and fixes the structure
-
-def get_part1(): # Imports to SYMBOLS
-    # We can read this from current file as it's likely safe (lines 1-1220)
-    with open('backend/main.py', 'r', encoding='utf-8', errors='replace') as f:
-        lines = f.readlines()
-    return lines[:1220]
-
-def get_correct_fetchers():
-    return [
-        "def _get_source_priority(symbol: str) -> List[str]:\n",
-        "    cfg = SYMBOLS[symbol]\n",
-        "    priority = CATEGORY_SOURCE_PRIORITY.get(cfg.category, DEFAULT_SOURCE_PRIORITY)\n",
-        "    return [s for s in priority if s in cfg.mappings]\n",
-        "\n",
-        "\n",
-        "async def fetch_historical(\n",
-        "    symbol: str, interval: str, limit: int\n",
-        ") -> Tuple[List[Dict[str, Any]], str]:\n",
-        "    prefix = _cache_prefix(symbol, interval)\n",
-        "    key    = f'hist_{prefix}'\n",
-        "    cached = historical_cache.get(key)\n",
-        "    if cached is not None:\n",
-        "        return cached[-limit:], 'cache'\n",
-        "    priority = _get_source_priority(symbol)\n",
-        "    errors: List[str] = []\n",
-        "    fetch_limit = max(limit, 1000)\n",
-        "    for source in priority:\n",
-        "        try:\n",
-        "            if source == 'binance': data = await fetch_binance(symbol, interval, fetch_limit)\n",
-        "            elif source == 'bybit': data = await fetch_bybit(symbol, interval, fetch_limit)\n",
-        "            elif source == 'coingecko': data = await fetch_coingecko(symbol, interval, fetch_limit)\n",
-        "            elif source == 'twelvedata': data = await fetch_twelvedata(symbol, interval, fetch_limit)\n",
-        "            elif source == 'finnhub': data = await fetch_finnhub(symbol, interval, fetch_limit)\n",
-        "            elif source == 'yfinance': data = await fetch_yfinance(symbol, interval, fetch_limit)\n",
-        "            else: continue\n",
-        "            if len(data) >= 20:\n",
-        "                historical_cache.set(key, data, ttl_seconds=interval_ttl(interval))\n",
-        "                return data[-limit:], source\n",
-        "        except Exception as ex: errors.append(f'{source}: {ex}')\n",
-        "    raise HTTPException(status_code=502, detail={'message': 'All sources failed', 'errors': errors})\n"
-    ]
-
-# Indicators part (Vectorized)
-def get_vectorized_indicators():
-    return [
-        "def _ema(arr: np.ndarray, period: int) -> np.ndarray:\n",
-        "    if len(arr) == 0: return np.array([], dtype=float)\n",
-        "    return pd.Series(arr).ewm(alpha=2.0/(period+1), adjust=False).mean().values\n",
-        "\n",
-        "def _rsi(close: np.ndarray, period: int = 14) -> np.ndarray:\n",
-        "    delta = np.diff(close)\n",
-        "    gain = np.where(delta > 0, delta, 0.0)\n",
-        "    loss = np.where(delta < 0, -delta, 0.0)\n",
-        "    avg_gain = pd.Series(gain).ewm(alpha=1.0/period, adjust=False).mean()\n",
-        "    avg_loss = pd.Series(loss).ewm(alpha=1.0/period, adjust=False).mean()\n",
-        "    rs = avg_gain / avg_loss.replace(0, np.inf)\n",
-        "    rsi = 100 - (100 / (1 + rs))\n",
-        "    return np.concatenate([[np.nan], rsi.values])\n",
-        "\n",
-        "def _bollinger(close: np.ndarray, period=20, k=2.0):\n",
-        "    s = pd.Series(close)\n",
-        "    mid = s.rolling(window=period).mean()\n",
-        "    std = s.rolling(window=period).std()\n",
-        "    return (mid + k*std).values, mid.values, (mid - k*std).values\n",
-        "\n",
-        "def _macd(close, fast=12, slow=26, signal=9):\n",
-        "    f, s = _ema(close, fast), _ema(close, slow)\n",
-        "    line = f - s\n",
-        "    sig = _ema(np.where(np.isnan(line), 0, line), signal)\n",
-        "    return line, sig, line - sig\n",
-        "\n",
-        "def _atr(high, low, close, period=14):\n",
-        "    tr = np.maximum(high[1:]-low[1:], np.maximum(np.abs(high[1:]-close[:-1]), np.abs(low[1:]-close[:-1])))\n",
-        "    tr = np.concatenate([[np.nan], tr])\n",
-        "    return pd.Series(tr).ewm(alpha=1.0/period, adjust=False).mean().values\n",
-        "\n",
-        "def _stoch_rsi(close, rsi_p=14, stoch_p=14, k_p=3, d_p=3):\n",
-        "    rsi = pd.Series(_rsi(close, rsi_p))\n",
-        "    mn, mx = rsi.rolling(stoch_p).min(), rsi.rolling(stoch_p).max()\n",
-        "    k = 100 * (rsi - mn) / (mx - mn).replace(0, np.inf)\n",
-        "    ks = k.rolling(k_p).mean()\n",
-        "    return ks.values, ks.rolling(d_p).mean().values\n",
-        "\n",
-        "def _sma(arr, p): return pd.Series(arr).rolling(p).mean().values if len(arr) else arr\n",
-        "\n",
-        "def _cci(h, l, c, p=20):\n",
-        "    tp = (h+l+c)/3.0; s = pd.Series(tp)\n",
-        "    sma = s.rolling(p).mean()\n",
-        "    mad = s.rolling(p).apply(lambda x: np.abs(x-x.mean()).mean(), raw=False)\n",
-        "    return (s - sma) / (0.015 * mad.replace(0, np.inf))\n",
-        "\n",
-        "def _adx(h, l, c, p=14):\n",
-        "    up = h[1:]-h[:-1]; dn = l[:-1]-l[1:]\n",
-        "    p_dm = np.concatenate([[0], np.where((up>dn)&(up>0), up, 0)])\n",
-        "    m_dm = np.concatenate([[0], np.where((dn>up)&(dn>0), dn, 0)])\n",
-        "    tr = _atr(h, l, c, p) # simplified TR for vectorization\n",
-        "    tr_s = pd.Series(tr).rolling(p).sum().replace(0, np.inf)\n",
-        "    p_di = 100 * pd.Series(p_dm).rolling(p).sum() / tr_s\n",
-        "    m_di = 100 * pd.Series(m_dm).rolling(p).sum() / tr_s\n",
-        "    dx = 100 * np.abs(p_di - m_di) / (p_di + m_di).replace(0, np.inf)\n",
-        "    return dx.rolling(p).mean().values, p_di.values, m_di.values\n",
-        "\n",
-        "def _awesome_oscillator(h, l): return _sma((h+l)/2, 5) - _sma((h+l)/2, 34)\n",
-        "def _momentum(c, p): return np.concatenate([np.full(p, np.nan), c[p:] - c[:-p]])\n",
-        "def _williams_r(h, l, c, p=14):\n",
-        "    hh, ll = pd.Series(h).rolling(p).max(), pd.Series(l).rolling(p).min()\n",
-        "    return -100 * (hh - c) / (hh - ll).replace(0, np.inf)\n",
-        "def _bull_bear_power(h, l, c, p=13): ema = _ema(c, p); return (h - ema) + (l - ema)\n",
-        "def _ultimate_oscillator(h, l, c, p1=7, p2=14, p3=28):\n",
-        "    cp = pd.Series(c).shift(1); tr = np.maximum(h, cp) - np.minimum(l, cp); bp = pd.Series(c) - np.minimum(l, cp)\n",
-        "    a1, a2, a3 = bp.rolling(p1).sum()/tr.rolling(p1).sum().replace(0,np.inf), bp.rolling(p2).sum()/tr.rolling(p2).sum().replace(0,np.inf), bp.rolling(p3).sum()/tr.rolling(p3).sum().replace(0,np.inf)\n",
-        "    return 100 * (4*a1 + 2*a2 + a3) / 7.0\n",
-        "def _vwma(c, v, p=20): return (pd.Series(c*v).rolling(p).sum() / pd.Series(v).rolling(p).sum().replace(0, np.inf)).values\n",
-        "def _hull_ma(c, p=9):\n",
-        "    h, s = max(p//2, 1), int(p**0.5)\n",
-        "    d = 2*_sma(c, h) - _sma(c, p)\n",
-        "    return _sma(np.where(np.isnan(d), c, d), s)\n"
-    ]
-
-# Add analytical engine back
-# (Omitted here for brevity in script creation, will insert in actual write)
-
-# ... Reconstruct and write ...
-print("Recovery logic ready (truncated here for brevity)")

backend/sign_agreement.py

@@ -1,43 +0,0 @@
-import httpx
-import asyncio
-import os
-import time
-import hmac
-import hashlib
-import json
-from dotenv import load_dotenv
-
-load_dotenv()
-
-async def sign_tradfi_agreement():
-    api_key = os.getenv("BYBIT_API_KEY")
-    api_secret = os.getenv("BYBIT_API_SECRET")
-    
-    url = "https://api.bybit.com/v5/user/sign-agreement"
-    
-    timestamp = str(int(time.time() * 1000))
-    recv_window = "5000"
-    payload = json.dumps({"agreementId": "1"})
-    
-    raw_str = timestamp + api_key + recv_window + payload
-    signature = hmac.new(api_secret.encode('utf-8'), 
-                        raw_str.encode('utf-8'), hashlib.sha256).hexdigest()
-    
-    headers = {
-        'X-BAPI-API-KEY': api_key,
-        'X-BAPI-TIMESTAMP': timestamp,
-        'X-BAPI-SIGN-TYPE': '2',
-        'X-BAPI-RECV-WINDOW': recv_window,
-        'X-BAPI-SIGN': signature,
-        'Content-Type': 'application/json'
-    }
-
-    async with httpx.AsyncClient() as client:
-        resp = await client.post(url, data=payload, headers=headers)
-        print(f"Status: {resp.status_code}")
-        print(f"Content: {resp.text}")
-        if resp.text:
-            print(f"Sign Agreement Result: {resp.json()}")
-
-if __name__ == "__main__":
-    asyncio.run(sign_tradfi_agreement())

backend/test_basecoin.py

@@ -1,30 +0,0 @@
-import httpx
-import asyncio
-import os
-import time
-import hmac
-import hashlib
-from dotenv import load_dotenv
-
-load_dotenv()
-
-async def test_basecoin_usd():
-    api_key = os.getenv("BYBIT_API_KEY")
-    api_secret = os.getenv("BYBIT_API_SECRET")
-    
-    url = "https://api.bybit.com/v5/market/instruments-info"
-    # Try filtering by baseCoin=USD for TradFi
-    params = {"category": "linear", "baseCoin": "USD"}
-    
-    async with httpx.AsyncClient() as client:
-        resp = await client.get(url, params=params)
-        data = resp.json()
-        if data.get("retCode") == 0:
-            symbols = [item["symbol"] for item in data["result"]["list"]]
-            print(f"Found {len(symbols)} symbols with baseCoin=USD")
-            print(f"Sample: {symbols[:10]}")
-        else:
-            print(f"Error: {data}")
-
-if __name__ == "__main__":
-    asyncio.run(test_basecoin_usd())

backend/test_bytick.py

@@ -1,45 +0,0 @@
-import httpx
-import asyncio
-import os
-import time
-import hmac
-import hashlib
-from dotenv import load_dotenv
-
-load_dotenv()
-
-async def test_bytick():
-    api_key = os.getenv("BYBIT_API_KEY")
-    api_secret = os.getenv("BYBIT_API_SECRET")
-    
-    symbol = "XAUUSD+"
-    url = "https://api.bytick.com/v5/market/tickers"
-    
-    async with httpx.AsyncClient() as client:
-        params = {"category": "linear", "symbol": symbol}
-        
-        headers = {}
-        if api_key and api_secret:
-            timestamp = str(int(time.time() * 1000))
-            recv_window = "5000"
-            sorted_params = "&".join([f"{k}={v}" for k, v in sorted(params.items())])
-            raw_str = timestamp + api_key + recv_window + sorted_params
-            signature = hmac.new(api_secret.encode('utf-8'), 
-                                raw_str.encode('utf-8'), hashlib.sha256).hexdigest()
-            
-            headers = {
-                'X-BAPI-API-KEY': api_key,
-                'X-BAPI-TIMESTAMP': timestamp,
-                'X-BAPI-SIGN-TYPE': '2',
-                'X-BAPI-RECV-WINDOW': recv_window,
-                'X-BAPI-SIGN': signature
-            }
-
-        try:
-            resp = await client.get(url, params=params, headers=headers)
-            print(f"Bytick Result: {resp.json()}")
-        except Exception as e:
-            print(f"Error: {e}")
-
-if __name__ == "__main__":
-    asyncio.run(test_bytick())

backend/test_cat.py

@@ -1,49 +0,0 @@
-import httpx
-import asyncio
-import os
-import time
-import hmac
-import hashlib
-from dotenv import load_dotenv
-
-load_dotenv()
-
-async def test_tradfi_category():
-    api_key = os.getenv("BYBIT_API_KEY")
-    api_secret = os.getenv("BYBIT_API_SECRET")
-    
-    # Try different categories
-    test_categories = ["tradfi", "mt5", "cfd", "linear"]
-    symbol = "XAUUSD+"
-    url = "https://api.bybit.com/v5/market/tickers"
-    
-    async with httpx.AsyncClient() as client:
-        for cat in test_categories:
-            params = {"category": cat, "symbol": symbol}
-            
-            headers = {}
-            if api_key and api_secret:
-                timestamp = str(int(time.time() * 1000))
-                recv_window = "5000"
-                sorted_params = "&".join([f"{k}={v}" for k, v in sorted(params.items())])
-                raw_str = timestamp + api_key + recv_window + sorted_params
-                signature = hmac.new(api_secret.encode('utf-8'), 
-                                    raw_str.encode('utf-8'), hashlib.sha256).hexdigest()
-                
-                headers = {
-                    'X-BAPI-API-KEY': api_key,
-                    'X-BAPI-TIMESTAMP': timestamp,
-                    'X-BAPI-SIGN-TYPE': '2',
-                    'X-BAPI-RECV-WINDOW': recv_window,
-                    'X-BAPI-SIGN': signature
-                }
-
-            try:
-                resp = await client.get(url, params=params, headers=headers)
-                data = resp.json()
-                print(f"Category: {cat} -> {data.get('retMsg')} ({data.get('retCode')})")
-            except Exception as e:
-                print(f"Error for {cat}: {e}")
-
-if __name__ == "__main__":
-    asyncio.run(test_tradfi_category())

backend/test_indices.py

@@ -1,43 +0,0 @@
-import httpx
-import asyncio
-import os
-import time
-import hmac
-import hashlib
-from dotenv import load_dotenv
-
-load_dotenv()
-
-async def test_indices():
-    api_key = os.getenv("BYBIT_API_KEY")
-    api_secret = os.getenv("BYBIT_API_SECRET")
-    
-    symbols = ["US30+", "SPX500+", "NAS100+", "DXY+", "AAPL+", "TSLA+"]
-    url = "https://api.bybit.com/v5/market/tickers"
-    
-    async with httpx.AsyncClient() as client:
-        for symbol in symbols:
-            params = {"category": "linear", "symbol": symbol}
-            
-            headers = {}
-            if api_key and api_secret:
-                timestamp = str(int(time.time() * 1000))
-                recv_window = "5000"
-                sorted_params = "&".join([f"{k}={v}" for k, v in sorted(params.items())])
-                raw_str = timestamp + api_key + recv_window + sorted_params
-                signature = hmac.new(api_secret.encode('utf-8'), 
-                                    raw_str.encode('utf-8'), hashlib.sha256).hexdigest()
-                
-                headers = {
-                    'X-BAPI-API-KEY': api_key,
-                    'X-BAPI-TIMESTAMP': timestamp,
-                    'X-BAPI-SIGN-TYPE': '2',
-                    'X-BAPI-RECV-WINDOW': recv_window,
-                    'X-BAPI-SIGN': signature
-                }
-
-            resp = await client.get(url, params=params, headers=headers)
-            print(f"Symbol: {symbol} -> {resp.json().get('retMsg')} ({resp.json().get('retCode')})")
-
-if __name__ == "__main__":
-    asyncio.run(test_indices())

backend/test_no_auth.py

@@ -1,15 +0,0 @@
-import httpx
-import asyncio
-
-async def test_no_auth():
-    url = "https://api.bybit.com/v5/market/kline"
-    symbols = ["XAUUSD+", "XAUUSD.s", "XAUUSD", "EURUSD+", "EURUSD.s", "EURUSD"]
-    
-    async with httpx.AsyncClient() as client:
-        for symbol in symbols:
-            params = {"category": "linear", "symbol": symbol, "interval": "60", "limit": "1"}
-            resp = await client.get(url, params=params)
-            print(f"Symbol: {symbol} -> {resp.json().get('retMsg')} ({resp.json().get('retCode')})")
-
-if __name__ == "__main__":
-    asyncio.run(test_no_auth())

backend/test_s.py

@@ -1,43 +0,0 @@
-import httpx
-import asyncio
-import os
-import time
-import hmac
-import hashlib
-from dotenv import load_dotenv
-
-load_dotenv()
-
-async def test_s_suffix():
-    api_key = os.getenv("BYBIT_API_KEY")
-    api_secret = os.getenv("BYBIT_API_SECRET")
-    
-    test_symbols = ["XAUUSD.s", "EURUSD.s", "SPX500.s"]
-    url = "https://api.bybit.com/v5/market/tickers"
-    
-    async with httpx.AsyncClient() as client:
-        for symbol in test_symbols:
-            params = {"category": "linear", "symbol": symbol}
-            
-            headers = {}
-            if api_key and api_secret:
-                timestamp = str(int(time.time() * 1000))
-                recv_window = "5000"
-                sorted_params = "&".join([f"{k}={v}" for k, v in sorted(params.items())])
-                raw_str = timestamp + api_key + recv_window + sorted_params
-                signature = hmac.new(api_secret.encode('utf-8'), 
-                                    raw_str.encode('utf-8'), hashlib.sha256).hexdigest()
-                
-                headers = {
-                    'X-BAPI-API-KEY': api_key,
-                    'X-BAPI-TIMESTAMP': timestamp,
-                    'X-BAPI-SIGN-TYPE': '2',
-                    'X-BAPI-RECV-WINDOW': recv_window,
-                    'X-BAPI-SIGN': signature
-                }
-
-            resp = await client.get(url, params=params, headers=headers)
-            print(f"Symbol: {symbol} -> {resp.json()}")
-
-if __name__ == "__main__":
-    asyncio.run(test_s_suffix())

backend/verify_bybit.py

@@ -1,31 +0,0 @@
-import sys
-import os
-
-# Mock the imports or setup path to import main
-sys.path.append(os.path.dirname(os.path.abspath(__file__)))
-from main import SYMBOLS, CATEGORY_SOURCE_PRIORITY, _get_source_priority
-
-def verify_bybit_priority():
-    test_symbols = ["EURUSD", "XAUUSD", "WTI", "CORN", "SP500", "BTCUSD"]
-    print("Verifying Bybit Priority for key symbols:")
-    print("-" * 50)
-    
-    all_ok = True
-    for sym in test_symbols:
-        priority = _get_source_priority(sym)
-        first_source = priority[0] if priority else "NONE"
-        bybit_mapped = "bybit" in SYMBOLS[sym].mappings
-        
-        status = "OK" if first_source == "bybit" and bybit_mapped else "FAIL"
-        if status == "FAIL": all_ok = False
-        
-        print(f"Symbol: {sym:10} | Priority: {str(priority):30} | Bybit Mapped: {str(bybit_mapped):5} | Status: {status}")
-        
-    print("-" * 50)
-    if all_ok:
-        print("Verification SUCCESS: Bybit is prioritized correctly.")
-    else:
-        print("Verification FAILED: Some symbols do not prioritize Bybit.")
-
-if __name__ == "__main__":
-    verify_bybit_priority()

backend/verify_new_key.py

@@ -1,43 +0,0 @@
-import httpx
-import asyncio
-import os
-import time
-import hmac
-import hashlib
-from dotenv import load_dotenv
-
-load_dotenv()
-
-async def verify_new_key():
-    api_key = os.getenv("BYBIT_API_KEY")
-    api_secret = os.getenv("BYBIT_API_SECRET")
-    
-    test_symbols = ["XAUUSD+", "EURUSD+", "SPX500+", "BTCUSDT"]
-    url = "https://api.bybit.com/v5/market/tickers"
-    
-    async with httpx.AsyncClient() as client:
-        for symbol in test_symbols:
-            params = {"category": "linear", "symbol": symbol}
-            
-            headers = {}
-            if api_key and api_secret:
-                timestamp = str(int(time.time() * 1000))
-                recv_window = "5000"
-                sorted_params = "&".join([f"{k}={v}" for k, v in sorted(params.items())])
-                raw_str = timestamp + api_key + recv_window + sorted_params
-                signature = hmac.new(api_secret.encode('utf-8'), 
-                                    raw_str.encode('utf-8'), hashlib.sha256).hexdigest()
-                
-                headers = {
-                    'X-BAPI-API-KEY': api_key,
-                    'X-BAPI-TIMESTAMP': timestamp,
-                    'X-BAPI-SIGN-TYPE': '2',
-                    'X-BAPI-RECV-WINDOW': recv_window,
-                    'X-BAPI-SIGN': signature
-                }
-
-            resp = await client.get(url, params=params, headers=headers)
-            print(f"Symbol: {symbol} -> {resp.json()}")
-
-if __name__ == "__main__":
-    asyncio.run(verify_new_key())

frontend/index.html

@@ -1,4 +1,4 @@
-<!doctype html>
+<!doctype html>
 <html lang="vi">
 
 <head>
@@ -100,8 +100,8 @@
       --logo-primary: #0ea5e9;
       --logo-secondary: #8b5cf6;
       --logo-glow: rgba(14, 165, 233, 0.3);
-      --light-bg-image: url("Light_BG.png?v=3");
-      --dark-bg-image: url("Dark_BG.png?v=3");
+      --light-bg-image: url("Light_BG.png?v=1");
+      --dark-bg-image: url("Dark_BG.png?v=1");
     }
 
     body.dark-theme {
@@ -184,8 +184,8 @@
       background-size: cover;
       background-position: center;
       background-repeat: no-repeat;
-      opacity: 0.01;
-      /* 1% opacity for the image as requested */
+      opacity: 1;
+      /* Main background set to full visibility as requested */
       transition: background 0.3s ease, opacity 0.3s ease;
     }
 
@@ -194,7 +194,7 @@
       background-size: cover;
       background-position: center;
       background-repeat: no-repeat;
-      opacity: 0.01;
+      opacity: 1;
     }
 
     body {
@@ -350,7 +350,7 @@
     /* Search Omnibox (Shrunk 50% horizontally from original 320px) */
     .omnibox {
       position: relative;
-      width: 160px;
+      width: 80px;
     }
 
     .omnibox input {
@@ -816,8 +816,9 @@
 
     .gauge-hero-svg-wrap {
       position: relative;
-      width: 320px;
-      height: 220px;
+      width: 100%;
+      max-width: 320px;
+      aspect-ratio: 320 / 220;
       display: flex;
       align-items: center;
       justify-content: center;
@@ -886,6 +887,8 @@
       letter-spacing: 0.15em;
       text-shadow: 0 0 20px rgba(0, 0, 0, 0.5);
       margin-top: 5px;
+      background: none !important;
+      padding: 0 !important;
     }
 
     .gauge-hero-signal.strong-buy {
@@ -1588,6 +1591,8 @@
       font-weight: 800;
       text-transform: uppercase;
       letter-spacing: 0.02em;
+      background: none !important;
+      padding: 0 !important;
     }
 
     .compact-gauge-card.hero {
@@ -2088,7 +2093,7 @@
     }
 
     .omnibox {
-      width: 250px;
+      width: 125px;
     }
 
     .omnibox input,
@@ -3196,7 +3201,8 @@
         const prev = points[i - 1];
         const curr = points[i];
         const diff = (curr?.value ?? 0) - (prev?.value ?? 0);
-        const color = diff > EPSILON ? '#45a9ff' : diff < -EPSILON ? '#ff6b7a' : '#f6c94a';
+        // Tăng: xanh lá, Giảm: đỏ, Đi ngang: vàng nhạt
+        const color = diff > EPSILON ? '#10b981' : diff < -EPSILON ? '#f43f5e' : '#fef08a';
         const segSeries = chart.addLineSeries({
           color,
           lineWidth: 2,
@@ -3458,8 +3464,9 @@
           </div>
         </div>
 
-        <!-- Dashboard Body -->
-        <div class="dash-body">
+        <!-- Dashboard Body Scaler -->
+        <div class="dash-body-scaler" style="flex:1; overflow-y:auto; overflow-x:hidden; display:flex; flex-direction:column;">
+          <div class="dash-body" style="transform-origin: top center; transition: transform 0.2s ease;">
 
           <!-- TOP ROW: 3 Big Gauges -->
           <div class="dash-gauges-hero">
@@ -3554,9 +3561,10 @@
 
           <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> <!-- End summary-disclaimer -->
 
-        </div>
+        </div> <!-- End dash-body -->
+      </div> <!-- End dash-body-scaler -->
       `;
 
       // Close logic
@@ -3742,6 +3750,7 @@
         if (currentSymbol !== symbol) return; // Discard if user switched
 
         renderAnalysisPanel(symbol, interval, fData);
+        setTimeout(updateDashboardScale, 10);
         renderCompactGauges(symbol, interval, fData);
 
         let isBull = false;
@@ -3912,6 +3921,7 @@
         if (lastAnalysisPayload && lastAnalysisSymbol === currentSymbol) {
           renderAnalysisPanel(lastAnalysisSymbol, lastAnalysisInterval, lastAnalysisPayload);
           analysisPanel.classList.add('active');
+          setTimeout(updateDashboardScale, 10);
         } else {
           // No cached data: fetch from API without reloading chart
           analysisPanel.classList.add('active');
@@ -3922,6 +3932,7 @@
             </div>
           `;
           fetchAIAnalysis(currentSymbol, timeframeSelect.value);
+          setTimeout(updateDashboardScale, 10);
         }
       } else {
         // Hide dashboard
@@ -3949,14 +3960,44 @@
       }
     });
 
+    /* ── Dashboard Auto-Scale ────────────────── */
+    function updateDashboardScale() {
+      const panel = document.getElementById('analysisPanel');
+      if (!panel || !panel.classList.contains('active')) return;
+      const body = panel.querySelector('.dash-body');
+      const scaler = panel.querySelector('.dash-body-scaler');
+      if (!body || !scaler) return;
+
+      const windowWidth = window.innerWidth;
+      const windowHeight = window.innerHeight;
+      
+      // Target width for 1:1 scale (Full HD standard)
+      const targetWidth = 1400; 
+      const targetHeight = 850;
+
+      let scaleW = windowWidth / targetWidth;
+      let scaleH = (windowHeight - 80) / targetHeight; // 80px for header
+      let scale = Math.min(scaleW, scaleH);
+
+      // Clamp scale
+      if (scale > 1.1) scale = 1.1;
+      if (scale < 0.45) scale = 0.45;
+
+      body.style.transform = `scale(${scale})`;
+      body.style.width = `${100 / scale}%`;
+      // body.style.height = `${100 / scale}%`;
+    }
+
     /* ── Resize handler ────────────────────────── */
     const ro = new ResizeObserver(() => {
       chart.applyOptions({
         width: chartEl.clientWidth,
         height: chartEl.clientHeight,
       });
+      updateDashboardScale();
     });
     ro.observe(chartEl);
+    window.addEventListener('resize', updateDashboardScale);
 
     /* ── Theme Management ── */
     function applyTheme(theme) {
@@ -4023,4 +4064,4 @@
   </script>
 </body>
 
-</html>
+</html>

update_symbols.py

@@ -1,84 +0,0 @@
-import re
-import sys
-
-def main():
-    with open('backend/main.py', 'r', encoding='utf-8') as f:
-        content = f.read()
-
-    # Update priorities
-    content = content.replace(
-        '"Cổ phiếu Mỹ":          ["yfinance", "finnhub", "twelvedata"],',
-        '"Cổ phiếu Mỹ":          ["bybit", "yfinance", "finnhub", "twelvedata"],'
-    )
-    content = content.replace(
-        '"Trái phiếu":           ["yfinance"],',
-        '"Trái phiếu":           ["bybit", "yfinance"],'
-    )
-    content = content.replace(
-        '"ETF":                  ["yfinance", "finnhub"],',
-        '"ETF":                  ["bybit", "yfinance", "finnhub"],'
-    )
-    content = content.replace(
-        'DEFAULT_SOURCE_PRIORITY: List[str] = ["yfinance", "twelvedata", "finnhub", "binance"]',
-        'DEFAULT_SOURCE_PRIORITY: List[str] = ["bybit", "yfinance", "twelvedata", "finnhub", "binance"]'
-    )
-
-    # We will do regex replacements for specific symbols
-    replacements = {
-        r'"DXY":\s*_s\("DXY",[^\{]+\{([^}]+)\}': lambda m: m.group(0).replace('"bybit":"DXY"', '"bybit":"DXY+"'),
-        r'"VIX":\s*_s\("VIX",[^\{]+\{([^}]+)\}': lambda m: m.group(0).replace(m.group(1), '"bybit":"VIX+", ' + m.group(1)) if '"bybit"' not in m.group(1) else m.group(0),
-        r'"US10Y":\s*_s\("US10Y",[^\{]+\{([^}]+)\}': lambda m: m.group(0).replace(m.group(1), '"bybit":"US10Y+", ' + m.group(1)) if '"bybit"' not in m.group(1) else m.group(0),
-        
-        # Indices
-        r'"DOW30":\s*_s\("DOW30",[^\{]+\{([^}]+)\}': lambda m: m.group(0).replace('"bybit":"DJ30"', '"bybit":"US30"'),
-        r'"NIKKEI225":\s*_s\("NIKKEI225",[^\{]+\{([^}]+)\}': lambda m: m.group(0).replace('"bybit":"Nikkei225"', '"bybit":"JPN225"'),
-        r'"EU50":\s*_s\("EU50",[^\{]+\{([^}]+)\}': lambda m: m.group(0).replace(m.group(1), '"bybit":"EU50", ' + m.group(1)) if '"bybit"' not in m.group(1) else m.group(0),
-        r'"ASX200":\s*_s\("ASX200",[^\{]+\{([^}]+)\}': lambda m: m.group(0).replace(m.group(1), '"bybit":"AUS200", ' + m.group(1)) if '"bybit"' not in m.group(1) else m.group(0),
-
-        # Energy & Metals & Agri
-        r'"NATURAL_GAS":\s*_s\("NATURAL_GAS",[^\{]+\{([^}]+)\}': lambda m: m.group(0).replace('"bybit":"NG"', '"bybit":"NGAS"'),
-        r'"COPPER":\s*_s\("COPPER",[^\{]+\{([^}]+)\}': lambda m: m.group(0).replace('"bybit":"Copper"', '"bybit":"COPPER"'),
-        r'"WHEAT":\s*_s\("WHEAT",[^\{]+\{([^}]+)\}': lambda m: m.group(0).replace('"bybit":"Wheat"', '"bybit":"WHEAT"'),
-        r'"CORN":\s*_s\("CORN",[^\{]+\{([^}]+)\}': lambda m: m.group(0).replace('"bybit":"Corn"', '"bybit":"CORN"'),
-        r'"SOYBEAN":\s*_s\("SOYBEAN",[^\{]+\{([^}]+)\}': lambda m: m.group(0).replace('"bybit":"Soybean"', '"bybit":"SOYBEAN"'),
-        r'"SUGAR_11":\s*_s\("SUGAR_11",[^\{]+\{([^}]+)\}': lambda m: m.group(0).replace('"bybit":"Sugar"', '"bybit":"SUGAR"'),
-        r'"COFFEE_ARABICA":\s*_s\("COFFEE_ARABICA",[^\{]+\{([^}]+)\}': lambda m: m.group(0).replace('"bybit":"Coffee"', '"bybit":"COFFEE"'),
-        r'"COCOA":\s*_s\("COCOA",[^\{]+\{([^}]+)\}': lambda m: m.group(0).replace('"bybit":"Cocoa"', '"bybit":"COCOA"'),
-        r'"COTTON":\s*_s\("COTTON",[^\{]+\{([^}]+)\}': lambda m: m.group(0).replace('"bybit":"Cotton"', '"bybit":"COTTON"'),
-    }
-
-    for pat, rep in replacements.items():
-        content = re.sub(pat, rep, content, count=1)
-
-    # Stocks & ETF (add bybit to existing ones)
-    stocks_to_update = ["AAPL", "MSFT", "NVDA", "GOOGL", "AMZN", "META", "TSLA", "JPM", "V", "MA", "WMT", "AMD", "INTC", "NFLX", "DIS"]
-    for stock in stocks_to_update:
-        pat = r'"XYZ":\s*_s\("XYZ",[^{]+\{([^}]+)\}'.replace('XYZ', stock)
-        def repl(m, s=stock):
-            if '"bybit"' not in m.group(1):
-                return m.group(0).replace(m.group(1), f'"bybit":"{s}", ' + m.group(1))
-            return m.group(0)
-        content = re.sub(pat, repl, content, count=1)
-
-    # Insert missing stocks and QQQ ETF
-    missing_symbols = """
-    "JNJ":   _s("JNJ","Johnson & Johnson","JNJ","Cổ phiếu Mỹ",{"bybit":"JNJ","yfinance":"JNJ"}),
-    "PG":    _s("PG","Procter & Gamble","P&G","Cổ phiếu Mỹ",{"bybit":"PG","yfinance":"PG"}),
-    "KO":    _s("KO","Coca-Cola","Coca-Cola","Cổ phiếu Mỹ",{"bybit":"KO","yfinance":"KO"}),
-    "MCD":   _s("MCD","McDonald's","McDonald's","Cổ phiếu Mỹ",{"bybit":"MCD","yfinance":"MCD"}),
-    "BA":    _s("BA","Boeing","Boeing","Cổ phiếu Mỹ",{"bybit":"BA","yfinance":"BA"}),
-    "BABA":  _s("BABA","Alibaba","Alibaba","Cổ phiếu Mỹ",{"bybit":"BABA","yfinance":"BABA"}),
-    "QQQ":   _s("QQQ","Invesco QQQ Trust","QQQ","ETF",{"bybit":"QQQ+","yfinance":"QQQ"}),
-"""
-    # Insert right before Cổ phiếu Việt Nam
-    if '"JNJ"' not in content:
-        content = content.replace(
-            '    # ══════════════════════════════════════════════════════════════════════\n    # 9. CỔ PHIẾU VIỆT NAM',
-            missing_symbols + '\n    # ══════════════════════════════════════════════════════════════════════\n    # 9. CỔ PHIẾU VIỆT NAM'
-        )
-
-    with open('backend/main.py', 'w', encoding='utf-8') as f:
-        f.write(content)
-
-if __name__ == '__main__':
-    main()