Arquitectura Y (tri-LLM) + mejoras de recuperación y robustez

- y_refiner.py: YRefiner con α (GLM-5.2) + γ (Kimi-K2.6) en paralelo y
N (DeepSeek-V4-Flash) bajo contrato (1 línea, ≤60 palabras). Cadenas
de fallback por rol, circuit breaker de sesión, reasoning_effort=none
para modelos híbridos, degradación 4 escalones, telemetría con coste.
- agent.py: prefijo BGE en queries, re-ranking CrossEncoder (top 30→15),
MMR λ=0.7 para léxico diverso, filtro de fragmentos 5-48 chars,
warmup de modelos en arranque.
- app.py: toggle ⚡Rápido/🔱Y, modo rápido sobre registry con fallback
(R6), strip de bloques <think>, verificación de catálogo al arrancar.
- README reescrito (transcript pegado eliminado, modelos reales).
- semantic_database.py eliminado (código muerto).

Verificado: contrato N 5/5 al primer intento, latencia media 8.3s,
degradación parcial y total OK, modo rápido sin regresión.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>

.gitignore

@@ -0,0 +1,2 @@
+__pycache__/
+*.pyc

README.md

@@ -13,187 +13,71 @@ short_description: Enriquecimiento de prompts visuales
 
 # PromptCraft: Refinamiento Estructural de Prompts
 
-**PromptCraft** es un sistema de ingeniería de prompts asistida por IA que transforma ideas en lenguaje natural en prompts optimizados para modelos de difusión (Midjourney, FLUX, SDXL).  
-A diferencia de los refinadores basados en parafraseo, **PromptCraft analiza la gramática descriptiva de 100.000 prompts profesionales** y reconstruye el concepto del usuario imitando esa estructura real.
+**PromptCraft** transforma ideas en castellano en prompts optimizados para modelos de
+difusión (SDXL, FLUX, Midjourney). Analiza la gramática descriptiva de ~100.000 prompts
+profesionales (índice FAISS local) y reconstruye el concepto del usuario imitando esa
+estructura real.
 
 > **No impone plantillas. No inventa. Solo estructura.**
 
----
-
-## 🌐 Flujo del sistema
-Usuario (castellano)
-↓
-Traducción local (es → en)
-↓
-Recuperación semántica (FAISS + categoría)
-↓
-Re-ranking con Cross-Encoder (top 6)
-↓
-Reconstrucción con LLaMA-3.2-3B (gramática del dataset)
-↓
-Generación con SDXL
-
-
----
-
-## 🔑 Características clave
-
-- **Refinamiento estructural**: el LLM imita la gramática de prompts reales, no sigue una plantilla abstracta.
-- **Categorización contextual**: filtra ejemplos por tipo (entidad, estilo, composición, etc.).
-- **Transparencia total**: muestra los 6 ejemplos del dataset usados para el refinamiento.
-- **Iteración libre**: refina el prompt tantas veces como necesites antes de generar.
-- **100% funcional en CPU**: traducción y análisis locales; solo la generación usa la nube.
-
----
+## ⚙️ Dos motores de refinamiento
+
+### ⚡ Modo Rápido (1 LLM)
+Pipeline clásico de una sola llamada:
+
+```
+castellano → traducción (Helsinki-NLP opus-mt-es-en, Inference API)
+          → recuperación semántica (FAISS + bge-small-en-v1.5, prefijo BGE en query)
+          → re-ranking (CrossEncoder ms-marco-MiniLM-L6-v2) + MMR (λ=0.7)
+          → composición estructural (Qwen2.5-7B-Instruct)
+          → validación (≤60 palabras, concepto presente) → SDXL
+```
+
+### 🔱 Modo Y (3 LLMs)
+Dos generadores en paralelo bajo restricciones heterogéneas, un normalizador bajo
+contrato estricto:
+
+```
+                    ┌─ α zai-org/GLM-5.2 ── vocabulario canónico SDXL + léxico FAISS
+concepto traducido ─┤                                                    (en paralelo)
+                    └─ γ moonshotai/Kimi-K2.6 ── solo lenguaje visual concreto,
+                                                 quality-tags prohibidos
+                          ↓
+        N deepseek-ai/DeepSeek-V4-Flash ── integra α+γ: 1 línea, ≤60 palabras
+                          ↓
+        contrato incumplido → 1 reintento (temp 0) → modo rápido → fallback semántico
+```
+
+Todos los modelos se sirven vía el router de Hugging Face
+(`https://router.huggingface.co/v1`, secreto `HF_TOKEN`), con cadena de fallback de
+provider/modelo por rol y `reasoning_effort="none"` para desactivar el modo thinking
+de los modelos híbridos. Generación de imagen:
+`stabilityai/stable-diffusion-xl-base-1.0`.
 
 ## 🛠️ Cómo usarlo
 
-1. **Escribe tu idea en castellano** (ej: *"un mercado en Antigua Guatemala"*).
-2. **(Opcional) Selecciona una categoría**:
-   - **Automática**: el sistema decide.
-   - **Entidad**: personas, objetos, criaturas.
-   - **Composición**: escenas, entornos, narrativas.
-   - **Estilo artístico**: pintura, ilustración, fotografía.
-   - **Imaginativo**: fantasía, ciencia ficción.
-   - **Texto**: tipografía, logotipos.
-3. Haz clic en **"🔄 Refinar prompt"**.
-4. Si no te gusta el resultado, **refina de nuevo**.
-5. Cuando estés satisfecho, haz clic en **"🎨 Generar imagen"**.
+1. Escribe tu idea en castellano.
+2. (Opcional) Selecciona categoría (entidad, composición, estilo, imaginativo, texto).
+3. Elige motor: **⚡ Rápido** (por defecto) o **🔱 Modo Y** (más lento, mayor calidad).
+4. **🔄 Refinar prompt** — repite hasta que te guste. El panel de estado muestra qué
+   motor/escalón produjo el resultado, latencias por nodo y coste estimado de sesión.
+5. **🎨 Generar imagen**.
 
----
+## 📁 Dataset
 
-## 📁 Requisitos del dataset
-
-Tu `metadata.json` debe tener este formato:
-```json
-[
-  {
-    "caption": "a cyberpunk street at night, neon signs...",
-    "category": "composition"
-  },
-  {
-    "caption": "oil painting of a forest, style of Van Gogh",
-    "category": "style"
-  }
-]
-
-Sin el campo "category", el sistema funciona en modo "Automática" (sin filtrar). 
-
-📦 Dependencias
-gradio==4.24.0
-Pillow
-huggingface-hub>=0.24.0
-sentence-transformers>=2.3.0
-faiss-cpu==1.7.4
-datasets>=2.10.0
-torch
-transformers
-sentencepiece
-profile
-Qwen3-Max
-7:48 pm
-¡Claro, socio! Aquí tienes el README.md completo en un solo bloque de código, listo para copiar y pegar, con los créditos finales como pediste.
-
-markdown
-
-
-1
-2
-3
-4
-5
-6
-7
-8
-9
-10
-11
-⌄
-⌄
-# PromptCraft: Refinamiento Estructural de Prompts
+`metadata.json`: lista de `{"caption": "...", "category": "..."}`. Sin `category`,
+todo funciona en modo "Automática". `faiss_index.bin` contiene los embeddings
+(bge-small-en-v1.5, sin prefijo — el prefijo BGE se aplica solo a las queries).
 
-**PromptCraft** es un sistema de ingeniería de prompts asistida por IA que transforma ideas en lenguaje natural en prompts optimizados para modelos de difusión (Midjourney, FLUX, SDXL).  
-A diferencia de los refinadores basados en parafraseo, **PromptCraft analiza la gramática descriptiva de 100.000 prompts profesionales** y reconstruye el concepto del usuario imitando esa estructura real.
+## 📦 Dependencias
 
-> **No impone plantillas. No inventa. Solo estructura.**
+Ver `requirements.txt` (versiones con wheels verificados para Python 3.13).
 
----
+## 🚀 Créditos
 
-## 🌐 Flujo del sistema
-
-Usuario (castellano)
-↓
-Traducción local (es → en)
-↓
-Recuperación semántica (FAISS + categoría)
-↓
-Re-ranking con Cross-Encoder (top 6)
-↓
-Reconstrucción con LLaMA-3.2-3B (gramática del dataset)
-↓
-Generación con SDXL
-
----
-
-## 🔑 Características clave
-
-- **Refinamiento estructural**: el LLM imita la gramática de prompts reales, no sigue una plantilla abstracta.
-- **Categorización contextual**: filtra ejemplos por tipo (entidad, estilo, composición, etc.).
-- **Transparencia total**: muestra los 6 ejemplos del dataset usados para el refinamiento.
-- **Iteración libre**: refina el prompt tantas veces como necesites antes de generar.
-- **100% funcional en CPU**: traducción y análisis locales; solo la generación usa la nube.
-
----
-
-## 🛠️ Cómo usarlo
-
-1. **Escribe tu idea en castellano** (ej: *"un mercado en Antigua Guatemala"*).
-2. **(Opcional) Selecciona una categoría**:
-   - **Automática**: el sistema decide.
-   - **Entidad**: personas, objetos, criaturas.
-   - **Composición**: escenas, entornos, narrativas.
-   - **Estilo artístico**: pintura, ilustración, fotografía.
-   - **Imaginativo**: fantasía, ciencia ficción.
-   - **Texto**: tipografía, logotipos.
-3. Haz clic en **"🔄 Refinar prompt"**.
-4. Si no te gusta el resultado, **refina de nuevo**.
-5. Cuando estés satisfecho, haz clic en **"🎨 Generar imagen"**.
-
----
+- Motor semántico: FAISS + bge-small-en-v1.5 + CrossEncoder + MMR.
+- Traducción: Helsinki-NLP/opus-mt-es-en.
+- Refinamiento: Qwen2.5-7B (rápido) · GLM-5.2 + Kimi-K2.6 + DeepSeek-V4-Flash (Y).
+- Generación: stabilityai/stable-diffusion-xl-base-1.0.
 
-## 📁 Requisitos del dataset
-
-Tu `metadata.json` debe tener este formato:
-```json
-[
-  {
-    "caption": "a cyberpunk street at night, neon signs...",
-    "category": "composition"
-  },
-  {
-    "caption": "oil painting of a forest, style of Van Gogh",
-    "category": "style"
-  }
-]
-Sin el campo "category", el sistema funciona en modo "Automática" (sin filtrar). 
-
-📦 Dependencias
-
-gradio==4.24.0
-Pillow
-huggingface-hub>=0.24.0
-sentence-transformers>=2.3.0
-faiss-cpu==1.7.4
-datasets>=2.10.0
-torch
-transformers
-sentencepiece
-
-🚀 Créditos
-Motor semántico: FAISS + bge-small-en-v1.5 + Cross-Encoder.
-Traducción: Helsinki-NLP/opus-mt-es-en (local, CPU).
-Refinamiento: meta-llama/Llama-3.2-3B-Instruct.
-Generación: stabilityai/stable-diffusion-xl-base-1.0.
-Este proyecto nace de la necesidad de coherencia narrativa y control estructural en la generación de imágenes por IA, especialmente para cineastas, escritores y artistas visuales.
-
-Creado por Angel E. Pariente 🇬🇹 según la idea de Nacho Ravinovich 🇦🇷
+Creado por Angel E. Pariente 🇬🇹 · Sobre una idea de Nacho Ravinovich 🇦🇷

