Update app.py

app.py

@@ -1,14 +1,19 @@
+--- START OF FILE app.py ---
 
 # -*- coding: utf-8 -*-
 """
-Pipeline v10 - COM MEMÓRIA DA API E HISTÓRICO DE GOVERNANÇA COMPACTADO (Últimas 10).
+Pipeline v10 - CÓDIGO FINAL E COESO
 
-PRINCIPAIS ALTERAÇÕES:
--   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.
+Características:
+- Memória API: Passagem de histórico em genai.types.Content para contexto.
+- Robustez: Chamada de API V1 com correções para Tools/ThinkingConfig.
+- Prompts Dinâmicos: Carregamento e salvamento via editor Gradio.
+- Auditoria: Histórico de Governança compactado no DNA (últimos 10 turnos).
 """
-# (IMPORTAÇÕES INALTERADAS)
+
+# ============================================================================
+# 1. IMPORTAÇÕES E CONFIGURAÇÃO INICIAL
+# ============================================================================
 import json
 import os
 import re
@@ -17,6 +22,7 @@ from datetime import datetime
 from typing import Dict, List, Tuple, Any
 
 import gradio as gr
+
 from google import genai
 from google.genai import types
 
@@ -25,25 +31,94 @@ 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.")
 
 CLIENT = genai.Client(api_key=API_KEY)
+
+# --- Definição dos Modelos e Título ---
 COUNSELOR_MODEL_NAME = "gemini-2.5-pro"
 SUPERVISOR_MODEL_NAME = "gemini-2.5-pro" 
-TITLE = "# 🚀 Pipeline v10 | Governanca com Memória API"
+TITLE = "# 🚀 Pipeline v10 | Governanca e Memória API"
 
-# (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()
+# ============================================================================
+# 2. PROMPTS CENTRALIZADOS (FUNÇÕES DE CARREGAMENTO/SALVAMENTO)
+# ============================================================================
+# Define a variável global que será usada para armazenar os prompts em tempo real
+PROMPTS = {} 
+
+# Placeholder de fallback para garantir a inicialização em caso de falha de leitura
+FALLBACK_PROMPTS = {
+    "P1_TRIAGEM": "METACOGNIÇÃO - TRIAGEM INICIAL.\nPERGUNTA: {pergunta}...\nRETORNE JSON: {{\"tipo\": \"...\"}}",
+    "P2_CENARIOS": "METACOGNIÇÃO - GERAÇÃO DE CENÁRIOS.\nANÁLISE (P1): {p1}, PERGUNTA: {pergunta}...\nRETORNE JSON: {{\"cenarios\": {{\"provaveis\": [], ...}}}}",
+    "GERAR_RESPOSTA_DIRETA": "TAREFA: Resposta Direta (Bypass).\nPERGUNTA: \"{pergunta}\"...\nRETORNE JSON: {{\"resposta_direta\": \"...\"}}",
+    "JUSTIFICAR_BYPASS": "METACOGNIÇÃO - JUSTIFICATIVA DE BYPASS. ANÁLISE (P1): {p1}...\nRETORNE JSON: {{\"justificativa_bypass\": {...}}}}",
+    "P4_CRUZAR_VALIDACOES": "METACOGNIÇÃO - ABSTRAÇÃO...\nRETORNE JSON: {{\"principio_central\": \"...\"}}",
+    "P5_LACUNAS_FINAIS": "METACOGNIÇÃO - ANÁLISE DE INCERTEZA...\nRETORNE JSON: {{\"pontos_de_incerteza\": [], \"decisao_interna\": \"...\"}}",
+    "P7_SINTETIZAR": "SINTETIZADOR. DADOS (P6): {p6}...\nRETORNE JSON: {{\"resposta\": \"...\"}}",
+    "P8_VERIFICAR": "VERIFICADOR FINAL.\nRESPOSTA: {resposta_a_verificar}...\nRETORNE JSON: {{\"todas_aprovadas\": true|false, \"resposta_corrigida\": null}}"
+}
+
+def carregar_prompts_externos(filename: str = PROMPT_FILENAME) -> Dict:
+    """Carrega prompts do arquivo ou retorna o fallback se houver falha na leitura ou validação."""
+    try:
+        with open(filename, 'r', encoding='utf-8') as f:
+            full_prompts = json.load(f)
+            # Uma verificação rápida se o arquivo tem os prompts chave
+            if not all(key in full_prompts for key in FALLBACK_PROMPTS.keys()):
+                raise ValueError("O arquivo de prompts está incompleto ou malformatado.")
+                
+            logger.log(f"Prompts carregados com sucesso do arquivo: {filename}", "SUCCESS")
+            return full_prompts
+            
+    except Exception as e:
+        logger.log(f"Não foi possível carregar os prompts externos: {e}. Usando FALLBACK.", "ERROR")
+        return FALLBACK_PROMPTS 
 
