Delete server_H.py

server_H.py

@@ -1,550 +0,0 @@
-"""
-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,
-    "risk_warning":       str,
-    "vault_status":       str,
-    "kelly_fraction":     float,
-    "kelly_continuous":   float,
-    "zscore":             float,
-    "monte_carlo_ruin_prob": float,
-    "panic_activated":    bool,
-    "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,
-    "_shadow":            bool,
-  }
-"""
-
-import os, time, asyncio, threading, math, collections
-from fastapi import FastAPI, Request
-from fastapi.responses import JSONResponse
-import httpx
-
-try:
-    import numpy as np
-    _NP = True
-except ImportError:
-    _NP = False
-
-app = FastAPI(title="Cerebro H — RiskAuditor v22.5 APEX Elastic")
-
-# ── 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}"
-BITNET_TIMEOUT = float(os.environ.get("BITNET_TIMEOUT", "15.0"))
-CACHE_TTL      = float(os.environ.get("CACHE_TTL",      "30.0"))
-
-KELLY_MAX      = float(os.environ.get("KELLY_MAX",     "0.05"))
-KELLY_MIN      = float(os.environ.get("KELLY_MIN",     "0.005"))
-ZSCORE_PANIC   = float(os.environ.get("ZSCORE_PANIC",  "2.5"))
-PDT_LIMIT      = int(os.environ.get("PDT_LIMIT",       "3"))
-PDT_MIN_BALANCE= float(os.environ.get("PDT_MIN",       "25000"))
-MC_SCENARIOS   = int(os.environ.get("MC_SCENARIOS",    "100"))
-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 (idéntico a v21.5) ─────────────────────────────────────────
-_bitnet_client: httpx.AsyncClient | None = None
-
-def _get_client() -> httpx.AsyncClient:
-    global _bitnet_client
-    if _bitnet_client is None or _bitnet_client.is_closed:
-        _bitnet_client = httpx.AsyncClient(
-            base_url=BITNET_BASE,
-            timeout=httpx.Timeout(connect=3.0, read=BITNET_TIMEOUT,
-                                  write=3.0, pool=2.0),
-            limits=httpx.Limits(max_connections=8, max_keepalive_connections=4),
-        )
-    return _bitnet_client
-
-async def _bitnet_single_token(prompt: str) -> str:
-    payload = {
-        "prompt":       prompt,
-        "n_predict":    2,
-        "temperature":  0.0,
-        "stream":       False,
-        "cache_prompt": False,
-        "stop":         ["\n", "<|im_end|>", "<|end_of_text|>", "<|eot_id|>"],
-    }
-    try:
-        resp = await _get_client().post("/completion", json=payload)
-        resp.raise_for_status()
-        return resp.json().get("content", "").strip()
-    except Exception:
-        return ""
-
-# ── 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:
-    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)
-        smoothed = prev * 0.30 + new_temp * 0.70
-        _risk_temp[sym] = round(smoothed, 4)
-        return smoothed
-
-def _temp_to_token(temp: float) -> str:
-    if temp < 0.35: return "G"
-    if temp < 0.65: return "Y"
-    return "R"
-
-def _ring_push(sym: str, token: str):
-    with _thermo_lock:
-        if sym not in _token_ring:
-            _token_ring[sym] = collections.deque(maxlen=10)
-        _token_ring[sym].append(token)
-
-def _ring_last5_all_R(sym: str) -> bool:
-    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 (idéntico a v21.5) ──────────────────────────────────────────
-_shadow: dict = {}
-_shadow_lock = threading.Lock()
-
-def _shadow_get(sym: str, current_temp: float) -> str | None:
-    with _shadow_lock:
-        e = _shadow.get(sym)
-    if not e:
-        return None
-    age = time.time() - e["ts"]
-    ttl = 10.0 if current_temp > 0.65 else (20.0 if current_temp > 0.35 else CACHE_TTL)
-    if age > ttl:
-        return None
-    if abs(current_temp - e["temp"]) > 0.15:
-        return None
-    return e["token"]
-
-def _shadow_set(sym: str, token: str, temp: float):
-    with _shadow_lock:
-        _shadow[sym] = {"token": token, "ts": time.time(), "temp": temp}
-
-
-# ══════════════════════════════════════════════════════════════════════════════
-#  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:
-        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)
-        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)
-    ruin = 0
-    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
-    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))]
-    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)
-
-
-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()
-    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,
-        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)
-
-    if zscore >= ZSCORE_PANIC:
-        size  = round(size * 0.50, 2)
-        kelly = round(kelly * 0.50, 6)
-
-    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)
-
-    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}{anchor_note} | {math_ms:.1f}ms")
-
-    return {
-        "pdt_ok": pdt_ok, "size_usd": size, "risk_warning": risk,
-        "vault_status": vault, "kelly_fraction": kelly,
-        "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 BitNet (mismo formato que v21.5) ───────────────────────────────────
-_SYS_H = (
-    "<|im_start|>system\n"
-    "Risk level G/Y/R. Respond ONLY with one letter.\n"
-    "G=green free trade. Y=yellow scalps only. R=red block all.\n"
-    "<|im_end|>\n"
-    "<|im_start|>user\n"
-)
-
-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},"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"]
-    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["kelly_fraction"] = 0.0
-        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,
-    })
-    return out
-
-
-# ── 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)
-    llm_ms = (time.perf_counter() - t0) * 1000
-    token  = raw.strip()[:1].upper()
-    if token in ("G", "Y", "R"):
-        _shadow_set(sym, token, temp)
-        _ring_push(sym, token)
-        print(f"[H/LLM] {sym}: token={token} temp={temp:.2f} | {llm_ms:.1f}ms (shadow actualizado)")
-    else:
-        print(f"[H/LLM-GUARD] {sym}: token inválido='{raw[:10]}' → shadow preservado")
-
-
-# ── 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   = _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
-
-    if is_shadow:
-        token  = cached_token
-        llm_ms = 0.0
-        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, 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, 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"):
-            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} 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": "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):
-    try:
-        payload = await request.json()
-    except Exception:
-        return JSONResponse({"error": "JSON inválido"}, status_code=400)
-    result = await _audit(payload)
-    return JSONResponse(result)
-
-print("[H] ✅ RiskAuditor v22.5 APEX — Elastic Payload + Degraded-Online + Anchor-Kelly")