Upload 2 files

server_H.py

@@ -1,536 +1,377 @@
 """
-server_H.py — Cerebro H — RiskAuditor v3.0 (APEX Kelly-Continuo + MonteCarlo)
-===============================================================================
-v3.0 — Remodelación según Plan Maestro APEX-ASYMMETRIC SWARM (Fase 4):
-
-ARQUITECTURA LLM+MATH (filosofía de Cerebro A):
-
-  FASE MATH (<1ms) — 100% matemática, nunca necesita LLM:
-    · Kelly Fraccional CONTINUO (numpy): no es Kelly clásico escalar.
-      Calcula f* = max(0, W/L - (1-W)/G) ajustado por:
-        - Racha de pérdidas consecutivas (penalización progresiva)
-        - Cronos score (amplificador de señal)
-        - Fase de bootstrap (<20 trades: override conservador 1%)
-    · Simulación Monte Carlo Express (<1ms, 100 escenarios numpy):
-        - Simula 100 trayectorias de P&L usando win_rate + avg_win/loss
-        - Calcula probabilidad de ruina: P(drawdown > 20% en 20 trades)
-        - Si P(ruina) > umbral crítico → activa bandera de alerta
-    · Z-Score de volatilidad reciente (para calibrar Kelly).
-    · Toda la matemática en <1ms gracias a numpy vectorizado.
-
-  FASE LLM (Interruptor de Pánico) — SOLO en condición CRÍTICA:
-    · El LLM NO calcula Kelly ni Monte Carlo. Solo actúa como veto.
-    · Se activa ÚNICAMENTE si: P(ruina) > PANIC_RUIN_THRESHOLD AND
-      drawdown_capital > PANIC_DRAWDOWN_PCT.
-    · Pregunta: "¿Inyecto más capital ahora dado este riesgo acumulado?"
-    · Output: {"veto": true|false, "motivo": "string"}
-    · Si veto=true → size_usd=0, vault_status="emergency_hold".
-    · Si LLM falla → math conservador decide (sin inyección extra).
-
-  REGLAS:
-    · 95% de las peticiones: Math responde en <1ms, LLM nunca se invoca.
-    · 5% (crisis): LLM actúa como cortocircuito de emergencia.
-
-OUTPUT (100% compatible con swarm_engine v16):
+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):
   {
-    "pdt_ok":          bool,
-    "size_usd":        float,
-    "risk_warning":    "none|streak_loss|high_zscore|monte_carlo_ruin|emergency",
-    "vault_status":    "protected|conservative|blocked_pdt|emergency_hold",
-    "kelly_fraction":  float,
-    "zscore":          float,
-    # Nuevos v3.0:
-    "monte_carlo_ruin_prob": float,  # P(ruina en 20 trades)
-    "kelly_continuous":      float,  # Kelly fraccional continuo ajustado
-    "panic_activated":       bool,   # True si LLM fue invocado
-    "_math_ms":  float,
-    "_llm_ms":   float,
-    "_total_ms": float,
+    "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" — nuevo v21.5
+    "risk_temperature":   float, # 0.0-1.0 continuo — nuevo v21.5
+    "_math_ms":           float,
+    "_llm_ms":            float,
+    "_total_ms":          float,
+    "_shadow":            bool,
   }
-
-TELEMETRÍA: [H/MATH] ms | [H/LLM] ms | [H/TOTAL] ms
 """
 
-import os, json, re, time, threading, math
+import os, time, asyncio, threading, math, collections
 from fastapi import FastAPI, Request
 from fastapi.responses import JSONResponse
-import httpx  # BitNet v6.0
+import httpx
 
 try:
     import numpy as np
-    _NP_OK = True
+    _NP = True
 except ImportError:
-    _NP_OK = False
+    _NP = False
 
-app = FastAPI(title="Cerebro H — RiskAuditor v3.0 Kelly+MonteCarlo")
+app = FastAPI(title="Cerebro H — RiskAuditor v21.5")
 
 # ── Config ──────────────────────────────────────────────────────��─────────────
