Update app.py

app.py

@@ -1,11 +1,11 @@
 # ============================================
-# 👑 TOMIRIS SPACE 19 v11.0 «СТАЛЬ» — SOL/USD MASTER
+# 👑 TOMIRIS SPACE 19 v12.0 «СТАЛЬ» — SOL/USD MASTER (УСИЛЕННЫЙ)
 # ============================================
-import os, time, threading, warnings, json, asyncio, sqlite3
+import os, time, threading, warnings, json, asyncio, sqlite3, glob
 from typing import Dict, Any, Optional, List, Tuple
 import numpy as np, pandas as pd
-import requests
-from datetime import datetime, timedelta
+import httpx
+from datetime import datetime, timezone
 from collections import deque
 from fastapi import FastAPI, Query
 import logging
@@ -31,20 +31,43 @@ TIMEFRAMES = ["15min", "1h", "4h"]
 HUB_URL = os.getenv("HUB_URL", "https://pro-3-tomiris-hub.hf.space")
 HUB_SECRET = os.getenv("HUB_SECRET", "TomyrisUltraSecret2026!")
 
-STARTUP_SLEEP = int(os.getenv("STARTUP_SLEEP", "600"))
-AUTO_REPORT_INTERVAL = 600
+STARTUP_SLEEP = int(os.getenv("STARTUP_SLEEP", "120"))
+AUTO_REPORT_INTERVAL = int(os.getenv("AUTO_REPORT_INTERVAL", "300"))
 SOL_THRESHOLD = 0.52
 
-CACHE_TTL = 600
+CACHE_TTL = 300
 DATA_CACHE: Dict[str, Dict[str, Any]] = {}
 LAST_CONFIDENCE = 0.5
 
-logger.info(f"🔗 Хаб: {HUB_URL}")
+logger.info(f"🔗 Хаб: {HUB_URL} | Старт: {STARTUP_SLEEP}с | Интервал: {AUTO_REPORT_INTERVAL}с")
+
+# ================= HTTP КЛИЕНТ =================
+http_client = httpx.AsyncClient(timeout=15.0)
 
 def hub_headers():
     return {"X-Hub-Secret": HUB_SECRET, "Content-Type": "application/json"}
 
-# ================= SQLite ДЛЯ СТАТИСТИКИ =================
+async def log_to_hub(event_type: str, message: str, details: dict = None):
+    try:
+        await http_client.post(
+            f"{HUB_URL}/log",
+            json={"space_id": str(SPACE_ID), "event_type": event_type, "message": message, "details": details or {}},
+            headers=hub_headers(), timeout=5
+        )
+    except: pass
+
+# ================= ИСТОРИЯ ДЛЯ Z-SCORE =================
+CONF_HISTORY = deque(maxlen=200)
+SCORE_HISTORY = deque(maxlen=200)
+
+def calculate_zscore(current: float, history: deque) -> float:
+    if len(history) < 10: return 0.0
+    arr = np.array(list(history))
+    mean, std = arr.mean(), arr.std()
+    if std == 0: return 0.0
+    return (current - mean) / std
+
+# ================= SQLite =================
 DB_FILE = "sol_master.db"
 
 def init_db():
@@ -62,9 +85,10 @@ def init_db():
         signal TEXT NOT NULL,
         confidence REAL,
         regime TEXT,
