Update app.py

app.py

@@ -1,25 +1,14 @@
+
 # -*- coding: utf-8 -*-
 """
-Pipeline v10 - VERSÃO FINAL COM NOVA CHAMADA DE API.
-
-Este script implementa a nova forma de chamada da API Gemini, utilizando
-genai.Client e generate_content_stream, conforme solicitado.
+Pipeline v10 - COM MEMÓRIA DA API E HISTÓRICO DE GOVERNANÇA COMPACTADO (Últimas 10).
 
 PRINCIPAIS ALTERAÇÕES:
--   NOVA CHAMADA DE API: A função `chamar_gemini_json` foi totalmente
-    refatorada para usar `genai.Client` e `generate_content_stream`.
-    Ela agora coleta os 'chunks' do stream para montar a resposta JSON completa.
--   MODELO PRO: Utiliza o 'gemini-1.5-pro-latest' para todas as operações.
--   FERRAMENTAS ATIVADAS: A Pesquisa Google (`GoogleSearch`) foi habilitada
-    como uma ferramenta para o modelo, permitindo que ele fundamente melhor
-    suas análises internas.
--   ROBUSTEZ E FUNCIONALIDADES ANTERIORES: Todas as lógicas de sanitização,
-    bypass, pausa/retomada e tratamento de erros foram mantidas.
+-   MEMÓRIA GEMINI: A API agora recebe o histórico completo da conversa (types.Content) em cada chamada.
+-   HISTÓRICO DE GOVERNANÇA: 'historico_chat' substituído por 'historico_governanca', limitado a 10 entradas de debug (P1/P8).
+-   VISUALIZADOR DNA: Novo grupo colapsável para ver o Histórico de Governança no DNA View.
 """
-
-# ============================================================================
-# 1. IMPORTAÇÕES E CONFIGURAÇÃO INICIAL
-# ============================================================================
+# (IMPORTAÇÕES INALTERADAS)
 import json
 import os
 import re
@@ -28,341 +17,426 @@ from datetime import datetime
 from typing import Dict, List, Tuple, Any
 
 import gradio as gr
-
-
-
 from google import genai
 from google.genai import types
 
+# Define o nome do arquivo de prompts para uso centralizado
+PROMPT_FILENAME = "prompts_pipeline.json"
+
 warnings.filterwarnings("ignore", category=FutureWarning, module="google.api_core")
 
-# --- Configuração da API ---
 API_KEY = os.getenv("GOOGLE_API_KEY")
 if not API_KEY:
     raise ValueError("A variável de ambiente GOOGLE_API_KEY não foi configurada.")
 
-# ATUALIZADO: Inicializa o Cliente em vez dos modelos.
-# A chave de API é passada diretamente aqui
-# Only run this block for Gemini Developer API
 CLIENT = genai.Client(api_key=API_KEY)
+COUNSELOR_MODEL_NAME = "gemini-2.5-pro"
+SUPERVISOR_MODEL_NAME = "gemini-2.5-pro" 
+TITLE = "# 🚀 Pipeline v10 | Governanca com Memória API"
 
-# --- Definição dos Modelos ---
-# ATUALIZADO: Agora são apenas strings com os nomes dos modelos.
-COUNSELOR_MODEL_NAME = "gemini-flash-latest"
-SUPERVISOR_MODEL_NAME = "gemini-flash-latest" # Pode ser diferente se desejado
+# (O bloco 2. PROMPTS CENTRALIZADOS - com carregar_prompts_externos, etc. - PERMANECE INALTERADO)
+# [ ... SEÇÃO 2 COMPLETA DEVE SER MANTIDA INALTERADA AQUI ... ]
+PROMPTS = carregar_prompts_externos()
 
-# --- Título da Interface ---
-TITLE = "# 🚀 Pipeline v10 | Nova API do Gemini Pro\n**Utilizando `Client`, `stream` e `tools` para raciocínio aprimorado.**"
 
