Update app.py

app.py

@@ -9,192 +9,555 @@ import warnings
 import re
 warnings.filterwarnings("ignore", category=FutureWarning, module="google.api_core")
 
+# ============================================================================
+# CONFIGURAÇÃO
 # ============================================================================
 API_KEY = os.getenv("GOOGLE_API_KEY", "sua-chave-aqui")
 genai.configure(api_key=API_KEY)
-model = genai.GenerativeModel("gemini-2.0-flash")
+counselor_model = genai.GenerativeModel("gemini-2.0-flash")
+supervisor_model = genai.GenerativeModel("gemini-2.0-flash")
+
+TITLE = "# 🚀 Pipeline v10 ATUALIZADA\n**P0-P1 → X1-X2 → P2-P8 (com Metacognição Pura)**"
 
+# ============================================================================
+# LOGGER MELHORADO
 # ============================================================================
 class Logger:
-    def __init__(self, verbose=True): self.verbose = verbose; self.logs = []
+    def __init__(self, verbose=True):
+        self.verbose = verbose
+        self.logs = []
     def log(self, msg: str, level="INFO"):
         timestamp = datetime.now().strftime("%H:%M:%S")
-        print(f"[{timestamp}] [{level}] {msg}")
+        log_msg = f"[{timestamp}] [{level}] {msg}"
+        self.logs.append(log_msg)
+        if self.verbose: print(log_msg)
+        print("="*70)
 
 logger = Logger(verbose=True)
 
 # ============================================================================
-def processar_anexo(arquivo): 
-    if not arquivo: return "", "nenhum"
+# HELPERS ULTRA ROBUSTOS (DEPURAÇÃO)
+# ============================================================================
+def processar_anexo(arquivo) -> Tuple[str, str]:
+    if arquivo is None: return "", "nenhum"
     try:
         caminho = str(arquivo)
-        if caminho.endswith('.pdf'):
+        if caminho.lower().endswith('.pdf'):
             try:
                 import PyPDF2
                 with open(caminho, 'rb') as f:
                     leitor = PyPDF2.PdfReader(f)
-                    return "".join(p.extract_text()+"\n" for p in leitor.pages[:3])[:2000], "pdf"
-            except: return "[PDF]", "pdf"
-        if any(caminho.endswith(x) for x in ['.png','.jpg','.jpeg']):
+                    texto = "".join(pagina.extract_text() + "\n" for pagina in leitor.pages[:3])
+                    return texto[:2000], "pdf"
+            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:
                 return base64.b64encode(f.read()).decode()[:500], "imagem"
-    except: pass
-    return "", "erro"
+        return "", "nao_suportado"
+    except Exception as e:
+        logger.log(f"Erro processar_anexo: {str(e)}", "ERROR")
+        return "", "erro"
 
-def construir_prompt(pergunta: str, anexo: str, tipo: str):
-    if not anexo: return pergunta
-    return f"ANEXO {tipo.upper()}:\n{anexo}\n\nPERGUNTA: {pergunta}"
+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": return f"""DOCUMENTO:
+{anexo_conteudo[:1800]}
+---
+PERGUNTA: {pergunta}"""
+    return f"""ANEXO VISUAL:
+PERGUNTA: {pergunta}"""
 
-# ============================================================================
-def PARSER_SIMPLES(texto: str) -> Dict:
-    """PARSER ULTRA SIMPLES - PEGA PRIMEIRO JSON"""
+def parse_json_ultra_robusto(texto: str) -> Dict:
+    """Extrai QUALQUER JSON de texto bagunçado"""
+    logger.log(f"Parse: {len(texto)} chars", "DEBUG")
+    print(f"DEBUG PARSE INPUT: {texto[:300]}...")
     if not texto: return {"erro": "vazio"}
     
-    # 1. Regex simples
-    match = re.search(r'\{[^{}]*(?:\{[^{}]*\}[^{}]*)*\}', texto)
-    if match:
-        try: return json.loads(match.group(0))
-        except: pass
-    
-    # 2. Primeiro { até último }
-    ini = texto.find('{')
-    fim = texto.rfind('}')
-    if ini >= 0 and fim > ini:
-        try: return json.loads(texto[ini:fim+1])
-        except: pass
+    try:
+        # Regex múltiplos JSONs
+        matches = re.findall(r'\{[^{}]*(?:\{[^{}]*\}[^{}]*)*\}', texto, re.DOTALL)
+        for match in matches:
+            try: 
+                resultado = json.loads(match)
+                logger.log(f"Parse OK via regex: {json.dumps(resultado, indent=2)[:200]}", "SUCCESS")
+                return resultado
+            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: 
+                resultado = json.loads(texto[inicio:i])
+                logger.log(f"Parse OK balanceado", "SUCCESS")
+                return resultado
+        
+        # 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: 
+                resultado = json.loads(texto[i+1:fim+1])
+                logger.log(f"Parse OK fallback", "SUCCESS")
+                return resultado
+            
+    except Exception as e:
+        logger.log(f"Parse falhou: {str(e)}", "ERROR")
     
-    return {"erro": texto[:100]}
+    return {"erro": "parse_falhou", "fallback": texto[:200]}
+
+def chamar_gemini_json(modelo, prompt_base: str, temperatura=0.4, max_tokens=1500) -> Dict:
+    prompt = f"""{prompt_base}
 
