Upload 6 files

interfaz_sara_directo_ui.py

@@ -7,10 +7,10 @@
 # ✅ Event handlers solo para sistema técnico
 
 import gradio as gr
-from sara_v3_interfaz_core import sara_optimized
 
 # Importar funciones core SOLO GEN-4
 from interfaz_sara_directo_core import (
+    sara_optimized,
     analyze_image_step1,
     generate_prompts_step2,
     update_system_info,

sara_v3_parte_4_gen4_carga.py

@@ -1,7 +1,7 @@
-# PARTE 4-GEN4 CARGA: MOTOR PRINCIPAL SARA TÉCNICO CON PARSER ARREGLADO
+# PARTE COMPLETA: SARA V3 PARTE 4-GEN4 CARGA - PARSER COMPLETAMENTE ARREGLADO
 # Sistema completo de carga y gestión del modelo Gen-4 con parser corregido
 # Usa HuggingFaceH4/zephyr-7b-beta con reglas inteligentes y extracción optimizada
-# ARREGLADO: Parser menos restrictivo, extracción mejorada, un prompt por nivel
+# ARREGLADO: Parser agresivo que ELIMINA todas las etiquetas técnicas
 
 import time
 import re
@@ -117,8 +117,8 @@ def generate_technical_prompts_gen4(image_description: str, user_idea: str = "")
         # Log de la respuesta raw para debug
         sara_v3_state.logger.info(f"🔍 Respuesta Gen-4 raw: {generated_text[:200]}...")
         
-        # Parsear prompts técnicos con extracción mejorada
-        prompts = _parse_technical_response_optimized(generated_text)
+        # Parsear prompts técnicos con extracción SUPER AGRESIVA
+        prompts = _parse_technical_response_super_aggressive(generated_text)
         
         generation_time = time.time() - start_time
         
@@ -144,220 +144,267 @@ def generate_technical_prompts_gen4(image_description: str, user_idea: str = "")
             'method': 'fallback_technical'
         }
 
-def _parse_technical_response_optimized(response: str) -> dict:
+def _parse_technical_response_super_aggressive(response: str) -> dict:
     """
-    Parser OPTIMIZADO para respuestas técnicas Gen-4
-    ARREGLADO: Menos restrictivo, mejor extracción, un prompt por nivel
+    Parser SUPER AGRESIVO para respuestas técnicas Gen-4
+    ARREGLADO: Elimina TODAS las etiquetas técnicas automáticamente
     """
     
     if not response.strip():
         sara_v3_state.logger.warning("⚠️ Respuesta vacía de Gen-4")
         return _generate_fallback_prompts_from_empty()
     
-    sara_v3_state.logger.info("📝 Parseando respuesta Gen-4 con extracción optimizada...")
+    sara_v3_state.logger.info("📝 Parseando respuesta Gen-4 con LIMPIEZA SUPER AGRESIVA...")
     
-    # Limpiar respuesta completa primero
-    cleaned_response = _clean_full_response(response)
+    # PASO 1: Limpiar respuesta completa de etiquetas obvias
+    cleaned_response = _super_aggressive_cleaning(response)
     
-    # Estrategia 1: Dividir por párrafos dobles
-    sections = [s.strip() for s in cleaned_response.split('\n\n') if s.strip() and len(s.strip()) > 20]
-    
-    # Estrategia 2: Si no hay párrafos, dividir por líneas
-    if len(sections) < 2:
-        lines = [l.strip() for l in cleaned_response.split('\n') if l.strip() and len(l.strip()) > 20]
-        sections = lines
+    # PASO 2: Dividir en secciones
+    sections = _extract_sections_multiple_strategies(cleaned_response)
     
-    # Estrategia 3: Si aún no hay suficiente, dividir por puntos
-    if len(sections) < 2:
-        sentences = [s.strip() + '.' for s in cleaned_response.split('.') if s.strip() and len(s.strip()) > 20]
-        sections = sentences
-    
-    # Limpiar y validar cada sección
-    valid_prompts = []
+    # PASO 3: Limpiar cada sección individualmente y ELIMINAR ETIQUETAS
+    clean_prompts = []
     for section in sections:
-        cleaned_section = _clean_prompt_aggressive(section)
-        if _is_valid_prompt_relaxed(cleaned_section):
-            valid_prompts.append(cleaned_section)
+        cleaned_prompt = _eliminate_all_technical_labels(section)
+        if _is_valid_clean_prompt(cleaned_prompt):
+            clean_prompts.append(cleaned_prompt)
     