-MODEL_PATH  = os.environ.get("MODEL_PATH", "/models/ggml-model-i2_s.gguf")
-N_CTX       = int(os.environ.get("N_CTX",       "128"))
-N_THREADS   = int(os.environ.get("N_THREADS",    "2"))
-N_BATCH     = int(os.environ.get("N_BATCH",     "64"))
-
-# ── BitNet Infrastructure v6.0 ───────────────────────────────────────────────
 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", "30.0"))
-LLM_MAX_TOKENS = int(os.environ.get("LLM_MAX_TOKENS", "48"))
-
-_bitnet_client = None
-
-def _get_bitnet_client():
+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 ─────────────────────────────────────────────────────────────
+_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(BITNET_TIMEOUT),
-            limits=httpx.Limits(max_connections=4, max_keepalive_connections=2),
+            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_infer(prompt_text: str, max_tokens: int = 48) -> dict:
-    client = _get_bitnet_client()
-    payload = {"prompt": prompt_text, "n_predict": max_tokens, "temperature": 0.05,
-               "top_p": 0.95, "top_k": 5, "repeat_penalty": 1.0, "stream": False,
-               "stop": ["<|eot_id|>", "<|end_of_text|>"]}
+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 client.post("/completion", json=payload)
+        resp = await _get_client().post("/completion", json=payload)
         resp.raise_for_status()
-        return {"raw": resp.json().get("content", "").strip(), "ok": True}
-    except httpx.TimeoutException:
-        return {"raw": "", "ok": False, "error": "TIMEOUT"}
-    except Exception as e:
-        return {"raw": "", "ok": False, "error": str(e)[:80]}
-
-
-# Parámetros Kelly
-KELLY_MAX_FRACTION  = float(os.environ.get("KELLY_MAX",      "0.05"))
-KELLY_MIN_FRACTION  = 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"))
-
-# Monte Carlo
-MC_SCENARIOS        = int(os.environ.get("MC_SCENARIOS",      "100"))
-MC_HORIZON          = int(os.environ.get("MC_HORIZON",        "20"))   # trades hacia adelante
-PANIC_RUIN_THRESHOLD = float(os.environ.get("PANIC_RUIN_THRESHOLD", "0.30"))  # 30% prob ruina
-PANIC_DRAWDOWN_PCT   = float(os.environ.get("PANIC_DRAWDOWN_PCT",   "0.15"))  # 15% drawdown
-RUIN_DRAWDOWN_DEF    = float(os.environ.get("RUIN_DRAWDOWN_DEF",    "0.20"))  # 20% = "ruina"
-
-# Cache
-CACHE_TTL = float(os.environ.get("CACHE_TTL", "30.0"))
-
-# ── BitNet v6.0: modelo servido por llama-server externo ─────────────────────
-# llm = Llama(...) eliminado — inferencias via HTTP a BITNET_BASE
-print(f"[H] ✅ RiskAuditor v3.0 Kelly+MonteCarlo+BitNet — n_ctx={N_CTX}")
-print(f"[H] BitNet server: {BITNET_BASE} | numpy={'✅' if _NP_OK else '⚠️'} | MC={MC_SCENARIOS}")
-
-# ── Cache ──────────────────────────────────────────────────────────────────────
-_H_CACHE: dict = {}
-_H_LOCK = threading.Lock()
-
-def _cache_get(key: str):
-    with _H_LOCK:
-        e = _H_CACHE.get(key)
-        if e and (time.time() - e["ts"]) < CACHE_TTL:
-            return {**e["r"], "_cached": True}
-    return None
-
-def _cache_set(key: str, r: dict):
-    with _H_LOCK:
-        _H_CACHE[key] = {"r": r, "ts": time.time()}
-
-
-# ══════════════════════════════════════════════════════════════════════════════
-#  KELLY FRACCIONAL CONTINUO (numpy)
-# ══════════════════════════════════════════════════════════════════════════════
-
-def _kelly_continuous(win_rate: float, avg_win: float, avg_loss: float,
-                       streak_losses: int, cronos: float,
-                       n_trades: int, bootstrap_size: float) -> float:
-    """
-    Kelly Fraccional Continuo:
-      f* = (W × G - (1-W) × L) / G   donde G=avg_win, L=avg_loss, W=win_rate
+        return resp.json().get("content", "").strip()
+    except Exception:
+        return ""
 
-    Ajustes:
-      1. Half-Kelly: f* /= 2 (conservador estándar)
-      2. Streak penalty: -15% por cada pérdida consecutiva (cap -45%)
-      3. Cronos amplifier: factor 0.8-1.2 según signal strength
-      4. Bootstrap override: < 20 trades → retornar bootstrap_size fijo
+# ── 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
+_thermo_lock = threading.Lock()
 
-    Retorna: fracción de Kelly ajustada (0.005 - KELLY_MAX_FRACTION)
+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
+
+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:
+    """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: 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 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"]
+
+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):
     if n_trades < 20:
