Update app.py

app.py

@@ -6,6 +6,7 @@ from typing import Dict, List, Tuple, Optional
 import gradio as gr
 import google.generativeai as genai
 import warnings
+import re
 warnings.filterwarnings("ignore", category=FutureWarning, module="google.api_core")
 
 # ============================================================================
@@ -15,363 +16,319 @@ API_KEY = os.getenv("GOOGLE_API_KEY", "sua-chave-aqui")
 genai.configure(api_key=API_KEY)
 model = genai.GenerativeModel("gemini-2.0-flash")
 
-TITLE = "# 🚀 Pipeline Híbrida v9\n**Lógica app-7.py + Estrutura 9 Passos**"
+TITLE = "# 🚀 Pipeline v10\n**P0-P1 → X1-X2 → P2-P8**"
 
 # ============================================================================
-# LOGGER
+# LOGGER MELHORADO
 # ============================================================================
 class Logger:
     def __init__(self, verbose=True):
         self.verbose = verbose
         self.logs = []
-
     def log(self, msg: str, level="INFO"):
         timestamp = datetime.now().strftime("%H:%M:%S")
         log_msg = f"[{timestamp}] [{level}] {msg}"
         self.logs.append(log_msg)
-        if self.verbose:
-            print(log_msg)
+        if self.verbose: print(log_msg)
 
 logger = Logger(verbose=True)
 
 # ============================================================================
-# HELPERS GLOBAIS (app-7.py style)
+# HELPERS ULTRA ROBUSTOS
 # ============================================================================
 def processar_anexo(arquivo) -> Tuple[str, str]:
-    if arquivo is None:
-        logger.log("Nenhum anexo fornecido.", "DEBUG")
-        return "", "nenhum"
+    if arquivo is None: return "", "nenhum"
     try:
         caminho = str(arquivo)
         if caminho.lower().endswith('.pdf'):
-            logger.log(f"Processando PDF: {caminho}", "DEBUG")
             try:
                 import PyPDF2
                 with open(caminho, 'rb') as f:
                     leitor = PyPDF2.PdfReader(f)
                     texto = "".join(pagina.extract_text() + "\n" for pagina in leitor.pages[:3])
-                    logger.log("PDF processado com sucesso.", "DEBUG")
                     return texto[:2000], "pdf"
-            except Exception as e:
-                logger.log(f"Falha ao processar PDF: {str(e)}", "WARNING")
-                return f"[PDF: {os.path.basename(caminho)}]", "pdf"
-        elif any(caminho.lower().endswith(ext) for ext in ['.png', '.jpg', '.jpeg', '.gif']):
-            logger.log(f"Processando imagem: {caminho}", "DEBUG")
+            except: return f"[PDF detectado]", "pdf"
+        elif any(caminho.lower().endswith(ext) for ext in ['.png','.jpg','.jpeg','.gif']):
             with open(caminho, 'rb') as f:
-                conteudo_b64 = base64.b64encode(f.read()).decode()[:500]
-                logger.log("Imagem processada para base64.", "DEBUG")
-                return conteudo_b64, "imagem"
-        else:
-            logger.log(f"Tipo de anexo não suportado: {caminho}", "WARNING")
-            return "", "nao_suportado"
-    except Exception as e:
-        logger.log(f"Erro ao processar anexo: {str(e)}", "ERROR")
-        return "", "erro"
+                return base64.b64encode(f.read()).decode()[:500], "imagem"
+        return "", "nao_suportado"
+    except: return "", "erro"
 
 def construir_prompt_com_anexo(pergunta: str, anexo_conteudo: str, tipo_anexo: str) -> str:
-    if not anexo_conteudo or tipo_anexo == "nenhum":
-        return pergunta
-    if tipo_anexo == "pdf":
-        prompt = f"""DOCUMENTO PDF:
-{anexo_conteudo}
-
+    if not anexo_conteudo or tipo_anexo == "nenhum": return pergunta
+    if tipo_anexo == "pdf": return f"""DOCUMENTO:
+{anexo_conteudo[:1800]}
+---
 PERGUNTA: {pergunta}"""
-        logger.log("Construindo prompt com conteúdo PDF.", "DEBUG")
-        return prompt
-    prompt = f"""IMAGEM FORNECIDA
-
+    return f"""ANEXO VISUAL:
 PERGUNTA: {pergunta}"""
