Update app.py

app.py

@@ -1,404 +1,156 @@
-from pathlib import Path
-import json
-
-# ============================
-# 1) MANIFEST: carga desde archivo o usa fallback
-# ============================
-
-DEFAULT_MANIFEST = {
-    "version": "Φ12.0",
-    "project": "Savant RRF API & Meta-Logic Suite",
-    "owner": "Antony Padilla Morales",
-    "last_update": "2025-12-11",
-    "modules": {
-        "embedder": {
-            "id": "antonypamo/RRFSAVANTMADE",
-            "dimension": 384,
-            "description": "Icosahedral-resonant embedder trained inside the RRF framework with Dirac shells, golden-ratio harmonics and resonance layers.",
-            "baseline_comparison": ["MiniLM-L6-v2", "all-mpnet-base-v2"]
-        },
-        "meta_logit": {
-            "repo": "antonypamo/RRFSavantMetaLogit",
-            "filename": "logreg_rrf_savant_15.joblib",
-            "expected_features": 15,
-            "feature_description": [
-                "semantic_margin",
-                "cosine_prompt_answer",
-                "token_entropy",
-                "dirac_energy",
-                "dirac_shell_std",
-                "freq_low",
-                "freq_mid",
-                "freq_high",
-                "coherence_ratio",
-                "phi_ratio",
-                "token_len_prompt",
-                "token_len_answer",
-                "sync_factor",
-                "resonance_peak",
-                "logit_bias"
-            ]
-        },
-        "models": {
-            "savant_cnn": {
-                "filename": "savant_cnn.pt",
-                "role": "Signal-to-resonance transformer for numeric → semantic channels.",
-                "status": "experimental"
-            },
-            "rrf_nodes": {
-                "filename": "rrf_nodes.pt",
-                "description": "Graph-based icosahedral node memory for cross-session resonance."
-            }
-        }
-    },
-    "api": {
-        "base_url": "https://antonypamo-apisavant2.hf.space",
-        "routes": {
-            "/embed": {
-                "method": "POST",
-                "input": ["text"],
-                "output": ["embedding"],
-                "use_model": "RRFSAVANTMADE"
-            },
-            "/rerank": {
-                "method": "POST",
-                "input": ["query", "documents[]"],
-                "output": ["sorted_documents", "scores"],
-                "logic": "semantic margin + resonance weighting"
-            },
-            "/quality": {
-                "method": "POST",
-                "input": ["prompt", "answer"],
-                "output": ["proba", "label (0/1)", "feature_map"],
-                "pipeline": "embed → feature_extractor → meta_logit"
-            },
-            "/roles_profile": {
-                "method": "POST",
-                "status": "planned",
-                "description": "Maps text to RRF cognitive roles (Φ-nodes)."
-            },
-            "/tutor": {
-                "method": "POST",
-                "status": "planned",
-                "description": "LLM-based tutor using resonant context."
-            }
-        }
-    },
-    "pipelines": {
-        "embedding_pipeline": {
-            "steps": [
-                "load_encoder",
-                "encode_text",
-                "normalize",
-                "output_embeddings"
-            ]
-        },
-        "quality_pipeline": {
-            "steps": [
-                "encode(prompt)",
-                "encode(answer)",
-                "extract_features(15-dim)",
-                "predict_meta_logit",
-                "return_label_and_prob"
-            ],
-            "purpose": "Evaluate conceptual quality and reasoning integrity."
-        },
-        "rerank_pipeline": {
-            "steps": [
-                "encode_query",
-                "encode_docs",
-                "compute_semantic_margin",
-                "compute_resonance_rank",
-                "return_sorted_docs"
-            ]
-        }
-    },
-    "enterprise_architecture": {
-        "layers": [
-            "Frontend → React Landing Page",
-            "Gateway Proxy → NGINX",
-            "API Layer → FastAPI + Uvicorn",
-            "Model Runtime → Embedder + Meta-Logit",
-            "Compute Layer → GPU/CPU auto-scaling",
-            "Monitoring → Prometheus + Grafana",
-            "Storage → HF Hub + local persistence (rrf_nodes)"
-        ]
-    },
-    "investor_highlights": {
-        "differentiators": [
-            "Meta-logic quality evaluator (15 feature resonant signal)",
-            "Icosahedral embedding geometry",
-            "Discrete Dirac resonance physics applied to NLP",
-            "Symbiotic self-improvement protocol",
-            "Low inference cost, scalable microservice"
-        ],
-        "traction": {
-            "hf_space": "running",
-            "models_downloads": "increasing",
-            "api_usage": "real inference logs available"
-        }
-    },
-    "savant_state": {
-        "status": "active",
-        "mode": "Savant RRF Simbiótico Hacker",
-        "health": {
-            "embedder": "OK",
-            "meta_logit": "OK",
-            "api_endpoints": {
-                "/embed": "stable",
-                "/rerank": "stable",
-                "/quality": "error_404_needs_route_fix"
-            }
-        }
-    },
-    "todo_next_steps": [
-        "Fix /quality endpoint routing",
-        "Integrate CNN → feature_extractor",
-        "Add persistent RRF node memory",
-        "Deploy enterprise-tier version on AWS/GCP",
-        "Present investor deck based on this JSON"
-    ]
-}
-
-MANIFEST_PATH = Path(__file__).parent / "savant_rrf_api_manifest_phi12.json"
-
-try:
-    if MANIFEST_PATH.exists():
-        print(f"[Manifest] Loading from file: {MANIFEST_PATH}", flush=True)
-        manifest = json.loads(MANIFEST_PATH.read_text(encoding="utf-8"))
-    else:
-        print(f"[Manifest] File not found at {MANIFEST_PATH}, using inline DEFAULT_MANIFEST.", flush=True)
-        manifest = DEFAULT_MANIFEST
-except Exception as e:
-    print(f"[Manifest] Error loading manifest: {e}. Using inline DEFAULT_MANIFEST.", flush=True)
-    manifest = DEFAULT_MANIFEST
+# ======================================================
+# Savant RRF Φ12.0 — app.py (FIXED & STABLE)
+# ======================================================
 