-        # Fase bootstrap: tamaño fijo conservador
-        return max(KELLY_MIN_FRACTION, min(bootstrap_size, KELLY_MAX_FRACTION))
-
+        return max(KELLY_MIN, min(bs_pct, KELLY_MAX))
     if avg_loss <= 0 or avg_win <= 0:
-        return KELLY_MIN_FRACTION
-
-    # Kelly continuo: (W×G - (1-W)×L) / G
+        return KELLY_MIN
     kelly_raw = (win_rate * avg_win - (1 - win_rate) * avg_loss) / avg_win
-
-    # Half-Kelly (conservador)
     kelly_half = kelly_raw / 2.0
-
-    # Penalización por racha de pérdidas consecutivas
-    streak_pen = 1.0 - min(streak_losses * 0.15, 0.45)  # -15%/pérdida, max -45%
-
-    # Amplificador Cronos (0.80-1.20)
+    streak_pen = 1.0 - min(streak * 0.15, 0.45)
     cronos_amp = 0.80 + cronos * 0.40
-
-    kelly_adj = kelly_half * streak_pen * cronos_amp
-
-    return round(max(KELLY_MIN_FRACTION, min(KELLY_MAX_FRACTION, kelly_adj)), 6)
-
-
-# ══════════════════════════════════════════════════════════════════════════════
-#  SIMULACIÓN MONTE CARLO EXPRESS (<1ms, 100 escenarios)
-# ══════════════════════════════════════════════════════════════════════════════
-
-def _monte_carlo_ruin(win_rate: float, avg_win_pct: float, avg_loss_pct: float,
-                       kelly_frac: float, balance: float,
-                       horizon: int = 20, scenarios: int = 100) -> float:
-    """
-    Simula `scenarios` trayectorias de P&L sobre `horizon` trades.
-
-    Cada trade:
-      P(win) = win_rate  → portfolio × (1 + kelly_frac × avg_win_pct)
-      P(loss)= 1-win_rate → portfolio × (1 - kelly_frac × avg_loss_pct)
-
-    Ruina = drawdown > RUIN_DRAWDOWN_DEF del balance inicial.
-
-    Retorna: P(ruina) entre 0.0 y 1.0.
-    Target: <1ms con numpy.
-    """
-    if _NP_OK:
-        # Vectorizado: scenarios × horizon matriz de resultados
-        np.random.seed(42)  # reproducible (mismo seed por balance/win_rate)
-        wins = np.random.random((scenarios, horizon)) < win_rate
-
-        win_factor  = 1.0 + kelly_frac * avg_win_pct
-        loss_factor = 1.0 - kelly_frac * avg_loss_pct
-
-        # Multiplicadores: (scenarios, horizon)
-        factors  = np.where(wins, win_factor, loss_factor)
-        # Portfolio acumulado: producto acumulado de factores
-        portfolios = np.cumprod(factors, axis=1)  # (scenarios, horizon)
-
-        # Mínimo de cada trayectoria (peor punto)
-        min_portfolios = portfolios.min(axis=1)   # (scenarios,)
-
-        # Ruina: mínimo < (1 - RUIN_DRAWDOWN_DEF)
-        ruina_threshold = 1.0 - RUIN_DRAWDOWN_DEF
-        ruin_count      = float(np.sum(min_portfolios < ruina_threshold))
-        return round(ruin_count / scenarios, 4)
-
-    else:
-        # Fallback puro-Python (más lento pero funcional)
-        import random
-        random.seed(42)
-        ruin_count = 0
-        for _ in range(scenarios):
-            port = 1.0
-            for _ in range(horizon):
-                if random.random() < win_rate:
-                    port *= (1.0 + kelly_frac * avg_win_pct)
-                else:
-                    port *= (1.0 - kelly_frac * avg_loss_pct)
-                if port < (1.0 - RUIN_DRAWDOWN_DEF):
-                    ruin_count += 1
-                    break
-        return round(ruin_count / scenarios, 4)
-
-
-# ══════════════════════════════════════════════════════════════════════════════
-#  Z-SCORE DE VOLATILIDAD (heredado de v2.0, mejorado)
-# ══════════════════════════════════════════════════════════════════════════════
-
-def _compute_zscore(bars: list) -> float:
-    if len(bars) < 5:
-        return 0.0
-    closes = []
-    for b in bars:
-        c = b.get("c") or b.get("close") or 0.0
-        if c > 0:
-            closes.append(float(c))
-    if len(closes) < 4:
-        return 0.0
-    returns = [abs(closes[i] / closes[i-1] - 1) for i in range(1, len(closes))]
-    if _NP_OK:
-        ret_arr = np.array(returns)
-        mean_r  = float(np.mean(ret_arr))
-        std_r   = float(np.std(ret_arr)) or 0.001
-        return round(float(abs((returns[-1] - mean_r) / std_r)), 3)
-    else:
-        mean_r = sum(returns) / len(returns)
-        std_r  = math.sqrt(sum((r - mean_r)**2 for r in returns) / len(returns)) or 0.001
-        return round(abs(returns[-1] - mean_r) / std_r, 3)
-
-
-# ══════════════════════════════════════════════════════════════════════════════
-#  FASE MATH COMPLETA
-# ══════════════════════════════════════════════════════════════════════════════
-
-def _math_audit_v3(payload: dict) -> dict:
-    """
-    Auditoría de riesgo completa en <1ms:
-      1. PDT check
-      2. Kelly Fraccional Continuo (numpy)
-      3. Monte Carlo Express (100 escenarios, <1ms)
-      4. Z-Score de volatilidad
-      5. Risk Warning + Vault Status
-    """
+    return round(max(KELLY_MIN, min(KELLY_MAX, kelly_half * streak_pen * cronos_amp)), 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:
     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))
