Delete app.py

app.py

@@ -1,1040 +0,0 @@
-# ╔════════════════════════════════════════════════════════════════════════════╗
-# ║                   PIPELINE v18: METACOGNIÇÃO CRUA                            ║
-# ║              Passos 0-6 Telegráficos → Sintetizador Humanizado               ║
-# ║                                                                              ║
-# ║  Arquitetura:                                                               ║
-# ║  - Passos 0-6: Pensamento puro (sem polimento)                              ║
-# ║  - Sintetizador: Transforma metacognição em prosa humana                    ║
-# ║  - Passo 7: Verificação final (factual, lógica, ética)                      ║
-# ║  - Gestão de Memória: Limpeza a cada 10 turnos                              ║
-# ╚════════════════════════════════════════════════════════════════════════════╝
-
-import os
-import json
-import re
-from datetime import datetime
-from typing import Dict, List, Optional, Tuple
-import warnings
-
-import gradio as gr
-import google.generativeai as genai
-
-warnings.filterwarnings("ignore", category=FutureWarning, module="google.api_core")
-
-# ==================== CONFIGURAÇÃO GEMINI ====================
-
-genai.configure(api_key=os.getenv("GOOGLE_API_KEY", "SUA_API_KEY_AQUI"))
-
-counselor_model = genai.GenerativeModel("gemini-2.0-flash-exp")
-supervisor_model = genai.GenerativeModel("gemini-2.0-flash-exp")
-
-# ==================== CONTEXTO FILOSÓFICO ====================
-
-def carregar_contexto_filosofico(caminho: str = "epct0.md") -> Optional[str]:
-    """Carrega contexto filosófico se disponível."""
-    try:
-        with open(caminho, "r", encoding="utf-8") as f:
-            print(f"✓ Contexto filosófico '{caminho}' carregado.")
-            return f.read()
-    except FileNotFoundError:
-        print(f"⚠ Arquivo '{caminho}' não encontrado.")
-        return None
-
-CONTEXTO_FILOSOFICO = carregar_contexto_filosofico()
-
-# ==================== INICIALIZAÇÃO DO DNA ====================
-
-def criar_dna_vazio() -> Dict:
-    """Cria estrutura de DNA vazio."""
-    return {
-        "historico_chat": [],
-        "historico_passos": {
-            "passo0": [],
-            "passo1": [],
-            "passo2": [],
-            "passo3": [],
-            "passo4": [],
-            "passo5": [],
-            "passo6": [],
-            "passo7": [],
-        },
-        "memoria_contextual": {
-            "ultimos_10_turnos": {
-                "memoria_tipo": "clara",
-                "indices_chat": [],
-                "passos_completos": True
-            },
-            "turnos_anteriores": {
-                "memoria_tipo": "vaga",
-                "total_turnos_comprimidos": 0,
-                "resumo_contexto_global": "",
-                "temas_principais": [],
-                "aprendizados_chave": []
-            }
-        },
-        "metadados": {
-            "total_turnos": 0,
-            "ultimo_turno_limpeza": 0,
-            "total_correcoes_passo7": 0,
-            "tipos_correcoes": {"factuais": 0, "logicas": 0, "eticas": 0},
-            "aprendizados_usuario": [],
-        }
-    }
-
-# ==================== UTILIDADES ====================
-
-def parse_json_seguro(texto: str) -> Dict:
-    """Extrai JSON de resposta mesmo com markdown."""
-    try:
-        # Remove blocos markdown se existirem
-        if "```json" in texto:
-            texto = re.search(r"```json(.*?)```", texto, re.DOTALL).group(1)
-        elif "```" in texto:
-            texto = re.search(r"```(.*?)```", texto, re.DOTALL).group(1)
-        
-        return json.loads(texto.strip())
-    except:
-        print(f"⚠ Erro parseando JSON: {texto[:100]}")
-        return {}
-
-def chamar_gemini(model, prompt: str, temperatura: float = 0.7) -> str:
-    """Chamada segura ao Gemini com retry."""
-    try:
-        response = model.generate_content(
-            prompt,
-            generation_config=genai.types.GenerationConfig(
-                temperature=temperatura,
-                max_output_tokens=2000
-            )
-        )
-        return response.text
-    except Exception as e:
-        print(f"❌ Erro Gemini: {e}")
-        return "{}"
-
-# ==================== PASSO 0: ALUNO ====================
-
-def passo0_aluno(
-    mensagem_usuario: str,
-    turno_anterior: Optional[Dict],
-    memoria_contextual: Dict
-) -> Dict:
-    """
-    METACOGNIÇÃO PURA - Detecta feedback do turno anterior.
-    Formato: telegráfico, sem frases polidas.
-    """
-    
-    if turno_anterior is None:
-        return {
-            "primeiro_turno": True,
-            "analise_feedback": "N/A - Primeira interação",
-            "decisao": "prosseguir_passo1"
-        }
-    
-    prompt = f"""
-Você é um METACOGNITIVO (pensamento interno, não comunicação).
-
-TURNO ANTERIOR:
-User: "{turno_anterior['user']}"
-Assistant: "{turno_anterior['assistant']}"
-
-NOVA MENSAGEM:
-"{mensagem_usuario}"
-
-CONTEXTO VAGO:
-{memoria_contextual.get('turnos_anteriores', {}).get('resumo_contexto_global', 'N/A')}
-
----
-
-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|nao",
-  "evidencias": "pergunta-nova | avança-tópico | não-reformulou",
-  "usuario_corrigiu": "sim|nao",
-  "correcao_detectada": "...|null",
-  "correcao_valida": "sim|nao|null",
-  "o_que_melhorar": "...|null",
-  "decisao": "prosseguir_passo1|reexplicar_passo6|atualizar_resposta_anterior",
-  "motivo": "..."
-}}
-"""
-    
-    resposta_raw = chamar_gemini(counselor_model, prompt, temperatura=0.5)
-    registro = parse_json_seguro(resposta_raw)
-    
-    return registro
-
-# ==================== PASSO 1: TRIAGEM ====================
-
-def passo1_triagem(
-    mensagem_usuario: str,
-    historico_recente: List[Dict],
-    contexto_vago: str
-) -> Dict:
-    """
-    METACOGNIÇÃO PURA - Classificação objetiva vs subjetiva.
-    Formato: telegráfico.
-    """
-    
-    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)}
-
-PERGUNTA:
-"{mensagem_usuario}"
-
----
-
-CLASSIFIQUE EM TELEGRÁFICO (sem frases):
-
-RETORNE JSON:
-{{
-  "tipo": "objetiva_factual|subjetiva_aberta",
-  "sinais": "tem-resposta-única | verificável | sem-contexto-pessoal",
-  "confianca": "alta|media|baixa",
-  "decisao": "responder_direto|analisar_profundamente",
-  "razao": "..."
-}}
-"""
-    
-    resposta_raw = chamar_gemini(counselor_model, prompt, temperatura=0.5)
-    registro = parse_json_seguro(resposta_raw)
-    
-    return registro
-
-# ==================== PASSO 2: CENÁRIOS ====================
-
-def passo2_cenarios(
-    mensagem_usuario: str,
-    historico_chat: List[Dict],
-    analise_p1: Dict,
-    contexto_vago: str
-) -> Dict:
-    """
-    METACOGNIÇÃO PURA - Mapeamento de cenários.
-    Formato: telegráfico com contexto denso.
-    """
-    
-    prompt = f"""
-METACOGNIÇÃO - CENÁRIOS.
-
-CONTEXTO VAGO:
-{contexto_vago}
-
-TRIAGEM (P1):
-{json.dumps(analise_p1, indent=2, ensure_ascii=False)}
-
-HISTÓRICO ÚLTIMAS 5:
-{json.dumps(historico_chat[-5:], indent=2, ensure_ascii=False)}
-
-PERGUNTA:
-"{mensagem_usuario}"
-
----
-
-MAPEIE CENÁRIOS ONDE RESPOSTA MUDA - TELEGRÁFICO:
-
-RETORNE JSON:
-{{
-  "cenarios": [
-    {{
-      "desc": "cenário-1-comprimido | contexto-relevante",
-      "razao": "resposta-muda-porque",
-      "prob": "mais_provavel|menos_provavel"
-    }}
-  ],
-  "total": 2,
-  "tipo_resposta": "multipla|univoca",
-  "confianca": "alta|media|baixa",
-  "decisao": "prosseguir|pedir_esclarecimento",
-  "pergunta": "esclarecimento-necessário|null"
-}}
-"""
-    
-    resposta_raw = chamar_gemini(counselor_model, prompt, temperatura=0.6)
-    registro = parse_json_seguro(resposta_raw)
-    
-    return registro
-
-# ==================== PASSO 3: EXPLORAÇÃO ====================
-
-def passo3_exploracao(
-    historico_chat: List[Dict],
-    analise_p1: Dict,
-    analise_p2: Dict
-) -> Dict:
-    """
-    METACOGNIÇÃO PURA - Para cada cenário, resposta essencial.
-    Formato: telegráfico, máximo contexto.
-    """
-    
-    prompt = f"""
-METACOGNIÇÃO - EXPLORAÇÃO.
-
-CENÁRIOS (P2):
-{json.dumps(analise_p2, indent=2, ensure_ascii=False)}
-
-HISTÓRICO:
-{json.dumps(historico_chat[-5:], indent=2, ensure_ascii=False)}
-
----
-
-PARA CADA CENÁRIO, RESPONDA ESSÊNCIA - TELEGRÁFICO:
-
-Não descreva, apenas essência densa: "Python | curva: 3-6m | vagas: 40% data/backend | frameworks: Django/Flask"
-
-RETORNE JSON:
-{{
-  "exploracoes": [
-    {{
-      "cenario_ref": "cenário-1-comprimido",
-      "resposta_essencia": "palavra-chave | razão-1 | razão-2 | implicação",
-      "confianca": "alta|media|baixa",
-      "lacunas": "contexto-ausente|null"
-    }}
-  ],
-  "cenario_mais_confiante": "cenário-X",
-  "recomendacao": "prosseguir_sintese|pedir_esclarecimento",
-  "pergunta": "esclarecimento|null"
-}}
-"""
-    
-    resposta_raw = chamar_gemini(counselor_model, prompt, temperatura=0.6)
-    registro = parse_json_seguro(resposta_raw)
-    
-    return registro
-
-# ==================== PASSO 4: PRINCÍPIOS + SÍMBOLOS ====================
-
-def passo4_principios_simbolos(
-    historico_chat: List[Dict],
-    analise_p1: Dict,
-    analise_p2: Dict,
-    analise_p3: Dict
-) -> Dict:
-    """
-    METACOGNIÇÃO PURA - Conhecimento fundamental.
-    Formato: telegráfico.
-    """
-    
-    prompt = f"""
-METACOGNIÇÃO - CONHECIMENTO FUNDAMENTAL.
-
-EXPLORAÇÕES (P3):
-{json.dumps(analise_p3, indent=2, ensure_ascii=False)}
-
----
-
-IDENTIFIQUE PRINCÍPIOS E SÍMBOLOS - TELEGRÁFICO:
-
-RETORNE JSON:
-{{
-  "principios": [
-    {{
-      "nome": "Custo-Oportunidade",
-      "cat": "economico|filosofico|matematico|psicologico",
-      "essencia": "escolher X = renunciar Y",
-      "aplica": ["cenário-1", "cenário-2"]
-    }}
-  ],
-  "simbolos": [
-    {{
-      "nome": "Jornada-Herói",
-      "tipo": "arquetipo|metafora|heuristica",
-      "essencia": "transformação-iminente | medo-natural",
-      "aplica": ["contexto-emocional"]
-    }}
-  ],
-  "principio_central": "...",
-  "simbolo_dominante": "...",
-  "tipo_situacao": "nova|mista|recordada"
-}}
-"""
-    
-    resposta_raw = chamar_gemini(counselor_model, prompt, temperatura=0.6)
-    registro = parse_json_seguro(resposta_raw)
-    
-    return registro
-
-# ==================== PASSO 5: METACOGNIÇÃO ====================
-
-def passo5_metacognicao(
-    historico_chat: List[Dict],
-    analise_p1: Dict,
-    analise_p2: Dict,
-    analise_p3: Dict,
-    analise_p4: Dict
-) -> Dict:
-    """
-    METACOGNIÇÃO PURA - Certezas vs dúvidas.
-    Formato: telegráfico.
-    """
-    
-    prompt = f"""
-METACOGNIÇÃO - CERTEZAS vs DÚVIDAS.
-
-EXPLORAÇÕES (P3):
-{json.dumps(analise_p3, indent=2, ensure_ascii=False)}
-
-PRINCÍPIOS (P4):
-{json.dumps(analise_p4, indent=2, ensure_ascii=False)}
-
----
-
-AVALIE CERTEZAS vs DÚVIDAS - TELEGRÁFICO:
-
-RETORNE JSON:
-{{
-  "analise_cenarios": [
-    {{
-      "cenario": "cenário-X",
-      "certezas": "certeza-1 verificável | certeza-2 | certeza-3",
-      "duvidas": "dúvida-1 contextual | dúvida-2",
-      "confianca": "alta|media|baixa",
-      "balanco": "certezas_superam|equilibrado|duvidas_superam",
-      "razao": "3 certezas vs 2 dúvidas"
-    }}
-  ],
-  "confianca_global": "alta|media|baixa",
-  "evolucao_cognitiva": "expandiu|estavel|regrediu",
-  "decisao": "responder|questionar",
-  "razao_decisao": "certezas suficientes",
-  "questionamento": "esclarecimento-necessário|null",
-  "risco": "resposta-genérica|null"
-}}
-"""
-    
-    resposta_raw = chamar_gemini(counselor_model, prompt, temperatura=0.5)
-    registro = parse_json_seguro(resposta_raw)
-    
-    return registro
-
-# ==================== PASSO 6: JUIZ DA VERDADE ====================
-
-def passo6_juiz_verdade(
-    historico_chat: List[Dict],
-    analise_p1: Dict,
-    analise_p2: Dict,
-    analise_p3: Dict,
-    analise_p4: Dict,
-    analise_p5: Dict,
-    rota_rapida: bool = False
-) -> Dict:
-    """
-    METACOGNIÇÃO PURA - Validação socrática.
-    Formato: telegráfico.
-    """
-    
-    prompt = f"""
-METACOGNIÇÃO - ARBITRAGEM SOCRÁTICA.
-
-TODOS PASSOS:
-P1: {json.dumps(analise_p1, indent=2, ensure_ascii=False)}
-P2: {json.dumps(analise_p2, indent=2, ensure_ascii=False)}
-P3: {json.dumps(analise_p3, indent=2, ensure_ascii=False)}
-P4: {json.dumps(analise_p4, indent=2, ensure_ascii=False)}
-P5: {json.dumps(analise_p5, indent=2, ensure_ascii=False)}
-
-ROTA: {"rápida-factual" if rota_rapida else "completa"}
-
----
-
-VALIDE VERDADES SOCRÁTICAS - TELEGRÁFICO:
-
-RETORNE JSON:
-{{
-  "verdade1_nao_sei_que_sei": {{
-    "validada": true|false,
-    "evidencias": "P3-respostas | P4-princípios | P5-certezas",
-    "lacunas": "nenhuma|lacuna-X",
-    "confianca": "alta|media|baixa"
-  }},
-  "verdade2_nao_sei_que_nao_sei": {{
-    "validada": true|false,
-    "evidencias": "P2-cenários-exaustivos | P5-dúvidas-explícitas",
-    "lacunas": "contexto-X-ausente",
-    "confianca": "alta|media|baixa"
-  }},
-  "ambas_validadas": true|false,
-  "decisao": "exibir_resposta|exibir_falhas|reprocessar",
-  "nivel_consciencia": "alto|medio|baixo",
-  "falhas": [
-    {{
-      "tipo": "verdade1|verdade2",
-      "desc": "falha-X",
-      "impacto": "resposta-genérica",
-      "correcao": "perguntar-contexto"
-    }}
-  ]
-}}
-"""
-    
-    resposta_raw = chamar_gemini(counselor_model, prompt, temperatura=0.5)
-    registro = parse_json_seguro(resposta_raw)
-    
-    return registro
-
-# ==================== SINTETIZADOR: METACOGNIÇÃO → HUMANO ====================
-
-def sintetizador_v18(
-    dna: Dict,
-    modo_sabio: bool = False,
-    turno_index: int = -1
-) -> str:
-    """
-    TRANSFORMA METACOGNIÇÃO CRUA EM PROSA HUMANIZADA.
-    
-    Este é o ÚNICO lugar onde polimento acontece.
-    Recebe essência telegráfica dos passos, gera resposta fluida.
-    """
-    
-    # Recupera última metacognição
-    analise_p1 = dna["historico_passos"]["passo1"][turno_index]["saida"] if dna["historico_passos"]["passo1"] else {}
-    analise_p2 = dna["historico_passos"]["passo2"][turno_index]["saida"] if dna["historico_passos"]["passo2"] else {}
-    analise_p3 = dna["historico_passos"]["passo3"][turno_index]["saida"] if dna["historico_passos"]["passo3"] else {}
-    analise_p4 = dna["historico_passos"]["passo4"][turno_index]["saida"] if dna["historico_passos"]["passo4"] else {}
-    analise_p5 = dna["historico_passos"]["passo5"][turno_index]["saida"] if dna["historico_passos"]["passo5"] else {}
-    analise_p6 = dna["historico_passos"]["passo6"][turno_index]["saida"] if dna["historico_passos"]["passo6"] else {}
-    
-    contexto_filosofico_str = ""
-    if modo_sabio and CONTEXTO_FILOSOFICO:
-        contexto_filosofico_str = f"""
-CONTEXTO FILOSÓFICO (use sutilmente se relevante):
-{CONTEXTO_FILOSOFICO[:1000]}
-
-Tom: Amigo Sábio - conversacional, empático, empoderador.
-"""
-    
-    prompt = f"""
-Você é um SINTETIZADOR - transforma METACOGNIÇÃO CRUA em PROSA HUMANIZADA.
-
-METACOGNIÇÃO DOS PASSOS (formato telegráfico):
-
-TRIAGEM (P1):
-{json.dumps(analise_p1, indent=2, ensure_ascii=False)}
-
-CENÁRIOS (P2):
-{json.dumps(analise_p2, indent=2, ensure_ascii=False)}
-
-EXPLORAÇÕES (P3):
-{json.dumps(analise_p3, indent=2, ensure_ascii=False)}
-
-PRINCÍPIOS (P4):
-{json.dumps(analise_p4, indent=2, ensure_ascii=False)}
-
-METACOGNIÇÃO (P5):
-{json.dumps(analise_p5, indent=2, ensure_ascii=False)}
-
-JUIZ (P6):
-{json.dumps(analise_p6, indent=2, ensure_ascii=False)}
-
-{contexto_filosofico_str}
-
----
-
-TAREFA: TRANSFORMAR METACOGNIÇÃO → PROSA HUMANIZADA
-
-**EXEMPLO ENTRADA:** "Python | curva: 3-6m | vagas: 40% DS/backend | ROI: 2x-rápido"
-
-**EXEMPLO SAÍDA:** "Python oferece uma curva de aprendizado mais rápida (3 a 6 meses), com 40% das vagas júnior em data science e backend. Você entra no mercado aproximadamente duas vezes mais rápido."
-
-**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 com introdução-desenvolvimento-nuances
-5. Se P4 identificou símbolos arquetípicos (ex: Jornada Herói) → tone empático
-6. Integre princípios naturalmente (não mencione "princípio de X")
-7. Se {modo_sabio} modo sábio → use metáforas, perguntas socráticas
-
-**GERE RESPOSTA FINAL (texto fluido, natural, humano):**
-"""
-    
-    resposta_raw = chamar_gemini(counselor_model, prompt, temperatura=0.8)
-    
-    return resposta_raw.strip()
-
-# ==================== PASSO 7: VERIFICADOR FINAL ====================
-
-def passo7_verificador_final(
-    resposta_sintetizada: str,
-    analise_p6: Dict
-) -> Dict:
-    """
-    VERIFICAÇÃO FINAL - Factual, lógico, ético.
-    ENTRADA: Resposta humanizada do sintetizador + P6.
-    SAÍDA: Aprovado ou corrigido.
-    """
-    
-    prompt = f"""
-Você é um VERIFICADOR FINAL - guardião de qualidade.
-
-RESPOSTA SINTETIZADA (prestes a ser enviada):
-"{resposta_sintetizada}"
-
-ANÁLISE DO PASSO 6 (Juiz):
-{json.dumps(analise_p6, indent=2, ensure_ascii=False)}
-
----
-
-VERIFICAÇÃO TRIPLA (devolver JSON):
-
-**1. VERIFICAÇÃO FACTUAL**
-Contém fatos incorretos? Datas, nomes, estatísticas errados?
-
-**2. VERIFICAÇÃO LÓGICA**
-Contém falácias? Saltos lógicos injustificados?
-
-**3. VERIFICAÇÃO ÉTICA**
-Eticamente apropriada? Sem conselhos médicos/legais sem disclaimers?
-
-RETORNE JSON:
-{{
-  "verificacao_factual": {{
-    "aprovada": true|false,
-    "problemas": ["problema-1"]|[],
-    "correcoes": ["correção-1"]|[]
-  }},
-  "verificacao_logica": {{
-    "aprovada": true|false,
-    "falacias": ["falácia-1"]|[],
-    "correcoes": ["correção-1"]|[]
-  }},
-  "verificacao_etica": {{
-    "aprovada": true|false,
-    "problemas": ["problema-1"]|[],
-    "correcoes": ["correção-1"]|[]
-  }},
-  "todas_aprovadas": true|false,
-  "decisao": "exibir_resposta|corrigir_e_exibir",
-  "justificativa": "...",
-  "resposta_corrigida": "versão corrigida ou null",
-  "nota_correcao": "nota ao usuário ou null"
-}}
-"""
-    
-    resposta_raw = chamar_gemini(supervisor_model, prompt, temperatura=0.5)
-    registro = parse_json_seguro(resposta_raw)
-    
-    return registro
-
-# ==================== GESTÃO DE MEMÓRIA ====================
-
-def gerar_resumo_contextual(turnos_antigos: List[Dict]) -> Dict:
-    """
-    Comprime turnos antigos em resumo vago mas útil.
-    Chamado quando há >10 turnos.
-    """
-    
-    dialogo_antigo = "\n\n".join([
-        f"User: {t['user']}\nAssistant: {t['assistant']}"
-        for t in turnos_antigos[:5]  # Amostra primeiros 5
-    ])
-    
-    prompt = f"""
-Você é um Compressor de Memória.
-
-HISTÓRICO ANTIGO (primeiros turnos):
-{dialogo_antigo}
-
----
-
-COMPRIMA EM RESUMO VAGO MAS ÚTIL (como professor que não lembra exatamente):
-
-Não tente detalhar tudo. Apenas:
-1. Temas gerais discutidos
-2. Aprendizados importantes sobre o usuário
-3. Contexto útil para o futuro
-
-RETORNE JSON:
-{{
-  "resumo": "1-3 frases com contexto global",
-  "temas": ["tema-1", "tema-2"],
-  "aprendizados": ["aprendizado-1", "aprendizado-2"]
-}}
-"""
-    
-    resposta_raw = chamar_gemini(counselor_model, prompt)
-    resumo = parse_json_seguro(resposta_raw)
-    
-    return {
-        "resumo": resumo.get("resumo", ""),
-        "temas": resumo.get("temas", []),
-        "aprendizados": resumo.get("aprendizados", [])
-    }
-
-def limpar_memoria_cognitiva(dna: Dict) -> None:
-    """
-    Executa a cada 10 turnos.
-    Preserva: historico_chat + metadados
-    Limpa: historico_passos (mantém últimos 10)
-    Comprime: turnos antigos → resumo contextual
-    """
-    
-    turno_atual = dna["metadados"]["total_turnos"]
-    ultimo_turno_limpeza = dna["metadados"].get("ultimo_turno_limpeza", 0)
-    
-    if turno_atual - ultimo_turno_limpeza < 10:
-        return
-    
-    print(f"\n{'='*70}")
-    print(f"🧹 LIMPEZA DE MEMÓRIA COGNITIVA (Turno {turno_atual})")
-    print(f"{'='*70}\n")
-    
-    # 1. Preserva últimos 10 registros de cada passo
-    for passo_nome in ["passo0", "passo1", "passo2", "passo3", "passo4", "passo5", "passo6", "passo7"]:
-        historico_passo = dna["historico_passos"][passo_nome]
-        
-        if len(historico_passo) > 10:
-            removidos = len(historico_passo) - 10
-            dna["historico_passos"][passo_nome] = historico_passo[-10:]
-            print(f"   {passo_nome}: {len(historico_passo)} → 10 (removidos {removidos})")
-    
-    # 2. Comprime turnos antigos
-    turnos_antigos_chat = dna["historico_chat"][:-10]
-    
-    if len(turnos_antigos_chat) > 0:
-        print(f"\n   Comprimindo {len(turnos_antigos_chat)} turnos antigos...\n")
-        resumo_contextual = gerar_resumo_contextual(turnos_antigos_chat)
-        
-        dna["memoria_contextual"] = {
-            "ultimos_10_turnos": {
-                "memoria_tipo": "clara",
-                "indices_chat": list(range(max(0, len(dna["historico_chat"]) - 10), len(dna["historico_chat"]))),
-                "passos_completos": True
-            },
-            "turnos_anteriores": {
-                "memoria_tipo": "vaga",
-                "total_turnos_comprimidos": len(turnos_antigos_chat),
-                "resumo_contexto_global": resumo_contextual["resumo"],
-                "temas_principais": resumo_contextual["temas"],
-                "aprendizados_chave": resumo_contextual["aprendizados"]
-            }
-        }
-    
-    # 3. Atualiza metadados
-    dna["metadados"]["ultimo_turno_limpeza"] = turno_atual
-    
-    print(f"✅ Limpeza concluída")
-    print(f"   Memória clara: últimos 10 turnos")
-    print(f"   Memória vaga: {len(turnos_antigos_chat)} turnos comprimidos")
-    print(f"{'='*70}\n")
-
-# ==================== PIPELINE PRINCIPAL v18 ====================
-
-def processar_turno_v18(
-    mensagem_usuario: str,
-    dna: Dict,
-    modo_sabio: bool = False
-) -> Tuple[str, Dict]:
-    """
-    Pipeline completa v18: Metacognição → Síntese → Verificação
-    Retorna: (resposta_final, dna_atualizado)
-    """
-    
-    print(f"\n{'='*70}")
-    print(f"📩 TURNO #{dna['metadados']['total_turnos'] + 1}")
-    print(f"{'='*70}\n")
-    
-    # 0. PASSO 0: ALUNO (Feedback)
-    print("🎓 PASSO 0: Aluno (analisando feedback)...")
-    
-    turno_anterior = dna["historico_chat"][-1] if len(dna["historico_chat"]) > 0 else None
-    memoria_contextual = dna["memoria_contextual"]
-    
-    registro_p0 = passo0_aluno(mensagem_usuario, turno_anterior, memoria_contextual)
-    
-    dna["historico_passos"]["passo0"].append({
-        "entrada": mensagem_usuario,
-        "saida": registro_p0,
-        "timestamp": datetime.now().isoformat()
-    })
-    
-    # Adiciona turno ao chat
-    dna["historico_chat"].append({
-        "user": mensagem_usuario,
-        "assistant": None,
-        "timestamp": datetime.now().isoformat()
-    })
-    dna["metadados"]["total_turnos"] += 1
-    
-    print(f"   Decisão P0: {registro_p0.get('decisao', 'N/A')}\n")
-    
-    # Verifica decisão P0
-    decisao_p0 = registro_p0.get("decisao")
-    
-    if decisao_p0 == "prosseguir_passo1":
-        print("✅ Prosseguindo pipeline normal...\n")
-        
-        # 1. PASSO 1: TRIAGEM
-        print("🔍 PASSO 1: Triagem...")
-        contexto_vago = memoria_contextual["turnos_anteriores"]["resumo_contexto_global"]
-        historico_recente = [{"user": t["user"], "assistant": t["assistant"]} for t in dna["historico_chat"][-4:-1]]
-        
-        registro_p1 = passo1_triagem(mensagem_usuario, historico_recente, contexto_vago)
-        
-        dna["historico_passos"]["passo1"].append({
-            "entrada": mensagem_usuario,
-            "saida": registro_p1,
-            "timestamp": datetime.now().isoformat()
-        })
-        
-        print(f"   Tipo: {registro_p1.get('tipo', 'N/A')}")
-        print(f"   Decisão: {registro_p1.get('decisao', 'N/A')}\n")
-        
-        # 2. PASSO 2: CENÁRIOS
-        print("🎯 PASSO 2: Cenários...")
-        
-        registro_p2 = passo2_cenarios(
-            mensagem_usuario,
-            dna["historico_chat"],
-            registro_p1,
-            contexto_vago
-        )
-        
-        dna["historico_passos"]["passo2"].append({
-            "entrada": mensagem_usuario,
-            "saida": registro_p2,
-            "timestamp": datetime.now().isoformat()
-        })
-        
-        if registro_p2.get("decisao") == "pedir_esclarecimento":
-            resposta_final = registro_p2.get("pergunta", "Poderia esclarecer melhor?")
-            dna["historico_chat"][-1]["assistant"] = resposta_final
-            return resposta_final, dna
-        
-        print(f"   Cenários: {registro_p2.get('total', 0)}")
-        print(f"   Decisão: {registro_p2.get('decisao', 'N/A')}\n")
-        
-        # 3. PASSO 3: EXPLORAÇÃO
-        print("💡 PASSO 3: Exploração...")
-        
-        registro_p3 = passo3_exploracao(
-            dna["historico_chat"],
-            registro_p1,
-            registro_p2
-        )
-        
-        dna["historico_passos"]["passo3"].append({
-            "entrada": f"Explorando {registro_p2.get('total', 0)} cenários",
-            "saida": registro_p3,
-            "timestamp": datetime.now().isoformat()
-        })
-        
-        if registro_p3.get("recomendacao") == "pedir_esclarecimento":
-            resposta_final = registro_p3.get("pergunta", "Poderia esclarecer melhor?")
-            dna["historico_chat"][-1]["assistant"] = resposta_final
-            return resposta_final, dna
-        
-        print(f"   Cenário mais confiante: {registro_p3.get('cenario_mais_confiante', 'N/A')}\n")
-        
-        # 4. PASSO 4: PRINCÍPIOS
-        print("🔀 PASSO 4: Princípios + Símbolos...")
-        
-        registro_p4 = passo4_principios_simbolos(
-            dna["historico_chat"],
-            registro_p1,
-            registro_p2,
-            registro_p3
-        )
-        
-        dna["historico_passos"]["passo4"].append({
-            "entrada": "Analisando conhecimento fundamental",
-            "saida": registro_p4,
-            "timestamp": datetime.now().isoformat()
-        })
-        
-        print(f"   Princípio central: {registro_p4.get('principio_central', 'N/A')}\n")
-        
-        # 5. PASSO 5: METACOGNIÇÃO
-        print("✨ PASSO 5: Metacognição...")
-        
-        registro_p5 = passo5_metacognicao(
-            dna["historico_chat"],
-            registro_p1,
-            registro_p2,
-            registro_p3,
-            registro_p4
-        )
-        
-        dna["historico_passos"]["passo5"].append({
-            "entrada": "Avaliação de certezas vs dúvidas",
-            "saida": registro_p5,
-            "timestamp": datetime.now().isoformat()
-        })
-        
-        if registro_p5.get("decisao") == "questionar":
-            resposta_final = registro_p5.get("questionamento", "Poderia esclarecer melhor?")
-            dna["historico_chat"][-1]["assistant"] = resposta_final
-            return resposta_final, dna
-        
-        print(f"   Confiança global: {registro_p5.get('confianca_global', 'N/A')}\n")
-        
-        # 6. PASSO 6: JUIZ
-        print("⚖️ PASSO 6: Juiz da Verdade...")
-        
-        rota_rapida = registro_p1.get("decisao") == "responder_direto"
-        
-        registro_p6 = passo6_juiz_verdade(
-            dna["historico_chat"],
-            registro_p1,
-            registro_p2,
-            registro_p3,
-            registro_p4,
-            registro_p5,
-            rota_rapida
-        )
-        
-        dna["historico_passos"]["passo6"].append({
-            "entrada": "Validação socrática",
-            "saida": registro_p6,
-            "timestamp": datetime.now().isoformat()
-        })
-        
-        if registro_p6.get("decisao") == "exibir_falhas":
-            resposta_final = registro_p6.get("pergunta_corretiva", "Há pontos que precisamos esclarecer melhor.")
-            dna["historico_chat"][-1]["assistant"] = resposta_final
-            return resposta_final, dna
-        
-        print(f"   Nível de consciência: {registro_p6.get('nivel_consciencia', 'N/A')}\n")
-        
-        # 7. SINTETIZADOR: Transforma metacognição em prosa
-        print("🎯 Sintetizador: Transformando metacognição em prosa...")
-        
-        resposta_sintetizada = sintetizador_v18(dna, modo_sabio)
-        
-        print(f"   Resposta gerada ({len(resposta_sintetizada)} caracteres)\n")
-        
-        # 8. PASSO 7: VERIFICADOR FINAL
-        print("🔍 PASSO 7: Verificação Final...")
-        
-        registro_p7 = passo7_verificador_final(resposta_sintetizada, registro_p6)
-        
-        dna["historico_passos"]["passo7"].append({
-            "entrada": f"Verificando resposta ({len(resposta_sintetizada)} caracteres)",
-            "saida": registro_p7,
-            "timestamp": datetime.now().isoformat()
-        })
-        
-        factual_ok = registro_p7.get("verificacao_factual", {}).get("aprovada", False)
-        logica_ok = registro_p7.get("verificacao_logica", {}).get("aprovada", False)
-        etica_ok = registro_p7.get("verificacao_etica", {}).get("aprovada", False)
-        
-        print(f"   Factual: {'✓' if factual_ok else '✗'}")
-        print(f"   Lógica: {'✓' if logica_ok else '✗'}")
-        print(f"   Ética: {'✓' if etica_ok else '✗'}\n")
-        
-        # 9. DECISÃO FINAL
-        if registro_p7.get("decisao") == "exibir_resposta":
-            resposta_final = resposta_sintetizada
-            print("✅ Verificação aprovada - Resposta original exibida\n")
-        else:
-            resposta_corrigida = registro_p7.get("resposta_corrigida", resposta_sintetizada)
-            nota = registro_p7.get("nota_correcao", "")
-            resposta_final = f"{resposta_corrigida}\n\n---\n\n**Nota de Refinamento:** {nota}"
-            print("⚠️ Correções aplicadas - Resposta refinada exibida\n")
-            
-            # Atualiza metadados
-            dna["metadados"]["total_correcoes_passo7"] += 1
-            tipo_correcao = []
-            if not factual_ok:
-                tipo_correcao.append("factuais")
-            if not logica_ok:
-                tipo_correcao.append("logicas")
-            if not etica_ok:
-                tipo_correcao.append("eticas")
-            
-            for tipo in tipo_correcao:
-                if tipo in dna["metadados"]["tipos_correcoes"]:
-                    dna["metadados"]["tipos_correcoes"][tipo] += 1
-    
-    else:
-        # Rotas especiais (reexplicar ou atualizar)
-        resposta_final = f"[Rota especial: {decisao_p0}] - Em desenvolvimento"
-    
-    # 10. ATUALIZA DNA
-    dna["historico_chat"][-1]["assistant"] = resposta_final
-    
-    # 11. LIMPEZA DE MEMÓRIA (a cada 10 turnos)
-    limpar_memoria_cognitiva(dna)
-    
-    print(f"✅ CONCLUÍDO\n{'='*70}\n")
-    
-    return resposta_final, dna
-
-# ==================== INTERFACE GRADIO ====================
-
-def criar_interface():
-    """Cria interface Gradio."""
-    
-    dna = criar_dna_vazio()
-    
-    def chat(mensagem, modo_sabio_check, historia_chat):
-        """Callback para chat."""
-        nonlocal dna
-        
-        resposta, dna = processar_turno_v18(mensagem, dna, modo_sabio_check)
-        
-        # Formata histórico para Gradio
-        historia_chat.append((mensagem, resposta))
-        
-        return "", historia_chat, json.dumps(dna, indent=2, ensure_ascii=False)
-    
-    with gr.Blocks(title="Pipeline v18: Metacognição → Síntese") as interface:
-        gr.Markdown("""
-        # 🧠 Pipeline v18: Metacognição Pura
-        
-        **Arquitetura:**
-        - Passos 0-6: Pensamento telegráfico (metacognição crua)
-        - Sintetizador: Transforma em prosa humanizada
-        - Passo 7: Verificação final (factual, lógica, ética)
-        - Gestão de Memória: Limpeza a cada 10 turnos
-        """)
-        
-        with gr.Row():
-            with gr.Column(scale=3):
-                chat_display = gr.Chatbot(label="Conversa", height=500)
-                msg_input = gr.Textbox(
-                    label="Sua mensagem",
-                    placeholder="Digite sua pergunta...",
-                    lines=2
-                )
-                modo_sabio = gr.Checkbox(label="🧙 Modo Sábio (Filosófico)")
-                
-                enviar_btn = gr.Button("Enviar", variant="primary")
-            
-            with gr.Column(scale=1):
-                dna_display = gr.Code(label="DNA (JSON)", language="json", lines=30)
-        
-        enviar_btn.click(
-            chat,
-            inputs=[msg_input, modo_sabio, chat_display],
-            outputs=[msg_input, chat_display, dna_display]
-        )
-        
-        msg_input.submit(
-            chat,
-            inputs=[msg_input, modo_sabio, chat_display],
-            outputs=[msg_input, chat_display, dna_display]
-        )
-    
-    return interface
-
-# ==================== MAIN ====================
-
-if __name__ == "__main__":
-    interface = criar_interface()
-    interface.launch(share=False)