agent.py

@@ -22,6 +22,10 @@ CONTENT_BLACKLIST = {"tokyo","antigua","guatemala","maya","indigenous","renaissa
                      "crimson","cerulean","velvet","silk","golden retriever","yorkshire terrier","atitlán",
                      "lucy nicholson","henrietta harris","blade runner","van gogh","jakub rozalski","carole at camelotcostumes"}
 
+# BGE requiere este prefijo SOLO en las queries; los documentos del índice
+# se embebieron sin prefijo (build estándar), así que el índice no se toca.
+BGE_QUERY_PREFIX = "Represent this sentence for searching relevant passages: "
+
 try:
     NLP = spacy.load("en_core_web_sm")
 except:
@@ -49,6 +53,13 @@ class ImprovedSemanticAgent:
                 self.indexed_examples = json.load(f)
             self.total_indexed = len(self.indexed_examples)
             self.is_ready = True
+            # Warmup: la primera inferencia de cada modelo paga carga/compilación
+            # (~10s); hacerlo en el arranque y no en el primer usuario.
+            try:
+                self.embedding_model.encode(["warmup"], normalize_embeddings=True)
+                self.reranker.predict([("warmup", "warmup")])
+            except Exception as e:
+                logger.warning(f"⚠️ Warmup fallido (no crítico): {e}")
             return f"✅ {self.total_indexed:,} ejemplos cargados"
         except Exception as e:
             return f"❌ Error: {str(e)}"
@@ -59,18 +70,29 @@ class ImprovedSemanticAgent:
             if not self.is_ready: return self._default_response()
             
         try:
-            query_emb = self.embedding_model.encode([user_en], normalize_embeddings=True)[0].astype('float32').reshape(1, -1)
+            query_emb = self.embedding_model.encode(
+                [BGE_QUERY_PREFIX + user_en], normalize_embeddings=True
+            )[0].astype('float32').reshape(1, -1)
             _, idxs = self.index.search(query_emb, 50)
-            
-            examples = []
+
+            # Candidatos válidos (hasta 30) conservando su idx para recuperar embeddings
+            candidates = []
             for idx in idxs[0]:
                 if 0 <= idx < len(self.indexed_examples):
                     ex = self.indexed_examples[idx]
                     cap = ex.get('caption', '')
                     if isinstance(cap, str) and len(cap) > 15 and (category == "auto" or ex.get('category') == category):
-                        examples.append(cap)
-                        if len(examples) >= k: break
-            if not examples: return self._default_response()
+                        candidates.append((int(idx), cap))
+                        if len(candidates) >= 30: break
+            if not candidates: return self._default_response()
+
+            # Re-ranking con CrossEncoder: (concepto, caption) → top 15
+            pairs = [(user_en, cap) for _, cap in candidates]
+            ce_scores = self.reranker.predict(pairs)
+            reranked = [c for _, c in sorted(zip(ce_scores, candidates), key=lambda t: -t[0])][:15]
+
+            # MMR (λ=0.7) sobre los 15 para elegir k ejemplos diversos
+            examples = [cap for _, cap in self._mmr_select(query_emb[0], reranked, k=k, lam=0.7)]
             
             # 1. Detectar patrón estructural real
             comma_counts = [len([p.strip() for p in ex.split(',') if len(p.strip()) > 4]) for ex in examples]
@@ -83,10 +105,12 @@ class ImprovedSemanticAgent:
             }
             pattern = patterns.get(avg, patterns[6])
             
-            # 2. Pool léxico contextual (últimas 2 cláusulas, filtradas)
+            # 2. Pool léxico contextual (últimas 2 cláusulas, filtradas).
+            # Hasta 48 chars: las SAFE_ATMOSPHERIC_FRAGMENTS miden 25-44 chars y el
+            # tope anterior de 15 las hacía inalcanzables.
             raw_fragments = []
             for ex in examples:
-                parts = [p.strip() for p in ex.split(',') if 5 < len(p.strip()) < 15]
+                parts = [p.strip() for p in ex.split(',') if 5 < len(p.strip()) <= 48]
                 raw_fragments.extend(parts[-2:])
                 
             lexicon = self._filter_and_score(raw_fragments, user_en)
@@ -100,11 +124,41 @@ class ImprovedSemanticAgent:
             logger.error(f"❌ Error extracción: {e}")
             return self._default_response()
 
+    def _mmr_select(self, query_emb: np.ndarray, candidates: List[Tuple[int, str]],
+                    k: int = 6, lam: float = 0.7) -> List[Tuple[int, str]]:
+        """Maximal Marginal Relevance: relevancia a la query − redundancia con lo ya elegido.
+        Usa los embeddings ya almacenados en el índice FAISS (reconstruct); si el tipo de
+        índice no lo permite, re-encodea los pocos candidatos (≤15, coste despreciable)."""
+        if len(candidates) <= k:
+            return candidates
+        try:
+            doc_embs = np.stack([self.index.reconstruct(idx) for idx, _ in candidates])
+        except Exception:
+            doc_embs = self.embedding_model.encode(
+                [cap for _, cap in candidates], normalize_embeddings=True
+            ).astype('float32')
+        # Embeddings normalizados → producto punto = similitud coseno
+        query_sims = doc_embs @ query_emb
+        selected, remaining = [], list(range(len(candidates)))
+        while remaining and len(selected) < k:
+            if not selected:
+                best = max(remaining, key=lambda i: query_sims[i])
+            else:
+                sel_embs = doc_embs[selected]
+                best = max(remaining,
+                           key=lambda i: lam * query_sims[i] - (1 - lam) * float(np.max(sel_embs @ doc_embs[i])))
+            selected.append(best)
+            remaining.remove(best)
+        return [candidates[i] for i in selected]
+
     def _filter_and_score(self, fragments: List[str], user_en: str) -> List[str]:
         user_lower = user_en.lower()
         valid = []
         for frag in fragments:
             fl = frag.lower()
+            # Fragmentos rotos por el split de comas (comillas sueltas, cláusulas
+            # que empiezan a mitad de frase): deben empezar por letra
+            if not frag or not frag[0].isalpha(): continue
             if any(b in fl for b in CONTENT_BLACKLIST): continue
             if any(w in user_lower for w in re.findall(r'\b[a-z]{4,}\b', fl)): continue
             doc = NLP(frag)

app.py

@@ -8,6 +8,7 @@ from typing import Optional, Tuple, List, Dict
 from huggingface_hub import InferenceClient
 from openai import OpenAI
 from agent import ImprovedSemanticAgent