+
+    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)
+    zscore = _zscore_bars(bars)
+    mc     = _monte_carlo(win_rate, avg_win, avg_loss, kelly, MC_HORIZON, MC_SCENARIOS)
 
-    sym          = payload.get("sym",             "?")
-    balance      = float(payload.get("balance",   10000))
-    open_pos     = int(payload.get("open_positions", 0))
-    daytrades    = int(payload.get("daytrade_count",  0))
-    trade_type   = payload.get("trade_type",      "scalp")
-    g_conf       = float(payload.get("g_confidence", 0.5))
-    cronos       = float(payload.get("cronos_score",  0.5))
-    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_loss  = int(payload.get("streak_losses",  0))
-    n_trades     = int(payload.get("n_trades",    len(payload.get("trade_history", []))))
-    kelly_override = payload.get("kelly_override")
-    bootstrap_pct  = float(payload.get("bootstrap_pct", 0.010))
-
-    # ── PDT check ─────────────────────────────────────────────────────────────
-    if is_crypto:
-        pdt_ok = True
-    else:
-        pdt_ok = not (daytrades >= PDT_LIMIT and balance < PDT_MIN_BALANCE)
-
-    # ── Kelly Fraccional Continuo ─────────────────────────────────────────────
-    if kelly_override is not None:
-        size_usd  = float(kelly_override)
-        kelly_f   = size_usd / balance if balance > 0 else KELLY_MIN_FRACTION
-        kelly_cont = kelly_f
-    else:
-        kelly_cont = _kelly_continuous(
-            win_rate, avg_win, avg_loss,
-            streak_loss, cronos, n_trades, bootstrap_pct)
-        size_usd = round(balance * kelly_cont, 2)
+    if zscore >= ZSCORE_PANIC:
+        size  = round(size * 0.50, 2)
+        kelly = round(kelly * 0.50, 6)
 