-def gemini_json(prompt: str, temp=0.4, tokens=1500) -> Dict:
-    prompt += "\n\n**JSON PURO. SEM TEXTO.**"
+---
+
+**JSON PURO OBRIGATÓRIO**
+SEM TEXTO EXTRA. APENAS:
+{{"chave": "valor"}}"""
+    
+    logger.log(f"Enviando prompt ({len(prompt)} chars): {prompt[:300]}...", "DEBUG")
+    print(f"DEBUG PROMPT GEMINI:\n{prompt}")
+    
     try:
-        resp = model.generate_content(prompt, 
+        response = modelo.generate_content(prompt, 
             generation_config=genai.types.GenerationConfig(
-                temperature=temp, max_output_tokens=tokens))
-        raw = resp.text or ""
-        logger.log(f"RAW({len(raw)}): {raw[:200]}...", "RAW")
-        return PARSER_SIMPLES(raw)
+                temperature=temperatura, 
+                max_output_tokens=max_tokens))
+        
+        resposta_bruta = response.text or ""
+        logger.log(f"Gemini RAW ({len(resposta_bruta)} chars): {resposta_bruta[:500]}...", "DEBUG")
+        print(f"DEBUG - RESPOSTA BRUTA GEMINI:\n{resposta_bruta}")
+        
+        resultado = parse_json_ultra_robusto(resposta_bruta)
+        logger.log(f"Gemini PARSE OK: {json.dumps(resultado, indent=2)[:300]}", "SUCCESS")
+        return resultado
+        
     except Exception as e:
-        logger.log(f"API ERRO: {e}", "ERROR")
+        logger.log(f"API erro: {str(e)}", "ERROR")
+        print(f"ERRO GEMINI: {str(e)}")
         return {"erro": str(e)}
 
+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": {f"passo{i}": [] for i in range(10)},
+        "memoria": {"resumo": ""},
+        "meta": {"total_turnos": 0, "ultimo_turno_limpeza": 0}
+    }
+
+# ============================================================================
+# PASSOS P0-P1 (COPIADOS DA VERSÃO ANTIGA - METACOGNIÇÃO PURA)
 # ============================================================================
-def criar_dna(): return {
-    "chat": [],
-    "passos": {f"p{i}": [] for i in range(10)},
-    "meta": {"turnos": 0}
-}
+def passo_0_aluno(pergunta: str, historico: List) -> Dict:
+    logger.log("🧠 P0-ALUNO - METACOGNIÇÃO PURA", "TASK")
+    print("="*70)
+    print("PASSO 0 ALUNO analisando feedback...")
+    
+    turno_anterior = historico[-1] if len(historico) > 0 else None
+    memoria_contextual = "NA"  # Pode ser expandido depois
+    
+    prompt = f"""Você é um METACOGNITIVO (pensamento interno, NÃO comunicação).
+
+TURNO ANTERIOR: 
+User: {turno_anterior['content'] if turno_anterior else 'NA'}
+Assistant: {historico[-2]['content'] if len(historico) >= 2 else 'NA'}
 
