Update app.py

app.py

@@ -1,626 +1,279 @@
 import json
 import os
 import base64
+import re
+import warnings
 from datetime import datetime
-from typing import Dict, List, Tuple, Optional
+from typing import Dict, List, Tuple
+
 import gradio as gr
 import google.generativeai as genai
-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")
+# Filtra avisos do gRPC para limpar o console
+warnings.filterwarnings("ignore", category=FutureWarning, module="google.api_core")
+
+# API KEY
+API_KEY = os.getenv("GOOGLE_API_KEY", "")
+if not API_KEY:
+    print("❌ ERRO CRÍTICO: GOOGLE_API_KEY não encontrada nas variáveis de ambiente.")
+    print("Defina com: export GOOGLE_API_KEY='sua_chave'")
+    # Não paramos o script, mas vai dar erro na chamada
+else:
+    print(f"✅ API Key carregada (termina em ...{API_KEY[-4:]})")
+
 genai.configure(api_key=API_KEY)
-counselor_model = genai.GenerativeModel("gemini-2.0-flash")
-supervisor_model = genai.GenerativeModel("gemini-2.0-flash")
+model = genai.GenerativeModel("gemini-1.5-flash")
 
-TITLE = "# 🚀 Pipeline v10 ATUALIZADA\n**P0-P1 → X1-X2 → P2-P8 (com Metacognição Pura)**"
+TITLE = "# 🛠️ Anise v10.2 DEBUG MODE\n**Console mostra SAÍDA BRUTA**"
 
 # ============================================================================
-# LOGGER MELHORADO
+# SISTEMA DE LOGS & DEBUG
 # ============================================================================
-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)
-        print("="*70)
-
-logger = Logger(verbose=True)
+def debug_print(titulo: str, conteudo: any):
+    """Imprime no console com formatação visível para debug"""
+    print(f"\n{'='*60}")
+    print(f"🐛 DEBUG: {titulo}")
+    print(f"{'-'*60}")
+    if isinstance(conteudo, (dict, list)):
+        print(json.dumps(conteudo, indent=2, ensure_ascii=False))
+    else:
+        print(str(conteudo))
+    print(f"{'='*60}\n")
 
 # ============================================================================
-# HELPERS ULTRA ROBUSTOS (DEPURAÇÃO)
+# HELPERS (SEM TRY/EXCEPT PARA DEBUG)
 # ============================================================================
 def processar_anexo(arquivo) -> Tuple[str, str]:
-    if arquivo is None: return "", "nenhum"
-    try:
-        caminho = str(arquivo)
-        if caminho.lower().endswith('.pdf'):
-            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])
-                    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"
-        return "", "nao_suportado"
-    except Exception as e:
-        logger.log(f"Erro processar_anexo: {str(e)}", "ERROR")
-        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": return f"""DOCUMENTO:
-{anexo_conteudo[:1800]}
----
-PERGUNTA: {pergunta}"""
-    return f"""ANEXO VISUAL:
-PERGUNTA: {pergunta}"""
-
-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"}
-    
-    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
+    if arquivo is None: 
+        return "", "nenhum"
+    
+    caminho = str(arquivo)
+    print(f"📂 Processando arquivo: {caminho}")
+
+    if caminho.lower().endswith('.pdf'):
+        import PyPDF2  # Se falhar aqui, queremos ver o erro de importação
+        with open(caminho, 'rb') as f:
+            leitor = PyPDF2.PdfReader(f)
+            texto = "".join(pagina.extract_text() + "\n" for pagina in leitor.pages[:5])
+            print(f"📄 PDF extraído: {len(texto)} caracteres")
+            return texto[:5000], "pdf"
             
-    except Exception as e:
-        logger.log(f"Parse falhou: {str(e)}", "ERROR")
-    
-    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}
+    elif any(caminho.lower().endswith(ext) for ext in ['.png','.jpg','.jpeg','.gif','.webp']):
+        with open(caminho, 'rb') as f:
+            encoded = base64.b64encode(f.read()).decode()
+            print(f"🖼️ Imagem codificada: {len(encoded)} bytes")
+            return encoded, "imagem"
+            
+    return "", "nao_suportado"
+
+def limpar_json_raw(texto: str) -> str:
+    """Limpa markdown ```json ... ``` para tentar parsear"""
+    texto = re.sub(r'^```json\s*', '', texto, flags=re.MULTILINE)
+    texto = re.sub(r'^```\s*', '', texto, flags=re.MULTILINE)
+    texto = re.sub(r'```$', '', texto, flags=re.MULTILINE)
+    return texto.strip()
+
+def chamar_gemini_json(prompt_base: str, etapa: str, temperatura=0.2, max_tokens=2000) -> Dict:
+    """
+    Chama o Gemini e imprime o RAW OUTPUT.
+    Se falhar o JSON, explode o erro para análise.
+    """
+    full_prompt = f"""{prompt_base}
 
 ---