-    sara_v3_state.logger.info(f"🧹 Extraídos {len(valid_prompts)} prompts válidos de {len(sections)} secciones")
+    sara_v3_state.logger.info(f"🧹 Extraídos {len(clean_prompts)} prompts LIMPIOS de {len(sections)} secciones")
     
-    # Asignar prompts a niveles - UN PROMPT POR NIVEL
+    # PASO 4: Asignar a niveles - UN PROMPT LIMPIO POR NIVEL
     levels = ['basic', 'intermediate', 'advanced', 'experimental']
     final_prompts = {}
     
     for i, level in enumerate(levels):
-        if i < len(valid_prompts):
-            # Usar prompt extraído
-            final_prompts[level] = valid_prompts[i]
+        if i < len(clean_prompts):
+            # Usar prompt limpio extraído
+            final_prompts[level] = clean_prompts[i]
         else:
-            # Generar prompt faltante basado en los existentes
-            final_prompts[level] = _generate_level_prompt(level, valid_prompts, cleaned_response)
+            # Generar prompt faltante sin etiquetas
+            final_prompts[level] = _generate_clean_level_prompt(level, clean_prompts, cleaned_response)
     
-    # Log final para debug
+    # Log final para verificar limpieza
     for level, prompt in final_prompts.items():
         sara_v3_state.logger.info(f"📝 {level.upper()}: {prompt[:60]}...")
     
     return final_prompts
 