-def hist_compacto(hist: List): 
-    return "\n".join([str(h).split("\n")[0][:60] for h in hist[-2:]] or ["PRIMEIRO"])
+NOVA MENSAGEM: {pergunta}
+CONTEXTO VAGO: {historico_compacto(historico)}
 
+---
+
+RESponda EM METACOGNIÇÃO PURA - TELEGRÁFICO
+NÃO use frases completas. APENAS essência semântica com conectores mínimos.
+
+EXEMPLO CERTO: entendeu-sim | pergunta-nova | avança-tópico | não-reformulou
+
+RETORNE JSON:
+{{
+  "usuario_entendeu": "sim|não",
+  "evidencias": ["entendeu-pergunta", "pediu-clarificação"],
+  "usuario_corrigiu": "sim|não",
+  "correcao_detectada": null|"texto-correção",
+  "correcao_valida": "sim|não|null",
+  "o_que_melhorar": null|"explicar-X-melhor",
+  "decisao": "prosseguir-passo1|reexplicar-passo6|atualizar-resposta-anterior",
+  "motivo": "texto-curtíssimo"
+}}"""
+    
+    return chamar_gemini_json(counselor_model, prompt, temperatura=0.5)
+
+def passo_1_triagem(pergunta: str, p0: Dict, historico: List) -> Dict:
+    logger.log("📊 P1-TRIAGEM - METACOGNIÇÃO PURA", "TASK")
+    print("="*70)
+    print("PASSO 1 TRIAGEM...")
+    
+    contexto_vago = historico_compacto(historico)
+    historico_recente = [{"user": msg["content"], "assistant": historico[i+1]["content"] if i+1 < len(historico) else "NA"} 
+                        for i, msg in enumerate(historico[-4:]) if msg["role"] == "user"]
+    
+    prompt = f"""METACOGNIÇÃO - TRIAGEM INICIAL.
+
+CONTEXTO VAGO: {contexto_vago}
+HISTÓRICO RECENTE (últimas 3): {json.dumps(historico_recente[-3:], indent=2, ensure_ascii=False)}
+P0: {json.dumps(p0, indent=2, ensure_ascii=False)}
+PERGUNTA: {pergunta}
+
+---
+
+CLASSIFIQUE EM TELEGRÁFICO (sem frases).
+
+RETORNE JSON:
+{{
+  "tipo": "objetiva|factual|subjetiva|aberta",
+  "sinais": ["tem-resposta-única-verificável", "sem-contexto-pessoal"],
+  "confianca": "alta|média|baixa",
+  "decisao": "responder-direto|analisar-profundamente",
+  "razao": "curtíssima",
+  "dados_fatuais": ["fato1", "fato2"],
+  "divergencias_fatuais": ["possível-ambiguidade-1"],
+  "objetivo_principal": "objetivo-primário-identificado",
+  "objetivo_secundario": ["objetivo-secundário-1"]
+}}"""
+    
+    return chamar_gemini_json(counselor_model, prompt, temperatura=0.5)
+
+# ============================================================================
+# NOVOS PASSOS X1-X2 (MELHORADOS)
 # ============================================================================
-# PASSOS
-def p0_aluno(pergunta: str, hist: List): 
-    logger.log("🧠 P0", "TASK")
-    return gemini_json(f"P0\nHIST: {hist_compacto(hist)}\nQ: {pergunta}\n{{\"relacao\": \"nova|continua\", \"peso\": \"alto|medio\"}}")
+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")
+    print("="*70)
+    
+    prompt = f"""X1-PERGUNTAS CRÍTICAS - TELEGRÁFICO
+P1: {json.dumps(p1, indent=2)}
+CONTEXTO: {historico_compacto(historico)}
+PERGUNTA PRINCIPAL: {pergunta}
 
