Update app.py

app.py

@@ -1,766 +1,638 @@
+# ╔════════════════════════════════════════════════════════════════════════════╗
+# ║                  PIPELINE v38: Documentação e Refatoração                  ║
+# ╚════════════════════════════════════════════════════════════════════════════╝
+
+# ==================== RESUMO TÉCNICO DA PIPELINE ====================
+#
+# OBJETIVO PRINCIPAL: Orquestrar chamadas sequenciais a modelos Groq,
+# utilizando um protocolo de agentes (pipeline) e mantendo um contexto
+# conversacional persistente (memória). O foco é no controle de fluxo.
+#
+# INOVAÇÕES CONSOLIDADAS (ADUC-SDR):
+# 1. ARQUITETURA DE UNIÃO COMPOSITIVA (ADUC): Utiliza um contexto persistente
+#    de chat (`contexto_persistente.json`) e um protocolo sequencial de
+#    agentes (`protocolo.json`) para criar um fluxo de trabalho modular.
+# 2. ESCALA DINÂMICA RESILIENTE (SDR): O contexto é limitado dinamicamente
+#    antes de cada chamada (`limitar_timeline`) por caracteres e número de
+#    mensagens para evitar erro de `context_length_exceeded`.
+# 3. FIX "last role user": Garante que o último role da API seja sempre 'user',
+#    conforme exigido pela Groq API.
+# 4. Prefixos de Rastreamento: Uso de prefixos `[USUARIO]` e `[AGENTE nome]`
+#    no contexto persistente para rastreabilidade e clareza do histórico.
+# 5. Lógica de STOP Refinada: O agente inicial controla a execução com a
+#    palavra-chave `STOP_PIPELINE:`, cuja resposta é extraída e exibida
+#    limpa ao usuário.
+#
+# LIMITAÇÕES:
+# - Não processa arquivos de imagem/áudio (apenas texto de anexos lidos).
+# - O limite de tokens é uma estimativa por caracteres.
+#
+# ==================== AVISO LEGAL E LICENCIAMENTO ====================
+#
+# Desenvolvedor: Carlos Rodrigues dos Santos
+# GitHub: github.com/carlex22/Izaak
+# Email: Carlex22@gmail.com
+#
+# POLÍTICA DE LICENCIAMENTO: Este código-fonte é distribuído sob a Licença MIT.
+#
+# AVISO DE PATENTE PENDENTE: As inovações de Arquitetura de União Compositiva
+# e Escala Dinâmica Resiliente (ADUC-SDR), essenciais para a orquestração
+# causal, estão com processo de patente pendente no Brasil e internacionalmente.
+# O uso comercial, replicação, ou incorporação dessas inovações sem autorização
+# expressa está sujeito a legislação de propriedade intelectual.
+#
+# =====================================================================
+
 import os
 import json
+import re
 import time
-import hashlib
 from datetime import datetime
-from concurrent.futures import ThreadPoolExecutor, as_completed
-
 import gradio as gr
 from groq import Groq
 
-# ... (Metadados e outras configurações permanecem iguais) ...
-
-# =================================================================================
-# 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 ====================
+groq_key = os.getenv("GROQ_API_KEY", "SUA_GROQ_KEY_AQUI")
+groq_client = Groq(api_key=groq_key)
 
-try:
-    groq_client = Groq(api_key=os.environ.get("GROQ_API_KEY"))
-    print("✅ Cliente Groq inicializado com sucesso.")
-except Exception as e:
-    groq_client = None
-    print(f"❌ Erro ao inicializar o cliente Groq. Verifique sua API Key: {e}")
-
-GROQ_MODELS = {
-    "flash": "llama3-8b-8192",
-    "pro": "llama3-70b-8192"
-}
-
+# Arquivos de persistência e configuração
 ARQUIVO_CONFIG = "protocolo.json"
-ARQUIVO_CONTEXTO_ANTECIPATORIO = "data.txt" 
-ARQUIVO_DOCUMENTACAO = "help.md" 
-PASTA_TRANSCRICOES = "transcricoes"
-PAGES_PER_CHUNK = 10
-MAX_WORKERS = 5
+ARQUIVO_HELP = "help.md"
+ARQUIVO_CONTEXTO = "contexto_persistente.json"
+DELAY_ENTRE_AGENTES = 1  # Delay para feedback visual
+STOP_KEYWORD = "STOP_PIPELINE" # Palavra-chave para interrupção do pipeline
 
-os.makedirs(PASTA_TRANSCRICOES, exist_ok=True)
+print("🚀 App inicializada - GROQ v38 + CONTEXTO PERSISTENTE")
+print(f"  ✅ Groq: {'OK' if groq_key != 'SUA_GROQ_KEY_AQUI' else '⚠️ placeholder'}")
 
-# ... (Seção 2. UTILIDADES e 3. PIPELINE DE IA permanecem as mesmas) ...
 # ==================== 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 estimar_tokens(texto):
+    """
+    Estimativa rápida de tokens.
+    Método: ~4 caracteres = 1 token (aproximação heurística).
+    """
+    return len(str(texto)) // 4
 
 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)
+    """Lê e retorna o conteúdo do protocolo de agentes em formato JSON."""
     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
+        with open(ARQUIVO_CONFIG, "r", encoding="utf-8") as f:
+            return f.read()
     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
+        print(f"❌ Erro carregar_protocolo: {e}")
+        return "[]"
 
-def processar_pdf_completo(arquivo_pdf):
-    # (Implementação existente)
-    if not PDF_SUPPORT:
-        return None, "❌ PyPDF2 não disponível"
-    
+def salvar_protocolo(conteudo):
+    """Salva o conteúdo JSON do protocolo no arquivo de configuração."""
     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
+        # Tenta validar o JSON antes de salvar
+        json.loads(conteudo)
+        with open(ARQUIVO_CONFIG, "w", encoding="utf-8") as f:
+            f.write(conteudo)
+        print(f"💾 Protocolo salvo: {len(json.loads(conteudo))} agentes")
+        return "✅ Protocolo salvo com sucesso"
     except Exception as e:
-        return None, f"❌ Erro no processamento: {str(e)}"
+        print(f"❌ Erro salvar_protocolo: {e}")
+        return f"❌ Erro JSON: {str(e)}"
 
-# ==================== 3. PIPELINE DE IA ====================
-
-def transcrever_chunk(chunk_data, config_agentes):
-    # ### ALTERADO ### - Função adaptada para usar a API da Groq
-    if not groq_client:
-        return None, "Cliente Groq não inicializado."
+def carregar_help():
+    """Lê e retorna o conteúdo do arquivo de ajuda."""
+    try:
+        with open(ARQUIVO_HELP, "r", encoding="utf-8") as f:
+            return f.read()
+    except:
+        return "# Help não encontrado\n\nCrie um arquivo help.md na raiz do projeto."
 
-    modelo_groq = GROQ_MODELS["flash"] # Usa sempre o modelo mais rápido para transcrição
-    
-    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']}
+def carregar_contexto_persistente():
+    """Carrega o histórico de mensagens persistentes do arquivo JSON."""
+    try:
+        with open(ARQUIVO_CONTEXTO, "r", encoding="utf-8") as f:
+            return json.load(f)
+    except:
+        print("📝 Contexto persistente vazio, iniciando novo")
+        return []
 
-Retorne APENAS o JSON com a seguinte estrutura: {{ "transcricao": "...", "objetos": ["..."], "resumo": "..." }}
-"""
+def salvar_contexto_persistente(contexto):
+    """Salva o contexto persistente (histórico de mensagens) no arquivo JSON."""
     try:
-        for tentativa in range(3):
-            try:
-                chat_completion = groq_client.chat.completions.create(
-                    messages=[{"role": "user", "content": prompt}],
-                    model=modelo_groq,
-                    temperature=0.1,
-                    max_tokens=4096,
-                )
-                texto_resp = chat_completion.choices[0].message.content
-                texto_limpo = texto_resp.replace("```json", "").replace("```", "").strip()
-                return json.loads(texto_limpo), None
-            except Exception as inner_e:
-                if "429" in str(inner_e): # Lida com Rate Limiting
-                    time.sleep(2 * (tentativa + 1))
-                    continue
-                raise inner_e
+        with open(ARQUIVO_CONTEXTO, "w", encoding="utf-8") as f:
+            json.dump(contexto, f, ensure_ascii=False, indent=2)
+        print(f"💾 Contexto persistente salvo: {len(contexto)} mensagens")
     except Exception as e:
-        return None, str(e)
-
-# ... (Seção 4. GERENCIADOR DE ARQUIVOS permanece a mesma) ...
-
-# ==================== 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
-        }
+        print(f"❌ Erro salvar contexto: {e}")
 
-    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"
+def limpar_contexto_persistente():
+    """Apaga o conteúdo do contexto persistente, iniciando uma nova memória."""
+    try:
+        with open(ARQUIVO_CONTEXTO, "w", encoding="utf-8") as f:
+            json.dump([], f)
+        print("🗑️ Contexto persistente limpo")
+        return "✅ Contexto limpo com sucesso"
+    except Exception as e:
+        return f"❌ Erro: {str(e)}"
 
-                elif isinstance(trans, dict) and "conteudo" in trans:
-                    conteudo = str(trans['conteudo'])
-                    prompt += f"Conteúdo: {conteudo[:1000]}...\n"
+def limitar_timeline(timeline, max_chars=12000, max_msgs=12):
+    """
+    Função de Escala Dinâmica Resiliente (SDR).
+    Limita o contexto (timeline) para manter o modelo dentro do orçamento de tokens.
+    Prioriza as mensagens mais recentes.
+    """
+    acumulado = 0
+    selecionadas = []
+    # Itera de trás para frente (mensagens mais recentes)
+    for msg in reversed(timeline):
+        texto = str(msg.get("content", ""))
+        acumulado += len(texto)
+        # Condição de parada: limite de chars ou número máximo de mensagens
+        if acumulado > max_chars or len(selecionadas) >= max_msgs:
+            break
+        selecionadas.append(msg)
         
-        if count == 0:
-            prompt += "(Nenhum arquivo processado ainda)"
-        return prompt
-
-# Instância Global
-gerenciador = GerenciadorArquivos()
-
-# ==================== 5. FUNÇÕES DE ORQUESTRAÇÃO ====================
-# ... (automacao_upload_processamento permanece a mesma) ...
-
-def automacao_upload_processamento(files, history, config_json):
-    # (Função de processamento de arquivos)
-    if not files:
-        return history
-    
-    if not groq_client:
-        history.append([None, "⚠️ **SISTEMA:** Cliente Groq não configurado. Verifique a API Key e reinicie a aplicação."])
-        yield history
-        return
-
+    selecionadas.reverse() # Reverte para a ordem cronológica
+    tokens_est = estimar_tokens(acumulado)
+    print(f"✂️ Timeline limitada: {len(selecionadas)} msgs, {acumulado} chars (~{tokens_est} tokens)")
+    return selecionadas, acumulado, tokens_est
+
+def ler_anexo(arquivo):
+    """Lê o conteúdo textual de um arquivo anexado e o formata com marcadores."""
+    if arquivo is None:
+        return ""
     try:
-        config_agentes = json.loads(config_json)
-    except:
-        config_agentes = []
-
-    if history is None:
-        history = []
-
-    history.append([None, 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)
+        with open(arquivo.name, "r", encoding="utf-8") as f:
+            conteudo = f.read()
+            print(f"📎 Anexo lido: {os.path.basename(arquivo.name)} ({len(conteudo)} chars)")
+            # Retorna o conteúdo formatado com marcadores para clareza do LLM
+            return f"\n\n[ANEXO: {os.path.basename(arquivo.name)}]\n{conteudo}\n[FIM ANEXO]\n"
+    except Exception as e:
+        print(f"❌ Erro ler_anexo {arquivo.name}: {e}")
+        return ""
+
+def verificar_stop(texto):
+    """Verifica se a palavra-chave de parada (STOP_PIPELINE:) está presente no output."""
+    if not texto:
+        return False
+    # Busca pela palavra-chave de parada
+    stop_detectado = bool(re.search(r'\b' + re.escape(STOP_KEYWORD) + r'\b', str(texto), re.IGNORECASE))
+    print(f"🛑 STOP detectado? {stop_detectado} em '{str(texto)[:100]}...'")
+    return stop_detectado
+
+# ==================== 3. ENGINE DE EXECUÇÃO (GROQ) ====================
+def executar_no(timeline, config):
+    """
+    Chama a API da Groq com o modelo e a timeline (contexto) definidos.
+    Gerencia o formato das mensagens, tokens e tratamento de streaming/erros.
+    """
+    print(f"\n🔥 === EXECUTANDO {config['nome']} ===")
+    modelo = config.get('modelo', 'meta-llama/llama-4-maverick-17b-128e-instruct')
+    print(f"   Modelo Groq: {modelo}")
     
-    for arq_id in ids_para_processar:
-        item = gerenciador.arquivos[arq_id]
-        nome = item["nome"]
+    try:
+        inicio = time.time()
         
-        # Cria um nome de cache consistente
-        nome_cache = limpar_nome_arquivo(nome)
-        caminho_cache = os.path.join(PASTA_TRANSCRICOES, nome_cache)
+        # 1. Limita o contexto
+        timeline_limited, chars_total, tokens_est = limitar_timeline(timeline, max_chars=12000, max_msgs=12)
         
-        # 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": []}
-                history.append([None, f"♻️ **Cache Encontrado:** `{nome}` já foi processado. Carregando..."])
-                yield history
-                continue
-            except Exception as e:
-                history.append([None, f"⚠️ Erro cache `{nome}`: {e}. Reprocessando..."])
-
-        history.append([None, f"⚙️ **Processando:** `{nome}`..."])
-        yield history
-
-        if nome.lower().endswith('.pdf'):
-            if not PDF_SUPPORT:
-                history.append([None, f"❌ Erro em `{nome}`: Biblioteca PDF ausente."])
-                yield history
-                continue
-
-            pdf_proc, erro = processar_pdf_completo(item["arquivo"])
-            if erro:
-                history.append([None, 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
-            
-            history.append([None, 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"
-            
+        # 2. Converte timeline para formato messages do Groq
+        messages = []
+        
+        # System message com missão do agente
+        system_msg = f"AGENTE: {config['nome']}\nMISSÃO: {config['missao']}"
+        messages.append({
+            "role": "system",
+            "content": system_msg
+        })
+        tokens_system = estimar_tokens(system_msg)
+        
+        # Adiciona timeline como contexto
+        for msg in timeline_limited:
+            role = msg.get('role')
+            if role in ['user', 'assistant']:
+                content = msg.get('content', '')
+                # Serializa JSON/List para string se necessário
+                if isinstance(content, (dict, list)):
+                    content = json.dumps(content, ensure_ascii=False)
+                messages.append({
+                    "role": role,
+                    "content": str(content)
+                })
+        
+        # 3. FIX: Garante que última mensagem seja sempre 'user'
+        user_prompt_final = (
+            f"Com base em TODO o contexto acima e na missão do agente '{config['nome']}', "
+            f"execute a missão agora e produza APENAS a saída esperada para este agente."
+        )
+        messages.append({
+            "role": "user",
+            "content": user_prompt_final
+        })
+        tokens_user_final = estimar_tokens(user_prompt_final)
+        
+        tokens_total = tokens_est + tokens_system + tokens_user_final
+        print(f"📤 Groq messages: {len(messages)} mensagens (última=user, OK)")
+        print(f"📊 Tokens estimados: ~{tokens_total} (system: {tokens_system} + context: {tokens_est} + user_final: {tokens_user_final})")
+        
+        # 4. Chama Groq API com streaming
+        completion = groq_client.chat.completions.create(
+            model=modelo,
+            messages=messages,
+            temperature=1,
+            max_completion_tokens=6048,
+            top_p=1,
+            stream=True,
+            stop=None
+        )
+        
+        # 5. Coleta resposta em streaming
+        out_raw = ""
+        for chunk in completion:
+            content_chunk = chunk.choices[0].delta.content or ""
+            out_raw += content_chunk
+        
+        tempo_exec = time.time() - inicio
+        tokens_resposta = estimar_tokens(out_raw)
+        
+        print(f"📥 OUTPUT GROQ ({len(out_raw)} chars, ~{tokens_resposta} tokens, {tempo_exec:.2f}s):")
+        print(out_raw[:500])
+        print("..." if len(out_raw) > 500 else "")
+        
+        # 6. Parse JSON se necessário
+        content = out_raw
+        if config.get('tipo_saida', 'texto').lower() in ['json', 'jshon']:
             try:
-                with open(caminho_cache, "w", encoding="utf-8") as f_out:
-                    json.dump(dados_finais, f_out, indent=2, ensure_ascii=False)
-                history.append([None, f"💾 `{nome}` processado e salvo no cache."])
-            except Exception as e:
-                 history.append([None, 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"
+                # Lógica de limpeza para extrair JSON de blocos de código
+                cleaned = out_raw.strip()
+                if cleaned.startswith("```"):
+                    cleaned = re.sub(r'^```json\s*', '', cleaned)
+                    cleaned = re.sub(r'^```', '', cleaned)
+                    cleaned = re.sub(r'\s*```$', '', cleaned)
                 
-                with open(caminho_cache, "w", encoding="utf-8") as f_out:
-                    json.dump(dados_finais, f_out, indent=2, ensure_ascii=False)
-                
-                history.append([None, f"✅ `{nome}` (Texto) lido e salvo."])
-            else:
-                history.append([None, f"❌ Falha ao ler `{nome}`."])
-            yield history
-            
-    history.append([None, "🏁 **Processamento de lote finalizado.** Os arquivos estão prontos para análise."])
-    yield history
-
-# ### ALTERADO ### - Função principal do chat com a nova lógica de inicialização
-def chat_orquestrador(message, history, system_prompt, config_json, pipeline_state, incluir_passo_antecipatorio):
-    if not groq_client:
-        history.append([message, "⚠️ **SISTEMA:** Cliente Groq não configurado. Verifique a API Key."])
-        yield history, [], pipeline_state
-        return
-    
-    # ### NOVO ### - LÓGICA DE INICIALIZAÇÃO (APENAS NA PRIMEIRA MENSAGEM)
-    if not history:
-        try:
-            # Pega o contexto dos arquivos já processados (sem mensagem de usuário ainda)
-            contexto_arquivos = gerenciador.gerar_prompt_com_transcricoes("")
-            
-            # Monta o prompt de inicialização especial
-            prompt_inicial = f"""
-Você é um assistente de IA especializado. Seu objetivo principal foi definido como: "{system_prompt}".
-
-Você acabou de ser inicializado e recebeu alguns documentos para análise prévia. O resumo do conteúdo desses documentos é:
-{contexto_arquivos}
-
-Sua primeira tarefa é enviar uma mensagem de boas-vindas ao usuário. Nesta mensagem, você DEVE:
-1. Confirmar que entendeu seu objetivo, resumindo-o com suas próprias palavras.
-2. Informar de forma muito breve o que você compreendeu a partir dos arquivos iniciais.
-3. Se apresentar de forma profissional e se colocar à disposição para iniciar a análise detalhada.
-
-Responda diretamente ao usuário em um tom prestativo e competente.
-"""
-            
-            # Cria a primeira entrada na timeline de auditoria
-            timeline_execucao = [{
-                "passo": 1,
-                "tipo": "inicializacao_sistema",
-                "objetivo_global": system_prompt,
-                "prompt_enviado": prompt_inicial
-            }]
-            
-            # Faz a chamada de streaming para a Groq
-            stream = groq_client.chat.completions.create(
-                messages=[{"role": "user", "content": prompt_inicial}],
-                model=GROQ_MODELS["pro"], # Usa o modelo mais forte para a primeira impressão
-                temperature=0.5,
-                max_tokens=2048,
-                stream=True,
-            )
-            
-            # Adiciona um placeholder na "history" para a resposta da IA
-            history.append([None, ""])
-            resposta_completa = ""
-            
-            for chunk in stream:
-                delta = chunk.choices[0].delta.content or ""
-                if delta:
-                    resposta_completa += delta
-                    history[-1][1] = resposta_completa # Atualiza a resposta no chat
-                    yield history, timeline_execucao, pipeline_state
-
-            # Adiciona a resposta final à auditoria
-            timeline_execucao[0]["resposta_ia"] = resposta_completa
-            yield history, timeline_execucao, pipeline_state
-            return # Encerra a execução aqui, pois foi apenas a inicialização
-
-        except Exception as e:
-            history.append([None, f"❌ Erro durante a inicialização: {str(e)}"])
-            yield history, [], pipeline_state
-            return
-
-    # --- FLUXO NORMAL PARA MENSAGENS SUBSEQUENTES ---
-    
-    if pipeline_state.get("is_paused"):
-        # (Lógica de continuação após STOP - sem alterações)
-        history.append([message, None])
+                content = json.loads(cleaned)
+                print("✅ JSON parseado com sucesso")
+            except Exception as parse_e:
+                print(f"⚠️ Erro parse JSON: {parse_e}")
+                content = out_raw # Mantém o raw output em caso de erro de parse
         
-        timeline_execucao = pipeline_state["timeline"]
-        agentes_restantes = pipeline_state["remaining_agents"]
+        print(f"⏱️ Tempo total: {tempo_exec:.2f}s")
         
-        timeline_execucao.append({
-            "passo": len(timeline_execucao) + 1,
-            "tipo": "resposta_usuario",
-            "conteudo": message
-        })
+        # 7. Retorna resultado
+        return {
+            "role": "assistant",
+            "agent": config['nome'],
+            "content": content,
+            "raw": out_raw,
+            "tempo": tempo_exec,
+            "tokens_input": tokens_total,
+            "tokens_output": tokens_resposta
+        }, True
         
-        pipeline_state["is_paused"] = False
+    except Exception as e:
+        # Tratamento de Erros da API
+        msg = str(e)
+        print(f"💥 ERRO GROQ: {msg}")
+        import traceback
+        traceback.print_exc()
         
-        yield from executar_pipeline(history, timeline_execucao, agentes_restantes, pipeline_state)
-        return
+        # Mensagens de erro amigáveis para o usuário
+        if "context_length_exceeded" in msg or "Please reduce the length of the messages" in msg:
+            erro_amistoso = (
+                "STOP: o contexto atual ficou grande demais para este modelo. "
+                "Tente limpar parte da memória ou resumir o histórico antes de continuar."
+            )
+        else:
+            erro_amistoso = msg
+        
+        return {
+            "role": "system",
+            "error": erro_amistoso,
+            "agent": config['nome']
+        }, False
 
-    # --- LÓGICA DE INÍCIO DE UMA NOVA ANÁLISE (após a inicialização) ---
+# ==================== 4. ORQUESTRADOR COM CONTEXTO PERSISTENTE (ADUC-SDR) ====================
+def orquestrador(texto, anexos_list, history, json_config, contexto_objetivo):
+    """
+    Função principal que gerencia o fluxo de trabalho (pipeline),
+    mantém o contexto persistente e coordena a execução dos agentes Groq.
+    Implementa a Arquitetura de União Compositiva (ADUC).
+    """
+    print("\n" + "="*80)
+    print("🎬 INICIANDO ORQUESTRADOR - NOVA EXECUÇÃO")
     
-    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
+    if not texto.strip():
+        print("⚠️ Texto vazio, abortando")
+        yield history, [], carregar_contexto_persistente()
         return
     
+    # Adiciona input do usuário ao histórico temporário do chatbot
+    history = history + [{"role": "user", "content": texto}]
+    
     try:
-        protocolo = json.loads(config_json)
-    except:
-        history.append([message, "❌ Erro no JSON de Configuração do Protocolo."])
-        yield history, [], pipeline_state
+        protocolo = json.loads(json_config)
+        print(f"🔗 Protocolo: {len(protocolo)} agentes")
+    except Exception as e:
+        print(f"💥 Erro JSON config: {e}")
+        history.append({"role": "assistant", "content": f"❌ Erro no JSON de Configuração: {str(e)}"})
+        yield history, [], carregar_contexto_persistente()
         return
-
-    history.append([message, None])
     
-    timeline_execucao = []
-    agentes_a_executar = protocolo
+    # Placeholder de resposta (para feedback visual)
+    history.append({"role": "assistant", "content": ""})
     
-    if incluir_passo_antecipatorio:
-        # (Lógica do Passo Antecipatório - sem alterações)
-        conteudo_antecipatorio = ler_arquivo_texto(ARQUIVO_CONTEXTO_ANTECIPATORIO)
-        if conteudo_antecipatorio:
-            timeline_execucao.append({
-                "passo": 1,
-                "tipo": "passo_antecipatorio_data",
-                "agente": "GOVERNANCA_INICIAL",
-                "conteudo": f"REGRAS E VERDADE FACTUAL INICIAL (data.txt):\n{conteudo_antecipatorio}"
-            })
-            history.append([None, f"ℹ️ **GOVERNANÇA INICIAL:** Contexto de `{ARQUIVO_CONTEXTO_ANTECIPATORIO}` injetado."])
-            history[-1][1] += f"\n\nInstrução do usuário: {message}"
-        else:
-             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."
-             
-        passo_inicial_prompt = len(timeline_execucao) + 1
-    else:
-        passo_inicial_prompt = 1
+    # Carrega e atualiza contexto persistente (Memória de Longo Prazo)
+    contexto_persistente = carregar_contexto_persistente()
     
-    timeline_execucao.append({"passo": passo_inicial_prompt, "tipo": "prompt_usuario_base", "conteudo": prompt_contexto})
+    # 1. Adiciona input do usuário ao contexto persistente COM PREFIXO [USUÁRIO]
+    contexto_persistente.append({
+        "role": "user",
+        "content": f"[USUÁRIO] {texto}",
+        "timestamp": datetime.now().strftime('%Y-%m-%d %H:%M:%S')
+    })
     
-    yield history, timeline_execucao, pipeline_state
+    # 2. Monta o Contexto Inicial para a Chamada Atual (Objetivo + Anexos)
+    contexto_inicial = ""
+    if contexto_objetivo and contexto_objetivo.strip():
+        contexto_inicial += f"[OBJETIVO DO MODELO]\n{contexto_objetivo.strip()}\n[FIM OBJETIVO]\n\n"
     
-    yield from executar_pipeline(history, timeline_execucao, agentes_a_executar, pipeline_state)
-
-# ... (função executar_pipeline permanece a mesma da versão Groq anterior) ...
-def executar_pipeline(history, timeline_execucao, agentes_a_executar, pipeline_state):
-    # ### ALTERADO ### - Lógica de execução da pipeline adaptada para Groq e streaming real
-    passo_atual = len(timeline_execucao) + 1
+    if anexos_list:
+        for anexo in anexos_list:
+            anexo_conteudo = ler_anexo(anexo)
+            if anexo_conteudo:
+                contexto_inicial += anexo_conteudo
+    
+    # 3. Monta a Timeline para o Agente (Contexto Completo para o LLM)
+    timeline = []
+    # Adiciona todo o histórico persistente (exceto o último input recém-adicionado)
+    for msg in contexto_persistente[:-1]:
+        timeline.append({
+            "role": msg["role"],
+            "content": msg["content"]
+        })
+    
+    # Adiciona o input atual, que contém o 'contexto_inicial' (objetivo + anexos)
+    timeline.append({
+        "role": "user",
+        "content": f"{contexto_inicial}{texto}".strip()
+    })
     
-    for i, cfg in enumerate(agentes_a_executar):
-        nome_agente = cfg.get("nome", "Agente")
-        # Seleciona o modelo Groq com base na configuração do agente
-        modelo_agente = GROQ_MODELS.get(cfg.get("modelo"), GROQ_MODELS["flash"])
-        tipo_saida = cfg.get("tipo_saida", "json")
+    print(f"🌐 Timeline montada: {len(timeline)} mensagens")
+    
+    # Calcula tokens totais da timeline para exibição no UI
+    timeline_chars = sum(len(str(m.get("content", ""))) for m in timeline)
+    timeline_tokens = estimar_tokens(timeline_chars)
+    
+    audit_data = [] # Para armazenar dados de auditoria
+    
+    # 4. Loop de Execução dos Agentes (Pipeline)
+    for idx, cfg in enumerate(protocolo):
+        print(f"\n{'='*50}")
+        print(f"🚀 FASE {idx+1}/{len(protocolo)}: {cfg['nome']}")
         
-        msg_atual = history[-1][1] or ""
-        history[-1][1] = msg_atual + f"⏳ **{nome_agente}** está analisando (modelo: `{modelo_agente}`)...\n"
-        yield history, timeline_execucao, pipeline_state
+        # Feedback visual inicial no UI
+        history[-1]["content"] = (
+            f"⏳ **Agente {idx+1}/{len(protocolo)}: {cfg['nome']}**\n\n"
+            f"📊 Contexto (~{timeline_tokens} tokens)\n"
+            f"🔧 Modelo: `{cfg.get('modelo', 'default')}`\n"
+            f"*Aguarde...*"
+        )
+        yield history, audit_data, contexto_persistente
         
-        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. Se for 'texto', responda de forma discursiva.
-"""
+        time.sleep(DELAY_ENTRE_AGENTES) # Delay entre chamadas de agentes
         