-    # ── Z-Score ────────────────────────────────────────────────────────────────
-    zscore = _compute_zscore(bars)
+    approx_dd = streak * avg_loss * kelly
+    temp = _update_thermometer(sym, mc, streak, approx_dd, zscore)
 
-    # ── Monte Carlo Express ────────────────────────────────────────────────────
-    mc_ruin = _monte_carlo_ruin(
-        win_rate, avg_win, avg_loss,
-        kelly_cont, balance,
-        horizon=MC_HORIZON, scenarios=MC_SCENARIOS)
+    if open_pos >= 8: size = round(size * 0.70, 2)
 
-    # ── Ajuste por Z-Score elevado ─────────────────────────────────────────────
-    if zscore >= ZSCORE_PANIC:
-        size_usd = round(size_usd * 0.50, 2)   # reducir 50% en pánico
-        kelly_cont = round(kelly_cont * 0.50, 6)
-
-    # ── Risk Warning ──────────────────────────────────────────────────────────
-    if mc_ruin >= PANIC_RUIN_THRESHOLD:
-        risk = "monte_carlo_ruin"
-    elif zscore >= ZSCORE_PANIC:
-        risk = "high_zscore"
-    elif streak_loss >= 3:
-        risk = "streak_loss"
-    elif open_pos >= 8:
-        risk = "slots_high"
-        size_usd = round(size_usd * 0.70, 2)
-    else:
-        risk = "none"
-
-    # ── Vault Status ──────────────────────────────────────────────────────────
-    if not pdt_ok:
-        vault = "blocked_pdt"
-    elif risk in ("monte_carlo_ruin", "high_zscore"):
-        vault = "conservative"
-    elif risk == "streak_loss":
-        vault = "conservative"
-    else:
-        vault = "protected"
-
-    # ── Detectar si se necesita LLM (Interruptor de Pánico) ───────────────────
-    # Calcular drawdown aproximado desde balance (necesitamos historial para exacto)
-    # Usamos Kelly fraction como proxy del tamaño relativo de las pérdidas recientes
-    approx_drawdown = streak_loss * avg_loss * kelly_cont
-    needs_llm = (mc_ruin >= PANIC_RUIN_THRESHOLD and
-                 approx_drawdown >= PANIC_DRAWDOWN_PCT and
-                 not is_crypto and  # crypto: pdt_ok=True siempre
-                 pdt_ok and n_trades >= 10)  # mínimo 10 trades de historial
+    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
-
-    print(f"[H/MATH] {sym}: pdt={pdt_ok} kelly={kelly_cont:.4f} "
-          f"size=${size_usd:.2f} z={zscore:.2f} mc_ruin={mc_ruin:.3f} "
-          f"risk={risk} | {math_ms:.1f}ms")
+    print(f"[H/MATH] {sym}: pdt={pdt_ok} kelly={kelly:.4f} ${size:.0f} "
+          f"mc={mc:.3f} temp={temp:.2f} | {math_ms:.1f}ms")
 
     return {
-        "pdt_ok":                pdt_ok,
-        "size_usd":              size_usd,
-        "risk_warning":          risk,
-        "vault_status":          vault,
-        "kelly_fraction":        round(kelly_cont, 6),
-        "kelly_continuous":      round(kelly_cont, 6),
-        "zscore":                zscore,
-        "monte_carlo_ruin_prob": mc_ruin,
-        "panic_activated":       False,
-        "needs_llm":             needs_llm,
-        "cerebro":               "H",
-        "_math_ms":              round(math_ms, 2),
-        "_llm_ms":               0.0,
-        # Para el LLM si se activa
-        "_sym":                  sym,
-        "_balance":              balance,
-        "_approx_drawdown":      round(approx_drawdown, 4),
+        "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),
+        "_math_ms": round(math_ms, 2), "_sym": sym,
+        "_balance": balance, "_temp": temp,
+        "_approx_dd": round(approx_dd, 4),
     }
 