-# ============================================================================
-# 2. PROMPTS CENTRALIZADOS
-# ============================================================================
-# (Os prompts permanecem os mesmos da versão anterior, sem alterações)
-PROMPTS = {
-    "P1_TRIAGEM": """
-METACOGNIÇÃO - TRIAGEM INICIAL.
-PERGUNTA: {pergunta}
----
-Analise a pergunta e classifique-a.
-- tipo: 'factual', 'objetiva_tecnica', 'subjetiva_complexa'.
-- confianca: 'extrema', 'alta', 'media', 'baixa', 'insuficiente'.
-RETORNE JSON: {{"tipo": "...", "confianca": "...", "decisao": "responder_direto|analisar_profundamente"}}
-""",
-    "GERAR_RESPOSTA_DIRETA": """
-TAREFA: Resposta Direta (Bypass).
-PERGUNTA: "{pergunta}"
----
-Forneça uma resposta direta, precisa e concisa.
-RETORNE JSON: {{"resposta_direta": "Sua resposta concisa aqui."}}
-""",
-    "JUSTIFICAR_BYPASS": """
-METACOGNIÇÃO - JUSTIFICATIVA DE BYPASS.
-ANÁLISE (P1): {p1}
----
-Justifique por que a pipeline de raciocínio profundo foi pulada.
-RETORNE JSON: {{"justificativa_bypass": {{"motivo": "...", "acao_tomada": "...", "proximo_passo": "..."}}}}
-""",
-    "P2_CENARIOS": """
-METACOGNIÇÃO - GERAÇÃO DE CENÁRIOS.
-ANÁLISE (P1): {p1}, PERGUNTA: {pergunta}
----
-Gere o cenário mais provável e um alternativo improvável.
-RETORNE JSON: {{"cenarios": {{"provaveis": [], "improvaveis": []}}, "decisao": "prosseguir"}}
-""",
-    "P4_CRUZAR_VALIDACOES": """
-METACOGNIÇÃO - ABSTRAÇÃO.
-ANÁLISES ANTERIORES: {p1}, {p2}, {p3}
----
-Identifique o princípio fundamental da discussão.
-RETORNE JSON: {{"principio_central": "..."}}
-""",
-    "P5_LACUNAS_FINAIS": """
-METACOGNIÇÃO - ANÁLISE DE INCERTEZA.
-PRINCÍPIO CENTRAL (P4): {p4}, PERGUNTA: {pergunta}
----
-Identifique a principal lacuna de informação e formule uma pergunta clara para o usuário.
-RETORNE JSON: {{"pontos_de_incerteza": [], "decisao_interna": "questionar", "pergunta_chave_para_usuario": "..."}}
-""",
-    "P7_SINTETIZAR": """
-SINTETIZADOR.
-DADOS (P6): {p6}
----
-Converta a análise técnica em uma resposta final coesa.
-RETORNE JSON: {{"resposta": "..."}}
-""",
-    "P8_VERIFICAR": """
-VERIFICADOR FINAL.
-RESPOSTA: {resposta_a_verificar}
----
-Realize uma verificação tripla (factual, lógica, clareza) e corrija se necessário.
-RETORNE JSON: {{"todas_aprovadas": true|false, "resposta_corrigida": null}}
-"""
-}
 # ============================================================================
 # 3. CLASSES E FUNÇÕES HELPERS
 # ============================================================================
-
 class Logger:
+    # (Logger inalterado)
     def __init__(self, verbose: bool = True): self.verbose = verbose
     def log(self, msg: str, level: str = "INFO"):
         log_msg = f"[{datetime.now().strftime('%H:%M:%S')}] [{level.upper()}] {msg}"; print(log_msg)
         if level.upper() in ["TASK", "START", "SUCCESS", "ERROR", "WARN"]: print("=" * 70)
-
 logger = Logger(verbose=True)
 
 def sanitizar_texto(texto: str) -> str:
+    # (sanitizar_texto inalterado)
     if not isinstance(texto, str): return ""
     texto_limpo = re.sub(r'[\x00-\x08\x0b\x0c\x0e-\x1f]', '', texto)
     texto_limpo = re.sub(r'\s{2,}', ' ', texto_limpo).replace('\\n', '\n')
     return texto_limpo.strip()
 
-# ATUALIZADO: Função totalmente refatorada para usar a nova chamada de API.
-#  ============================================================================
-# CORREÇÃO DA FUNÇÃO DE CHAMADA DA API (google-genai v1.0+)
-# ===========================================================================
-
-# ============================================================================
-# FUNÇÃO CORRIGIDA: REMOVIDO response_mime_type PARA COMPATIBILIDADE COM TOOLS
-# ============================================================================
-
-def chamar_gemini_json(model_name: str, prompt: str, temperatura: float = 0.7, max_tokens: int = 12000) -> Dict:
-    # 1. Ajuste de Prompt
-    # Modelos "Thinking" funcionam melhor quando explicamos o que queremos, 
-    # mas mantemos a proibição de Markdown no output final para facilitar o regex.
-    prompt_completo = f"{prompt}\n\n---\n\n**INSTRUÇÃO CRÍTICA: Ao final do seu raciocínio, sua resposta FINAL deve ser estritamente um único objeto JSON válido. Não use blocos de código markdown"
-    
-    print(f"\n{'='*25} 💬 API INPUT PARA [{model_name}] {'='*25}\n{prompt_completo[:300]}...\n{'='*78}\n")
+# ATUALIZADO: Chama a API com Histórico de Conversa (memória nativa)
+def chamar_gemini_json(model_name: str, prompt: str, 
+                       historico_conversa: List[types.Content] = None, # <--- AGORA ACEITA HISTÓRICO
+                       temperatura: float = 0.4, max_tokens: int = 8192) -> Dict:
+    prompt_completo = f"{prompt}\n\n---\n\n**INSTRUÇÃO CRÍTICA: Não use formatação Markdown. Sua resposta DEVE ser estritamente um único objeto JSON válido.**"
+    # print(f"\n{'='*25} 💬 API INPUT PARA [{model_name}] {'='*25}\n{prompt_completo}\n{'='*78}\n")
 
     try:
-        # 2. Configurar o Thinking
-        # include_thoughts=True fará com que o pensamento apareça no output (ajuda a debugar), 
-        # mas o seu regex filtrará para pegar só o JSON depois.
-        thinking_config = types.thinkingConfig(
-            #include_thoughts=True
-            thinkingBudget: -1
+        # 1. Monta o contents, INCLUINDO o histórico E a pergunta atual.
+        contents = historico_conversa if historico_conversa else []
+        contents.append( # Adiciona o prompt da TAREFA (Triagem, Cenários, etc)
+            types.Content(
+                role="user", # Sempre 'user' para a instrução da tarefa atual
+                parts=[types.Part.from_text(text=prompt_completo)],
+            )
         )
 
-        # 3. Ferramentas (Google Search)
-        tools = [
-            types.Tool(google_search=types.GoogleSearch()),
-        ]
-
-        # 4. Configuração da Geração
-        # ATENÇÃO: Modelos "Thinking" exigem temperatura maior ou igual a 0.7 para serem criativos no raciocínio.
-        # removemos 'response_mime_type' pois conflita com Tools e Thinking juntos.
+        # 2. Configuração (Thinking e Tools - inalterado)
+        tools = [types.Tool(google_search=types.GoogleSearch())]
         generate_content_config = types.GenerateContentConfig(
-            temperature=0.7,             # Thinking requer > 0
+            temperature=temperatura,
             max_output_tokens=max_tokens,
-            thinking_config=thinking_config,
+            thinking_config=types.ThinkingConfig(thinking_budget=8192), 
             tools=tools
         )
 
-        # 5. Configurar Conteúdo
-        contents = [
-            types.Content(
-                role="user",
-                parts=[types.Part.from_text(text=prompt_completo)],
-            ),
-        ]
-
-        # 6. Chamada API
+        # 3. Chamada de API Corrigida
         stream = CLIENT.models.generate_content_stream(
-            model=model_name,
-            contents=contents,
-            config=generate_content_config,
+            model=model_name, contents=contents, config=generate_content_config
         )
+        # ... (Agregação de resposta, sanitização e extração de JSON inalterados) ...
+        resposta_bruta = "".join(chunk.text for chunk in stream if chunk.text)
+        resposta_sanitizada = sanitizar_texto(resposta_bruta)
+
+        if not resposta_sanitizada:
+            return {"erro": "API_EMPTY_RESPONSE"}
         
-        # 7. Agregar Resposta
-        resposta_bruta = ""
-        for chunk in stream:
-            # Captura partes de texto e partes de pensamento (se retornadas como texto no stream)
-            if chunk.text:
-                resposta_bruta += chunk.text
-            # Modelos Thinking as vezes retornam "executable_code", garantimos pegar apenas texto
-            
-        print(f"\n{'='*25} 📥 API RAW OUTPUT (Thinking + JSON) {'='*25}\n{resposta_bruta[:500]}... [conteudo longo] ...\n{'='*78}\n")
-        
-        # 8. Sanitização e Extração
-        # Como o modelo vai "pensar" primeiro, o texto vai começar com o raciocínio e terminar com o JSON.
-        # O Regex aqui é CRUCIAL.
-        match = re.search(r'(\{.*\})', resposta_bruta, re.DOTALL)
-        
+        match = re.search(r'\{.*\}', resposta_sanitizada, re.DOTALL)
         if match:
-            json_str = match.group(0)
-            return json.loads(json_str)
+            return json.loads(match.group(0))
         else:
-            # Fallback: Tenta limpar chars estranhos caso o regex falhe
-            logger.log("Regex primário falhou, tentando limpeza forçada...", "WARN")
-            resposta_sanitizada = sanitizar_texto(resposta_bruta)
-            match_retry = re.search(r'(\{.*\})', resposta_sanitizada, re.DOTALL)
-            if match_retry:
-                return json.loads(match_retry.group(0))
-            
-            return {"erro": "JSON_NOT_FOUND", "raw": resposta_bruta[:500], "detalhes": "O modelo pensou mas não entregou o JSON no formato esperado."}
-        
+             return json.loads(resposta_sanitizada)
+
     except Exception as e:
-        logger.log(f"Falha na chamada da API com Thinking: {e}", "ERROR")
+        logger.log(f"Falha na chamada da API ou no parse do JSON: {e}", "ERROR")
         return {"erro": "API_CALL_FAILED", "detalhes": str(e)}
 
+# ATUALIZADO: Helper para Histórico (Memória API)
+def to_gemini_contents(historico: List[Dict]) -> List[types.Content]:
+    """Converte o histórico Gradio-compatível para o formato genai.types.Content (user/model)."""
+    gemini_contents = []
+    for entry in historico:
+        role = "model" if entry["role"] == "assistant" else "user"
+        # Garante que só há conteúdo para a API (exclui a JUSTIFICATIVA DE RESPOSTA DIRETA/formatação do Gradio)
+        content_for_api = re.sub(r'\*\*JUSTIFICATIVA DE RESPOSTA DIRETA:\*\*.*?\-\-\-\n\n', '', entry["content"], flags=re.DOTALL)
         
-
-
+        if content_for_api:
+            gemini_contents.append(
+                types.Content(
+                    role=role,
+                    parts=[types.Part.from_text(text=content_for_api)]
+                )
+            )
+    return gemini_contents
+
+# ATUALIZADO: DNA para o Novo Histórico de Governança
 def criar_dna() -> Dict:
-    return { "historico_chat": [], "meta": {"total_turnos": 0}, "pipeline_state": { "status": "completed", "paused_at_step": None, "saved_data": {} } }
+    return { 
+        "historico_governanca": [], # <--- NOVO: Listagem das últimas 10 iterações de debug
+        "meta": {"total_turnos": 0}, 
+        "pipeline_state": { 
+            "status": "completed", 
+            "paused_at_step": None, 
+            "saved_data": {} 
+        },
+        # Campos de debug/visualização do TURNO ATUAL
+        "P1_data": {}, "P2_data": {}, "P4_data": {}, "P5_data": {}, "P8_data": {},
+    }
+
+def formatar_dna_json(data: Dict) -> str:
+    # (formatar_dna_json inalterado)
+    try:
+        return json.dumps(data, indent=2, ensure_ascii=False)
+    except:
+        return f"Erro ao serializar dados: {data}"
 
 # ============================================================================
-# 4. PASSOS DA PIPELINE
+# 4. PASSOS DA PIPELINE E 5. ORQUESTRADOR
 # ============================================================================
-# ATUALIZADO: As chamadas agora passam o NOME do modelo.
-def passo_1_triagem(pergunta: str) -> Dict:
+
+# Os passos precisam receber historico_conversa, mas como o prompt é fechado em JSON, 
+# só P1 e o Bypass Resposta Direta P8 usam a memória, por conveniência e performance.
+def passo_1_triagem(pergunta: str, dna: Dict, historico_memoria: List[types.Content]) -> Tuple[Dict, Dict]:
     logger.log("📊 PASSO 1: TRIAGEM INICIAL", "TASK")
-    return chamar_gemini_json(COUNSELOR_MODEL_NAME, PROMPTS["P1_TRIAGEM"].format(pergunta=pergunta))
-def passo_gerar_resposta_direta(pergunta: str) -> Dict:
+    p1 = chamar_gemini_json(COUNSELOR_MODEL_NAME, PROMPTS["P1_TRIAGEM"].format(pergunta=pergunta), historico_conversa=historico_memoria)
+    dna["P1_data"] = p1
+    return p1, dna
+def passo_gerar_resposta_direta(pergunta: str, historico_memoria: List[types.Content]) -> Dict:
     logger.log("⚡ FAST PATH: GERANDO RESPOSTA DIRETA", "TASK")
-    return chamar_gemini_json(COUNSELOR_MODEL_NAME, PROMPTS["GERAR_RESPOSTA_DIRETA"].format(pergunta=pergunta))
+    # Usa a memória para contextuar a resposta
+    return chamar_gemini_json(COUNSELOR_MODEL_NAME, PROMPTS["GERAR_RESPOSTA_DIRETA"].format(pergunta=pergunta), historico_conversa=historico_memoria)
+
+# Os outros passos (P2, P4, P5, P8) podem continuar usando o formato antigo por eficiência/objetividade, 
+# pois os prompts internos dependem principalmente dos JSONs gerados anteriormente (meta-cognição).
 def passo_justificar_bypass(p1: Dict) -> Dict:
     logger.log("⚡ FAST PATH: GERANDO JUSTIFICATIVA", "TASK")
     return chamar_gemini_json(COUNSELOR_MODEL_NAME, PROMPTS["JUSTIFICAR_BYPASS"].format(p1=json.dumps(p1)))
-def passo_2_cenarios(pergunta: str, p1: Dict) -> Dict:
+
+def passo_2_cenarios(pergunta: str, p1: Dict, dna: Dict) -> Tuple[Dict, Dict]:
     logger.log("🧠 PASSO 2: GERAÇÃO DE CENÁRIOS", "TASK")
-    return chamar_gemini_json(COUNSELOR_MODEL_NAME, PROMPTS["P2_CENARIOS"].format(p1=json.dumps(p1), pergunta=pergunta))
-def passo_4_cruzar_validacoes(p1: Dict, p2: Dict, p3: Dict) -> Dict:
+    # Apenas o prompt da tarefa: Não passamos histórico para focar no JSON de meta-cognição
+    p2 = chamar_gemini_json(COUNSELOR_MODEL_NAME, PROMPTS["P2_CENARIOS"].format(p1=json.dumps(p1), pergunta=pergunta))
+    dna["P2_data"] = p2
+    return p2, dna
+
+# ... (outros passos com chamadas inalteradas: passo_4_cruzar_validacoes, passo_5_lacunas_finais, passo_8_verificar, e os simulados)
+def passo_4_cruzar_validacoes(p1: Dict, p2: Dict, p3: Dict, dna: Dict) -> Tuple[Dict, Dict]:
     logger.log("🧠 PASSO 4: IDENTIFICAÇÃO DO PRINCÍPIO CENTRAL", "TASK")
-    return chamar_gemini_json(COUNSELOR_MODEL_NAME, PROMPTS["P4_CRUZAR_VALIDACOES"].format(p1=json.dumps(p1), p2=json.dumps(p2), p3=json.dumps(p3)))
-def passo_5_lacunas_finais(pergunta: str, p4: Dict) -> Dict:
+    p4 = chamar_gemini_json(COUNSELOR_MODEL_NAME, PROMPTS["P4_CRUZAR_VALIDACOES"].format(p1=json.dumps(p1), p2=json.dumps(p2), p3=json.dumps(p3)))
+    dna["P4_data"] = p4
+    return p4, dna
+def passo_5_lacunas_finais(pergunta: str, p4: Dict, dna: Dict) -> Tuple[Dict, Dict]:
     logger.log("🧠 PASSO 5: ANÁLISE DE INCERTEZA", "TASK")
-    return chamar_gemini_json(COUNSELOR_MODEL_NAME, PROMPTS["P5_LACUNAS_FINAIS"].format(p4=json.dumps(p4), pergunta=pergunta))
-def passo_8_verificar(resposta_a_verificar: str) -> Dict:
+    p5 = chamar_gemini_json(COUNSELOR_MODEL_NAME, PROMPTS["P5_LACUNAS_FINAIS"].format(p4=json.dumps(p4), pergunta=pergunta))
+    dna["P5_data"] = p5
+    return p5, dna
+def passo_8_verificar(resposta_a_verificar: str, dna: Dict) -> Tuple[Dict, Dict]:
     logger.log("✅ PASSO 8: VERIFICAÇÃO FINAL", "TASK")
-    return chamar_gemini_json(SUPERVISOR_MODEL_NAME, PROMPTS["P8_VERIFICAR"].format(resposta_a_verificar=resposta_a_verificar))
+    # Passamos o histórico aqui apenas para fins de contextuação na checagem final.
+    p8 = chamar_gemini_json(SUPERVISOR_MODEL_NAME, PROMPTS["P8_VERIFICAR"].format(resposta_a_verificar=resposta_a_verificar))
+    dna["P8_data"] = p8
+    return p8, dna
+
 def passo_3_isolar_cenarios(p2: Dict) -> Dict: return {"simulado": True}
 def passo_6_ponderar(p2: Dict, p4: Dict, p5: Dict) -> Dict: return {"simulado": True}
-def passo_7_sintetizar(p6: Dict) -> Dict: return {"resposta": "Resposta vinda da pipeline completa."}
-
-# ============================================================================
-# 5. ORQUESTRADOR PRINCIPAL
-# ============================================================================
+def passo_7_sintetizar(p6: Dict) -> Dict: return {"resposta": "Resposta sintetizada vinda da pipeline completa (simulado)."}
 
-def iniciar_nova_pipeline(pergunta_original: str, historico: List[Dict], anexo: Any, dna: Dict) -> Tuple[str, List, Dict]:
+def iniciar_nova_pipeline(pergunta_original: str, historico: List[Dict], anexo: Any, dna: Dict, historico_memoria: List[types.Content]) -> Tuple[str, List, Dict]: # <--- historico_memoria adicionado
+    # (Lógica de orquestrador, atualizada com historico_memoria)
     pergunta = sanitizar_texto(pergunta_original)
-    logger.log(f"INICIANDO NOVA PIPELINE (Input Sanitizado): '{pergunta[:70]}...'", "START")
     
-    p1 = passo_1_triagem(pergunta)
+    # PASSO 1
+    p1, dna = passo_1_triagem(pergunta, dna, historico_memoria) # <--- PASSANDO MEMÓRIA
     if "erro" in p1: return f"Erro na Triagem: {p1.get('detalhes', 'Não foi possível classificar a pergunta.')}", historico, dna
 
+    # FAST PATH / FULL PATH
     if p1.get("decisao") == "responder_direto":
-        logger.log("DECISÃO: Tomar o Caminho Rápido (Bypass).", "INFO")
-        resposta_direta_data = passo_gerar_resposta_direta(pergunta)
+        
+        # Gerar e Justificar
+        resposta_direta_data = passo_gerar_resposta_direta(pergunta, historico_memoria) # <--- PASSANDO MEMÓRIA
         justificativa_data = passo_justificar_bypass(p1)
 
-        if "erro" in resposta_direta_data or "erro" in justificativa_data: return "Erro ao gerar a resposta direta.", historico, dna
+        if "erro" in resposta_direta_data: 
+             return f"Erro ao gerar a resposta direta: {resposta_direta_data['detalhes']}", historico, dna
+
+        # P8, Justificativa e Consolidação...
+        # ... (consolidação final da resposta é a mesma)
         
         resposta_direta = resposta_direta_data.get("resposta_direta", "Não foi possível gerar a resposta.")
         justificativa = justificativa_data.get("justificativa_bypass", {})
-        verificacao = passo_8_verificar(resposta_direta)
-        resposta_final = verificacao.get("resposta_corrigida") or resposta_direta
         
-        justificativa_texto = f"**JUSTIFICATIVA DE RESPOSTA DIRETA:**\n- **Motivo:** {justificativa.get('motivo', 'N/A')}\n- **Ação:** {justificativa.get('acao_tomada', 'N/A')}\n\n---\n"
+        verificacao, dna = passo_8_verificar(resposta_direta, dna)
+        resposta_final = verificacao.get("resposta_corrigida") or resposta_direta
+        justificativa_texto = f"**JUSTIFICATIVA DE RESPOSTA DIRETA:**\n- **Tipo/Confiança (P1):** {p1.get('tipo', 'N/A')}/{p1.get('confianca', 'N/A')}\n- **Motivo:** {justificativa.get('motivo', 'N/A')}\n\n---\n"
         resposta_formatada = justificativa_texto + resposta_final
         
         novo_historico = historico + [{"role": "user", "content": pergunta_original}, {"role": "assistant", "content": resposta_formatada}]
-        logger.log("PIPELINE (FAST PATH) CONCLUÍDA", "SUCCESS")
+        
+        # --- ATUALIZAÇÃO DO HISTÓRICO DE GOVERNANÇA ---
+        dna["historico_governanca"].append({"turno": dna['meta']['total_turnos'], "tipo": "FAST_PATH", "p1": p1, "p8": verificacao, "pergunta": pergunta_original})
+        if len(dna["historico_governanca"]) > 10: dna["historico_governanca"] = dna["historico_governanca"][-10:]
+        
         return "PIPELINE_COMPLETED", novo_historico, dna
-    else:
-        logger.log("DECISÃO: Tomar o Caminho Completo de Análise Profunda.", "INFO")
-        p2 = passo_2_cenarios(pergunta, p1)
+        
+    else: # FULL PATH
+        # ... (P2, P3, P4, P5 - Lógica inalterada - os passos P2-P5 não precisam de memória API)
+        
+        # PASSO 2, 4, 5 (chamadas com retorno pX, dna = passo_X...)
+        p2, dna = passo_2_cenarios(pergunta, p1, dna)
         p3 = passo_3_isolar_cenarios(p2)
-        p4 = passo_4_cruzar_validacoes(p1, p2, p3)
-        p5 = passo_5_lacunas_finais(pergunta, p4)
+        p4, dna = passo_4_cruzar_validacoes(p1, p2, p3, dna)
+        p5, dna = passo_5_lacunas_finais(pergunta, p4, dna)
 
         if p5.get("decisao_interna") == "questionar":
-            logger.log("INTERRUPÇÃO no P5. Salvando estado no DNA.", "WARN")
+            # ... (Lógica de Pausa inalterada)
+            # SALVAR A GOVERNANÇA ANTES DE PAUSAR:
+            dna["historico_governanca"].append({"turno": dna['meta']['total_turnos'], "tipo": "FULL_PATH_PAUSA", "p1": p1, "p5": p5, "pergunta": pergunta_original})
+            if len(dna["historico_governanca"]) > 10: dna["historico_governanca"] = dna["historico_governanca"][-10:]
+
             dna['pipeline_state'] = {"status": "paused", "paused_at_step": "P5", "saved_data": {'p1':p1, 'p2':p2, 'p3':p3, 'p4':p4, 'pergunta_original': pergunta, 'historico_original': historico}}
             pergunta_do_bot = p5.get('pergunta_chave_para_usuario', 'Preciso de mais informações.')
             historico_atualizado = historico + [{"role": "user", "content": pergunta_original}, {"role": "assistant", "content": pergunta_do_bot}]
             return "PIPELINE_PAUSED", historico_atualizado, dna
-
+        
+        # PASSO 6, 7 (Simulados)
         p6 = passo_6_ponderar(p2, p4, p5)
         p7 = passo_7_sintetizar(p6)
-        p8 = passo_8_verificar(p7.get("resposta", ""))
+        
+        # PASSO 8
+        p8, dna = passo_8_verificar(p7.get("resposta", ""), dna)
+        
         resposta_final = p8.get("resposta_corrigida") or p7.get("resposta", "Não foi possível gerar a resposta.")
         novo_historico = historico + [{"role": "user", "content": pergunta_original}, {"role": "assistant", "content": resposta_final}]
-        logger.log("PIPELINE (COMPLETA) CONCLUÍDA", "SUCCESS")
+        dna['pipeline_state']['status'] = 'completed' 
+        
+        # --- ATUALIZAÇÃO DO HISTÓRICO DE GOVERNANÇA ---
+        dna["historico_governanca"].append({"turno": dna['meta']['total_turnos'], "tipo": "FULL_PATH_CONCLUIDO", "p1": p1, "p2": p2, "p4": p4, "p5": p5, "p8": p8, "pergunta": pergunta_original})
+        if len(dna["historico_governanca"]) > 10: dna["historico_governanca"] = dna["historico_governanca"][-10:]
+        
         return "PIPELINE_COMPLETED", novo_historico, dna
 
-def resumir_pipeline(esclarecimento_usuario_original: str, dna: Dict) -> Tuple[str, List, Dict]:
-    # ... (lógica de resumir pipeline, que pode ser reativada e adaptada se necessário) ...
-    logger.log("Lógica de retomada (resumir pipeline) executada.", "INFO")
-    resposta = "A lógica de retomada foi acionada. O fluxo completo precisa ser re-implementado."
-    dna['pipeline_state']['status'] = 'completed'
-    return "PIPELINE_COMPLETED", dna['pipeline_state']['saved_data']['historico_original'] + [{"role": "user", "content": esclarecimento_usuario_original}, {"role": "assistant", "content": resposta}], dna
 
-def executar_pipeline(pergunta: str, historico: List[Dict], anexo: Any, dna: Dict) -> Tuple[str, List, Dict]:
+# ATUALIZADO: Executar pipeline agora aceita a memória.
+def executar_pipeline(pergunta: str, historico: List[Dict], anexo: Any, dna: Dict, historico_memoria: List[types.Content]) -> Tuple[str, List, Dict]:
+    # (Orquestrador de alto nível com gestão de estados)
     try:
+        # ... (contagem de turno e limpeza de Px_data para turno atual)
         if 'pipeline_state' not in dna: dna.update(criar_dna())
+        dna['meta']['total_turnos'] = dna['meta'].get('total_turnos', 0) + 1
+        
         if dna['pipeline_state']['status'] == 'paused':
             return resumir_pipeline(pergunta, dna)
-        return iniciar_nova_pipeline(pergunta, historico, anexo, dna)
+            
+        for key in ["P1_data", "P2_data", "P4_data", "P5_data", "P8_data"]:
+             dna[key] = {}
+            
+        return iniciar_nova_pipeline(pergunta, historico, anexo, dna, historico_memoria) # <--- PASSA MEMÓRIA
+        
     except Exception as e:
+        # ... (gestão de erro inalterada)
         logger.log(f"Erro catastrófico no orquestrador: {e}", "ERROR")
         resposta_erro = f"Ocorreu um erro inesperado na pipeline: {e}"
+        dna['pipeline_state']['status'] = 'error'
+        
+        # SALVAR GOVERNANÇA DE ERRO:
+        dna["historico_governanca"].append({"turno": dna['meta']['total_turnos'], "tipo": "ERRO_CATASTRÓFICO", "erro": str(e), "pergunta": pergunta})
+        if len(dna["historico_governanca"]) > 10: dna["historico_governanca"] = dna["historico_governanca"][-10:]
+
         return "PIPELINE_ERROR", historico + [{"role": "user", "content": pergunta}, {"role": "assistant", "content": resposta_erro}], dna
 
+
 # ============================================================================
-# 6. INTERFACE COM GRADIO
+# 6. INTERFACE COM GRADIO (Incluindo Expansor de Governança no Rodapé do DNA)
 # ============================================================================
-def chat_interface(pergunta: str, historico_gradio: List[List[str]], anexo: Any, dna_json_str: str) -> Tuple[List, str, str, None]:
-    # ... (lógica da interface sem alterações) ...
+
+def chat_interface(pergunta: str, historico_gradio: List[List[str]], anexo: Any, dna_json_str: str) -> Tuple[List, str, str, None, str, str, str, str, str, str, str]: # AGORA 11 RETORNOS
+    
+    # ... (Inicialização do DNA)
     try:
         dna = json.loads(dna_json_str) if dna_json_str and dna_json_str.strip() else criar_dna()
     except:
         dna = criar_dna()
         
-    historico_interno = [item for turno in historico_gradio for item in ({"role": "user", "content": turno[0]}, {"role": "assistant", "content": turno[1]}) if turno and item['content']]
-    _ , novo_historico_para_exibir, dna_atualizado = executar_pipeline(pergunta, historico_interno, anexo, dna)
+    # Converte Histórico Gradio -> Histórico Interno (para orquestrador e conversão para Gemini)
+    historico_interno = []
+    for turno in historico_gradio:
+        if turno and turno[0]: historico_interno.append({"role": "user", "content": turno[0]})
+        if turno and turno[1]: historico_interno.append({"role": "assistant", "content": turno[1]})
+
+    # --- NOVO: Histórico no formato Gemini ---
+    historico_para_gemini = to_gemini_contents(historico_interno)
+
+    # Executa a Pipeline, passando o historico_memoria para as funções de baixo nível.
+    _ , novo_historico_para_exibir, dna_atualizado = executar_pipeline(
+        pergunta, historico_interno, anexo, dna, historico_para_gemini
+    )
     
+    # ... (Conversão de novo_historico_para_exibir para novo_historico_gradio é inalterada) ...
     novo_historico_gradio = []
     for i in range(0, len(novo_historico_para_exibir), 2):
-        if i + 1 < len(novo_historico_para_exibir):
-            novo_historico_gradio.append([novo_historico_para_exibir[i]['content'], novo_historico_para_exibir[i+1]['content']])
+        user_msg = novo_historico_para_exibir[i]['content']
+        assistant_msg = novo_historico_para_exibir[i+1]['content'] if i + 1 < len(novo_historico_para_exibir) else ""
+        novo_historico_gradio.append([user_msg, assistant_msg])
+
+
+    # Prepara as Saídas de Debug/Visualização
+    dna_completo_str = json.dumps(dna_atualizado, indent=2, ensure_ascii=False)
+    p1_data_str = formatar_dna_json(dna_atualizado.get('P1_data', {}))
+    p2_data_str = formatar_dna_json(dna_atualizado.get('P2_data', {}))
+    p4_data_str = formatar_dna_json(dna_atualizado.get('P4_data', {}))
+    p5_data_str = formatar_dna_json(dna_atualizado.get('P5_data', {}))
+    p8_data_str = formatar_dna_json(dna_atualizado.get('P8_data', {}))
+    
+    # --- NOVO: Histórico de Governança para o Rodapé (11º retorno) ---
+    historico_gov_str = formatar_dna_json(dna_atualizado.get('historico_governanca', []))
+    
+    return (novo_historico_gradio, 
+            "", 
+            json.dumps(dna_atualizado, indent=2, ensure_ascii=False), # 3: dna_json_hidden (Oculto)
+            None, # 4: file_upload
+            dna_completo_str, # 5: dna_view (Completo Formatado)
+            p1_data_str,  # 6: P1
+            p2_data_str,  # 7: P2
+            p4_data_str,  # 8: P4
+            p5_data_str,  # 9: P5
+            p8_data_str,  # 10: P8
+            historico_gov_str # 11: Novo Painel de Governança
+           )
 
-    return novo_historico_gradio, "", json.dumps(dna_atualizado, indent=2, ensure_ascii=False), None
 
 if __name__ == "__main__":
+    prompts_text_inicial = get_prompts_raw_text()
+    
+    # Variáveis de Visualização (Declaradas na seção 1 do if __name__ e renderizadas na seção 2)
+    # Componentes P1-P8... inalterados aqui
+    
     with gr.Blocks(title="Pipeline v10 - Raciocínio Adaptativo", theme=gr.themes.Soft()) as demo:
-        # ... (layout do Gradio sem alterações) ...
+        # Variáveis de Visualização do Turno Atual
+        p1_out = gr.Code(label="1. TRIAGEM (P1)", language="json", interactive=False, value="{}")
+        p2_out = gr.Code(label="2. CENÁRIOS (P2)", language="json", interactive=False, value="{}")
+        p4_out = gr.Code(label="4. PRINCÍPIO (P4)", language="json", interactive=False, value="{}")
+        p5_out = gr.Code(label="5. LACUNAS/DECISÃO (P5)", language="json", interactive=False, value="{}")
+        p8_out = gr.Code(label="8. VERIFICAÇÃO (P8)", language="json", interactive=False, value="{}")
+
+        # NOVO: Variável de Visualização de Governança
+        gov_out = gr.Code(label=f"Histórico de Governança (Últimos 10 Turnos)", language="json", interactive=False, value="[]")
+
         gr.Markdown(TITLE)
-        with gr.Row():
-            with gr.Column(scale=3):
-                chatbot = gr.Chatbot(label="Chat", height=600, bubble_full_width=False)
-                input_textbox = gr.Textbox(label="Digite sua pergunta...", lines=3)
-                with gr.Row():
-                    submit_button = gr.Button("🚀 Enviar", variant="primary", scale=1)
-                    file_upload = gr.File(label="Anexar Arquivo", scale=1)
-            with gr.Column(scale=2):
-                dna_view = gr.Code(label="DNA (Estado da Conversa)", language="json", interactive=False, value=json.dumps(criar_dna(), indent=2, ensure_ascii=False))
-        dna_json_hidden = gr.Textbox(value=json.dumps(criar_dna()), visible=False)
-        submit_button.click(fn=chat_interface, inputs=[input_textbox, chatbot, file_upload, dna_json_hidden], outputs=[chatbot, input_textbox, dna_json_hidden, file_upload])
-        input_textbox.submit(fn=chat_interface, inputs=[input_textbox, chatbot, file_upload, dna_json_hidden], outputs=[chatbot, input_textbox, dna_json_hidden, file_upload])
-        dna_json_hidden.change(fn=lambda x: x, inputs=[dna_json_hidden], outputs=[dna_view])
-    demo.launch(server_name="0.0.0.0", server_port=7860, share=False)
+
+        with gr.Tab("💬 Chat e Resposta"):
+            with gr.Row():
+                with gr.Column(scale=3):
+                    chatbot = gr.Chatbot(label="Chat", height=500, bubble_full_width=False)
+                    input_textbox = gr.Textbox(label="Digite sua pergunta...", lines=3)
+                    with gr.Row():
+                        submit_button = gr.Button("🚀 Enviar", variant="primary", scale=1)
+                        file_upload = gr.File(label="Anexar Arquivo", scale=1)
+
+                with gr.Column(scale=2):
+                    # Elementos de DNA (Oculto + Visível)
+                    dna_json_hidden = gr.Textbox(value=json.dumps(criar_dna()), visible=False)
+                    dna_view = gr.Code(label="DNA (Estado Completo da Conversa/Meta-Dados)", language="json", interactive=False, value=json.dumps(criar_dna(), indent=2, ensure_ascii=False))
+                    
+                    # --- NOVO: Grupo Expansível para Governança ---
+                    with gr.Group():
+                        with gr.Accordion("📜 Ver Histórico de Governança", open=False):
+                            gov_out.render()
+
+
+        with gr.Tab("🛠️ Debug da Pipeline"):
+             gr.Markdown("## Visualização JSON por Passo do TURNO ATUAL")
+             with gr.Row():
+                 p1_out.render() # 1. P1 - Triagem
+                 p2_out.render() # 2. P2 - Geração de Cenários
+             with gr.Row():
+                 p4_out.render() # 4. P4 - Princípio Central
+                 p5_out.render() # 5. P5 - Lacunas/Decisão (Pausa)
+             with gr.Row():
+                 p8_out.render() # 8. P8 - Verificação Final
+
+        with gr.Tab("📝 Editor de Prompts"):
+            # ... (Lógica de editor inalterada)
+             gr.Markdown(f"## Editor Dinâmico de Prompts ({PROMPT_FILENAME})")
+             prompts_editor = gr.Code(label="Conteúdo do JSON de Prompts", language="json", value=prompts_text_inicial, interactive=True, lines=30)
+             save_button = gr.Button("💾 SALVAR E RECARREGAR PROMPTS NO SERVIDOR", variant="stop")
+             save_status = gr.Textbox(label="Status do Servidor", interactive=False)
+             
+             save_button.click(fn=salvar_e_recarregar_prompts, inputs=[prompts_editor], outputs=[save_status])
+
+
+        # Ações do Botão/Entrada do Chat (Incluindo novo retorno: gov_out)
+        fn_args = {
+            "fn": chat_interface, 
+            "inputs": [input_textbox, chatbot, file_upload, dna_json_hidden], 
+            "outputs": [chatbot, 
+                        input_textbox, 
+                        dna_json_hidden, 
+                        file_upload,
+                        dna_view,    # 5
+                        p1_out,      # 6
+                        p2_out,      # 7
+                        p4_out,      # 8
+                        p5_out,      # 9
+                        p8_out,      # 10
+                        gov_out      # 11 <--- NOVO
+                       ]
+        }
+        
+        submit_button.click(**fn_args)
+        input_textbox.submit(**fn_args)
+        
+    demo.launch(server_name="0.0.0.0", server_port=7860, share=False)
+---