+def get_prompts_raw_text(filename: str = PROMPT_FILENAME) -> str:
+    """Lê o arquivo de prompts como texto bruto para o editor do Gradio, ou retorna fallback."""
+    try:
+        if not os.path.exists(filename):
+            return json.dumps(FALLBACK_PROMPTS, indent=2, ensure_ascii=False)
+            
+        with open(filename, 'r', encoding='utf-8') as f:
+            return f.read()
+    except:
+        return json.dumps({"erro": "Não foi possível ler o arquivo."}, indent=2, ensure_ascii=False)
+
+def salvar_e_recarregar_prompts(new_prompts_json_str: str) -> str:
+    """Salva o novo JSON no arquivo e recarrega a variável PROMPTS global."""
+    global PROMPTS 
+    try:
+        # 1. Tenta carregar/validar o JSON
+        novo_dicionario = json.loads(new_prompts_json_str)
+        
+        # 2. Tenta salvar no disco
+        with open(PROMPT_FILENAME, 'w', encoding='utf-8') as f:
+            json.dump(novo_dicionario, f, indent=2, ensure_ascii=False)
+            
+        # 3. Atualiza a variável global em memória
+        PROMPTS = novo_dicionario
+        logger.log(f"Novo arquivo de prompts salvo e recarregado com sucesso.", "SUCCESS")
+        return f"✅ SUCESSO! Prompts salvos em {PROMPT_FILENAME} e variáveis em memória atualizadas. Última atualização: {datetime.now().strftime('%H:%M:%S')}."
+        
+    except json.JSONDecodeError:
+        logger.log("ERRO: O JSON enviado é inválido. Não foi possível salvar ou recarregar.", "ERROR")
+        return "❌ ERRO: O JSON enviado está malformado. Corrija o JSON antes de salvar."
+    except Exception as e:
+        logger.log(f"ERRO: Falha ao salvar ou recarregar o arquivo: {e}", "ERROR")
+        return f"❌ ERRO CRÍTICO no servidor: Falha ao escrever o arquivo. Detalhes: {e}"
+
+# INICIALIZAÇÃO OBRIGATÓRIA DA VARIÁVEL GLOBAL
+PROMPTS = carregar_prompts_externos()
 
 # ============================================================================
 # 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)
@@ -51,30 +126,43 @@ class Logger:
 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: Chama a API com Histórico de Conversa (memória nativa)
+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 limpo para a API (exclui a JUSTIFICATIVA 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/CORRIGIDO: Chamada com Memória API e ThinkingConfig
 def chamar_gemini_json(model_name: str, prompt: str, 
-                       historico_conversa: List[types.Content] = None, # <--- AGORA ACEITA HISTÓRICO
+                       historico_conversa: List[types.Content] = None, # Histórico da API para memória
                        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:
-        # 1. Monta o contents, INCLUINDO o histórico E a pergunta atual.
+        # 1. Conteúdo: Combina histórico + prompt da tarefa
         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)],
-            )
+        contents.append( 
+            types.Content(role="user", parts=[types.Part.from_text(text=prompt_completo)])
         )
 