-
-# ══════════════════════════════════════════════════════════════════════════════
-#  FASE LLM — Interruptor de Pánico (SOLO si P(ruina) crítica)
-# ══════════════════════════════════════════════════════════════════════════════
-
-async def _llm_panic_switch(math_result: dict) -> dict:
-    """
-    El LLM actúa como cortocircuito de emergencia.
-    Solo se invoca cuando:
-      P(ruina_MC) > PANIC_RUIN_THRESHOLD AND drawdown_approx > PANIC_DRAWDOWN_PCT
-
-    Pregunta: ¿Veto la inyección de capital en este trade dado el riesgo?
-    Output: {"veto": true|false, "motivo": "string"}
-    """
-    t0_llm = time.perf_counter()
-
-    sym      = math_result.get("_sym", "?")
-    balance  = math_result.get("_balance", 10000)
-    mc_ruin  = math_result.get("monte_carlo_ruin_prob", 0.0)
-    drawdown = math_result.get("_approx_drawdown", 0.0)
-    risk     = math_result.get("risk_warning", "none")
-    streak   = math_result.get("risk_warning",  "")
-
-    llm_prompt = (
-        "<|im_start|>system\n"
-        'Risk switch. SOLO JSON: {"veto":true|false,"motivo":"<5w"}.\n'
-        "veto=true=detener inyección capital. Sin pensar.\n"
-        "<|im_end|>\n"
-        "<|im_start|>user\n"
-        f'{{"s":"{sym[:8]}","mc":{mc_ruin:.3f},"dd":{drawdown:.3f},'
-        f'"bal":{balance:.0f},"r":"{risk[:6]}"}}\n'
-        "<|im_end|>\n"
-        "<|im_start|>assistant\n{"
+# ── Prompt sistema 100% estático ─────────────────────────────────────────────
+_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) -> str:
+    return (
+        _SYS_H
+        + f'{{"mc":{mc:.2f},"t":{temp:.2f},"s":{streak},"d":{dd:.2f}}}\n'
+        + "<|im_end|>\n"
+        + "<|im_start|>assistant\n"
     )
 
-    try:
-        result = await _bitnet_infer(llm_prompt)
-        raw_out_text = result.get("raw", "")
-
-        llm_ms = (time.perf_counter() - t0_llm) * 1000
-        raw    = "{" + raw_out_text
-
-        m = re.search(r'\{[^{}]*"veto"\s*:\s*(true|false)[^{}]*\}', raw, re.IGNORECASE)
-        if m:
-            parsed = json.loads(m.group())
-            veto   = bool(parsed.get("veto", False))
-            motivo = str(parsed.get("motivo", ""))[:60]
-            print(f"[H/LLM] {sym}: PANIC veto={veto} motivo='{motivo}' | {llm_ms:.1f}ms")
-            return {"veto": veto, "motivo": motivo, "_llm_ms": round(llm_ms, 1)}
-
-        # Parseo parcial
-        veto = "true" in raw.lower()
-        print(f"[H/LLM] {sym}: partial veto={veto} | {llm_ms:.1f}ms")
-        return {"veto": veto, "motivo": "partial_parse", "_llm_ms": round(llm_ms, 1)}
-
-    except Exception as e:
-        llm_ms = (time.perf_counter() - t0_llm) * 1000
-        print(f"[H/LLM-ERR] {sym}: {type(e).__name__}: {str(e)[:50]} | {llm_ms:.1f}ms → no_veto")
-        # Fallback conservador: si LLM falla en pánico, NO vetar (evitar falsos negativos)
-        return {"veto": False, "motivo": "llm_error_no_veto", "_llm_ms": round(llm_ms, 1)}
-
+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
+    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 ─────────────────────────────────────────────────────
+
+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 (Math → LLM opcional)
-# ══════════════════════════════════════════════════════════════════════════════
+# ── Pipeline principal ────────────────────────────────────────────────────────
 
 async def _audit(payload: dict) -> dict:
     t0 = time.perf_counter()