-def p1_triagem(pergunta: str, p0: Dict, hist: List):
-    logger.log("📊 P1", "TASK")
-    return gemini_json(f"P1\nP0: {json.dumps(p0)}\nQ: {pergunta}\n{{\"tipo\": \"factual|subjetiva\", \"conf\": \"alta|baixa\"}}")
+LACUNAS FACTUAIS/SUBJETIVAS:
 
-def x1_perguntas(pergunta: str, p1: Dict, hist: List):
-    logger.log("❓ X1", "TASK")
-    return gemini_json(f"X1\nP1: {json.dumps(p1)}\nQ: {pergunta}\n{{\"perguntas\": [{{\"t\": \"pergunta\", \"nec\": \"alta|baixa\"}}]}}")
+{{"perguntas": [
+  {{"texto": "pergunta-curta", "necessidade": "alta|média|baixa", "relevancia": "alta|média"}}
+]}}"""
+    
+    return chamar_gemini_json(counselor_model, prompt, max_tokens=2000)
 
-def x2_respostas(pergunta: str, p1: Dict, x1: Dict, hist: List):
-    logger.log("✅ X2", "TASK")
-    return gemini_json(f"X2\nP1: {json.dumps(p1)}\nX1: {json.dumps(x1)}\n{{\"respostas\": [{{\"p\": \"pergunta\", \"r\": \"resposta\", \"conf\": \"alta\"}}]}}")
+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")
+    print("="*70)
+    
+    perguntas = x1.get("perguntas", [])
+    prompt = f"""X2-RESOLUÇÃO - TELEGRÁFICO
+P1: {json.dumps(p1, indent=2)}
+PERGUNTAS X1: {json.dumps(perguntas, indent=2)}
+CONTEXTO: {historico_compacto(historico)}
 
-def p2_cenarios(pergunta: str, p1: Dict, x1: Dict, x2: Dict, hist: List):
-    logger.log("🎯 P2", "TASK")
-    return gemini_json(f"P2\nP1: {json.dumps(p1)}\nX1: {json.dumps(x1)}\nX2: {json.dumps(x2)}\n{{\"cen\": {{\"prov\": [{{\"id\": \"C1\"}}], \"imp\": [{{\"id\": \"C2\"}}]}}}}")
+PARA CADA PERGUNTA:
+{{"respostas": [
+  {{"pergunta": "texto-original",
+    "resposta": "curta-direta",
+    "confianca": "alta|média|baixa",
+    "conflito": "alto|médio|baixo",
+    "razao": "1-2-palavras"}}
+]}}"""
+    
+    return chamar_gemini_json(counselor_model, prompt, max_tokens=2000)
 
-def p3_isolar(p2: Dict):
-    logger.log("🔍 P3", "TASK")
-    res = []
-    for tipo in ['prov', 'imp']:
-        for c in p2.get('cen', {}).get(tipo, [])[:1]:
-            res.append(gemini_json(f"P3-{c.get('id')}\n{{\"id\": \"{c.get('id')}\", \"sol\": \"direta\"}}"))
-    return {"isol": res}
+# ============================================================================
+# PASSOS P2-P8 (COPIADOS E ADAPTADOS DA VERSÃO ANTIGA)
+# ============================================================================
+def passo_2_cenarios(pergunta: str, p1: Dict, x1: Dict, x2: Dict, historico: List) -> Dict:
+    logger.log("🎯 P2-CENÁRIOS (com X1-X2)", "TASK")
+    print("="*70)
+    print("PASSO 2 CENÁRIOS...")
+    
+    prompt = f"""METACOGNIÇÃO - CENÁRIOS.
+CONTEXTO VAGO: {historico_compacto(historico)}
+TRIAGEM P1: {json.dumps(p1, indent=2)}
+X1-PERGUNTAS: {json.dumps(x1, indent=2)}
+X2-RESPOSTAS: {json.dumps(x2, indent=2)}
+PERGUNTA: {pergunta}
 
-def p4_validar(p1: Dict, p2: Dict, p3: Dict):
-    logger.log("✅ P4", "TASK")
-    return gemini_json(f"P4\n{{\"conf\": [{{\"f\": \"fato\", \"n\": \"alta\"}}]}}")
+---
 
