Upload ai_studio_code (5).py

ai_studio_code (5).py

@@ -0,0 +1,716 @@
+import os
+import json
+import time
+import hashlib
+from datetime import datetime
+from concurrent.futures import ThreadPoolExecutor, as_completed
+
+import gradio as gr
+import google.generativeai as genai
+
+# =================================================================================
+# METADADOS DO PROJETO - HACKATHON OAB 2025
+# --------------------------------------------------------------------------------
+# Desenvolvedor: Carlos Rodrigues dos Santos
+# Contato: carlex22@gmaill.com
+# GitHub: github.com/carlex22
+# Licença: GPLv3
+# --------------------------------------------------------------------------------
+# FUNÇÃO DE ORQUESTRAÇÃO, CADEIA COGNITIVA E GOVERNANÇA (Transparência Causal)
+# --------------------------------------------------------------------------------
+# O orquestrador gerencia a 'Cadeia Cognitiva' através de 'Agentes Causais',
+# onde a saída de uma Fase (JSON de contexto) alimenta a entrada da próxima.
+# Isso garante 'Transparência' e 'Governanca' por meio da:
+#
+# 1. Pipeline Estruturada: Execução sequencial das missões definidas em
+#    'protocolo.json' (Fase 0 a 7), garantindo que cada agente cumpra um papel.
+# 2. Saída Auditorável (JSON): As fases retornam um JSON padronizado para
+#    o painel 'Auditoria', permitindo rastrear o raciocínio de cada agente.
+# 3. Ponto de Controle (STOP): A Fase 0 (e a lógica da pipeline) pode solicitar
+#    input do usuário (gatilho STOP), pausando a cadeia para validar fatos
+#    críticos ou inserir contexto faltante, garantindo governança humana
+#    em momentos de alta incerteza.
+# 4. Formato Envolvente (Fase 7): A fase final (Relatório) recebe tratamento
+#    especial para apresentar a valoração de forma dinâmica e clara, conforme
+#    o propósito de valorar a dignidade humana.
+# 5. Contexto Antecipatório: Opcionalmente inclui um passo inicial com dados
+#    de 'data.txt' para estabelecer regras e 'verdades factuais' para os agentes.
+# =================================================================================
+
+
+# Dependências para PDF
+try:
+    import PyPDF2
+    PDF_SUPPORT = True
+except ImportError:
+    PDF_SUPPORT = False
+    print("⚠️  PyPDF2 não instalado. PDFs serão lidos como texto simples.")
+
+# ==================== 1. CONFIGURAÇÃO ====================
+
+api_key = os.getenv("GOOGLE_API_KEY", "SUA_API_KEY_AQUI")
+if api_key and api_key != "SUA_API_KEY_AQUI":
+    genai.configure(api_key=api_key)
+
+# Modelos do Gemini
+model_flash = genai.GenerativeModel("gemini-flash-latest")
+model_pro = genai.GenerativeModel("gemini-pro-latest")
+
+ARQUIVO_CONFIG = "protocolo.json"
+ARQUIVO_CONTEXTO_ANTECIPATORIO = "data.txt" # Arquivo com regras/verdade factual
+ARQUIVO_DOCUMENTACAO = "help.md" # Arquivo com documentação (pode ser .txt)
+PASTA_TRANSCRICOES = "transcricoes"
+PAGES_PER_CHUNK = 10
+MAX_WORKERS = 5  # Limite de chamadas paralelas
+
+os.makedirs(PASTA_TRANSCRICOES, exist_ok=True)
+
+# ==================== 2. UTILIDADES ====================
+
+# Define as constantes de autoria
+DEVS_NAME = "Carlos Rodrigues dos Santos"
+DEVS_EMAIL = "carlex22@gmaill.com"
+LICENSE_INFO = "GPLv3"
+
+def ler_arquivo_texto(arquivo_path):
+    # Função auxiliar que lê um arquivo de texto pelo caminho
+    if not os.path.exists(arquivo_path):
+        return None
+    try:
+        with open(arquivo_path, "r", encoding="utf-8") as f:
+            conteudo = f.read()
+        return conteudo
+    except: return None
+
+def carregar_protocolo():
+    """ Carrega o protocolo. Se não existir, cria um com um esqueleto limpo. """
+    return ler_arquivo_texto(ARQUIVO_CONFIG) or json.dumps(
+        [{"fase": 0, "nome": "INICIAR_ANALISE", "modelo": "flash", "tipo_saida": "json", "missao": "Leia o input do usuário e os documentos anexados. Identifique quem é a vítima, qual foi o dano (ex: Morte, Lesão Grave) e quem é o réu. Se faltarem informações críticas para uma análise de valoração (ex: os fatos do caso), defina DUVIDA_DETECTADA como true e use TESTE_REFLEXAO para perguntar ao usuário."}], 
+        indent=2, 
+        ensure_ascii=False
+    )
+
+def carregar_documentacao():
+    """ Carrega o arquivo de documentação. """
+    return ler_arquivo_texto(ARQUIVO_DOCUMENTACAO) or "Documentação não encontrada. Crie um arquivo 'help.md' ou 'help.txt' na pasta principal para exibir aqui."
+
+
+def limpar_nome_arquivo(nome):
+    # (Implementação existente)
+    nome_base = os.path.basename(nome)
+    nome_limpo = "".join([c for c in nome_base if c.isalnum() or c in (' ', '.', '_', '-')]).strip()
+    return nome_limpo + ".json"
+
+def extrair_texto_pdf(caminho_pdf):
+    # (Implementação existente)
+    try:
+        with open(caminho_pdf, 'rb') as f:
+            reader = PyPDF2.PdfReader(f)
+            paginas = []
+            for i, page in enumerate(reader.pages):
+                texto = page.extract_text()
+                paginas.append({
+                    "numero": i + 1,
+                    "texto": texto,
+                    "metadata": str(page)[:200]
+                })
+            return paginas, None
+    except Exception as e:
+        return None, str(e)
+
+
+def fragmentar_pdf(paginas, tamanho_chunk=PAGES_PER_CHUNK):
+    # (Implementação existente)
+    chunks = []
+    for i in range(0, len(paginas), tamanho_chunk):
+        chunk = paginas[i:i + tamanho_chunk]
+        num_inicio = chunk[0]["numero"]
+        num_fim = chunk[-1]["numero"]
+        
+        texto_consolidado = "\n---QUEBRA DE PÁGINA---\n".join(
+            [f"[PÁGINA {p['numero']}]\n{p['texto']}" for p in chunk]
+        )
+        
+        chunks.append({
+            "id": f"chunk_{num_inicio}_{num_fim}",
+            "paginas": f"{num_inicio}-{num_fim}",
+            "num_paginas": len(chunk),
+            "texto": texto_consolidado,
+            "metadata": [p["metadata"] for p in chunk]
+        })
+    return chunks
+
+def processar_pdf_completo(arquivo_pdf):
+    # (Implementação existente)
+    if not PDF_SUPPORT:
+        return None, "❌ PyPDF2 não disponível"
+    
+    try:
+        paginas, erro = extrair_texto_pdf(arquivo_pdf.name if hasattr(arquivo_pdf, 'name') else arquivo_pdf)
+        if erro:
+            return None, f"❌ Erro ao ler PDF: {erro}"
+        
+        chunks = fragmentar_pdf(paginas)
+        nome_arquivo = os.path.basename(arquivo_pdf.name if hasattr(arquivo_pdf, 'name') else arquivo_pdf)
+        
+        return {
+            "arquivo": nome_arquivo,
+            "total_paginas": len(paginas),
+            "total_chunks": len(chunks),
+            "chunks": chunks,
+            "tipo": "pdf"
+        }, None
+    except Exception as e:
+        return None, f"❌ Erro no processamento: {str(e)}"
+
+# A função limpar_markdown_basico foi removida, pois reativamos o render_markdown no Chatbot.
+
+
+# ==================== 3. PIPELINE DE IA ====================
+
+def transcrever_chunk(chunk_data, config_agentes):
+    # (Implementação existente)
+    modelo = model_flash
+    try:
+        if config_agentes and isinstance(config_agentes, list):
+            if config_agentes[0].get("modelo") == "pro":
+                modelo = model_pro
+    except:
+        pass
+    
+    prompt = f"""
+ANÁLISE DE DOCUMENTO (OCR/LEITURA):
+Transcreva e estruture o conteúdo das páginas {chunk_data['paginas']}.
+Texto extraído:
+{chunk_data['texto']}
+
+Retorne JSON: {{ "transcricao": "...", "objetos": ["..."], "resumo": "..." }}
+"""
+    try:
+        for tentativa in range(3):
+            try:
+                resposta = modelo.generate_content(prompt)
+                texto_resp = resposta.text.replace("```json", "").replace("```", "")
+                return json.loads(texto_resp.strip()), None
+            except Exception as inner_e:
+                if "429" in str(inner_e):
+                    time.sleep(2 * (tentativa + 1))
+                    continue
+                raise inner_e
+    except Exception as e:
+        return None, str(e)
+
+# ==================== 4. GERENCIADOR DE ARQUIVOS ====================
+
+class GerenciadorArquivos:
+    def __init__(self):
+        self.arquivos = {} 
+
+    def adicionar(self, arquivo, arquivo_id):
+        # (Implementação existente)
+        self.arquivos[arquivo_id] = {
+            "arquivo": arquivo,
+            "nome": os.path.basename(arquivo.name),
+            "status": "adicionado",
+            "processado": None,
+            "transcricao": None
+        }
+
+    def gerar_prompt_com_transcricoes(self, texto_usuario):
+        # (Implementação existente)
+        prompt = texto_usuario + "\n\n--- CONTEXTO DOS ARQUIVOS ---\n"
+        count = 0
+        for _, item in self.arquivos.items():
+            if item["status"] == "processado" and item["transcricao"]:
+                count += 1
+                trans = item["transcricao"]
+                nome = item["nome"]
+                prompt += f"\n[ARQUIVO: {nome}]\n"
+                
+                if isinstance(trans, dict) and "chunks_processados" in trans:
+                    for chunk in trans["chunks_processados"]:
+                        if chunk.get("status") == "OK":
+                            resumo = chunk.get('resumo', '')
+                            resumo = str(resumo) if resumo else ""
+                            prompt += f"Páginas {chunk['paginas']}: {resumo}\n"
+                            
+                            texto_full = chunk.get('transcricao', '')
+                            if texto_full:
+                                texto_seguro = str(texto_full)
+                                prompt += f"Trecho: {texto_seguro[:400]}...\n"
+                            else:
+                                prompt += "Trecho: (vazio)\n"
+
+                elif isinstance(trans, dict) and "conteudo" in trans:
+                    conteudo = str(trans['conteudo'])
+                    prompt += f"Conteúdo: {conteudo[:1000]}...\n"
+        
+        if count == 0:
+            prompt += "(Nenhum arquivo processado ainda)"
+        return prompt
+
+# Instância Global
+gerenciador = GerenciadorArquivos()
+
+# ==================== 5. FUNÇÕES DE ORQUESTRAÇÃO ====================
+
+def automacao_upload_processamento(files, history, config_json):
+    # (Função de processamento de arquivos)
+    if not files:
+        return history
+
+    try:
+        config_agentes = json.loads(config_json)
+    except:
+        config_agentes = []
+
+    if history is None:
+        history = []
+
+    # CORREÇÃO: [None, mensagem] -> ["", mensagem]
+    history.append(["", f"📂 **SISTEMA:** Recebi {len(files)} arquivo(s). Verificando cache e processando..."])
+    yield history
+    
+    ids_para_processar = []
+    
+    for f in files:
+        # Usa um hash do conteúdo para ID de arquivo de texto simples para melhorar o cache
+        if f.name.lower().endswith(('.txt', '.json', '.md')):
+            with open(f.name, 'r', encoding='utf-8') as file:
+                file_hash = hashlib.sha256(file.read().encode('utf-8')).hexdigest()
+            arquivo_id = f"txt_{file_hash}"
+        else:
+            arquivo_id = f"arq_{int(time.time()*1000)}_{f.name}"
+            
+        gerenciador.adicionar(f, arquivo_id)
+        ids_para_processar.append(arquivo_id)
+    
+    for arq_id in ids_para_processar:
+        item = gerenciador.arquivos[arq_id]
+        nome = item["nome"]
+        
+        # Cria um nome de cache consistente
+        nome_cache = limpar_nome_arquivo(nome)
+        caminho_cache = os.path.join(PASTA_TRANSCRICOES, nome_cache)
+        
+        # Lógica de Cache e Reprocessamento
+        if os.path.exists(caminho_cache):
+            try:
+                with open(caminho_cache, "r", encoding="utf-8") as cache_file:
+                    dados_cache = json.load(cache_file)
+                item["transcricao"] = dados_cache
+                item["status"] = "processado"
+                if nome.lower().endswith('.pdf') and "chunks_processados" in dados_cache:
+                     item["processado"] = {"tipo": "pdf", "chunks": []}
+                # CORREÇÃO: [None, mensagem] -> ["", mensagem]
+                history.append(["", f"♻️ **Cache Encontrado:** `{nome}` já foi processado. Carregando..."])
+                yield history
+                continue
+            except Exception as e:
+                # CORREÇÃO: [None, mensagem] -> ["", mensagem]
+                history.append(["", f"⚠️ Erro cache `{nome}`: {e}. Reprocessando..."])
+
+        # CORREÇÃO: [None, mensagem] -> ["", mensagem]
+        history.append(["", f"⚙️ **Processando:** `{nome}`..."])
+        yield history
+
+        if nome.lower().endswith('.pdf'):
+            if not PDF_SUPPORT:
+                # CORREÇÃO: [None, mensagem] -> ["", mensagem]
+                history.append(["", f"❌ Erro em `{nome}`: Biblioteca PDF ausente."])
+                yield history
+                continue
+
+            pdf_proc, erro = processar_pdf_completo(item["arquivo"])
+            if erro:
+                # CORREÇÃO: [None, mensagem] -> ["", mensagem]
+                history.append(["", f"❌ Erro em `{nome}`: {erro}"])
+                yield history
+                continue
+            
+            item["processado"] = pdf_proc
+            chunks = pdf_proc["chunks"]
+            total_chunks = len(chunks)
+            
+            chunks_ordenados = [None] * total_chunks
+            
+            # CORREÇÃO: [None, mensagem] -> ["", mensagem]
+            history.append(["", f"📄 `{nome}` fragmentado em {total_chunks} partes. Iniciando IA (Paralelo: {MAX_WORKERS} threads)..."])
+            yield history
+
+            with ThreadPoolExecutor(max_workers=MAX_WORKERS) as executor:
+                futures_map = {}
+                for i, chunk in enumerate(chunks):
+                    future = executor.submit(transcrever_chunk, chunk, config_agentes)
+                    futures_map[future] = i
+                
+                concluidos = 0
+                for future in as_completed(futures_map):
+                    index_original = futures_map[future]
+                    res, err = future.result()
+                    
+                    if err:
+                        chunks_ordenados[index_original] = {"status": "ERRO", "paginas": chunks[index_original]["paginas"]}
+                    else:
+                        chunks_ordenados[index_original] = {
+                            "status": "OK",
+                            "paginas": chunks[index_original]["paginas"],
+                            "transcricao": res.get("transcricao"),
+                            "resumo": res.get("resumo")
+                        }
+                    
+                    concluidos += 1
+                    if concluidos % 2 == 0 or concluidos == total_chunks:
+                        msg_base = f"📄 `{nome}`: Processando partes... ({concluidos}/{total_chunks})"
+                        history[-1][1] = msg_base
+                        yield history
+
+            dados_finais = {
+                "arquivo": nome,
+                "data_processamento": str(datetime.now()),
+                "chunks_processados": chunks_ordenados
+            }
+            
+            item["transcricao"] = dados_finais
+            item["status"] = "processado"
+            
+            try:
+                with open(caminho_cache, "w", encoding="utf-8") as f_out:
+                    json.dump(dados_finais, f_out, indent=2, ensure_ascii=False)
+                # CORREÇÃO: [None, mensagem] -> ["", mensagem]
+                history.append(["", f"💾 `{nome}` processado e salvo no cache."])
+            except Exception as e:
+                 # CORREÇÃO: [None, mensagem] -> ["", mensagem]
+                 history.append(["", f"⚠️ Erro ao salvar cache: {e}"])
+            
+            yield history
+
+        else:
+            res_content = ler_arquivo_texto(item["arquivo"].name)
+            if res_content:
+                item["processado"] = res_content
+                dados_finais = {"conteudo": res_content, "data_processamento": str(datetime.now())}
+                item["transcricao"] = dados_finais
+                item["status"] = "processado"
+                
+                with open(caminho_cache, "w", encoding="utf-8") as f_out:
+                    json.dump(dados_finais, f_out, indent=2, ensure_ascii=False)
+                
+                # CORREÇÃO: [None, mensagem] -> ["", mensagem]
+                history.append(["", f"✅ `{nome}` (Texto) lido e salvo."])
+            else:
+                # CORREÇÃO: [None, mensagem] -> ["", mensagem]
+                history.append(["", f"❌ Falha ao ler `{nome}`."])
+            yield history
+            
+    # CORREÇÃO: [None, mensagem] -> ["", mensagem]
+    history.append(["", "🏁 **Processamento de lote finalizado.** Os arquivos estão prontos para análise."])
+    yield history
+
+
+def chat_orquestrador(message, history, config_json, pipeline_state, incluir_passo_antecipatorio):
+    if pipeline_state.get("is_paused"):
+        # (Lógica de continuação após STOP)
+        history.append([message, None])
+        
+        timeline_execucao = pipeline_state["timeline"]
+        agentes_restantes = pipeline_state["remaining_agents"]
+        
+        timeline_execucao.append({
+            "passo": len(timeline_execucao) + 1,
+            "tipo": "resposta_usuario",
+            "conteudo": message
+        })
+        
+        pipeline_state["is_paused"] = False
+        
+        yield from executar_pipeline(history, timeline_execucao, agentes_restantes, pipeline_state)
+        return
+
+    # --- LÓGICA DE INÍCIO DE UMA NOVA CONVERSA ---
+    
+    # 1. Monta o Prompt de Contexto dos Arquivos
+    try:
+        prompt_contexto = gerenciador.gerar_prompt_com_transcricoes(message)
+    except Exception as e:
+        history.append([message, f"❌ Erro ao gerar contexto: {str(e)}"])
+        yield history, [], pipeline_state
+        return
+    
+    # 2. Carrega o Protocolo
+    try:
+        protocolo = json.loads(config_json)
+    except:
+        history.append([message, "❌ Erro no JSON de Configuração do Protocolo."])
+        yield history, [], pipeline_state
+        return
+
+    # CORREÇÃO: Usar None é aceitável para a primeira parte de uma nova conversa.
+    history.append([message, None])
+    
+    # 3. Lógica do Passo Antecipatório
+    timeline_execucao = []
+    agentes_a_executar = protocolo
+    
+    if incluir_passo_antecipatorio:
+        conteudo_antecipatorio = ler_arquivo_texto(ARQUIVO_CONTEXTO_ANTECIPATORIO)
+        if conteudo_antecipatorio:
+            # Injeta o contexto na timeline como o primeiro passo
+            timeline_execucao.append({
+                "passo": 1,
+                "tipo": "passo_antecipatorio_data",
+                "agente": "GOVERNANCA_INICIAL",
+                "conteudo": f"REGRAS E VERDADE FACTUAL INICIAL (data.txt):\n{conteudo_antecipatorio}"
+            })
+            # CORREÇÃO: [None, mensagem] -> ["", mensagem]
+            history.append(["", f"ℹ️ **GOVERNANÇA INICIAL:** Contexto de `{ARQUIVO_CONTEXTO_ANTECIPATORIO}` injetado na cadeia cognitiva."])
+            history[-1][1] += f"\n\nInstrução do usuário: {message}"
+        else:
+             # Se o arquivo não existe, apenas adiciona a instrução do usuário
+             history[-1][1] = f"⚠️ Instrução do usuário: {message}"
+             history[-1][1] += f"\n\n**Aviso:** Passo Antecipatório ativado, mas arquivo `{ARQUIVO_CONTEXTO_ANTECIPATORIO}` não encontrado."
+             
+        # Ajusta o número do passo inicial na timeline
+        passo_inicial_prompt = len(timeline_execucao) + 1
+    else:
+        passo_inicial_prompt = 1
+    
+    # Adiciona a instrução do usuário (com contexto de arquivos) à trilha de auditoria
+    timeline_execucao.append({"passo": passo_inicial_prompt, "tipo": "prompt_usuario_base", "conteudo": prompt_contexto})
+    
+    yield history, timeline_execucao, pipeline_state
+    
+    # Inicia a execução dos agentes
+    yield from executar_pipeline(history, timeline_execucao, agentes_a_executar, pipeline_state)
+
+
+def executar_pipeline(history, timeline_execucao, agentes_a_executar, pipeline_state):
+    # (Implementação de execução da pipeline e simulação de digitação)
+    passo_atual = len(timeline_execucao) + 1
+    
+    for i, cfg in enumerate(agentes_a_executar):
+        nome_agente = cfg.get("nome", "Agente")
+        modelo_agente = model_pro if cfg.get("modelo") == "pro" else model_flash
+        tipo_saida = cfg.get("tipo_saida", "json")
+        
+        msg_atual = history[-1][1] or ""
+        history[-1][1] = msg_atual + f"⏳ **{nome_agente}** está analisando...\n"
+        yield history, timeline_execucao, pipeline_state
+        
+        prompt_agente = f"""
+--- HISTÓRICO DA CONVERSA ATÉ AGORA ---
+{json.dumps(timeline_execucao, ensure_ascii=False, indent=2)}
+-----------------
+Sua Identidade: {nome_agente}
+Sua Missão Específica Agora: {cfg['missao']}
+Se o tipo de saída exigido for 'json', sua resposta DEVE ser APENAS o JSON.
+"""
+        
+        try:
+            inicio = time.time()
+            resp = modelo_agente.generate_content(prompt_agente)
+            texto_resp = resp.text
+            duracao = time.time() - inicio
+
+            # --- LÓGICA DE DETECÇÃO DE SAÍDA NÃO-JSON (STOP ou Relatório) ---
+            if tipo_saida == "json":
+                try:
+                    # Tenta interpretar a resposta como JSON
+                    texto_json_limpo = texto_resp.replace("```json", "").replace("```", "").strip()
+                    resposta_json = json.loads(texto_json_limpo)
+                    
+                    # 1. LÓGICA DE PAUSA (STOP)
+                    if resposta_json.get("PROXIMA_ACAO") == "PERGUNTAR_USUARIO" and resposta_json.get("DUVIDA_DETECTADA") == True:
+                        
+                        # VERIFICA REGRAS DE STOP - Fora de escopo?
+                        if "STOP:" in texto_resp:
+                            # Caso de STOP por fora do escopo
+                            stop_message = texto_resp.split("STOP:")[1].strip() if "STOP:" in texto_resp else "Análise interrompida por dúvida crítica ou tema fora de escopo."
+                            history[-1][1] = stop_message
+                            yield history, timeline_execucao, pipeline_state
+                            return 
+
+                        # Caso de STOP por dúvida crítica (regra do protocolo da Fase 0)
+                        perguntas = resposta_json.get("TESTE_REFLEXAO", {}).get("perguntas", [])
+                        
+                        # Formata a resposta STOP
+                        stop_response = "STOP: preciso que você esclareça até 3 pontos antes de continuar:\n\n"
+                        for idx, p in enumerate(perguntas):
+                             if idx < 3:
+                                stop_response += f"{idx + 1}) {p}\n"
+                        
+                        # Salva o estado atual da pipeline
+                        pipeline_state["is_paused"] = True
+                        pipeline_state["timeline"] = timeline_execucao
+                        pipeline_state["remaining_agents"] = agentes_a_executar[i+1:]
+                        
+                        # Adiciona o passo à auditoria e ao chat
+                        timeline_execucao.append({"passo": passo_atual, "tipo": "STOP_USUARIO_REQUERIDO", "agente": nome_agente, "detalhes": stop_response})
+                        
+                        # Prepara a mensagem para o usuário no chat
+                        msg_para_usuario = f"**{nome_agente}** precisa de mais informações. Por favor, responda aos pontos abaixo para seguirmos com a análise:\n\n"
+                        for idx, p in enumerate(perguntas):
+                            if idx < 3:
+                                msg_para_usuario += f"**{idx + 1})** {p}\n"
+                        
+                        msg_atual = history[-1][1].replace(f"⏳ **{nome_agente}** está analisando...\n", "")
+                        history[-1][1] = msg_atual + msg_para_usuario
+                        
+                        yield history, timeline_execucao, pipeline_state
+                        return # Sai da função para esperar o input do usuário
+                        
+                    # 2. Resposta JSON normal
+                    texto_para_auditoria = texto_json_limpo
+                    timeline_execucao.append({"passo": passo_atual, "tipo": "resposta_agente", "agente": nome_agente, "resposta": texto_para_auditoria})
+                    
+                    msg_atual = history[-1][1].replace(f"⏳ **{nome_agente}** está analisando...\n", "")
+                    novo_trecho = f"✅ **[{nome_agente}]** concluiu sua análise em ({duracao:.1f}s). (JSON para Auditoria)\n"
+                    history[-1][1] = msg_atual + novo_trecho
+                    yield history, timeline_execucao, pipeline_state
+                    
+                except json.JSONDecodeError:
+                    # Se deveria ser JSON e não é, trata como erro na auditoria
+                    timeline_execucao.append({"passo": passo_atual, "tipo": "erro_resposta_json", "agente": nome_agente, "resposta_raw": texto_resp, "erro": "Esperado JSON, mas recebeu texto não-JSON."})
+                    msg_atual = history[-1][1].replace(f"⏳ **{nome_agente}** está analisando...\n", "")
+                    history[-1][1] = msg_atual + f"❌ **[{nome_agente}]** falhou: Resposta não era JSON válido. ({duracao:.1f}s).\n"
+                    yield history, timeline_execucao, pipeline_state
+                
+            elif tipo_saida == "texto":
+                # Lógica para a Fase 7 (RELATORIO_VALOR_VIDA)
+                
+                # O markdown será renderizado pelo Chatbot, não precisa de limpeza manual.
+
+                # Adiciona o passo à auditoria
+                timeline_execucao.append({"passo": passo_atual, "tipo": "relatorio_final", "agente": nome_agente, "relatorio": texto_resp})
+                
+                # Simula a digitação envolvente
+                msg_final = f"**[RELATÓRIO FINAL DO {nome_agente}]**\n\n"
+                history[-1][1] = msg_final
+                yield history, timeline_execucao, pipeline_state
+                
+                # Divide o texto do relatório em blocos (parágrafos ou seções)
+                blocos = texto_resp.split('\n\n')
+                
+                for bloco in blocos:
+                    if bloco.strip():
+                        # Simula a digitação bloco por bloco
+                        msg_final += f"{bloco}\n\n"
+                        history[-1][1] = msg_final
+                        # Pequena pausa para o efeito dinâmico
+                        time.sleep(0.5) 
+                        yield history, timeline_execucao, pipeline_state
+                        
+                # Finalização da digitação no chat
+                msg_final += "\n\n--- FIM DO RELATÓRIO DE VALORAÇÃO ---"
+                history[-1][1] = msg_final
+                yield history, timeline_execucao, pipeline_state
+                
+            else:
+                # Caso de tipo_saida não definido (erro)
+                timeline_execucao.append({"passo": passo_atual, "tipo": "erro_config", "agente": nome_agente, "erro": "Tipo de saída não reconhecido ('json' ou 'texto')."})
+                msg_atual = history[-1][1].replace(f"⏳ **{nome_agente}** está analisando...\n", "")
+                history[-1][1] = msg_atual + f"\n❌ Erro de Configuração em {nome_agente}: Tipo de saída inválido. ({duracao:.1f}s).\n"
+                yield history, timeline_execucao, pipeline_state
+            
+        except Exception as e:
+            timeline_execucao.append({"passo": passo_atual, "tipo": "erro_agente", "agente": nome_agente, "erro": str(e)})
+            msg_atual = history[-1][1]
+            history[-1][1] = msg_atual.replace(f"⏳ **{nome_agente}** está analisando...\n", "") + f"\n❌ Erro em {nome_agente}: {str(e)}\n"
+            yield history, timeline_execucao, pipeline_state
+        
+        passo_atual += 1
+
+# ==================== 6. UI (Gradio) ====================
+
+def ui_v29_stop_logic():
+    css = """
+    footer {display: none !important;}
+    .contain {border: none !important;}
+    """
+    
+    config_inicial = carregar_protocolo()
+    documentacao = carregar_documentacao()
+    
+    # Define o objeto do tema
+    app_theme = gr.themes.Soft()
+
+    # CORREÇÃO: Removido 'css' e 'theme' do construtor gr.Blocks().
+    with gr.Blocks(title="AI Forensics Auto") as app: 
+        
+        # Estado da configuração dos agentes
+        state_config = gr.State(config_inicial)
+        # NOVO: Estado para controlar a pausa/continuação da pipeline
+        pipeline_state = gr.State({"is_paused": False, "timeline": [], "remaining_agents": []})
+
+        with gr.Tabs():
+            with gr.Tab("💬 Investigação"):
+                
+                chatbot = gr.Chatbot(
+                    height=400, 
+                    show_label=False, 
+                    # CORREÇÃO: show_copy_button foi removido, render_markdown reativado com o formato de dados corrigido.
+                    render_markdown=True,
+                    label="Chat de Investigação"
+                )
+                
+                with gr.Row():
+                    txt_input = gr.Textbox(
+                        scale=8, 
+                        show_label=False, 
+                        placeholder="Digite sua instrução ou responda à pergunta do agente...", 
+                        lines=1
+                    )
+                    btn_enviar = gr.Button("Enviar 📨", variant="primary", scale=1)
+                
+                # Caixa de Opções Avançadas
+                with gr.Accordion("⚙️ Opções Avançadas de Governança", open=False):
+                    chk_antecipatorio = gr.Checkbox(
+                        label=f"Incluir Contexto Antecipatório (`{ARQUIVO_CONTEXTO_ANTECIPATORIO}`) no início da análise (Recomendado).",
+                        value=True, # Ativado por padrão
+                        show_label=True
+                    )
+
+                with gr.Accordion("📂 Adicionar Arquivos para Análise", open=False):
+                    gr.Markdown("Selecione arquivos (PDF, TXT). A transcrição iniciará **automaticamente**.")
+                    file_uploader = gr.File(
+                        file_count="multiple",
+                        file_types=[".pdf", ".txt", ".json", ".md"],
+                        label="Arraste arquivos aqui ou clique para selecionar"
+                    )
+
+            with gr.Tab("🕵️ Auditoria"):
+                gr.Markdown("### Trilha de Auditoria\nExibe o histórico completo de prompts e respostas de cada agente na última execução.")
+                json_audit = gr.JSON(label="Timeline da Execução da Última Mensagem")
+
+            with gr.Tab("⚙️ Protocolo & Autoria"):
+                gr.Markdown(f"### Protocolo Causal (Diretrizes de Agentes)\nDesenvolvedor: **{DEVS_NAME}** ({DEVS_EMAIL}) | Licença: **{LICENSE_INFO}**")
+                gr.Markdown("Visualize as missões dos agentes de IA. O número de fases é totalmente configurável na estrutura JSON abaixo.")
+                code_config = gr.Code(value=config_inicial, language="json", label="protocolo.json (Visualização de Diretrizes)", interactive=False)
+            
+            with gr.Tab("📚 Documentação"):
+                gr.Markdown("### Documentação da Aplicação (help.md)")
+                gr.Markdown(documentacao)
+
+
+        # Ação de clique agora passa o novo checkbox para o orquestrador
+        btn_enviar.click(
+            chat_orquestrador,
+            inputs=[txt_input, chatbot, state_config, pipeline_state, chk_antecipatorio],
+            outputs=[chatbot, json_audit, pipeline_state]
+        ).then(
+            lambda: "", outputs=[txt_input]
+        )
+
+        file_uploader.upload(
+            automacao_upload_processamento,
+            inputs=[file_uploader, chatbot, state_config],
+            outputs=[chatbot]
+        )
+
+    # CORREÇÃO: Retorna o app, o css e o tema para serem passados para launch()
+    return app, css, app_theme
+
+if __name__ == "__main__":
+    # CORREÇÃO: Recebe o app, o css e o tema e os passa para app.launch()
+    app, css_styles, app_theme = ui_v29_stop_logic()
+    app.launch(css=css_styles, theme=app_theme)