-def _clean_full_response(response: str) -> str:
-    """Limpieza inicial de la respuesta completa"""
-    
-    # Remover texto introductorio común
-    intro_patterns = [
-        r'^Based on.*?here are.*?:',
-        r'^Here are.*?prompts.*?:',
-        r'^.*?Generate.*?prompts.*?:',
-        r'^.*?four prompts.*?:',
-        r'^.*?increasing complexity.*?:'
+def _super_aggressive_cleaning(response: str) -> str:
+    """
+    Limpieza SUPER AGRESIVA de etiquetas técnicas de la respuesta completa
+    ARREGLADO: Elimina TODO lo que parezca etiqueta técnica
+    """
+    
+    # Lista completa de patrones a eliminar AGRESIVAMENTE
+    aggressive_patterns = [
+        # Patrones específicos que vimos en los logs
+        r'Prompt\s*\d+\s*\([^)]+\):\s*',           # "Prompt 1 (Basic): "
+        r'Prompt\s*\d+\s*\(.*?\):\s*',             # "Prompt 1 (cualquier cosa): "
+        r'Prompt\s*\d+:\s*',                       # "Prompt 1: "
+        
+        # Patrones generales de etiquetas
+        r'^\d+\.\s*',                              # "1. "
+        r'^Basic:\s*',                             # "Basic: "
+        r'^Intermediate:\s*',                      # "Intermediate: "
+        r'^Advanced:\s*',                          # "Advanced: "
+        r'^Experimental:\s*',                      # "Experimental: "
+        r'^Level\s*\d+:\s*',                       # "Level 1: "
+        r'^[\-\*\•]\s*',                          # "- ", "* ", "• "
+        
+        # Patrones más agresivos
+        r'Based on.*?here are.*?:',               # Textos introductorios
+        r'Here are.*?prompts.*?:',                # "Here are the prompts:"
+        r'Generate.*?prompts.*?:',                # "Generate 4 prompts:"
+        r'.*?four prompts.*?:',                   # "Here are four prompts:"
+        r'.*?increasing complexity.*?:',          # "with increasing complexity:"
+        
+        # Eliminar numeración al inicio
+        r'^\s*\d+\)\s*',                          # "1) "
+        r'^\s*\(\d+\)\s*',                        # "(1) "
+        
+        # Eliminar comillas mal formadas
+        r'^["\']|["\']$',                         # Comillas al inicio/final
     ]
     
-    for pattern in intro_patterns:
+    original_response = response
+    
+    # Aplicar todos los patrones de limpieza
+    for pattern in aggressive_patterns:
         response = re.sub(pattern, '', response, flags=re.IGNORECASE | re.MULTILINE)
     
-    # Limpiar saltos de línea excesivos
+    # Limpiar espacios múltiples y saltos de línea excesivos
     response = re.sub(r'\n{3,}', '\n\n', response)
+    response = re.sub(r'\s+', ' ', response)
     response = response.strip()
     
+    sara_v3_state.logger.info(f"🧹 Limpieza agresiva: {len(original_response)} → {len(response)} caracteres")
+    
     return response
 
-def _clean_prompt_aggressive(text: str) -> str:
+def _extract_sections_multiple_strategies(text: str) -> list:
     """
-    Limpieza AGRESIVA pero inteligente de prompts individuales
-    ARREGLADO: Menos destructiva, preserva contenido válido
+    Extraer secciones usando múltiples estrategias
     """
     
-    if not text or len(text) < 10:
+    # Estrategia 1: Dividir por párrafos dobles
+    sections = [s.strip() for s in text.split('\n\n') if s.strip() and len(s.strip()) > 15]
+    
+    if len(sections) >= 4:
+        return sections[:4]  # Tomar los primeros 4
+    
+    # Estrategia 2: Dividir por líneas individuales
+    if len(sections) < 4:
+        lines = [l.strip() for l in text.split('\n') if l.strip() and len(l.strip()) > 15]
+        if len(lines) >= 4:
+            return lines[:4]
+        sections.extend(lines)
+    
+    # Estrategia 3: Dividir por puntos
+    if len(sections) < 4:
+        sentences = [s.strip() + '.' for s in text.split('.') if s.strip() and len(s.strip()) > 15]
+        sections.extend(sentences)
+    
+    # Retornar al menos 4 secciones (rellenar si es necesario)
+    while len(sections) < 4:
+        sections.append("Camera moves smoothly while subject performs natural action, professional lighting creates cinematic atmosphere.")
+    
+    return sections[:4]
+
+def _eliminate_all_technical_labels(text: str) -> str:
+    """
+    Eliminar TODAS las etiquetas técnicas de un prompt individual
+    ARREGLADO: Más agresivo con la limpieza
+    """
+    
+    if not text or len(text) < 5:
         return ""
     
     original_text = text
     
-    # Remover etiquetas obvias pero conservar contenido
-    patterns_to_remove = [
-        r'^\d+\.\s*',                    # "1. "
-        r'^Basic:\s*',                   # "Basic: "
-        r'^Intermediate:\s*',            # "Intermediate: "
-        r'^Advanced:\s*',                # "Advanced: "
-        r'^Experimental:\s*',            # "Experimental: "
-        r'^Prompt\s*\d+:\s*',           # "Prompt 1: "
-        r'^Level\s*\d+:\s*',            # "Level 1: "
-        r'^[\-\*\•]\s*',                # "- ", "* ", "• "
+    # Patrones específicos para eliminar etiquetas restantes
+    label_elimination_patterns = [
+        r'^Prompt\s*\d+\s*\([^)]+\):\s*',         # "Prompt 1 (Basic): "
+        r'^Prompt\s*\d+\s*\(.*?\):\s*',           # "Prompt 1 (...): "
+        r'^Prompt\s*\d+:\s*',                     # "Prompt 1: "
+        r'^\d+\.\s*Basic:\s*',                    # "1. Basic: "
+        r'^\d+\.\s*Intermediate:\s*',             # "2. Intermediate: "
+        r'^\d+\.\s*Advanced:\s*',                 # "3. Advanced: "
+        r'^\d+\.\s*Experimental:\s*',             # "4. Experimental: "
+        r'^Basic\s*Level:\s*',                    # "Basic Level: "
+        r'^Intermediate\s*Level:\s*',             # "Intermediate Level: "
+        r'^Advanced\s*Level:\s*',                 # "Advanced Level: "
+        r'^Experimental\s*Level:\s*',             # "Experimental Level: "
+        r'^\d+\.\s*',                             # "1. ", "2. ", etc.
+        r'^[\-\*\•]\s*',                          # "- ", "* ", "• "
     ]
     
-    for pattern in patterns_to_remove:
+    # Aplicar limpieza de etiquetas
+    for pattern in label_elimination_patterns:
         text = re.sub(pattern, '', text, flags=re.IGNORECASE)
     
-    # Limpiar comillas mal formadas
-    text = re.sub(r'^["\']|["\']$', '', text)
-    text = re.sub(r'["\']([^"\']*)["\']', r'\1', text)
-    
-    # Normalizar espacios
+    # Limpiar comillas y espacios
+    text = re.sub(r'^["\'\s]+|["\'\s]+$', '', text)
     text = re.sub(r'\s+', ' ', text)
     text = text.strip()
     
-    # Si se vació demasiado, intentar extracción suave
-    if len(text) < 15 and len(original_text) > 30:
+    # Asegurar capitalización y terminación
+    if text and len(text) > 5:
+        # Capitalizar primera letra
+        text = text[0].upper() + text[1:] if len(text) > 1 else text.upper()
+        
+        # Asegurar terminación con punto
+        if not text.endswith(('.', '!', '?')):
+            text += '.'
+    
+    # Si se vació demasiado, intentar recuperar contenido útil
+    if len(text) < 10 and len(original_text) > 20:
         # Buscar contenido después de dos puntos
         if ':' in original_text:
             parts = original_text.split(':', 1)
-            if len(parts) > 1 and len(parts[1].strip()) > 15:
+            if len(parts) > 1 and len(parts[1].strip()) > 10:
                 text = parts[1].strip()
                 text = re.sub(r'^["\'\s]+|["\'\s]+$', '', text)
-    
-    # Asegurar capitalización y terminación
-    if text and len(text) > 10:
-        if not text[0].isupper():
-            text = text[0].upper() + text[1:]
-        
-        if not text.endswith(('.', '!', '?')):
-            text += '.'
+                if text and not text.endswith(('.', '!', '?')):
+                    text += '.'
     
     return text.strip()
 
-def _is_valid_prompt_relaxed(text: str) -> bool:
+def _is_valid_clean_prompt(text: str) -> bool:
     """
-    Validación RELAJADA de prompts - ARREGLADO: Menos restrictiva
+    Validación PERMISIVA de prompts limpios
     """
     
-    if not text or len(text) < 10:
+    if not text or len(text) < 8:
         return False
     
-    # Patrones que definitivamente NO son prompts (muy restrictivo)
-    definitely_invalid = [
-        r'^(Here are|Based on|Generate|Create)',
-        r'^(BASIC|INTERMEDIATE|ADVANCED|EXPERIMENTAL)[:]\s*$',
-        r'^\d+\.\s*$',
-        r'^[Pp]rompt\s*\d+\s*[:]\s*$'
+    # NO debe contener etiquetas técnicas residuales
+    bad_patterns = [
+        r'Prompt\s*\d+',
+        r'Basic:|Intermediate:|Advanced:|Experimental:',
+        r'Level\s*\d+',
+        r'^\d+\.',
+        r'^[\-\*\•]'
     ]
     
-    for pattern in definitely_invalid:
-        if re.match(pattern, text, re.IGNORECASE):
+    for pattern in bad_patterns:
+        if re.search(pattern, text, re.IGNORECASE):
             return False
     
-    # Debe tener al menos UNA palabra clave de video IA (muy permisivo)
+    # Debe tener al menos alguna palabra relacionada con video
     video_keywords = [
         'camera', 'shot', 'movement', 'lighting', 'frame', 'focus',
         'moves', 'tracks', 'follows', 'reveals', 'transitions',
-        'smoothly', 'slowly', 'gently', 'steadily', 'woman', 'man', 
-        'person', 'subject', 'dolly', 'crane', 'steadicam', 'time-lapse',
-        'cinematic', 'dramatic', 'golden', 'natural', 'professional'
+        'smoothly', 'slowly', 'gently', 'steadily', 'subject', 
+        'cinematic', 'dramatic', 'natural', 'professional'
     ]
     
     text_lower = text.lower()
-    keyword_count = sum(1 for keyword in video_keywords if keyword in text_lower)
-    
-    # Muy permisivo: solo necesita 1 palabra clave
-    has_keywords = keyword_count >= 1
-    
-    # Debe tener longitud razonable
-    reasonable_length = 10 <= len(text) <= 1000
+    has_video_keyword = any(keyword in text_lower for keyword in video_keywords)
     
-    # Debe tener al menos 3 palabras
-    has_words = len(text.split()) >= 3
-    
-    return has_keywords and reasonable_length and has_words
+    return has_video_keyword and len(text.split()) >= 5
 
-def _generate_level_prompt(level: str, existing_prompts: list, original_response: str) -> str:
+def _generate_clean_level_prompt(level: str, existing_prompts: list, original_response: str) -> str:
     """
-    Generar prompt para nivel específico basado en prompts existentes
-    ARREGLADO: Mejor integración con prompts reales extraídos
+    Generar prompt limpio para nivel específico SIN etiquetas técnicas
     """
     
-    # Si hay prompts existentes, usar como base
+    # Templates limpios sin etiquetas
+    clean_templates = {
+        'basic': "Camera tracks steadily while subject moves naturally, professional lighting creates clean visual foundation.",
+        
+        'intermediate': "Steadicam follows subject with controlled movement, enhanced lighting creates cinematic depth and atmospheric storytelling.",
+        
+        'advanced': "Sophisticated camera work employs complex staging techniques, dramatic lighting transitions with color grading create compelling visual narrative using advanced cinematographic elements.",
+        
+        'experimental': "Time-lapse sequences transform conventional reality through innovative camera approaches, experimental lighting techniques create transcendent visual poetry."
+    }
+    
+    # Si hay prompts existentes, intentar extrapolar el contenido
     if existing_prompts:
         base_prompt = existing_prompts[0]
         
-        # Extraer elementos del prompt base
+        # Extraer sujeto del prompt base
         base_lower = base_prompt.lower()
-        
         if 'woman' in base_lower:
-            subject = "Woman"
+            subject = "woman"
         elif 'man' in base_lower:
-            subject = "Man"
+            subject = "man"
         elif 'person' in base_lower:
-            subject = "Person"
+            subject = "person"
         else:
-            subject = "Subject"
-        
-        # Generar prompts escalados basados en el contenido real
-        level_templates = {
-            'basic': f"Camera tracks {subject.lower()} with steady movement, natural lighting creates professional framing.",
-            
-            'intermediate': f"Steadicam follows {subject.lower()} with controlled precision, enhanced lighting creates cinematic depth and visual storytelling.",
-            
-            'advanced': f"Sophisticated crane shot reveals {subject.lower()} through complex staging techniques, dramatic lighting transitions with color grading create compelling visual narrative using advanced cinematographic elements.",
-            
-            'experimental': f"Time-lapse sequences transform conventional reality as {subject.lower()} transcends physical boundaries through innovative camera approaches and experimental lighting techniques."
-        }
+            subject = "subject"
         
-        return level_templates.get(level, base_prompt)
+        # Personalizar template con el sujeto
+        template = clean_templates.get(level, clean_templates['basic'])
+        personalized = template.replace('subject', subject)
+        return personalized
     
-    # Fallback si no hay prompts válidos extraídos
-    return f"Camera moves smoothly while subject performs natural movement, professional lighting creates cinematic atmosphere."
+    return clean_templates.get(level, clean_templates['basic'])
 
 def _generate_fallback_prompts_from_empty() -> dict:
-    """Generar prompts cuando la respuesta está completamente vacía"""
+    """Generar prompts limpios cuando la respuesta está vacía"""
     
-    sara_v3_state.logger.warning("⚠️ Generando prompts desde respuesta vacía")
+    sara_v3_state.logger.warning("⚠️ Generando prompts limpios desde respuesta vacía")
     
     return {
         'basic': "Camera tracks steadily while subject moves naturally, professional lighting creates clean visual foundation.",
@@ -367,7 +414,7 @@ def _generate_fallback_prompts_from_empty() -> dict:
     }
 
 def _generate_technical_fallback_gen4(image_description: str, user_idea: str = "") -> dict:
-    """Fallback técnico mejorado para Gen-4"""
+    """Fallback técnico mejorado para Gen-4 SIN etiquetas"""
     
     sara_v3_state.logger.info("🔄 Generando fallback técnico Gen-4...")
     
@@ -387,7 +434,6 @@ def _generate_technical_fallback_gen4(image_description: str, user_idea: str = "
     
     # Procesar e integrar user_idea si existe
     if user_idea.strip():
-        # Limpiar user_idea
         clean_idea = user_idea.strip()
         
         # Remover artículos en español
@@ -406,9 +452,7 @@ def _generate_technical_fallback_gen4(image_description: str, user_idea: str = "
             'se acerca': 'approaches',
             'lentamente': 'slowly',
             'rápidamente': 'quickly',
-            'suavemente': 'gently',
-            'movimiento': 'movement',
-            'iluminación': 'lighting'
+            'suavemente': 'gently'
         }
         
         for spanish, english in translation_map.items():
@@ -418,7 +462,7 @@ def _generate_technical_fallback_gen4(image_description: str, user_idea: str = "
     else:
         action_base = "moves naturally"
     
-    # Generar prompts técnicos mejorados con integración real
+    # Generar prompts técnicos LIMPIOS sin etiquetas
     return {
         'basic': f"{subject} {action_base} while camera tracks steadily, {clean_description}, professional lighting setup creates clean visual foundation.",
         
@@ -464,7 +508,7 @@ def get_gen4_info() -> dict:
     info = {
         'status': get_gen4_status(),
         'model': 'HuggingFaceH4/zephyr-7b-beta',
-        'system': 'Reglas Inteligentes + Parser Optimizado'
+        'system': 'Reglas Inteligentes + Parser SUPER AGRESIVO'
     }
     
     if hasattr(sara_v3_state, 'gen4_load_time'):
@@ -479,35 +523,9 @@ def get_gen4_info() -> dict:
     
     return info
 
-# Función principal para integración con sistema existente
-def integrate_gen4_with_existing_system():
-    """Integrar Gen-4 con sistema SARA existente sin romper compatibilidad"""
-    
-    sara_v3_state.logger.info("🔗 Integrando Gen-4 con sistema existente...")
-    
-    # Verificar que sistema actual esté disponible
-    try:
-        from sara_v3_parte_4 import is_sara_ready
-        
-        if is_sara_ready():
-            sara_v3_state.logger.info("✅ Sistema poético SARA-v2 disponible")
-        else:
-            sara_v3_state.logger.info("⚠️ Sistema poético no disponible")
-    except ImportError:
-        sara_v3_state.logger.info("⚠️ Sistema poético no disponible")
-    
-    if is_gen4_ready():
-        sara_v3_state.logger.info("✅ Sistema técnico Gen-4 disponible")
-    else:
-        sara_v3_state.logger.info("⚠️ Sistema técnico no disponible")
-    
-    # Marcar integración completada
-    sara_v3_state.dual_system_ready = True
-    sara_v3_state.logger.info("🎯 Sistema dual SARA disponible: Poético + Técnico")
-
 if __name__ == "__main__":
-    # Test del sistema Gen-4
-    print("🧪 Probando carga SARA Gen-4...")
+    # Test del sistema Gen-4 con parser agresivo
+    print("🧪 Probando carga SARA Gen-4 con parser SUPER AGRESIVO...")
     
     success = load_sara_gen4_complete()
     
@@ -524,25 +542,23 @@ if __name__ == "__main__":
         if test_result['success']:
             print("🎬 Test generación exitoso:")
             for level, prompt in test_result['prompts'].items():
-                print(f"  {level.upper()}: {prompt[:60]}...")
+                print(f"  {level.upper()}: {prompt}")
         else:
             print(f"❌ Test generación falló: {test_result['error']}")
     else:
         print("❌ Error cargando Gen-4")
     
-    print("✅ Test Gen-4 completado")
+    print("✅ Test Gen-4 completado con parser SUPER AGRESIVO")
 
-# FINAL SARA V3 PARTE 4-GEN4 CARGA: PARSER COMPLETAMENTE ARREGLADO
+# FINAL SARA V3 PARTE 4-GEN4 CARGA: PARSER SUPER AGRESIVO IMPLEMENTADO
 # 
 # CORRECCIONES IMPLEMENTADAS:
-# ✅ _parse_technical_response_optimized() - Parser completamente reescrito
-# ✅ _clean_prompt_aggressive() - Limpieza menos destructiva  
-# ✅ _is_valid_prompt_relaxed() - Validación mucho menos restrictiva
-# ✅ _generate_level_prompt() - Generación mejorada basada en contenido real
-# ✅ _clean_full_response() - Limpieza inicial de respuesta completa
-# ✅ _generate_fallback_prompts_from_empty() - Manejo de respuestas vacías
-# ✅ _generate_technical_fallback_gen4() - Fallback mejorado con traducción
-# ✅ Logging de debug para diagnosticar problemas de parsing
-# ✅ Estrategias múltiples de extracción (párrafos, líneas, oraciones)
-# ✅ Un prompt limpio por nivel garantizado
-# ✅ Preservación de contenido válido durante limpieza
+# ✅ _parse_technical_response_super_aggressive() - Parser completamente reescrito
+# ✅ _super_aggressive_cleaning() - Limpieza SUPER agresiva de etiquetas
+# ✅ _eliminate_all_technical_labels() - Eliminación total de "Prompt X (Level):"
+# ✅ _is_valid_clean_prompt() - Validación que rechaza prompts con etiquetas
+# ✅ _generate_clean_level_prompt() - Generación SIN etiquetas técnicas
+# ✅ _extract_sections_multiple_strategies() - Extracción mejorada
+# ✅ Todos los fallbacks generan prompts LIMPIOS sin etiquetas
+# ✅ Logging detallado para verificar limpieza efectiva
+# ✅ Garantía: Los prompts salen LIMPIOS sin "Prompt X (Level):"