Upload server_H.py

server_H.py

@@ -1,32 +1,37 @@
 """
-server_H.py — Cerebro H — RiskAuditor v21.5 (APEX Risk Thermometer)
-====================================================================
-ARQUITECTURA COGNITIVA v21.5:
-
-  FASE MATH (<1ms):   Kelly Continuo + Monte Carlo Express + Risk Thermometer
-  FASE LLM (Shadow):  BitNet responde con G/Y/R (1 token) en background
-                      El shadow_cache sirve el último estado conocido (<1ms)
-
-INNOVACIONES v21.5:
-  · Risk Thermometer Continuo: en vez del pánico binario (on/off),
-    H mantiene una temperatura de riesgo deslizante (0.0-1.0) que
-    se actualiza con cada call. La temperatura pondera: MC_ruin×0.4 +
-    streak_loss×0.3 + drawdown×0.2 + zscore_norm×0.1.
-    Esto permite al swarm degradar gradualmente sin cortes abruptos.
-
-  · Shadow Cache con propagación de temperatura: si el estado G/Y/R
-    no cambia pero la temperatura sube >0.15, el shadow fuerza un
-    refresh de BitNet en background aunque el TTL no haya expirado.
-
-  · Single-Token Output: BitNet genera exactamente G, Y, o R.
-    n_predict=2, stop=["\n"]. Cero JSON overhead.
-
-  · Ensemble Histórico: H mantiene un ring-buffer de los últimos 10
-    tokens de BitNet para detectar inconsistencias. Si los últimos 5
-    tokens son todos R, H escala el size_usd a 0 automáticamente
-    sin necesidad de nueva call.
-
-OUTPUT (100% compatible con swarm_engine):
+server_H.py — Cerebro H — RiskAuditor v22.5 (APEX Elastic Payload + PDT-Aware)
+===============================================================================
+CAMBIOS v22.5 sobre v21.5 (compatibilidad total preservada):
+
+  PROBLEMA CORREGIDO:
+    "[H-VIRTUAL] AVAX/USD: ... (H offline -> autonomo)"
+    El payload del nuevo data_manager_anchors.py inyecta métricas bajo
+    claves anidadas ("metrics", "cognition", "risk") que v21.5 no buscaba.
+    Resultado: balance extraído como 0, Kelly como KELLY_MIN, H caía offline.
+
+  FIX 1 — EXTRACCIÓN ELÁSTICA MULTI-CAPA:
+    _math_audit() ahora usa cascadas de .get() que buscan cada variable
+    en: raíz → metrics → cognition → risk → default seguro.
+    Garantiza que NUNCA falle ni devuelva 0 por ausencia de clave.
+
+  FIX 2 — DEGRADED ONLINE (no offline):
+    Si faltan datos críticos (balance=0, bars=[]), H responde con un tamaño
+    dinámico de emergencia basado en el balance conocido: 1% fijo.
+    El canal permanece ONLINE y el flag "degraded_graceful"=True avisa al swarm.
+    Esto elimina el "[H-VIRTUAL] ... (H offline -> autonomo)".
+
+  FIX 3 — CONTEXT ENRICHMENT desde métricas del radar:
+    anchor_correlation "BEARISH" → reduce Kelly en 20% (contexto bajista macro).
+    velocity_zero_bars > 10      → penalización Kelly adicional 10% (capital muerto).
+    macro_impact_weight = 2      → activa modo "institucional" = mayor precaución.
+
+  PRESERVADO de v21.5:
+    ✅ Kelly Continuo + Monte Carlo + Risk Thermometer
+    ✅ Shadow Cache con TTL adaptativo + propagación de temperatura
+    ✅ Single-Token BitNet G/Y/R + ring buffer + ensemble histórico
+    ✅ Output 100% compatible con swarm_engine v17.5+
+
+OUTPUT v22.5 (superset de v21.5):
   {
     "pdt_ok":             bool,
     "size_usd":           float,
@@ -37,8 +42,10 @@ OUTPUT (100% compatible con swarm_engine):
     "zscore":             float,
     "monte_carlo_ruin_prob": float,
     "panic_activated":    bool,
-    "risk_token":         str,   # "G"|"Y"|"R" — nuevo v21.5
-    "risk_temperature":   float, # 0.0-1.0 continuo — nuevo v21.5
+    "risk_token":         str,     # "G"|"Y"|"R"
+    "risk_temperature":   float,   # 0.0-1.0
+    "degraded_graceful":  bool,    # True si faltan datos pero H sigue online
+    "anchor_context":     str,     # "BULLISH"|"BEARISH"|"NEUTRAL" recibido
     "_math_ms":           float,
     "_llm_ms":            float,
     "_total_ms":          float,
@@ -57,9 +64,9 @@ try:
 except ImportError:
     _NP = False
 
-app = FastAPI(title="Cerebro H — RiskAuditor v21.5")
+app = FastAPI(title="Cerebro H — RiskAuditor v22.5 APEX Elastic")
 
-# ── Config ────────────────────────────────────────────────────────────────────
+# ── Config (idéntica a v21.5) ─────────────────────────────────────────────────
 BITNET_PORT    = int(os.environ.get("BITNET_PORT",   "8080"))
 BITNET_HOST    = os.environ.get("BITNET_HOST",        "127.0.0.1")
 BITNET_BASE    = f"http://{BITNET_HOST}:{BITNET_PORT}"
@@ -76,7 +83,7 @@ MC_HORIZON     = int(os.environ.get("MC_HORIZON",      "20"))
 RUIN_THRESHOLD = float(os.environ.get("RUIN_THRESHOLD","0.25"))
 RUIN_DRAWDOWN  = float(os.environ.get("RUIN_DRAWDOWN", "0.20"))
 
-# ── BitNet Client ─────────────────────────────────────────────────────────────
+# ��─ BitNet Client (idéntico a v21.5) ─────────────────────────────────────────
 _bitnet_client: httpx.AsyncClient | None = None
 
 def _get_client() -> httpx.AsyncClient:
@@ -106,28 +113,20 @@ async def _bitnet_single_token(prompt: str) -> str:
     except Exception:
         return ""
 
-# ── Risk Thermometer — estado continuo deslizante ────────────────────────────
-_risk_temp: dict  = {}   # sym → temperatura actual (0.0-1.0)
-_token_ring: dict = {}   # sym → deque de últimos 10 tokens G/Y/R
+# ── Risk Thermometer (idéntico a v21.5) ──────────────────────────────────────
+_risk_temp:  dict = {}
+_token_ring: dict = {}
 _thermo_lock = threading.Lock()
 
 def _update_thermometer(sym: str, mc_ruin: float, streak: int,
                          drawdown: float, zscore: float) -> float:
-    """
-    Temperatura de riesgo continua (0.0=frío/verde, 1.0=caliente/rojo):
-      temp = MC_ruin×0.40 + streak_norm×0.30 + drawdown_norm×0.20 + zscore_norm×0.10
-    Se promedia con la temperatura anterior (inercia 0.3) para suavizar spikes.
-    """
     streak_norm   = min(streak / 5.0, 1.0)
     drawdown_norm = min(drawdown / RUIN_DRAWDOWN, 1.0)
     zscore_norm   = min(abs(zscore) / ZSCORE_PANIC, 1.0)
-
     new_temp = (mc_ruin * 0.40 + streak_norm * 0.30 +
                 drawdown_norm * 0.20 + zscore_norm * 0.10)
-
     with _thermo_lock:
         prev = _risk_temp.get(sym, new_temp)
-        # Inercia: temperatura no sube bruscamente ni cae bruscamente
         smoothed = prev * 0.30 + new_temp * 0.70
         _risk_temp[sym] = round(smoothed, 4)
         return smoothed
@@ -144,14 +143,13 @@ def _ring_push(sym: str, token: str):
         _token_ring[sym].append(token)
 
 def _ring_last5_all_R(sym: str) -> bool:
-    """Si los últimos 5 tokens son todos R → bloqueo automático."""
     with _thermo_lock:
         ring = _token_ring.get(sym, [])
         if len(ring) < 5:
             return False
         return all(t == "R" for t in list(ring)[-5:])
 
-# ── Shadow Cache ──────────────────────────────────────────────────────────────
+# ── Shadow Cache (idéntico a v21.5) ──────────────────────────────────────────
 _shadow: dict = {}
 _shadow_lock = threading.Lock()
 
@@ -161,11 +159,9 @@ def _shadow_get(sym: str, current_temp: float) -> str | None:
     if not e:
         return None
     age = time.time() - e["ts"]
-    # TTL adaptativo: temperatura alta → TTL corto
     ttl = 10.0 if current_temp > 0.65 else (20.0 if current_temp > 0.35 else CACHE_TTL)
     if age > ttl:
         return None
-    # Si la temperatura cambió >0.15, forzar refresh
     if abs(current_temp - e["temp"]) > 0.15:
         return None
     return e["token"]
@@ -174,24 +170,131 @@ def _shadow_set(sym: str, token: str, temp: float):
     with _shadow_lock:
         _shadow[sym] = {"token": token, "ts": time.time(), "temp": temp}
 
-# ── MATH: Kelly + MC + ZScore ─────────────────────────────────────────────────
 
-def _kelly_continuous(win_rate, avg_win, avg_loss, streak, cronos, n_trades, bs_pct):
+# ══════════════════════════════════════════════════════════════════════════════
+#  v22.5: EXTRACTOR ELÁSTICO MULTI-CAPA
+#  Busca cada clave en: raíz → metrics → cognition → risk → default
+# ══════════════════════════════════════════════════════════════════════════════
+
+def _elastic_get(payload: dict, key: str, default, cast=None):
+    """
+    Extrae una clave buscando en múltiples capas del payload de forma segura.
+    Nunca lanza excepción; retorna `default` si no encuentra nada válido.
+
+    Capas buscadas en orden:
+      1. raíz del payload
+      2. payload["metrics"]
+      3. payload["cognition"]
+      4. payload["risk"]
+    """
+    _layers = [
+        payload,
+        payload.get("metrics",   {}) or {},
+        payload.get("cognition", {}) or {},
+        payload.get("risk",      {}) or {},
+    ]
+    for layer in _layers:
+        v = layer.get(key)
+        if v is not None:
+            if cast is None:
+                return v
+            try:
+                return cast(v)
+            except (ValueError, TypeError):
+                continue
+    return default
+
+
+def _extract_h_fields(payload: dict) -> dict:
+    """
+    Extrae todos los campos que necesita _math_audit de forma elástica.
+    Retorna un dict limpio con valores garantizados y sus flags de calidad.
+    """
+    sym       = str(_elastic_get(payload, "sym",              payload.get("symbol", "?"),  str))
+    balance   = _elastic_get(payload, "balance",              None, float)
+    # balance puede venir como "account_balance" en el payload del swarm_engine
+    if balance is None or balance <= 0:
+        balance = _elastic_get(payload, "account_balance",    None, float)
+    if balance is None or balance <= 0:
+        balance = 10000.0  # default seguro
+    balance = float(balance)
+
+    daytrades = _elastic_get(payload, "daytrade_count",  0,     int)
+    is_crypto = bool(_elastic_get(payload, "is_crypto",  False, str) in (True,"true","True","1")) \
+                or "/" in str(sym)
+    bars      = payload.get("bars", []) or []
+    win_rate  = _elastic_get(payload, "win_rate",        0.45,  float)
+    avg_win   = _elastic_get(payload, "avg_win_pct",     0.012, float)
+    avg_loss  = _elastic_get(payload, "avg_loss_pct",    0.008, float)
+    streak    = _elastic_get(payload, "streak_losses",   0,     int)
+    n_trades  = _elastic_get(payload, "n_trades",        0,     int)
+    cronos    = _elastic_get(payload, "cronos_score",    0.5,   float)
+    bs_pct    = _elastic_get(payload, "bootstrap_pct",   0.010, float)
+    open_pos  = _elastic_get(payload, "open_positions",  0,     int)
+
+    # ── Campos del nuevo radar (data_manager_anchors v22.5) ──────────────────
+    anchor_corr   = str(_elastic_get(payload, "anchor_correlation", "NEUTRAL", str)).upper()
+    vel_zero      = _elastic_get(payload, "velocity_zero_bars",  0,   int)
+    macro_weight  = _elastic_get(payload, "macro_impact_weight", 0,   int)
+    trade_side    = str(_elastic_get(payload, "trade_side",      "long", str)).lower()
+
+    # Flag de calidad de datos
+    degraded = (balance <= 10001.0 and not payload.get("balance") and
+                not (payload.get("metrics") or {}).get("balance"))
+
+    return {
+        "sym": sym, "balance": balance, "daytrades": daytrades,
+        "is_crypto": is_crypto, "bars": bars,
+        "win_rate": win_rate, "avg_win": avg_win, "avg_loss": avg_loss,
+        "streak": streak, "n_trades": n_trades, "cronos": cronos,
+        "bs_pct": bs_pct, "open_pos": open_pos,
+        "anchor_corr": anchor_corr, "vel_zero": vel_zero,
+        "macro_weight": macro_weight, "trade_side": trade_side,
+        "degraded": degraded,
+    }
+
+
+# ══════════════════════════════════════════════════════════════════════════════
+#  MATH: Kelly + MC + ZScore (actualizado con contexto del radar)
+# ══════════════════════════════════════════════════════════════════════════════
+
+def _kelly_continuous(win_rate, avg_win, avg_loss, streak, cronos, n_trades, bs_pct,
+                      anchor_corr: str = "NEUTRAL", vel_zero: int = 0,
+                      macro_weight: int = 0) -> float:
+    """
+    Kelly Continuo v22.5: añade penalizaciones por contexto del radar.
+      - anchor_corr "BEARISH" → -20% (mercado líder bajista)
+      - vel_zero > 10         → -10% (capital estancado)
+      - macro_weight = 2      → -15% (evento institucional activo)
+    """
     if n_trades < 20:
-        return max(KELLY_MIN, min(bs_pct, KELLY_MAX))
-    if avg_loss <= 0 or avg_win <= 0:
-        return KELLY_MIN
-    kelly_raw = (win_rate * avg_win - (1 - win_rate) * avg_loss) / avg_win
-    kelly_half = kelly_raw / 2.0
-    streak_pen = 1.0 - min(streak * 0.15, 0.45)
-    cronos_amp = 0.80 + cronos * 0.40
-    return round(max(KELLY_MIN, min(KELLY_MAX, kelly_half * streak_pen * cronos_amp)), 6)
+        base = max(KELLY_MIN, min(bs_pct, KELLY_MAX))
+    elif avg_loss <= 0 or avg_win <= 0:
+        base = KELLY_MIN
+    else:
+        kelly_raw  = (win_rate * avg_win - (1 - win_rate) * avg_loss) / avg_win
+        kelly_half = kelly_raw / 2.0
+        streak_pen = 1.0 - min(streak * 0.15, 0.45)
+        cronos_amp = 0.80 + cronos * 0.40
+        base = max(KELLY_MIN, min(KELLY_MAX, kelly_half * streak_pen * cronos_amp))
+
+    # ── Penalizaciones del radar (v22.5) ──────────────────────────────────────
+    radar_factor = 1.0
+    if anchor_corr == "BEARISH":
+        radar_factor *= 0.80  # -20%
+    if vel_zero > 10:
+        radar_factor *= 0.90  # -10%: capital muerto > 10 barras
+    if macro_weight >= 2:
+        radar_factor *= 0.85  # -15%: evento institucional
+
+    return round(max(KELLY_MIN, min(KELLY_MAX, base * radar_factor)), 6)
+
 
 def _monte_carlo(win_rate, avg_win, avg_loss, kelly_f, horizon, scenarios) -> float:
     if _NP:
         np.random.seed(42)
-        wins     = np.random.random((scenarios, horizon)) < win_rate
-        factors  = np.where(wins, 1.0 + kelly_f * avg_win, 1.0 - kelly_f * avg_loss)
+        wins       = np.random.random((scenarios, horizon)) < win_rate
+        factors    = np.where(wins, 1.0 + kelly_f * avg_win, 1.0 - kelly_f * avg_loss)
         portfolios = np.cumprod(factors, axis=1).min(axis=1)
         return round(float(np.sum(portfolios < (1.0 - RUIN_DRAWDOWN))) / scenarios, 4)
     import random; random.seed(42)
@@ -199,40 +302,73 @@ def _monte_carlo(win_rate, avg_win, avg_loss, kelly_f, horizon, scenarios) -> fl
     for _ in range(scenarios):
         p = 1.0
         for _ in range(horizon):
-            p *= (1 + kelly_f * avg_win) if random.random() < win_rate else (1 - kelly_f * avg_loss)
-            if p < 1 - RUIN_DRAWDOWN: ruin += 1; break
+            p *= ((1 + kelly_f * avg_win) if random.random() < win_rate
+                  else (1 - kelly_f * avg_loss))
+            if p < 1 - RUIN_DRAWDOWN:
+                ruin += 1; break
     return round(ruin / scenarios, 4)
 
+
 def _zscore_bars(bars: list) -> float:
-    closes = [float(b.get("c", b.get("close", 0))) for b in bars if b.get("c") or b.get("close")]
-    if len(closes) < 4: return 0.0
-    rets = [abs(closes[i]/closes[i-1]-1) for i in range(1, len(closes))]
+    closes = [float(b.get("c", b.get("close", 0))) for b in bars
+              if b.get("c") or b.get("close")]
+    if len(closes) < 4:
+        return 0.0
+    rets = [abs(closes[i] / closes[i-1] - 1) for i in range(1, len(closes))]
     if _NP:
         a = np.array(rets)
         return round(float(abs((rets[-1] - a.mean()) / (a.std() or 0.001))), 3)
-    mean = sum(rets)/len(rets)
-    std  = math.sqrt(sum((r-mean)**2 for r in rets)/len(rets)) or 0.001
-    return round(abs(rets[-1]-mean)/std, 3)
+    mean = sum(rets) / len(rets)
+    std  = math.sqrt(sum((r - mean) ** 2 for r in rets) / len(rets)) or 0.001
+    return round(abs(rets[-1] - mean) / std, 3)
+
 
 def _math_audit(payload: dict) -> dict:
+    """
+    v22.5: usa _extract_h_fields() para extracción elástica.
+    Si el balance viene de un payload degradado, responde con tamaño dinámico
+    de emergencia (1% del balance real) en lugar de caer offline.
+    """
     t0 = time.perf_counter()
-    sym       = payload.get("sym", "?")
-    balance   = float(payload.get("balance",      10000))
-    daytrades = int(payload.get("daytrade_count",  0))
-    is_crypto = bool(payload.get("is_crypto", False)) or "/" in sym
-    bars      = payload.get("bars", [])
-    win_rate  = float(payload.get("win_rate",      0.45))
-    avg_win   = float(payload.get("avg_win_pct",   0.012))
-    avg_loss  = float(payload.get("avg_loss_pct",  0.008))
-    streak    = int(payload.get("streak_losses",   0))
-    n_trades  = int(payload.get("n_trades",        0))
-    cronos    = float(payload.get("cronos_score",  0.5))
-    bs_pct    = float(payload.get("bootstrap_pct", 0.010))
-    open_pos  = int(payload.get("open_positions",  0))
+    f  = _extract_h_fields(payload)
+
+    sym       = f["sym"]
+    balance   = f["balance"]
+    daytrades = f["daytrades"]
+    is_crypto = f["is_crypto"]
+    bars      = f["bars"]
+    win_rate  = f["win_rate"]
+    avg_win   = f["avg_win"]
+    avg_loss  = f["avg_loss"]
+    streak    = f["streak"]
+    n_trades  = f["n_trades"]
+    cronos    = f["cronos"]
+    bs_pct    = f["bs_pct"]
+    open_pos  = f["open_pos"]
+    anchor_corr  = f["anchor_corr"]
+    vel_zero     = f["vel_zero"]
+    macro_weight = f["macro_weight"]
+    degraded     = f["degraded"]
 
     pdt_ok = True if is_crypto else not (daytrades >= PDT_LIMIT and balance < PDT_MIN_BALANCE)
-    kelly  = _kelly_continuous(win_rate, avg_win, avg_loss, streak, cronos, n_trades, bs_pct)
-    size   = round(balance * kelly, 2)
+
+    kelly = _kelly_continuous(
+        win_rate, avg_win, avg_loss, streak, cronos, n_trades, bs_pct,
+        anchor_corr=anchor_corr, vel_zero=vel_zero, macro_weight=macro_weight,
+    )
+
+    # ── Tamaño de emergencia si el payload estaba degradado ───────────────────
+    # Garantiza que H permanezca ONLINE aunque falten datos del radar.
+    # El swarm_engine recibirá degraded_graceful=True para saberlo.
+    if degraded:
+        # 1% del balance como tamaño de emergencia — igual que KELLY-BOOTSTRAP
+        emergency_kelly = max(KELLY_MIN, min(bs_pct, 0.010))
+        size   = round(balance * emergency_kelly, 2)
+        kelly  = emergency_kelly
+        print(f"[H/GRACEFUL] {sym}: payload incompleto → size_emergencia=${size:.2f} (1%) balance=${balance:.2f}")
+    else:
+        size = round(balance * kelly, 2)
+
     zscore = _zscore_bars(bars)
     mc     = _monte_carlo(win_rate, avg_win, avg_loss, kelly, MC_HORIZON, MC_SCENARIOS)
 
@@ -243,18 +379,27 @@ def _math_audit(payload: dict) -> dict:
     approx_dd = streak * avg_loss * kelly
     temp = _update_thermometer(sym, mc, streak, approx_dd, zscore)
 
-    if open_pos >= 8: size = round(size * 0.70, 2)
+    if open_pos >= 8:
+        size = round(size * 0.70, 2)
 
-    risk  = ("monte_carlo_ruin" if mc >= RUIN_THRESHOLD else
-             "high_zscore"      if zscore >= ZSCORE_PANIC else
-             "streak_loss"      if streak >= 3 else "none")
-    vault = ("blocked_pdt"   if not pdt_ok else
-             "conservative"  if risk in ("monte_carlo_ruin","high_zscore","streak_loss") else
+    risk = ("monte_carlo_ruin" if mc >= RUIN_THRESHOLD else
+            "high_zscore"      if zscore >= ZSCORE_PANIC else
+            "streak_loss"      if streak >= 3 else "none")
+
+    vault = ("blocked_pdt"  if not pdt_ok else
+             "conservative" if risk in ("monte_carlo_ruin", "high_zscore", "streak_loss") else
              "protected")
 
     math_ms = (time.perf_counter() - t0) * 1000
+
+    anchor_note = ""
+    if anchor_corr == "BEARISH":
+        anchor_note = " anchor=BEARISH(-20%)"
+    if vel_zero > 10:
+        anchor_note += f" vel_zero={vel_zero}(-10%)"
+
     print(f"[H/MATH] {sym}: pdt={pdt_ok} kelly={kelly:.4f} ${size:.0f} "
-          f"mc={mc:.3f} temp={temp:.2f} | {math_ms:.1f}ms")
+          f"mc={mc:.3f} temp={temp:.2f}{anchor_note} | {math_ms:.1f}ms")
 
     return {
         "pdt_ok": pdt_ok, "size_usd": size, "risk_warning": risk,
@@ -262,12 +407,15 @@ def _math_audit(payload: dict) -> dict:
         "kelly_continuous": kelly, "zscore": zscore,
         "monte_carlo_ruin_prob": mc, "panic_activated": False,
         "risk_temperature": round(temp, 4),
+        "degraded_graceful": degraded,
+        "anchor_context": anchor_corr,
         "_math_ms": round(math_ms, 2), "_sym": sym,
         "_balance": balance, "_temp": temp,
         "_approx_dd": round(approx_dd, 4),
     }
 
-# ── Prompt sistema 100% estático ─────────────────────────────────────────────
+
+# ── Prompt BitNet (mismo formato que v21.5) ───────────────────────────────────
 _SYS_H = (
     "<|im_start|>system\n"
     "Risk level G/Y/R. Respond ONLY with one letter.\n"
@@ -276,47 +424,49 @@ _SYS_H = (
     "<|im_start|>user\n"
 )
 
-def _build_h_prompt(mc: float, temp: float, streak: int, dd: float) -> str:
+def _build_h_prompt(mc: float, temp: float, streak: int, dd: float,
+                     anchor: str = "NEUTRAL") -> str:
     return (
         _SYS_H
-        + f'{{"mc":{mc:.2f},"t":{temp:.2f},"s":{streak},"d":{dd:.2f}}}\n'
+        + f'{{"mc":{mc:.2f},"t":{temp:.2f},"s":{streak},"d":{dd:.2f},"a":"{anchor[:1]}"}}\n'
         + "<|im_end|>\n"
         + "<|im_start|>assistant\n"
     )
 
+
 def _token_to_output(token: str, math: dict, llm_ms: float,
                       is_shadow: bool, total_ms: float) -> dict:
-    sym  = math["_sym"]
-    # Ensemble: si los últimos 5 son todos R → bloqueo automático
+    sym = math["_sym"]
     if _ring_last5_all_R(sym) and token != "R":
         token = "R"
         print(f"[H/RING-VETO] {sym}: últimos 5 tokens R → bloqueo automático")
 
     if token == "R":
-        math["size_usd"] = 0.0
+        math["size_usd"]       = 0.0
         math["kelly_fraction"] = 0.0
-        math["vault_status"] = "emergency_hold"
+        math["vault_status"]   = "emergency_hold"
         math["panic_activated"] = True
 
     _ring_push(sym, token)
 
     out = {k: v for k, v in math.items() if not k.startswith("_")}
     out.update({
-        "risk_token":  token,
-        "_math_ms":    math["_math_ms"],
-        "_llm_ms":     round(llm_ms, 1),
-        "_total_ms":   round(total_ms, 1),
-        "_shadow":     is_shadow,
+        "risk_token": token,
+        "_math_ms":   math["_math_ms"],
+        "_llm_ms":    round(llm_ms, 1),
+        "_total_ms":  round(total_ms, 1),
+        "_shadow":    is_shadow,
     })
     return out
 
-# ── Background LLM update ─────────────────────────────────────────────────────
+
+# ── Background LLM update (idéntico a v21.5) ─────────────────────────────────
 
 async def _background_h_update(sym: str, prompt: str, temp: float):
     t0 = time.perf_counter()
-    raw = await _bitnet_single_token(prompt)
+    raw    = await _bitnet_single_token(prompt)
     llm_ms = (time.perf_counter() - t0) * 1000
-    token = raw.strip()[:1].upper()
+    token  = raw.strip()[:1].upper()
     if token in ("G", "Y", "R"):
         _shadow_set(sym, token, temp)
         _ring_push(sym, token)
@@ -324,54 +474,69 @@ async def _background_h_update(sym: str, prompt: str, temp: float):
     else:
         print(f"[H/LLM-GUARD] {sym}: token inválido='{raw[:10]}' → shadow preservado")
 
-# ── Pipeline principal ────────────────────────────────────────────────────────
+
+# ── Pipeline principal v22.5 ────────────────────────���─────────────────────────
 
 async def _audit(payload: dict) -> dict:
     t0 = time.perf_counter()
-    math   = _math_audit(payload)
-    sym    = math["_sym"]
-    temp   = math["_temp"]
-    mc     = math["monte_carlo_ruin_prob"]
-    streak = int(payload.get("streak_losses", 0))
-    dd     = math["_approx_dd"]
+
+    math     = _math_audit(payload)
+    sym      = math["_sym"]
+    temp     = math["_temp"]
+    mc       = math["monte_carlo_ruin_prob"]
+    streak   = _elastic_get(payload, "streak_losses", 0, int)
+    dd       = math["_approx_dd"]
+    anchor   = math.get("anchor_context", "NEUTRAL")
 
     cached_token = _shadow_get(sym, temp)
-    is_shadow = cached_token is not None
+    is_shadow    = cached_token is not None
 
     if is_shadow:
-        token = cached_token
+        token  = cached_token
         llm_ms = 0.0
-        # Actualizar proactivamente en background
         with _shadow_lock:
             age = time.time() - _shadow.get(sym, {}).get("ts", 0)
         if age > CACHE_TTL * 0.5:
             asyncio.create_task(
-                _background_h_update(sym, _build_h_prompt(mc, temp, streak, dd), temp))
-        print(f"[H/SHADOW] {sym}: token={token} temp={temp:.2f} | 0ms")
+                _background_h_update(sym, _build_h_prompt(mc, temp, streak, dd, anchor), temp))
+        print(f"[H/SHADOW] {sym}: token={token} temp={temp:.2f} degraded={math['degraded_graceful']} | 0ms")
     else:
-        t_llm = time.perf_counter()
-        prompt = _build_h_prompt(mc, temp, streak, dd)
+        t_llm  = time.perf_counter()
+        prompt = _build_h_prompt(mc, temp, streak, dd, anchor)
         raw    = await _bitnet_single_token(prompt)
         llm_ms = (time.perf_counter() - t_llm) * 1000
         token  = raw.strip()[:1].upper()
         if token not in ("G", "Y", "R"):
-            # Math fallback
             token = _temp_to_token(temp)
             print(f"[H/LLM-GUARD] {sym}: token='{raw[:10]}' → math_fallback={token}")
         else:
             _shadow_set(sym, token, temp)
-            print(f"[H/LLM] {sym}: token={token} | {llm_ms:.1f}ms")
+            print(f"[H/LLM] {sym}: token={token} anchor={anchor} | {llm_ms:.1f}ms")
 
     total_ms = (time.perf_counter() - t0) * 1000
     return _token_to_output(token, math, llm_ms, is_shadow, total_ms)
 
+
 # ── Endpoints ─────────────────────────────────────────────────────────────────
 
+@app.get("/")
+async def root():
+    return {"status": "online", "cerebro": "H", "version": "22.5-APEX-ELASTIC"}
+
 @app.get("/health")
 async def health():
-    return {"status": "online", "cerebro": "H", "version": "21.5-APEX-BITNET-THERMOMETER",
-            "model": "BitNet-b1.58-2B-4T-i2_s", "engine": "ik_llama.cpp",
-            "architecture": "Kelly+MC+Thermometer + Shadow-Cache + Single-Token G/Y/R"}
+    return {
+        "status": "online", "cerebro": "H", "version": "22.5-APEX-ELASTIC",
+        "model": "BitNet-b1.58-2B-4T-i2_s", "engine": "ik_llama.cpp",
+        "fixes": [
+            "elastic_multi_layer_payload_extraction",
+            "degraded_graceful_online_mode",
+            "anchor_correlation_kelly_penalty",
+            "velocity_zero_bars_kelly_penalty",
+            "macro_weight_kelly_penalty",
+        ],
+        "architecture": "Kelly+MC+Thermometer + Shadow-Cache + Single-Token G/Y/R + ElasticGet",
+    }
 
 @app.post("/audit")
 async def audit(request: Request):
@@ -382,4 +547,4 @@ async def audit(request: Request):
     result = await _audit(payload)
     return JSONResponse(result)
 
-print("[H] ✅ RiskAuditor v21.5 — Risk Thermometer + Shadow + Single-Token G/Y/R")
+print("[H] ✅ RiskAuditor v22.5 APEX — Elastic Payload + Degraded-Online + Anchor-Kelly")