-        models_used INTEGER
+        models_used INTEGER,
+        adx REAL,
+        score REAL
     )''')
-    # Инициализируем дефолтные значения если таблица пуста
     for comp in ["model", "tf", "onchain", "derivatives"]:
         c.execute("INSERT OR IGNORE INTO component_perf (component, correct, total, sharpe) VALUES (?, 0, 1, 1.0)", (comp,))
     conn.commit()
@@ -83,8 +107,6 @@ def load_component_perf():
             perf[row[0]] = {"correct": row[1], "total": row[2], "sharpe": row[3]}
         conn.close()
     except: pass
-    
-    # Гарантируем что все компоненты есть
     for comp in ["model", "tf", "onchain", "derivatives"]:
         if comp not in perf:
             perf[comp] = {"correct": 0, "total": 1, "sharpe": 1.0}
@@ -104,31 +126,46 @@ def save_component_perf(perf: Dict):
 COMPONENT_PERF = load_component_perf()
 
 REGIME_WEIGHTS = {
-    "TREND":     {"model": 0.70, "tf": 0.30},
-    "VOLATILE":  {"model": 0.50, "tf": 0.50},
-    "RANGE":     {"model": 0.60, "tf": 0.40}
+    "TREND":    {"model": 0.65, "tf": 0.35},
+    "VOLATILE": {"model": 0.45, "tf": 0.55},
+    "RANGE":    {"model": 0.55, "tf": 0.45}
 }
 
 # ================= ЗАГРУЗКА МОДЕЛЕЙ =================
-logger.info(f"🔥 Загрузка моделей для {SYMBOL}...")
-MODELS: Dict[str, Optional[Any]] = {"xgb_daily": None, "xgb_4h": None, "lgb": None}
-
-if HAS_JOBLIB:
-    for fname, key in [("xgboost_sol_daily.joblib", "xgb_daily"), 
-                        ("xgboost_sol_4h.joblib", "xgb_4h"),
-                        ("lgb_sol.joblib", "lgb")]:
-        if os.path.exists(fname):
-            try:
-                MODELS[key] = joblib.load(fname)
-                logger.info(f"✅ {fname} загружен")
-            except Exception as e:
-                logger.warning(f"⚠️ {fname}: {e}")
-
-# ================= HTTP СЕССИЯ =================
-session = requests.Session()
-session.headers.update({"User-Agent": "Tomiris-Space19-v11.0"})
-
-# 🔥 ФИКСИРОВАННЫЙ ПОРЯДОК ПРИЗНАКОВ!
+MODELS: Dict[str, Optional[Any]] = {}
+
+def load_all_models():
+    global MODELS
+    MODELS = {}
+    
+    if HAS_JOBLIB:
+        # Стандартные модели
+        for fname, key in [("xgboost_sol_daily.joblib", "xgb_daily"), 
+                            ("xgboost_sol_4h.joblib", "xgb_4h"),
+                            ("lgb_sol.joblib", "lgb")]:
+            if os.path.exists(fname):
+                try:
+                    MODELS[key] = joblib.load(fname)
+                    logger.info(f"✅ {fname} загружен")
+                except Exception as e:
+                    logger.warning(f"⚠️ {fname}: {e}")
+        
+        # Дополнительные .joblib файлы
+        for filepath in glob.glob("*.joblib"):
+            filename = os.path.basename(filepath)
+            if filename not in ["xgboost_sol_daily.joblib", "xgboost_sol_4h.joblib", "lgb_sol.joblib"]:
+                model_name = filename.replace(".joblib", "")
+                if "sol" in model_name.lower():
+                    try:
+                        MODELS[model_name] = joblib.load(filepath)
+                        logger.info(f"✅ Доп. модель: {model_name}")
+                    except: pass
+    
+    logger.info(f"🧠 SOL моделей: {sum(1 for m in MODELS.values() if m is not None)}")
+
+load_all_models()
+
+# ================= ФИКСИРОВАННЫЙ ПОРЯДОК ПРИЗНАКОВ =================
 FEATURE_ORDER = [
     "price", "return_1h", "return_24h", "hurst_exponent",
     "volatility_1h", "high_low_ratio",
@@ -136,7 +173,7 @@ FEATURE_ORDER = [
     "ema_50", "price_vs_ema_50",
     "macd", "macd_signal", "macd_hist",
     "rsi_14", "adx", "atr_14", "atr_pct",
-    "tvl", "tvl_trend", "dex_volume_24h",
+    "tvl", "tvl_change_24h", "dex_volume_24h", "dex_change_24h",
     "funding_rate", "open_interest",
     "funding_bullish", "funding_bearish",
     "is_weekend", "hour"
@@ -166,40 +203,19 @@ def safe_ema(close, span):
     except: return float(close.iloc[-1])
 
 def calculate_adx(df: pd.DataFrame, period: int = 14) -> float:
-    """🔥 НАСТОЯЩИЙ ADX!"""
-    if df is None or len(df) < period * 2:
-        return 20.0
-    
-    high = df["high"].astype(float).values
-    low = df["low"].astype(float).values
-    close = df["close"].astype(float).values
-    
-    dm_plus = np.zeros(len(high))
-    dm_minus = np.zeros(len(high))
-    tr = np.zeros(len(high))
-    
+    if df is None or len(df) < period * 2: return 20.0
+    high = df["high"].astype(float).values; low = df["low"].astype(float).values; close = df["close"].astype(float).values
+    dm_plus = np.zeros(len(high)); dm_minus = np.zeros(len(high)); tr = np.zeros(len(high))
     for i in range(1, len(high)):
-        # True Range
         tr[i] = max(high[i] - low[i], abs(high[i] - close[i-1]), abs(low[i] - close[i-1]))
-        
-        # Directional Movement
-        up_move = high[i] - high[i-1]
-        down_move = low[i-1] - low[i]
-        
-        if up_move > down_move and up_move > 0:
-            dm_plus[i] = up_move
-        if down_move > up_move and down_move > 0:
-            dm_minus[i] = down_move
-    
-    # Сглаживание за 14 периодов
+        up_move = high[i] - high[i-1]; down_move = low[i-1] - low[i]
+        if up_move > down_move and up_move > 0: dm_plus[i] = up_move
+        if down_move > up_move and down_move > 0: dm_minus[i] = down_move
     atr = np.mean(tr[-period:]) if np.mean(tr[-period:]) > 0 else 0.001
     di_plus = 100 * np.mean(dm_plus[-period:]) / atr
     di_minus = 100 * np.mean(dm_minus[-period:]) / atr
-    
     dx_sum = di_plus + di_minus
-    if dx_sum > 0:
-        adx = abs(di_plus - di_minus) / dx_sum * 100
-        return float(adx)
+    if dx_sum > 0: return float(abs(di_plus - di_minus) / dx_sum * 100)
     return 20.0
 
 def hurst_exponent(series, lags=20):
@@ -224,19 +240,17 @@ def detect_market_regime(features):
     if volatility > 0.04: return "VOLATILE"
     return "RANGE"
 
-# ================= ЗАГРУЗКА ДАННЫХ (ТОЛЬКО ХАБ!) =================
-def fetch_ohlc_hub(symbol, tf, limit=200):
+# ================= ЗАГРУЗКА ДАННЫХ =================
+async def fetch_ohlc_hub(symbol, tf, limit=200):
     cache_key = f"hub_{symbol}_{tf}"
     if cache_key in DATA_CACHE and time.time() - DATA_CACHE[cache_key].get("timestamp", 0) < CACHE_TTL:
         return DATA_CACHE[cache_key]["df"]
     
     try:
-        # 🔥 Используем оба параметра для совместимости
-        r = session.get(
+        r = await http_client.get(
             f"{HUB_URL}/candles",
             params={"symbol": symbol, "interval": tf, "timeframe": tf, "limit": limit},
-            timeout=30,
-            headers=hub_headers()
+            timeout=30, headers=hub_headers()
         )
         if r.status_code == 200:
             candles = r.json().get("candles", [])
@@ -254,17 +268,14 @@ def fetch_ohlc_hub(symbol, tf, limit=200):
         logger.warning(f"Hub {symbol} {tf}: {e}")
     return None
 
-def fetch_ohlc(symbol, tf="1h"):
-    return fetch_ohlc_hub(symbol, tf)
-
-def fetch_solana_onchain():
+async def fetch_solana_onchain():
     cache_key = "solana_onchain"
     if cache_key in DATA_CACHE and time.time() - DATA_CACHE[cache_key].get("timestamp", 0) < CACHE_TTL:
         return DATA_CACHE[cache_key]["data"]
     
     result = {"tvl": 0, "tvl_change_24h": 0, "dex_volume_24h": 0, "dex_change_24h": 0}
     try:
-        r = session.get("https://api.llama.fi/tvl/solana", timeout=10)
+        r = await http_client.get("https://api.llama.fi/v2/chains/solana", timeout=10)
         if r.status_code == 200:
             text = r.text.strip()
             if text:
@@ -274,51 +285,55 @@ def fetch_solana_onchain():
                         result['tvl'] = float(data)
                     elif isinstance(data, dict):
                         result['tvl'] = data.get('tvl', 0)
-                        result['tvl_change_24h'] = data.get('change_1d', 0)
+                        result['tvl_change_24h'] = data.get('change_1d', 0) or data.get('change_24h', 0)
                 except: pass
+    
+        # DEX объёмы
+        r2 = await http_client.get("https://api.llama.fi/overview/dexs/solana?excludeTotalDataChart=true", timeout=10)
+        if r2.status_code == 200:
+            dex_data = r2.json()
+            result['dex_volume_24h'] = dex_data.get('total24h', 0)
+            result['dex_change_24h'] = dex_data.get('change_1d', 0) or dex_data.get('dailyChange', 0)
     except: pass
     
     result['tvl_trend'] = 'UP' if result.get('tvl_change_24h', 0) > 0 else 'DOWN'
     DATA_CACHE[cache_key] = {"data": result, "timestamp": time.time()}
     return result
 
-def fetch_binance_sol():
+async def fetch_binance_sol():
     result = {}
     try:
-        r = session.get("https://fapi.binance.com/fapi/v1/premiumIndex", timeout=10)
+        r = await http_client.get("https://fapi.binance.com/fapi/v1/premiumIndex?symbol=SOLUSDT", timeout=10)
         if r.status_code == 200:
-            for item in r.json():
-                if item.get('symbol') == 'SOLUSDT':
-                    result['funding_rate'] = float(item.get('lastFundingRate', 0))
-                    # 🔥 Более умная трактовка funding rate
-                    fr = result['funding_rate']
-                    if fr > 0.005:  # Очень высокий → возможен разворот
-                        result['funding_signal'] = 'CAUTION_LONG'
-                    elif fr > 0.001:  # Высокий → бычий рынок, но осторожно
-                        result['funding_signal'] = 'BULLISH'
-                    elif fr < -0.005:
-                        result['funding_signal'] = 'CAUTION_SHORT'
-                    elif fr < -0.001:
-                        result['funding_signal'] = 'BEARISH'
-                    else:
-                        result['funding_signal'] = 'NEUTRAL'
-                    break
+            data = r.json()
+            if isinstance(data, list):
+                for item in data:
+                    if item.get('symbol') == 'SOLUSDT':
+                        result['funding_rate'] = float(item.get('lastFundingRate', 0))
+                        break
+            elif isinstance(data, dict):
+                result['funding_rate'] = float(data.get('lastFundingRate', 0))
+            
+            fr = result.get('funding_rate', 0)
+            if fr > 0.005: result['funding_signal'] = 'CAUTION_LONG'
+            elif fr > 0.001: result['funding_signal'] = 'BULLISH'
+            elif fr < -0.005: result['funding_signal'] = 'CAUTION_SHORT'
+            elif fr < -0.001: result['funding_signal'] = 'BEARISH'
+            else: result['funding_signal'] = 'NEUTRAL'
     except: pass
+    
     try:
-        r = session.get("https://fapi.binance.com/fapi/v1/openInterest?symbol=SOLUSDT", timeout=10)
+        r = await http_client.get("https://fapi.binance.com/fapi/v1/openInterest?symbol=SOLUSDT", timeout=10)
         if r.status_code == 200:
             result['open_interest'] = float(r.json().get('openInterest', 0))
     except: pass
     return result
 
-# ================= ПОСТРОЕНИЕ ПРИЗНАКОВ (ФИКСИРОВАННЫЙ ПОРЯДОК!) =================
+# ================= ПОСТРОЕНИЕ ПРИЗНАКОВ =================
 def build_sol_features(df, onchain_data=None, derivatives=None) -> Dict:
-    if df is None or len(df) < 20:
-        return {}
+    if df is None or len(df) < 20: return {}
     
-    close = df["close"].astype(float)
-    high = df["high"].astype(float)
-    low = df["low"].astype(float)
+    close = df["close"].astype(float); high = df["high"].astype(float); low = df["low"].astype(float)
     
     features = {}
     features["price"] = safe_float(close.iloc[-1])
@@ -336,19 +351,14 @@ def build_sol_features(df, onchain_data=None, derivatives=None) -> Dict:
         features[f"price_vs_ema_{span}"] = safe_float(((close.iloc[-1] - ema_val) / ema_val) * 100) if ema_val != 0 else 0
     
     if len(close) >= 26:
-        ema12 = close.ewm(span=12, adjust=False).mean()
-        ema26 = close.ewm(span=26, adjust=False).mean()
-        macd = ema12 - ema26
-        signal = macd.ewm(span=9, adjust=False).mean()
-        features["macd"] = safe_float(macd.iloc[-1])
-        features["macd_signal"] = safe_float(signal.iloc[-1])
+        ema12 = close.ewm(span=12, adjust=False).mean(); ema26 = close.ewm(span=26, adjust=False).mean()
+        macd = ema12 - ema26; signal = macd.ewm(span=9, adjust=False).mean()
+        features["macd"] = safe_float(macd.iloc[-1]); features["macd_signal"] = safe_float(signal.iloc[-1])
         features["macd_hist"] = features["macd"] - features["macd_signal"]
     else:
         features["macd"] = features["macd_signal"] = features["macd_hist"] = 0.0
     
     features["rsi_14"] = safe_rsi(close, 14) if len(close) >= 14 else 50.0
-    
-    # 🔥 НАСТОЯЩИЙ ADX!
     features["adx"] = calculate_adx(df, 14)
     
     if len(close) >= 14:
@@ -357,15 +367,15 @@ def build_sol_features(df, onchain_data=None, derivatives=None) -> Dict:
         features["atr_14"] = safe_float(tr.rolling(14, min_periods=14).mean().iloc[-1])
         features["atr_pct"] = (features["atr_14"] / (close.iloc[-1] + 1e-10)) * 100
     else:
-        features["atr_14"] = close.iloc[-1] * 0.03
-        features["atr_pct"] = 3.0
+        features["atr_14"] = close.iloc[-1] * 0.03; features["atr_pct"] = 3.0
     
     if onchain_data:
         features["tvl"] = onchain_data.get("tvl", 0)
-        features["tvl_trend"] = 1 if onchain_data.get("tvl_trend") == "UP" else -1
+        features["tvl_change_24h"] = onchain_data.get("tvl_change_24h", 0)
         features["dex_volume_24h"] = onchain_data.get("dex_volume_24h", 0)
+        features["dex_change_24h"] = onchain_data.get("dex_change_24h", 0)
     else:
-        features["tvl"] = features["tvl_trend"] = features["dex_volume_24h"] = 0
+        features["tvl"] = features["tvl_change_24h"] = features["dex_volume_24h"] = features["dex_change_24h"] = 0
     
     if derivatives:
         features["funding_rate"] = derivatives.get("funding_rate", 0)
@@ -377,11 +387,10 @@ def build_sol_features(df, onchain_data=None, derivatives=None) -> Dict:
         features["funding_rate"] = features["open_interest"] = 0
         features["funding_bullish"] = features["funding_bearish"] = 0
     
-    now = datetime.utcnow()
+    now = datetime.now(timezone.utc)
     features["is_weekend"] = 1 if now.weekday() >= 5 else 0
     features["hour"] = now.hour
     
-    # 🔥 ГАРАНТИРУЕМ ФИКСИРОВАННЫЙ ПОРЯДОК!
     ordered = {}
     for key in FEATURE_ORDER:
         ordered[key] = features.get(key, 0.0)
@@ -389,198 +398,216 @@ def build_sol_features(df, onchain_data=None, derivatives=None) -> Dict:
     return ordered
 
 # ================= ОТПРАВКА СИГНАЛА =================
-def send_signal_to_hub(signal: str, confidence: float, features: Dict = None):
-    if features is None:
-        features = {}
-    
+async def send_signal_to_hub(signal: str, confidence: float, features: Dict = None):
+    if features is None: features = {}
     payload = {
-        "space_id": SPACE_ID,
-        "space_name": SPACE_NAME,
-        "symbol": SYMBOL,
-        "signal": signal,
-        "confidence": round(confidence, 4),
-        "features": features,
-        "metadata": {"version": "11.0"},
-        "timestamp": datetime.now().isoformat()
+        "space_id": SPACE_ID, "space_name": SPACE_NAME,
+        "symbol": SYMBOL, "signal": signal, "confidence": round(confidence, 4),
+        "features": features, "metadata": {"version": "12.0"},
+        "timestamp": datetime.now(timezone.utc).isoformat()
     }
-    
     for attempt in range(3):
         try:
-            headers = hub_headers()
-            r = session.post(f"{HUB_URL}/signals", json=payload, timeout=30, headers=headers)
+            r = await http_client.post(f"{HUB_URL}/signals", json=payload, timeout=15, headers=hub_headers())
             if r.status_code == 200:
                 logger.info(f"📤 {SYMBOL}: {signal} conf={confidence:.3f}")
                 return True
-            elif r.status_code == 429:
-                time.sleep(5 * (attempt + 1))
-            else:
-                time.sleep(3)
-        except:
-            time.sleep(3)
+            await asyncio.sleep(2)
+        except Exception as e:
+            logger.warning(f"Попытка {attempt+1}: {e}")
+            await asyncio.sleep(2)
     return False
 
-# ================= СИГНАЛ =================
-def get_sol_signal():
+# ================= 🔥 СИГНАЛ =================
+async def get_sol_signal():
     global LAST_CONFIDENCE
     start = time.time()
     
-    onchain_data = fetch_solana_onchain()
-    binance_data = fetch_binance_sol()
+    onchain_data = await fetch_solana_onchain()
+    binance_data = await fetch_binance_sol()
     
     all_features = {}
     for tf in TIMEFRAMES:
-        df = fetch_ohlc(SYMBOL, tf)
+        df = await fetch_ohlc_hub(SYMBOL, tf)
         if df is not None and len(df) >= 30:
             feats = build_sol_features(df, onchain_data, binance_data)
             if feats:
                 all_features[tf] = feats
     
     if not all_features:
-        send_signal_to_hub("WAIT", 0.0, {"reason": "no_data"})
+        await send_signal_to_hub("WAIT", 0.0, {"reason": "no_data"})
         return None
     
     h1_features = all_features.get("1h", list(all_features.values())[0])
     price = h1_features.get("price", 0)
-    if price == 0:
-        return None
+    if price == 0: return None
     
     regime = detect_market_regime(h1_features)
+    adx_val = h1_features.get("adx", 20)
     
-    # 🔥 ML предсказание с фиксированным порядком признаков!
+    # 🔥 ML предсказание
     xgb_prob = 0.5
     models_used = 0
+    all_probs = []
+    
     try:
         X = np.array([h1_features.get(f, 0.0) for f in FEATURE_ORDER], dtype=np.float64).reshape(1, -1)
         X = np.nan_to_num(X)
         
-        probs = []
-        for mk in ["xgb_daily", "xgb_4h"]:
-            if MODELS.get(mk):
+        for mk, model in MODELS.items():
+            if model and hasattr(model, 'predict_proba'):
                 try:
-                    proba = MODELS[mk].predict_proba(X)[0]
-                    probs.append(float(proba[1] if len(proba) > 1 else proba[0]))
+                    proba = model.predict_proba(X)[0]
+                    prob = float(proba[1] if len(proba) > 1 else proba[0])
+                    all_probs.append(prob)
                     models_used += 1
                 except: pass
         
-        if MODELS.get("lgb"):
-            try:
-                proba = MODELS["lgb"].predict_proba(X)[0]
-                lgb_prob = float(proba[1] if len(proba) > 1 else proba[0])
-                xgb_prob = (sum(probs)/len(probs) * 0.6 + lgb_prob * 0.4) if probs else lgb_prob
-                models_used += 1
-            except: pass
-        elif probs:
-            xgb_prob = sum(probs) / len(probs)
+        if all_probs:
+            mean_prob = np.mean(all_probs)
+            weighted_probs = [p * (1.0 + abs(p - 0.5)) for p in all_probs]
+            xgb_prob = np.mean(weighted_probs) * 0.6 + mean_prob * 0.4
     except: pass
     
-    # Мульти-ТФ
+    # 🔥 Мульти-ТФ консенсус
     confirmations, total_tf = 0, 0
     for tf, feats in all_features.items():
         total_tf += 1
         ema_score = feats.get("price_vs_ema_21", 0)
         rsi_val = feats.get("rsi_14", 50)
         macd_hist = feats.get("macd_hist", 0)
-        if ema_score > 0 and rsi_val > 50 and macd_hist > 0:
-            confirmations += 1
-        elif ema_score < 0 and rsi_val < 50 and macd_hist < 0:
-            confirmations -= 1
+        if ema_score > 0 and rsi_val > 50 and macd_hist > 0: confirmations += 1
+        elif ema_score < 0 and rsi_val < 50 and macd_hist < 0: confirmations -= 1
+    
     tf_norm = ((confirmations / max(total_tf, 1)) + 1) / 2
     
-    # Meta SOL Score
-    tvl_norm = min(1.0, max(0.0, 0.5 + onchain_data.get("tvl_change_24h", 0) / 20))
-    meta_sol_score = tvl_norm  # Упрощённо
+    # 🔥 On-chain скор
+    tvl_change = onchain_data.get("tvl_change_24h", 0)
+    dex_change = onchain_data.get("dex_change_24h", 0)
+    onchain_score = 0.5 + (tvl_change / 40) + (dex_change / 80)
+    onchain_score = max(0.1, min(0.9, onchain_score))
     
-    deriv_norm = 0.5
+    # 🔥 Деривативы скор
     fs = binance_data.get("funding_signal", "NEUTRAL")
-    if fs == "BULLISH": deriv_norm = 0.7
-    elif fs == "BEARISH": deriv_norm = 0.3
-    elif fs == "CAUTION_LONG": deriv_norm = 0.4
-    elif fs == "CAUTION_SHORT": deriv_norm = 0.6
+    if fs == "BULLISH": deriv_score = 0.70
+    elif fs == "BEARISH": deriv_score = 0.30
+    elif fs == "CAUTION_LONG": deriv_score = 0.45
+    elif fs == "CAUTION_SHORT": deriv_score = 0.55
+    else: deriv_score = 0.50
     
-    # 🔥 ФИКС: Проверка что total > 0 перед делением!
+    # 🔥 Взвешенная агрегация
     base = REGIME_WEIGHTS.get(regime, REGIME_WEIGHTS["RANGE"])
     model_perf = COMPONENT_PERF.get("model", {"correct": 0, "total": 1})
     tf_perf = COMPONENT_PERF.get("tf", {"correct": 0, "total": 1})
     
-    # Если нет статистики — используем базовые веса
-    if model_perf["total"] <= 1:
-        model_w = base["model"]
-        tf_w = base["tf"]
-    else:
-        model_acc = model_perf["correct"] / max(model_perf["total"], 1)
-        tf_acc = tf_perf["correct"] / max(tf_perf["total"], 1)
-        model_w = base["model"] * max(model_acc, 0.3)  # Минимум 30% веса
-        tf_w = base["tf"] * max(tf_acc, 0.3)
+    model_acc = model_perf["correct"] / max(model_perf["total"], 1)
+    tf_acc = tf_perf["correct"] / max(tf_perf["total"], 1)
     
+    model_w = base["model"] * max(model_acc, 0.3)
+    tf_w = base["tf"] * max(tf_acc, 0.3)
     remaining = 1.0 - (model_w + tf_w)
-    onchain_w = remaining * 0.6
-    deriv_w = remaining * 0.4
+    onchain_w = remaining * 0.55
+    deriv_w = remaining * 0.45
     total_w = model_w + tf_w + onchain_w + deriv_w
     if total_w > 0:
         model_w /= total_w; tf_w /= total_w; onchain_w /= total_w; deriv_w /= total_w
     
-    final_score = xgb_prob * model_w + tf_norm * tf_w + meta_sol_score * onchain_w + deriv_norm * deriv_w
+    final_score = xgb_prob * model_w + tf_norm * tf_w + onchain_score * onchain_w + deriv_score * deriv_w
     confidence = smooth_confidence(final_score)
     
-    if confidence > SOL_THRESHOLD + 0.08:
+    # 🔥 Z-score уверенности
+    CONF_HISTORY.append(confidence)
+    conf_z = calculate_zscore(confidence, CONF_HISTORY)
+    SCORE_HISTORY.append(final_score)
+    score_z = calculate_zscore(final_score, SCORE_HISTORY)
+    
+    # 🔥 Адаптивный порог на основе ADX
+    if adx_val > 35:
+        adaptive_threshold = SOL_THRESHOLD - 0.04  # В тренде — ниже порог
+    elif adx_val > 25:
+        adaptive_threshold = SOL_THRESHOLD
+    else:
+        adaptive_threshold = SOL_THRESHOLD + 0.04  # В рендже — выше порог
+    
+    if confidence > adaptive_threshold + 0.08:
         signal = "BUY"
-    elif confidence < SOL_THRESHOLD - 0.08:
+    elif confidence < adaptive_threshold - 0.08:
         signal = "SELL"
     else:
         signal = "WAIT"
     
-    features_out = {"ml_prob": xgb_prob, "tf_norm": tf_norm, "regime": regime, "models_used": models_used}
-    send_signal_to_hub(signal, confidence, features_out)
+    # Усиление от z-score
+    if conf_z > 2.0 and signal == "BUY": confidence = min(0.95, confidence * 1.2)
+    elif conf_z < -2.0 and signal == "SELL": confidence = min(0.95, confidence * 1.2)
+    
+    features_out = {
+        "ml_prob": round(xgb_prob, 4),
+        "tf_norm": round(tf_norm, 4),
+        "onchain_score": round(onchain_score, 4),
+        "deriv_score": round(deriv_score, 4),
+        "regime": regime,
+        "adx": round(adx_val, 1),
+        "models_used": models_used,
+        "conf_zscore": round(conf_z, 2)
+    }
+    
+    await send_signal_to_hub(signal, confidence, features_out)
     
     # Логируем в SQLite
     try:
         conn = sqlite3.connect(DB_FILE)
         c = conn.cursor()
-        c.execute("INSERT INTO signals_log (timestamp, signal, confidence, regime, models_used) VALUES (?, ?, ?, ?, ?)",
-                  (datetime.now().isoformat(), signal, confidence, regime, models_used))
+        c.execute("INSERT INTO signals_log (timestamp, signal, confidence, regime, models_used, adx, score) VALUES (?, ?, ?, ?, ?, ?, ?)",
+                  (datetime.now(timezone.utc).isoformat(), signal, confidence, regime, models_used, round(adx_val, 1), round(final_score, 4)))
         conn.commit()
         conn.close()
     except: pass
     
-    logger.info(f"🥉 SOL/USD: {signal} | conf={confidence:.3f} | models={models_used} | regime={regime} | adx={h1_features.get('adx', 0):.1f}")
-    return {"signal": signal, "confidence": confidence}
+    elapsed = int((time.time() - start) * 1000)
+    logger.info(f"🥉 SOL: {signal} conf={confidence:.3f} score={final_score:.3f} regime={regime} adx={adx_val:.1f} models={models_used} | {elapsed}ms")
+    
+    return {"signal": signal, "confidence": confidence, "score": final_score, "regime": regime}
 
-def auto_report():
+# ================= АВТО-ОТПРАВКА =================
+async def auto_report():
     logger.info(f"⏳ Стартовый сон {STARTUP_SLEEP}с...")
-    time.sleep(STARTUP_SLEEP)
+    await log_to_hub("STARTUP", f"SOL Master v12.0 запущен, жду {STARTUP_SLEEP}с")
+    await asyncio.sleep(STARTUP_SLEEP)
     logger.info("✅ SOL Master — начинаю авто-отправку!")
     while True:
-        time.sleep(AUTO_REPORT_INTERVAL)
+        await asyncio.sleep(AUTO_REPORT_INTERVAL)
         try:
-            get_sol_signal()
+            await get_sol_signal()
         except Exception as e:
             logger.error(f"Ошибка: {e}")
 
-threading.Thread(target=auto_report, daemon=True).start()
+# ================= FASTAPI =================
+app = FastAPI(title="SOL Master v12.0 STEEL")
 
-app = FastAPI(title="SOL Master v11.0 STEEL")
+@app.on_event("startup")
+async def startup():
+    asyncio.create_task(auto_report())
+    logger.info(f"🚀 Space 19 v12.0 | Hub: {HUB_URL} | Models: {sum(1 for m in MODELS.values() if m is not None)}")
 
 @app.get("/health")
 async def health():
-    return {"space_id": SPACE_ID, "status": "ok", "version": "11.0", "symbol": SYMBOL, "models": sum(1 for m in MODELS.values() if m is not None)}
+    return {"space_id": SPACE_ID, "status": "ok", "version": "12.0", "symbol": SYMBOL, "models": sum(1 for m in MODELS.values() if m is not None)}
 
 @app.head("/health")
-async def health_head():
-    return {}
+async def health_head(): return {}
 
 @app.get("/consilium")
 async def consilium():
-    result = get_sol_signal()
-    if result:
-        return {"signal": result["signal"], "confidence": result["confidence"]}
+    result = await get_sol_signal()
+    if result: return {"signal": result["signal"], "confidence": result["confidence"]}
     return {"signal": "WAIT", "confidence": 0.0}
 
 @app.get("/")
 async def root():
-    return {"name": "SOL Master v11.0 STEEL", "space_id": SPACE_ID, "hub": HUB_URL}
+    return {"name": "SOL Master v12.0 STEEL", "space_id": SPACE_ID, "hub": HUB_URL}
 
 if __name__ == "__main__":
     import uvicorn
     uvicorn.run(app, host="0.0.0.0", port=7860)
 
-print("🚀 SPACE 19 v11.0 STEEL — ГОТОВ!")
+print("🚀 SPACE 19 v12.0 STEEL — ГОТОВ!")