Create app.py

app.py

@@ -0,0 +1,1040 @@
+# ╔════════════════════════════════════════════════════════════════════════════╗
+# ║                   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)