Update app.py

app.py

@@ -7,7 +7,6 @@ import importlib
 
 REQUIRED_PACKAGES = {
     'numpy': 'numpy',
-    'pandas': 'pandas',
     'requests': 'requests'
 }
 
@@ -20,21 +19,20 @@ for module_name, pip_name in REQUIRED_PACKAGES.items():
         print(f"✅ {pip_name} установлен!")
 
 # ============================================
-# 👑 TOMIRIS SPACE 28 v1.0 — MARKET REGIME & BUBBLE DETECTOR
+# 👑 TOMIRIS SPACE 29 v1.0 — MACRO SURPRISE INDEX
 # ============================================
-# Определяет режим рынка (TREND/RANGE/VOLATILE/BUBBLE).
-# Euphoria Index, NVT Ratio, RSI экстремумы, пузыри.
-# Имеет право ВЕТО — при пузыре блокирует BUY.
+# Оценивает, насколько макроданные отклоняются от консенсуса.
+# NFP, CPI, FOMC, PMI, GDP — сюрпризы двигают рынки.
+# Положительный сюрприз = риск-он, отрицательный = риск-офф.
 # ============================================
 
 from fastapi import FastAPI, Query
-from typing import Dict, Any, List, Optional, Tuple
+from typing import Dict, Any, List, Optional
 import time
 import requests
 import threading
 import numpy as np
-import pandas as pd
-from datetime import datetime
+from datetime import datetime, timedelta
 from collections import deque
 import warnings
 warnings.filterwarnings('ignore')
@@ -44,326 +42,368 @@ SYMBOLS: List[str] = ["XAU/USD", "ETH/USD", "SOL/USD"]
 
 SPACE_18_ARBITER: str = "https://tomiris-ai-name6-6.hf.space"
 
