Update app.py

app.py

@@ -7,6 +7,7 @@ REQUIRED_PACKAGES = {
     'numpy': 'numpy',
     'pandas': 'pandas',
     'httpx': 'httpx',
+    'scipy': 'scipy',
     'fastapi': 'fastapi',
     'uvicorn': 'uvicorn',
     'requests': 'requests'
@@ -21,14 +22,15 @@ for module_name, pip_name in REQUIRED_PACKAGES.items():
         print(f"✅ {pip_name} установлен!")
 
 # ============================================
-# 👑 TOMIRIS SPACE 26 v3.1 — OPTIONS & DERIVATIVES ENGINE (FIXED)
+# 👑 TOMIRIS SPACE 26 v4.0 — OPTIONS & DERIVATIVES ENGINE (УСИЛЕННЫЙ)
 # ============================================
 import os, time, json, logging, asyncio
-from typing import Dict, Any, List, Optional
+from typing import Dict, Any, List, Optional, Tuple
 from datetime import datetime, timezone
 from collections import deque
 import numpy as np
 import pandas as pd
+from scipy import stats
 import httpx
 from fastapi import FastAPI, Query
 
@@ -42,23 +44,48 @@ SYMBOLS = ["XAU/USD", "ETH/USD", "SOL/USD"]
 
 HUB_URL = os.getenv("HUB_URL", "https://pro-3-tomiris-hub.hf.space")
 HUB_SECRET = os.getenv("HUB_SECRET", "TomyrisUltraSecret2026!")
-TWELVE_DATA_KEY = os.getenv("TWELVE_DATA_KEY", "a5da25be2e4f41bab4cd78ed8461e180")
-FRED_KEY = os.getenv("FRED_KEY", "faa11c8e2e4beee08c5b966e8b63a513")
+TWELVE_DATA_KEY = os.getenv("TWELVE_DATA_KEY", "")
+FRED_KEY = os.getenv("FRED_KEY", "")
+FRED_KEY_2 = os.getenv("FRED_KEY_2", "")
 
-STARTUP_SLEEP = int(os.getenv("STARTUP_SLEEP", "600"))
-AUTO_SEND_INTERVAL = int(os.getenv("AUTO_SEND_INTERVAL", "600"))
+FRED_KEYS = [k for k in [FRED_KEY, FRED_KEY_2] if k]
+if not FRED_KEYS: FRED_KEYS = ["no_key"]
 
-logger.info(f"🔗 Хаб: {HUB_URL}")
-logger.info(f"🔑 FRED: {'✅' if FRED_KEY else '❌'} | TwelveData: {'✅' if TWELVE_DATA_KEY else '❌'}")
+STARTUP_SLEEP = int(os.getenv("STARTUP_SLEEP", "120"))
+AUTO_SEND_INTERVAL = int(os.getenv("AUTO_SEND_INTERVAL", "300"))
+
+logger.info(f"🔗 Хаб: {HUB_URL} | Старт: {STARTUP_SLEEP}с | Интервал: {AUTO_SEND_INTERVAL}с")
+logger.info(f"🔑 FRED: {len(FRED_KEYS)} | TwelveData: {'✓' if TWELVE_DATA_KEY else '✗'}")
 
 HISTORY_FILE = "options_history.json"
-CACHE_TTL = {"funding": 60, "oi": 60, "lsr": 120, "deribit": 300, "fred": 3600, "vix": 60, "maxpain": 300}
+CACHE_TTL = {"funding": 60, "oi": 60, "lsr": 120, "deribit": 300, "fred": 3600, "vix": 60}
 
 http_client = httpx.AsyncClient(timeout=15.0)
 
 def hub_headers():
     return {"X-Hub-Secret": HUB_SECRET, "Content-Type": "application/json"}
 
+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 =================
+SCORE_HISTORY = {sym: deque(maxlen=200) for sym in SYMBOLS}
+FUNDING_HISTORY = {sym: deque(maxlen=200) for sym in SYMBOLS}
+OI_HISTORY = {sym: deque(maxlen=200) for sym in SYMBOLS}
+
+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
+
 cache_store = {}
 cache_times = {}
 CIRCUIT_BREAKER = {}
@@ -92,12 +119,13 @@ def save_history():
 # ================= ЗАГРУЗКА ДАННЫХ =================
 async def fetch_vix() -> Dict[str, Any]:
     if breaker_open("vix"): return {"vix": 20.0, "level": "NORMAL", "signal": "NEUTRAL"}
+    if not TWELVE_DATA_KEY: return {"vix": 20.0, "level": "NORMAL", "signal": "NEUTRAL"}
     try:
         r = await http_client.get(f"https://api.twelvedata.com/quote?symbol=VIX&apikey={TWELVE_DATA_KEY}")
         if r.status_code == 200:
             data = r.json(); vix_val = float(data.get("close", 20))
-            level = "HIGH" if vix_val > 30 else "ELEVATED" if vix_val > 25 else "NORMAL"
-            signal = "BEARISH_RISK" if vix_val > 30 else "NEUTRAL"
+            level = "CRITICAL" if vix_val > 35 else "HIGH" if vix_val > 28 else "ELEVATED" if vix_val > 22 else "NORMAL"
+            signal = "STRONG_SELL" if vix_val > 35 else "SELL" if vix_val > 28 else "CAUTION" if vix_val > 22 else "NEUTRAL"
             breaker_record("vix", True)
             return {"vix": vix_val, "level": level, "signal": signal}
     except: breaker_record("vix", False)
@@ -106,14 +134,30 @@ async def fetch_vix() -> Dict[str, Any]:
 async def fetch_funding_rate(symbol: str) -> Dict[str, Any]:
     if breaker_open(f"funding_{symbol}"): return {"funding_rate": 0, "signal": "NEUTRAL"}
     try:
-        r = await http_client.get("https://fapi.binance.com/fapi/v1/premiumIndex")
+        r = await http_client.get(f"https://fapi.binance.com/fapi/v1/premiumIndex?symbol={symbol}")
         if r.status_code == 200:
-            for item in r.json():
-                if item.get('symbol') == symbol:
-                    fr = float(item.get('lastFundingRate', 0))
-                    signal = "BEARISH" if fr > 0.001 else "BULLISH" if fr < -0.001 else "NEUTRAL"
-                    breaker_record(f"funding_{symbol}", True)
-                    return {"funding_rate": fr, "funding_rate_pct": round(fr * 100, 4), "signal": signal}
+            data = r.json()
+            if isinstance(data, list):
+                for item in data:
+                    if item.get('symbol') == symbol:
+                        fr = float(item.get('lastFundingRate', 0))
+                        break
+            elif isinstance(data, dict):
+                fr = float(data.get('lastFundingRate', 0))
+            else:
+                return {"funding_rate": 0, "signal": "NEUTRAL"}
+            
+            FUNDING_HISTORY[symbol].append(fr)
+            fr_z = calculate_zscore(fr, FUNDING_HISTORY[symbol])
+            
+            if fr > 0.005: signal = "STRONG_BEARISH"
+            elif fr > 0.001: signal = "BEARISH"
+            elif fr < -0.005: signal = "STRONG_BULLISH"
+            elif fr < -0.001: signal = "BULLISH"
+            else: signal = "NEUTRAL"
+            
+            breaker_record(f"funding_{symbol}", True)
+            return {"funding_rate": fr, "funding_rate_pct": round(fr * 100, 4), "zscore": round(fr_z, 2), "signal": signal}
     except: breaker_record(f"funding_{symbol}", False)
     return {"funding_rate": 0, "signal": "NEUTRAL"}
 
@@ -126,9 +170,18 @@ async def fetch_open_interest(symbol: str) -> Dict[str, Any]:
             prev_key = f"oi_{symbol}_prev"; prev_oi = cache_store.get(prev_key, oi)
             change = ((oi - prev_oi) / prev_oi * 100) if prev_oi > 0 else 0
             cache_store[prev_key] = oi
-            signal = "BULLISH" if change > 3 else "BEARISH" if change < -3 else "NEUTRAL"
+            
+            OI_HISTORY[symbol].append(change)
+            oi_z = calculate_zscore(change, OI_HISTORY[symbol])
+            
+            if change > 10: signal = "STRONG_BULLISH"
+            elif change > 3: signal = "BULLISH"
+            elif change < -10: signal = "STRONG_BEARISH"
+            elif change < -3: signal = "BEARISH"
+            else: signal = "NEUTRAL"
+            
             breaker_record(f"oi_{symbol}", True)
-            return {"open_interest": oi, "change_pct": round(change, 2), "signal": signal}
+            return {"open_interest": oi, "change_pct": round(change, 2), "zscore": round(oi_z, 2), "signal": signal}
     except: breaker_record(f"oi_{symbol}", False)
     return {"open_interest": 0, "change_pct": 0, "signal": "NEUTRAL"}
 
@@ -139,7 +192,9 @@ async def fetch_long_short_ratio(symbol: str) -> Dict[str, Any]:
         if r.status_code == 200:
             lsr = float(r.json().get("longShortRatio", 1))
             long_pct = lsr / (1 + lsr) * 100; short_pct = 100 - long_pct
-            if lsr > 2.0: signal = "BEARISH"
+            if lsr > 3.0: signal = "STRONG_BEARISH"
+            elif lsr > 2.0: signal = "BEARISH"
+            elif lsr < 0.33: signal = "STRONG_BULLISH"
             elif lsr < 0.5: signal = "BULLISH"
             else: signal = "NEUTRAL"
             breaker_record(f"lsr_{symbol}", True)
@@ -155,46 +210,76 @@ async def fetch_deribit_options(coin: str = "ETH") -> Dict[str, Any]:
             instruments = r.json().get('result', [])
             call_vol = sum(float(i.get('volume', 0)) for i in instruments if i.get('option_type') == 'call')
             put_vol = sum(float(i.get('volume', 0)) for i in instruments if i.get('option_type') == 'put')
-            pcr = put_vol / call_vol if call_vol > 0 else 1.0
-            signal = "BEARISH" if pcr > 1.3 else "BULLISH" if pcr < 0.7 else "NEUTRAL"
+            
+            # Open Interest тоже
+            call_oi = sum(float(i.get('open_interest', 0)) for i in instruments if i.get('option_type') == 'call')
+            put_oi = sum(float(i.get('open_interest', 0)) for i in instruments if i.get('option_type') == 'put')
+            
+            pcr_volume = put_vol / call_vol if call_vol > 0 else 1.0
+            pcr_oi = put_oi / call_oi if call_oi > 0 else 1.0
+            
+            if pcr_volume > 1.5: signal = "STRONG_BEARISH"
+            elif pcr_volume > 1.2: signal = "BEARISH"
+            elif pcr_volume < 0.6: signal = "STRONG_BULLISH"
+            elif pcr_volume < 0.8: signal = "BULLISH"
+            else: signal = "NEUTRAL"
+            
             breaker_record("deribit", True)
-            return {"put_call_ratio_volume": round(pcr, 4), "signal": signal}
+            return {
+                "put_call_ratio_volume": round(pcr_volume, 4),
+                "put_call_ratio_oi": round(pcr_oi, 4),
+                "signal": signal
+            }
     except: breaker_record("deribit", False)
-    return {"put_call_ratio_volume": 1.0, "signal": "NEUTRAL"}
+    return {"put_call_ratio_volume": 1.0, "put_call_ratio_oi": 1.0, "signal": "NEUTRAL"}
 
 async def fetch_gold_derivatives() -> Dict[str, Any]:
     if breaker_open("fred"): return {"signal": "NEUTRAL"}
-    try:
-        dxy_r = await http_client.get(f"https://api.stlouisfed.org/fred/series/observations?series_id=DTWEXBGS&api_key={FRED_KEY}&file_type=json&limit=30&sort_order=desc")
-        tips_r = await http_client.get(f"https://api.stlouisfed.org/fred/series/observations?series_id=DFII10&api_key={FRED_KEY}&file_type=json&limit=30&sort_order=desc")
-        dxy_vals = [float(o['value']) for o in dxy_r.json().get('observations', []) if o['value'] != '.'] if dxy_r.status_code == 200 else []
-        tips_vals = [float(o['value']) for o in tips_r.json().get('observations', []) if o['value'] != '.'] if tips_r.status_code == 200 else []
-        dxy_change = ((dxy_vals[0] - dxy_vals[-1]) / dxy_vals[-1] * 100) if len(dxy_vals) >= 2 else 0
-        tips_current = tips_vals[0] if tips_vals else 0.5
-        signal = "BULLISH" if dxy_change < -2 and tips_current < 0 else "BEARISH" if dxy_change > 2 and tips_current > 0 else "NEUTRAL"
-        breaker_record("fred", True)
-        return {"dxy": dxy_vals[0] if dxy_vals else 104.5, "dxy_change_pct": round(dxy_change, 2), "tips_yield": tips_current, "signal": signal}
-    except: breaker_record("fred", False)
+    if not FRED_KEYS or FRED_KEYS == ["no_key"]: return {"signal": "NEUTRAL"}
+    
+    for key in FRED_KEYS:
+        try:
+            dxy_r = await http_client.get(f"https://api.stlouisfed.org/fred/series/observations?series_id=DTWEXBGS&api_key={key}&file_type=json&limit=30&sort_order=desc")
+            tips_r = await http_client.get(f"https://api.stlouisfed.org/fred/series/observations?series_id=DFII10&api_key={key}&file_type=json&limit=30&sort_order=desc")
+            
+            if dxy_r.status_code == 200 and tips_r.status_code == 200:
+                dxy_vals = [float(o['value']) for o in dxy_r.json().get('observations', []) if o['value'] != '.']
+                tips_vals = [float(o['value']) for o in tips_r.json().get('observations', []) if o['value'] != '.']
+                
+                dxy_change = ((dxy_vals[0] - dxy_vals[-1]) / dxy_vals[-1] * 100) if len(dxy_vals) >= 2 else 0
+                tips_current = tips_vals[0] if tips_vals else 0.5
+                
+                if dxy_change < -2 and tips_current < 0: signal = "STRONG_BULLISH"
+                elif dxy_change < 0 and tips_current < 0: signal = "BULLISH"
+                elif dxy_change > 2 and tips_current > 0: signal = "STRONG_BEARISH"
+                elif dxy_change > 0 and tips_current > 0: signal = "BEARISH"
+                else: signal = "NEUTRAL"
+                
+                breaker_record("fred", True)
+                return {
+                    "dxy": dxy_vals[0] if dxy_vals else 104.5,
+                    "dxy_change_pct": round(dxy_change, 2),
+                    "tips_yield": tips_current,
+                    "signal": signal
+                }
+        except: continue
+    
+    breaker_record("fred", False)
     return {"signal": "NEUTRAL"}
 
 async def get_current_price(symbol: str) -> float:
     try:
         r = await http_client.get(f"{HUB_URL}/price/{symbol}", headers=hub_headers())
-        if r.status_code == 200: 
+        if r.status_code == 200:
             data = r.json()
             return float(data.get("price", data.get("mid", 0)))
     except: pass
-    bin_symbol = symbol.replace("/", "")
-    try:
-        r = await http_client.get(f"https://fapi.binance.com/fapi/v1/ticker/price?symbol={bin_symbol}")
-        if r.status_code == 200: return float(r.json()["price"])
-    except: pass
     return 0.0
 
 def calculate_max_pain(current_price: float) -> float:
     return round(current_price * 0.98, 2) if current_price > 0 else 0.0
 
-# ================= АНАЛИЗ =================
+# ================= 🔥 АНАЛИЗ =================
 async def analyze_derivatives(symbol: str) -> Dict[str, Any]:
     native = "XAU" if "XAU" in symbol else ("ETH" if "ETH" in symbol else "SOL")
     bin_sym = "" if native == "XAU" else (native + "USDT")
@@ -207,6 +292,7 @@ async def analyze_derivatives(symbol: str) -> Dict[str, Any]:
 
     results = await asyncio.gather(*tasks)
     idx = 0; metrics = {}
+    
     if bin_sym:
         metrics['funding_rate'] = results[idx]; idx += 1
         metrics['open_interest'] = results[idx]; idx += 1
@@ -215,103 +301,154 @@ async def analyze_derivatives(symbol: str) -> Dict[str, Any]:
     if native == "XAU": metrics['gold_derivatives'] = results[idx]; idx += 1
     vix_data = results[idx]
 
-    signals = []; score = 50.0
-
-    if vix_data["vix"] > 30:
-        signals.append({"source": "VIX", "signal": "BEARISH_RISK", "reason": f"VIX={vix_data['vix']:.1f}"})
-        score += 15 if native == "XAU" else -10
-    elif vix_data["vix"] > 25: score += 5
+    signals = {}
+    score = 50.0
+
+    # VIX (вес 15%)
+    vix_val = vix_data.get("vix", 20)
+    if vix_val > 35:
+        signals["vix"] = ("STRONG_SELL", 18) if native != "XAU" else ("STRONG_BUY", 18)
+        score += 18 if native == "XAU" else -18
+    elif vix_val > 28:
+        signals["vix"] = ("SELL", 12) if native != "XAU" else ("BUY", 12)
+        score += 12 if native == "XAU" else -12
+    elif vix_val > 22:
+        score += 6 if native == "XAU" else -6
+        signals["vix"] = ("SLIGHT_BUY", 6) if native == "XAU" else ("SLIGHT_SELL", 6)
+    else:
+        signals["vix"] = ("NEUTRAL", 0)
 
+    # Funding Rate (вес 20%)
     fund = metrics.get('funding_rate', {})
-    if fund.get('signal') == 'BEARISH':
-        signals.append({"source": "FUNDING", "signal": "BEARISH", "reason": f"Перегретый лонг ({fund.get('funding_rate_pct')}%)"}); score -= 15
-    elif fund.get('signal') == 'BULLISH':
-        signals.append({"source": "FUNDING", "signal": "BULLISH", "reason": f"Перегретый шорт ({fund.get('funding_rate_pct')}%)"}); score += 15
+    fund_signal = fund.get('signal', 'NEUTRAL')
+    fund_z = fund.get('zscore', 0)
+    if fund_signal == 'STRONG_BEARISH':
+        score -= 20; signals["funding"] = ("STRONG_SELL", 20)
+    elif fund_signal == 'BEARISH':
+        score -= 14; signals["funding"] = ("SELL", 14)
+    elif fund_signal == 'STRONG_BULLISH':
+        score += 20; signals["funding"] = ("STRONG_BUY", 20)
+    elif fund_signal == 'BULLISH':
+        score += 14; signals["funding"] = ("BUY", 14)
+    else:
+        signals["funding"] = ("NEUTRAL", 0)
+    
+    if abs(fund_z) > 2.0:
+        score += 8 if fund_z < 0 else -8
 
+    # Open Interest (вес 15%)
     oi = metrics.get('open_interest', {})
-    if oi.get('signal') == 'BEARISH':
-        signals.append({"source": "OI", "signal": "BEARISH", "reason": f"OI перегрет ({oi.get('change_pct')}%)"}); score -= 10
-    elif oi.get('signal') == 'BULLISH':
-        signals.append({"source": "OI", "signal": "BULLISH", "reason": f"OI растёт ({oi.get('change_pct')}%)"}); score += 10
+    oi_signal = oi.get('signal', 'NEUTRAL')
+    if oi_signal == 'STRONG_BULLISH':
+        score += 12; signals["oi"] = ("BUY", 12)
+    elif oi_signal == 'BULLISH':
+        score += 8; signals["oi"] = ("SLIGHT_BUY", 8)
+    elif oi_signal == 'STRONG_BEARISH':
+        score -= 12; signals["oi"] = ("SELL", 12)
+    elif oi_signal == 'BEARISH':
+        score -= 8; signals["oi"] = ("SLIGHT_SELL", 8)
+    else:
+        signals["oi"] = ("NEUTRAL", 0)
 
+    # Long/Short Ratio (вес 15%)
     lsr = metrics.get('long_short_ratio', {})
-    if lsr.get('signal') == 'BEARISH':
-        signals.append({"source": "L/S", "signal": "BEARISH", "reason": f"Слишком много лонгов ({lsr.get('long_pct')}%)"}); score -= 10
-    elif lsr.get('signal') == 'BULLISH':
-        signals.append({"source": "L/S", "signal": "BULLISH", "reason": f"Много шортов ({lsr.get('short_pct')}%)"}); score += 10
+    lsr_signal = lsr.get('signal', 'NEUTRAL')
+    if lsr_signal == 'STRONG_BEARISH':
+        score -= 15; signals["lsr"] = ("STRONG_SELL", 15)
+    elif lsr_signal == 'BEARISH':
+        score -= 10; signals["lsr"] = ("SELL", 10)
+    elif lsr_signal == 'STRONG_BULLISH':
+        score += 15; signals["lsr"] = ("STRONG_BUY", 15)
+    elif lsr_signal == 'BULLISH':
+        score += 10; signals["lsr"] = ("BUY", 10)
+    else:
+        signals["lsr"] = ("NEUTRAL", 0)
 
+    # Options PCR (вес 15%)
     options = metrics.get('options', {})
-    if options.get('signal') == 'BEARISH':
-        signals.append({"source": "OPTIONS", "signal": "BEARISH", "reason": f"PCR={options.get('put_call_ratio_volume')}"}); score -= 8
+    if options.get('signal') == 'STRONG_BEARISH':
+        score -= 12; signals["options"] = ("SELL", 12)
+    elif options.get('signal') == 'BEARISH':
+        score -= 8; signals["options"] = ("SLIGHT_SELL", 8)
+    elif options.get('signal') == 'STRONG_BULLISH':
+        score += 12; signals["options"] = ("BUY", 12)
     elif options.get('signal') == 'BULLISH':
-        signals.append({"source": "OPTIONS", "signal": "BULLISH", "reason": f"PCR={options.get('put_call_ratio_volume')}"}); score += 8
+        score += 8; signals["options"] = ("SLIGHT_BUY", 8)
+    else:
+        signals["options"] = ("NEUTRAL", 0)
 
+    # Gold Derivatives (вес 10%)
     gold = metrics.get('gold_derivatives', {})
-    if gold.get('signal') == 'BULLISH':
-        signals.append({"source": "COT/DXY/TIPS", "signal": "BULLISH", "reason": "Макро-факторы за золото"}); score += 12
+    if gold.get('signal') == 'STRONG_BULLISH':
+        score += 12; signals["gold"] = ("STRONG_BUY", 12)
+    elif gold.get('signal') == 'BULLISH':
+        score += 8; signals["gold"] = ("BUY", 8)
+    elif gold.get('signal') == 'STRONG_BEARISH':
+        score -= 12; signals["gold"] = ("STRONG_SELL", 12)
     elif gold.get('signal') == 'BEARISH':
-        signals.append({"source": "COT/DXY/TIPS", "signal": "BEARISH", "reason": "Макро-факторы против золота"}); score -= 12
+        score -= 8; signals["gold"] = ("SELL", 8)
+    else:
+        signals["gold"] = ("NEUTRAL", 0)
 
+    # Max Pain (вес 10%)
     price = await get_current_price(symbol) if native != "XAU" else 0
     max_pain = calculate_max_pain(price) if price > 0 else 0
-    if max_pain > 0 and price < max_pain:
-        signals.append({"source": "MAX_PAIN", "signal": "BULLISH", "reason": f"Цена ниже Max Pain ({max_pain})"}); score += 8
-    elif max_pain > 0 and price > max_pain:
-        signals.append({"source": "MAX_PAIN", "signal": "BEARISH", "reason": f"Цена выше Max Pain ({max_pain})"}); score -= 8
-
-    score = max(0, min(100, score))
-    
-    # 🔥 BUY/SELL вместо LONG/SHORT
-    if score > 60:
-        signal = "BUY"
-        confidence = score / 100
-    elif score < 40:
-        signal = "SELL"
-        confidence = (100 - score) / 100
+    if max_pain > 0 and price < max_pain * 0.97:
+        score += 8; signals["maxpain"] = ("BUY", 8)
+    elif max_pain > 0 and price > max_pain * 1.03:
+        score -= 8; signals["maxpain"] = ("SELL", 8)
     else:
-        signal = "WAIT"
-        confidence = 0.0
+        signals["maxpain"] = ("NEUTRAL", 0)
+
+    score = round(max(3, min(97, score)), 1)
+
+    # Z-score
+    SCORE_HISTORY[symbol].append(score)
+    score_z = calculate_zscore(score, SCORE_HISTORY[symbol])
+
+    if score > 62: signal, confidence = "BUY", min(0.92, score / 100)
+    elif score > 54: signal, confidence = "BUY", min(0.68, (score - 50) / 50)
+    elif score < 38: signal, confidence = "SELL", min(0.92, (100 - score) / 100)
+    elif score < 46: signal, confidence = "SELL", min(0.68, (50 - score) / 50)
+    else: signal, confidence = "WAIT", 0.0
 
-    analysis = {"derivative_score": score, "signal": signal, "confidence": round(confidence, 4), "signals": signals, "metrics": {**metrics, "vix": vix_data, "max_pain": max_pain}}
-    OPTIONS_HISTORY.append({"timestamp": datetime.now(timezone.utc).isoformat(), "symbol": symbol, "signal": signal, "score": score})
+    analysis = {
+        "derivative_score": score,
+        "score_zscore": round(score_z, 2),
+        "signal": signal,
+        "confidence": round(confidence, 4),
+        "signals_breakdown": {k: v[0] for k, v in signals.items()},
+        "metrics": {**metrics, "vix": vix_data, "max_pain": max_pain}
+    }
+    
+    OPTIONS_HISTORY.append({
+        "timestamp": datetime.now(timezone.utc).isoformat(),
+        "symbol": symbol, "signal": signal, "score": score
+    })
     save_history()
+    
     return analysis
 
-# ================= ОТПРАВКА В HUB (ИСПРАВЛЕНО) =================
+# ================= ОТПРАВКА В HUB =================
 async def send_signal_to_hub(symbol: str, signal: str, confidence: float, features: Dict = None):
-    if features is None:
-        features = {}
-    
+    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": "3.1"},
-        "timestamp": datetime.now().isoformat()
+        "space_id": SPACE_ID, "space_name": SPACE_NAME,
+        "symbol": symbol, "signal": signal, "confidence": round(confidence, 4),
+        "features": features, "metadata": {"version": "4.0"},
+        "timestamp": datetime.now(timezone.utc).isoformat()
     }