-    logger.log("Construindo prompt com conteúdo de imagem.", "DEBUG")
-    return prompt
 
-def parse_json_seguro(texto: str) -> Dict:
+def parse_json_ultra_robusto(texto: str) -> Dict:
+    """Extrai QUALQUER JSON de texto bagunçado"""
+    logger.log(f"Parse: {len(texto)} chars", "DEBUG")
+    if not texto: return {"erro": "vazio"}
+    
     try:
-        if not texto:
-            logger.log("Texto vazio recebido para parse de JSON.", "WARNING")
-            return {"erro": "texto_vazio"}
-        import re
-        match = re.search(r'\{.*\}', texto, re.DOTALL)
-        if match:
-            return json.loads(match.group(0).strip())
-        inicio, fim = texto.find('{'), texto.rfind('}') + 1
-        if inicio >= 0 and fim > inicio:
-            return json.loads(texto[inicio:fim])
-        logger.log("JSON não encontrado no texto.", "WARNING")
+        # Regex múltiplos JSONs
+        matches = re.findall(r'\{[^{}]*(?:\{[^{}]*\}[^{}]*)*\}', texto, re.DOTALL)
+        for match in matches:
+            try: return json.loads(match)
+            except: continue
+        
+        # JSON balanceado primeiro
+        inicio = texto.find('{')
+        if inicio != -1:
+            count, i = 1, inicio + 1
+            while i < len(texto) and count > 0:
+                if texto[i] == '{': count += 1
+                elif texto[i] == '}': count -= 1
+                i += 1
+            if count == 0: return json.loads(texto[inicio:i])
+        
+        # Fallback último JSON
+        fim = texto.rfind('}')
+        if fim != -1:
+            count, i = 1, fim - 1
+            while i >= 0 and count > 0:
+                if texto[i] == '}': count += 1
+                elif texto[i] == '{': count -= 1
+                i -= 1
+            if count == 0: return json.loads(texto[i+1:fim+1])
+            
     except Exception as e:
-        logger.log(f"Falha ao parsear JSON: {e}", "ERROR")
-    return {"erro": "parse_falhou"}
+        logger.log(f"Parse falhou: {str(e)[:100]}", "ERROR")
+    
+    return {"erro": "parse_falhou", "fallback": texto[:200]}
+
+def chamar_gemini_json(prompt_base: str, temperatura=0.4, max_tokens=1500) -> Dict:
+    prompt = f"""{prompt_base}
+
+---
 
-def chamar_gemini_json(prompt_base: str, temperatura: float = 0.5, max_tokens: int = 1500) -> Dict:
-    prompt = f"{prompt_base}\n\nRETORNE APENAS JSON VÁLIDO. SEM TEXTO EXTRA."
-    logger.log(f"Enviando prompt ao modelo Gemini (temperatura={temperatura}, max_tokens={max_tokens})", "DEBUG")
+**JSON PURO OBRIGATÓRIO**
+SEM TEXTO EXTRA. APENAS:
+{{"chave": "valor"}}"""
+    
     try:
         response = model.generate_content(prompt, 
             generation_config=genai.types.GenerationConfig(
-                temperature=temperatura, max_output_tokens=max_tokens))
-        logger.log("Resposta recebida do Gemini.", "DEBUG")
-        return parse_json_seguro(response.text or "")
+                temperature=temperatura, 
+                max_output_tokens=max_tokens))
+        logger.log(f"Gemini OK: {len(response.text)} chars", "DEBUG")
+        return parse_json_ultra_robusto(response.text or "")
     except Exception as e:
-        logger.log(f"Erro na chamada da API Gemini: {str(e)}", "ERROR")
+        logger.log(f"API erro: {str(e)}", "ERROR")
         return {"erro": str(e)}
 
