Update app.py

app.py

@@ -1,444 +1,206 @@
+# ╔════════════════════════════════════════════════════════════════════════════╗
+# ║                 PIPELINE v22: ORQUESTRAÇÃO DE AGENTES (JSON-LIST)            ║
+# ║        O Segredo: Uma lista de instruções que governa o pensamento.        ║
+# ╚════════════════════════════════════════════════════════════════════════════╝
 
-# -*- coding: utf-8 -*-
-"""
-Pipeline v10 - CÓDIGO FINAL E COESO
-
-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, salvamento e edição dinâmica.
-- Auditoria: Histórico de Governança compactado no DNA (últimos 10 turnos).
-"""
-
-# ============================================================================
-# 1. IMPORTAÇÕES E CONFIGURAÇÃO INICIAL
-# ============================================================================
-import json
 import os
+import json
 import re
-import warnings
-from datetime import datetime
-from typing import Dict, List, Tuple, Any
-
 import gradio as gr
+import google.generativeai as genai
+
+# ==================== 1. CONFIGURAÇÃO ====================
+api_key = os.getenv("GOOGLE_API_KEY", "SUA_API_KEY_AQUI")
+genai.configure(api_key=api_key)
+
+# Modelo Flash para raciocínio rápido, Pro para redação final
+model_fast = genai.GenerativeModel("gemini-flash-latest")
+model_pro  = genai.GenerativeModel("gemini-pro-latest")
+
+# ==================== 2. O PROTOCOLO (A "ALMA" DA IA) ====================
+# É aqui que você define a inteligência. O código abaixo apenas obedece esta lista.
+# Adicione ou remova agentes aqui para mudar o comportamento do sistema.
+
+PROTOCOLO_OPERACIONAL = [
+    {
+        "nome": "ESCRIVÃO_DIGITAL",
+        "tipo_saida": "json",
+        "modelo": model_fast,
+        "missao": """
+        Leia o input do Usuário. Sua tarefa é extrair FATOS frios.
+        Extraia:
+        1. Quem são as partes (Vítima/Acusado).
+        2. Cronologia (O que aconteceu e quando).
+        3. Inventário de Provas (O que foi citado: áudio, vídeo, testemunha).
+        Retorne APENAS JSON.
+        """
+    },
+    {
+        "nome": "ANALISTA_COMPORTAMENTAL",
+        "tipo_saida": "json",
+        "modelo": model_fast,
+        "missao": """
+        Leia o input original e os fatos do Escrivão.
+        Sua tarefa é analisar o SUBTEXTO e a PSICOLOGIA.
+        1. Analise o tom de voz descrito ou transcrito.
+        2. Identifique manipulação (Gaslighting, Inversão de Culpa).
+        3. Avalie a coerência emocional (Alguém calmo demais? Alguém desesperado?).
+        Retorne APENAS JSON.
+        """
+    },
+    {
+        "nome": "AUDITOR_INVESTIGATIVO",
+        "tipo_saida": "json",
+        "modelo": model_fast,
+        "missao": """
+        Sua tarefa é encontrar a MENTIRA.
+        Cruze o depoimento do acusado (Fatos) com a análise psicológica (Comportamental).
+        Liste as contradições. Onde a versão dele não bate com a realidade do áudio/texto?
+        Retorne APENAS JSON.
+        """
+    },
+    {
+        "nome": "PROMOTOR_SENIOR",
+        "tipo_saida": "texto", # Gera o relatório final visível
+        "modelo": model_pro,   # Modelo mais potente para escrever bem
+        "missao": """
+        Escreva o PARECER TÉCNICO FINAL (Relatório Jurídico).
+        Use Markdown. Seja detalhado (+600 palavras).
+        Estrutura Obrigatória:
+        1. Cabeçalho (Data/Assunto).
+        2. Sumário dos Fatos (Baseado no Escrivão).
+        3. Análise Forense (Baseado no Analista e Auditor). Explique a manipulação.
+        4. Fundamentação Jurídica (Cite leis: Maria da Penha, Ameaça, Violência Psicológica).
+        5. Conclusão e Pedidos (Prisão? Medida Protetiva?).
+        """
+    }
+]
 