-
-    # ── FASE 1: MATH ───────��──────────────────────────────────────────────────
-    result  = _math_audit_v3(payload)
-    math_ms = result["_math_ms"]
-    sym     = result.get("_sym", "?")
-
-    llm_ms = 0.0
-
-    # ── FASE 2: LLM Interruptor de Pánico (solo si condición crítica) ─────────
-    if result.get("needs_llm", False):
-        llm_result = await _llm_panic_switch(result)
-        llm_ms     = llm_result.get("_llm_ms", 0.0)
-
-        if llm_result.get("veto", False):
-            # LLM vetó — bloquear inyección de capital
-            result["size_usd"]        = 0.0
-            result["kelly_fraction"]  = 0.0
-            result["kelly_continuous"] = 0.0
-            result["vault_status"]    = "emergency_hold"
-            result["risk_warning"]    = "emergency"
-            result["panic_activated"] = True
-            print(f"[H/PANIC-VETO] {sym}: inyección BLOQUEADA por LLM | mc={result['monte_carlo_ruin_prob']:.3f}")
+    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"]
+
+    cached_token = _shadow_get(sym, temp)
+    is_shadow = cached_token is not None
+
+    if is_shadow:
+        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")
+    else:
+        t_llm = time.perf_counter()
+        prompt = _build_h_prompt(mc, temp, streak, dd)
+        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:
-            result["panic_activated"] = False
-            print(f"[H/PANIC-ALLOWED] {sym}: inyección PERMITIDA a pesar de mc_ruin | LLM: {llm_result.get('motivo','')}")
-
-    # Limpiar campos internos antes de retornar
-    result.pop("needs_llm", None)
-    result.pop("_sym", None)
-    result.pop("_balance", None)
-    result.pop("_approx_drawdown", None)
+            _shadow_set(sym, token, temp)
+            print(f"[H/LLM] {sym}: token={token} | {llm_ms:.1f}ms")
 
     total_ms = (time.perf_counter() - t0) * 1000
-    result["_llm_ms"]   = round(llm_ms, 1)
-    result["_total_ms"] = round(total_ms, 1)
-
-    print(f"[H/TOTAL] {sym}: math={math_ms:.1f}ms llm={llm_ms:.1f}ms total={total_ms:.1f}ms")
-    return result
-
-
-# ── Endpoints FastAPI ─────────────────────────────────────────────────────────
-
-@app.get("/")
-async def root():
-    return {
-        "status":  "online",
-        "agent":   "RiskAuditor",
-        "cerebro": "H",
-        "version": "3.0-APEX-Kelly+MonteCarlo",
-    }
+    return _token_to_output(token, math, llm_ms, is_shadow, total_ms)
 
+# ── Endpoints ─────────────────────────────────────────────────────────────────
 
 @app.get("/health")
 async def health():