-        # 2. Configuração (Thinking e Tools - inalterado)
+        # 2. Configuração: Tools e Pensamento (ThinkingConfig)
         tools = [types.Tool(google_search=types.GoogleSearch())]
         generate_content_config = types.GenerateContentConfig(
             temperature=temperatura,
@@ -83,11 +171,12 @@ def chamar_gemini_json(model_name: str, prompt: str,
             tools=tools
         )
 
-        # 3. Chamada de API Corrigida
+        # 3. Chamada de API Corrigida (V1 SDK)
         stream = CLIENT.models.generate_content_stream(
             model=model_name, contents=contents, config=generate_content_config
         )
-        # ... (Agregação de resposta, sanitização e extração de JSON inalterados) ...
+        
+        # 4. Processamento da Resposta
         resposta_bruta = "".join(chunk.text for chunk in stream if chunk.text)
         resposta_sanitizada = sanitizar_texto(resposta_bruta)
 
@@ -98,249 +187,220 @@ def chamar_gemini_json(model_name: str, prompt: str,
         if match:
             return json.loads(match.group(0))
         else:
+             # Tenta carregar o conteúdo restante como JSON se a expressão regular falhar
              return json.loads(resposta_sanitizada)
 
     except Exception as e:
         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_governanca": [], # <--- NOVO: Listagem das últimas 10 iterações de debug
+        "historico_governanca": [], 
         "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)
+    """Retorna um JSON formatado com dois espaços de indentação."""
     try:
         return json.dumps(data, indent=2, ensure_ascii=False)
     except:
         return f"Erro ao serializar dados: {data}"
 
 # ============================================================================
-# 4. PASSOS DA PIPELINE E 5. ORQUESTRADOR
+# 4. PASSOS DA PIPELINE
 # ============================================================================
+# OBS: O parâmetro 'historico_memoria' só é passado nas chamadas onde o contexto é CRÍTICO.
 
-# 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")
     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")
-    # 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, dna: Dict) -> Tuple[Dict, Dict]:
     logger.log("🧠 PASSO 2: GERAÇÃO DE CENÁRIOS", "TASK")
-    # Apenas o prompt da tarefa: Não passamos histórico para focar no JSON de meta-cognição
+    # Não precisa de memória, o JSON anterior é o suficiente
     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")
     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")
     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")
-    # 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
-
+    
+# Passos Simluados
 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 sintetizada vinda da pipeline completa (simulado)."}
 
-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)
+
+# ============================================================================
+# 5. ORQUESTRADOR PRINCIPAL
+# ============================================================================
+def salvar_governanca(dna: Dict, pergunta: str, tipo: str, **data) -> None:
+    """Função helper para salvar o histórico de governança."""
+    entry = {"turno": dna['meta']['total_turnos'], "timestamp": datetime.now().strftime('%H:%M:%S'), "tipo": tipo, "pergunta": pergunta, **data}
+    dna["historico_governanca"].append(entry)
+    # Mantém o histórico com o limite de 10 entradas (os últimos)
+    if len(dna["historico_governanca"]) > 10:
+        dna["historico_governanca"] = dna["historico_governanca"][-10:]
+
+def iniciar_nova_pipeline(pergunta_original: str, historico: List[Dict], anexo: Any, dna: Dict, historico_memoria: List[types.Content]) -> Tuple[str, List, Dict]: 
     pergunta = sanitizar_texto(pergunta_original)
     
     # PASSO 1
-    p1, dna = passo_1_triagem(pergunta, dna, historico_memoria) # <--- PASSANDO MEMÓRIA
+    p1, dna = passo_1_triagem(pergunta, dna, historico_memoria)
     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
+    # FAST PATH
     if p1.get("decisao") == "responder_direto":
-        
-        # Gerar e Justificar
-        resposta_direta_data = passo_gerar_resposta_direta(pergunta, historico_memoria) # <--- PASSANDO MEMÓRIA
+        resposta_direta_data = passo_gerar_resposta_direta(pergunta, historico_memoria) 
         justificativa_data = passo_justificar_bypass(p1)
-
         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)
         
+        # Consolidação
         resposta_direta = resposta_direta_data.get("resposta_direta", "Não foi possível gerar a resposta.")
         justificativa = justificativa_data.get("justificativa_bypass", {})
-        
         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}]
-        
-        # --- 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:]
-        
+        salvar_governanca(dna, pergunta_original, "FAST_PATH", p1=p1, p8=verificacao) # <-- GOVERNANÇA SALVA
         return "PIPELINE_COMPLETED", novo_historico, dna
         
-    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...)
+    # FULL PATH
+    else: 
         p2, dna = passo_2_cenarios(pergunta, p1, dna)
         p3 = passo_3_isolar_cenarios(p2)
         p4, dna = passo_4_cruzar_validacoes(p1, p2, p3, dna)
         p5, dna = passo_5_lacunas_finais(pergunta, p4, dna)
 
+        # Interrupção/Pausa
         if p5.get("decisao_interna") == "questionar":
-            # ... (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:]
-
+            salvar_governanca(dna, pergunta_original, "FULL_PATH_PAUSA", p1=p1, p5=p5) # <-- GOVERNANÇA SALVA (PAUSA)
             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)
+        # Conclusão do Full Path
         p6 = passo_6_ponderar(p2, p4, p5)
         p7 = passo_7_sintetizar(p6)
-        
-        # 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}]
         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:]
-        
+        salvar_governanca(dna, pergunta_original, "FULL_PATH_CONCLUIDO", p1=p1, p2=p2, p4=p4, p5=p5, p8=p8) # <-- GOVERNANÇA SALVA
         return "PIPELINE_COMPLETED", novo_historico, dna
 