-def historico_texto(historico: List) -> str:
-    if not historico:
-        return "Primeira interação"
-    texto = ""
-    for msg in historico[-3:]:
-        if isinstance(msg, dict) and 'content' in msg:
-            texto += f"U: {msg['content'][:80]}...\n"
-        elif isinstance(msg, (list, tuple)) and len(msg) >= 2:
-            texto += f"U: {msg[0][:80]}...\n"
-    return texto[:800]
-
-def criar_dna_vazio() -> Dict:
-    logger.log("Inicializando objeto DNA vazio.", "DEBUG")
+def historico_compacto(historico: List) -> str:
+    if not historico: return "PRIMEIRO"
+    return "\n".join([str(msg).split("\n")[0][:80] for msg in historico[-2:]])
+
+def criar_dna() -> Dict:
     return {
         "historico_chat": [],
-        "historico_passos": {
-            "passo0": [], "passo1": [], "passo2": [], "passo3": [], 
-            "passo4": [], "passo5": [], "passo6": [], "passo7": [], "passo8": []
-        },
-        "memoria_contextual": {"resumo": "", "temas": []},
-        "metadados": {"total_turnos": 0}
+        "historico_passos": {f"passo{i}": [] for i in range(10)},
+        "memoria": {"resumo": ""},
+        "meta": {"turnos": 0}
     }
 
 # ============================================================================
-# PASSOS HÍBRIDOS (base app-7.py + estrutura v9)
+# PASSOS P0-P1 (ANTIGOS)
 # ============================================================================
-
-def passo_0_aluno(pergunta: str, historico: List, dna: Dict) -> Dict:
-    logger.log("🧠 Executando P0: ALUNO - Feedback anterior", "TASK")
-    hist = historico_texto(historico)
-    prompt = f"""METACOGNIÇÃO PURA - P0-ALUNO (TELEGRÁFICO)
-TURNO ANTERIOR: {hist}
-NOVA MENSAGEM: {pergunta}
-
-USUARIO-entendeu sim/nao | pergunta-nova avanca-topico | 
-usuario-corrigiu sim/nao | correcao-detectada texto-null
-
-{{"tipo_relacao": "continuação|correção|dúvida|nova", 
-  "peso_historico": "alto|médio|baixo",
-  "decisao": "prosseguirpasso1|reexplicar"}}"""
-    return chamar_gemini_json(prompt, temperatura=0.5)
-
-def passo_1_triagem_epistemica(pergunta: str, p0: Dict, historico: List, dna: Dict) -> Dict:
-    logger.log("📊 Executando P1: TRIAGEM", "TASK")
-    contextovago = dna.get("memoria_contextual", {}).get("resumo", "")
-    historicorecente = historico[-3:]
-    prompt = f"""METACOGNIÇÃO - P1-TRIAGEM (TELEGRÁFICO)
-CONTEXTO VAGO: {contextovago}
-HISTÓRICO RECENTE: {json.dumps(historicorecente[-3:], ensure_ascii=False)}
+def passo_0_aluno(pergunta: str, historico: List) -> Dict:
+    logger.log("🧠 P0-ALUNO", "TASK")
+    prompt = f"""P0-ALUNO TELEGRÁFICO
+HISTÓRICO: {historico_compacto(historico)}
 PERGUNTA: {pergunta}
 
-tipo objetiva/factual/subjetiva | sinais tem-resposta-unica | 
-confianca alta/media/baixa | decisao responderdireto/analisarprofundamente
+{{"relacao": "continua|nova|corrige", "peso_hist": "alto|medio|baixo"}}"""
+    return chamar_gemini_json(prompt)
 
-{{"tipo": "objetiva|factual|subjetiva", 
-  "sinais": ["tem-resposta-unica"], 
-  "confianca": "alta|media|baixa",
-  "decisao": "responderdireto|analisarprofundamente",
-  "razao": "breve"}}"""
-    return chamar_gemini_json(prompt, temperatura=0.5)
-
-def passo_2_gerador_cenarios(pergunta: str, p1: Dict, historico: List, dna: Dict) -> Dict:
-    logger.log("🎯 Executando P2: CENÁRIOS", "TASK")
-    contextovago = dna.get("memoria_contextual", {}).get("resumo", "")
-    prompt = f"""METACOGNIÇÃO - P2-CENÁRIOS (TELEGRÁFICO)
-CONTEXTO VAGO: {contextovago}
-TRIAGEM P1: {json.dumps(p1, ensure_ascii=False)}
+def passo_1_triagem(pergunta: str, p0: Dict, historico: List) -> Dict:
+    logger.log("📊 P1-TRIAGEM", "TASK")
+    prompt = f"""P1-TRIAGEM TELEGRÁFICO
+P0: {json.dumps(p0)}
 PERGUNTA: {pergunta}
 