+**INSTRUÇÃO DE SISTEMA OBRIGATÓRIA:**
+1. Responda APENAS com um JSON válido.
+2. NÃO use blocos de código markdown (```json).
+3. NÃO escreva texto antes ou depois do JSON.
+"""
+    
+    # 1. Chamada API
+    print(f"📡 Enviando requisição para {etapa}...")
+    response = model.generate_content(
+        full_prompt, 
+        generation_config=genai.types.GenerationConfig(
+            temperature=temperatura, 
+            max_output_tokens=max_tokens,
+            # response_mime_type="application/json" # Opcional: força modo JSON estrito do 1.5
+        )
+    )
+    
+    raw_text = response.text
+    
+    # 2. PRINT DA SAÍDA BRUTA (O que você pediu)
+    print(f"\n🛑 SAÍDA BRUTA GEMINI [{etapa}]:")
+    print(f">>> INICIO RAW <<<\n{raw_text}\n>>> FIM RAW <<<")
+
+    # 3. Tentativa de Parse (sem try/except silencioso)
+    texto_limpo = limpar_json_raw(raw_text)
+    
+    if not texto_limpo:
+        raise ValueError(f"[{etapa}] Gemini retornou texto vazio!")
 
-**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:
-        response = modelo.generate_content(prompt, 
-            generation_config=genai.types.GenerationConfig(
-                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: {str(e)}", "ERROR")
-        print(f"ERRO GEMINI: {str(e)}")
-        return {"erro": str(e)}
+        dados_json = json.loads(texto_limpo)
+        return dados_json
+    except json.JSONDecodeError as e:
+        print(f"❌ FALHA NO PARSE JSON [{etapa}]")
+        print(f"Erro: {e}")
+        print("Tentando corrigir manualmente strings...")
+        # Fallback simples se for apenas texto solto (opcional)
+        raise e # Relança o erro para parar o script e ver o traceback
 
 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:]])
+    if not historico: return "Nenhum."
+    return "\n".join([f"{m['role']}: {str(m['content'])[:100]}..." for m in historico[-4:]])
 
 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}
-    }
+    return {"historico": [], "meta": {"turnos": 0}}
 
 # ============================================================================
-# PASSOS P0-P1 (COPIADOS DA VERSÃO ANTIGA - METACOGNIÇÃO PURA)
+# PIPELINE - PASSOS (COM LOGS EXPLÍCITOS)
 # ============================================================================
-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'}
 
-NOVA MENSAGEM: {pergunta}
-CONTEXTO VAGO: {historico_compacto(historico)}
+def passo_0_aluno(pergunta: str, historico: List) -> Dict:
+    prompt = f"""ETAPA: P0-INTENÇÃO
+HISTÓRICO: {historico_compacto(historico)}
+PERGUNTA: {pergunta}
 
----
+Analise a intenção do usuário.
+JSON: {{"relacao": "continua|nova", "intent": "resumo"}}"""
+    return chamar_gemini_json(prompt, "P0")
 
-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) -> Dict:
+    prompt = f"""ETAPA: P1-TRIAGEM
+P0: {json.dumps(p0)}
+PERGUNTA: {pergunta}
 
-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.
+Classifique a pergunta.
+JSON: {{"tipo": "factual|analitica", "complexidade": "alta|baixa"}}"""
+    return chamar_gemini_json(prompt, "P1")
 
-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)}
+def passo_x1_lacunas(pergunta: str, p1: Dict) -> Dict:
+    prompt = f"""ETAPA: X1-LACUNAS
+P1: {json.dumps(p1)}
 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)
+Quais perguntas o assistente deve fazer a si mesmo para responder isso perfeitamente?
+JSON: {{"perguntas_internas": ["pergunta1", "pergunta2"]}}"""
+    return chamar_gemini_json(prompt, "X1")
 
-# ============================================================================
-# NOVOS PASSOS X1-X2 (MELHORADOS)
-# ============================================================================
-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)
+def passo_x2_resolver(x1: Dict, historico: List) -> Dict:
+    perguntas = x1.get("perguntas_internas", [])
+    if not perguntas: return {"respostas": []}
     
-    prompt = f"""X1-PERGUNTAS CRÍTICAS - TELEGRÁFICO
-P1: {json.dumps(p1, indent=2)}
+    prompt = f"""ETAPA: X2-RESOLUÇÃO
+PERGUNTAS: {json.dumps(perguntas)}
 CONTEXTO: {historico_compacto(historico)}
-PERGUNTA PRINCIPAL: {pergunta}
-
-LACUNAS FACTUAIS/SUBJETIVAS:
 
-{{"perguntas": [
-  {{"texto": "pergunta-curta", "necessidade": "alta|média|baixa", "relevancia": "alta|média"}}
-]}}"""
-    
-    return chamar_gemini_json(counselor_model, prompt, max_tokens=2000)
+Responda as perguntas internas.
+JSON: {{"respostas": [{{"p": "pergunta", "r": "resposta", "confianca": "alta|baixa"}}]}}"""
+    return chamar_gemini_json(prompt, "X2")
 
-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 passo_2_cenarios(pergunta: str, x2: Dict) -> Dict:
+    prompt = f"""ETAPA: P2-CENÁRIOS
+DADOS X2: {json.dumps(x2)}
+PERGUNTA ORIGINAL: {pergunta}
 
-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)
+Crie cenários de resposta ou decida parar se faltar informação crítica.
+JSON: {{"decisao": "continuar|parar", "cenarios": ["C1: ...", "C2: ..."], "motivo_parada": "..."}}"""
+    return chamar_gemini_json(prompt, "P2")
 
-# ============================================================================
-# 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)}
+def passo_7_sintese(p2: Dict, pergunta: str) -> Dict:
+    prompt = f"""ETAPA: P7-FINAL
+CENÁRIOS: {json.dumps(p2)}
 PERGUNTA: {pergunta}
 
----
-
-MAPEIE CENÁRIOS ONDE RESPOSTA MUDA - TELEGRÁFICO
-
-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 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)}
-
-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)
+Escreva a resposta final para o usuário.
+JSON: {{"resposta_final": "texto aqui"}}"""
+    return chamar_gemini_json(prompt, "P7", temperatura=0.7)
 
 # ============================================================================
-# ORQUESTADOR PRINCIPAL v10 (SEM TRY-EXCEPT PARA DEPURAÇÃO)
+# ORQUESTADOR (SEM REDE DE SEGURANÇA)
 # ============================================================================
-#PIPELINE PRINCIPAL
-def processar_pipeline(pergunta: str, historico: List, arquivo_anexo=None, dna=None) -> tuple:
-    if dna is None or not isinstance(dna, dict):
-        dna = criar_dna()
-        logger.log("🧬 DNA inicializado")
-    
-    logger.log(f"🚀 PIPELINE v10: {pergunta[:60]}...")
-    
-    if not pergunta.strip():
-        return "Digite uma pergunta válida", historico, dna
-    
-    # Processa anexo
-    conteudo_anexo, tipo_anexo = processar_anexo(arquivo_anexo)
-    pergunta_completa = prompt_com_anexo(pergunta, conteudo_anexo, tipo_anexo)
-
-
-    # PASSOS 0-2
-    try:
-        p0 = passo_0_aluno(pergunta_completa, historico)
-        p1 = passo_1_triagem(pergunta_completa, p0, historico)
-        x1 = passo_x1_perguntas(pergunta_completa, p1, historico)
-        x2 = passo_x2_respostas(pergunta_completa, p1, x1)
-        
-        # CENÁRIOS
-        p2 = passo_2_cenarios(pergunta_completa, p1, x1, x2)
-        p3 = passo_3_isolar(p2)
-        p4 = passo_4_validar(p1, p2, p3)
-
-        
-        # LACUNAS
-        p5 = passo_5_lacunas(p1, p4)
-        if p5.get("decisao") == "INTERROMPIDO":
-            esclarecimento = p5.get("pergunta_clarificacao", "Preciso de mais informações")
-            return f"❓ **ESCLARECIMENTO NECESSÁRIO**:\n{esclarecimento}", historico, dna
-        
-        # DECISÃO FINAL
-        p6 = passo_6_decidir(p2, p4, p5)
-        p7 = passo_7_sintetizar(p6)
-        
-        # FORMATA RESPOSTA FINAL
-        resposta_final = formatar_resposta_para_chat(p7)
-
-        # NOVO HISTÓRICO
-        novo_historico = historico + [
-            {"role": "user", "content": pergunta},
-            {"role": "assistant", "content": resposta_final}
-        ]
-        
-        # ATUALIZA DNA
-        dna["historico_chat"].append({"user": pergunta, "assistant": resposta_final})
-        dna["metadados"]["total_turnos"] += 1
-        
-        logger.log("✅ PIPELINE CONCLUÍDA")
-        return resposta_final, novo_historico, dna
-        
-    except Exception as e:
-        erro_msg = f"❌ Erro na pipeline: {str(e)}"
-        logger.log(f"ERRO: {e}", "ERROR")
-        return erro_msg, historico, dna
-        
+def processar_pipeline(pergunta: str, historico: List, arquivo_anexo=None, dna=None) -> Tuple[str, List, Dict]:
+    # Debug inicial
+    debug_print("INICIO PIPELINE", f"Pergunta: {pergunta}\nAnexo: {arquivo_anexo}")
 
-def processar_pipeline2(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()
-    
-    logger.log(f"🚀 v10 ATUALIZADA: {pergunta[:50]}", "START")
-    print("="*70)
-    print("PIPELINE PRINCIPAL v10 ATUALIZADA")
-    print("="*70)
-    
-    if not pergunta.strip(): 
-        return "Pergunta inválida", historico, dna
-    
-    anexo_c, tipo_a = processar_anexo(arquivo_anexo)
-    pergunta_final = construir_prompt_com_anexo(pergunta, anexo_c, tipo_a)
+    if dna is None: dna = criar_dna()
     
-    # P0-P1 (Metacognição Pura)
-    p0 = passo_0_aluno(pergunta_final, historico)
-    logger.log(f"P0 Decisão: {p0.get('decisao', 'NA')}", "INFO")
-    
-    p1 = passo_1_triagem(pergunta_final, p0, historico)
-    logger.log(f"P1 Tipo: {p1.get('tipo', 'NA')} | Decisão: {p1.get('decisao', 'NA')}", "INFO")
+    # 1. Processar Anexo
+    conteudo_anexo, tipo_anexo = processar_anexo(arquivo_anexo)
     
-    # X1-X2 (Perguntas Críticas)
-    x1 = passo_x1_perguntas_necessarias(pergunta_final, p1, historico)
-    x2 = passo_x2_resolver_perguntas(pergunta_final, p1, x1, historico)
+    # 2. Montar Prompt com Contexto Visual/Documental
+    if tipo_anexo == "pdf":
+        prompt_final = f"CONTEXTO DO PDF:\n{conteudo_anexo}\n---\nPERGUNTA: {pergunta}"
+    elif tipo_anexo == "imagem":
+        prompt_final = f"[IMAGEM BASE64: {conteudo_anexo}]\nAnalise a imagem.\nPERGUNTA: {pergunta}"
+    else:
+        prompt_final = pergunta
+
+    # 3. Execução Linear (Se falhar, o erro aparece no console)
+    p0 = passo_0_aluno(prompt_final, historico)
+    debug_print("P0 Resultado", p0)
     
-    # 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
+    p1 = passo_1_triagem(prompt_final, p0)
+    debug_print("P1 Resultado", p1)
     
-    p3 = passo_3_isolar_cenarios(p2)
-    p4 = passo_4_cruzar_validacoes(p1, p2, p3, x2)
-    p5 = passo_5_lacunas_finais(p1, p4)
+    x1 = passo_x1_lacunas(prompt_final, p1)
+    debug_print("X1 Resultado", x1)
     
-    if p5.get("decisao") == "questionar":
-        questionamento = p5.get("questionamento", "Lacuna crítica")
-        return questionamento, historico, dna
+    x2 = passo_x2_resolver(x1, historico)
+    debug_print("X2 Resultado", x2)
     
-    p6 = passo_6_ponderar(p2, p4, p5)
-    p7 = passo_7_sintetizar(p6)
-    p8 = passo_8_verificar(p7)
+    p2 = passo_2_cenarios(prompt_final, x2)
+    debug_print("P2 Resultado", p2)
     
-    # Decisão Final P8
-    if p8.get("todas_aprovadas") == "true" or p8.get("decisao") == "exibir-resposta":
-        resposta = p7.get("resposta", "Resposta gerada")
+    # Lógica de Parada
+    if p2.get("decisao") == "parar":
+        resposta = f"⚠️ Não consigo responder com certeza.\nMotivo: {p2.get('motivo_parada')}"
     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
+        p7 = passo_7_sintese(p2, prompt_final)
+        debug_print("P7 Resultado", p7)
+        resposta = p7.get("resposta_final", "Erro na síntese P7")
+
+    # Atualiza Histórico
+    novo_hist = historico + [
+        {"role": "user", "content": pergunta},
+        {"role": "assistant", "content": resposta}
+    ]
     
-    logger.log("✅ PIPELINE CONCLUÍDA", "SUCCESS")
-    print("="*70)
-    print("RESPOSTA FINAL:")
-    print(resposta)
-    print("="*70)
+    dna["historico"].append({"turn": dna["meta"]["turnos"], "p": pergunta, "r": resposta[:20]})
+    dna["meta"]["turnos"] += 1
     
     return resposta, novo_hist, dna
 
 # ============================================================================
-# INTERFACE (DEPURAÇÃO)
+# INTERFACE
 # ============================================================================
-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 = {}
+def chat_interface(msg, hist, anexo, dna_json):
+    # Converte string JSON do DNA de volta para dict
+    dna = json.loads(dna_json) if dna_json else {}
+    if hist is None: hist = []
     
+    # Chama o pipeline (Erros vão aparecer no console do servidor)
     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(title="Pipeline v10 ATUALIZADA", theme=gr.themes.Soft()) as demo:
-        gr.Markdown(TITLE + "\n**Metacognição Pura + X1-X2 + Verificação Final**")
+    with gr.Blocks(title="Anise Debug", theme=gr.themes.Base()) as demo:
+        gr.Markdown(TITLE)
         
         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", server_port=7860, share=False)
+            chat = gr.Chatbot(height=500, type="messages", label="Chat")
+            dna_box = gr.Code(label="DNA (JSON State)", language="json")
+            
+        with gr.Row():
+            txt_in = gr.Textbox(label="Pergunta", scale=2)
+            file_in = gr.File(label="Anexo")
+            btn = gr.Button("Enviar", variant="primary")
+            
+        btn.click(chat_interface, [txt_in, chat, file_in, dna_box], [chat, txt_in, dna_box, file_in])
+        txt_in.submit(chat_interface, [txt_in, chat, file_in, dna_box], [chat, txt_in, dna_box, file_in])
+
+    print("🚀 Servidor Iniciado! Verifique este console para logs.")
+    demo.launch(server_name="0.0.0.0", server_port=7860)