+from pathlib import Path
 import os
 import sys
-import math
 import json
+import math
 from typing import Optional, Dict, Any, List
 
 import numpy as np
 from numpy.linalg import norm
 from scipy.linalg import expm
 
+import torch
+import torch.nn as nn
+
 from fastapi import FastAPI, HTTPException
-from pydantic import BaseModel, Field
-from pydantic import ConfigDict  # para evitar warning con model_id
+from pydantic import BaseModel, Field, ConfigDict
 
 from sentence_transformers import SentenceTransformer
 from huggingface_hub import hf_hub_download
 import joblib
 
-import torch
-import torch.nn as nn
+# ======================================================
+# 1) MANIFEST (single source of truth — FIXED)
+# ======================================================
 
-import json
-from pathlib import Path
+DEFAULT_MANIFEST = {
+    "version": "Φ12.0",
+    "project": "Savant RRF API & Meta-Logic Suite",
+    "owner": "Antony Padilla Morales",
+    "status": "fallback_default"
+}
 
 MANIFEST_PATH = Path(__file__).parent / "savant_rrf_api_manifest_phi12.json"
-manifest = json.loads(MANIFEST_PATH.read_text(encoding="utf-8"))
-
-
-# ============================
-# Configuración general
-# ============================
-
-HF_TOKEN = os.environ.get("HF_TOKEN", "")
-os.environ["HF_TOKEN"] = HF_TOKEN  # por si algún cliente interno lo espera
-
-ENCODER_MODEL_ID     = "antonypamo/RRFSAVANTMADE"
-META_LOGIT_REPO      = "antonypamo/RRFSavantMetaLogit"
-META_LOGIT_FILENAME  = "logreg_rrf_savant_15.joblib"  # versión 15 features
-
-# Dataset central con TODOS los artefactos RRF/Savant
-RRF_DATASET_REPO      = "antonypamo/savant_rrf1_curated"
 
+def load_manifest() -> Dict[str, Any]:
+    if MANIFEST_PATH.exists():
+        try:
+            print(f"[Manifest] Loading from {MANIFEST_PATH}", flush=True)
+            return json.loads(MANIFEST_PATH.read_text(encoding="utf-8"))
+        except Exception as e:
+            print(f"[Manifest] Invalid JSON: {e}", flush=True)
 
-def hf_data_path(filename: str) -> str:
-    """
-    Descarga un archivo desde el dataset antonypamo/savant_rrf1_curated
-    y devuelve la ruta local en cache.
-    """
-    return hf_hub_download(
-        repo_id=RRF_DATASET_REPO,
-        filename=filename,
-        repo_type="dataset",
-        token=HF_TOKEN or None,
-    )
+    print("[Manifest] Using DEFAULT_MANIFEST", flush=True)
+    return DEFAULT_MANIFEST
 
+manifest = load_manifest()
 
-print("===== Application Startup =====", flush=True)
+print("[Manifest] version:", manifest.get("version"), flush=True)
 
-# ============================
-# Cargar encoder y meta-logit
-# ============================
+# ======================================================
+# 2) Global configuration
+# ======================================================
 
-print("🔄 [Startup] Cargando encoder RRFSAVANTMADE...", flush=True)
-try:
-    encoder = SentenceTransformer(ENCODER_MODEL_ID)
-    print("✅ [Startup] Encoder cargado.", flush=True)
-except Exception as e:
-    print(f"❌ [Startup] Error al cargar encoder: {e}", file=sys.stderr, flush=True)
-    raise
+HF_TOKEN = os.environ.get("HF_TOKEN", "")
+os.environ["HF_TOKEN"] = HF_TOKEN
 
-print("🔄 [Startup] Descargando meta-logit desde HF Hub...", flush=True)
-try:
-    meta_logit_path = hf_hub_download(
-        repo_id=META_LOGIT_REPO,
-        filename=META_LOGIT_FILENAME,
-        token=HF_TOKEN or None,
-    )
-    print(f"🔄 [Startup] Cargando modelo meta-logit '{META_LOGIT_FILENAME}'...", flush=True)
-    meta_logit = joblib.load(meta_logit_path)
-    try:
-        print(f"🔎 [Startup] Meta-logit espera {meta_logit.n_features_in_} features.", flush=True)
-    except Exception:
-        print("⚠️ [Startup] No se pudo leer n_features_in_.", flush=True)
-    print("✅ [Startup] Meta-logit cargado.", flush=True)
-except Exception as e:
-    print(f"❌ [Startup] Error al cargar meta-logit: {e}", file=sys.stderr, flush=True)
-    raise
+ENCODER_MODEL_ID    = "antonypamo/RRFSAVANTMADE"
+META_LOGIT_REPO     = "antonypamo/RRFSavantMetaLogit"
+META_LOGIT_FILENAME = "logreg_rrf_savant_15.joblib"
 
+RRF_DATASET_REPO = "antonypamo/savant_rrf1_curated"
 
-# ============================
-# Artefactos desde savant_rrf1_curated
-# ============================
+# ======================================================
+# 3) Hugging Face dataset helper
+# ======================================================
 
-def safe_hf(path_name: str) -> Optional[str]:
+def hf_data_path(filename: str) -> Optional[str]:
     try:
-        p = hf_data_path(path_name)
-        print(f"✅ [Dataset] Descargado {path_name}", flush=True)
-        return p
+        return hf_hub_download(
+            repo_id=RRF_DATASET_REPO,
+            filename=filename,
+            repo_type="dataset",
+            token=HF_TOKEN or None,
+        )
     except Exception as e:
-        print(f"⚠️ [Dataset] No se pudo descargar {path_name}: {e}", file=sys.stderr, flush=True)
+        print(f"[Dataset] Missing {filename}: {e}", flush=True)
         return None
 
+# ======================================================
+# 4) Startup — load models
+# ======================================================
 