-TWELVE_KEYS: List[str] = [
-    "e3740c072fda4fe8b8539d40b07e445e",
-    "58e67e0008e24161ac9b1671b7c2d2d0"
+# FRED API ключи
+FRED_KEYS: List[str] = [
+    "faa11c8e2e4beee08c5b966e8b63a513",
+    "3305a8458cb112b417183b1d6b87f2e1"
 ]
 
-CACHE: Dict[str, Any] = {}
+# NewsAPI ключи
+NEWSAPI_KEYS: List[str] = [
+    "948c7816beea47baa23b054592472d0e",
+    "96199e06c4ac45e19236e2dfd879fd37"
+]
+
+CACHE: Dict[str, Dict[str, Any]] = {}
 CACHE_TIMES: Dict[str, float] = {}
 FEATURES_STORE: Dict[str, Dict[str, Any]] = {}
 MT5_MAX_AGE_SEC: int = 300
-BUBBLE_HISTORY: deque = deque(maxlen=200)
+SURPRISE_HISTORY: deque = deque(maxlen=100)
 
-twelve_counter: int = 0
+fred_counter: int = 0
+newsapi_counter: int = 0
 api_lock = threading.Lock()
 
-def get_next_key() -> str:
-    global twelve_counter
+def get_next_fred_key() -> str:
+    global fred_counter
+    with api_lock:
+        key = FRED_KEYS[fred_counter % len(FRED_KEYS)]
+        fred_counter += 1
+        return key
+
+def get_next_newsapi_key() -> str:
+    global newsapi_counter
     with api_lock:
-        key = TWELVE_KEYS[twelve_counter % len(TWELVE_KEYS)]
-        twelve_counter += 1
+        key = NEWSAPI_KEYS[newsapi_counter % len(NEWSAPI_KEYS)]
+        newsapi_counter += 1
         return key
 
 def send_to_arbiter(signal_data: Dict[str, Any]) -> None:
     try:
         requests.post(
             f"{SPACE_18_ARBITER}/log_signal",
-            json={'space': 'space_28_regime', 'symbol': 'ALL', 'signal': signal_data.get('signal', {})},
+            json={'space': 'space_29_macro_surprise', 'symbol': 'ALL', 'signal': signal_data.get('signal', {})},
             timeout=5
         )
     except:
         pass
 
-# ================= ЗАГРУЗКА ДАННЫХ =================
-def fetch_historical(symbol: str, tf: str = "1h", count: int = 200) -> Optional[pd.DataFrame]:
-    cache_key = f"hist_{symbol}_{tf}_{count}"
-    if cache_key in CACHE and time.time() - CACHE_TIMES.get(cache_key, 0) < 300:
+# ================= КОНСЕНСУС-ПРОГНОЗЫ (ОЖИДАНИЯ) =================
+# Аппроксимация рыночного консенсуса (обновляется ежемесячно)
+CONSENSUS: Dict[str, float] = {
+    "CPI_YOY": 3.2,       # Инфляция годовая
+    "CORE_CPI_YOY": 3.5,  # Базовая инфляция
+    "UNEMPLOYMENT": 4.0,  # Безработица
+    "NFP": 180_000,       # Non-Farm Payrolls
+    "GDP_QOQ": 2.0,       # ВВП квартальный
+    "FED_RATE": 4.25,     # Ставка ФРС
+    "ISM_MANUF": 49.0,    # ISM Manufacturing
+    "ISM_SERVICES": 52.0, # ISM Services
+    "RETAIL_SALES": 0.3,  # Розничные продажи
+    "DURABLE_GOODS": 0.5, # Заказы длительного пользования
+}
+
+# ================= ЗАГРУЗКА FRED =================
+def fetch_fred_series(series_id: str, days: int = 12) -> List[Dict[str, Any]]:
+    cache_key = f"fred_{series_id}_{days}"
+    if cache_key in CACHE and time.time() - CACHE_TIMES.get(cache_key, 0) < 3600:
         return CACHE[cache_key]
 
     try:
-        key = get_next_key()
-        twelve_symbol = symbol.replace("/", "")
-        url = f"https://api.twelvedata.com/time_series?symbol={twelve_symbol}&interval={tf}&outputsize={count}&apikey={key}"
+        key = get_next_fred_key()
+        url = f"https://api.stlouisfed.org/fred/series/observations?series_id={series_id}&api_key={key}&file_type=json&sort_order=desc&limit={days}"
         r = requests.get(url, timeout=10)
         if r.status_code == 200:
             data = r.json()
-            if 'values' in data:
-                df = pd.DataFrame(data['values']).iloc[::-1]
-                df['close'] = pd.to_numeric(df['close'])
-                df['high'] = pd.to_numeric(df['high'])
-                df['low'] = pd.to_numeric(df['low'])
-                if 'volume' in df.columns:
-                    df['volume'] = pd.to_numeric(df['volume'], errors='coerce').fillna(0)
-                CACHE[cache_key] = df
-                CACHE_TIMES[cache_key] = time.time()
-                return df
-    except Exception as e:
-        print(f"⚠️ {symbol}: {e}")
-    return None
-
-# ================= ИНДИКАТОРЫ =================
-def safe_rsi(close: pd.Series, period: int = 14) -> float:
-    try:
-        delta = close.diff()
-        gain = delta.clip(lower=0).rolling(period, min_periods=period).mean()
-        loss = (-delta.clip(upper=0)).rolling(period, min_periods=period).mean()
-        g_val, l_val = gain.iloc[-1], loss.iloc[-1]
-        if pd.notna(g_val) and pd.notna(l_val) and l_val > 0:
-            rs = g_val / l_val
-            return float(100 - (100 / (1 + rs)))
-        return 50.0
+            values = [
+                {'date': obs['date'], 'value': float(obs['value'])}
+                for obs in data.get('observations', []) if obs['value'] != '.'
+            ]
+            CACHE[cache_key] = values
+            CACHE_TIMES[cache_key] = time.time()
+            return values
     except:
-        return 50.0
-
-def calculate_euphoria_index(df: pd.DataFrame) -> float:
-    """Euphoria Index: 0-100, где >70 = эйфория."""
-    if df is None or len(df) < 50:
-        return 50.0
-
-    close = df['close']
-    volume = df['volume'] if 'volume' in df.columns else pd.Series([1]*len(df))
-
-    score = 0.0
-
-    # RSI на D1 (перекупленность)
-    rsi = safe_rsi(close, 14)
-    if rsi > 80:
-        score += 30
-    elif rsi > 70:
-        score += 20
-    elif rsi > 60:
-        score += 10
-
-    # Положение относительно SMA 50
-    if len(close) >= 50:
-        sma50 = close.rolling(50).mean().iloc[-1]
-        price_vs_sma = ((close.iloc[-1] - sma50) / sma50) * 100
-        if price_vs_sma > 20:
-            score += 25
-        elif price_vs_sma > 10:
-            score += 15
-        elif price_vs_sma > 5:
-            score += 5
-
-    # Объём (аномально высокий = эйфория)
-    if len(volume) >= 20:
-        vol_avg = volume.rolling(20).mean().iloc[-1]
-        vol_ratio = volume.iloc[-1] / (vol_avg + 1e-10)
-        if vol_ratio > 3:
-            score += 20
-        elif vol_ratio > 2:
-            score += 10
-
-    return min(100, score)
-
-def calculate_nvt_ratio(df: pd.DataFrame) -> float:
-    """Network Value to Transactions — аналог NVT для крипты."""
-    if df is None or len(df) < 30:
-        return 50.0
-
-    close = df['close']
-    volume = df['volume'] if 'volume' in df.columns else pd.Series([1]*len(df))
-
-    # Упрощённый NVT = MarketCap / Daily Volume
-    market_cap = close.iloc[-1] * 120_000_000  # Грубая оценка supply
-    daily_volume = volume.iloc[-24:].sum() if len(volume) >= 24 else volume.sum()
-
-    if daily_volume > 0:
-        nvt = market_cap / daily_volume
-    else:
-        nvt = 50
-
-    # Нормализация (для ETH норма NVT ~ 30-80)
-    if nvt > 150:
-        nvt_signal = "EXTREME_OVERBOUGHT"
-        nvt_score = 30
-    elif nvt > 100:
-        nvt_signal = "OVERBOUGHT"
-        nvt_score = 20
-    elif nvt < 30:
-        nvt_signal = "OVERSOLD"
-        nvt_score = -15
-    else:
-        nvt_signal = "NORMAL"
-        nvt_score = 0
-
-    return float(nvt_score)
-
-# ================= РЕЖИМ РЫНКА =================
-def detect_market_regime(df: pd.DataFrame, symbol: str) -> Dict[str, Any]:
-    if df is None or len(df) < 50:
-        return {"regime": "UNKNOWN", "score": 50, "bubble_risk": "UNKNOWN", "veto": False}
-
-    close = df['close'].values
-    high = df['high'].values
-    low = df['low'].values
-
-    # Волатильность
-    returns = np.diff(np.log(close))
-    volatility = float(np.std(returns[-24:])) if len(returns) >= 24 else 0.01
-
-    # ADX (упрощённо через размах)
-    recent_high = np.max(high[-20:])
-    recent_low = np.min(low[-20:])
-    range_pct = (recent_high - recent_low) / recent_low * 100
-
-    # Euphoria Index
-    euphoria = calculate_euphoria_index(df)
-
-    # NVT (только для крипты)
-    nvt_score = 0.0
-    if "XAU" not in symbol:
-        nvt_score = calculate_nvt_ratio(df)
-
-    # RSI
-    rsi = safe_rsi(pd.Series(close), 14)
-
-    # Определение режима
-    if euphoria > 70:
-        regime = "BUBBLE"
-        veto = True
-        signal = "FORCE_WAIT"
-    elif euphoria > 55:
-        regime = "EUPHORIA"
-        veto = False
-        signal = "CAUTION"
-    elif volatility > 0.03:
-        regime = "VOLATILE"
-        veto = False
-        signal = "NEUTRAL"
-    elif range_pct < 3:
-        regime = "RANGE"
-        veto = False
-        signal = "NEUTRAL"
+        pass
+    return []
+
+# ================= РАСЧЁТ СЮРПРИЗА =================
+def calculate_surprise(actual: float, consensus: float) -> Dict[str, Any]:
+    """Вычисляет, насколько факт отклонился от консенсуса."""
+    if consensus == 0:
+        return {"surprise_pct": 0, "level": "NEUTRAL", "impact": 0}
+
+    surprise_pct = ((actual - consensus) / abs(consensus)) * 100
+
+    if abs(surprise_pct) > 100:
+        level = "EXTREME_SURPRISE"
+        impact = 30
+    elif abs(surprise_pct) > 50:
+        level = "MAJOR_SURPRISE"
+        impact = 20
+    elif abs(surprise_pct) > 20:
+        level = "MODERATE_SURPRISE"
+        impact = 10
+    elif abs(surprise_pct) > 5:
+        level = "MINOR_SURPRISE"
+        impact = 5
     else:
-        regime = "TREND"
-        veto = False
-        signal = "NORMAL"
-
-    regime_score = 50.0
-    if regime == "BUBBLE":
-        regime_score = 90
-    elif regime == "EUPHORIA":
-        regime_score = 70
-    elif regime == "VOLATILE":
-        regime_score = 55
-    elif regime == "RANGE":
-        regime_score = 30
+        level = "IN_LINE"
+        impact = 0
+
+    return {
+        "surprise_pct": round(surprise_pct, 2),
+        "level": level,
+        "impact": impact,
+        "direction": "POSITIVE" if surprise_pct > 0 else "NEGATIVE" if surprise_pct < 0 else "NEUTRAL"
+    }
+
+# ================= ОЦЕНКА МАКРО-СЮРПРИЗОВ =================
+def analyze_macro_surprises() -> Dict[str, Any]:
+    surprises = []
+    total_surprise_score = 0.0
+    positive_impact = 0.0
+    negative_impact = 0.0
+
+    # CPI (CPIAUCSL)
+    cpi_data = fetch_fred_series("CPIAUCSL", 12)
+    if len(cpi_data) >= 2:
+        cpi_current = cpi_data[0]['value']
+        cpi_prev = cpi_data[-1]['value']
+        cpi_yoy = ((cpi_current - cpi_prev) / cpi_prev) * 100
+        surprise = calculate_surprise(cpi_yoy, CONSENSUS.get("CPI_YOY", 3.2))
+
+        if surprise['direction'] == 'POSITIVE':
+            # Инфляция выше ожиданий = негатив для риска
+            negative_impact += surprise['impact']
+            total_surprise_score -= surprise['impact']
+            signal = "BEARISH"
+        else:
+            positive_impact += surprise['impact']
+            total_surprise_score += surprise['impact']
+            signal = "BULLISH"
+
+        surprises.append({
+            "indicator": "CPI_YOY",
+            "actual": round(cpi_yoy, 2),
+            "consensus": CONSENSUS.get("CPI_YOY", 3.2),
+            "surprise": surprise,
+            "market_signal": signal
+        })
+
+    # Unemployment (UNRATE)
+    unemp_data = fetch_fred_series("UNRATE", 6)
+    if unemp_data:
+        unemp_current = unemp_data[0]['value']
+        surprise = calculate_surprise(unemp_current, CONSENSUS.get("UNEMPLOYMENT", 4.0))
+
+        if surprise['direction'] == 'POSITIVE':
+            # Безработица выше ожиданий = негатив
+            negative_impact += surprise['impact']
+            total_surprise_score -= surprise['impact']
+            signal = "BEARISH"
+        else:
+            # Безработица ниже = позитив
+            positive_impact += surprise['impact']
+            total_surprise_score += surprise['impact']
+            signal = "BULLISH"
+
+        surprises.append({
+            "indicator": "UNEMPLOYMENT",
+            "actual": round(unemp_current, 2),
+            "consensus": CONSENSUS.get("UNEMPLOYMENT", 4.0),
+            "surprise": surprise,
+            "market_signal": signal
+        })
+
+    # FOMC — через новости
+    fomc_surprise = fetch_fomc_surprise()
+    if fomc_surprise.get('impact', 0) != 0:
+        surprises.append(fomc_surprise)
+        total_surprise_score += fomc_surprise.get('impact', 0)
+        if fomc_surprise.get('direction') == 'HAWKISH':
+            negative_impact += abs(fomc_surprise.get('impact', 0))
+        else:
+            positive_impact += abs(fomc_surprise.get('impact', 0))
+
+    # Нормализация
+    total_surprise_score = max(-50, min(50, total_surprise_score))
+    surprise_index = 50 + total_surprise_score
+    surprise_index = max(0, min(100, surprise_index))
+
+    if surprise_index > 65:
+        market_regime = "RISK_ON"
+        direction = "LONG"
+        confidence = surprise_index / 100
+    elif surprise_index < 35:
+        market_regime = "RISK_OFF"
+        direction = "SHORT"
+        confidence = (100 - surprise_index) / 100
     else:
-        regime_score = 50
+        market_regime = "NEUTRAL"
+        direction = "WAIT"
+        confidence = 0.0
 
     return {
-        "regime": regime,
-        "regime_score": regime_score,
-        "euphoria_index": round(euphoria, 1),
-        "nvt_score": round(nvt_score, 1),
-        "rsi_14": round(rsi, 1),
-        "volatility_24h_pct": round(volatility * 100, 3),
-        "range_20_pct": round(range_pct, 1),
-        "bubble_risk": "HIGH" if regime == "BUBBLE" else "ELEVATED" if regime == "EUPHORIA" else "LOW",
-        "veto": veto,
-        "signal": signal
+        "surprise_index": round(surprise_index, 2),
+        "market_regime": market_regime,
+        "direction": direction,
+        "confidence": round(confidence, 4),
+        "total_surprise_score": round(total_surprise_score, 2),
+        "positive_impact": round(positive_impact, 2),
+        "negative_impact": round(negative_impact, 2),
+        "surprises": surprises
     }
 
+# ================= FOMC СЮРПРИЗ =================
+def fetch_fomc_surprise() -> Dict[str, Any]:
+    """Оценивает сюрприз от решений ФРС через новости."""
+    cache_key = "fomc_surprise"
+    if cache_key in CACHE and time.time() - CACHE_TIMES.get(cache_key, 0) < 3600:
+        return CACHE[cache_key]
+
+    try:
+        key = get_next_newsapi_key()
+        url = f"https://newsapi.org/v2/everything?q=fomc+federal+reserve+surprise+rate&pageSize=10&apiKey={key}"
+        r = requests.get(url, timeout=10)
+        if r.status_code == 200:
+            articles = r.json().get('articles', [])
+
+            hawkish_count = 0
+            dovish_count = 0
+
+            for a in articles:
+                title = a.get('title', '').lower()
+                desc = a.get('description', '').lower()
+                text = title + ' ' + desc
+
+                if any(kw in text for kw in ['hawkish', 'raise', 'tighten', 'surprise hike']):
+                    hawkish_count += 1
+                if any(kw in text for kw in ['dovish', 'cut', 'ease', 'surprise cut']):
+                    dovish_count += 1
+
+            if hawkish_count > dovish_count * 2:
+                signal = "HAWKISH_SURPRISE"
+                impact = -15
+            elif dovish_count > hawkish_count * 2:
+                signal = "DOVISH_SURPRISE"
+                impact = 15
+            else:
+                signal = "NO_SURPRISE"
+                impact = 0
+
+            result = {
+                "indicator": "FOMC",
+                "signal": signal,
+                "impact": impact,
+                "hawkish_articles": hawkish_count,
+                "dovish_articles": dovish_count,
+                "direction": "HAWKISH" if impact < 0 else "DOVISH" if impact > 0 else "NEUTRAL"
+            }
+
+            CACHE[cache_key] = result
+            CACHE_TIMES[cache_key] = time.time()
+            return result
+    except:
+        pass
+
+    return {"indicator": "FOMC", "impact": 0, "direction": "NEUTRAL"}
+
 # ================= АНАЛИЗ ИЗ MT5 =================
 def analyze_from_mt5(mt5_features: Dict[str, Any]) -> Optional[Dict[str, Any]]:
     try:
         score = 50.0
-        veto = False
+        now = datetime.utcnow()
+        hour = now.hour
+        weekday = now.weekday()
+
+        # В часы выхода важных данных (12-14 UTC) — ожидаем сюрпризов
+        if hour in [12, 13, 14]:
+            if weekday in [2, 3, 4]:  # Ср-Пт — дни NFP/CPI
+                score -= 10
 
         rsi = mt5_features.get('H1_rsi', 50)
-        if isinstance(rsi, (int, float)):
-            if rsi > 85:
-                veto = True
-                regime = "BUBBLE"
-                score = 90
-            elif rsi > 75:
-                regime = "EUPHORIA"
-                score = 70
-            elif rsi < 20:
-                regime = "CAPITULATION"
-                score = 10
-            else:
-                regime = "NORMAL"
+        atr = mt5_features.get('H1_atr_pct', 1)
 
-        atr_pct = mt5_features.get('H1_atr_pct', 1)
-        if isinstance(atr_pct, (int, float)) and atr_pct > 4:
-            regime = "VOLATILE"
-            score = max(score, 60)
+        if isinstance(rsi, (int, float)) and isinstance(atr, (int, float)):
+            if atr > 2 and rsi > 70:
+                score += 15
+            elif atr > 2 and rsi < 30:
+                score -= 15
+
+        score = max(0, min(100, score))
+
+        if score > 60:
+            direction, confidence = "LONG", score / 100
+        elif score < 40:
+            direction, confidence = "SHORT", (100 - score) / 100
+        else:
+            direction, confidence = "WAIT", 0.0
 
         return {
-            "regime": regime,
-            "regime_score": score,
-            "veto": veto,
-            "euphoria_index": score,
+            "direction": direction,
+            "confidence": round(confidence, 4),
+            "surprise_index": score,
             "source": "MT5"
         }
     except:
         return None
 
 # ================= ГЛАВНЫЙ СИГНАЛ =================
-def get_regime_signal(symbol: str = "XAU/USD") -> Dict[str, Any]:
+def get_macro_surprise_signal() -> Dict[str, Any]:
     start = time.time()
 
     # Проверка MT5
-    if symbol in FEATURES_STORE:
-        fs = FEATURES_STORE[symbol]
-        age = time.time() - fs.get("timestamp", 0)
-        if age < MT5_MAX_AGE_SEC:
-            mt5_features = fs.get("features", {})
-            if mt5_features:
-                mt5_result = analyze_from_mt5(mt5_features)
-                if mt5_result:
-                    direction = "WAIT" if mt5_result["veto"] else "NEUTRAL"
-                    result = {
-                        "space": "space_28_regime",
-                        "timestamp": int(time.time()),
-                        "symbol": symbol,
-                        "signal": {
-                            "direction": direction,
-                            "confidence": mt5_result["regime_score"] / 100,
-                            "veto": mt5_result["veto"]
-                        },
-                        "regime_analysis": {
-                            "regime": mt5_result["regime"],
-                            "regime_score": mt5_result["regime_score"],
-                            "euphoria_index": mt5_result["euphoria_index"],
-                            "veto": mt5_result["veto"]
-                        },
-                        "data_source": "MT5",
-                        "meta": {"latency_ms": int((time.time() - start) * 1000)}
-                    }
-                    send_to_arbiter(result)
-                    print(f"🫧 REGIME {symbol}: {mt5_result['regime']} | Veto={mt5_result['veto']} (MT5)")
-                    return result
+    for symbol in SYMBOLS:
+        if symbol in FEATURES_STORE:
+            fs = FEATURES_STORE[symbol]
+            age = time.time() - fs.get("timestamp", 0)
+            if age < MT5_MAX_AGE_SEC:
+                mt5_features = fs.get("features", {})
+                if mt5_features:
+                    mt5_result = analyze_from_mt5(mt5_features)
+                    if mt5_result and mt5_result["confidence"] > 0.3:
+                        result = {
+                            "space": "space_29_macro_surprise",
+                            "timestamp": int(time.time()),
+                            "signals": {
+                                s: {"direction": mt5_result["direction"], "confidence": mt5_result["confidence"]}
+                                for s in SYMBOLS
+                            },
+                            "surprise_index": mt5_result["surprise_index"],
+                            "data_source": "MT5",
+                            "meta": {"latency_ms": int((time.time() - start) * 1000)}
+                        }
+                        send_to_arbiter(result)
+                        print(f"📈 MACRO SURPRISE: {mt5_result['direction']} | Index={mt5_result['surprise_index']} (MT5)")
+                        return result
 
     # Fallback
-    df = fetch_historical(symbol, "1h", 200)
-    regime_data = detect_market_regime(df, symbol)
-
-    direction = "WAIT" if regime_data["veto"] else "NEUTRAL"
-    confidence = regime_data["regime_score"] / 100
-
+    analysis = analyze_macro_surprises()
     latency = int((time.time() - start) * 1000)
 
     result = {
-        "space": "space_28_regime",
+        "space": "space_29_macro_surprise",
         "timestamp": int(time.time()),
-        "symbol": symbol,
-        "signal": {
-            "direction": direction,
-            "confidence": round(confidence, 4),
-            "veto": regime_data["veto"],
-            "veto_reason": "BUBBLE_DETECTED" if regime_data["veto"] else None
+        "signals": {
+            s: {
+                "direction": analysis['direction'],
+                "confidence": analysis['confidence']
+            }
+            for s in SYMBOLS
         },
-        "regime_analysis": regime_data,
-        "data_source": "API",
+        "surprise_analysis": {
+            "surprise_index": analysis['surprise_index'],
+            "market_regime": analysis['market_regime'],
+            "surprises": analysis['surprises'],
+            "positive_impact": analysis['positive_impact'],
+            "negative_impact": analysis['negative_impact']
+        },
+        "data_source": "FRED+NEWS",
         "meta": {"latency_ms": latency}
     }
 
     send_to_arbiter(result)
-    print(f"🫧 REGIME v1 {symbol}: {regime_data['regime']} | Euphoria={regime_data['euphoria_index']:.0f} | Veto={regime_data['veto']}")
+    print(f"📈 MACRO SURPRISE v1: Index={analysis['surprise_index']:.0f} | Regime={analysis['market_regime']} | Surprises={len(analysis['surprises'])}")
     return result
 
 # ================= KEEP-ALIVE =================
@@ -378,57 +418,37 @@ def keep_alive():
 threading.Thread(target=keep_alive, daemon=True).start()
 
 # ================= FASTAPI =================
-app = FastAPI(title="TOMIRIS SPACE 28 v1.0 — MARKET REGIME & BUBBLE DETECTOR")
+app = FastAPI(title="TOMIRIS SPACE 29 v1.0 — MACRO SURPRISE INDEX")
 
 @app.get("/health")
 @app.head("/health")
 async def health():
     return {
-        "space": "Space 28 - Market Regime & Bubble Detector v1.0",
+        "space": "Space 29 - Macro Surprise Index v1.0",
         "status": "operational",
         "symbols": SYMBOLS,
-        "features": ["Euphoria Index", "NVT Ratio", "RSI Extremes", "Bubble VETO"],
-        "bubble_history": len(BUBBLE_HISTORY)
+        "indicators": list(CONSENSUS.keys()),
+        "features": ["CPI Surprise", "NFP Surprise", "FOMC Surprise", "Citigroup Surprise Index"]
     }
 
 @app.get("/consilium")
-async def consilium(symbol: str = Query("XAU/USD")):
-    if symbol not in SYMBOLS:
-        return {"error": f"Unsupported: {symbol}"}
-    return get_regime_signal(symbol)
-
-@app.get("/regime/{symbol}")
-async def regime(symbol: str):
-    if symbol not in SYMBOLS:
-        return {"error": f"Unsupported: {symbol}"}
-    df = fetch_historical(symbol)
-    if df is None:
-        return {"error": "no_data"}
-    return detect_market_regime(df, symbol)
-
-@app.get("/euphoria/{symbol}")
-async def euphoria(symbol: str):
-    if symbol not in SYMBOLS:
-        return {"error": f"Unsupported: {symbol}"}
-    df = fetch_historical(symbol)
-    if df is None:
-        return {"error": "no_data"}
-    return {
-        "symbol": symbol,
-        "euphoria_index": calculate_euphoria_index(df)
-    }
+async def consilium():
+    return get_macro_surprise_signal()
 
-@app.get("/nvt/{symbol}")
-async def nvt(symbol: str):
-    if symbol not in ["ETH/USD", "SOL/USD"]:
-        return {"error": "NVT доступен только для крипты"}
-    df = fetch_historical(symbol)
-    if df is None:
-        return {"error": "no_data"}
-    return {
-        "symbol": symbol,
-        "nvt_score": calculate_nvt_ratio(df)
-    }
+@app.get("/surprise_index")
+async def surprise_index():
+    return analyze_macro_surprises()
+
+@app.get("/fomc")
+async def fomc():
+    return fetch_fomc_surprise()
+
+@app.get("/indicator/{name}")
+async def indicator(name: str):
+    consensus = CONSENSUS.get(name.upper())
+    if consensus is None:
+        return {"error": f"Unknown: {name}", "available": list(CONSENSUS.keys())}
+    return {"indicator": name, "consensus": consensus}
 
 @app.post("/features")
 async def receive_features(data: Dict[str, Any]):
@@ -441,6 +461,6 @@ async def receive_features(data: Dict[str, Any]):
     print(f"📥 MT5 {symbol}: {len(data.get('features', {}))} признаков")
     return {"status": "ok"}
 
-print(f"🚀 SPACE 28 v1.0 — MARKET REGIME & BUBBLE DETECTOR ЗАПУЩЕН!")
-print(f"🫧 Детектор: Euphoria Index | NVT Ratio | RSI | Режим рынка | ВЕТО при пузыре")
+print(f"🚀 SPACE 29 v1.0 — MACRO SURPRISE INDEX ЗАПУЩЕН!")
+print(f"📈 Анализ: CPI | NFP | FOMC | GDP | ISM | Сравнение с консенсусом")
 print(f"✅ Готов к бою!")