-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")
-
-# --- Classes de Utilidade: LOGGER (Movido para garantir a definição inicial) ---
-class Logger:
-    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)
-        
-# INSTÂNCIA DO LOGGER
-logger = Logger(verbose=True)
-
-# --- 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 e Memória API"
-
-# ============================================================================
-# 2. PROMPTS CENTRALIZADOS (FUNÇÕES DE CARREGAMENTO/SALVAMENTO)
-# ============================================================================
-PROMPTS = {} # Variável global para os prompts em memória
-
-# Placeholder de fallback completo (para uso direto)
-FALLBACK_PROMPTS = {
-    "P1_TRIAGEM": "METACOGNIÇÃO - TRIAGEM INICIAL.\nPERGUNTA: {pergunta}\n---\nAnalise a PERGUNTA do usuário e o histórico de conversa. Sua função é CLASSIFICAR e TOMAR UMA DECISÃO.\n\n### CRITÉRIOS DE CLASSIFICAÇÃO\n1.  **tipo**: 'factual', 'objetiva_tecnica', ou 'subjetiva_complexa'.\n2.  **confianca**: 'extrema', 'alta', 'media', 'baixa', ou 'insuficiente'.\n### DECISÃO\n-   'responder_direto': Use para 'factual' com confiança 'extrema' ou 'alta'.\n-   'analisar_profundamente': Use para todas as outras combinações.\nRETORNE JSON: {{\"tipo\": \"...\", \"confianca\": \"...\", \"decisao\": \"responder_direto|analisar_profundamente\"}}",
-    "GERAR_RESPOSTA_DIRETA": "TAREFA: Resposta Direta (Bypass).\nPERGUNTA: \"{pergunta}\"\n---\nConsiderando o histórico de conversa (memória), forneça uma resposta completa, precisa e concisa para a última PERGUNTA do usuário.\nRETORNE JSON: {{\"resposta_direta\": \"Sua resposta concisa e precisa aqui.\"}}",
-    "JUSTIFICAR_BYPASS": "METACOGNIÇÃO - JUSTIFICATIVA DE BYPASS.\nANÁLISE (P1): {p1}\n---\nJustifique, para a governança interna, por que a pipeline de raciocínio profundo foi pulada com base na Triagem P1 (JSON fornecido).\nRETORNE JSON: {{\"justificativa_bypass\": {{\"motivo\": \"A pergunta foi classificada como ... e a confiança era ....\", \"acao_tomada\": \"...\", \"proximo_passo\": \"...\", \"p1_decisao\": {p1}}}}}",
-    "P2_CENARIOS": "METACOGNIÇÃO - GERAÇÃO DE CENÁRIOS.\nANÁLISE (P1): {p1}, PERGUNTA: {pergunta}\n---\nCrie 2 cenários prováveis que VALIDAM e 2 cenários IMPROVÁVEIS que REFUTAM o princípio inerente da pergunta.\nRETORNE JSON: {{\"cenarios\": {{\"provaveis\": [\"Fato/Cenário que Valida 1\", \"Fato/Cenário que Valida 2\"], \"improvaveis\": [\"Fato/Cenário que Refuta 1\", \"Fato/Cenário que Refuta 2\"]}}, \"decisao\": \"prosseguir para as próximas validações.\"}}",
-    "P4_CRUZAR_VALIDACOES": "METACOGNIÇÃO - ABSTRAÇÃO E FUNDAMENTO.\nANÁLISES ANTERIORES: P1(Triagem): {p1}, P2(Cenários): {p2}, P3(Isolamento Simulado): {p3}\n---\nCruze as análises. Identifique o Princípio Central/Fundamento que guiará a resposta.\nRETORNE JSON: {{\"principio_central\": \"O Princípio Central da discussão é ...\", \"analise_de_inconsistencia\": \"...\", \"status_analise\": \"FUNDAMENTO_OK\"}}",
-    "P5_LACUNAS_FINAIS": "METACOGNIÇÃO - ANÁLISE DE INCERTEZA.\nPRINCÍPIO CENTRAL (P4): {p4}, PERGUNTA: {pergunta}\n---\nIdentifique a(s) lacuna(s) de informação.\n- Decisão: 'continuar' (pode resolver a incerteza) ou 'questionar' (precisa do dado do usuário).\nRETORNE JSON: {{\"pontos_de_incerteza\": [\"Detalhe 1\", \"Detalhe 2\"], \"decisao_interna\": \"questionar|continuar\", \"pergunta_chave_para_usuario\": \"Sua pergunta para o usuário (ou null se for 'continuar').\"}}",
-    "P7_SINTETIZAR": "SINTETIZADOR.\nDADOS CRÍTICOS (P6: Ponderação Final): {p6}\n---\nConverta todo o raciocínio profundo em uma RESPOSTA FINAL coesa e completa.\nRETORNE JSON: {{\"resposta\": \"Sua resposta completa aqui. Deve ser direta e refletir a profundidade da análise executada.\"}}",
-    "P8_VERIFICAR": "VERIFICADOR FINAL (SUPERVISOR DE QUALIDADE).\nRESPOSTA A VERIFICAR: {resposta_a_verificar}\n---\nRealize a verificação tripla (Factual, Lógica, Clareza). Se for necessário, corrija.\nRETORNE JSON: {{\"todas_aprovadas\": true|false, \"erros_encontrados\": \"...\", \"resposta_corrigida\": null}} (Se true) ou {{\"todas_aprovadas\": false, \"erros_encontrados\": \"...\", \"resposta_corrigida\": \"[Novo Texto Final e Corrigido].\"}} (Se false)"
-}
-
-
-def carregar_prompts_externos(filename: str = PROMPT_FILENAME) -> Dict:
-    """Carrega prompts do arquivo ou retorna o fallback."""
-    try:
-        with open(filename, 'r', encoding='utf-8') as f:
-            full_prompts = json.load(f)
-            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 
+# ==================== 3. O MOTOR (CÓDIGO AGNÓSTICO) ====================
 