-    
     for attempt in range(3):
         try:
-            headers = hub_headers()
-            r = await http_client.post(f"{HUB_URL}/signals", json=payload, timeout=15, 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
-            elif r.status_code == 429:
-                wait = 3 * (attempt + 1)
-                logger.warning(f"⏳ 429 для {symbol}, жду {wait}с...")
-                await asyncio.sleep(wait)
-            else:
-                logger.warning(f"Попытка {attempt+1}: HTTP {r.status_code}")
-                await asyncio.sleep(2)
+                return True
+            await asyncio.sleep(2)
         except Exception as e:
             logger.warning(f"Попытка {attempt+1}: {e}")
             await asyncio.sleep(2)
-    
-    logger.error(f"❌ Не удалось отправить {symbol}")
+    return False
 
 # ================= ГЛАВНЫЙ СИГНАЛ =================
 async def get_derivative_signal(symbol: str = "ETH/USD") -> Dict[str, Any]:
@@ -319,24 +456,25 @@ async def get_derivative_signal(symbol: str = "ETH/USD") -> Dict[str, Any]:
     analysis = await analyze_derivatives(symbol)
     latency = int((time.time() - start) * 1000)
     
-    features = {"derivative_score": analysis['derivative_score']}
+    features = {
+        "derivative_score": analysis['derivative_score'],
+        "score_zscore": analysis['score_zscore']
+    }
     await send_signal_to_hub(symbol, analysis['signal'], analysis['confidence'], features)
     
-    logger.info(f"📊 Options {symbol}: {analysis['signal']} conf={analysis['confidence']:.3f} | {latency}ms")
+    logger.info(f"📊 Options {symbol}: {analysis['signal']} conf={analysis['confidence']:.3f} score={analysis['derivative_score']} | {latency}ms")
     return {
-        "space_id": SPACE_ID,
-        "timestamp": int(time.time()),
-        "symbol": symbol,
-        "signal": analysis['signal'],
-        "confidence": analysis['confidence'],
-        "derivative_analysis": analysis
+        "space_id": SPACE_ID, "timestamp": int(time.time()),
+        "symbol": symbol, "signal": analysis['signal'],
+        "confidence": analysis['confidence'], "derivative_analysis": analysis
     }
 
 # ================= АВТО-ОТПРАВКА =================
 async def auto_send_loop():
     logger.info(f"⏳ Стартовый сон {STARTUP_SLEEP}с...")
+    await log_to_hub("STARTUP", f"Options Engine v4.0 запущен, жду {STARTUP_SLEEP}с")
     await asyncio.sleep(STARTUP_SLEEP)
-    logger.info(f"🔄 Options Engine запущен (интервал {AUTO_SEND_INTERVAL}с)")
+    logger.info(f"🔄 Options Engine [интервал={AUTO_SEND_INTERVAL}с]")
     while True:
         try:
             for symbol in SYMBOLS:
@@ -344,28 +482,25 @@ async def auto_send_loop():
                 await asyncio.sleep(2)
             logger.info("✅ Options Engine цикл завершён")
         except Exception as e:
-            logger.error(f"Ошибка авто-отправки: {e}")
+            logger.error(f"Ошибка: {e}")
+            await log_to_hub("ERROR", f"Ошибка: {str(e)[:200]}")
         await asyncio.sleep(AUTO_SEND_INTERVAL)
 
 # ================= FASTAPI =================
-app = FastAPI(title="Tomiris Space 26 v3.1 — Options & Derivatives")
+app = FastAPI(title="Tomiris Space 26 v4.0 — Options & Derivatives")
 
 @app.on_event("startup")
 async def startup():
     asyncio.create_task(auto_send_loop())
-    logger.info(f"🚀 Space 26 v3.1 ЗАПУЩЕН | Хаб: {HUB_URL}")
+    logger.info(f"🚀 Space 26 v4.0 | Хаб: {HUB_URL}")
 
 @app.on_event("shutdown")
-async def shutdown():
-    await http_client.aclose()
+async def shutdown(): await http_client.aclose()
 
 @app.get("/health")
-async def health():
-    return {"space_id": SPACE_ID, "status": "operational", "version": "3.1"}
-
+async def health(): return {"space_id": SPACE_ID, "status": "operational", "version": "4.0"}
 @app.head("/health")
-async def health_head():
-    return {}
+async def health_head(): return {}
 
 @app.get("/consilium")
 async def consilium(symbol: str = Query("ETH/USD")):
@@ -373,23 +508,40 @@ async def consilium(symbol: str = Query("ETH/USD")):
     return await get_derivative_signal(symbol)
 
 @app.get("/funding/{symbol}")
-async def funding(symbol: str): return await fetch_funding_rate(symbol.upper())
+async def funding(symbol: str):
+    native = "XAU" if "XAU" in symbol.upper() else ("ETH" if "ETH" in symbol.upper() else "SOL")
+    bin_sym = native + "USDT"
+    return await fetch_funding_rate(bin_sym)
+
 @app.get("/oi/{symbol}")
-async def oi(symbol: str): return await fetch_open_interest(symbol.upper())
+async def oi(symbol: str):
+    native = "XAU" if "XAU" in symbol.upper() else ("ETH" if "ETH" in symbol.upper() else "SOL")
+    bin_sym = native + "USDT"
+    return await fetch_open_interest(bin_sym)
+
 @app.get("/lsr/{symbol}")
-async def lsr(symbol: str): return await fetch_long_short_ratio(symbol.upper())
+async def lsr(symbol: str):
+    native = "XAU" if "XAU" in symbol.upper() else ("ETH" if "ETH" in symbol.upper() else "SOL")
+    bin_sym = native + "USDT"
+    return await fetch_long_short_ratio(bin_sym)
+
 @app.get("/options")
 async def options(): return await fetch_deribit_options("ETH")
+
 @app.get("/gold")
 async def gold(): return await fetch_gold_derivatives()
+
 @app.get("/vix")
 async def vix(): return await fetch_vix()
+
 @app.get("/maxpain/{symbol}")
 async def maxpain(symbol: str):
     price = await get_current_price(symbol); mp = calculate_max_pain(price)
     return {"symbol": symbol, "current_price": price, "max_pain": mp}
+
 @app.get("/history")
 async def history(limit: int = 50): return list(OPTIONS_HISTORY)[-limit:]
+
 @app.get("/send_now")
 async def send_now():
     results = {}
@@ -399,11 +551,10 @@ async def send_now():
     return {"status": "sent", "results": results}
 
 @app.get("/")
-async def root():
-    return {"name": "Options Engine v3.1", "space_id": SPACE_ID, "hub": HUB_URL}
+async def root(): return {"name": "Options Engine v4.0", "space_id": SPACE_ID, "hub": HUB_URL}
 
 if __name__ == "__main__":
     import uvicorn
     uvicorn.run(app, host="0.0.0.0", port=7860)
 
-print("🚀 SPACE 26 v3.1 — OPTIONS & DERIVATIVES ENGINE ГОТОВ К РАБОТЕ!")
+print("🚀 SPACE 26 v4.0 — OPTIONS & DERIVATIVES ENGINE ГОТОВ!")