-cenarios: desc cenrio-1-comprimido | razao resposta-muda | 
-prob maisprovavel/menosprovavel | total 2-3
+{{"tipo": "factual|subjetiva|aberta", 
+  "confianca": "alta|media|baixa",
+  "fatos": ["fato1", "fato2"]}}"""
+    return chamar_gemini_json(prompt)
 
-{{"cenarios": {{"provaveis": [{{"id": "C1", "desc": "curta", "validadores": []}}], 
-              "improvaveis": [{{"id": "C2", "desc": "curta"}}],
-              "total": 2}},
-  "decisao": "prosseguir|pediresclarecimento",
-  "pergunta": "null"}}"""
-    return chamar_gemini_json(prompt, temperatura=0.6)
+# ============================================================================
+# NOVOS PASSOS X1-X2
+# ============================================================================
+def passo_x1_perguntas_necessarias(pergunta: str, p1: Dict, historico: List) -> Dict:
+    """X1: Quais perguntas precisamos responder antes dos cenários?"""
+    logger.log("❓ X1-PERGUNTAS NECESSÁRIAS", "TASK")
+    prompt = f"""X1-PERGUNTAS CRÍTICAS TELEGRÁFICO
+P1: {json.dumps(p1)}
+CONTEXTO: {historico_compacto(historico)}
+PERGUNTA PRINCIPAL: {pergunta}
+
+LACUNAS FACTUAIS/SUBJETIVAS:
+{{"perguntas": [
+  {{"texto": "pergunta curta", "necessidade": "alta|media|baixa", "relevancia": "alta|media"}}
+]}}"""
+    return chamar_gemini_json(prompt)
+
+def passo_x2_resolver_perguntas(pergunta: str, p1: Dict, x1: Dict, historico: List) -> Dict:
+    """X2: Responde as perguntas levantadas com confiança/conflito"""
+    logger.log("✅ X2-RESOLVER PERGUNTAS", "TASK")
+    perguntas = x1.get("perguntas", [])
+    prompt = f"""X2-RESOLUÇÃO TELEGRÁFICO
+P1: {json.dumps(p1)}
+PERGUNTAS X1: {json.dumps(perguntas)}
+CONTEXTO: {historico_compacto(historico)}
+
+PARA CADA PERGUNTA:
+{{"respostas": [
+  {{"pergunta": "texto original",
+    "resposta": "curta direta",
+    "confianca": "alta|media|baixa",
+    "conflito": "alto|medio|baixo",
+    "razao": "1-2 palavras"}
+]}}"""
+    return chamar_gemini_json(prompt, max_tokens=2000)
+
+# ============================================================================
+# PASSOS P2-P8 (MELHORADOS COM X1-X2)
+# ============================================================================
+def passo_2_cenarios(pergunta: str, p1: Dict, x1: Dict, x2: Dict, historico: List) -> Dict:
+    logger.log("🎯 P2-CENÁRIOS (com X1-X2)", "TASK")
+    prompt = f"""P2-CENÁRIOS TELEGRÁFICO
+P1: {json.dumps(p1)}
+X1-PERGUNTAS: {json.dumps(x1)}
+X2-RESPOSTAS: {json.dumps(x2)}
+PERGUNTA: {pergunta}
+
+{{"cenarios": {{"provaveis": [{{"id": "C1", "desc": "curto"}}],
+               "improvaveis": [{{"id": "C2", "desc": "curto"}}]},
+  "total": 2}}"""
+    return chamar_gemini_json(prompt)
 