-        try:
-            inicio = time.time()
+        # Executa agente
+        res, sucesso = executar_no(timeline, cfg)
+        
+        resposta_content = res.get('content', '')
+        
+        # 5. Verificação de Condição de Parada (STOP_PIPELINE)
+        if verificar_stop(resposta_content):
+            print("🛑 STOP_PIPELINE detectado - encerrando pipeline")
+            
+            texto_final = str(resposta_content)
             
-            # --- LÓGICA DE DETECÇÃO DE SAÍDA NÃO-JSON (STOP ou Relatório) ---
-            if tipo_saida == "json":
-                chat_completion = groq_client.chat.completions.create(
-                    messages=[{"role": "user", "content": prompt_agente}],
-                    model=modelo_agente,
-                    temperature=0.1,
-                    max_tokens=8192,
+            # TRATAMENTO PARA EXTRAIR A RESPOSTA DO JSON
+            if isinstance(resposta_content, dict) and 'proximo_passo' in resposta_content:
+                texto_parcial = resposta_content['proximo_passo']
+                if texto_parcial.startswith(STOP_KEYWORD):
+                    # Remove o prefixo de parada para exibir apenas a resposta limpa
+                    texto_final = texto_parcial.replace(STOP_KEYWORD, "").strip()
+                else:
+                    texto_final = texto_parcial
+            elif not isinstance(resposta_content, str):
+                 # Se não for string nem JSON com a chave, exibe o JSON formatado
+                texto_final = json.dumps(resposta_content, ensure_ascii=False, indent=2)
+
+            # Se for string, verifica se contém o prefixo
+            elif texto_final.startswith(STOP_KEYWORD):
+                texto_final = texto_final.replace(STOP_KEYWORD, "").strip()
+
+
+            # Aplica o efeito typewriter e encerra
+            for i in range(0, len(texto_final), 10):
+                history[-1]["content"] = texto_final[:i+10]
+                yield history, audit_data, contexto_persistente
+                time.sleep(0.01)
+            
+            history[-1]["content"] = texto_final
+            yield history, audit_data, contexto_persistente
+            return
+        
+        # 6. Processamento e Persistência do Resultado (Apenas se não houve STOP)
+        if sucesso and resposta_content:
+            # Adiciona a resposta do agente ao contexto persistente COM PREFIXO [AGENTE nome]
+            content_to_persist = f"[{cfg['nome']}] {resposta_content if isinstance(resposta_content, str) else json.dumps(resposta_content, ensure_ascii=False)}"
+            contexto_persistente.append({
+                "role": "assistant",
+                "agent": cfg['nome'],
+                "content": content_to_persist,
+                "timestamp": datetime.now().strftime('%Y-%m-%d %H:%M:%S')
+            })
+            
+            # Adiciona a resposta à timeline para o próximo agente (sem prefixo, para não poluir o prompt)
+            timeline.append({
+                "role": "assistant",
+                "content": resposta_content
+            })
+            
+            # Atualiza contagem de tokens e salva o contexto
+            timeline_chars = sum(len(str(m.get("content", ""))) for m in timeline)
+            timeline_tokens = estimar_tokens(timeline_chars)
+            salvar_contexto_persistente(contexto_persistente)
+            print(f"🧠 Resposta de '{cfg['nome']}' salva e adicionada à timeline.")
+        else:
+            # Erro na execução (não é STOP_PIPELINE) - interrompe o pipeline
+            erro_msg = res.get("error", "Erro desconhecido na chamada ao modelo.")
+            history[-1]["content"] = f"❌ **Erro no agente {cfg['nome']}:**\n\n{erro_msg}"
+            
+            audit_entry = {
+                "step": idx + 1, "agent": cfg['nome'], "model": cfg.get('modelo', 'default'), 
+                "type": cfg.get('tipo_saida', 'texto'), "error": erro_msg, "sucesso": False,
+                "timestamp": datetime.now().strftime('%H:%M:%S')
+            }
+            audit_data.append(audit_entry)
+            yield history, audit_data, contexto_persistente
+            print("⛔ Pipeline interrompida devido a erro")
+            return
+        
+        # 7. Registro de Auditoria
+        audit_entry = {
+            "step": idx + 1, "agent": cfg['nome'], "model": cfg.get('modelo', 'default'), 
+            "type": cfg.get('tipo_saida', 'texto'), "response_preview": str(resposta_content)[:100] + "...", 
+            "raw_len": len(res.get('raw', '')), "tokens_input": res.get('tokens_input', 0),
+            "tokens_output": res.get('tokens_output', 0), "tempo": round(res.get('tempo', 0), 2),
+            "sucesso": sucesso, "timestamp": datetime.now().strftime('%H:%M:%S')
+        }
+        audit_data.append(audit_entry)
+        
+        # 8. Exibição da Resposta Final (último agente ou agente de saída tipo 'texto')
+        if idx == len(protocolo) - 1 or cfg.get('tipo_saida') == 'texto':
+            texto_final = str(resposta_content) if isinstance(resposta_content, str) else json.dumps(resposta_content, ensure_ascii=False, indent=2)
+            
+            # Efeito Typewriter (para visualização no Gradio)
+            for i in range(0, len(texto_final), 10):
+                history[-1]["content"] = texto_final[:i+10]
+                yield history, audit_data, contexto_persistente
+                time.sleep(0.01)
+            
+            history[-1]["content"] = texto_final
+            yield history, audit_data, contexto_persistente
+    
+    print("🏁 Pipeline concluída com sucesso")
+    print("="*80)
+
+# ==================== 5. UI (GRADIO) ====================
+def ui_clean():
+    """Constrói e retorna a interface Gradio."""
+    config_init = carregar_protocolo()
+    help_init = carregar_help()
+    
+    # CORREÇÃO DO WARNING: Parâmetro 'css' movido para o método .launch() no final do arquivo
+    with gr.Blocks(title="AI Forensics - Groq (v38)") as app:
+        # Estados para dados persistentes
+        anexos_state = gr.State([])
+        
+        # Tabs de Navegação
+        with gr.Tabs():
+            # Tab 1: Chat Principal
+            with gr.Tab("💬 Chat"):
+                gr.Markdown("## Investigador AI (v38 - Orquestração ADUC-SDR)")
+                # CORREÇÃO DO ERRO: Garantir que não há parâmetros inesperados como 'show_copy_button'
+                chatbot = gr.Chatbot(label="Histórico Conversacional", height=500)
+                
+                with gr.Row():
+                    txt_in = gr.Textbox(show_label=False, placeholder="Digite sua mensagem...", lines=2, scale=9)
+                    btn_send = gr.Button("📤 Enviar", variant="primary", scale=1)
+            
+            # Tab 2: Configurações de Contexto
+            with gr.Tab("📎 Anexos & Contexto"):
+                gr.Markdown("""
+                ## Anexos e Contexto Factual
+                
+                **Anexos:** Conteúdo lido e adicionado *apenas* ao input da execução atual. **NÃO PERSISTE** na memória.
+                **Objetivo:** Define o `System Prompt` e a orientação de todos os agentes.
+                """)
+                objetivo_text = gr.Textbox(
+                    label="Objetivo do Modelo (System Prompt Global)",
+                    value="Voce é um agente chamado IndenizaAI existe para transformar um dano — seja ele físico, emocional ou existencial — em um valor que faça sentido. Seu papel não é tomar partido nem alimentar vingança, mas construir um ponto de equilíbrio entre a dor sofrida e a responsabilidade de quem causou o prejuízo. Ele organiza os fatos, compreende o impacto real e traduz tudo isso em um número que reconhece a gravidade do acontecido sem exageros, sem minimizações e sem distorções. O cálculo é o coração do seu trabalho. O IndenizaAI observa cada elemento com sobriedade: o que aconteceu, quem foi afetado, como a vida mudou, o que se perdeu e o que não pode ser restaurado. A partir disso, ele converge todos os fatores — humanos, materiais e existenciais — para uma medida proporcional e defensável. Esse valor não é um prêmio nem uma punição; é a forma concreta de dizer que houve dano, que esse dano tem peso e que a reparação precisa ser justa. No fim, sua importância está em oferecer clareza onde a emoção costuma criar névoa. Ele dá ao usuário uma referência honesta, capaz de orientar decisões, acordos e caminhos jurídicos. Seu cálculo é a ponte entre a vítima e a justiça: um número que não repara o passado, mas reconhece sua dor e estabelece o que é devido. E é nessa precisão equilibrada que o IndenizaAI cumpre sua razão de existir"
+                    , placeholder="Ex: Você é um analista forense imparcial...",
+                    lines=5
                 )
-                texto_resp = chat_completion.choices[0].message.content
-                duracao = time.time() - inicio
-
-                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:
-                        
-                        if "STOP:" in texto_resp:
-                            stop_message = texto_resp.split("STOP:")[1].strip() if "STOP:" in texto_resp else "Análise interrompida por dúvida crítica."
-                            history[-1][1] = stop_message
-                            yield history, timeline_execucao, pipeline_state
-                            return 
-
-                        perguntas = resposta_json.get("TESTE_REFLEXAO", {}).get("perguntas", [])
-                        
-                        pipeline_state["is_paused"] = True
-                        pipeline_state["timeline"] = timeline_execucao
-                        pipeline_state["remaining_agents"] = agentes_a_executar[i+1:]
-                        
-                        stop_response = "STOP: preciso que você esclareça pontos antes de continuar."
-                        timeline_execucao.append({"passo": passo_atual, "tipo": "STOP_USUARIO_REQUERIDO", "agente": nome_agente, "detalhes": stop_response})
-                        
-                        msg_para_usuario = f"**{nome_agente}** precisa de mais informações. Por favor, responda aos pontos abaixo:\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 (modelo: `{modelo_agente}`)...\n", "")
-                        history[-1][1] = msg_atual + msg_para_usuario
-                        
-                        yield history, timeline_execucao, pipeline_state
-                        return 
-                        
-                    # 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 (modelo: `{modelo_agente}`)...\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:
-                    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 (modelo: `{modelo_agente}`)...\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
+                gr.Markdown("### Anexos (não persistentes)")
+                anexos_upload = gr.File(
+                    file_count="multiple",
+                    file_types=[".txt", ".md", ".json"]
+                )
+                anexos_display = gr.Textbox(label="Arquivos Carregados", interactive=False, lines=3)
                 