+def resumir_pipeline(esclarecimento_usuario_original: str, dna: Dict, historico_memoria: List[types.Content]) -> Tuple[str, List, Dict]:
+    # SIMULAÇÃO: Lógica de Retomada...
+    dados_salvos = dna['pipeline_state']['saved_data']
+    resposta = "RESUMIDO! A pipeline (pausada) foi retomada com o seu esclarecimento, mas a lógica de retomada completa precisa ser implementada."
+    dna['pipeline_state']['status'] = 'completed'
+    historico_atualizado = dados_salvos['historico_original'] + [{"role": "user", "content": esclarecimento_usuario_original}, {"role": "assistant", "content": resposta}]
+    
+    salvar_governanca(dna, esclarecimento_usuario_original, "RETOMADA_SIMULADA", p_resumido=True, status="P_COMPLETED")
+    return "PIPELINE_COMPLETED", historico_atualizado, dna
+
 
-# 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
         
+        # Se pausado, retoma.
         if dna['pipeline_state']['status'] == 'paused':
-            return resumir_pipeline(pergunta, dna)
-            
+            return resumir_pipeline(pergunta, dna, historico_memoria) # <--- PASSANDO MEMÓRIA
+
+        # Limpa dados de passos anteriores para o TURNO ATUAL
         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
+        return iniciar_nova_pipeline(pergunta, historico, anexo, dna, historico_memoria) # <--- PASSANDO 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:]
-
+        salvar_governanca(dna, pergunta, "ERRO_CATASTRÓFICO", erro=str(e)) # <-- GOVERNANÇA SALVA (ERRO)
         return "PIPELINE_ERROR", historico + [{"role": "user", "content": pergunta}, {"role": "assistant", "content": resposta_erro}], dna
 
-
 # ============================================================================
-# 6. INTERFACE COM GRADIO (Incluindo Expansor de Governança no Rodapé do DNA)
+# 6. INTERFACE COM GRADIO 
 # ============================================================================
 
-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
+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]: 
     
-    # ... (Inicialização do DNA)
+    # 1. Carga do Estado (DNA)
     try:
         dna = json.loads(dna_json_str) if dna_json_str and dna_json_str.strip() else criar_dna()
     except:
         dna = criar_dna()
         
-    # Converte Histórico Gradio -> Histórico Interno (para orquestrador e conversão para Gemini)
+    # 2. Formato de Histórico para o Orquestrador/API
     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.
+    # 3. Execução
     _ , 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) ...
+    # 4. Saídas para Gradio Chat e Elementos de UI
     novo_historico_gradio = []
     for i in range(0, len(novo_historico_para_exibir), 2):
         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, 
@@ -360,18 +420,16 @@ def chat_interface(pergunta: str, historico_gradio: List[List[str]], anexo: Any,
 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:
-        # Variáveis de Visualização do Turno Atual
+        
+        # Variáveis de Visualização do Turno Atual (aba Debug)
         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
+        # Variável de Histórico de Governança (Rodapé do DNA)
         gov_out = gr.Code(label=f"Histórico de Governança (Últimos 10 Turnos)", language="json", interactive=False, value="[]")
 
         gr.Markdown(TITLE)
@@ -386,11 +444,11 @@ if __name__ == "__main__":
                         file_upload = gr.File(label="Anexar Arquivo", scale=1)
 
                 with gr.Column(scale=2):
-                    # Elementos de DNA (Oculto + Visível)
+                    # Estado Completo do 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 ---
+                    # Expansível para Governança
                     with gr.Group():
                         with gr.Accordion("📜 Ver Histórico de Governança", open=False):
                             gov_out.render()
@@ -399,16 +457,15 @@ if __name__ == "__main__":
         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
+                 p1_out.render()
+                 p2_out.render()
              with gr.Row():
-                 p4_out.render() # 4. P4 - Princípio Central
-                 p5_out.render() # 5. P5 - Lacunas/Decisão (Pausa)
+                 p4_out.render()
+                 p5_out.render()
              with gr.Row():
-                 p8_out.render() # 8. P8 - Verificação Final
+                 p8_out.render()
 
         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")
@@ -417,7 +474,7 @@ if __name__ == "__main__":
              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)
+        # Ações do Botão/Entrada do Chat
         fn_args = {
             "fn": chat_interface, 
             "inputs": [input_textbox, chatbot, file_upload, dna_json_hidden], 
@@ -425,17 +482,18 @@ if __name__ == "__main__":
                         input_textbox, 
                         dna_json_hidden, 
                         file_upload,
-                        dna_view,    # 5
+                        dna_view,    # 5: DNA Completo
                         p1_out,      # 6
                         p2_out,      # 7
                         p4_out,      # 8
                         p5_out,      # 9
                         p8_out,      # 10
-                        gov_out      # 11 <--- NOVO
+                        gov_out      # 11: Governança
                        ]
         }
         
         submit_button.click(**fn_args)
         input_textbox.submit(**fn_args)
         
-    demo.launch(server_name="0.0.0.0", server_port=7860, share=False)
+    demo.launch(server_name="0.0.0.0", server_port=7860, share=False)
+--- END OF FILE app.py ---