-def passo_3_explorador_puro(p2: Dict) -> Dict:
-    logger.log("🔍 Executando P3: EXPLORADOR PURO", "TASK")
+def passo_3_isolar_cenarios(p2: Dict) -> Dict:
+    logger.log("🔍 P3-ISOLAR", "TASK")
     exploracoes = []
-    cenarios = p2.get('cenarios', {})
     for tipo in ['provaveis', 'improvaveis']:
-        for cenario in cenarios.get(tipo, [])[:2]:
-            prompt = f"""P3-EXPLORADOR PURO: {cenario.get('id')} ISOLADO
-NÃO compare cenários. Solução direta: {cenario.get('desc', '')}
-
-{{"cenario_id": "{cenario.get('id')}", "solucao": "", 
-  "convergentes": [], "divergentes": [], "balanco": "positivo|negativo"}}"""
+        for c in p2.get('cenarios', {}).get(tipo, [])[:2]:
+            prompt = f"""P3-ISOLAR: {c.get('id')}
+{{"id": "{c.get('id')}", "solucao": "direta", "balanco": "positivo|negativo"}}"""
             exploracoes.append(chamar_gemini_json(prompt))
-    return {"exploracoes": exploracoes}
+    return {"isolados": exploracoes}
 
-def passo_4_validador_cruzado(p1: Dict, p2: Dict, p3: Dict) -> Dict:
-    logger.log("✅ Executando P4: VALIDADOR CRUZADO", "TASK")
-    prompt = f"""P4-VALIDADOR: Cruze P1+P2+P3
-{{"confiabilidades": [{{"fato": "", "conf_verdade": "alto"}}],
-  "ambiguidades_validadas": []}}"""
+def passo_4_cruzar_validacoes(p1: Dict, p2: Dict, p3: Dict, x2: Dict) -> Dict:
+    logger.log("✅ P4-VALIDAR", "TASK")
+    prompt = f"""P4-VALIDAR TELEGRÁFICO
+{{"confiancas": [{{"fato": "X", "origem": "X1|X2|P3", "nivel": "alta|baixa"}}]}}"""
     return chamar_gemini_json(prompt)
 
-def passo_5_detector_lacunas(p1: Dict, p4: Dict) -> Dict:
-    logger.log("🚨 Executando P5: DETECTOR LACUNAS", "TASK")
-    prompt = f"""P5-LACUNAS: CRÍTICAS|IMPORTANTES|OPCIONAIS
-{{"lacunas": [{{"desc": "", "tipo": "CRÍTICA"}}],
-  "decisao": "PERGUNTAR|PROSSEGUIR",
-  "pergunta_lacuna": "null"}}"""
+def passo_5_lacunas_finais(p1: Dict, p4: Dict) -> Dict:
+    logger.log("🚨 P5-LACUNAS FINAIS", "TASK")
+    prompt = f"""P5-LACUNAS RESTANTES
+{{"lacunas": [{{"texto": "curto", "critica": "sim|nao"}}],
+  "decisao": "continuar|parar"}}"""
     return chamar_gemini_json(prompt)
 