+from y_refiner import YRefiner, call_with_fallback, check_catalog, NodeError
 
 # ✅ Configuración de logging profesional
 logging.basicConfig(
@@ -36,9 +37,23 @@ class LlamaRefiner:
         
         # Modelo principal confirmado
         self.model_name = "Qwen/Qwen2.5-7B-Instruct:together"
-        
+
+        # Métricas de sesión: cuántas veces el LLM respondió bien, fue rechazado
+        # por el validador, falló la llamada, o se usó el fallback semántico
+        self.metrics = {"total": 0, "llm_ok": 0, "llm_rejected": 0, "llm_error": 0, "fallback": 0}
+
         logger.info("✅ LlamaRefiner v3.1 inicializado correctamente")
 
+    def _metrics_summary(self) -> str:
+        """Resumen corto de métricas para mostrar en la UI."""
+        m = self.metrics
+        if m["total"] == 0:
+            return ""
+        reject_rate = 100.0 * (m["llm_rejected"] + m["llm_error"]) / m["total"]
+        return (f"Sesión: {m['total']} refinados | LLM OK: {m['llm_ok']} | "
+                f"rechazados: {m['llm_rejected']} | errores: {m['llm_error']} | "
+                f"fallback: {m['fallback']} | tasa de rechazo LLM: {reject_rate:.0f}%")
+
     def _translate_to_english(self, text_es: str) -> str:
         """Traduce ES → EN con fallback seguro."""
         if not text_es.strip():
@@ -66,46 +81,36 @@ class LlamaRefiner:
         system_prompt = (
             "You are an expert diffusion prompt composer. Your task is to transcribe the user's concept into a "
             "professional, narrative-style image prompt that strictly follows the structural cadence of high-end datasets.\n\n"
-            f"STRUCTURAL TEMPLATE: {pattern_str}\n"
+            f"STRUCTURAL TEMPLATE (internal guide only — the labels must NEVER appear in your output): {pattern_str}\n"
             f"AVAILABLE ATMOSPHERIC/STYLISTIC FRAGMENTS: {lexicon_str}\n\n"
             "RULES:\n"
-            "1. Map the user concept exactly to the template. Maintain natural, comma-separated clause flow.\n"
+            "1. Map the user concept to the template slots. Maintain natural, comma-separated clause flow.\n"
             "2. Use ONLY the provided fragments to enrich atmospheric, lighting, or quality slots. DO NOT invent objects, colors, or eras.\n"
-            "3. DO NOT copy full reference phrases. DO NOT output explanations. Output ONLY the final prompt.\n"
-            "4. Keep the prompt between 15-35 words. Ensure professional diffusion-ready syntax."
+            "3. DO NOT copy full reference phrases. DO NOT output explanations.\n"
+            "4. Output EXACTLY ONE line of plain text: no line breaks, no section labels (e.g. 'Opening/Pose:'), "
+            "no arrows (→), no numbering, no bullet points, no quotes.\n"
+            "5. HARD LIMIT: the prompt must contain between 20 and 40 words. Output ONLY the prompt text."
         )
         
         user_prompt = f"User concept to compose: {user_en}"
         return system_prompt, user_prompt
 
     def _call_llm(self, system_prompt: str, user_prompt: str) -> Optional[str]:
-        """Llamada al LLM con manejo de errores y timeout."""
+        """Llamada al LLM del modo rápido, con cadena de fallback de provider (fix R6)."""
         try:
-            logger.info(f"🔄 Llamando a {self.model_name}...")
-            response = self.openai_client.chat.completions.create(
-                model=self.model_name,
+            logger.info(f"🔄 Llamando al modo rápido (cadena 'fast' del registry)...")
+            result = call_with_fallback(
+                self.openai_client, "fast",
                 messages=[
                     {"role": "system", "content": system_prompt},
                     {"role": "user", "content": user_prompt}
                 ],
-                max_tokens=160,
-                temperature=0.1,
-                top_p=0.9,
-                timeout=50
+                max_tokens=160, temperature=0.1, timeout=50
             )
-            if response and response.choices and response.choices[0].message.content:
-                raw_output = response.choices[0].message.content.strip()
-                logger.info(f"✅ LLM respondió ({len(raw_output)} chars)")
-                return raw_output
-            else:
-                logger.warning("⚠️ LLM devolvió respuesta vacía.")
-                return None
-        except Exception as e:
-            err_msg = str(e)
-            if "400" in err_msg or "401" in err_msg or "403" in err_msg or "not supported" in err_msg.lower():
-                logger.error(f"🚫 Error de modelo/proveedor: {err_msg[:100]}")
-            else:
-                logger.warning(f"⚠️ Error de conexión/timeout: {err_msg[:100]}")
+            logger.info(f"✅ LLM respondió ({len(result['text'])} chars, {result['model']})")
+            return result["text"]
+        except NodeError as e:
+            logger.error(f"🚫 Cadena del modo rápido agotada: {e}")
             return None
 
     def _validate_output(self, user_en: str, output: str) -> Tuple[bool, str]:
@@ -123,9 +128,12 @@ class LlamaRefiner:
         if not any(w in output_lower for w in user_tokens):
             return False, "missing_user_concept"
             
-        # 2. Longitud razonable
+        # 2. Longitud razonable. El encoder CLIP de SDXL trunca a 77 tokens (~55-60
+        # palabras en inglés): hasta ahí el prompt es útil, no "demasiado largo".
+        # El system prompt pide 20-40 palabras; 60 da margen para no rechazar
+        # outputs válidos que se pasan un poco.
         word_count = len(output.split())
-        if word_count > 40:
+        if word_count > 60:
             return False, f"too_long ({word_count} words)"
             
         # 3. Seguridad (términos prohibidos)
@@ -136,15 +144,37 @@ class LlamaRefiner:
             
         return True, "valid"
 
+    # Etiquetas de sección del template que Qwen a veces copia en el output
+    # (p. ej. "Opening/Pose: ..." o "Subject/Core → ...")
+    _SECTION_LABEL_RE = re.compile(
+        r'\b(?:Opening|Subject|Core|Secondary|Descriptive|Atmospheric|Environment(?:al)?|Context|'
+        r'Lighting|Mood|Technical|Quality|Stylistic|Style|Medium|Frame|Pose|Detail|Clause)'
+        r'(?:\s*/\s*[A-Za-z]+)?\s*[:：]\s*',
+        re.IGNORECASE
+    )
+
     def _clean_output(self, text: str) -> str:
-        """Limpieza final del prompt generado."""
+        """Limpieza final del prompt generado. Debe ejecutarse ANTES de validar longitud."""
+        # Cinturón extra: bloques de razonamiento de modelos híbridos (thinking)
+        text = re.sub(r'<think>.*?</think>', '', text, flags=re.DOTALL)
+        if '</think>' in text:  # apertura truncada: quedarse con lo posterior al cierre
+            text = text.split('</think>')[-1]
         text = text.strip().strip("\"'")
         # Eliminar prefijos comunes de LLM
         for prefix in ["Here is", "Final:", "Output:", "Prompt:", "Result:", "Generated:"]:
             if text.startswith(prefix):
                 text = text.split(":", 1)[-1].strip()
+        # Colapsar saltos de línea y bullets/numeración en flujo de cláusulas
+        lines = [re.sub(r'^\s*(?:[-•*]|\d+[.)])\s*', '', ln).strip() for ln in text.splitlines()]
+        text = ', '.join(ln for ln in lines if ln)
+        # Eliminar etiquetas de sección del template y flechas
+        text = self._SECTION_LABEL_RE.sub('', text)
+        text = re.sub(r'\s*(?:→|->)\s*', ', ', text)
         # Eliminar markdown/etiquetas residuales
         text = re.sub(r'\*+|_+|</?[^>]+>', '', text).strip()
+        # Normalizar comas: dobles, colgantes al inicio/final, espacios
+        text = re.sub(r'\s*,\s*(?:,\s*)+', ', ', text)
+        text = re.sub(r'\s{2,}', ' ', text).strip().strip(',').strip()
         # Eliminar punto final si parece frase suelta
         if text.endswith('.') and text.count(',') < 3:
             text = text.rstrip('.')
@@ -176,22 +206,32 @@ class LlamaRefiner:
         sys_msg, usr_msg = self._build_compositional_prompt(user_en, agent_data)
         
         # 4. Llamada al LLM
+        self.metrics["total"] += 1
         raw_output = self._call_llm(sys_msg, usr_msg)
-        
+
+        fallback_reason = "sin respuesta del LLM"
         if raw_output:
             cleaned = self._clean_output(raw_output)
             is_valid, reason = self._validate_output(user_en, cleaned)
-            
+
             if is_valid:
                 logger.info(f"✅ Prompt validado: {reason}")
-                return cleaned, "✅ Refinado exitosamente", agent_data.get("examples_ui", [])
+                self.metrics["llm_ok"] += 1
+                status = f"✅ Refinado con LLM ({self.model_name.split('/')[-1].split(':')[0]})\n{self._metrics_summary()}"
+                return cleaned, status, agent_data.get("examples_ui", [])
             else:
                 logger.warning(f"⚠️ Output rechazado: {reason} → '{cleaned}'")
-                
-        # 5. Fallback semántico
+                self.metrics["llm_rejected"] += 1
+                fallback_reason = f"LLM rechazado: {reason}"
+        else:
+            self.metrics["llm_error"] += 1
+
+        # 5. Fallback semántico (visible para el usuario, con motivo)
         logger.info("🔧 Aplicando fallback semántico...")
+        self.metrics["fallback"] += 1
         fallback, _ = self.agent.enhance_prompt(user_en, category)
-        return self._clean_output(fallback), "⚠️ Fallback: enriquecimiento semántico", agent_data.get("examples_ui", [])
+        status = f"⚠️ Fallback semántico ({fallback_reason})\n{self._metrics_summary()}"
+        return self._clean_output(fallback), status, agent_data.get("examples_ui", [])
 
 
 class SDXLGenerator:
@@ -225,18 +265,19 @@ def create_interface():
     try:
         refiner = LlamaRefiner()
         generator = SDXLGenerator()
+        y_refiner = YRefiner(refiner)
+        check_catalog()
         logger.info("✅ Todos los servicios inicializados correctamente")
     except Exception as e:
         logger.error(f"❌ Error crítico de inicialización: {e}", exc_info=True)
         raise
 
-    def do_refine(prompt: str, category_es: str, progress=gr.Progress()):
+    def do_refine(prompt: str, category_es: str, mode: str, progress=gr.Progress()):
         if not prompt.strip():
             return "", "", "Prompt vacío."
         if refiner is None:
             return "", "", "❌ Servicio no disponible (revisa los logs)."
-            
-        progress(0.3, desc="🔄 Traduciendo y analizando estructura...")
+
         category_map = {
             "Automática": "auto",
             "Entidad": "entity",
@@ -246,10 +287,15 @@ def create_interface():
             "Texto": "text"
         }
         category_en = category_map.get(category_es, "auto")
-        
-        progress(0.7, desc="✨ Composición estructural...")
-        refined_prompt, status_msg, examples = refiner.refine(prompt, category_en)
-        
+
+        if mode.startswith("🔱"):
+            refined_prompt, status_msg, examples = y_refiner.refine_y(
+                prompt, category_en, progress_cb=progress)
+        else:
+            progress(0.3, desc="🔄 Traduciendo y analizando estructura...")
+            progress(0.7, desc="✨ Composición estructural...")
+            refined_prompt, status_msg, examples = refiner.refine(prompt, category_en)
+
         examples_text = "\n".join(f"{i+1}. {ex}" for i, ex in enumerate(examples)) if examples else "Sin ejemplos recuperados."
         return refined_prompt, examples_text, status_msg
 
@@ -291,6 +337,12 @@ def create_interface():
                     placeholder="Ej: retrato de una mujer en la edad media con un elaborado vestido"
                 )
                 category_input = gr.Dropdown(label="📂 Categoría", choices=CATEGORY_CHOICES, value="Automática")
+                mode_input = gr.Radio(
+                    label="⚙️ Motor de refinamiento",
+                    choices=["⚡ Rápido (1 LLM)", "🔱 Modo Y (3 LLMs)"],
+                    value="⚡ Rápido (1 LLM)",
+                    info="Y: dos generadores en paralelo + normalizador. Más lento y ~14× más caro, mayor calidad."
+                )
                 aspect_input = gr.Dropdown(label="📐 Proporción", choices=ASPECT_CHOICES, value="1:1")
                 
                 refine_btn = gr.Button("🔄 Refinar Prompt", variant="secondary", size="lg")
@@ -300,7 +352,7 @@ def create_interface():
                 refined_output = gr.Textbox(label="🇬🇧 Prompt refinado (inglés)", interactive=False, lines=2)
                 image_output = gr.Image(label="🖼️ Imagen generada", type="filepath", height=420)
                 examples_output = gr.Textbox(label="📚 Referencia estructural (dataset)", interactive=False, lines=4)
-                status_output = gr.Textbox(label="📊 Estado / Métricas", interactive=False, lines=2)
+                status_output = gr.Textbox(label="📊 Estado / Métricas", interactive=False, lines=3)
 
         gr.HTML("""
         <div style="text-align: center; padding: 15px; margin-top: 20px; border-top: 1px solid #333; color: #666; font-size: 0.9em;">
@@ -310,7 +362,7 @@ def create_interface():
 
         refine_btn.click(
             fn=do_refine,
-            inputs=[prompt_input, category_input],
+            inputs=[prompt_input, category_input, mode_input],
             outputs=[refined_output, examples_output, status_output],
             show_progress=True
         )
@@ -324,4 +376,5 @@ def create_interface():
 
 if __name__ == "__main__":
     demo = create_interface()
-    demo.launch(server_name="0.0.0.0", server_port=7860)
+    # ssr_mode=False: evita el error "Could not get API info" del SSR de Gradio en Spaces
+    demo.launch(server_name="0.0.0.0", server_port=7860, ssr_mode=False)

requirements.txt

@@ -1,15 +1,14 @@
+# Versiones verificadas con wheels para Python 3.13 (cp313/abi3 en PyPI)
 gradio>=6.11.0,<7.0.0
-Pillow>=10.0.0
-huggingface-hub>=0.24.0
-sentence-transformers>=2.3.0
-faiss-cpu>=1.9.0.post1
-datasets>=2.10.0
-torch>=2.0.0
-transformers>=4.34.0
-sentencepiece>=0.1.99
-spacy>=3.7.0,<4.0.0
-uvicorn>=0.14.0
-websockets>=10.4
+Pillow>=10.4.0
+huggingface-hub>=0.27.0
+sentence-transformers>=3.3.0
+faiss-cpu>=1.9.0.post1        # primer release con wheel cp313
+torch>=2.6.0                  # cp313 desde 2.5.0; 2.6+ recomendado (fix CVE torch.load)
+transformers>=4.48.0
+tokenizers>=0.21.0            # wheels abi3 compatibles con 3.13
+sentencepiece>=0.2.1          # ÚNICA versión con wheel cp313 (0.2.0 compila desde source y falla)
+spacy>=3.8.2,<4.0.0           # cp313 desde 3.8.2; 3.7.x NO soporta 3.13
+sacremoses>=0.1.1
+openai>=1.55.0
 spaces
-sacremoses>=0.0.53
-openai>=1.0.0

semantic_database.py

@@ -1,541 +0,0 @@
-# semantic_database.py
-import sqlite3
-import hashlib
-import json
-import logging
-import time
-from datetime import datetime, timedelta
-from typing import Optional, Dict, List, Any, Tuple
-import threading
-
-# Configurar logging
-logging.basicConfig(level=logging.INFO)
-logger = logging.getLogger(__name__)
-
-class SemanticDatabase:
-    """
-    💾 SISTEMA DE BASE DE DATOS SEMÁNTICA — ¡AHORA EN USO ACTIVO!
-
-    Gestiona:
-    - Caché de prompts de alta calidad (¡priorizados por el agente!)
-    - Memoria episódica de sesiones
-    - Estadísticas del sistema
-    - Optimización y limpieza automática
-    """
-    
-    def __init__(self, db_path: str = "semantic_cache.db"):
-        self.db_path = db_path
-        self.lock = threading.Lock()
-        self._initialize_database()
-        logger.info(f"📊 Base de datos semántica inicializada: {db_path}")
-    
-    def _initialize_database(self):
-        """🏗️ Crea las tablas necesarias si no existen"""
-        try:
-            with sqlite3.connect(self.db_path) as conn:
-                cursor = conn.cursor()
-                
-                # Tabla de caché de prompts — ¡AHORA USADA ACTIVAMENTE!
-                cursor.execute("""
-                    CREATE TABLE IF NOT EXISTS prompt_cache (
-                        prompt_hash TEXT PRIMARY KEY,
-                        original_prompt TEXT NOT NULL,
-                        enhanced_prompt TEXT NOT NULL,
-                        category TEXT NOT NULL,
-                        similarity_score REAL NOT NULL,
-                        source_field TEXT NOT NULL,
-                        hit_count INTEGER DEFAULT 1,
-                        created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
-                        last_accessed TIMESTAMP DEFAULT CURRENT_TIMESTAMP
-                    )
-                """)
-                
-                # Tabla de memoria episódica
-                cursor.execute("""
-                    CREATE TABLE IF NOT EXISTS episodic_memory (
-                        id INTEGER PRIMARY KEY AUTOINCREMENT,
-                        session_id TEXT NOT NULL,
-                        prompt TEXT NOT NULL,
-                        category TEXT NOT NULL,
-                        strategy TEXT NOT NULL,
-                        similarity_score REAL NOT NULL,
-                        processing_time REAL NOT NULL,
-                        models_used TEXT NOT NULL,
-                        success BOOLEAN NOT NULL,
-                        timestamp TIMESTAMP DEFAULT CURRENT_TIMESTAMP
-                    )
-                """)
-                
-                # Tabla de estadísticas diarias
-                cursor.execute("""
-                    CREATE TABLE IF NOT EXISTS daily_stats (
-                        date TEXT PRIMARY KEY,
-                        total_searches INTEGER DEFAULT 0,
-                        cache_hits INTEGER DEFAULT 0,
-                        unique_prompts INTEGER DEFAULT 0,
-                        avg_processing_time REAL DEFAULT 0.0,
-                        successful_enhancements INTEGER DEFAULT 0,
-                        failed_enhancements INTEGER DEFAULT 0
-                    )
-                """)
-                
-                # Tabla de configuración del sistema
-                cursor.execute("""
-                    CREATE TABLE IF NOT EXISTS system_config (
-                        key TEXT PRIMARY KEY,
-                        value TEXT NOT NULL,
-                        updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
-                    )
-                """)
-                
-                # Índices para optimización — ¡CRÍTICOS PARA PERFORMANCE!
-                cursor.execute("CREATE INDEX IF NOT EXISTS idx_prompt_hash ON prompt_cache(prompt_hash)")
-                cursor.execute("CREATE INDEX IF NOT EXISTS idx_category_score ON prompt_cache(category, similarity_score)")
-                cursor.execute("CREATE INDEX IF NOT EXISTS idx_hit_count ON prompt_cache(hit_count)")
-                cursor.execute("CREATE INDEX IF NOT EXISTS idx_session_id ON episodic_memory(session_id)")
-                cursor.execute("CREATE INDEX IF NOT EXISTS idx_timestamp ON episodic_memory(timestamp)")
-                cursor.execute("CREATE INDEX IF NOT EXISTS idx_last_accessed ON prompt_cache(last_accessed)")
-                
-                conn.commit()
-                logger.info("✅ Tablas de base de datos inicializadas correctamente")
-                
-        except Exception as e:
-            logger.error(f"❌ Error inicializando base de datos: {e}")
-            raise
-    
-    def _get_prompt_hash(self, prompt: str) -> str:
-        """🔐 Genera hash único para un prompt"""
-        return hashlib.md5(prompt.strip().lower().encode()).hexdigest()
-    
-    def store_cache_result(self, original_prompt: str, enhanced_prompt: str, 
-                          category: str, similarity_score: float, source_field: str) -> bool:
-        """💾 Almacena resultado en caché — ¡USADO POR EL AGENTE!"""
-        try:
-            prompt_hash = self._get_prompt_hash(original_prompt)
-            
-            with self.lock:
-                with sqlite3.connect(self.db_path) as conn:
-                    cursor = conn.cursor()
-                    
-                    # Verificar si ya existe
-                    cursor.execute(
-                        "SELECT hit_count FROM prompt_cache WHERE prompt_hash = ?",
-                        (prompt_hash,)
-                    )
-                    
-                    existing = cursor.fetchone()
-                    
-                    if existing:
-                        # Actualizar hit count y última vez accedido
-                        cursor.execute("""
-                            UPDATE prompt_cache 
-                            SET hit_count = hit_count + 1, 
-                                last_accessed = CURRENT_TIMESTAMP,
-                                enhanced_prompt = ?,
-                                similarity_score = ?
-                            WHERE prompt_hash = ?
-                        """, (enhanced_prompt, similarity_score, prompt_hash))
-                    else:
-                        # Insertar nuevo registro
-                        cursor.execute("""
-                            INSERT INTO prompt_cache 
-                            (prompt_hash, original_prompt, enhanced_prompt, category, 
-                             similarity_score, source_field) 
-                            VALUES (?, ?, ?, ?, ?, ?)
-                        """, (prompt_hash, original_prompt, enhanced_prompt, category, 
-                              similarity_score, source_field))
-                    
-                    conn.commit()
-                    return True
-                    
-        except Exception as e:
-            logger.error(f"❌ Error almacenando en caché: {e}")
-            return False
-    
-    def get_cached_result(self, prompt: str) -> Optional[Dict]:
-        """🔍 Busca resultado en caché"""
-        try:
-            prompt_hash = self._get_prompt_hash(prompt)
-            
-            with self.lock:
-                with sqlite3.connect(self.db_path) as conn:
-                    cursor = conn.cursor()
-                    
-                    cursor.execute("""
-                        SELECT enhanced_prompt, category, similarity_score, source_field, 
-                               hit_count, created_at, last_accessed
-                        FROM prompt_cache 
-                        WHERE prompt_hash = ?
-                    """, (prompt_hash,))
-                    
-                    result = cursor.fetchone()
-                    
-                    if result:
-                        # Actualizar hit_count y last_accessed
-                        cursor.execute("""
-                            UPDATE prompt_cache 
-                            SET hit_count = hit_count + 1, 
-                                last_accessed = CURRENT_TIMESTAMP 
-                            WHERE prompt_hash = ?
-                        """, (prompt_hash,))
-                        
-                        # Volver a leer para obtener valores actualizados
-                        cursor.execute("""
-                            SELECT enhanced_prompt, category, similarity_score, source_field, 
-                                   hit_count, created_at, last_accessed
-                            FROM prompt_cache 
-                            WHERE prompt_hash = ?
-                        """, (prompt_hash,))
-                        
-                        updated_result = cursor.fetchone()
-                        conn.commit()
-                        
-                        if updated_result:
-                            return {
-                                'enhanced_prompt': updated_result[0],
-                                'category': updated_result[1],
-                                'similarity_score': updated_result[2],
-                                'source_field': updated_result[3],
-                                'hit_count': updated_result[4],
-                                'created_at': updated_result[5],
-                                'last_accessed': updated_result[6]
-                            }
-                    
-                    return None
-                    
-        except Exception as e:
-            logger.error(f"❌ Error buscando en caché: {e}")
-            return None
-
-    def get_top_cached_prompts(self, prompt: str, category: str, top_k: int = 5) -> List[Dict]:
-        """🌟 OBTIENE LOS MEJORES PROMPTS CURADOS — ¡NUEVO MÉTODO CLAVE!
-        Busca prompts de alta calidad (score > 0.8) en la misma categoría, ordenados por relevancia y uso."""
-        try:
-            with self.lock:
-                with sqlite3.connect(self.db_path) as conn:
-                    cursor = conn.cursor()
-                    
-                    cursor.execute("""
-                        SELECT enhanced_prompt, category, similarity_score, source_field, hit_count
-                        FROM prompt_cache 
-                        WHERE category = ? AND similarity_score > 0.8
-                        ORDER BY hit_count DESC, similarity_score DESC
-                        LIMIT ?
-                    """, (category, top_k))
-                    
-                    results = cursor.fetchall()
-                    
-                    cached_prompts = []
-                    for row in results:
-                        cached_prompts.append({
-                            'enhanced_prompt': row[0],
-                            'category': row[1],
-                            'similarity_score': row[2],
-                            'source_field': row[3],
-                            'hit_count': row[4]
-                        })
-                    
-                    if cached_prompts:
-                        logger.info(f"🧠 Encontrados {len(cached_prompts)} prompts curados de alta calidad para categoría '{category}'")
-                    return cached_prompts
-                    
-        except Exception as e:
-            logger.error(f"❌ Error obteniendo prompts curados: {e}")
-            return []
-
-    def store_episodic_memory(self, session_id: str, prompt: str, category: str, 
-                             strategy: str, similarity_score: float, processing_time: float,
-                             models_used: List[str], success: bool) -> bool:
-        """🧠 Almacena memoria episódica"""
-        try:
-            models_json = json.dumps(models_used)
-            
-            with self.lock:
-                with sqlite3.connect(self.db_path) as conn:
-                    cursor = conn.cursor()
-                    
-                    cursor.execute("""
-                        INSERT INTO episodic_memory 
-                        (session_id, prompt, category, strategy, similarity_score, 
-                         processing_time, models_used, success) 
-                        VALUES (?, ?, ?, ?, ?, ?, ?, ?)
-                    """, (session_id, prompt, category, strategy, similarity_score,
-                          processing_time, models_json, success))
-                    
-                    conn.commit()
-                    return True
-                    
-        except Exception as e:
-            logger.error(f"❌ Error almacenando memoria episódica: {e}")
-            return False
-    
-    def get_session_history(self, session_id: str, limit: int = 50) -> List[Dict]:
-        """📚 Obtiene historial de una sesión"""
-        try:
-            with self.lock:
-                with sqlite3.connect(self.db_path) as conn:
-                    cursor = conn.cursor()
-                    
-                    cursor.execute("""
-                        SELECT prompt, category, strategy, similarity_score, 
-                               processing_time, models_used, success, timestamp
-                        FROM episodic_memory 
-                        WHERE session_id = ? 
-                        ORDER BY timestamp DESC 
-                        LIMIT ?
-                    """, (session_id, limit))
-                    
-                    results = cursor.fetchall()
-                    
-                    history = []
-                    for row in results:
-                        history.append({
-                            'prompt': row[0],
-                            'category': row[1],
-                            'strategy': row[2],
-                            'similarity_score': row[3],
-                            'processing_time': row[4],
-                            'models_used': json.loads(row[5]),
-                            'success': bool(row[6]),
-                            'timestamp': row[7]
-                        })
-                    
-                    return history
-                    
-        except Exception as e:
-            logger.error(f"❌ Error obteniendo historial: {e}")
-            return []
-    
-    def update_daily_stats(self, searches: int = 0, cache_hits: int = 0, 
-                          processing_time: float = 0.0, success: bool = True) -> bool:
-        """📊 Actualiza estadísticas diarias"""
-        try:
-            today = datetime.now().strftime('%Y-%m-%d')
-            
-            with self.lock:
-                with sqlite3.connect(self.db_path) as conn:
-                    cursor = conn.cursor()
-                    
-                    cursor.execute(
-                        "SELECT total_searches, cache_hits, avg_processing_time, successful_enhancements, failed_enhancements FROM daily_stats WHERE date = ?",
-                        (today,)
-                    )
-                    
-                    existing = cursor.fetchone()
-                    
-                    if existing:
-                        new_total = existing[0] + searches
-                        new_cache_hits = existing[1] + cache_hits
-                        new_successful = existing[3] + (1 if success else 0)
-                        new_failed = existing[4] + (0 if success else 1)
-                        
-                        if new_total > 0:
-                            new_avg_time = ((existing[2] * existing[0]) + processing_time) / new_total
-                        else:
-                            new_avg_time = 0.0
-                        
-                        cursor.execute("""
-                            UPDATE daily_stats 
-                            SET total_searches = ?, cache_hits = ?, avg_processing_time = ?,
-                                successful_enhancements = ?, failed_enhancements = ?
-                            WHERE date = ?
-                        """, (new_total, new_cache_hits, new_avg_time, new_successful, new_failed, today))
-                    else:
-                        cursor.execute("""
-                            INSERT INTO daily_stats 
-                            (date, total_searches, cache_hits, avg_processing_time, 
-                             successful_enhancements, failed_enhancements) 
-                            VALUES (?, ?, ?, ?, ?, ?)
-                        """, (today, searches, cache_hits, processing_time, 
-                              1 if success else 0, 0 if success else 1))
-                    
-                    conn.commit()
-                    return True
-                    
-        except Exception as e:
-            logger.error(f"❌ Error actualizando estadísticas: {e}")
-            return False
-    
-    def get_system_stats(self) -> Dict[str, Any]:
-        """📈 Obtiene estadísticas del sistema"""
-        try:
-            with self.lock:
-                with sqlite3.connect(self.db_path) as conn:
-                    cursor = conn.cursor()
-                    
-                    stats = {}
-                    
-                    # Estadísticas de caché
-                    cursor.execute("SELECT COUNT(*), AVG(hit_count), AVG(similarity_score) FROM prompt_cache")
-                    cache_stats = cursor.fetchone()
-                    stats['caché'] = {
-                        'total_entradas': cache_stats[0] or 0,
-                        'promedio_usos': round(cache_stats[1] or 0, 2),
-                        'promedio_similitud': round(cache_stats[2] or 0, 3)
-                    }
-                    
-                    # Estadísticas de memoria episódica
-                    cursor.execute("""
-                        SELECT COUNT(*), COUNT(DISTINCT session_id), 
-                               AVG(similarity_score), AVG(processing_time),
-                               SUM(CASE WHEN success = 1 THEN 1 ELSE 0 END) * 100.0 / COUNT(*)
-                        FROM episodic_memory
-                    """)
-                    memory_stats = cursor.fetchone()
-                    stats['episódica'] = {
-                        'búsquedas_totales': memory_stats[0] or 0,
-                        'sesiones_únicas': memory_stats[1] or 0,
-                        'promedio_similitud': round(memory_stats[2] or 0, 3),
-                        'tiempo_promedio': round(memory_stats[3] or 0, 2),
-                        'tasa_éxito': round(memory_stats[4] or 0, 1)
-                    }
-                    
-                    # Estadísticas de últimos 7 días
-                    cursor.execute("""
-                        SELECT SUM(total_searches), SUM(cache_hits), AVG(avg_processing_time)
-                        FROM daily_stats 
-                        WHERE date >= date('now', '-7 days')
-                    """)
-                    weekly_stats = cursor.fetchone()
-                    stats['semanal'] = {
-                        'búsquedas_totales': weekly_stats[0] or 0,
-                        'aciertos_caché': weekly_stats[1] or 0,
-                        'tiempo_promedio': round(weekly_stats[2] or 0, 2)
-                    }
-                    
-                    # Información de la base de datos
-                    cursor.execute("SELECT COUNT(*) FROM sqlite_master WHERE type='table'")
-                    table_count = cursor.fetchone()[0]
-                    
-                    stats['base_de_datos'] = {
-                        'tablas': table_count,
-                        'tamaño_mb': self._get_db_size_mb(),
-                        'última_limpieza': self._get_config_value('last_cleanup'),
-                        'versión': '2.0'
-                    }
-                    
-                    return stats
-                    
-        except Exception as e:
-            logger.error(f"❌ Error obteniendo estadísticas: {e}")
-            return {}
-    
-    def cleanup_cache(self, max_age_days: int = 30, max_entries: int = 1000) -> Tuple[int, int]:
-        """🧹 Limpieza de caché antiguo"""
-        try:
-            with self.lock:
-                with sqlite3.connect(self.db_path) as conn:
-                    cursor = conn.cursor()
-                    
-                    # Eliminar entradas muy antiguas
-                    cutoff_date = (datetime.now() - timedelta(days=max_age_days)).isoformat()
-                    cursor.execute(
-                        "DELETE FROM prompt_cache WHERE last_accessed < ?",
-                        (cutoff_date,)
-                    )
-                    old_deleted = cursor.rowcount
-                    
-                    # Eliminar entradas menos usadas si hay demasiadas
-                    cursor.execute("SELECT COUNT(*) FROM prompt_cache")
-                    total_count = cursor.fetchone()[0]
-                    
-                    excess_deleted = 0
-                    if total_count > max_entries:
-                        excess_count = total_count - max_entries
-                        cursor.execute("""
-                            DELETE FROM prompt_cache 
-                            WHERE prompt_hash IN (
-                                SELECT prompt_hash FROM prompt_cache 
-                                ORDER BY hit_count ASC, last_accessed ASC 
-                                LIMIT ?
-                            )
-                        """, (excess_count,))
-                        excess_deleted = cursor.rowcount
-                    
-                    # Limpiar memoria episódica antigua (más de 90 días)
-                    old_memory_cutoff = (datetime.now() - timedelta(days=90)).isoformat()
-                    cursor.execute(
-                        "DELETE FROM episodic_memory WHERE timestamp < ?",
-                        (old_memory_cutoff,)
-                    )
-                    
-                    # Actualizar configuración
-                    self._set_config_value('last_cleanup', datetime.now().isoformat())
-                    
-                    conn.commit()
-                    
-                    total_deleted = old_deleted + excess_deleted
-                    logger.info(f"🧹 Limpieza completada: {total_deleted} entradas eliminadas")
-                    
-                    return old_deleted, excess_deleted
-                    
-        except Exception as e:
-            logger.error(f"❌ Error en limpieza: {e}")
-            return 0, 0
-    
-    def optimize_databases(self) -> bool:
-        """⚡ Optimiza la base de datos"""
-        try:
-            with self.lock:
-                with sqlite3.connect(self.db_path) as conn:
-                    cursor = conn.cursor()
-                    
-                    cursor.execute("VACUUM")
-                    cursor.execute("ANALYZE")
-                    
-                    conn.commit()
-                    
-                    logger.info("⚡ Base de datos optimizada")
-                    return True
-                    
-        except Exception as e:
-            logger.error(f"❌ Error optimizando base de datos: {e}")
-            return False
-    
-    def _get_db_size_mb(self) -> float:
-        """📏 Obtiene tamaño de la base de datos en MB"""
-        try:
-            import os
-            size_bytes = os.path.getsize(self.db_path)
-            return round(size_bytes / (1024 * 1024), 2)
-        except:
-            return 0.0
-    
-    def _get_config_value(self, key: str) -> Optional[str]:
-        """⚙️ Obtiene valor de configuración"""
-        try:
-            with sqlite3.connect(self.db_path) as conn:
-                cursor = conn.cursor()
-                cursor.execute("SELECT value FROM system_config WHERE key = ?", (key,))
-                result = cursor.fetchone()
-                return result[0] if result else None
-        except:
-            return None
-    
-    def _set_config_value(self, key: str, value: str) -> bool:
-        """⚙️ Establece valor de configuración"""
-        try:
-            with sqlite3.connect(self.db_path) as conn:
-                cursor = conn.cursor()
-                cursor.execute("""
-                    INSERT OR REPLACE INTO system_config (key, value) 
-                    VALUES (?, ?)
-                """, (key, value))
-                conn.commit()
-                return True
-        except:
-            return False
-    
-    def get_cache_size(self) -> int:
-        """📊 Obtiene número de entradas en caché"""
-        try:
-            with sqlite3.connect(self.db_path) as conn:
-                cursor = conn.cursor()
-                cursor.execute("SELECT COUNT(*) FROM prompt_cache")
-                return cursor.fetchone()[0]
-        except:
-            return 0
-    
-    def close(self):
-        """🔒 Cierra conexiones (cleanup)"""
-        logger.info("📊 Base de datos cerrada correctamente")

y_refiner.py

@@ -0,0 +1,353 @@
+# y_refiner.py — PromptCraft: Arquitectura Y (tri-LLM)
+# α (canónico) y γ (concreto) generan en paralelo bajo restricciones heterogéneas;
+# N (normalizador) integra ambos bajo contrato estricto (1 línea, ≤60 palabras).
+import logging
+import re
+import time
+from collections import deque
+from concurrent.futures import ThreadPoolExecutor
+from typing import Callable, Dict, List, Optional, Tuple
+
+logger = logging.getLogger(__name__)
+
+# ── Registry de modelos ─────────────────────────────────────────────────────
+# Por rol: cadena [primario, fallback1, ...]. pricing = USD por 1M tokens (in, out).
+# extra: parámetros extra del body; reasoning_effort="none" desactiva el modo
+# thinking de los híbridos 2026 (GLM-5.2, Kimi-K2.6, DeepSeek-V4, Qwen3.5) — sin
+# él, el razonamiento inline consume todo el max_tokens (verificado empíricamente).
+MODEL_REGISTRY: Dict[str, List[Dict]] = {
+    "alpha": [
+        {"model": "zai-org/GLM-5.2:fireworks-ai",  "pricing": (1.40, 4.40), "extra": {"reasoning_effort": "none"}},
+        {"model": "zai-org/GLM-5.1:together",       "pricing": (1.40, 4.40), "extra": {"reasoning_effort": "none"}},
+        {"model": "zai-org/GLM-4.7:deepinfra",      "pricing": (0.40, 1.75), "extra": {"reasoning_effort": "none"}},
+    ],
+    "gamma": [
+        {"model": "moonshotai/Kimi-K2.6:together",       "pricing": (1.20, 4.50), "extra": {"reasoning_effort": "none"}},
+        {"model": "moonshotai/Kimi-K2.6:fireworks-ai",   "pricing": (0.95, 4.00), "extra": {"reasoning_effort": "none"}},
+        {"model": "meta-llama/Llama-3.3-70B-Instruct:groq", "pricing": (0.59, 0.79), "extra": {}},
+        {"model": "moonshotai/Kimi-K2.5:fireworks-ai",   "pricing": (0.60, 3.00), "extra": {"reasoning_effort": "none"}},
+    ],
+    "normalizer": [
+        {"model": "deepseek-ai/DeepSeek-V4-Flash:fireworks-ai", "pricing": (0.14, 0.28), "extra": {"reasoning_effort": "none"}},
+        {"model": "Qwen/Qwen3.5-9B:deepinfra",                  "pricing": (0.10, 0.15), "extra": {"reasoning_effort": "none"}},
+        {"model": "Qwen/Qwen2.5-7B-Instruct:together",          "pricing": (0.30, 0.30), "extra": {}},
+    ],
+    # Cadena del modo rápido (usada por LlamaRefiner vía este registry — fix R6)
+    "fast": [
+        {"model": "Qwen/Qwen2.5-7B-Instruct:together", "pricing": (0.30, 0.30), "extra": {}},
+        {"model": "Qwen/Qwen3.5-9B:deepinfra",         "pricing": (0.10, 0.15), "extra": {"reasoning_effort": "none"}},
+    ],
+}
+
+TIMEOUTS = {"alpha": 30, "gamma": 30, "normalizer": 20}
+GLOBAL_BUDGET_S = 75
+MAX_TOKENS = {"alpha": 200, "gamma": 200, "normalizer": 120}
+
+# ── Prompts de nodo (definidos en el brief de implementación — no editar) ───
+NODE_PROMPTS = {
+    "alpha": """You write prompts for the SDXL image generation model.
+
+You will receive: a visual CONCEPT, a structural PATTERN, and LEXICON fragments taken from a professional prompt dataset.
+
+Write ONE prompt for the concept. Pursue the canonical cluster: use the most familiar, most professional SDXL vocabulary for this kind of image. The PATTERN tells you which aspects to cover (subject, detail, environment, lighting, technical quality, medium) — it is an internal guide only, its labels must NEVER appear in your output. Weave in LEXICON fragments where they genuinely fit; ignore the ones that don't.
+
+Output: the prompt text only. One single line. No labels, no arrows, no numbering, no quotes, no explanations. 40-70 words.""",
+
+    "gamma": """You write prompts for the SDXL image generation model.
+
+You will receive a visual CONCEPT. Write ONE prompt for it with one absolute rule: NO quality tags of any kind. Forbidden: 4k, 8k, hdr, masterpiece, best quality, highly detailed, ultra-realistic, award-winning, trending on artstation, professional, stunning, breathtaking, and every synonym of these.
+
+Build the image with concrete matter only: physical objects and their materials, textures, specific colors, the exact quality and direction of light, spatial composition, atmosphere as physical fact (dust, haze, wet asphalt), camera position if it matters. Every word must describe something visible.
+
+Output: the prompt text only. One single line. No labels, no arrows, no numbering, no quotes, no explanations. 40-70 words.""",
+
+    "normalizer": """You will receive a visual CONCEPT and two prompts below, A and B. They are two different attempts at an SDXL prompt for that concept. You did not see how they were made.
+
+Your task: write the final SDXL prompt. You have full creative liberty — merge them, cut them, rewrite from scratch if you believe the result is better. Your only obligation: the final prompt depicts the CONCEPT, unmistakably.
+
+ABSOLUTE PROHIBITIONS:
+1. One single line. No line breaks anywhere in your output.
+2. No labels, no section names, no arrows, no numbering, no bullet points, no quotation marks around the prompt.
+3. No preamble and no commentary. Do not write "Here is", do not explain choices. Your first word is the first word of the prompt.
+4. Maximum 60 words. This is a hard ceiling — the image model truncates beyond it, so every word past 60 is discarded.
+5. At most TWO quality tags total (words like "detailed", "8k", "masterpiece"). Concrete visual matter always wins over quality tags. If in doubt, use zero.
+6. Do not copy either source verbatim. The final prompt is yours.""",
+}
+
+
+class NodeError(Exception):
+    """Fallo de un nodo tras agotar su cadena de fallback."""
+
+
+def check_catalog() -> None:
+    """Mitigación R4: al arrancar, 1 GET al catálogo del router y log de qué
+    primarios del registry siguen servidos (no fatal si el GET falla)."""
+    import json
+    import urllib.request
+    try:
+        with urllib.request.urlopen("https://router.huggingface.co/v1/models", timeout=10) as r:
+            catalog = json.loads(r.read())
+        served = {}
+        for m in catalog.get("data", []):
+            served[m["id"]] = {p["provider"] for p in m.get("providers", [])
+                               if p.get("status") == "live"}
+        for role, chain in MODEL_REGISTRY.items():
+            primary = chain[0]["model"]
+            model_id, _, provider = primary.partition(":")
+            live = provider in served.get(model_id, set()) if provider else model_id in served
+            icon = "✅" if live else "🚨"
+            logger.info(f"{icon} Catálogo router — {role}: {primary} "
+                        f"{'live' if live else 'NO SERVIDO (usará fallback)'}")
+    except Exception as e:
+        logger.warning(f"⚠️ No se pudo verificar el catálogo del router: {e}")
+
+
+# Circuit breaker de sesión: entradas con ≥3 fallos consecutivos se saltan
+# (p.ej. un provider que devuelve siempre content vacío por no honrar
+# reasoning_effort). Se rearma si el modelo vuelve a responder.
+_BREAKER_THRESHOLD = 3
+_consecutive_failures: Dict[str, int] = {}
+
+
+def call_with_fallback(client, role: str, messages: List[Dict], max_tokens: int,
+                       temperature: float, timeout: int) -> Dict:
+    """Recorre la cadena de fallback del rol. 1 retry con backoff solo en
+    transitorios (429/5xx/timeout); los fallos deterministas (4xx, respuesta
+    vacía) saltan directo al siguiente modelo. Devuelve dict con
+    text/model/latency_s/cost_usd. Lanza NodeError si toda la cadena falla."""
+    chain = MODEL_REGISTRY[role]
+    last_err = None
+    for entry in chain:
+        model = entry["model"]
+        if _consecutive_failures.get(model, 0) >= _BREAKER_THRESHOLD:
+            logger.info(f"⏭️ [{role}] {model} saltado (circuit breaker abierto)")
+            continue
+        extra = dict(entry.get("extra", {}))
+        for attempt in (1, 2):
+            t0 = time.time()
+            try:
+                resp = client.chat.completions.create(
+                    model=model, messages=messages, max_tokens=max_tokens,
+                    temperature=temperature, timeout=timeout,
+                    extra_body=extra if extra else None,
+                )
+                text = (resp.choices[0].message.content or "").strip()
+                if not text:
+                    # Determinista (p.ej. thinking no desactivable se come los
+                    # tokens): no reintentar este modelo
+                    raise _EmptyResponse("respuesta vacía")
+                _consecutive_failures[model] = 0
+                usage = getattr(resp, "usage", None)
+                p_in, p_out = entry["pricing"]
+                cost = 0.0
+                if usage:
+                    cost = (usage.prompt_tokens * p_in + usage.completion_tokens * p_out) / 1e6
+                return {"text": text, "model": model,
+                        "latency_s": round(time.time() - t0, 2), "cost_usd": cost}
+            except Exception as e:
+                last_err = e
+                status = getattr(e, "status_code", None)
+                err_str = str(e)
+                logger.warning(f"⚠️ [{role}] {model} intento {attempt}: "
+                               f"HTTP {status} {err_str[:120]}")
+                _consecutive_failures[model] = _consecutive_failures.get(model, 0) + 1
+                # El provider rechaza los parámetros extra → reintentar sin ellos
+                if status == 400 and extra and "extra inputs" in err_str.lower():
+                    extra = {}
+                    continue
+                if isinstance(e, _EmptyResponse):
+                    break  # determinista → siguiente modelo
+                # Transitorios: 1 retry con backoff sobre el mismo modelo
+                if attempt == 1 and (status in (429, 500, 502, 503, 504) or status is None):
+                    time.sleep(1.5)
+                    continue
+                break  # 4xx u otro persistente → siguiente modelo de la cadena
+    raise NodeError(f"{role}: cadena agotada ({type(last_err).__name__}: {str(last_err)[:100]})")
+
+
+class _EmptyResponse(RuntimeError):
+    pass
+
+
+class YRefiner:
+    """Orquestador de la arquitectura Y. Compone un LlamaRefiner existente y
+    reutiliza su traducción, agente FAISS, limpieza y validación de contrato."""
+
+    def __init__(self, base):
+        self.base = base                      # LlamaRefiner
+        self.client = base.openai_client
+        self.records = deque(maxlen=200)      # telemetría por refinamiento
+        self.session = {"y_total": 0, "n_ok_first": 0, "n_ok_retry": 0,
+                        "alpha_fail": 0, "gamma_fail": 0, "degraded_fast": 0,
+                        "fallback_sem": 0, "cost_total_usd": 0.0}
+        logger.info("🔱 YRefiner inicializado (α+γ paralelos → N)")
+
+    # ── helpers ──
+    def _alpha_messages(self, user_en: str, agent_data: Dict) -> List[Dict]:
+        pattern = " → ".join(agent_data["pattern"])
+        lexicon = " | ".join(agent_data["lexicon"][:6])
+        return [{"role": "system", "content": NODE_PROMPTS["alpha"]},
+                {"role": "user", "content": f"CONCEPT: {user_en}\nPATTERN: {pattern}\nLEXICON: {lexicon}"}]
+
+    def _gamma_messages(self, user_en: str) -> List[Dict]:
+        # γ trabaja a ciegas del dataset: solo el concepto
+        return [{"role": "system", "content": NODE_PROMPTS["gamma"]},
+                {"role": "user", "content": f"CONCEPT: {user_en}"}]
+
+    def _normalizer_messages(self, user_en: str, out_a: str, out_b: str) -> List[Dict]:
+        return [{"role": "system", "content": NODE_PROMPTS["normalizer"]},
+                {"role": "user", "content": f"CONCEPT: {user_en}\n\nSOURCE A:\n{out_a}\n\nSOURCE B:\n{out_b}"}]
+
+    def _check_contract(self, user_en: str, raw: str) -> Tuple[str, bool, str]:
+        """Limpia y verifica el contrato de N: 1 línea, ≤60 palabras, concepto presente."""
+        cleaned = self.base._clean_output(raw)
+        ok, reason = self.base._validate_output(user_en, cleaned)
+        return cleaned, ok, reason
+
+    def _session_summary(self) -> str:
+        s = self.session
+        if s["y_total"] == 0:
+            return ""
+        contract_ok = s["n_ok_first"] + s["n_ok_retry"]
+        rate = 100.0 * contract_ok / s["y_total"]
+        return (f"Y: {s['y_total']} | contrato N: {rate:.0f}% "
+                f"(1er intento: {s['n_ok_first']}, reintento: {s['n_ok_retry']}) | "
+                f"degradados: {s['degraded_fast']} | fallback: {s['fallback_sem']} | "
+                f"coste sesión: ${s['cost_total_usd']:.4f}")
+
+    # ── pipeline principal ──
+    def refine_y(self, prompt_es: str, category: str = "auto",
+                 progress_cb: Optional[Callable] = None) -> Tuple[str, str, List[str]]:
+        t_start = time.time()
+        self.session["y_total"] += 1
+        rec = {"mode": "y", "lat": {}, "failed_node": None, "final_step": None, "cost_usd": 0.0}
+
+        def report(frac, desc):
+            if progress_cb:
+                progress_cb(frac, desc=desc)
+
+        def elapsed():
+            return time.time() - t_start
+
+        # 1. Traducción + recuperación (reutilizadas del pipeline base)
+        report(0.10, "🌍 Traduciendo...")
+        t0 = time.time()
+        user_en = self.base._translate_to_english(prompt_es)
+        rec["lat"]["traduccion"] = round(time.time() - t0, 2)
+        if not user_en:
+            return "", "❌ Entrada vacía o traducción fallida.", []
+
+        report(0.20, "📐 Recuperación semántica (FAISS + rerank + MMR)...")
+        t0 = time.time()
+        try:
+            agent_data = self.base.agent.extract_pattern_and_lexicon(user_en, category=category, k=6)
+        except Exception as e:
+            logger.error(f"❌ Agente: {e}")
+            agent_data = self.base.agent._default_response()
+        rec["lat"]["agente"] = round(time.time() - t0, 2)
+        examples_ui = agent_data.get("examples_ui", [])
+
+        # 2. α + γ en paralelo
+        report(0.35, "🔱 α (GLM) + γ (Kimi) generando en paralelo...")
+        out_a = out_g = None
+        with ThreadPoolExecutor(max_workers=2) as pool:
+            fut_a = pool.submit(call_with_fallback, self.client, "alpha",
+                                self._alpha_messages(user_en, agent_data),
+                                MAX_TOKENS["alpha"], 0.7, TIMEOUTS["alpha"])
+            fut_g = pool.submit(call_with_fallback, self.client, "gamma",
+                                self._gamma_messages(user_en),
+                                MAX_TOKENS["gamma"], 0.7, TIMEOUTS["gamma"])
+            try:
+                out_a = fut_a.result()
+                rec["lat"]["alpha"] = out_a["latency_s"]
+                rec["cost_usd"] += out_a["cost_usd"]
+            except Exception as e:
+                logger.warning(f"⚠️ α caído: {e}")
+                self.session["alpha_fail"] += 1
+                rec["failed_node"] = "alpha"
+            try:
+                out_g = fut_g.result()
+                rec["lat"]["gamma"] = out_g["latency_s"]
+                rec["cost_usd"] += out_g["cost_usd"]
+            except Exception as e:
+                logger.warning(f"⚠️ γ caído: {e}")
+                self.session["gamma_fail"] += 1
+                rec["failed_node"] = "gamma" if not rec["failed_node"] else "alpha+gamma"
+
+        # Ambos paralelos caídos → escalón 3 directamente
+        if not out_a and not out_g:
+            return self._degrade_fast(prompt_es, category, rec, examples_ui, elapsed)
+
+        # Degradación parcial: el superviviente ocupa ambos slots de N
+        # (la prohibición 6 de N fuerza reescritura, no copia)
+        src_a = out_a["text"] if out_a else out_g["text"]
+        src_b = out_g["text"] if out_g else out_a["text"]
+
+        # 3. N bajo contrato (1 intento + 1 reintento a temp 0.0)
+        for n_attempt, temp in ((1, 0.3), (2, 0.0)):
+            if elapsed() > GLOBAL_BUDGET_S:
+                logger.warning("⏱️ Presupuesto global agotado → fallback semántico")
+                return self._fallback_sem(user_en, category, rec, examples_ui)
+            report(0.75, f"⚖️ N (DeepSeek) normalizando (intento {n_attempt})...")
+            try:
+                out_n = call_with_fallback(self.client, "normalizer",
+                                           self._normalizer_messages(user_en, src_a, src_b),
+                                           MAX_TOKENS["normalizer"], temp, TIMEOUTS["normalizer"])
+            except NodeError as e:
+                logger.warning(f"⚠️ N caído: {e}")
+                rec["failed_node"] = (rec["failed_node"] or "") + "+N" if rec["failed_node"] else "N"
+                break
+            rec["lat"][f"N{n_attempt}"] = out_n["latency_s"]
+            rec["cost_usd"] += out_n["cost_usd"]
+            cleaned, ok, reason = self._check_contract(user_en, out_n["text"])
+            if ok:
+                key = "n_ok_first" if n_attempt == 1 else "n_ok_retry"
+                self.session[key] += 1
+                rec["final_step"] = "y" if n_attempt == 1 else "y_retry"
+                self._commit(rec)
+                lat_str = self._lat_str(rec)
+                partial = "" if (out_a and out_g) else f" (parcial: {'α' if not out_a else 'γ'} caído)"
+                status = (f"🔱 Y completo{partial} — {out_n['model'].split('/')[-1].split(':')[0]}"
+                          f"{' · reintento N' if n_attempt == 2 else ''}\n"
+                          f"{lat_str}\n{self._session_summary()}")
+                return cleaned, status, examples_ui
+            logger.warning(f"⚠️ N intento {n_attempt} incumple contrato: {reason} → '{cleaned[:80]}'")
+
+        # 4. N incumplió dos veces (o cayó) → escalón 3: modo rápido
+        return self._degrade_fast(prompt_es, category, rec, examples_ui, elapsed)
+
+    # ── escalones de degradación ──
+    def _degrade_fast(self, prompt_es, category, rec, examples_ui, elapsed):
+        if elapsed() > GLOBAL_BUDGET_S:
+            user_en = self.base._translate_to_english(prompt_es)
+            return self._fallback_sem(user_en, category, rec, examples_ui)
+        logger.info("⬇️ Degradando a modo rápido...")
+        self.session["degraded_fast"] += 1
+        rec["final_step"] = "degraded_fast"
+        t0 = time.time()
+        result, base_status, examples = self.base.refine(prompt_es, category)
+        rec["lat"]["fast"] = round(time.time() - t0, 2)
+        self._commit(rec)
+        status = (f"⚡ Y degradado a modo rápido (nodo caído: {rec['failed_node'] or 'contrato N'})\n"
+                  f"{base_status.splitlines()[0]}\n{self._session_summary()}")
+        return result, status, examples or examples_ui
+
+    def _fallback_sem(self, user_en, category, rec, examples_ui):
+        self.session["fallback_sem"] += 1
+        rec["final_step"] = "fallback_sem"
+        self._commit(rec)
+        fallback, _ = self.base.agent.enhance_prompt(user_en, category)
+        status = (f"⚠️ Fallback semántico (presupuesto {GLOBAL_BUDGET_S}s agotado o cadena caída)\n"
+                  f"{self._session_summary()}")
+        return self.base._clean_output(fallback), status, examples_ui
+
+    def _commit(self, rec):
+        rec["total_s"] = round(sum(v for v in rec["lat"].values()), 2)
+        self.session["cost_total_usd"] += rec["cost_usd"]
+        self.records.append(rec)
+        logger.info(f"📊 Telemetría Y: {rec}")
+
+    @staticmethod
+    def _lat_str(rec):
+        parts = [f"{k} {v}s" for k, v in rec["lat"].items()]
+        return "Latencias: " + " | ".join(parts) + f" | coste ~${rec['cost_usd']:.4f}"