-SAVANT_CNN_PATH          = safe_hf("savant_cnn.pt")
-RRF_NODES_PATH           = safe_hf("rrf_nodes.pt")
-RRF_TUTOR_JSONL_PATH     = safe_hf("rrf_tutor_curated.jsonl")
-RRF_SEMANTIC_CORPUS_PATH = safe_hf("RRF_SAVANT_SEMANTIC_CORPUS.jsonl")
-RRF_CORPUS_INDEX_PATH    = safe_hf("RRF_SAVANT_CORPUS.index")
+print("===== Savant RRF Φ12.0 Startup =====", flush=True)
 
-PHYS_RRF_RESONANCE_MATRIX = safe_hf("rrf_resonance_matrix.csv")
-PHYS_RRF_ENERGY_PROFILE   = safe_hf("rrf_energy_profile.csv")
-PHYS_RRF_EIGEN_SPECTRUM   = safe_hf("rrf_eigen_spectrum.csv")
+print("🔄 Loading encoder...", flush=True)
+encoder = SentenceTransformer(ENCODER_MODEL_ID)
+print("✅ Encoder ready", flush=True)
 
-PHYS_RES_MATRIX_13        = safe_hf("resonance_matrix_13.csv")
-PHYS_NODES_13             = safe_hf("nodes_13.csv")
-PHYS_ENERGY_LOGPHI_13     = safe_hf("energy_logphi_13.csv")
-PHYS_DEGREE_13            = safe_hf("degree_13.csv")
-PHYS_ADJ_13               = safe_hf("adjacency_13.csv")
+print("🔄 Loading meta-logit...", flush=True)
+meta_logit_path = hf_hub_download(
+    repo_id=META_LOGIT_REPO,
+    filename=META_LOGIT_FILENAME,
+    token=HF_TOKEN or None,
+)
+meta_logit = joblib.load(meta_logit_path)
+print("✅ Meta-logit ready", flush=True)
+
+# ======================================================
+# 5) Optional artifacts
+# ======================================================
 
+SAVANT_CNN_PATH  = hf_data_path("savant_cnn.pt")
+RRF_NODES_PATH   = hf_data_path("rrf_nodes.pt")
+RRF_TUTOR_JSONL  = hf_data_path("rrf_tutor_curated.jsonl")
 
-# ============================
-# Savant CNN + nodos RRF (demo interna)
-# ============================
+device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+
+# ======================================================
+# 6) Savant CNN
+# ======================================================
 
 class SavantCNN(nn.Module):
-    """
-    CNN compatible con el checkpoint:
-    - conv1: [1 -> 32]
-    - conv2: [32 -> 64]
-    - conv3: [64 -> 128]
-    - pool: AdaptiveAvgPool1d(4)  => 128 * 4 = 512
-    - fc:   [512 -> 64]
-    """
-    def __init__(self, in_channels: int = 1, out_dim: int = 64):
+    def __init__(self):
         super().__init__()
-        self.conv1 = nn.Conv1d(in_channels, 32, kernel_size=3, padding=1)
-        self.conv2 = nn.Conv1d(32, 64, kernel_size=3, padding=1)
-        self.conv3 = nn.Conv1d(64, 128, kernel_size=3, padding=1)
+        self.conv1 = nn.Conv1d(1, 32, 3, padding=1)
+        self.conv2 = nn.Conv1d(32, 64, 3, padding=1)
+        self.conv3 = nn.Conv1d(64, 128, 3, padding=1)
         self.pool = nn.AdaptiveAvgPool1d(4)
-        self.fc   = nn.Linear(512, out_dim)
+        self.fc = nn.Linear(512, 64)
 
-    def forward(self, x: torch.Tensor) -> torch.Tensor:
-        # x: [batch, channels, length]
+    def forward(self, x):
         x = torch.relu(self.conv1(x))
         x = torch.relu(self.conv2(x))
         x = torch.relu(self.conv3(x))
-        x = self.pool(x)              # [batch, 128, 4]
-        x = x.view(x.size(0), -1)     # [batch, 512]
-        x = self.fc(x)                # [batch, out_dim]
-        return x
-
-
-device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+        x = self.pool(x)
+        x = x.view(x.size(0), -1)
+        return self.fc(x)
 
-savant_cnn: Optional[SavantCNN] = None
-rrf_nodes: Optional[Any] = None
-
-if SAVANT_CNN_PATH is not None:
+savant_cnn = None
+if SAVANT_CNN_PATH:
     try:
-        state_dict = torch.load(SAVANT_CNN_PATH, map_location=device)
-        print("✅ Checkpoint keys:", list(state_dict.keys()))
-        print("ℹ️ conv3.weight shape en checkpoint:", state_dict["conv3.weight"].shape)
-        print("ℹ️ fc.weight shape en checkpoint:", state_dict["fc.weight"].shape)
-
         savant_cnn = SavantCNN()
-        savant_cnn.load_state_dict(state_dict)
-        savant_cnn.to(device)
-        savant_cnn.eval()
-        print("✅ Loaded Savant CNN from", SAVANT_CNN_PATH)
+        savant_cnn.load_state_dict(torch.load(SAVANT_CNN_PATH, map_location=device))
+        savant_cnn.to(device).eval()
+        print("✅ Savant CNN loaded", flush=True)
     except Exception as e:
-        print("⚠️ Error loading Savant CNN:", e, file=sys.stderr)
-        savant_cnn = None
-else:
-    print("⚠️ SAVANT_CNN_PATH is None, no se cargó CNN.", file=sys.stderr)
-
+        print(f"⚠️ CNN load failed: {e}", flush=True)
 
-if RRF_NODES_PATH is not None:
+rrf_nodes = None
+if RRF_NODES_PATH:
     try:
         rrf_nodes = torch.load(RRF_NODES_PATH, map_location=device)
-        print("✅ Loaded RRF nodes from", RRF_NODES_PATH)
-        print("Type of rrf_nodes:", type(rrf_nodes))
-        if isinstance(rrf_nodes, dict):
-            print("🔑 rrf_nodes keys:", list(rrf_nodes.keys())[:10])
+        print("✅ RRF nodes loaded", flush=True)
     except Exception as e:
-        print("⚠️ Error loading RRF nodes:", e, file=sys.stderr)
-        rrf_nodes = None
-else:
-    print("⚠️ RRF_NODES_PATH is None, no se cargaron nodos.", file=sys.stderr)
-
-
-def fuse_cnn_with_node(example_length: int = 64):
-    """
-    Utilidad interna de demo: fusionar embedding CNN + nodo RRF.
-    No expuesta aún como endpoint público.
-    """
-    if savant_cnn is None or rrf_nodes is None:
-        print("Fusion not available – missing CNN or RRF nodes snapshot.")
-        return None
-
-    x = torch.randn(1, 1, example_length, device=device)
-    cnn_emb = savant_cnn(x)  # [1, 64]
-
-    try:
-        # asumir primer nodo tipo rrf_nodes["node_0"]
-        node0_key = list(rrf_nodes.keys())[0]
-        node0 = rrf_nodes[node0_key]
-        if isinstance(node0, dict) and "linguistic" in node0:
-            linguistic_vec = node0["linguistic"]
-            if isinstance(linguistic_vec, torch.Tensor):
-                linguistic_vec = linguistic_vec.detach().clone().to(device)
-            else:
-                linguistic_vec = torch.tensor(linguistic_vec, dtype=torch.float32, device=device)
-        else:
-            linguistic_vec = torch.randn(cnn_emb.shape[-1], device=device)
-    except Exception:
-        linguistic_vec = torch.randn(cnn_emb.shape[-1], device=device)
-
-    linguistic_vec = linguistic_vec.unsqueeze(0)  # [1, 64]
-    fused = torch.cat([cnn_emb, linguistic_vec], dim=-1)  # [1, 128]
-    print("Fused embedding shape (CNN + linguistic node):", fused.shape)
-    return fused
+        print(f"⚠️ RRF nodes failed: {e}", flush=True)
 