-def passo_6_metacognicao_ponderativa(p2: Dict, p4: Dict, p5: Dict) -> Dict:
-    logger.log("⚖️ Executando P6: METACOGNIÇÃO PONDERATIVA", "TASK")
-    prompt = f"""P6-PONDERATIVA: Escolha cenário final
-{{"cenario_final": "C1", "confianca": "alto", "justificativa": ""}}"""
-    return chamar_gemini_json(prompt, temperatura=0.6)
-
-def passo_7_sintetizador_refinado(p6: Dict) -> Dict:
-    logger.log("✍️ Executando P7: SINTETIZADOR", "TASK")
-    prompt = f"""SINTETIZADOR v1.8 - PROSA HUMANIZADA
-P6: {json.dumps(p6, ensure_ascii=False)}
-
-Transforme METACOGNIÇÃO em PROSA:
-1. Conectores naturais (porque, portanto)
-2. Expanda abreviações
-3. Parágrafos estruturados
-
-{{"resposta_final": "TEXTO FLUIDO NATURAL",
-  "tom": "assertivo|cauteloso"}}"""
-    return chamar_gemini_json(prompt, temperatura=0.8, max_tokens=2500)
-
-def passo_8_validador_final(p7: Dict) -> Dict:
-    logger.log("🔍 Executando P8: VALIDADOR FINAL", "TASK")
-    resposta = p7.get('resposta_final', '')
-    prompt = f"""P8-VERIFICADOR FINAL
-RESPOSTA: {resposta[:1500]}
-
-VERIFICAÇÃO TRIPLA:
-1. FACTUAL aprovada true/false
-2. LÓGICA aprovada true/false  
-3. ÉTICA aprovada true/false
-
-{{"verificacao_factual": {{"aprovada": true, "problemas": []}},
-  "verificacao_logica": {{"aprovada": true}},
-  "verificacao_etica": {{"aprovada": true}},
-  "todas_aprovadas": true,
-  "resposta_final": "texto validado"}}"""
-    return chamar_gemini_json(prompt, temperatura=0.4)
+def passo_6_ponderar(p2: Dict, p4: Dict, p5: Dict) -> Dict:
+    logger.log("⚖️ P6-PONDERAR", "TASK")
+    prompt = f"""P6-DECISÃO FINAL
+{{"vencedor": "C1", "peso": "0.8", "razao": "curta"}}"""
+    return chamar_gemini_json(prompt)
+
+def passo_7_sintetizar(p6: Dict) -> Dict:
+    logger.log("✍️ P7-SINTETIZAR", "TASK")
+    prompt = f"""P7-PROSA NATURAL
+P6: {json.dumps(p6)}
+
+{{"resposta": "texto fluido completo"}}"""
+    return chamar_gemini_json(prompt, temperatura=0.7, max_tokens=2500)
+
+def passo_8_verificar(p7: Dict) -> Dict:
+    logger.log("🔍 P8-FINAL", "TASK")
+    prompt = f"""P8-VERIFICAÇÃO
+{{"factual": "ok", "logica": "ok", "etica": "ok",
+  "final": "texto aprovado"}}"""
+    return chamar_gemini_json(prompt)
 
 # ============================================================================
-# ORQUESTADOR PRINCIPAL HÍBRIDO
+# ORQUESTADOR PRINCIPAL v10
 # ============================================================================
 def processar_pipeline(pergunta: str, historico: List, arquivo_anexo=None, dna=None) -> Tuple[str, List, Dict]:
-    if dna is None or not isinstance(dna, dict) or "historico_chat" not in dna:
-        logger.log("DNA inválido ou inexistente, inicializando novo DNA.", "WARNING")
-        dna = criar_dna_vazio()
+    if dna is None or not isinstance(dna, dict):
+        dna = criar_dna()
     
-    logger.log(f"🚀 Iniciando pipeline híbrida para: {pergunta[:60]}", "INPUT")
-    if not pergunta.strip():
-        logger.log("Pergunta vazia ou inválida detectada.", "WARNING")
-        return "Digite uma pergunta válida.", historico, dna
+    logger.log(f"🚀 v10: {pergunta[:50]}", "START")
+    if not pergunta.strip(): return "Pergunta inválida", historico, dna
     
-    anexo_conteudo, tipo_anexo = processar_anexo(arquivo_anexo)
-    pergunta_com_anexo = construir_prompt_com_anexo(pergunta, anexo_conteudo, tipo_anexo)
+    anexo_c, tipo_a = processar_anexo(arquivo_anexo)
+    pergunta_final = construir_prompt_com_anexo(pergunta, anexo_c, tipo_a)
     
     try:
-        p0 = passo_0_aluno(pergunta_com_anexo, historico, dna)
-        dna["historico_passos"]["passo0"].append(p0)
-
-        p1 = passo_1_triagem_epistemica(pergunta_com_anexo, p0, historico, dna)
-        dna["historico_passos"]["passo1"].append(p1)
-
-        p2 = passo_2_gerador_cenarios(pergunta_com_anexo, p1, historico, dna)
-        dna["historico_passos"]["passo2"].append(p2)
-
-        if p2.get("decisao") == "pediresclarecimento":
-            logger.log("Interrupção em P2: pedido de esclarecimento pelo usuário.", "INFO")
-            return p2.get("pergunta", "Preciso de mais informações."), historico, dna
-
-        p3 = passo_3_explorador_puro(p2)
-        dna["historico_passos"]["passo3"].append(p3)
-
-        p4 = passo_4_validador_cruzado(p1, p2, p3)
-        dna["historico_passos"]["passo4"].append(p4)
-
-        p5 = passo_5_detector_lacunas(p1, p4)
-        dna["historico_passos"]["passo5"].append(p5)
-
-        if p5.get("decisao") == "PERGUNTAR":
-            logger.log("Interrupção em P5: lacuna crítica detectada, solicitando pergunta de esclarecimento.", "INFO")
-            return p5.get("pergunta_lacuna", "Por favor forneça mais detalhes."), historico, dna
-
-        p6 = passo_6_metacognicao_ponderativa(p2, p4, p5)
-        dna["historico_passos"]["passo6"].append(p6)
-
-        p7 = passo_7_sintetizador_refinado(p6)
-        dna["historico_passos"]["passo7"].append(p7)
-
-        p8 = passo_8_validador_final(p7)
-        dna["historico_passos"]["passo8"].append(p8)
-
-        resposta_final = p8.get("resposta_final", "Erro na validação final.")
-        disclaimer = p8.get("disclaimer", "")
-
-        if disclaimer:
-            resposta_final += f"\n\n⚠️ {disclaimer}"
-
-        novo_historico = historico + [{"role": "user", "content": pergunta}, 
-                                    {"role": "assistant", "content": resposta_final}]
-
-        dna["historico_chat"].append({"user": pergunta, "assistant": resposta_final})
-        dna["metadados"]["total_turnos"] += 1
-
-        logger.log("Pipeline concluída com sucesso.", "SUCCESS")
-        return resposta_final, novo_historico, dna
-
+        # P0-P1
+        p0 = passo_0_aluno(pergunta_final, historico)
+        p1 = passo_1_triagem(pergunta_final, p0, historico)
+        
+        # NOVOS X1-X2
+        x1 = passo_x1_perguntas_necessarias(pergunta_final, p1, historico)
+        x2 = passo_x2_resolver_perguntas(pergunta_final, p1, x1, historico)
+        
+        # P2 usa X1-X2
+        p2 = passo_2_cenarios(pergunta_final, p1, x1, x2, historico)
+        if p2.get("decisao") == "parar": 
+            return x1.get("perguntas", ["Esclareça"]), historico, dna
+        
+        # P3-P8 fluxo normal
+        p3 = passo_3_isolar_cenarios(p2)
+        p4 = passo_4_cruzar_validacoes(p1, p2, p3, x2)
+        p5 = passo_5_lacunas_finais(p1, p4)
+        
+        if p5.get("decisao") == "parar":
+            return "Lacuna crítica", historico, dna
+        
+        p6 = passo_6_ponderar(p2, p4, p5)
+        p7 = passo_7_sintetizar(p6)
+        p8 = passo_8_verificar(p7)
+        
+        resposta = p8.get("final", p7.get("resposta", "Erro"))
+        novo_hist = historico + [{"role": "user", "content": pergunta}, 
+                               {"role": "assistant", "content": resposta}]
+        
+        dna["historico_chat"].append({"u": pergunta, "a": resposta})
+        dna["meta"]["turnos"] += 1
+        
+        return resposta, novo_hist, dna
+        
     except Exception as e:
-        logger.log(f"Erro inesperado na pipeline: {str(e)}", "ERROR")
+        logger.log(f"ERRO v10: {str(e)}", "ERROR")
         return f"Erro: {str(e)}", historico, dna
 
 # ============================================================================
-# INTERFACE GRADIO
+# INTERFACE
 # ============================================================================