-            elif tipo_saida == "texto":
-                # Lógica para a Fase 7 com STREAMING REAL
-                stream = groq_client.chat.completions.create(
-                    messages=[{"role": "user", "content": prompt_agente}],
-                    model=modelo_agente,
-                    temperature=0.7,
-                    max_tokens=8192,
-                    stream=True,
+                def atualizar_anexos(files):
+                    if not files:
+                        return [], "Nenhum arquivo carregado"
+                    nomes = [os.path.basename(f.name) for f in files]
+                    return files, f"📎 {len(files)} arquivo(s): {', '.join(nomes)}"
+                
+                anexos_upload.change(atualizar_anexos, anexos_upload, [anexos_state, anexos_display])
+            
+            # Tab 3: Memória Persistente
+            with gr.Tab("🧠 Contexto Persistente"):
+                gr.Markdown("""
+                ## Memória Persistente do Sistema (ADUC)
+                
+                Armazena o histórico da conversação. É limitado a ~12k chars por chamada.
+                - **Input do usuário:** prefixo `[USUÁRIO]`
+                - **Respostas dos agentes:** prefixo `[AGENTE nome]`
+                """)
+                
+                contexto_display = gr.JSON(
+                    label="Contexto Persistente",
+                    value=carregar_contexto_persistente()
                 )
                 
-                msg_final = f"**[RELATÓRIO FINAL DO {nome_agente}]**\n\n"
-                history[-1][1] = msg_final
-                relatorio_completo = ""
+                with gr.Row():
+                    btn_reload_ctx = gr.Button("🔄 Recarregar", size="sm")
+                    btn_limpar_ctx = gr.Button("🗑️ Limpar Contexto", size="sm", variant="stop")
                 
-                for chunk in stream:
-                    delta = chunk.choices[0].delta.content or ""
-                    if delta:
-                        relatorio_completo += delta
-                        history[-1][1] = msg_final + relatorio_completo
-                        yield history, timeline_execucao, pipeline_state
+                status_ctx = gr.Markdown("")
                 
-                # Adiciona o passo completo à auditoria no final
-                timeline_execucao.append({"passo": passo_atual, "tipo": "relatorio_final", "agente": nome_agente, "relatorio": relatorio_completo})
-                history[-1][1] += "\n\n--- FIM DO RELATÓRIO DE VALORAÇÃO ---"
-                yield history, timeline_execucao, pipeline_state
+                btn_reload_ctx.click(
+                    lambda: carregar_contexto_persistente(),
+                    outputs=contexto_display
+                )
                 
-            else:
-                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.\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 (modelo: `{modelo_agente}`)...\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()
-
-    with gr.Blocks(title="AI Forensics Auto", css=css, theme=gr.themes.Soft()) as app:
-        
-        state_config = gr.State(config_inicial)
-        pipeline_state = gr.State({"is_paused": False, "timeline": [], "remaining_agents": []})
-
-        with gr.Tabs():
-            with gr.Tab("💬 Investigação"):
+                def limpar_e_recarregar():
+                    msg = limpar_contexto_persistente()
+                    return carregar_contexto_persistente(), msg
                 
-                # ### NOVO ### - Campo para o Objetivo Global (System Prompt)
-                with gr.Column():
-                    gr.Markdown("### 1. Defina o Objetivo Principal da Análise")
-                    txt_system_prompt = gr.Textbox(
-                        label="Objetivo do Modelo (System Prompt Global)",
-                        placeholder="Ex: 'Atuar como um perito judicial para analisar o processo e determinar o valor do dano moral com base na jurisprudência do TJSP.'",
-                        lines=2
-                    )
-
-                chatbot = gr.Chatbot(
-                    elem_id="chatbot",
-                    height=400, 
-                    show_label=False, 
-                    show_copy_button=True,
-                    render_markdown=True,
-                    label="Chat de Investigação"
+                btn_limpar_ctx.click(
+                    limpar_e_recarregar,
+                    outputs=[contexto_display, status_ctx]
                 )
+            
+            # Tab 4: Configuração da Pipeline
+            with gr.Tab("⚙️ Protocolo"):
+                gr.Markdown("""
+                ## Edição do Protocolo de Agentes (Pipeline)
+                
+                Define a sequência de agentes.
+                """)
                 
                 with gr.Row():
-                    txt_input = gr.Textbox(
-                        scale=8, 
-                        show_label=False, 
-                        placeholder="Digite sua primeira instrução para iniciar, ou continue a conversa...", 
-                        lines=1
-                    )
-                    btn_enviar = gr.Button("Enviar 📨", variant="primary", scale=1)
+                    btn_save_proto = gr.Button("💾 Salvar", variant="primary", size="sm")
+                    btn_reload_proto = gr.Button("🔄 Recarregar", size="sm")
+                proto_status = gr.Markdown("")
+                code_json = gr.Code(value=config_init, language="json", lines=30)
                 
-                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}`)",
-                        value=True
-                    )
-
-                with gr.Accordion("📂 Adicionar Arquivos para Análise", open=True):
-                    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"
-                    )
-
-            # ... (Abas de Auditoria, Protocolo e Documentação permanecem as mesmas) ...
-            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)
+                btn_save_proto.click(salvar_protocolo, code_json, proto_status)
+                btn_reload_proto.click(lambda: carregar_protocolo(), outputs=code_json)
             
-            with gr.Tab("📚 Documentação"):
-                gr.Markdown("### Documentação da Aplicação (help.md)")
-                gr.Markdown(documentacao)
-
-        # ### ALTERADO ### - Adiciona o txt_system_prompt como input
-        btn_enviar.click(
-            chat_orquestrador,
-            inputs=[txt_input, chatbot, txt_system_prompt, 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]
-        )
-
+            # Tab 5: Auditoria
+            with gr.Tab("🔍 Auditoria"):
+                gr.Markdown("""
+                ## Auditoria da Última Execução
+                
+                Rastreamento do consumo de recursos por agente.
+                """)
+                audit_display = gr.JSON(label="Dados de Auditoria", value=[])
+            
+            with gr.Tab("❓ Ajuda"):
+                help_content = gr.Markdown(help_init)
+                btn_reload_help = gr.Button("🔄 Recarregar Help")
+                btn_reload_help.click(lambda: carregar_help(), outputs=help_content)
+        
+        # Triggers de Ação
+        btn_send.click(
+            orquestrador,
+            [txt_in, anexos_state, chatbot, code_json, objetivo_text],
+            [chatbot, audit_display, contexto_display]
+        ).then(lambda: "", outputs=txt_in)
+        
+        txt_in.submit(
+            orquestrador,
+            [txt_in, anexos_state, chatbot, code_json, objetivo_text],
+            [chatbot, audit_display, contexto_display]
+        ).then(lambda: "", outputs=txt_in)
+    
     return app
 
 if __name__ == "__main__":
-    app = ui_v29_stop_logic()
-    app.launch()
+    print("🎉 Lançando app Groq v38...")
+    # Lançamento do Gradio
+    # CORREÇÃO DO WARNING: O parâmetro `css` foi movido para o método launch()
+    ui_clean().launch(css="footer{display:none!important;}")