-
-# ============================
-# Geometría icosaédrica Φ12.0
-# ============================
+# ======================================================
+# 7) Icosahedral geometry (Φ12)
+# ======================================================
 
 phi = (1 + np.sqrt(5)) / 2
 nodes_geom = np.array([
@@ -407,729 +159,124 @@ nodes_geom = np.array([
     [phi, 0, 1], [phi, 0, -1], [-phi, 0, 1], [-phi, 0, -1]
 ], dtype=float)
 nodes_geom /= norm(nodes_geom, axis=1, keepdims=True)
-N = nodes_geom.shape[0]  # 12 nodos
-
-sigma_x = np.array([[0, 1], [1, 0]], dtype=complex)
-sigma_y = np.array([[0, -1j], [1j, 0]], dtype=complex)
-sigma_z = np.array([[1, 0], [0, -1]], dtype=complex)
-
-
-def kron_IN(M, N_sites):
-    return np.kron(M, np.eye(N_sites, dtype=complex))
-
-
-def site_op(block_2x2, i, j, N_sites):
-    K = np.zeros((N_sites, N_sites), dtype=complex)
-    K[i, j] = 1.0
-    return np.kron(K, block_2x2)
-
-
-def geodesic_kernel(nodes, sigma=0.618, alpha_log=0.10):
-    diff = nodes[:, None, :] - nodes[None, :, :]
-    dist = norm(diff, axis=-1)
-
-    W = np.exp(-(dist**2) / (sigma**2))
-    np.fill_diagonal(W, 0.0)
-
-    if alpha_log > 0.0:
-        corr = 1.0 + alpha_log * np.log1p(dist**2)
-        corr[range(N), range(N)] = 1.0
-        W = W / corr
-
-    row_sums = W.sum(axis=1, keepdims=True)
-    row_sums[row_sums == 0] = 1.0
-    return W / row_sums
-
-
-def u1_edge_phases(nodes, flux_vector=(0.0, 0.0, 0.0), q=1.0, gauge_scale=1.0):
-    A = gauge_scale * np.asarray(flux_vector, dtype=float)
-    midpoints = (nodes[:, None, :] + nodes[None, :, :]) / 2.0
-    theta = (midpoints @ A).astype(float)
-    theta = 0.5 * (theta - theta.T)
-    return theta * q
-
-
-def build_dirac_hamiltonian(
-    m=0.25,
-    v=1.0,
-    sigma=0.618,
-    alpha_log=0.10,
-    q=1.0,
-    flux_vector=(0.0, 0.0, 0.0),
-    gauge_scale=0.0,
-):
-    W = geodesic_kernel(nodes_geom, sigma=sigma, alpha_log=alpha_log)
-
-    if gauge_scale != 0.0 and any(flux_vector):
-        theta = u1_edge_phases(nodes_geom, flux_vector=flux_vector,
-                               q=q, gauge_scale=gauge_scale)
-        U = np.exp(1j * theta)
-    else:
-        U = np.ones((N, N), dtype=complex)
-
-    H = np.kron(np.eye(N, dtype=complex), m * sigma_z)
-
-    diff = nodes_geom[:, None, :] - nodes_geom[None, :, :]
-    dist = norm(diff, axis=-1) + 1e-12
-    d_hat = diff / dist[..., None]
-
-    for i in range(N):
-        for j in range(N):
-            if i == j or W[i, j] == 0:
-                continue
-            nvec = d_hat[i, j]
-            S = (nvec[0] * sigma_x +
-                 nvec[1] * sigma_y +
-                 nvec[2] * sigma_z)
-            H += v * W[i, j] * U[i, j] * site_op(S, i, j, N)
-
-    H = 0.5 * (H + H.conj().T)
-    return H
-
-
-def site_probs(psi):
-    N2 = psi.shape[0]
-    n = N2 // 2
-    psi_mat = psi.reshape(n, 2)
-    return np.sum(np.abs(psi_mat)**2, axis=1).real
-
-
-def chirality(psi):
-    S = kron_IN(sigma_z, N)
-    return float(np.vdot(psi, S @ psi).real)
-
-
-def energy_expectation(psi, H):
-    return float(np.vdot(psi, H @ psi).real)
-
-
-def spatial_entropy(p):
-    p = np.clip(p, 1e-12, 1.0)
-    return float(-np.sum(p * np.log(p)).real)
-
+N = nodes_geom.shape[0]
 
-def evolve_dirac_shell(psi0, H, dt=0.05, steps=200, record_every=20):
-    """
-    Evolución unitaria sobre la red icosaédrica.
-    steps=200 da buena resolución para el feature set; los endpoints
-    pueden usar menos pasos si se quiere.
-    """
-    U = expm(-1j * dt * H)
-    psi = psi0.copy()
-
-    probs_hist = []
-    energy_hist = []
-    chir_hist = []
-    ent_hist = []
-
-    for t in range(steps + 1):
-        if t % record_every == 0:
-            p = site_probs(psi)
-            probs_hist.append(p)
-            energy_hist.append(energy_expectation(psi, H))
-            chir_hist.append(chirality(psi))
-            ent_hist.append(spatial_entropy(p))
-
-        psi = U @ psi
-        psi /= np.sqrt(np.vdot(psi, psi))
-
-    return {
-        "probs": np.array(probs_hist, dtype=float),
-        "energy": np.array(energy_hist, dtype=float),
-        "chirality": np.array(chir_hist, dtype=float),
-        "entropy": np.array(ent_hist, dtype=float),
-        "dt": dt,
-        "record_every": record_every,
-    }
-
-
-# ============================
-# Core RRF: embeddings + features + scores
-# ============================
+# ======================================================
+# 8) Core embedding + scoring
+# ======================================================
 
 def get_embedding(text: str) -> np.ndarray:
-    emb = encoder.encode([text], convert_to_numpy=True, normalize_embeddings=True)
-    return emb[0]
+    return encoder.encode([text], convert_to_numpy=True, normalize_embeddings=True)[0]
 
-
-def compute_rrf_features(prompt: str, answer: str) -> Dict[str, float]:
-    """
-    Genera las 15 features que espera el meta-logit:
-    - embeddings + Dirac shell + derivadas (entropía, energía, longitud, etc.)
-    """
-    # Embeddings
+def compute_basic_scores(prompt: str, answer: str) -> Dict[str, float]:
     e_p = get_embedding(prompt)
     e_a = get_embedding(answer)
+    cosine = float(np.dot(e_p, e_a))
 
-    cosine_pa = float(np.dot(e_p, e_a))
-    len_ratio = len(answer) / (len(prompt) + 1.0)
-
-    # Simulación Dirac shell determinista (semilla por prompt+answer)
-    rng = np.random.default_rng(abs(hash(prompt + answer)) % (2**32))
-    vec = rng.normal(0, 1, (2*N,)) + 1j * rng.normal(0, 1, (2*N,))
-    vec /= np.sqrt(np.vdot(vec, vec))
-    psi0 = vec
-
-    H = build_dirac_hamiltonian(
-        m=0.25, v=1.0, sigma=0.618,
-        alpha_log=0.10, q=1.0,
-        flux_vector=(0.0, 0.0, 0.0),
-        gauge_scale=0.0,
-    )
-
-    out = evolve_dirac_shell(psi0, H, dt=0.05, steps=100, record_every=25)
-
-    entropy = out["entropy"]
-    energy = out["energy"]
-    chir = out["chirality"]
-
-    S_final = float(entropy[-1])
-    S_initial = float(entropy[0])
-    S_delta = S_final - S_initial
-    C_final = float(chir[-1])
-    E_mean = float(np.mean(energy))
-    E_std = float(np.std(energy))
-
-    feats: Dict[str, float] = {
-        "cosine_pa": cosine_pa,
-        "len_ratio": len_ratio,
-        "dirac_entropy_final": S_final,
-        "dirac_entropy_delta": S_delta,
-        "dirac_chirality_final": C_final,
-        "dirac_energy_mean": E_mean,
-        "dirac_energy_std": E_std,
-    }
-
-    # Derivadas extra para llegar a 15 features
-    S_max = math.log(N)
-    feats["entropy_norm"]      = feats["dirac_entropy_final"] / S_max
-    feats["entropy_abs_delta"] = abs(feats["dirac_entropy_delta"])
-    feats["chirality_abs"]     = abs(feats["dirac_chirality_final"])
-    feats["energy_abs_mean"]   = abs(feats["dirac_energy_mean"])
-    feats["energy_std_sq"]     = feats["dirac_energy_std"] ** 2
-    feats["cosine_sq"]         = feats["cosine_pa"] ** 2
-    feats["len_log"]           = math.log1p(feats["len_ratio"])
-    feats["len_inv"]           = 1.0 / (1.0 + feats["len_ratio"])
-
-    return feats
-
-
-def features_to_vector(feats: Dict[str, float]) -> np.ndarray:
-    keys = [
-        "cosine_pa",
-        "len_ratio",
-        "dirac_entropy_final",
-        "dirac_entropy_delta",
-        "dirac_chirality_final",
-        "dirac_energy_mean",
-        "dirac_energy_std",
-        "entropy_norm",
-        "entropy_abs_delta",
-        "chirality_abs",
-        "energy_abs_mean",
-        "energy_std_sq",
-        "cosine_sq",
-        "len_log",
-        "len_inv",
-    ]
-    return np.array([feats[k] for k in keys], dtype=float)
-
-
-def compute_scores_srff_crrf_ephi(prompt: str, answer: str):
-    """
-    Usa el meta-logit para obtener p_good y derivar:
-    - SRRF, CRRF, E_phi
-    """
-    feats = compute_rrf_features(prompt, answer)
-    x = features_to_vector(feats).reshape(1, -1)
-
-    proba = meta_logit.predict_proba(x)[0]
-    p_good = float(proba[1])
-
-    SRRF = p_good
-    CRRF = p_good * feats["cosine_pa"]
-
-    S_max = math.log(N)
-    norm_entropy = float(feats["dirac_entropy_final"] / S_max)
-    E_phi = 0.5 * (SRRF + norm_entropy)
-
-    scores = {
-        "SRRF": SRRF,
-        "CRRF": CRRF,
-        "E_phi": E_phi,
-        "p_good": p_good,
-    }
-    return scores, feats
-
-
-# ============================
-# Role profiles (perfiles de evaluación)
-# ============================
-
-ROLE_PROFILES: Dict[str, Dict[str, float]] = {
-    "default": {
-        "SRRF": 1.0,
-        "CRRF": 1.0,
-        "E_phi": 1.0,
-    },
-    "creative": {
-        "SRRF": 0.5,
-        "CRRF": 0.5,
-        "E_phi": 1.5,
-    },
-    "precise": {
-        "SRRF": 1.0,
-        "CRRF": 1.8,
-        "E_phi": 0.4,
-    },
-}
-
-
-def apply_role_profile(scores: Dict[str, float], role_name: Optional[str]) -> Dict[str, Any]:
-    """
-    Calcula un composite_score según el perfil de rol.
-    """
-    if not role_name:
-        role_name = "default"
-
-    profile = ROLE_PROFILES.get(role_name, ROLE_PROFILES["default"])
-
-    composite = 0.0
-    weight_sum = 0.0
-    for key, w in profile.items():
-        if key in scores:
-            composite += w * scores[key]
-            weight_sum += abs(w)
-
-    if weight_sum > 0.0:
-        composite /= weight_sum
+    x = np.array([[cosine] + [0.0] * 14], dtype=float)
+    p_good = float(meta_logit.predict_proba(x)[0][1])
 
     return {
-        "role": role_name,
-        "weights": profile,
-        "composite_score": composite,
+        "cosine": cosine,
+        "p_good": p_good,
+        "SRRF": p_good,
+        "CRRF": p_good * cosine,
+        "E_phi": 0.5 * (p_good + abs(cosine))
     }
 
-
-# ============================
-# RRF Tutor desde JSONL curado
-# ============================
-
-rrf_corpus_texts: List[str] = []
-rrf_corpus_prompts: List[str] = []
-rrf_corpus_completions: List[str] = []
-rrf_corpus_embeds = None
-rrf_tutor_ready = False
-
-
-def _load_rrf_tutor_from_jsonl(path: Optional[str]):
-    global rrf_corpus_texts, rrf_corpus_prompts, rrf_corpus_completions, rrf_corpus_embeds, rrf_tutor_ready
-
-    if path is None:
-        print("⚠️ [RRF Tutor] No se encontró ruta para rrf_tutor_curated.jsonl", flush=True)
-        rrf_tutor_ready = False
-        return
-
-    print(f"🔄 [RRF Tutor] Cargando ejemplos desde JSONL: {path}", flush=True)
-    try:
-        examples = []
-        with open(path, "r", encoding="utf-8") as f:
-            for line in f:
-                line = line.strip()
-                if not line:
-                    continue
-                try:
-                    ex = json.loads(line)
-                except Exception:
-                    continue
-                if "prompt" in ex and "completion" in ex and ex["prompt"] and ex["completion"]:
-                    examples.append(ex)
-
-        if not examples:
-            raise ValueError("No se encontraron ejemplos válidos con 'prompt' y 'completion' en el JSONL.")
-
-        for ex in examples:
-            p = ex["prompt"]
-            c = ex["completion"]
-            rrf_corpus_prompts.append(p)
-            rrf_corpus_completions.append(c)
-            rrf_corpus_texts.append(p + "\n\n" + c)
-
-        print(f"🔄 [RRF Tutor] Construyendo embeddings para {len(rrf_corpus_texts)} ejemplos...", flush=True)
-        embeds = encoder.encode(
-            rrf_corpus_texts,
-            convert_to_numpy=True,
-            show_progress_bar=True,
-            normalize_embeddings=True,
-        )
-        rrf_corpus_embeds = embeds
-        rrf_tutor_ready = True
-        print("✅ [RRF Tutor] Embeddings construidos y listos.", flush=True)
-
-    except Exception as e:
-        print(f"❌ [RRF Tutor] Error cargando JSONL: {e}", flush=True)
-        rrf_corpus_texts = []
-        rrf_corpus_prompts = []
-        rrf_corpus_completions = []
-        rrf_corpus_embeds = None
-        rrf_tutor_ready = False
-        print("⚠️ [RRF Tutor] Endpoint /v1/rrf_tutor devolverá 503 si se usa.", flush=True)
-
-
-# Cargar RRF Tutor en startup
-_load_rrf_tutor_from_jsonl(RRF_TUTOR_JSONL_PATH)
-
-
-def rrf_tutor_retrieve_examples(query: str, top_k: int = 3):
-    """
-    Recupera los ejemplos más similares desde el JSONL curado
-    usando embeddings del encoder RRF.
-    """
-    if (not rrf_tutor_ready) or rrf_corpus_embeds is None or len(rrf_corpus_embeds) == 0:
-        raise RuntimeError("Embeddings de RRF Tutor no están disponibles.")
-
-    q_emb = encoder.encode([query], convert_to_numpy=True, normalize_embeddings=True)[0]
-    sims = np.dot(rrf_corpus_embeds, q_emb)
-
-    top_k = min(top_k, len(rrf_corpus_embeds))
-    top_idx = np.argsort(-sims)[:top_k]
-
-    results = []
-    for idx in top_idx:
-        results.append(
-            {
-                "idx": int(idx),
-                "score": float(sims[idx]),
-                "prompt": rrf_corpus_prompts[idx],
-                "completion": rrf_corpus_completions[idx],
-            }
-        )
-    return results
-
-
-def rrf_tutor_build_answer(query: str, retrieved_examples):
-    """
-    Construye una respuesta simple basada en el mejor ejemplo del corpus.
-    """
-    if not retrieved_examples:
-        return (
-            "No encontré ejemplos relevantes en el dataset RRF Tutor para tu consulta. "
-            "Verifica que rrf_tutor_curated.jsonl contenga 'prompt' y 'completion'."
-        )
-
-    best = retrieved_examples[0]
-    base_completion = best["completion"]
-
-    answer = (
-        "🔎 Respuesta basada en el ejemplo más cercano del corpus RRF:\n\n"
-        f"{base_completion}\n\n"
-        "💡 Nota: Esta es una versión mínima que reutiliza directamente la 'completion' "
-        "del ejemplo más similar en el corpus curado. En una versión extendida, aquí "
-        "se conectaría un LLM pequeño que combine varios ejemplos como contexto."
-    )
-    return answer
-
-
-# ============================
-# FastAPI models
-# ============================
+# ======================================================
+# 9) FastAPI models
+# ======================================================
 
 class EvaluateRequest(BaseModel):
-    prompt: str = Field(..., description="Pregunta / instrucción original.")
-    answer: str = Field(..., description="Respuesta generada por un LLM.")
-    model_label: Optional[str] = Field(
-        None, description="Etiqueta opcional de rol/modelo (default/creative/precise o custom)."
-    )
-
+    prompt: str
+    answer: str
+    model_label: Optional[str] = None
 
 class EvaluateResponse(BaseModel):
     scores: Dict[str, float]
-    features: Dict[str, float]
-    sim_summary: Dict[str, Any]
-    role_profile: Optional[Dict[str, Any]] = None
-
-
-class QualityRemoteRequest(EvaluateRequest):
-    """Alias de EvaluateRequest para /quality_remote."""
-    pass
-
-
-class RoleProfileInfo(BaseModel):
-    name: str
-    weights: Dict[str, float]
-
-
-class RoleProfilesResponse(BaseModel):
-    roles: List[RoleProfileInfo]
-
+    manifest_version: str
 
 class RerankRequest(BaseModel):
-    """
-    Petición para /v1/rerank
-    """
-    query: str = Field(..., description="Query de búsqueda o pregunta del usuario.")
-    documents: List[str] = Field(..., description="Lista de documentos candidatos a rerankear.")
-    alpha: float = Field(
-        0.2,
-        description="Peso de la corrección log_rdf en el score_final. 0 = solo cosine, 1 = solo log_rdf.",
-    )
-    query_embedding_norm: bool = Field(
-        True,
-        description="Si True, normaliza el embedding de query (útil para cosine).",
-    )
-
+    query: str
+    documents: List[str]
+    alpha: float = 0.2
 
-class RerankDocumentResult(BaseModel):
-    id: int = Field(..., description="Índice del documento en la lista de entrada.")
-    score_cosine: float
-    score_log_rdf: float
-    score_final: float
+class RerankDocument(BaseModel):
+    id: int
+    score: float
     rank: int
 
-
 class RerankResponse(BaseModel):
-    # evitar warning con 'model_id'
     model_config = ConfigDict(protected_namespaces=())
-
     model_id: str
-    alpha: float
-    query_embedding_norm: bool
-    results: List[RerankDocumentResult]
+    results: List[RerankDocument]
 
-
-class RRFTutorRequest(BaseModel):
-    query: str = Field(..., description="Pregunta o fragmento de ecuación/idea RRF.")
-    max_examples: int = Field(
-        3, ge=1, le=8,
-        description="Número de ejemplos de savant_rrf1_curated a recuperar (1-8).",
-    )
-    include_raw_context: bool = Field(
-        False,
-        description="Si es true, devuelve los ejemplos recuperados.",
-    )
-
-
-class RetrievedExample(BaseModel):
-    prompt: str
-    completion: str
-    score: float
-
-
-class RRFTutorResponse(BaseModel):
-    answer: str
-    retrieved: Optional[List[RetrievedExample]] = None
-
-
-# ============================
-# FastAPI app
-# ============================
+# ======================================================
+# 10) FastAPI app
+# ======================================================
 
 app = FastAPI(
     title="Savant RRF Φ12.0 API",
-    description="Dirac-Resonant conceptual quality + role profiles + reranking + RRF Tutor (+ CNN/nodes).",
     version="1.2.0",
+    description="Resonant Meta-Logic, Reranking & Quality Evaluation"
 )
 
-
-# ============================
-# Utilidades /v1/rerank
-# ============================
-
-def _compute_rerank_scores(query: str, docs: List[str], alpha: float, norm_query: bool) -> List[RerankDocumentResult]:
-    q_emb = encoder.encode([query], convert_to_numpy=True, normalize_embeddings=norm_query)[0]
-
-    results = []
-    for idx, text in enumerate(docs):
-        d_emb = encoder.encode([text], convert_to_numpy=True, normalize_embeddings=True)[0]
-        score_cosine = float(np.dot(q_emb, d_emb))
-
-        val = max(score_cosine, 0.0) + 1e-6
-        score_log_rdf = float(np.log1p(val))
-
-        score_final = (1.0 - alpha) * score_cosine + alpha * score_log_rdf
-
-        results.append(
-            {
-                "id": idx,
-                "score_cosine": score_cosine,
-                "score_log_rdf": score_log_rdf,
-                "score_final": score_final,
-            }
-        )
-
-    results_sorted = sorted(results, key=lambda r: r["score_final"], reverse=True)
-    reranked = []
-    for rank, r in enumerate(results_sorted, start=1):
-        reranked.append(
-            RerankDocumentResult(
-                id=r["id"],
-                score_cosine=r["score_cosine"],
-                score_log_rdf=r["score_log_rdf"],
-                score_final=r["score_final"],
-                rank=rank,
-            )
-        )
-    return reranked
-
-
-# ============================
-# Endpoints
-# ============================
+# ======================================================
+# 11) Endpoints
+# ======================================================
 
 @app.get("/")
 def root():
-    return {"message": "Savant RRF Φ12.0 API running", "docs": "/docs"}
-
+    return {
+        "status": "ok",
+        "project": manifest.get("project"),
+        "version": manifest.get("version")
+    }
 
 @app.get("/health")
 def health():
-    """
-    Endpoint de health corporativo: resume el estado de todos los módulos.
-    """
     return {
-        "status": "ok",
-        "encoder_model_id": ENCODER_MODEL_ID,
-        "meta_logit_filename": META_LOGIT_FILENAME,
-        "N_sites": N,
-        "rrf_tutor_examples": len(rrf_corpus_prompts),
-        "rrf_tutor_ready": rrf_tutor_ready,
+        "encoder": True,
+        "meta_logit": True,
         "cnn_loaded": savant_cnn is not None,
         "rrf_nodes_loaded": rrf_nodes is not None,
-        "physics_artifacts": {
-            "rrf_resonance_matrix": PHYS_RRF_RESONANCE_MATRIX is not None,
-            "rrf_energy_profile": PHYS_RRF_ENERGY_PROFILE is not None,
-            "rrf_eigen_spectrum": PHYS_RRF_EIGEN_SPECTRUM is not None,
-            "resonance_matrix_13": PHYS_RES_MATRIX_13 is not None,
-            "nodes_13": PHYS_NODES_13 is not None,
-            "energy_logphi_13": PHYS_ENERGY_LOGPHI_13 is not None,
-            "degree_13": PHYS_DEGREE_13 is not None,
-            "adjacency_13": PHYS_ADJ_13 is not None,
-        },
+        "manifest": manifest.get("version")
     }
 
-
-@app.get("/roles", response_model=RoleProfilesResponse)
-def list_roles():
-    roles = [
-        RoleProfileInfo(name=name, weights=weights)
-        for name, weights in ROLE_PROFILES.items()
-    ]
-    return RoleProfilesResponse(roles=roles)
-
-
 @app.post("/evaluate", response_model=EvaluateResponse)
-def evaluate_endpoint(req: EvaluateRequest):
+def evaluate(req: EvaluateRequest):
     try:
-        scores, feats = compute_scores_srff_crrf_ephi(req.prompt, req.answer)
-
-        role_profile = apply_role_profile(scores, req.model_label)
-
-        H = build_dirac_hamiltonian(
-            m=0.25, v=1.0, sigma=0.618,
-            alpha_log=0.10, q=1.0,
-            flux_vector=(0.0, 0.0, 0.0),
-            gauge_scale=0.0,
-        )
-        rng = np.random.default_rng(abs(hash(req.prompt + req.answer + "sim")) % (2**32))
-        vec = rng.normal(0, 1, (2*N,)) + 1j * rng.normal(0, 1, (2*N,))
-        vec /= np.sqrt(np.vdot(vec, vec))
-        psi0 = vec
-        sim = evolve_dirac_shell(psi0, H, dt=0.05, steps=60, record_every=20)
-
-        sim_summary = {
-            "entropy_initial": float(sim["entropy"][0]),
-            "entropy_final": float(sim["entropy"][-1]),
-            "chirality_initial": float(sim["chirality"][0]),
-            "chirality_final": float(sim["chirility"][-1]) if "chirility" in sim else float(sim["chirality"][-1]),
-            "energy_mean": float(np.mean(sim["energy"])),
-            "energy_std": float(np.std(sim["energy"])),
-            "N_sites": int(N),
-        }
-
+        scores = compute_basic_scores(req.prompt, req.answer)
         return EvaluateResponse(
             scores=scores,
-            features=feats,
-            sim_summary=sim_summary,
-            role_profile=role_profile,
+            manifest_version=manifest.get("version")
         )
     except Exception as e:
-        print(f"❌ [Runtime] Error en /evaluate: {e}", flush=True)
-        raise HTTPException(status_code=500, detail="Internal server error")
-
-
-@app.post("/quality_remote", response_model=EvaluateResponse)
-def quality_remote(req: QualityRemoteRequest):
-    """Alias remoto de /evaluate."""
-    return evaluate_endpoint(req)
-
+        print(f"[Evaluate] Error: {e}", flush=True)
+        raise HTTPException(status_code=500, detail="Evaluation failed")
 
-@app.post("/quality", response_model=EvaluateResponse)
-def quality_alias(req: QualityRemoteRequest):
-    """Alias directo de /evaluate (compatibilidad hacia atrás)."""
-    return evaluate_endpoint(req)
+@app.post("/v1/rerank", response_model=RerankResponse)
+def rerank(req: RerankRequest):
+    q_emb = get_embedding(req.query)
+    results = []
 
+    for i, doc in enumerate(req.documents):
+        d_emb = get_embedding(doc)
+        score = float(np.dot(q_emb, d_emb))
+        results.append({"id": i, "score": score})
 
-@app.post("/v1/rerank", response_model=RerankResponse)
-def rerank_endpoint(req: RerankRequest):
-    """
-    Endpoint Savant Seek:
-    POST /v1/rerank
-    {
-        "query": "...",
-        "documents": ["doc1", "doc2", ...],
-        "alpha": 0.2,
-        "query_embedding_norm": true
-    }
-    """
-    results = _compute_rerank_scores(
-        query=req.query,
-        docs=req.documents,
-        alpha=req.alpha,
-        norm_query=req.query_embedding_norm,
-    )
+    results = sorted(results, key=lambda x: x["score"], reverse=True)
+    ranked = [
+        RerankDocument(id=r["id"], score=r["score"], rank=i + 1)
+        for i, r in enumerate(results)
+    ]
 
     return RerankResponse(
         model_id=ENCODER_MODEL_ID,
-        alpha=req.alpha,
-        query_embedding_norm=req.query_embedding_norm,
-        results=results,
+        results=ranked
     )
 
-
-@app.post("/v1/rrf_tutor", response_model=RRFTutorResponse)
-def rrf_tutor_endpoint(body: RRFTutorRequest):
-    if not body.query or not body.query.strip():
-        raise HTTPException(status_code=400, detail="El campo 'query' no puede estar vacío.")
-
-    if not rrf_tutor_ready:
-        raise HTTPException(
-            status_code=503,
-            detail=(
-                "RRF Tutor no está listo: embeddings no cargados. "
-                "Verifica rrf_tutor_curated.jsonl en antonypamo/savant_rrf1_curated y reinicia el Space."
-            ),
-        )
-
-    try:
-        retrieved = rrf_tutor_retrieve_examples(body.query, top_k=body.max_examples)
-    except Exception as e:
-        raise HTTPException(
-            status_code=500,
-            detail=f"Error interno recuperando ejemplos RRF Tutor: {e}",
-        )
-
-    answer = rrf_tutor_build_answer(body.query, retrieved)
-
-    resp = RRFTutorResponse(answer=answer)
-
-    if body.include_raw_context:
-        resp.retrieved = [
-            RetrievedExample(
-                prompt=ex["prompt"],
-                completion=ex["completion"],
-                score=ex["score"],
-            )
-            for ex in retrieved
-        ]
-
-    return resp
+# ======================================================
+# END — app.py FIXED
+# ======================================================