-def chat_interface(mensagem: str, historico: List, arquivo_anexo=None, dna_json: str = "{}") -> Tuple[List, str, str, None]:
-    if not mensagem.strip():
-        logger.log("Mensagem vazia recebida na interface.", "WARNING")
-        return historico, "", dna_json, None
-    try:
-        dna = json.loads(dna_json) if dna_json else criar_dna_vazio()
-    except Exception as e:
-        logger.log(f"Falha ao carregar DNA do estado: {str(e)}. Criando novo DNA.", "WARNING")
-        dna = criar_dna_vazio()
-
-    hist_tuples = []
-    for msg in historico:
-        if isinstance(msg, dict) and 'content' in msg:
-            hist_tuples.append(msg['content'])
-        elif isinstance(msg, (list, tuple)) and len(msg) >= 2:
-            hist_tuples.append(msg[0])
-
-    resposta, novo_hist, dna_atualizado = processar_pipeline(mensagem, hist_tuples, arquivo_anexo, dna)
-    return novo_hist, "", json.dumps(dna_atualizado, indent=2, ensure_ascii=False), None
+def chat_interface(msg: str, hist: List, anexo=None, dna_json: str="{}") -> Tuple[List, str, str, None]:
+    try: dna = json.loads(dna_json) if dna_json else {}
+    except: dna = {}
+    
+    resp, novo_hist, dna_new = processar_pipeline(msg, hist, anexo, dna)
+    return novo_hist, "", json.dumps(dna_new, indent=2), None
 
-# ============================================================================
-# MAIN
-# ============================================================================
 if __name__ == "__main__":
-    with gr.Blocks(title="Pipeline Híbrida v9", theme=gr.themes.Soft()) as demo:
-        gr.Markdown(f"{TITLE}\n\n**🧬 Lógica app-7.py + Estrutura 9 Passos v9**")
+    with gr.Blocks(title="Pipeline v10", theme=gr.themes.Soft()) as demo:
+        gr.Markdown(TITLE + "\n**X1-Perguntas → X2-Resolução → Cenários Aprofundados**")
+        
         with gr.Row():
             with gr.Column(scale=2):
-                chatbot = gr.Chatbot(label="🤖 Pipeline Híbrida v9", height=550, type="messages")
-                dna_display = gr.Code(label="🧬 DNA", language="json", lines=15)
+                chat = gr.Chatbot(height=550, type="messages")
+                dna_view = gr.Code(label="DNA", language="json", lines=12)
             with gr.Column(scale=1):
-                entrada = gr.Textbox(label="📝 Pergunta", lines=3, placeholder="Descreva o caso...", scale=2)
-                anexo = gr.File(label="📎 Anexo (PDF/PNG/JPG)", file_types=[".pdf", ".png", ".jpg", ".jpeg"], scale=1)
-                btn = gr.Button("🚀 ANALISAR", variant="primary")
-
-        btn.click(chat_interface, inputs=[entrada, chatbot, anexo, dna_display], outputs=[chatbot, entrada, dna_display, anexo])
-        entrada.submit(chat_interface, inputs=[entrada, chatbot, anexo, dna_display], outputs=[chatbot, entrada, dna_display, anexo])
-        gr.Markdown("**⚠️ Aviso legal**: ferramenta auxiliar. Consulte profissional qualificado.")
-
-    logger.log("🚀 Pipeline Híbrida v9 iniciada e aguardando interações.", "INFO")
-    demo.launch(server_name="0.0.0.0", server_port=7860, share=False)
+                input_txt = gr.Textbox(label="Pergunta", lines=3, scale=2)
+                file_up = gr.File(label="Anexo", file_types=[".pdf",".png",".jpg"])
+                btn_go = gr.Button("🚀 v10", variant="primary")
+        
+        btn_go.click(chat_interface, [input_txt, chat, file_up, dna_view], 
+                    [chat, input_txt, dna_view, file_up])
+        input_txt.submit(chat_interface, [input_txt, chat, file_up, dna_view], 
+                        [chat, input_txt, dna_view, file_up])
+    
+    demo.launch(server_name="0.0.0.0", server_port=7860)