-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."""
+def limpar_json(texto: str) -> dict:
+    """Garante que o JSON venha limpo, sem markdown."""
     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()
+        if "```" in texto: 
+            texto = re.search(r"```json?(.*?)```", texto, re.DOTALL).group(1)
+        return json.loads(texto.strip())
     except:
-        return json.dumps({"erro": "Não foi possível ler o arquivo."}, indent=2, ensure_ascii=False)
+        return {"conteudo_bruto": texto}
 
-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:
-        novo_dicionario = json.loads(new_prompts_json_str)
-        with open(PROMPT_FILENAME, 'w', encoding='utf-8') as f:
-            json.dump(novo_dicionario, f, indent=2, ensure_ascii=False)
-        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 CRÍTICO no servidor: Falha ao escrever o arquivo. Detalhes: {e}", "ERROR")
-        return f"❌ ERRO CRÍTICO no servidor: Falha ao escrever o arquivo. Detalhes: {e}"
-
-# INICIALIZAÇÃO OBRIGATÓRIA DA VARIÁVEL GLOBAL DE PROMPTS
-PROMPTS = carregar_prompts_externos()
-
-
-# ============================================================================
-# 3. CLASSES E FUNÇÕES HELPERS ADICIONAIS
-# ============================================================================
-def sanitizar_texto(texto: str) -> str:
-    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()
-
-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"
-        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
-
-def chamar_gemini_json(model_name: str, prompt: str, 
-                       historico_conversa: List[types.Content] = None, 
-                       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.**"
+def executar_agente(timeline: list, config: dict) -> dict:
+    """Um agente entra na sala, lê a timeline e dá sua opinião."""
+    
+    # 1. O agente recebe todo o histórico anterior como contexto
+    contexto_str = json.dumps(timeline, ensure_ascii=False, indent=2)
+    
+    prompt = f"""
+    --- CONTEXTO DO PROCESSO (TIMELINE) ---
+    {contexto_str}
+    ---------------------------------------
+    
+    VOCÊ É O AGENTE: {config['nome']}
+    SUA MISSÃO: {config['missao']}
+    
+    IMPORTANTE: Não converse. Apenas execute a missão.
+    """
+    
     try:
-        contents = historico_conversa if historico_conversa else []
-        contents.append(types.Content(role="user", parts=[types.Part.from_text(text=prompt_completo)]))
-        tools = [types.Tool(google_search=types.GoogleSearch())]
-        generate_content_config = types.GenerateContentConfig(
-            temperature=temperatura,
-            max_output_tokens=max_tokens,
-            thinking_config=types.ThinkingConfig(thinking_budget=8192), 
-            tools=tools
-        )
-        stream = CLIENT.models.generate_content_stream(model=model_name, contents=contents, config=generate_content_config)
+        # 2. Chamada à API
+        response = config['modelo'].generate_content(prompt)
+        conteudo_raw = response.text
         
-        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"}
-        
-        match = re.search(r'\{.*\}', resposta_sanitizada, re.DOTALL)
-        if match:
-            return json.loads(match.group(0))
+        # 3. Processamento da Saída
+        if config['tipo_saida'] == 'json':
+            conteudo_processado = limpar_json(conteudo_raw)
         else:
-             return json.loads(resposta_sanitizada)
-
+            conteudo_processado = conteudo_raw # Texto/Markdown
+            
+        return {
+            "role": "assistant",
+            "agent_name": config['nome'],
+            "content": conteudo_processado
+        }
+        
     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)}
+        return {"role": "system", "error": str(e)}
 
-def criar_dna() -> Dict:
-    return { 
-        "historico_governanca": [], 
-        "meta": {"total_turnos": 0}, 
-        "pipeline_state": { "status": "completed", "paused_at_step": None, "saved_data": {} },
-        "P1_data": {}, "P2_data": {}, "P4_data": {}, "P5_data": {}, "P8_data": {},
-    }
+def orquestrador(texto_usuario: str):
+    """Loop principal que roda a lista de agentes."""
+    if not texto_usuario.strip(): return "Insira um caso.", []
 
-def formatar_dna_json(data: Dict) -> str:
-    """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
-# ============================================================================
-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")
-    return chamar_gemini_json(COUNSELOR_MODEL_NAME, PROMPTS["GERAR_RESPOSTA_DIRETA"].format(pergunta=pergunta), historico_conversa=historico_memoria)
-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")
-    p2 = chamar_gemini_json(COUNSELOR_MODEL_NAME, PROMPTS["P2_CENARIOS"].format(p1=json.dumps(p1), pergunta=pergunta))
-    dna["P2_data"] = p2
-    return p2, dna
-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")
-    p8 = chamar_gemini_json(SUPERVISOR_MODEL_NAME, PROMPTS["P8_VERIFICAR"].format(resposta_a_verificar=resposta_a_verificar))
-    dna["P8_data"] = p8
-    return p8, dna
-# Simulado
-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)."}
-
-
-# ============================================================================
-# 5. ORQUESTRADOR PRINCIPAL
-# ============================================================================
-def salvar_governanca(dna: Dict, pergunta: str, tipo: str, **data) -> None:
-    """Salva o registro da iteração 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)
-    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)
+    # 1. Inicia a Timeline com a entrada do usuário
+    timeline = [
+        {"role": "user", "content": texto_usuario}
+    ]
     
-    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
+    relatorio_final = ""
 
-    # FAST PATH
-    if p1.get("decisao") == "responder_direto":
-        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
+    # 2. O Loop Mágico (Itera sobre o Protocolo)
+    for passo in PROTOCOLO_OPERACIONAL:
+        # Executa o agente atual
+        resultado = executar_agente(timeline, passo)
         
-        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
+        # Adiciona o resultado à timeline para os próximos agentes verem
+        timeline.append(resultado)
         
-        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}]
-        salvar_governanca(dna, pergunta_original, "FAST_PATH", p1=p1, p8=verificacao) 
-        return "PIPELINE_COMPLETED", novo_historico, dna
-        
-    # 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)
+        # Se for o Promotor (texto), salvamos para exibir na tela principal
+        if passo['tipo_saida'] == 'texto':
+            relatorio_final = resultado['content']
+
+    # Retorna o texto formatado e a timeline completa (JSON) para inspeção
+    return relatorio_final, timeline
 
-        if p5.get("decisao_interna") == "questionar":
-            salvar_governanca(dna, pergunta_original, "FULL_PATH_PAUSA", p1=p1, p5=p5)
-            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
+# ==================== 4. INTERFACE GRÁFICA ====================
+
+def interface():
+    with gr.Blocks(title="Orquestrador v22", theme=gr.themes.Soft()) as app:
         
-        p6 = passo_6_ponderar(p2, p4, p5)
-        p7 = passo_7_sintetizar(p6)
-        p8, dna = passo_8_verificar(p7.get("resposta", ""), dna)
+        gr.Markdown("# ⚖️ Pipeline Cognitiva: Orquestração de Agentes")
+        gr.Markdown("Este sistema não usa um prompt único. Ele usa uma cadeia de especialistas virtuais definidos em JSON.")
         
-        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' 
+        with gr.Row():
+            # Entrada
+            inp = gr.Textbox(
+                label="Dossiê do Caso (Texto/Transcrições)", 
+                lines=8, 
+                placeholder="Cole aqui o BO, depoimentos e transcrições..."
+            )
         
-        salvar_governanca(dna, pergunta_original, "FULL_PATH_CONCLUIDO", p1=p1, p2=p2, p4=p4, p5=p5, p8=p8)
-        return "PIPELINE_COMPLETED", novo_historico, dna
-
-def resumir_pipeline(esclarecimento_usuario_original: str, dna: Dict, historico_memoria: List[types.Content]) -> Tuple[str, List, Dict]:
-    # Lógica de Retomada Simulada
-    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
-
-def executar_pipeline(pergunta: str, historico: List[Dict], anexo: Any, dna: Dict, historico_memoria: List[types.Content]) -> Tuple[str, List, Dict]:
-    try:
-        if 'pipeline_state' not in dna: dna.update(criar_dna())
-        dna['meta']['total_turnos'] = dna['meta'].get('total_turnos', 0) + 1
+        btn = gr.Button("🚀 INICIAR ORQUESTRAÇÃO", variant="primary", size="lg")
         
-        if dna['pipeline_state']['status'] == 'paused':
-            return resumir_pipeline(pergunta, dna, historico_memoria)
-
-        for key in ["P1_data", "P2_data", "P4_data", "P5_data", "P8_data"]:
-             dna[key] = {}
+        with gr.Row():
+            # Saída Final (Markdown Renderizado)
+            out_relatorio = gr.Markdown(label="Parecer Final do Promotor")
             
-        return iniciar_nova_pipeline(pergunta, historico, anexo, dna, historico_memoria)
-        
-    except Exception as e:
-        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_governanca(dna, pergunta, "ERRO_CATASTRÓFICO", erro=str(e))
-        return "PIPELINE_ERROR", historico + [{"role": "user", "content": pergunta}, {"role": "assistant", "content": resposta_erro}], 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]: 
-    
-    try:
-        dna = json.loads(dna_json_str) if dna_json_str and dna_json_str.strip() else criar_dna()
-    except:
-        dna = criar_dna()
+            # Saída de Debug (O "Cérebro" da máquina)
+            out_timeline = gr.JSON(label="Timeline de Consciência (Passo a Passo)")
+            
+        btn.click(orquestrador, inp, [out_relatorio, out_timeline])
         
-    # Prepara o histórico
-    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]})
+    return app
 
-    historico_para_gemini = to_gemini_contents(historico_interno)
+# ==================== PSEUDO-CÓDIGO (DOCUMENTAÇÃO) ====================
+"""
+COMO ESTE CÓDIGO PENSA (Lógica Humanizada):
 