-def p5_lacunas(p1: Dict, p4: Dict):
-    logger.log("🚨 P5", "TASK")
-    return gemini_json(f"P5\n{{\"lac\": [{{\"t\": \"lacuna\", \"c\": \"sim\"}}], \"dec\": \"cont|par\"}}")
+MAPEIE CENÁRIOS ONDE RESPOSTA MUDA - TELEGRÁFICO
 
-def p6_ponderar(p2: Dict, p4: Dict, p5: Dict):
-    logger.log("⚖️ P6", "TASK")
-    return gemini_json(f"P6\n{{\"win\": \"C1\", \"peso\": 0.8}}")
+RETORNE JSON:
+{{"cenarios": {{"provaveis": [{{"id": "C1", "desc": "cenário-1-comprimido", "contexto-relevante": "X"}}],
+               "improvaveis": [{{"id": "C2", "desc": "cenário-2-comprimido"}}]},
+  "total": 2,
+  "tipo_resposta": "múltipla|unívoca",
+  "confianca": "alta|média|baixa",
+  "decisao": "prosseguir|pedir-esclarecimento",
+  "pergunta_esclarecimento": null|"texto-pergunta"
+}}"""
+    
+    resultado = chamar_gemini_json(counselor_model, prompt, temperatura=0.6)
+    logger.log(f"Cenários: {resultado.get('cenarios', {}).get('total', 0)}", "INFO")
+    return resultado
 
-def p7_sintetizar(p6: Dict):
-    logger.log("✍️ P7", "TASK")
-    return gemini_json(f"P7\nP6: {json.dumps(p6)}\n{{\"resp\": \"texto final\"}}", temp=0.7, tokens=2000)
+def passo_3_isolar_cenarios(p2: Dict) -> Dict:
+    logger.log("🔍 P3-ISOLAR CENÁRIOS", "TASK")
+    print("="*70)
+    print("PASSO 3 EXPLORAÇÃO...")
+    
+    exploracoes = []
+    for tipo in ['provaveis', 'improvaveis']:
+        for c in p2.get('cenarios', {}).get(tipo, [])[:2]:
+            prompt = f"""METACOGNIÇÃO - EXPLORAÇÃO.
+CENÁRIO P2: {json.dumps(c, indent=2)}
 
-def p8_verificar(p7: Dict):
-    logger.log("🔍 P8", "TASK")
-    return gemini_json(f"P8\n{{\"ok\": true, \"final\": \"aprovado\"}}")
+PARA ESTE CENÁRIO, RESPONDA ESSÊNCIA - TELEGRÁFICO
 
+{{"id": "{c.get('id')}", 
+  "resposta_essencia": "palavra-chave-razoes", 
+  "confianca": "alta|média|baixa",
+  "lacunas": "contexto-ausente|null"
+}}"""
+            exploracoes.append(chamar_gemini_json(counselor_model, prompt, temperatura=0.6))
+    
+    logger.log(f"P3: {len(exploracoes)} explorações isoladas", "INFO")
+    return {"isolados": exploracoes}
+
+def passo_4_cruzar_validacoes(p1: Dict, p2: Dict, p3: Dict, x2: Dict) -> Dict:
+    logger.log("✅ P4-VALIDAR (Princípios/Símbolos)", "TASK")
+    print("="*70)
+    print("PASSO 4 PRINCÍPIOS...")
+    
+    prompt = f"""METACOGNIÇÃO - CONHECIMENTO FUNDAMENTAL.
+P1: {json.dumps(p1, indent=2)}
+P2: {json.dumps(p2, indent=2)}
+P3: {json.dumps(p3, indent=2)}
+X2: {json.dumps(x2, indent=2)}
+
+---
+
+IDENTIFIQUE PRINCÍPIOS E SÍMBOLOS - TELEGRÁFICO
+
+RETORNE JSON:
+{{"principios": [{{"nome": "Custo-Oportunidade", "essencia": "escolher-X-renunciar-Y"}}],
+  "simbolos": [{{"nome": "Jornada-Herói", "essencia": "transformação-iminente"}}],
+  "principio_central": "nome",
+  "simbolo_dominante": "nome"
+}}"""
+    
+    return chamar_gemini_json(counselor_model, prompt, temperatura=0.6)
+
+def passo_5_lacunas_finais(p1: Dict, p4: Dict) -> Dict:
+    logger.log("🚨 P5-LACUNAS FINAIS (Metacognição)", "TASK")
+    print("="*70)
+    print("PASSO 5 METACOGNIÇÃO...")
+    
+    prompt = f"""METACOGNIÇÃO - CERTEZAS vs DÚVIDAS.
+P1: {json.dumps(p1, indent=2)}
+P4: {json.dumps(p4, indent=2)}
+
+---
+
+AVALIE CERTEZAS vs DÚVIDAS - TELEGRÁFICO
+
+RETORNE JSON:
+{{"analise_cenarios": [{{"cenario": "C1", "certezas": ["certeza1"], "duvidas": ["dúvida1"]}}],
+  "confianca_global": "alta|média|baixa",
+  "balanco": "certezas-superam|equilibrado",
+  "decisao": "responder|questionar",
+  "questionamento": null|"texto"
+}}"""
+    
+    return chamar_gemini_json(counselor_model, prompt, temperatura=0.5)
+
+def passo_6_ponderar(p2: Dict, p4: Dict, p5: Dict) -> Dict:
+    logger.log("⚖️ P6-PONDERAR (Juiz da Verdade)", "TASK")
+    print("="*70)
+    print("PASSO 6 JUIZ DA VERDADE...")
+    
+    prompt = f"""METACOGNIÇÃO - ARBITRAGEM SOCRÁTICA.
+P2: {json.dumps(p2, indent=2)}
+P4: {json.dumps(p4, indent=2)}
+P5: {json.dumps(p5, indent=2)}
+
+---
+
+VALIDE VERDADES SOCRÁTICAS - TELEGRÁFICO
+
+RETORNE JSON:
+{{"verdade1_nao_sei": "validada-true|false",
+  "evidencias": "P3-respostas-P4-principios",
+  "confianca": "alta|média|baixa",
+  "decisao": "exibir-resposta|exibir-falhas|reprocessar",
+  "nivel_consciencia": "alto|médio|baixo"
+}}"""
+    
+    return chamar_gemini_json(counselor_model, prompt, temperatura=0.5)
+
+def passo_7_sintetizar(p6: Dict) -> Dict:
+    logger.log("✍️ P7-SINTETIZAR (Prosa Humanizada)", "TASK")
+    print("="*70)
+    print("SINTETIZADOR - Transformando metacognição em prosa...")
+    
+    prompt = f"""Você é um SINTETIZADOR - transforma METACOGNIÇÃO CRUA em PROSA HUMANIZADA.
+
+JUIZ P6: {json.dumps(p6, indent=2)}
+
+---
+
+TAREFA: TRANSFORMAR METACOGNIÇÃO → PROSA HUMANIZADA
+
+INSTRUÇÕES:
+1. Adicione conectores naturais (porque, portanto, isso significa)
+2. Expanda abreviações (curva-aprendizado → curva de aprendizado)
+3. Humanize números (3-6m → 3 a 6 meses)
+4. Estruture em parágrafos (introdução-desenvolvimento-nuances)
+5. Integre princípios naturalmente
+6. Tom: Amigo, empático, empoderador
+
+GENRE RESPOSTA FINAL (texto fluido, natural, humano):"""
+    
+    resposta_raw = chamar_gemini_json(counselor_model, prompt, temperatura=0.8, max_tokens=2500)
+    logger.log(f"P7: Resposta gerada ({len(resposta_raw.get('resposta', ''))} chars)", "INFO")
+    return resposta_raw
+
+def passo_8_verificar(p7: Dict) -> Dict:
+    logger.log("🔍 P8-FINAL (Verificador)", "TASK")
+    print("="*70)
+    print("PASSO 8 VERIFICAÇÃO FINAL...")
+    
+    resposta_sintetizada = p7.get("resposta", "")
+    
+    prompt = f"""Você é um VERIFICADOR FINAL - guardião de qualidade.
+
+RESPOSTA SINTETIZADA: {resposta_sintetizada}
+ANÁLISE P6: {json.dumps(p7, indent=2)}
+
+---
+
+VERIFICAÇÃO TRIPLA (devolver JSON):
+1. VERIFICAÇÃO FACTUAL: Fatos incorretos?
+2. VERIFICAÇÃO LÓGICA: Falácias? Saltos injustificados?
+3. VERIFICAÇÃO ÉTICA: Apropriada? Disclaimers?
+
+RETORNE JSON:
+{{"verificacao_factual": {{"aprovada": "true|false", "problemas": []}},
+  "verificacao_logica": {{"aprovada": "true|false", "problemas": []}},
+  "verificacao_etica": {{"aprovada": "true|false", "problemas": []}},
+  "todas_aprovadas": "true|false",
+  "decisao": "exibir-resposta|corrigir|reexibir",
+  "resposta_corrigida": null|"versão-corrigida"
+}}"""
+    
+    return chamar_gemini_json(supervisor_model, prompt, temperatura=0.5)
+
+# ============================================================================
+# ORQUESTADOR PRINCIPAL v10 (SEM TRY-EXCEPT PARA DEPURAÇÃO)
 # ============================================================================
-def processar(pergunta: str, hist: List, anexo=None, dna=None):
-    if dna is None: dna = criar_dna()
-    logger.log(f"🚀 {pergunta[:40]}", "START")
+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):
+        dna = criar_dna()
     
-    if not pergunta.strip(): return "Pergunta inválida", hist, dna
+    logger.log(f"🚀 v10 ATUALIZADA: {pergunta[:50]}", "START")
+    print("="*70)
+    print("PIPELINE PRINCIPAL v10 ATUALIZADA")
+    print("="*70)
     
-    a_c, a_t = processar_anexo(anexo)
-    q = construir_prompt(pergunta, a_c, a_t)
+    if not pergunta.strip(): 
+        return "Pergunta inválida", historico, dna
     
-    # PIPELINE
-    p0 = p0_aluno(q, hist)
-    p1 = p1_triagem(q, p0, hist)
-    x1 = x1_perguntas(q, p1, hist)
-    x2 = x2_respostas(q, p1, x1, hist)
+    anexo_c, tipo_a = processar_anexo(arquivo_anexo)
+    pergunta_final = construir_prompt_com_anexo(pergunta, anexo_c, tipo_a)
     
-    p2 = p2_cenarios(q, p1, x1, x2, hist)
-    if p2.get("dec") == "par": return "Esclareça", hist, dna
+    # P0-P1 (Metacognição Pura)
+    p0 = passo_0_aluno(pergunta_final, historico)
+    logger.log(f"P0 Decisão: {p0.get('decisao', 'NA')}", "INFO")
     
-    p3 = p3_isolar(p2)
-    p4 = p4_validar(p1, p2, p3)
-    p5 = p5_lacunas(p1, p4)
+    p1 = passo_1_triagem(pergunta_final, p0, historico)
+    logger.log(f"P1 Tipo: {p1.get('tipo', 'NA')} | Decisão: {p1.get('decisao', 'NA')}", "INFO")
     
-    if p5.get("dec") == "par": return "Lacuna", hist, dna
+    # X1-X2 (Perguntas Críticas)
+    x1 = passo_x1_perguntas_necessarias(pergunta_final, p1, historico)
+    x2 = passo_x2_resolver_perguntas(pergunta_final, p1, x1, historico)
     
-    p6 = p6_ponderar(p2, p4, p5)
-    p7 = p7_sintetizar(p6)
-    p8 = p8_verificar(p7)
+    # P2-P8 (Fluxo Principal com Metacognição)
+    p2 = passo_2_cenarios(pergunta_final, p1, x1, x2, historico)
+    if p2.get("decisao") == "pedir-esclarecimento":
+        esclarecimento = p2.get("pergunta_esclarecimento", "Esclareça")
+        return esclarecimento, historico, dna
     
-    resp = p8.get("final") or p7.get("resp") or "Erro"
-    novo_hist = hist + [{"role": "user", "content": pergunta}, {"role": "assistant", "content": resp}]
+    p3 = passo_3_isolar_cenarios(p2)
+    p4 = passo_4_cruzar_validacoes(p1, p2, p3, x2)
+    p5 = passo_5_lacunas_finais(p1, p4)
     
-    dna["chat"].append({"u": pergunta, "a": resp})
-    dna["meta"]["turnos"] += 1
+    if p5.get("decisao") == "questionar":
+        questionamento = p5.get("questionamento", "Lacuna crítica")
+        return questionamento, historico, dna
     
-    return resp, novo_hist, dna
+    p6 = passo_6_ponderar(p2, p4, p5)
+    p7 = passo_7_sintetizar(p6)
+    p8 = passo_8_verificar(p7)
+    
+    # Decisão Final P8
+    if p8.get("todas_aprovadas") == "true" or p8.get("decisao") == "exibir-resposta":
+        resposta = p7.get("resposta", "Resposta gerada")
+    else:
+        resposta = p8.get("resposta_corrigida", p7.get("resposta", "Erro na verificação"))
+    
+    novo_hist = historico + [{"role": "user", "content": pergunta}, 
+                           {"role": "assistant", "content": resposta}]
+    
+    dna["historico_chat"].append({"u": pergunta, "a": resposta})
+    dna["meta"]["total_turnos"] += 1
+    
+    logger.log("✅ PIPELINE CONCLUÍDA", "SUCCESS")
+    print("="*70)
+    print("RESPOSTA FINAL:")
+    print(resposta)
+    print("="*70)
+    
+    return resposta, novo_hist, dna
 
 # ============================================================================
-def chat(msg: str, hist: List, anexo=None, dna_j: str="{}"):
-    try: dna = json.loads(dna_j)
-    except: dna = {}
-    r, nh, nd = processar(msg, hist, anexo, dna)
-    return nh, "", json.dumps(nd, indent=2)
+# INTERFACE (DEPURAÇÃO)
+# ============================================================================
+def chat_interface(msg: str, hist: List, anexo=None, dna_json: str="{}") -> Tuple[List, str, str, None]:
+    print(f"\n🎯 NOVA MENSAGEM: {msg[:100]}...")
+    try: 
+        dna = json.loads(dna_json) if dna_json else {}
+    except Exception as e:
+        print(f"Erro DNA: {e}")
+        dna = {}
+    
+    resp, novo_hist, dna_new = processar_pipeline(msg, hist, anexo, dna)
+    print(f"✅ RESPOSTA ENVIADA: {len(resp)} chars")
+    return novo_hist, "", json.dumps(dna_new, indent=2), None
 
-if __name__ == "__main__":
-    with gr.Blocks(theme=gr.themes.Soft()) as demo:
-        gr.Markdown("# 🚀 v10 X1-X2")
-        with gr.Row():
-            with gr.Column(2):
-                c = gr.Chatbot(height=500)
-                dj = gr.Code(label="DNA", language="json")
-            with gr.Column(1):
-                i = gr.Textbox(label="Pergunta", lines=3)
-                f = gr.File(file_types=[".pdf", ".png", ".jpg"])
-                b = gr.Button("GO", variant="primary")
+__name__ == "__main__":
+    with gr.Blocks(title="Pipeline v10 ATUALIZADA", theme=gr.themes.Soft()) as demo:
+        gr.Markdown(TITLE + "\n**Metacognição Pura + X1-X2 + Verificação Final**")
         
-        b.click(chat, [i,c,f,dj], [c,i,dj,f])
-        i.submit(chat, [i,c,f,dj], [c,i,dj,f])
+        with gr.Row():
+            with gr.Column(scale=2):
+                chat = gr.Chatbot(height=550, type="messages")
+                dna_view = gr.Code(label="DNA", language="json", lines=12)
+            with gr.Column(scale=1):
+                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 ATUALIZADA", 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", port=7860)
+    demo.launch(server_name="0.0.0.0", server_port=7860, share=False)