-    return {
-        "status":       "online",
-        "agent":        "RiskAuditor",
-        "cerebro":      "H",
-        "version":      "3.0-APEX-Kelly+MonteCarlo",
-        "model": "BitNet-b1.58-2B-4T-i2_s (ik_llama.cpp)", "bitnet_server": BITNET_BASE,
-        "numpy_ok":     _NP_OK,
-        "mc_scenarios": MC_SCENARIOS,
-        "mc_horizon":   MC_HORIZON,
-        "kelly_max":    KELLY_MAX_FRACTION,
-        "zscore_panic": ZSCORE_PANIC,
-        "agents":       ["RiskAuditor"],
-        "architecture": {
-            "math":    "Kelly-Continuo + MC-100 + ZScore (<1ms, 95% requests)",
-            "llm":     "Interruptor de Pánico (solo P_ruin>30% AND drawdown>15%)",
-            "trigger": f"mc_ruin>{PANIC_RUIN_THRESHOLD} AND drawdown>{PANIC_DRAWDOWN_PCT}",
-        },
-    }
-
+    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"}
 
 @app.post("/audit")
 async def audit(request: Request):
@@ -538,14 +379,7 @@ async def audit(request: Request):
         payload = await request.json()
     except Exception:
         return JSONResponse({"error": "JSON inválido"}, status_code=400)
-
-    sym    = payload.get("sym", "?")
-    cache_key = f"{sym}:{float(payload.get('balance', 0)):.0f}"
-    cached = _cache_get(cache_key)
-    if cached:
-        print(f"[H/CACHE] {sym}: hit")
-        return JSONResponse(cached)
-
     result = await _audit(payload)
-    _cache_set(cache_key, result)
     return JSONResponse(result)
+
+print("[H] ✅ RiskAuditor v21.5 — Risk Thermometer + Shadow + Single-Token G/Y/R")

start_H.sh

@@ -2,20 +2,33 @@
 set -e
 MODEL_PATH="${MODEL_PATH:-/models/ggml-model-i2_s.gguf}"
 BITNET_PORT="${BITNET_PORT:-8080}"
-N_CTX="${N_CTX:-2048}"
+N_CTX="${N_CTX:-512}"
 N_THREADS="${N_THREADS:-2}"
 PORT="${PORT:-7860}"
+SERVER="server_H"
 
-echo "[START] Cerebro RiskAuditor v3.0 (BitNet REAL)"
+echo "[START] Cerebro H v21.5 (BitNet REAL)"
 [ ! -f "$MODEL_PATH" ] && echo "[START] FATAL: modelo no encontrado" && exit 1
 echo "[START] Modelo: $(du -h $MODEL_PATH | cut -f1)"
 
 BITNET_LOG="/tmp/bitnet.log"
 > "$BITNET_LOG"
 
+# Anti-alucinación v21.5:
+#   --cache-prompt-ram 0  → desactiva cache RAM (evita bug {{{{ de ik_llama.cpp)
+#   --jinja               → habilita chat template nativo Llama-3/ChatML
+#   --no-mmap             → evita lecturas corruptas por memory-map
+#   --ctx-size 512        → n_ctx pequeño para single-token output (<1ms evaluación)
 llama-server \
-    --model "$MODEL_PATH" --host 127.0.0.1 --port "$BITNET_PORT" \
-    --ctx-size "$N_CTX" --threads "$N_THREADS" --gpu-layers 0 \
+    --model "$MODEL_PATH" \
+    --host 127.0.0.1 \
+    --port "$BITNET_PORT" \
+    --ctx-size "$N_CTX" \
+    --threads "$N_THREADS" \
+    --gpu-layers 0 \
+    --no-mmap \
+    --jinja \
+    --cache-prompt-ram 0 \
     2>&1 | tee "$BITNET_LOG" | sed 's/^/[BITNET] /' &
 LLAMA_PID=$!
 
@@ -29,4 +42,4 @@ done
 [ $ELAPSED -ge $MAX_WAIT ] && echo "[START] FATAL: timeout" && exit 1
 echo "[START] BitNet ONLINE — iniciando FastAPI..."
 
-exec uvicorn server_H:app --host 0.0.0.0 --port "$PORT" --workers 1 --log-level info
+exec uvicorn ${SERVER}:app --host 0.0.0.0 --port "$PORT" --workers 1 --log-level info