-    # Execução
-    _ , novo_historico_para_exibir, dna_atualizado = executar_pipeline(pergunta, historico_interno, anexo, dna, historico_para_gemini)
-    
-    # Conversão de Outputs
-    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])
+1. RECEBER(Caso) -> Cria uma Lista: [Caso]
 
-    dna_completo_str = formatar_dna_json(dna_atualizado)
-    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', {}))
-    historico_gov_str = formatar_dna_json(dna_atualizado.get('historico_governanca', []))
+2. PARA CADA Agente NA Lista_de_Instruções:
+    A. O Agente LÊ toda a Lista até agora (memória perfeita).
+    B. O Agente EXECUTA sua instrução específica (ex: "Ache mentiras").
+    C. O Agente ESCREVE sua conclusão no final da Lista.
     
-    return (novo_historico_gradio, 
-            "", 
-            json.dumps(dna_atualizado, indent=2, ensure_ascii=False), 
-            None, 
-            dna_completo_str, 
-            p1_data_str, 
-            p2_data_str,  
-            p4_data_str,  
-            p5_data_str,  
-            p8_data_str,  
-            historico_gov_str 
-           )
-
+    Exemplo Visual da Lista crescendo:
+    [
+      {User: "Ele disse que não bateu..."},
+      {Escrivão: "Fatos: Agressão dia 20..."},
+      {Psicólogo: "Tom: Ele está manipulando..."},
+      {Investigador: "Mentira detectada: Ele nega mas o áudio prova..."},
+      {Promotor: "Relatório Final: Com base na mentira detectada pelo Investigador..."}
+    ]
+
+3. EXIBIR o trabalho do último Agente (Promotor).
+"""
 
 if __name__ == "__main__":
-    prompts_text_inicial = get_prompts_raw_text()
-    
-    with gr.Blocks(title="Pipeline v10 - Raciocínio Adaptativo", theme=gr.themes.Soft()) as demo:
-        
-        
-        #gr.Markdown(TITLE)
-
-        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):
-                    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))
-                    
-                    with gr.Group():
-                        with gr.Accordion("📜 Ver Histórico de Governança", open=False):
-                            gov_out = gr.Code(label=f"Histórico de Governança (Últimos 10 Turnos)", language="json", interactive=False, value="[]")
-                            gov_out#.render()
-                            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="{}")
-                            
-
-
-        with gr.Tab("🛠️ Debug da Pipeline"):
-             gr.Markdown("## Visualização JSON por Passo do TURNO ATUAL")
-             with gr.Row():
-                 p1_out#.render()
-                 p2_out#.render()
-             with gr.Row():
-                 p4_out#.render()
-                 p5_out#.render()
-             with gr.Row():
-                 p8_out#.render()
-
-        with gr.Tab("📝 Editor de Prompts"):
-             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])
-
-
-        # Mapeamento Completo de Inputs e Outputs (11 Saídas)
-        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,    
-                        p1_out,      
-                        p2_out,      
-                        p4_out,      
-                        p5_out,      
-                        p8_out,      
-                        gov_out      
-                       ]
-        }
-        
-        submit_button.click(**fn_args)
-        input_textbox.submit(**fn_args)
-        
-    demo.launch(server_name="0.0.0.0", server_port=7860, share=False)
+    interface().launch()