Spaces:

Cristobal299
/

PRUEBA

No application file

App Files Files Community

Cristobal299 commited on Jul 17

Commit

551f7cd

verified ·

1 Parent(s): de99996

Upload app (8).py

Browse files

Files changed (1) hide show

app (8).py +896 -0

app (8).py ADDED Viewed

	@@ -0,0 +1,896 @@

+# -*- coding: utf-8 -*-
+"""
+app.py
+Interfaz de usuario mística (Frontend) basada en Gradio para Fénix Aprendiz.
+Incluye el Bot de Inquietudes Humanas: una "preparación del oráculo" que sube
+automáticamente +1 nivel por día (tope 100) y genera 10 inquietudes diarias,
+rotando entre categorías (miedos existenciales, crisis de fe, propósito de vida,
+debates bíblicos, consejo espiritual, alma y más allá) con profundidad creciente
+según el nivel, sin repetir temas recientes.
+Compatible con todas las versiones de Gradio (sin type="messages" ni parámetros experimentales).
+"""
+import os
+import time
+import threading
+from datetime import datetime, timedelta
+import gradio as gr
+import fenix_core  # Importamos para inyectar voces místicas de forma dinámica
+from fenix_core import (
+    ciclo_completo,
+    procesar_pdf,
+    generar_voz,
+    guardar_conversacion,
+    cargar_conversaciones,
+    revisar_conversaciones_pendientes,
+    actualizar_claves_dinamicas,
+    llamar_cerebras_directo,
+    rotar_clave_cerebras_fallida,
+    CEREBRAS_KEYS_POOL,
+    NVIDIA_KEYS_POOL,
+    describir_imagen,
+    generar_imagen_ia,
+    cargar_galeria_imagenes,
+    texto_biblioteca,
+    borrar_libro,
+    listar_libros,
+    guardar_gratitud,
+    listar_gratitudes,
+    guardar_historia,
+    listar_historias,
+)
+from fenix_progreso import obtener_progreso, registrar_pregunta
+from gradio_theme_fenix import apply_fenix_theme, FENIX_CSS, fenix_header, fenix_footer
+SUFIJO_MAESTRO = "\n\n_(maestro:"
+# El orbe se acelera al enviar y vuelve solo a su ritmo normal a los 14s.
+# FIX CRÍTICO: cuando 'js' y 'fn' van en el MISMO evento con 'inputs' definidos,
+# Gradio pasa esos inputs como argumentos a la función JS y usa lo que ELLA
+# devuelva como los valores reales que llegan a 'fn'. La versión anterior no
+# aceptaba ni devolvía nada, así que Gradio mandaba 'undefined' (-> None) en
+# vez del mensaje real, y por eso 'responder()' recibía mensaje=None y petaba.
+# Ahora la JS recibe (mensaje, historial, voz) y los devuelve TAL CUAL, usando
+# la función solo para el efecto visual como efecto secundario.
+JS_ORBE_PENSANDO = """
+(mensaje, historial, voz) => {
+    const orbe = document.querySelector('.orbe-luz');
+    if (orbe) {
+        orbe.classList.add('orbe-pensando');
+        setTimeout(() => orbe.classList.remove('orbe-pensando'), 14000);
+    }
+    return [mensaje, historial, voz];
+}
+"""
+# Analizador de volumen real de la voz de Fénix (Web Audio API), inyectado UNA
+# vez en <head> con demo.launch(head=...) para que sobreviva a que Gradio
+# reemplace el <audio> en cada respuesta nueva. Engancha un AnalyserNode al
+# elemento de audio y, mientras suena, traduce el volumen instantáneo en la
+# escala/brillo del orbe. Nota: los navegadores exigen un gesto del usuario
+# para arrancar el AudioContext; como esto se dispara tras pulsar "Enviar",
+# ese requisito ya queda cubierto.
+SCRIPT_ANALIZADOR_VOZ = """
+<script>
+(function () {
+    function iniciarAnalizadorVoz() {
+        const audioEl = document.querySelector('#audio_voz_fenix audio');
+        const orbe = document.querySelector('.orbe-luz');
+        if (!audioEl || !orbe || audioEl._fenixConectado) return;
+        audioEl._fenixConectado = true;
+        try {
+            if (!window._fenixAudioCtx) {
+                window._fenixAudioCtx = new (window.AudioContext || window.webkitAudioContext)();
+            }
+            const ctx = window._fenixAudioCtx;
+            const source = ctx.createMediaElementSource(audioEl);
+            const analyser = ctx.createAnalyser();
+            analyser.fftSize = 64;
+            source.connect(analyser);
+            analyser.connect(ctx.destination);
+            const datos = new Uint8Array(analyser.frequencyBinCount);
+            function animar() {
+                if (audioEl.paused || audioEl.ended) return;
+                analyser.getByteFrequencyData(datos);
+                const promedio = datos.reduce((a, b) => a + b, 0) / datos.length;
+                const escala = 1 + (promedio / 255) * 0.6;
+                const halo = 15 + (promedio / 255) * 60;
+                orbe.style.transform = `scale(${escala})`;
+                orbe.style.boxShadow = `0 0 ${halo}px ${halo / 2}px rgba(212,175,55,0.85)`;
+                requestAnimationFrame(animar);
+            }
+            const limpiar = () => {
+                orbe.classList.remove('orbe-hablando');
+                orbe.style.transform = '';
+                orbe.style.boxShadow = '';
+            };
+            audioEl.addEventListener('play', () => {
+                if (ctx.state === 'suspended') ctx.resume();
+                orbe.classList.add('orbe-hablando');
+                animar();
+            });
+            audioEl.addEventListener('pause', limpiar);
+            audioEl.addEventListener('ended', limpiar);
+        } catch (e) {
+            console.warn('Analizador de voz de Fénix no disponible:', e);
+        }
+    }
+    // El <audio> de Gradio se crea/renueva de forma asíncrona; se observa el
+    // DOM para engancharse en cuanto aparezca, en esta carga y en las siguientes.
+    const obs = new MutationObserver(iniciarAnalizadorVoz);
+    obs.observe(document.body, { childList: true, subtree: true });
+    iniciarAnalizadorVoz();
+})();
+</script>
+"""
+BOT_ID = "espiritual"
+PREGUNTAS_POR_DIA = 10
+INTERVALO_SEGUNDOS = 86400 // PREGUNTAS_POR_DIA  # 8640s ≈ cada 2h24min
+# Categorías por las que rota el oráculo. Con 10 preguntas/día y 6 categorías,
+# ninguna se queda sin cubrir: en pocos días ya hay cobertura completa y el
+# ciclo empieza de nuevo, ahora con más profundidad (según el nivel).
+CATEGORIAS_ORACULO = [
+    "miedos e inquietudes existenciales (muerte, vacío, soledad, sufrimiento)",
+    "crisis de fe y dudas religiosas",
+    "búsqueda de propósito y sentido de la vida",
+    "debates y controversias de interpretación bíblica (pasajes concretos, "
+    "aparentes contradicciones, contexto histórico y teológico)",
+    "consejo práctico y consuelo espiritual ante situaciones difíciles de la vida real",
+    "preguntas sobre el alma, la reencarnación, el juicio y el más allá",
+]
+# Mapa de nivel (0-100) -> profundidad esperada. Es la "preparación del oráculo":
+# según el nivel actual, las inquietudes generadas ganan matiz y especificidad.
+NIVELES_ORACULO = [
+    (20, "preguntas introductorias y generales, propias de alguien que recién "
+         "empieza a hacerse preguntas grandes sobre la vida"),
+    (40, "preguntas más personales e íntimas sobre crisis de fe, pérdida, dolor "
+         "y búsqueda de propósito"),
+    (60, "debates teológicos con referencias a pasajes bíblicos concretos y sus "
+         "posibles contradicciones, matices de traducción o interpretaciones distintas"),
+    (80, "dilemas existenciales profundos: el problema del mal, el sufrimiento "
+         "injusto, el libre albedrío frente a la voluntad divina, la naturaleza de Dios"),
+    (100, "preguntas de altísima profundidad teológica y filosófica, comparando "
+          "tradiciones espirituales distintas, cuestionando dogmas asumidos, y "
+          "buscando consuelo genuino ante circunstancias extremas de la vida"),
+]
+def _descripcion_nivel_oraculo(nivel: int) -> str:
+    for tope, descripcion in NIVELES_ORACULO:
+        if nivel <= tope:
+            return descripcion
+    return NIVELES_ORACULO[-1][1]
+def _categoria_del_turno(nivel: int, preguntas_hoy: int) -> str:
+    """Rotación determinista: cada pregunta del día avanza a la siguiente
+    categoría, y el nivel desplaza el punto de partida para no caer siempre
+    en el mismo orden entre días."""
+    indice = (nivel + preguntas_hoy) % len(CATEGORIAS_ORACULO)
+    return CATEGORIAS_ORACULO[indice]
+def _segundos_hasta_manana() -> int:
+    ahora = datetime.now()
+    manana = (ahora + timedelta(days=1)).replace(hour=0, minute=5, second=0, microsecond=0)
+    return max(60, int((manana - ahora).total_seconds()))
+def identidad_login_ui(nombre, pin):
+    """Envoltorio para el Jardín (Templo de Gratitud, Círculo de Historias,
+    Río de Conversación): expone entrar_o_registrar_identidad como endpoint
+    de API propio ('identidad_login'), separado por completo del chat
+    ('responder'). Devuelve un JSON en texto plano para que el cliente
+    Android lo parsee fácil, sin depender de un formato de salida nuevo."""
+    import json as _json
+    resultado = fenix_core.entrar_o_registrar_identidad(nombre, pin)
+    return _json.dumps(resultado, ensure_ascii=False)
+def gratitud_guardar_ui(nombre, texto):
+    """Envoltorio de API para guardar una gratitud del Templo. Devuelve
+    JSON en texto plano: {"ok": bool, "mensaje": str}."""
+    import json as _json
+    resultado = guardar_gratitud(nombre, texto)
+    return _json.dumps(resultado, ensure_ascii=False)
+def gratitud_listar_ui(nombre):
+    """Envoltorio de API para listar las gratitudes guardadas de 'nombre'.
+    Devuelve JSON en texto plano: una lista de {"texto":..., "created_at":...}."""
+    import json as _json
+    resultado = listar_gratitudes(nombre)
+    return _json.dumps(resultado, ensure_ascii=False)
+def circulo_publicar_ui(nombre, texto):
+    """Envoltorio de API para publicar una historia en el Círculo comunal.
+    Devuelve JSON en texto plano: {"ok": bool, "mensaje": str}."""
+    import json as _json
+    resultado = guardar_historia(nombre, texto)
+    return _json.dumps(resultado, ensure_ascii=False)
+def circulo_listar_ui():
+    """Envoltorio de API para listar TODAS las historias del Círculo, más
+    recientes primero. Devuelve JSON: lista de
+    {"nombre_visible":..., "texto":..., "created_at":...}."""
+    import json as _json
+    resultado = listar_historias()
+    return _json.dumps(resultado, ensure_ascii=False)
+def altar_encender_ui(nombre, intencion):
+    """Envoltorio de API para encender una luz en el Altar. Devuelve
+    JSON en texto plano: {"ok": bool, "mensaje": str}."""
+    import json as _json
+    resultado = fenix_core.encender_luz(nombre, intencion)
+    return _json.dumps(resultado, ensure_ascii=False)
+def altar_listar_ui(nombre):
+    """Envoltorio de API para listar las luces encendidas de 'nombre'.
+    Devuelve JSON en texto plano: una lista de {"intencion":..., "created_at":...}."""
+    import json as _json
+    resultado = fenix_core.listar_luces(nombre)
+    return _json.dumps(resultado, ensure_ascii=False)
+def _ciclo_con_voz(mensaje, historial, voz_seleccionada, nombre_jardin="", clave_usuario=None, incluir_bot_en_vista=True):
+    """Lógica compartida de un turno de chat + generación de audio.
+    La usan tanto responder() (la web del Space, sin cambios de comportamiento)
+    como responder_movil() (el endpoint nuevo y explícito para la app Android,
+    que además puede mandar nombre_jardin para que Fénix use el contexto del
+    Jardín — lección actual y gratitudes recientes — y clave_usuario para
+    usar la clave personal de Cerebras de esa persona si la guardó).
+    incluir_bot_en_vista controla si el río devuelto (historial_view_out)
+    incluye las inquietudes del bot autónomo. La web lo deja en True (sin
+    cambios); la app móvil lo pasa en False para ver SOLO a las personas."""
+    if not mensaje.strip():
+        return historial, "", None, cargar_conversaciones(limite=300, incluir_bot=incluir_bot_en_vista)
+    historial = historial or []
+    # 🧹 Purificación del historial para evitar Error 400 en la API de Cerebras
+    # FIX DOBLE MAESTRO: ademas de normalizar el formato, se limpia el sufijo
+    # "_(maestro: ...)" de los mensajes del asistente ANTES de enviarlos a Cerebras.
+    historial_limpio = []
+    for msg in historial:
+        if isinstance(msg, dict) and "role" in msg and "content" in msg:
+            contenido = msg["content"]
+            if msg["role"] == "assistant" and isinstance(contenido, str):
+                contenido = contenido.split(SUFIJO_MAESTRO)[0].strip()
+            historial_limpio.append({
+                "role": msg["role"],
+                "content": contenido
+            })
+    config_voces = {
+        "Anciano Sabio (Hombre Místico)": {
+            "voice": "es-ES-AlvaroNeural", "rate": "-14%", "pitch": "-12Hz", "eco_filtro": None
+        },
+        "Eco del Anciano (Voz Serena)": {
+            "voice": "es-ES-AlvaroNeural", "rate": "-10%", "pitch": "-16Hz", "eco_filtro": fenix_core.ECO_CAVERNA
+        },
+        "Voz de Teshuá (El Retorno)": {
+            "voice": "es-ES-AlvaroNeural", "rate": "-17%", "pitch": "-19Hz", "eco_filtro": fenix_core.ECO_TESHUA
+        },
+        "Guía Solemne (Hombre Profundo)": {
+            "voice": "es-ES-AlvaroNeural", "rate": "-6%", "pitch": "-22Hz", "eco_filtro": None
+        },
+        "Oráculo Celestial (Mujer Sacra)": {
+            "voice": "es-ES-ElviraNeural", "rate": "-10%", "pitch": "-6Hz", "eco_filtro": None
+        },
+        "Esencia Cálida (Voz Pausada)": {
+            "voice": "es-MX-DaliaNeural", "rate": "-9%", "pitch": "-3Hz", "eco_filtro": None
+        }
+    }
+    cfg = config_voces.get(voz_seleccionada, config_voces["Anciano Sabio (Hombre Místico)"])
+    respuesta, evaluacion = ciclo_completo(mensaje, historial_limpio, nombre_jardin, clave_usuario)
+    respuesta = respuesta.split(SUFIJO_MAESTRO)[0].strip()
+    texto_final = f"{respuesta}\n\n_(maestro: {evaluacion['veredicto']} · {evaluacion['categoria']})_"
+    historial.append({"role": "user", "content": mensaje})
+    historial.append({"role": "assistant", "content": texto_final})
+    guardar_conversacion(mensaje, texto_final)
+    # FIX CONCURRENCIA: la voz elegida por ESTE usuario se pasa directo a
+    # generar_voz, en vez de guardarse en una variable global de fenix_core.
+    # Así, si otro usuario manda un mensaje al mismo tiempo con otra voz
+    # elegida, no se pisan entre sí.
+    audio_path = generar_voz(
+        respuesta,
+        voz=cfg["voice"],
+        rate=cfg["rate"],
+        pitch=cfg["pitch"],
+        eco_filtro=cfg.get("eco_filtro"),
+    )
+    historial_actualizado = cargar_conversaciones(limite=300, incluir_bot=incluir_bot_en_vista)
+    return historial, "", audio_path, historial_actualizado
+def responder(mensaje, historial, voz_seleccionada):
+    return _ciclo_con_voz(mensaje, historial, voz_seleccionada, nombre_jardin="", clave_usuario=None)
+def responder_movil(mensaje, historial, voz_seleccionada, clave_usuario, nombre_jardin):
+    """Endpoint explícito para la app Android (api_name='fenix_chat_movil').
+    Igual que responder(), pero recibiendo clave_usuario (la clave personal
+    de Cerebras guardada en el móvil, o "" si usa el pool compartido) y
+    nombre_jardin (para el contexto de lección+gratitudes del Jardín, o ""
+    si esa persona no tiene identidad ahí todavía)."""
+    return _ciclo_con_voz(
+        mensaje, historial, voz_seleccionada,
+        nombre_jardin=nombre_jardin or "",
+        clave_usuario=(clave_usuario or None),
+        incluir_bot_en_vista=False,  # el Río móvil muestra SOLO a las personas
+    )
+def subir_pdf(archivo):
+    if archivo is None:
+        return "Por favor, selecciona un archivo PDF válido.", gr.update()
+    resultado = procesar_pdf(archivo)
+    # Refresca la lista de la biblioteca y el desplegable tras subir
+    nombres = [n for n, _ in listar_libros()]
+    return resultado + "\n\n" + texto_biblioteca(), gr.update(choices=nombres, value=None)
+def refrescar_biblioteca():
+    nombres = [n for n, _ in listar_libros()]
+    return texto_biblioteca(), gr.update(choices=nombres, value=None)
+def borrar_libro_ui(nombre):
+    estado = borrar_libro(nombre)
+    nombres = [n for n, _ in listar_libros()]
+    return estado + "\n\n" + texto_biblioteca(), gr.update(choices=nombres, value=None)
+def responder_vision(ruta_imagen, pregunta_imagen):
+    if ruta_imagen is None:
+        return "Sube o pega una imagen primero para que Fénix pueda describirla."
+    return describir_imagen(ruta_imagen, pregunta_imagen or "")
+def responder_creacion_imagen(prompt_imagen):
+    ruta_local, url_publica, estado = generar_imagen_ia(prompt_imagen)
+    galeria = cargar_galeria_imagenes()
+    return ruta_local, estado, galeria
+def refrescar_galeria():
+    return cargar_galeria_imagenes()
+def controlar_musica(seleccion):
+    mapeo_canciones = {
+        "Canción 1 (Espiritual)": "cancion_1.mp3",
+        "Canción 2 (Meditación)": "cancion_2.mp3",
+        "Canción 3 (Sacra)": "cancion_3.mp3",
+        "Canción 4 (Armonía)": "cancion_4.mp3",
+        "Canción 5 (Celestial)": "cancion_5.mp3",
+        "Canción 6 (Mística)": "cancion_6.mp3"
+    }
+    if seleccion == "Silencio":
+        return None, "_Atmósfera en silencio._"
+    archivo_objetivo = mapeo_canciones.get(seleccion)
+    if archivo_objetivo and os.path.exists(archivo_objetivo):
+        return archivo_objetivo, f"🎵 **Sonando ahora:** {seleccion}"
+    else:
+        return None, f"⚠️ El archivo `{archivo_objetivo}` no está en el Space. Súbelo para escucharlo."
+def guardar_claves_usuario(pin_admin, c1, c2, c3, c4, n1, n2, n3, n4):
+    pin_real = os.environ.get("FENIX_ADMIN_PIN", "")
+    if not pin_real:
+        return "🔒 Panel bloqueado: define el secret FENIX_ADMIN_PIN en los Settings del Space para habilitarlo."
+    if (pin_admin or "").strip() != pin_real.strip():
+        return "🔒 Código de administrador incorrecto."
+    cerebras_list = [c1, c2, c3, c4]
+    nvidia_list = [n1, n2, n3, n4]
+    if not any(k and k.strip() for k in cerebras_list + nvidia_list):
+        return "⚠️ No se aplicó nada: todas las casillas están vacías."
+    actualizar_claves_dinamicas(cerebras_list, nvidia_list)
+    return "✅ ¡Pool de claves actualizado en caliente! Los modelos ahora rotarán entre estas credenciales."
+def estado_progreso_oraculo() -> str:
+    """Muestra en la pestaña de configuración cómo va la preparación del oráculo."""
+    progreso = obtener_progreso(BOT_ID)
+    nivel = progreso.get("nivel", 0)
+    preguntas_hoy = progreso.get("preguntas_hoy", 0)
+    descripcion = _descripcion_nivel_oraculo(nivel)
+    categoria_actual = _categoria_del_turno(nivel, preguntas_hoy)
+    return (
+        f"🔮 **Nivel de preparación:** {nivel}/100\n\n"
+        f"**Profundidad de hoy:** {descripcion}\n\n"
+        f"**Próxima categoría:** {categoria_actual}\n\n"
+        f"**Inquietudes generadas hoy:** {preguntas_hoy}/{PREGUNTAS_POR_DIA}"
+    )
+# =====================================================================
+# BOT DE INQUIETUDES HUMANAS INTEGRADO (BACKGROUND THREAD)
+# Preparación del oráculo: sube +1 nivel por día, 10 inquietudes/día,
+# rotando categorías y con profundidad creciente segun el nivel.
+# =====================================================================
+def bucle_inquietudes_espirituales():
+    time.sleep(5)
+    print("✨ [Nube] Iniciando el Bot de Inquietudes Existenciales (preparación del oráculo)...")
+    historial_simulado = []
+    while True:
+        try:
+            progreso = obtener_progreso(BOT_ID)
+            nivel = progreso.get("nivel", 0)
+            preguntas_hoy = progreso.get("preguntas_hoy", 0)
+            if preguntas_hoy >= PREGUNTAS_POR_DIA:
+                print(f"💤 [Bot Oráculo] Meta diaria cumplida (nivel {nivel}/100). Esperando al día siguiente...")
+                time.sleep(_segundos_hasta_manana())
+                continue
+            c_key = fenix_core.CEREBRAS_KEYS_POOL[0] if fenix_core.CEREBRAS_KEYS_POOL else (os.environ.get("CEREBRAS_KEY") or os.environ.get("CEREBRAS_API_KEY"))
+            if not c_key:
+                print("⚠️ [Bot Nube] Esperando configuración de la clave de Cerebras...")
+                time.sleep(30)
+                continue
+            categoria = _categoria_del_turno(nivel, preguntas_hoy)
+            descripcion_nivel = _descripcion_nivel_oraculo(nivel)
+            temas_previos = progreso.get("temas_recientes") or []
+            evitar = ""
+            if temas_previos:
+                lista = "\n".join(f"- {t[:100]}" for t in temas_previos[-10:])
+                evitar = f"\n\nNO repitas ni parafrasees estas inquietudes ya usadas recientemente:\n{lista}"
+            prompt_generador_crisis = (
+                f"Eres un simulador de la psique humana real, atrapada en el sufrimiento, la duda "
+                f"existencial y la búsqueda de la verdad. Estás generando la inquietud del nivel "
+                f"{nivel} de 100 en la preparación progresiva de un oráculo espiritual. "
+                f"Hoy debes enfocarte en esta categoría concreta: {categoria}. "
+                f"El grado de profundidad correspondiente a este nivel es: {descripcion_nivel}. "
+                "Redacta UNA pregunta o inquietud extremadamente profunda, sincera y de la mejor "
+                "calidad posible para ese nivel y esa categoría. Escribe en primera persona, como un "
+                "buscador desesperado, un filósofo atormentado, alguien con miedo genuino, o alguien "
+                "cuestionando un pasaje concreto de la Biblia." + evitar +
+                "\nDevuelve ÚNICAMENTE la inquietud mística cruda, sin introducciones corporativas, "
+                "saludos ni preámbulos."
+            )
+            try:
+                inquietud_generada = llamar_cerebras_directo(
+                    api_key=c_key,
+                    model=fenix_core.MODELO_FENIX,
+                    messages=[{"role": "system", "content": prompt_generador_crisis},
+                              {"role": "user", "content": "Genera la inquietud ahora."}],
+                    temperature=0.95,
+                    # gpt-oss-120b es un modelo razonador: con 220 tokens se los
+                    # gastaba TODOS "pensando" y nunca escribía la respuesta
+                    # (llegaba 'reasoning' sin 'content'). reasoning_effort=low
+                    # recorta el pensamiento interno y max_tokens=700 deja
+                    # presupuesto de sobra para la pregunta final.
+                    max_tokens=700,
+                    reasoning_effort="low"
+                ).strip()
+            except Exception:
+                rotar_clave_cerebras_fallida()
+                raise
+            respuesta, evaluacion = ciclo_completo(inquietud_generada, historial_simulado)
+            texto_persistido = f"{respuesta}\n\n_(maestro: {evaluacion['veredicto']} · {evaluacion['categoria']})_"
+            guardar_conversacion(f"[Bot Autónomo · Nivel {nivel}/100 · {categoria}] {inquietud_generada}", texto_persistido)
+            registrar_pregunta(BOT_ID, inquietud_generada)
+            historial_simulado.append({"role": "user", "content": inquietud_generada})
+            historial_simulado.append({"role": "assistant", "content": respuesta})
+            if len(historial_simulado) > 6:
+                historial_simulado = historial_simulado[-6:]
+            print(f"✅ [Bot Oráculo] Inquietud {preguntas_hoy + 1}/{PREGUNTAS_POR_DIA} del nivel {nivel}/100 ({categoria}) registrada.")
+        except Exception as e:
+            print(f"⚠️ [Bot Nube] Error en el ciclo de meditación continua: {e}")
+        time.sleep(INTERVALO_SEGUNDOS)
+# Lanzar hilo en segundo plano
+threading.Thread(target=bucle_inquietudes_espirituales, daemon=True).start()
+# =====================================================================
+with gr.Blocks(title="Fénix Aprendiz") as demo:
+    fenix_header("Fénix Aprendiz", "Una experiencia mística e inmersiva gobernada por Inteligencia Artificial.")
+    with gr.Tabs():
+        # --- PESTAÑA 1: EL ORÁCULO ---
+        with gr.TabItem("🔮 El Oráculo"):
+            gr.HTML(
+                '<div class="orbe-contenedor">'
+                '<div class="brasa"></div><div class="brasa"></div>'
+                '<div class="brasa"></div><div class="brasa"></div>'
+                '<span class="letra-hebrea letra-1">ת</span>'
+                '<span class="letra-hebrea letra-2">ש</span>'
+                '<span class="letra-hebrea letra-3">ו</span>'
+                '<span class="letra-hebrea letra-4">ע</span>'
+                '<span class="letra-hebrea letra-5">ה</span>'
+                '<div class="orbe-luz"></div>'
+                '</div>'
+            )
+            with gr.Row():
+                with gr.Column(scale=3):
+                    chatbot = gr.Chatbot(
+                        label="Canal de Comunicación Sagrada",
+                        height=520,
+                        value=cargar_conversaciones(limite=40),
+                    )
+                    with gr.Row():
+                        txt = gr.Textbox(
+                            placeholder="Escríbele a Fénix...",
+                            show_label=False,
+                            scale=4,
+                            lines=1
+                        )
+                        send_btn = gr.Button("Enviar 🔥", scale=1)
+                    audio_respuesta = gr.Audio(
+                        label="🔊 Voz de Fénix",
+                        autoplay=True,
+                        elem_id="audio_voz_fenix"
+                    )
+                with gr.Column(scale=1):
+                    gr.Markdown("### 🗣️ Identidad Vocal")
+                    selector_voz = gr.Dropdown(
+                        choices=[
+                            "Anciano Sabio (Hombre Místico)",
+                            "Eco del Anciano (Voz Serena)",
+                            "Voz de Teshuá (El Retorno)",
+                            "Guía Solemne (Hombre Profundo)",
+                            "Oráculo Celestial (Mujer Sacra)",
+                            "Esencia Cálida (Voz Pausada)"
+                        ],
+                        value="Guía Solemne (Hombre Profundo)",
+                        label="Selecciona la voz de Fénix",
+                        interactive=True
+                    )
+                    gr.Markdown("### 🎶 Ambiente Musical")
+                    selector_musica = gr.Dropdown(
+                        choices=[
+                            "Silencio",
+                            "Canción 1 (Espiritual)",
+                            "Canción 2 (Meditación)",
+                            "Canción 3 (Sacra)",
+                            "Canción 4 (Armonía)",
+                            "Canción 5 (Celestial)",
+                            "Canción 6 (Mística)"
+                        ],
+                        value="Silencio",
+                        label="Elige la melodía de fondo",
+                        interactive=True
+                    )
+                    musica_status = gr.Markdown("_Atmósfera en silencio._")
+                    musica_player = gr.Audio(
+                        label="Reproductor en Bucle",
+                        loop=True,
+                        autoplay=True
+                    )
+        # --- PESTAÑA 2: MEMORIA DOCUMENTAL (SUBIDA DE PDF) ---
+        with gr.TabItem("📄 Memoria Documental"):
+            gr.Markdown("### 📚 Enseña nuevos conocimientos a Fénix")
+            gr.Markdown("Al subir un manuscrito en PDF, el sistema lo segmentará y guardará en Supabase. Fénix recurrirá a él en cada dilema.")
+            with gr.Row():
+                with gr.Column():
+                    pdf_input = gr.File(label="Carga tu archivo PDF", file_types=[".pdf"])
+                with gr.Column():
+                    pdf_status = gr.Markdown("_Esperando un documento sagrado..._")
+            gr.Markdown("---")
+            gr.Markdown("### 🗂️ Biblioteca de Fénix")
+            gr.Markdown("Aquí ves todos los libros cargados. Si alguno no encaja con el mensaje de Teshuá, puedes borrarlo (es reversible: vuelves a subir el PDF cuando quieras).")
+            biblioteca_estado = gr.Markdown("_Pulsa actualizar para ver los libros..._")
+            with gr.Row():
+                selector_libro = gr.Dropdown(label="Elige un libro para borrar", choices=[], value=None, interactive=True)
+                btn_actualizar_biblioteca = gr.Button("🔄 Actualizar lista")
+                btn_borrar_libro = gr.Button("🗑️ Borrar libro elegido", variant="stop")
+        # --- PESTAÑA 2.5: VISIÓN Y CREACIÓN DE IMÁGENES (IA GRATUITA) ---
+        with gr.TabItem("🖼️ Visión & Creación"):
+            gr.Markdown("### 👁️ Ojo de Fénix — describir imágenes")
+            gr.Markdown("Sube una imagen y Fénix la describirá usando visión gratuita (NVIDIA NIM).")
+            with gr.Row():
+                with gr.Column():
+                    vision_input = gr.Image(label="Sube una imagen", type="filepath")
+                    vision_pregunta = gr.Textbox(
+                        label="¿Qué quieres preguntar sobre la imagen? (opcional)",
+                        placeholder="Ej: ¿Qué simbolismo espiritual ves aquí?"
+                    )
+                    vision_btn = gr.Button("👁️ Describir imagen", variant="primary")
+                with gr.Column():
+                    vision_output = gr.Textbox(label="Descripción de Fénix", lines=10, interactive=False)
+            gr.Markdown("---")
+            gr.Markdown("### 🎨 Fragua de Imágenes — creación con IA (gratis)")
+            gr.Markdown("Describe la imagen que quieres crear. Se genera gratis y queda guardada en tu galería de Supabase.")
+            with gr.Row():
+                with gr.Column():
+                    crear_prompt = gr.Textbox(
+                        label="Describe la imagen especial que quieres crear",
+                        placeholder="Ej: un ave fénix dorada renaciendo de las cenizas, estilo místico, fondo negro"
+                    )
+                    crear_btn = gr.Button("🔥 Crear imagen", variant="primary")
+                    crear_status = gr.Markdown("_Esperando tu visión..._")
+                with gr.Column():
+                    crear_output = gr.Image(label="Imagen creada", type="filepath")
+            gr.Markdown("#### 🗂️ Galería guardada en Supabase")
+            btn_refrescar_galeria = gr.Button("🔄 Refrescar galería")
+            galeria_imagenes = gr.Gallery(label="Imágenes especiales creadas", columns=4, height="auto")
+        # --- PESTAÑA 3: HISTORIAL ---
+        with gr.TabItem("🕰️ Historial"):
+            gr.Markdown("### 🕰️ Conversaciones pasadas con Fénix")
+            gr.Markdown("Conversaciones unificadas en Supabase. Haz clic en actualizar para traer los últimos retos del bot de fondo.")
+            historial_view = gr.Chatbot(
+                label="Historial completo",
+                height=600,
+                value=cargar_conversaciones(limite=300),
+            )
+            with gr.Row():
+                btn_refrescar_historial = gr.Button("🔄 Actualizar historial")
+                btn_revisar_lecciones = gr.Button("🎓 Revisar historial y aprender")
+            estado_revision = gr.Markdown("_Fénix aprende en tiempo real de cada turno._")
+        # --- PESTAÑA 4: MULTI-API KEYS Y PROGRESO ---
+        with gr.TabItem("⚙️ Configuración"):
+            gr.Markdown("### 🔮 Preparación del Oráculo (0 a 100)")
+            gr.Markdown("El bot de fondo sube +1 nivel automáticamente cada día, rota entre 6 categorías (miedos, crisis de fe, propósito, debates bíblicos, consejo, alma/más allá) y genera 10 inquietudes diarias, sin repetir temas.")
+            progreso_view = gr.Markdown(estado_progreso_oraculo())
+            btn_refrescar_progreso = gr.Button("🔄 Actualizar progreso")
+            gr.Markdown("---")
+            gr.Markdown("### 🔑 Panel de Multi-API Keys en Caliente")
+            gr.Markdown("Configura credenciales alternativas. Requiere el código de administrador (secret `FENIX_ADMIN_PIN` del Space). El sistema rotará automáticamente ante cualquier error de red.")
+            admin_pin = gr.Textbox(label="🔐 Código de administrador", type="password")
+            with gr.Row():
+                with gr.Column():
+                    gr.Markdown("#### 🟢 API Keys de Cerebras (Hasta 4)")
+                    g_key_1 = gr.Textbox(label="Cerebras Key 1 (Principal)", type="password")
+                    g_key_2 = gr.Textbox(label="Cerebras Key 2", type="password")
+                    g_key_3 = gr.Textbox(label="Cerebras Key 3", type="password")
+                    g_key_4 = gr.Textbox(label="Cerebras Key 4", type="password")
+                with gr.Column():
+                    gr.Markdown("#### 🟢 API Keys de NVIDIA (Hasta 4)")
+                    n_key_1 = gr.Textbox(label="NVIDIA Key 1 (Principal)", type="password")
+                    n_key_2 = gr.Textbox(label="NVIDIA Key 2", type="password")
+                    n_key_3 = gr.Textbox(label="NVIDIA Key 3", type="password")
+                    n_key_4 = gr.Textbox(label="NVIDIA Key 4", type="password")
+            btn_guardar_claves = gr.Button("💾 Aplicar y Registrar Claves", variant="primary")
+            estado_claves = gr.Markdown("_Pool de claves activo y listo._")
+    # --- Endpoint de API "identidad_login" para el Jardín (Templo de
+    # Gratitud, Círculo de Historias, Río de Conversación) ---
+    # Componentes ocultos: no aparecen en la interfaz visible del chat, solo
+    # existen para que Android pueda llamar a gradio_api/call/identidad_login.
+    with gr.Row(visible=False):
+        identidad_nombre_in = gr.Textbox(label="nombre")
+        identidad_pin_in = gr.Textbox(label="pin")
+        identidad_resultado_out = gr.Textbox(label="resultado_json")
+        identidad_btn = gr.Button("identidad_login")
+    identidad_btn.click(
+        fn=identidad_login_ui,
+        inputs=[identidad_nombre_in, identidad_pin_in],
+        outputs=[identidad_resultado_out],
+        api_name="identidad_login",
+    )
+    # --- Endpoints de API del Templo de Gratitud ---
+    with gr.Row(visible=False):
+        gratitud_nombre_in = gr.Textbox(label="nombre")
+        gratitud_texto_in = gr.Textbox(label="texto")
+        gratitud_guardar_out = gr.Textbox(label="resultado_json")
+        gratitud_guardar_btn = gr.Button("gratitud_guardar")
+    gratitud_guardar_btn.click(
+        fn=gratitud_guardar_ui,
+        inputs=[gratitud_nombre_in, gratitud_texto_in],
+        outputs=[gratitud_guardar_out],
+        api_name="gratitud_guardar",
+    )
+    with gr.Row(visible=False):
+        gratitud_listar_nombre_in = gr.Textbox(label="nombre")
+        gratitud_listar_out = gr.Textbox(label="resultado_json")
+        gratitud_listar_btn = gr.Button("gratitud_listar")
+    gratitud_listar_btn.click(
+        fn=gratitud_listar_ui,
+        inputs=[gratitud_listar_nombre_in],
+        outputs=[gratitud_listar_out],
+        api_name="gratitud_listar",
+    )
+    # --- Endpoints de API del Altar de la Luz ---
+    with gr.Row(visible=False):
+        altar_nombre_in = gr.Textbox(label="nombre")
+        altar_intencion_in = gr.Textbox(label="intencion")
+        altar_encender_out = gr.Textbox(label="resultado_json")
+        altar_encender_btn = gr.Button("altar_encender")
+    altar_encender_btn.click(
+        fn=altar_encender_ui,
+        inputs=[altar_nombre_in, altar_intencion_in],
+        outputs=[altar_encender_out],
+        api_name="altar_encender",
+    )
+    with gr.Row(visible=False):
+        altar_listar_nombre_in = gr.Textbox(label="nombre")
+        altar_listar_out = gr.Textbox(label="resultado_json")
+        altar_listar_btn = gr.Button("altar_listar")
+    altar_listar_btn.click(
+        fn=altar_listar_ui,
+        inputs=[altar_listar_nombre_in],
+        outputs=[altar_listar_out],
+        api_name="altar_listar",
+    )
+    # --- Endpoints de API del Círculo de Historias (comunal) ---
+    with gr.Row(visible=False):
+        circulo_nombre_in = gr.Textbox(label="nombre")
+        circulo_texto_in = gr.Textbox(label="texto")
+        circulo_publicar_out = gr.Textbox(label="resultado_json")
+        circulo_publicar_btn = gr.Button("circulo_publicar")
+    circulo_publicar_btn.click(
+        fn=circulo_publicar_ui,
+        inputs=[circulo_nombre_in, circulo_texto_in],
+        outputs=[circulo_publicar_out],
+        api_name="circulo_publicar",
+    )
+    with gr.Row(visible=False):
+        circulo_listar_out = gr.Textbox(label="resultado_json")
+        circulo_listar_btn = gr.Button("circulo_listar")
+    circulo_listar_btn.click(
+        fn=circulo_listar_ui,
+        inputs=[],
+        outputs=[circulo_listar_out],
+        api_name="circulo_listar",
+    )
+    # --- Endpoint explícito para el chat de la app Android (Jardín) ---
+    # Deliberadamente separado de txt.submit/send_btn.click (la web del
+    # Space), que no tienen api_name explícito y no deben tocarse. Este es
+    # el único endpoint de chat que la app móvil debería llamar de aquí
+    # en adelante: FenixApiClient.kt necesita apuntar a "fenix_chat_movil"
+    # y mandar el nombre del Jardín (o "" si la persona no tiene identidad).
+    with gr.Row(visible=False):
+        movil_mensaje_in = gr.Textbox(label="mensaje")
+        movil_historial_in = gr.JSON(label="historial")
+        movil_voz_in = gr.Textbox(label="voz_seleccionada")
+        movil_clave_in = gr.Textbox(label="clave_usuario")
+        movil_nombre_in = gr.Textbox(label="nombre_jardin")
+        movil_historial_out = gr.JSON(label="historial_out")
+        movil_txt_out = gr.Textbox(label="txt_out")
+        movil_audio_out = gr.Audio(label="audio_out")
+        movil_historial_view_out = gr.JSON(label="historial_view_out")
+        movil_btn = gr.Button("fenix_chat_movil")
+    movil_btn.click(
+        fn=responder_movil,
+        inputs=[movil_mensaje_in, movil_historial_in, movil_voz_in, movil_clave_in, movil_nombre_in],
+        outputs=[movil_historial_out, movil_txt_out, movil_audio_out, movil_historial_view_out],
+        api_name="fenix_chat_movil",
+    )
+    # Gestión de Eventos
+    txt.submit(
+        fn=responder,
+        inputs=[txt, chatbot, selector_voz],
+        outputs=[chatbot, txt, audio_respuesta, historial_view],
+        js=JS_ORBE_PENSANDO
+    )
+    send_btn.click(
+        fn=responder,
+        inputs=[txt, chatbot, selector_voz],
+        outputs=[chatbot, txt, audio_respuesta, historial_view],
+        js=JS_ORBE_PENSANDO
+    )
+    btn_refrescar_historial.click(
+        fn=lambda: cargar_conversaciones(limite=300),
+        outputs=historial_view
+    )
+    btn_revisar_lecciones.click(
+        fn=revisar_conversaciones_pendientes,
+        outputs=estado_revision
+    )
+    vision_btn.click(
+        fn=responder_vision,
+        inputs=[vision_input, vision_pregunta],
+        outputs=[vision_output]
+    )
+    crear_btn.click(
+        fn=responder_creacion_imagen,
+        inputs=[crear_prompt],
+        outputs=[crear_output, crear_status, galeria_imagenes]
+    )
+    btn_refrescar_galeria.click(
+        fn=refrescar_galeria,
+        inputs=[],
+        outputs=[galeria_imagenes]
+    )
+    demo.load(
+        fn=refrescar_galeria,
+        inputs=[],
+        outputs=[galeria_imagenes]
+    )
+    pdf_input.change(
+        fn=subir_pdf,
+        inputs=pdf_input,
+        outputs=[pdf_status, selector_libro]
+    )
+    btn_actualizar_biblioteca.click(
+        fn=refrescar_biblioteca,
+        inputs=None,
+        outputs=[biblioteca_estado, selector_libro]
+    )
+    btn_borrar_libro.click(
+        fn=borrar_libro_ui,
+        inputs=selector_libro,
+        outputs=[biblioteca_estado, selector_libro]
+    )
+    selector_musica.change(
+        fn=controlar_musica,
+        inputs=selector_musica,
+        outputs=[musica_player, musica_status]
+    )
+    btn_guardar_claves.click(
+        fn=guardar_claves_usuario,
+        inputs=[admin_pin, g_key_1, g_key_2, g_key_3, g_key_4, n_key_1, n_key_2, n_key_3, n_key_4],
+        outputs=estado_claves
+    )
+    btn_refrescar_progreso.click(
+        fn=estado_progreso_oraculo,
+        outputs=progreso_view
+    )
+    fenix_footer()
+if __name__ == "__main__":
+    # FIX CONCURRENCIA: sin queue(), Gradio por defecto ya encola las
+    # peticiones, pero con concurrency_count=1 implícito en muchas versiones
+    # (una petición a la vez para TODO el Space). default_concurrency_limit
+    # sube cuántas peticiones de 'responder' (y del resto de botones) se
+    # procesan en paralelo. Súbelo con cuidado: cada una consume RAM/CPU del
+    # Space y hace una llamada a Cerebras/NVIDIA/Edge-TTS en simultáneo.
+    # Con el hardware básico gratuito de HF, 4 es un punto de partida
+    # razonable; si tienes hardware pago con más CPU/RAM, puedes subirlo.
+    demo.queue(default_concurrency_limit=4, max_size=50)
+    demo.launch(theme=apply_fenix_theme(), css=FENIX_CSS, head=SCRIPT_ANALIZADOR_VOZ)