Update app.py

app.py

@@ -4,16 +4,17 @@ import json
 import os
 import copy
 
+# --- Configuration from Script 1 & 2 (merged) ---
 GEMINI_API_KEY = os.getenv("GEMINI_API_KEY")
 if not GEMINI_API_KEY:
     print("ALERTA: GEMINI_API_KEY não encontrada como Secret no Hugging Face Space. O app não funcionará.")
     # Para teste local, descomente e cole sua chave, mas NÃO FAÇA COMMIT DISSO COM A CHAVE.
     # GEMINI_API_KEY = "SUA_CHAVE_AQUI_PARA_TESTE_LOCAL_APENAS"
 
-
-MODEL_NAME = "gemini-1.5-flash-latest"
+MODEL_NAME = "gemini-1.5-flash-latest" # Consistent model name
 API_URL_BASE = f"https://generativelanguage.googleapis.com/v1beta/models/{MODEL_NAME}:generateContent"
 
+# --- Fases da AIJ (from Script 1) ---
 FASE_INICIAL_CONFIG = "CONFIGURACAO"
 FASE_ABERTURA_CONCILIACAO = "ABERTURA_E_CONCILIACAO"
 FASE_TESTEMUNHAS_AUTOR_INICIO = "TESTEMUNHAS_AUTOR_INICIO"
@@ -27,6 +28,71 @@ FASE_ALEGACOES_FINAIS_REU = "ALEGACOES_FINAIS_REU"
 FASE_ANALISE_FINAL_PROFESSOR = "ANALISE_FINAL_PROFESSOR"
 FASE_CONCLUIDA = "AIJ_CONCLUIDA"
 
+# --- Predefined Case Data (from Script 2, adapted for Script 1 structure) ---
+CASO_TITULO_PREDEFINIDO = "O Caso da Reportagem Revisitada"
+CASO_PARTES_PREDEFINIDO = "Autor: Carlos Alberto Mendes\nRéu: Jornal 'A Verdade Diária'"
+CASO_DESCRICAO_PREDEFINIDO = """
+Uma pessoa (Carlos Alberto Mendes) processou um jornal (A Verdade Diária) alegando violação do direito ao esquecimento.
+O jornal publicou uma matéria relembrando um crime ocorrido há 15 anos, no qual o autor foi
+acusado de fraude, mas posteriormente absolvido por falta de provas. A matéria original foi publicada na época dos fatos
+e a nova matéria, parte de uma série "Crimes que Marcaram a Cidade", revisitou o caso, mencionando a absolvição.
+
+O autor alega que a republicação da história, mesmo com a menção da absolvição, causou-lhe
+constrangimentos sociais, dificuldades em obter novo emprego e reacendeu traumas passados,
+afetando sua vida familiar. Ele requer a remoção da matéria do site do jornal e uma indenização
+por danos morais.
+
+O jornal (réu) defende a liberdade de imprensa e o direito à informação, argumentando que
+a matéria tem interesse público histórico, é factualmente correta (inclusive quanto à absolvição)
+e faz parte do acervo jornalístico que documenta a história da comunidade.
+"""
+CASO_FATOS_COMPLETO_PREDEFINIDO = f"Título: {CASO_TITULO_PREDEFINIDO}\nPartes:\n{CASO_PARTES_PREDEFINIDO}\n\n---INÍCIO DOS FATOS---\n{CASO_DESCRICAO_PREDEFINIDO.strip()}"
+
+ARGUMENTOS_AUTOR_PREDEFINIDOS = [
+    "Argumento: A matéria publicada reabriu feridas do passado e causou danos psicológicos e sociais ao autor. Prova: Laudo psicológico atestando abalo emocional e depoimentos sobre constrangimento social.",
+    "Argumento: O autor já foi absolvido judicialmente e tem direito a reconstruir sua vida sem o estigma do passado. Prova: Cópia da sentença absolutória.",
+    "Argumento: O tempo transcorrido (15 anos) torna o caso desatualizado e sem relevância pública atual que justifique a exposição. Prova: Irrelevância pública atual, foco no dano individual.",
+    "Argumento: A publicação violou o direito à privacidade e à honra do autor. Prova: Doutrina e jurisprudência sobre direitos da personalidade."
+]
+PROVAS_AUTOR_SUPPOSTAS_TEXTO_PREDEFINIDO = "\n".join(ARGUMENTOS_AUTOR_PREDEFINIDOS)
+
+CONTRA_ARGUMENTOS_REU_PREDEFINIDOS = [
+    "Argumento: A liberdade de imprensa é um direito fundamental e a matéria é de interesse público histórico. Prova: Art. 5º, IX e XIV da CF/88; Doutrina sobre liberdade de imprensa.",
+    "Argumento: A matéria baseia-se inteiramente em informações verídicas e de acesso público (processo judicial). Prova: Cópia da matéria original e da recente, certidão do processo.",
+    "Argumento: O STF (RE 1.010.606) não reconheceu o direito ao esquecimento de forma absoluta, ponderando-o com a liberdade de informação. Prova: Inteiro teor do acórdão do RE 1.010.606.",
+    "Argumento: A matéria destacou a absolvição do autor, não havendo intenção de difamar. Prova: Conteúdo da própria matéria."
+]
+PROVAS_REU_TEXTO_PREDEFINIDO = "\n".join(CONTRA_ARGUMENTOS_REU_PREDEFINIDOS)
+
+TESTEMUNHAS_REU_PREDEFINIDAS = [
+    {"nome": "João Silva", "pontos_chave": "Editor-chefe do jornal. Confirmará o processo editorial, o interesse público da série de reportagens e a ausência de intenção de prejudicar o autor."},
+    {"nome": "Dra. Maria Santos", "pontos_chave": "Historiadora local. Atestará a relevância histórica do caso para a comunidade e a importância de preservar a memória de tais eventos."},
+    {"nome": "Roberto Almeida", "pontos_chave": "Jornalista responsável pela matéria. Detalhará a pesquisa, a verificação dos fatos e a menção explícita à absolvição do autor."}
+]
+TESTEMUNHAS_REU_TEXTO_PREDEFINIDO = "\n".join([f"{t['nome']}: {t['pontos_chave']}" for t in TESTEMUNHAS_REU_PREDEFINIDAS])
+
+# Para o caso padrão, precisamos de testemunhas do autor também.
+TESTEMUNHAS_AUTOR_SUPPOSTAS_PREDEFINIDAS_TEXTO = """
+Dr. Felipe Antunes: Psicólogo do autor. Relatará o impacto emocional da nova reportagem na vida do autor.
+Sra. Clara Dias: Vizinha do autor. Comentará sobre as mudanças no tratamento social que o autor recebeu após a reportagem.
+"""
+
+LEGISLACAO_PRECEDENTES_PREDEFINIDO = {
+    "favoraveis_ao_reu": [
+        "Art. 5º, IV, IX e XIV da Constituição Federal - garantia da liberdade de expressão e acesso à informação",
+        "ADPF 130 (STF) - declarou a Lei de Imprensa incompatível com a ordem constitucional atual",
+        "RE 1.010.606 (STF) - não reconheceu o direito ao esquecimento na esfera civil de forma irrestrita",
+        "Pacto de San José da Costa Rica - proteção à liberdade de expressão",
+    ],
+    "favoraveis_ao_autor": [
+        "Art. 5º, X da Constituição Federal - inviolabilidade da intimidade, vida privada e honra",
+        "Art. 21 do Código Civil - proteção à vida privada",
+        "Enunciado 531 da VI Jornada de Direito Civil - reconhece o direito ao esquecimento",
+        "LGPD (Lei Geral de Proteção de Dados) - embora não diretamente, reforça a proteção a dados pessoais."
+    ]
+}
+
+# --- Funções de Estado e API (from Script 1) ---
 def estado_inicial_simulacao():
     return {
         "fase_aij": FASE_INICIAL_CONFIG, "caso_fatos": "", "provas_reu_texto": "",
@@ -35,7 +101,7 @@ def estado_inicial_simulacao():
         "testemunha_reu_atual_idx": -1, "testemunha_em_depoimento": None,
         "transcricao_chat": [], "transcricao_logica": [],
         "feedback_para_usuario": "Aguardando início da simulação.",
-        "instrucao_para_usuario": "Configure os detalhes do caso na aba 'Configuração'."
+        "instrucao_para_usuario": "Configure os detalhes do caso na aba 'Configuração' ou carregue o caso padrão."
     }
 
 def chamar_gemini_api(prompt_text, temperature=0.7, max_output_tokens=800):
@@ -55,7 +121,7 @@ def chamar_gemini_api(prompt_text, temperature=0.7, max_output_tokens=800):
         ]
     }
     try:
-        response = requests.post(api_url_com_chave, headers=headers, data=json.dumps(data), timeout=120)
+        response = requests.post(api_url_com_chave, headers=headers, data=json.dumps(data), timeout=180) # Increased timeout
         response.raise_for_status()
         response_json = response.json()
         if response_json.get("candidates") and response_json["candidates"][0].get("content"):
@@ -63,6 +129,8 @@ def chamar_gemini_api(prompt_text, temperature=0.7, max_output_tokens=800):
         elif response_json.get("promptFeedback") and response_json["promptFeedback"].get("blockReason"):
             return f"ERRO_API: Conteúdo bloqueado. Razão: {response_json['promptFeedback']['blockReason']}"
         return "ERRO_API: Resposta inesperada da API."
+    except requests.exceptions.Timeout:
+        return "ERRO_CONEXAO: Timeout ao chamar a API Gemini. Tente novamente."
     except requests.exceptions.RequestException as e:
         error_msg = f"ERRO_CONEXAO: {e}"
         if e.response is not None:
@@ -80,7 +148,9 @@ def formatar_historico_para_prompt(transcricao_logica, max_turns=15):
         historico_formatado += f"- {ator}: {fala}\n"
     return historico_formatado
 
+# --- Funções de Geração de Conteúdo IA (from Script 1, some new) ---
 def gerar_caso_ficticio_com_ia():
+    # (Função mantida como no Script 1 original)
     prompt_geracao_caso = """
 **Instrução de Persona:** Você é um roteirista jurídico criativo e experiente, especializado em criar casos simulados realistas para treinamento de advogados.
 **Tarefa:** Crie um caso fictício detalhado para uma simulação de Audiência de Instrução e Julgamento (AIJ) sobre o tema "Direito ao Esquecimento vs. Liberdade de Imprensa".
@@ -102,12 +172,13 @@ def gerar_caso_ficticio_com_ia():
 `## Testemunhas Hipotéticas da Parte RÉ`
 O conteúdo de cada seção deve vir após o marcador. Para Argumentos/Provas e Testemunhas, liste cada item em uma nova linha.
 """
-    texto_caso_completo = chamar_gemini_api(prompt_geracao_caso, temperature=0.75, max_output_tokens=2000)
+    texto_caso_completo = chamar_gemini_api(prompt_geracao_caso, temperature=0.75, max_output_tokens=2500) # Increased tokens
     if "ERRO_" in texto_caso_completo:
         return {"fatos": f"Falha ao gerar caso com IA: {texto_caso_completo}", "provas_autor": "", "provas_reu": "", "testemunhas_autor": "", "testemunhas_reu": ""}
     return parse_caso_gerado(texto_caso_completo)
 
 def parse_caso_gerado(texto_completo_caso):
+    # (Função mantida como no Script 1 original)
     dados_caso = {"fatos": "Falha parsing: Fatos", "provas_autor": "Falha parsing: Provas Autor", "provas_reu": "Falha parsing: Provas Réu", "testemunhas_autor": "Falha parsing: Testemunhas Autor", "testemunhas_reu": "Falha parsing: Testemunhas Réu"}
     secoes = {"fatos": "## Resumo Detalhado dos Fatos", "provas_autor": "## Argumentos e \"Provas\" Hipotéticas da Parte AUTORA", "provas_reu": "## Argumentos e \"Provas\" Hipotéticas da Parte RÉ (Jornal)", "testemunhas_autor": "## Testemunhas Hipotéticas da Parte AUTORA", "testemunhas_reu": "## Testemunhas Hipotéticas da Parte RÉ"}
     fatos_prefix = ""
@@ -135,9 +206,16 @@ def parse_caso_gerado(texto_completo_caso):
         dados_caso[chave_atual] = fatos_prefix + conteudo_secao if chave_atual == "fatos" and fatos_prefix else conteudo_secao
         current_pos = fim_conteudo
     for key_testemunha in ["testemunhas_autor", "testemunhas_reu"]:
-        if "Falha no parsing" not in dados_caso[key_testemunha]:
+        if "Falha no parsing" not in dados_caso[key_testemunha] and dados_caso[key_testemunha]: # Check if not empty
             linhas = dados_caso[key_testemunha].split('\n')
-            linhas_formatadas = [f"{p[0].strip()}: {p[1].strip()}" if len(p := linha.split(':', 1)) == 2 else linha.strip() for linha in linhas if linha.strip()]
+            linhas_formatadas = []
+            for linha in linhas:
+                if linha.strip():
+                    partes = linha.split(':', 1)
+                    if len(partes) == 2:
+                        linhas_formatadas.append(f"{partes[0].strip()}: {partes[1].strip()}")
+                    else:
+                        linhas_formatadas.append(partes[0].strip()) # Handle lines without colon if necessary
             dados_caso[key_testemunha] = "\n".join(linhas_formatadas)
     return dados_caso
 
@@ -146,7 +224,19 @@ def acao_gerar_caso_ficticio_ui():
     dados_gerados = gerar_caso_ficticio_com_ia()
     return [dados_gerados["fatos"], dados_gerados["provas_reu"], dados_gerados["provas_autor"], dados_gerados["testemunhas_reu"], dados_gerados["testemunhas_autor"], "Caso fictício gerado. Revise e salve."]
 
+def acao_carregar_caso_padrao_ui():
+    gr.Info("Carregando caso padrão...")
+    return [
+        CASO_FATOS_COMPLETO_PREDEFINIDO,
+        PROVAS_REU_TEXTO_PREDEFINIDO,
+        PROVAS_AUTOR_SUPPOSTAS_TEXTO_PREDEFINIDO,
+        TESTEMUNHAS_REU_TEXTO_PREDEFINIDO,
+        TESTEMUNHAS_AUTOR_SUPPOSTAS_PREDEFINIDAS_TEXTO,
+        "Caso padrão carregado. Revise e salve."
+    ]
+
 def gerar_resposta_juiz_ia(estado_simulacao, acao_especifica=""):
+    # (Função mantida como no Script 1 original)
     fase = estado_simulacao["fase_aij"]
     historico = formatar_historico_para_prompt(estado_simulacao["transcricao_logica"])
     prompt = f"**Persona:** Juiz(a) experiente em AIJ (Direito Esquecimento vs Liberdade Imprensa).\n**Fatos:** {estado_simulacao['caso_fatos'] or 'Não detalhado.'}\n{historico}**Fase Atual:** {fase}\n"
@@ -158,9 +248,10 @@ def gerar_resposta_juiz_ia(estado_simulacao, acao_especifica=""):
     elif fase == FASE_ANALISE_FINAL_PROFESSOR: prompt += "**Tarefa:** Declare audiência encerrada para julgamento (simulado)."
     else: prompt += f"**Tarefa:** Conduza a audiência. Ação específica: {acao_especifica or 'Nenhuma'}. Mantenha ordem e fluxo."
     prompt += "\n**Sua Fala (Juiz):**"
-    return chamar_gemini_api(prompt, temperature=0.6, max_output_tokens=250)
+    return chamar_gemini_api(prompt, temperature=0.6, max_output_tokens=300)
 
 def gerar_resposta_advogado_autor_ia(estado_simulacao, fala_adv_reu=""):
+    # (Função mantida como no Script 1 original)
     fase = estado_simulacao["fase_aij"]
     historico = formatar_historico_para_prompt(estado_simulacao["transcricao_logica"])
     prompt = f"**Persona:** Advogado(a) do AUTOR em AIJ (Direito Esquecimento vs Liberdade Imprensa). Cliente busca esquecimento/reparação.\n**Réu:** Jornal.\n**Fatos:** {estado_simulacao['caso_fatos'] or 'Não detalhado.'}\n**Provas/Argumentos Autor:** {estado_simulacao['provas_autor_supostas_texto'] or 'Passagem tempo, desinteresse público, dano vida privada.'}\n{historico}**Fase Atual:** {fase}\n"
@@ -181,21 +272,91 @@ def gerar_resposta_advogado_autor_ia(estado_simulacao, fala_adv_reu=""):
     elif fase == FASE_ALEGACOES_FINAIS_AUTOR: prompt += "**Tarefa:** Juiz concedeu palavra para alegações finais. Apresente resumo persuasivo e reitere pedidos."
     else: prompt += f"**Contexto:** Adv. Réu (Usuário) disse: \"{fala_adv_reu}\"\n**Tarefa:** Responda estrategicamente."
     prompt += "\n**Sua Resposta (Advogado Autor):**"
-    return chamar_gemini_api(prompt, temperature=0.75, max_output_tokens=400)
+    return chamar_gemini_api(prompt, temperature=0.75, max_output_tokens=450)
 
 def gerar_resposta_testemunha_autor_ia(estado_simulacao, pergunta_feita):
+    # (Função mantida como no Script 1 original)
     testemunha_obj = estado_simulacao.get("testemunha_em_depoimento")
     if not testemunha_obj or testemunha_obj["parte"] != "AUTOR": return "Testemunha do Autor (IA): (Erro interno - Nenhuma testemunha do autor em depoimento)"
     historico = formatar_historico_para_prompt(estado_simulacao["transcricao_logica"])
     prompt = f"**Persona:** Testemunha {testemunha_obj['nome']} (AUTOR).\n**Caso:** Direito Esquecimento vs Liberdade Imprensa.\n**Fatos:** {estado_simulacao['caso_fatos'] or 'Não detalhado.'}\n**Seus Pontos Chave:** {testemunha_obj['pontos_chave'] or 'Conhecimento geral sobre autor e impactos.'}\n{historico}**Pergunta Feita:** \"{pergunta_feita}\"\n**Tarefa:** Responda claro, conciso, baseado nos seus pontos. Se Adv. Réu, seja cauteloso(a).\n**Sua Resposta (Testemunha {testemunha_obj['nome']}):**"
-    return chamar_gemini_api(prompt, temperature=0.6, max_output_tokens=200)
+    return chamar_gemini_api(prompt, temperature=0.6, max_output_tokens=250)
 
 def analisar_atuacao_defesa_ia(estado_simulacao, ultima_fala_reu=""):
+    # (Função mantida como no Script 1 original)
     historico_completo_dialogo = formatar_historico_para_prompt(estado_simulacao["transcricao_logica"], max_turns=len(estado_simulacao["transcricao_logica"]))
     prompt_analise = f"**Persona:** Professor(a) de Prática Jurídica experiente.\n**Tarefa:** Feedback construtivo para aluno (Adv. RÉU - Jornal) em AIJ (Direito Esquecimento vs Liberdade Imprensa).\n**Fatos:** {estado_simulacao['caso_fatos'] or 'Não detalhado.'}\n**Provas/Argumentos Réu:** {estado_simulacao['provas_reu_texto'] or 'Não detalhado.'}\n**Transcrição AIJ:** {historico_completo_dialogo}\n**Última Intervenção Réu:** \"{ultima_fala_reu}\"\n**Feedback Detalhado (Pontos Fortes, Melhorias, Sugestões, Fundamentação, Estratégia):**"
-    return chamar_gemini_api(prompt_analise, temperature=0.65, max_output_tokens=1000)
-
+    return chamar_gemini_api(prompt_analise, temperature=0.65, max_output_tokens=1200)
+
+# --- Novas Funções de IA para Treinamento (inspiradas em Script 2) ---
+def avaliar_argumentos_defesa_ia(fatos_caso, provas_reu, tipo_argumento, argumento_usuario):
+    if not argumento_usuario.strip():
+        return "Por favor, insira seus argumentos para avaliação."
+
+    contexto_caso = f"""
+    Você está avaliando argumentos no contexto de um caso jurídico no Brasil sobre direito ao esquecimento vs. liberdade de imprensa.
+    O usuário representa a defesa (jornal).
+    **Fatos do Caso:** {fatos_caso if fatos_caso else CASO_DESCRICAO_PREDEFINIDO}
+    **Principais Argumentos/Provas da Defesa (Jornal):** {provas_reu if provas_reu else "\n".join(CONTRA_ARGUMENTOS_REU_PREDEFINIDOS)}
+    """
+    prompt = f"""
+    {contexto_caso}
+
+    **Persona:** Você é um Juiz experiente em um tribunal brasileiro, com especialidade em casos de liberdade de imprensa e direitos da personalidade.
+    **Tarefa:** Avalie o seguinte argumento apresentado pelo advogado de defesa (jornal) para a peça/momento processual: "{tipo_argumento}".
+    Forneça feedback detalhado e construtivo em português brasileiro, incluindo:
+    1.  **Pontos Fortes:** Destaque aspectos positivos (ex: fundamentação legal sólida, coerência lógica, clareza, persuasão, uso de fatos).
+    2.  **Pontos a Melhorar:** Identifique fraquezas (ex: falta de aprofundamento, generalizações, omissão de contrapontos importantes, linguagem inadequada, falta de nexo com os fatos/provas do réu).
+    3.  **Sugestões Específicas:** Ofereça conselhos práticos para aprimoramento (ex: citar precedentes específicos como o RE 1.010.606/STF, refutar explicitamente possíveis argumentos do autor, conectar melhor o argumento às provas do réu, sugerir redação alternativa).
+    4.  **Nota Geral (0 a 5):** Atribua uma nota considerando:
+        *   Fundamentação Legal/Jurisprudencial (Peso 3)
+        *   Coerência e Lógica (Peso 2)
+        *   Persuasão e Clareza (Peso 2)
+        *   Adequação ao tipo de peça/momento (Peso 1)
+        *   Conexão com os fatos/provas do caso (Peso 2)
+
+    Formato da Resposta: Utilize linguagem formal e jurídica. Estruture a resposta rigorosamente com os títulos:
+    `### Pontos Fortes`
+    `### Pontos a Melhorar`
+    `### Sugestões Específicas`
+    `### Nota Geral`
+
+    **Argumento do Advogado de Defesa (Jornal):**
+    "{argumento_usuario}"
+
+    **Sua Avaliação:**
+    """
+    return chamar_gemini_api(prompt, temperature=0.6, max_output_tokens=1000)
+
+def gerar_resposta_testemunha_defesa_para_treino_ia(fatos_caso, nome_testemunha, pontos_chave_testemunha, historico_perguntas_respostas, pergunta_atual_adv_defesa):
+    contexto_caso = f"""
+    Você está simulando o depoimento de uma testemunha de DEFESA (Jornal) em uma Audiência de Instrução e Julgamento (AIJ) no Brasil.
+    O caso envolve Direito ao Esquecimento vs. Liberdade de Imprensa. O jornal (réu) é processado por relembrar um crime antigo (com absolvição) do autor.
+    **Fatos do Caso:** {fatos_caso if fatos_caso else CASO_DESCRICAO_PREDEFINIDO}
+    """
+    historico_formatado = "\nDepoimento até agora:\n"
+    for p, r in historico_perguntas_respostas:
+        historico_formatado += f"- Advogado Defesa: {p}\n- {nome_testemunha}: {r}\n"
+
+    prompt = f"""
+    {contexto_caso}
+
+    **Persona:** Você é {nome_testemunha}, testemunha arrolada pela DEFESA (Jornal).
+    **Seus Pontos Chave a Defender/Explicar:** {pontos_chave_testemunha}
+    Você deve responder às perguntas do advogado de defesa de forma consistente com esses pontos e com a tese da defesa (liberdade de imprensa, interesse público, veracidade, ausência de dolo/culpa, destaque à absolvição do autor no caso original).
+    Use linguagem formal, mas acessível para uma testemunha. Seja objetivo e direto. Evite admitir qualquer falha ou negligência por parte do jornal.
+    {historico_formatado if historico_perguntas_respostas else "Este é o início do seu depoimento."}
+
+    **Pergunta do Advogado de Defesa (Jornal):** "{pergunta_atual_adv_defesa}"
+
+    **Sua Resposta ({nome_testemunha}):**
+    """
+    return chamar_gemini_api(prompt, temperature=0.5, max_output_tokens=300)
+
+
+# --- Funções de Lógica da Simulação e UI (from Script 1, adaptadas e com novas) ---
 def adicionar_fala_transcricao(estado_simulacao, ator, fala):
+    # (Função mantida como no Script 1 original)
     estado_simulacao["transcricao_logica"].append((ator, fala))
     if ator == "Advogado do Réu (Você)": estado_simulacao["transcricao_chat"].append((fala, None))
     else:
@@ -205,6 +366,7 @@ def adicionar_fala_transcricao(estado_simulacao, ator, fala):
     return estado_simulacao
 
 def mostrar_botoes_corretos(fase_atual):
+    # (Função mantida como no Script 1 original)
     vis = {
         "btn_responder_conciliacao": fase_atual == FASE_ABERTURA_CONCILIACAO,
         "btn_chamar_testemunha_reu": fase_atual == FASE_TESTEMUNHAS_REU_INICIO,
@@ -217,83 +379,147 @@ def mostrar_botoes_corretos(fase_atual):
     }
     return [gr.update(visible=vis[k]) for k in sorted(vis.keys())]
 
-
 def configurar_e_iniciar_simulacao(estado_s, fatos, p_reu, p_autor, t_reu_str, t_autor_str):
+    # (Função adaptada do Script 1)
     novo_estado = estado_inicial_simulacao()
+    if not fatos or not p_reu or not p_autor: # Basic validation
+        gr.Warning("Por favor, preencha todos os campos de configuração do caso ou carregue o caso padrão.")
+        return [novo_estado, novo_estado["transcricao_chat"], "Erro: Configuração incompleta.", "Preencha a configuração.", gr.Dropdown(choices=[], value=None)] + mostrar_botoes_corretos(novo_estado["fase_aij"])
+
     novo_estado["caso_fatos"], novo_estado["provas_reu_texto"], novo_estado["provas_autor_supostas_texto"] = fatos, p_reu, p_autor
     def parse_testemunhas(t_str):
-        return [{"nome": p[0].strip(), "pontos_chave": p[1].strip() if len(p) == 2 else "Não especificado."} for linha in t_str.strip().split('\n') if linha.strip() and (p := linha.split(':', 1))]
-    novo_estado["testemunhas_reu_defs"], novo_estado["testemunhas_autor_supostas_defs"] = parse_testemunhas(t_reu_str), parse_testemunhas(t_autor_str)
+        defs = []
+        if t_str and t_str.strip():
+            for linha in t_str.strip().split('\n'):
+                if linha.strip():
+                    partes = linha.split(':', 1)
+                    if len(partes) == 2:
+                        defs.append({"nome": partes[0].strip(), "pontos_chave": partes[1].strip()})
+                    elif len(partes) == 1 and partes[0].strip(): # Testemunha sem pontos chave explícitos
+                        defs.append({"nome": partes[0].strip(), "pontos_chave": "Não especificado."})
+        return defs
+
+    novo_estado["testemunhas_reu_defs"] = parse_testemunhas(t_reu_str)
+    novo_estado["testemunhas_autor_supostas_defs"] = parse_testemunhas(t_autor_str)
+
     novo_estado["fase_aij"] = FASE_ABERTURA_CONCILIACAO
     novo_estado = adicionar_fala_transcricao(novo_estado, "Sistema", "Configuração salva. Iniciando simulação...")
+    gr.Info("Iniciando simulação... Gerando falas iniciais da IA.")
     fala_juiz = gerar_resposta_juiz_ia(novo_estado)
     novo_estado = adicionar_fala_transcricao(novo_estado, "Juiz (IA)", fala_juiz)
     fala_adv_autor = gerar_resposta_advogado_autor_ia(novo_estado)
     novo_estado = adicionar_fala_transcricao(novo_estado, "Advogado do Autor (IA)", fala_adv_autor)
     novo_estado["instrucao_para_usuario"] = "Responda à proposta de conciliação do Autor ou declare sua posição."
     novo_estado["feedback_para_usuario"] = analisar_atuacao_defesa_ia(novo_estado)
-    nomes_testemunhas_reu = [t["nome"] for t in novo_estado["testemunhas_reu_defs"]]
+    nomes_testemunhas_reu = [t["nome"] for t in novo_estado["testemunhas_reu_defs"]] if novo_estado["testemunhas_reu_defs"] else []
     botoes_vis = mostrar_botoes_corretos(novo_estado["fase_aij"])
-    return [novo_estado, novo_estado["transcricao_chat"], novo_estado["feedback_para_usuario"], novo_estado["instrucao_para_usuario"], gr.Dropdown(choices=nomes_testemunhas_reu, value=None)] + botoes_vis
+    gr.Info("Simulação iniciada.")
+    return [novo_estado, novo_estado["transcricao_chat"], novo_estado["feedback_para_usuario"], novo_estado["instrucao_para_usuario"], gr.Dropdown(choices=nomes_testemunhas_reu, value=None, interactive=True)] + botoes_vis
 
 def lidar_com_fala_usuario(estado_s, fala_usuario_txt):
+    # (Função mantida como no Script 1 original, com pequenas adaptações)
     if not fala_usuario_txt and estado_s["fase_aij"] not in [FASE_TESTEMUNHAS_REU_INICIO]:
         estado_s["instrucao_para_usuario"] = "Por favor, digite sua fala ou selecione uma ação."
         return [estado_s, estado_s["transcricao_chat"], estado_s["feedback_para_usuario"], estado_s["instrucao_para_usuario"], gr.Textbox(value="")] + mostrar_botoes_corretos(estado_s["fase_aij"])
 
     estado_s = copy.deepcopy(estado_s)
     ator_usuario = "Advogado do Réu (Você)"
-    if estado_s["fase_aij"] == FASE_TESTEMUNHAS_REU_PERGUNTAS_REU: ator_usuario = f"Advogado do Réu (Você) perguntando a {estado_s['testemunha_em_depoimento']['nome']}"
-    elif estado_s["fase_aij"] == FASE_TESTEMUNHAS_REU_INQUIRICAO_AUTOR: ator_usuario = f"Testemunha {estado_s['testemunha_em_depoimento']['nome']} (Réu) respondendo"
-    if fala_usuario_txt: estado_s = adicionar_fala_transcricao(estado_s, ator_usuario, fala_usuario_txt)
+    if estado_s["fase_aij"] == FASE_TESTEMUNHAS_REU_PERGUNTAS_REU and estado_s.get("testemunha_em_depoimento"):
+        ator_usuario = f"Advogado do Réu (Você) perguntando a {estado_s['testemunha_em_depoimento']['nome']}"
+    elif estado_s["fase_aij"] == FASE_TESTEMUNHAS_REU_INQUIRICAO_AUTOR and estado_s.get("testemunha_em_depoimento"):
+        ator_usuario = f"Testemunha {estado_s['testemunha_em_depoimento']['nome']} (Réu) respondendo"
+
+    if fala_usuario_txt:
+        estado_s = adicionar_fala_transcricao(estado_s, ator_usuario, fala_usuario_txt)
+        gr.Info(f"Sua fala registrada. Aguardando respostas da IA...")
 
+    # Lógica de transição de fases e respostas da IA
     if estado_s["fase_aij"] == FASE_ABERTURA_CONCILIACAO:
         fala_adv_autor = gerar_resposta_advogado_autor_ia(estado_s, fala_adv_reu=fala_usuario_txt)
         estado_s = adicionar_fala_transcricao(estado_s, "Advogado do Autor (IA)", fala_adv_autor)
         fala_juiz = gerar_resposta_juiz_ia(estado_s, acao_especifica="Partes se manifestaram sobre conciliação. Decida o prosseguimento.")
         estado_s = adicionar_fala_transcricao(estado_s, "Juiz (IA)", fala_juiz)
-        if any(k in fala_juiz.lower() for k in ["testemunha", "instrução", "prossegu"]):
-            if estado_s["testemunhas_autor_supostas_defs"]: estado_s["fase_aij"], estado_s["instrucao_para_usuario"] = FASE_TESTEMUNHAS_AUTOR_INICIO, "Aguarde Juiz/Adv.Autor chamarem testemunha."
-            elif estado_s["testemunhas_reu_defs"]: estado_s["fase_aij"], estado_s["instrucao_para_usuario"] = FASE_TESTEMUNHAS_REU_INICIO, "Selecione sua testemunha."
-            else: estado_s["fase_aij"], estado_s["instrucao_para_usuario"] = FASE_ALEGACOES_FINAIS_AUTOR, "Aguarde Juiz iniciar Alegações Finais."
-        else: estado_s["instrucao_para_usuario"] = "Responda ao Juiz ou Adv. Autor sobre conciliação."
+        if any(k in fala_juiz.lower() for k in ["testemunha", "instrução", "prossegu", "oitiva"]):
+            if estado_s["testemunhas_autor_supostas_defs"]:
+                estado_s["fase_aij"], estado_s["instrucao_para_usuario"] = FASE_TESTEMUNHAS_AUTOR_INICIO, "Aguarde Juiz/Adv.Autor chamarem testemunha."
+                # Adicionar fala do Adv. Autor chamando a testemunha
+                fala_adv_autor_chamando = gerar_resposta_advogado_autor_ia(estado_s)
+                estado_s = adicionar_fala_transcricao(estado_s, "Advogado do Autor (IA)", fala_adv_autor_chamando)
+                if not ("Não tenho mais testemunhas" in fala_adv_autor_chamando or "Não arrolei testemunhas" in fala_adv_autor_chamando):
+                    estado_s["testemunha_autor_atual_idx"] += 1
+                    idx = estado_s["testemunha_autor_atual_idx"]
+                    if idx < len(estado_s["testemunhas_autor_supostas_defs"]):
+                        t_info = estado_s["testemunhas_autor_supostas_defs"][idx]
+                        estado_s["testemunha_em_depoimento"] = {"nome": t_info["nome"], "pontos_chave": t_info["pontos_chave"], "parte": "AUTOR"}
+                        fala_test_autor = gerar_resposta_testemunha_autor_ia(estado_s, pergunta_feita=fala_adv_autor_chamando)
+                        estado_s = adicionar_fala_transcricao(estado_s, f"Testemunha {t_info['nome']} (Autor - IA)", fala_test_autor)
+                        estado_s["fase_aij"], estado_s["instrucao_para_usuario"] = FASE_TESTEMUNHAS_AUTOR_CONTRADITA_REU, f"Contradite/pergunte à testemunha {t_info['nome']} (Autor)."
+            elif estado_s["testemunhas_reu_defs"]:
+                estado_s["fase_aij"], estado_s["instrucao_para_usuario"] = FASE_TESTEMUNHAS_REU_INICIO, "Selecione sua testemunha para chamar."
+            else:
+                estado_s["fase_aij"], estado_s["instrucao_para_usuario"] = FASE_ALEGACOES_FINAIS_AUTOR, "Aguarde Juiz iniciar Alegações Finais."
+                # Se for para alegações do autor, o juiz deve dar a palavra e o adv. autor falar
+                fala_juiz_aleg = gerar_resposta_juiz_ia(estado_s)
+                estado_s = adicionar_fala_transcricao(estado_s, "Juiz (IA)", fala_juiz_aleg)
+                fala_aleg_autor = gerar_resposta_advogado_autor_ia(estado_s)
+                estado_s = adicionar_fala_transcricao(estado_s, "Advogado do Autor (IA)", fala_aleg_autor)
+                estado_s["fase_aij"], estado_s["instrucao_para_usuario"] = FASE_ALEGACOES_FINAIS_REU, "Apresente suas Alegações Finais."
+        else:
+            estado_s["instrucao_para_usuario"] = "Responda ao Juiz ou Adv. Autor sobre conciliação."
+
     elif estado_s["fase_aij"] == FASE_TESTEMUNHAS_AUTOR_CONTRADITA_REU:
         fala_test_autor = gerar_resposta_testemunha_autor_ia(estado_s, pergunta_feita=fala_usuario_txt)
         estado_s = adicionar_fala_transcricao(estado_s, f"Testemunha {estado_s['testemunha_em_depoimento']['nome']} (Autor - IA)", fala_test_autor)
-        estado_s["instrucao_para_usuario"] = f"Faça outra pergunta à testemunha {estado_s['testemunha_em_depoimento']['nome']} (Autor) ou aguarde Juiz."
-    elif estado_s["fase_aij"] == FASE_TESTEMUNHAS_REU_PERGUNTAS_REU:
+        estado_s["instrucao_para_usuario"] = f"Faça outra pergunta à testemunha {estado_s['testemunha_em_depoimento']['nome']} (Autor) ou clique 'Juiz Avançar'."
+
+    elif estado_s["fase_aij"] == FASE_TESTEMUNHAS_REU_PERGUNTAS_REU: # Usuário (Adv Réu) perguntou à sua testemunha
+        # Aqui, o usuário está *atuando* como sua testemunha para responder à sua própria pergunta.
+        # A IA do Adv. Autor fará perguntas à testemunha do Réu.
+        # O usuário deve então responder como se fosse sua testemunha.
+        # Após a pergunta do usuário à sua testemunha, e a resposta simulada (pelo usuário mesmo, no chat),
+        # o Adv. Autor (IA) deve ter a chance de inquirir.
         estado_s["fase_aij"] = FASE_TESTEMUNHAS_REU_INQUIRICAO_AUTOR
-        fala_adv_autor_ia = gerar_resposta_advogado_autor_ia(estado_s)
+        fala_adv_autor_ia = gerar_resposta_advogado_autor_ia(estado_s) # Adv. Autor IA pergunta à testemunha do Réu
         estado_s = adicionar_fala_transcricao(estado_s, "Advogado do Autor (IA)", fala_adv_autor_ia)
-        estado_s["instrucao_para_usuario"] = f"Responda (como {estado_s['testemunha_em_depoimento']['nome']}) à pergunta do Adv. Autor."
-    elif estado_s["fase_aij"] == FASE_TESTEMUNHAS_REU_INQUIRICAO_AUTOR:
-        fala_adv_autor_ia = gerar_resposta_advogado_autor_ia(estado_s, fala_adv_reu=fala_usuario_txt)
+        estado_s["instrucao_para_usuario"] = f"Como testemunha {estado_s['testemunha_em_depoimento']['nome']}, responda à pergunta do Adv. Autor."
+
+    elif estado_s["fase_aij"] == FASE_TESTEMUNHAS_REU_INQUIRICAO_AUTOR: # Usuário respondeu como sua testemunha à pergunta do Adv. Autor
+        # Advogado do Autor (IA) pode fazer mais perguntas ou encerrar.
+        fala_adv_autor_ia = gerar_resposta_advogado_autor_ia(estado_s, fala_adv_reu=fala_usuario_txt) # Passa a resposta da testemunha do réu
         estado_s = adicionar_fala_transcricao(estado_s, "Advogado do Autor (IA)", fala_adv_autor_ia)
-        if "pergunta" in fala_adv_autor_ia.lower() or "?" in fala_adv_autor_ia: estado_s["instrucao_para_usuario"] = f"Responda (como {estado_s['testemunha_em_depoimento']['nome']}) à nova pergunta."
-        else: estado_s["fase_aij"], estado_s["instrucao_para_usuario"] = FASE_TESTEMUNHAS_REU_PERGUNTAS_REU, f"Faça mais perguntas à {estado_s['testemunha_em_depoimento']['nome']} ou clique 'Juiz Avançar'."
+        if "pergunta" in fala_adv_autor_ia.lower() or "?" in fala_adv_autor_ia and "não tenho mais perguntas" not in fala_adv_autor_ia.lower():
+            estado_s["instrucao_para_usuario"] = f"Como testemunha {estado_s['testemunha_em_depoimento']['nome']}, responda à nova pergunta do Adv. Autor."
+        else: # Adv. Autor não tem mais perguntas
+            fala_juiz = gerar_resposta_juiz_ia(estado_s, acao_especifica=f"Adv. Autor encerrou inquirição da testemunha {estado_s['testemunha_em_depoimento']['nome']}. Adv. Réu pode fazer mais perguntas ou dispensar.")
+            estado_s = adicionar_fala_transcricao(estado_s, "Juiz (IA)", fala_juiz)
+            estado_s["fase_aij"] = FASE_TESTEMUNHAS_REU_PERGUNTAS_REU # Volta para Adv. Réu perguntar
+            estado_s["instrucao_para_usuario"] = f"Faça mais perguntas à sua testemunha {estado_s['testemunha_em_depoimento']['nome']}, ou clique 'Juiz Avançar' para dispensá-la."
+
     elif estado_s["fase_aij"] == FASE_ALEGACOES_FINAIS_REU:
-        # estado_s = adicionar_fala_transcricao(estado_s, "Advogado do Réu (Você)", fala_usuario_txt) # Já adicionado no início da função
         estado_s["fase_aij"] = FASE_ANALISE_FINAL_PROFESSOR
         fala_juiz = gerar_resposta_juiz_ia(estado_s)
         estado_s = adicionar_fala_transcricao(estado_s, "Juiz (IA)", fala_juiz)
-        estado_s["instrucao_para_usuario"] = "Audiência encerrada. Veja feedback final."
-    
+        estado_s["instrucao_para_usuario"] = "Audiência encerrada para sentença (simulada). Veja o feedback final do Professor IA."
+        # Analise final é chamada abaixo
+
     estado_s["feedback_para_usuario"] = analisar_atuacao_defesa_ia(estado_s, ultima_fala_reu=fala_usuario_txt if ator_usuario == "Advogado do Réu (Você)" else "")
+    gr.Info("Respostas da IA geradas.")
     return [estado_s, estado_s["transcricao_chat"], estado_s["feedback_para_usuario"], estado_s["instrucao_para_usuario"], gr.Textbox(value="")] + mostrar_botoes_corretos(estado_s["fase_aij"])
 
 def acao_botao_juiz_avancar(estado_s):
+    # (Função mantida e adaptada do Script 1)
     estado_s = copy.deepcopy(estado_s)
     fase_atual = estado_s["fase_aij"]
-    acao_juiz_txt = "A parte solicitou o avanço ou encerramento da fase atual."
+    gr.Info(f"Avançando fase a partir de: {fase_atual}. Aguarde IA...")
 
     if fase_atual == FASE_ABERTURA_CONCILIACAO:
-        if estado_s["testemunhas_autor_supostas_defs"]: estado_s["fase_aij"], acao_juiz_txt = FASE_TESTEMUNHAS_AUTOR_INICIO, "Conciliação infrutífera. Inicie oitiva testemunhas Autor."
-        elif estado_s["testemunhas_reu_defs"]: estado_s["fase_aij"], acao_juiz_txt = FASE_TESTEMUNHAS_REU_INICIO, "Sem testemunhas Autor. Inicie oitiva testemunhas Réu."
-        else: estado_s["fase_aij"], acao_juiz_txt = FASE_ALEGACOES_FINAIS_AUTOR, "Sem testemunhas. Prossiga alegações finais Autor."
-        fala_juiz = gerar_resposta_juiz_ia(estado_s, acao_especifica=acao_juiz_txt) # Juiz comanda nova fase
-        estado_s = adicionar_fala_transcricao(estado_s, "Juiz (IA)", fala_juiz)
-        if estado_s["fase_aij"] == FASE_TESTEMUNHAS_AUTOR_INICIO: # Se for para testemunha do autor, adv autor precisa agir
-            fala_adv_autor = gerar_resposta_advogado_autor_ia(estado_s)
+        # Se partes não chegaram a acordo, ou se o usuário pulou a conciliação.
+        estado_s = adicionar_fala_transcricao(estado_s, "Juiz (IA)", "Considerando frustrada a tentativa de conciliação, passaremos à instrução.")
+        if estado_s["testemunhas_autor_supostas_defs"]:
+            estado_s["fase_aij"] = FASE_TESTEMUNHAS_AUTOR_INICIO
+            fala_juiz = gerar_resposta_juiz_ia(estado_s)
+            estado_s = adicionar_fala_transcricao(estado_s, "Juiz (IA)", fala_juiz)
+            fala_adv_autor = gerar_resposta_advogado_autor_ia(estado_s) # Adv Autor chama/pergunta
             estado_s = adicionar_fala_transcricao(estado_s, "Advogado do Autor (IA)", fala_adv_autor)
             if not ("Não tenho mais testemunhas" in fala_adv_autor or "Não arrolei testemunhas" in fala_adv_autor):
                 estado_s["testemunha_autor_atual_idx"] += 1
@@ -301,164 +527,462 @@ def acao_botao_juiz_avancar(estado_s):
                 if idx < len(estado_s["testemunhas_autor_supostas_defs"]):
                     t_info = estado_s["testemunhas_autor_supostas_defs"][idx]
                     estado_s["testemunha_em_depoimento"] = {"nome": t_info["nome"], "pontos_chave": t_info["pontos_chave"], "parte": "AUTOR"}
-                    fala_test_autor = gerar_resposta_testemunha_autor_ia(estado_s, pergunta_feita=fala_adv_autor)
+                    fala_test_autor = gerar_resposta_testemunha_autor_ia(estado_s, pergunta_feita=fala_adv_autor) # Testemunha responde à pergunta inicial
                     estado_s = adicionar_fala_transcricao(estado_s, f"Testemunha {t_info['nome']} (Autor - IA)", fala_test_autor)
-                    estado_s["fase_aij"], estado_s["instrucao_para_usuario"] = FASE_TESTEMUNHAS_AUTOR_CONTRADITA_REU, f"Contradite {t_info['nome']} (Autor)."
-            # Se adv autor não tem testemunhas, a lógica de transição já teria ido para o réu ou alegações
+                    estado_s["fase_aij"], estado_s["instrucao_para_usuario"] = FASE_TESTEMUNHAS_AUTOR_CONTRADITA_REU, f"Contradite ou faça perguntas à testemunha {t_info['nome']} (Autor)."
+            else: # Adv Autor não tem testemunhas, mesmo que tenha sido definido
+                 if estado_s["testemunhas_reu_defs"]: estado_s["fase_aij"], estado_s["instrucao_para_usuario"] = FASE_TESTEMUNHAS_REU_INICIO, "Selecione sua testemunha para chamar."
+                 else: estado_s["fase_aij"] = FASE_ALEGACOES_FINAIS_AUTOR # Pula para alegações finais
+        elif estado_s["testemunhas_reu_defs"]:
+            estado_s["fase_aij"] = FASE_TESTEMUNHAS_REU_INICIO
+            fala_juiz = gerar_resposta_juiz_ia(estado_s)
+            estado_s = adicionar_fala_transcricao(estado_s, "Juiz (IA)", fala_juiz)
+            estado_s["instrucao_para_usuario"] = "Selecione sua testemunha para chamar."
+        else: # Sem testemunhas de nenhuma parte
+            estado_s["fase_aij"] = FASE_ALEGACOES_FINAIS_AUTOR
+            fala_juiz = gerar_resposta_juiz_ia(estado_s) # Juiz anuncia alegações
+            estado_s = adicionar_fala_transcricao(estado_s, "Juiz (IA)", fala_juiz)
+            fala_adv_autor = gerar_resposta_advogado_autor_ia(estado_s) # Adv Autor faz alegações
+            estado_s = adicionar_fala_transcricao(estado_s, "Advogado do Autor (IA)", fala_adv_autor)
+            estado_s["fase_aij"], estado_s["instrucao_para_usuario"] = FASE_ALEGACOES_FINAIS_REU, "Apresente suas Alegações Finais."
+
     elif fase_atual == FASE_TESTEMUNHAS_AUTOR_INICIO or fase_atual == FASE_TESTEMUNHAS_AUTOR_PERGUNTAS_AUTOR:
-        fala_juiz = gerar_resposta_juiz_ia(estado_s)
+        # Juiz pede ao Adv. Autor para chamar a *próxima* testemunha ou encerrar
+        fala_juiz = gerar_resposta_juiz_ia(estado_s, acao_especifica="Verificar se há mais testemunhas do Autor ou encerrar esta fase.")
         estado_s = adicionar_fala_transcricao(estado_s, "Juiz (IA)", fala_juiz)
-        fala_adv_autor = gerar_resposta_advogado_autor_ia(estado_s)
+        fala_adv_autor = gerar_resposta_advogado_autor_ia(estado_s) # Adv. Autor chama próxima ou diz que não tem mais
         estado_s = adicionar_fala_transcricao(estado_s, "Advogado do Autor (IA)", fala_adv_autor)
-        if "Não tenho mais testemunhas" in fala_adv_autor or "Não arrolei testemunhas" in fala_adv_autor:
-            if estado_s["testemunhas_reu_defs"]: estado_s["fase_aij"], estado_s["instrucao_para_usuario"] = FASE_TESTEMUNHAS_REU_INICIO, "Selecione sua testemunha."
-            else: estado_s["fase_aij"], estado_s["instrucao_para_usuario"] = FASE_ALEGACOES_FINAIS_AUTOR, "Aguarde Juiz iniciar Alegações Finais."
-            fala_juiz_trans = gerar_resposta_juiz_ia(estado_s) # Juiz anuncia a nova fase
-            estado_s = adicionar_fala_transcricao(estado_s, "Juiz (IA)", fala_juiz_trans)
-        else:
-            estado_s["testemunha_autor_atual_idx"] += 1; idx = estado_s["testemunha_autor_atual_idx"]
+
+        if "Não tenho mais testemunhas" in fala_adv_autor or "Não arrolei testemunhas" in fala_adv_autor or estado_s["testemunha_autor_atual_idx"] +1 >= len(estado_s["testemunhas_autor_supostas_defs"]):
+            estado_s["testemunha_em_depoimento"] = None
+            if estado_s["testemunhas_reu_defs"]:
+                estado_s["fase_aij"] = FASE_TESTEMUNHAS_REU_INICIO
+                fala_juiz_trans = gerar_resposta_juiz_ia(estado_s) # Juiz anuncia oitiva das testemunhas do Réu
+                estado_s = adicionar_fala_transcricao(estado_s, "Juiz (IA)", fala_juiz_trans)
+                estado_s["instrucao_para_usuario"] = "Selecione sua testemunha para chamar."
+            else: # Sem testemunhas do Réu, vai para alegações finais
+                estado_s["fase_aij"] = FASE_ALEGACOES_FINAIS_AUTOR
+                fala_juiz_trans = gerar_resposta_juiz_ia(estado_s) # Juiz anuncia alegações
+                estado_s = adicionar_fala_transcricao(estado_s, "Juiz (IA)", fala_juiz_trans)
+                fala_aleg_autor = gerar_resposta_advogado_autor_ia(estado_s) # Adv Autor faz alegações
+                estado_s = adicionar_fala_transcricao(estado_s, "Advogado do Autor (IA)", fala_aleg_autor)
+                estado_s["fase_aij"], estado_s["instrucao_para_usuario"] = FASE_ALEGACOES_FINAIS_REU, "Apresente suas Alegações Finais."
+        else: # Adv Autor chamou próxima testemunha
+            estado_s["testemunha_autor_atual_idx"] += 1
+            idx = estado_s["testemunha_autor_atual_idx"]
+            # Garantir que o índice é válido
             if idx < len(estado_s["testemunhas_autor_supostas_defs"]):
                 t_info = estado_s["testemunhas_autor_supostas_defs"][idx]
                 estado_s["testemunha_em_depoimento"] = {"nome": t_info["nome"], "pontos_chave": t_info["pontos_chave"], "parte": "AUTOR"}
-                fala_test_autor = gerar_resposta_testemunha_autor_ia(estado_s, pergunta_feita=fala_adv_autor)
+                fala_test_autor = gerar_resposta_testemunha_autor_ia(estado_s, pergunta_feita=fala_adv_autor) # Testemunha responde à pergunta inicial do Adv. Autor
                 estado_s = adicionar_fala_transcricao(estado_s, f"Testemunha {t_info['nome']} (Autor - IA)", fala_test_autor)
-                estado_s["fase_aij"], estado_s["instrucao_para_usuario"] = FASE_TESTEMUNHAS_AUTOR_CONTRADITA_REU, f"Contradite {t_info['nome']} (Autor)."
+                estado_s["fase_aij"], estado_s["instrucao_para_usuario"] = FASE_TESTEMUNHAS_AUTOR_CONTRADITA_REU, f"Contradite ou faça perguntas à testemunha {t_info['nome']} (Autor)."
+            else: # Caso raro de lógica inconsistente, trata como se não houvesse mais testemunhas
+                estado_s["fase_aij"] = FASE_TESTEMUNHAS_REU_INICIO # Ou alegações finais, conforme lógica acima
+                # ... (repetir lógica de transição para Réu ou Alegações)
+
     elif fase_atual == FASE_TESTEMUNHAS_AUTOR_CONTRADITA_REU:
+        # Usuário (Adv. Réu) terminou de perguntar à testemunha do Autor.
         estado_s["testemunha_em_depoimento"] = None
-        acao_juiz_txt = "Adv. Réu encerrou contradita test. Autor. Verifique mais test. Autor ou prossiga."
-        fala_juiz = gerar_resposta_juiz_ia(estado_s, acao_especifica=acao_juiz_txt)
-        estado_s = adicionar_fala_transcricao(estado_s, "Juiz (IA)", fala_juiz)
+        # Verificar se há mais testemunhas do Autor
         if estado_s["testemunha_autor_atual_idx"] + 1 < len(estado_s["testemunhas_autor_supostas_defs"]):
-            estado_s["fase_aij"], estado_s["instrucao_para_usuario"] = FASE_TESTEMUNHAS_AUTOR_INICIO, "Aguarde Juiz/Adv.Autor chamarem próxima test. Autor."
+            estado_s["fase_aij"] = FASE_TESTEMUNHAS_AUTOR_INICIO # Volta para o juiz pedir ao Adv. Autor chamar a próxima
+            fala_juiz = gerar_resposta_juiz_ia(estado_s, acao_especifica="Advogado do Réu encerrou perguntas à testemunha do Autor. Verificar próxima testemunha do Autor.")
+            estado_s = adicionar_fala_transcricao(estado_s, "Juiz (IA)", fala_juiz)
             # Adv Autor precisa ser chamado para agir
             fala_adv_autor = gerar_resposta_advogado_autor_ia(estado_s) # Adv Autor chama/pergunta
             estado_s = adicionar_fala_transcricao(estado_s, "Advogado do Autor (IA)", fala_adv_autor)
             if not ("Não tenho mais testemunhas" in fala_adv_autor or "Não arrolei testemunhas" in fala_adv_autor):
-                estado_s["testemunha_autor_atual_idx"] += 1; idx_new = estado_s["testemunha_autor_atual_idx"]
+                estado_s["testemunha_autor_atual_idx"] += 1
+                idx_new = estado_s["testemunha_autor_atual_idx"]
                 if idx_new < len(estado_s["testemunhas_autor_supostas_defs"]):
                     t_info_new = estado_s["testemunhas_autor_supostas_defs"][idx_new]
                     estado_s["testemunha_em_depoimento"] = {"nome": t_info_new["nome"], "pontos_chave": t_info_new["pontos_chave"], "parte": "AUTOR"}
                     fala_test_autor_new = gerar_resposta_testemunha_autor_ia(estado_s, pergunta_feita=fala_adv_autor)
                     estado_s = adicionar_fala_transcricao(estado_s, f"Testemunha {t_info_new['nome']} (Autor - IA)", fala_test_autor_new)
-                    estado_s["fase_aij"], estado_s["instrucao_para_usuario"] = FASE_TESTEMUNHAS_AUTOR_CONTRADITA_REU, f"Contradite {t_info_new['nome']} (Autor)."
-
-        elif estado_s["testemunhas_reu_defs"]: estado_s["fase_aij"], estado_s["instrucao_para_usuario"] = FASE_TESTEMUNHAS_REU_INICIO, "Selecione sua testemunha."
-        else: estado_s["fase_aij"], estado_s["instrucao_para_usuario"] = FASE_ALEGACOES_FINAIS_AUTOR, "Aguarde Juiz iniciar Alegações Finais."
-        if fase_atual != estado_s["fase_aij"]: # Se mudou de fase principal, juiz anuncia
-            fala_juiz_trans = gerar_resposta_juiz_ia(estado_s)
-            estado_s = adicionar_fala_transcricao(estado_s, "Juiz (IA)", fala_juiz_trans)
-            if estado_s["fase_aij"] == FASE_ALEGACOES_FINAIS_AUTOR: # Se for para alegações do autor
-                fala_aleg_autor = gerar_resposta_advogado_autor_ia(estado_s)
+                    estado_s["fase_aij"], estado_s["instrucao_para_usuario"] = FASE_TESTEMUNHAS_AUTOR_CONTRADITA_REU, f"Contradite ou faça perguntas à testemunha {t_info_new['nome']} (Autor)."
+            else: # Adv. Autor não tem mais, mesmo que houvesse na lista (raro)
+                 if estado_s["testemunhas_reu_defs"]: estado_s["fase_aij"], estado_s["instrucao_para_usuario"] = FASE_TESTEMUNHAS_REU_INICIO, "Selecione sua testemunha para chamar."
+                 else: estado_s["fase_aij"] = FASE_ALEGACOES_FINAIS_AUTOR
+                 fala_juiz_trans = gerar_resposta_juiz_ia(estado_s) # Juiz comanda nova fase
+                 estado_s = adicionar_fala_transcricao(estado_s, "Juiz (IA)", fala_juiz_trans)
+                 if estado_s["fase_aij"] == FASE_ALEGACOES_FINAIS_AUTOR:
+                    fala_aleg_autor = gerar_resposta_advogado_autor_ia(estado_s)
+                    estado_s = adicionar_fala_transcricao(estado_s, "Advogado do Autor (IA)", fala_aleg_autor)
+                    estado_s["fase_aij"], estado_s["instrucao_para_usuario"] = FASE_ALEGACOES_FINAIS_REU, "Apresente suas Alegações Finais."
+
+        else: # Não há mais testemunhas do Autor
+            if estado_s["testemunhas_reu_defs"]:
+                estado_s["fase_aij"] = FASE_TESTEMUNHAS_REU_INICIO
+                fala_juiz = gerar_resposta_juiz_ia(estado_s, acao_especifica="Encerrada oitiva das testemunhas do Autor. Iniciar oitiva das testemunhas do Réu.")
+                estado_s = adicionar_fala_transcricao(estado_s, "Juiz (IA)", fala_juiz)
+                estado_s["instrucao_para_usuario"] = "Selecione sua testemunha para chamar."
+            else: # Sem testemunhas do Réu, vai para alegações finais
+                estado_s["fase_aij"] = FASE_ALEGACOES_FINAIS_AUTOR
+                fala_juiz = gerar_resposta_juiz_ia(estado_s, acao_especifica="Instrução encerrada. Passar para alegações finais do Autor.")
+                estado_s = adicionar_fala_transcricao(estado_s, "Juiz (IA)", fala_juiz)
+                fala_aleg_autor = gerar_resposta_advogado_autor_ia(estado_s) # Adv Autor faz alegações
                 estado_s = adicionar_fala_transcricao(estado_s, "Advogado do Autor (IA)", fala_aleg_autor)
                 estado_s["fase_aij"], estado_s["instrucao_para_usuario"] = FASE_ALEGACOES_FINAIS_REU, "Apresente suas Alegações Finais."
 
     elif fase_atual in [FASE_TESTEMUNHAS_REU_PERGUNTAS_REU, FASE_TESTEMUNHAS_REU_INQUIRICAO_AUTOR]:
+        # Usuário (Adv. Réu) dispensou sua testemunha atual.
+        nome_test_dispensada = estado_s.get("testemunha_em_depoimento", {}).get("nome", "a testemunha do Réu")
         estado_s["testemunha_em_depoimento"] = None
-        acao_juiz_txt = "Adv. Réu encerrou oitiva de sua testemunha. Verifique mais test. Réu ou Alegações Finais."
-        fala_juiz = gerar_resposta_juiz_ia(estado_s, acao_especifica=acao_juiz_txt)
-        estado_s = adicionar_fala_transcricao(estado_s, "Juiz (IA)", fala_juiz)
-        if estado_s["testemunha_reu_atual_idx"] + 1 < len(estado_s["testemunhas_reu_defs"]): estado_s["fase_aij"], estado_s["instrucao_para_usuario"] = FASE_TESTEMUNHAS_REU_INICIO, "Selecione sua próxima testemunha."
-        else:
-            estado_s["fase_aij"], estado_s["instrucao_para_usuario"] = FASE_ALEGACOES_FINAIS_AUTOR, "Aguarde Juiz iniciar Alegações Finais."
-            fala_juiz_trans = gerar_resposta_juiz_ia(estado_s)
-            estado_s = adicionar_fala_transcricao(estado_s, "Juiz (IA)", fala_juiz_trans)
-            fala_adv_autor = gerar_resposta_advogado_autor_ia(estado_s)
+        fala_juiz_dispensa = f"Juiz (IA): Dispensada {nome_test_dispensada}."
+        if estado_s.get("testemunha_em_depoimento"): # Adiciona só se havia uma testemunha em depoimento
+             fala_juiz_dispensa = gerar_resposta_juiz_ia(estado_s, acao_especifica=f"Dispensar {nome_test_dispensada}. Perguntar ao Adv. Réu se tem mais testemunhas.")
+        estado_s = adicionar_fala_transcricao(estado_s, "Juiz (IA)", fala_juiz_dispensa)
+
+
+        if estado_s["testemunha_reu_atual_idx"] + 1 < len(estado_s["testemunhas_reu_defs"]):
+            estado_s["fase_aij"] = FASE_TESTEMUNHAS_REU_INICIO # Volta para o usuário selecionar a próxima
+            estado_s["instrucao_para_usuario"] = "Selecione sua próxima testemunha para chamar ou clique 'Juiz Avançar' para encerrar oitiva das suas testemunhas."
+        else: # Não há mais testemunhas do Réu
+            estado_s["fase_aij"] = FASE_ALEGACOES_FINAIS_AUTOR
+            fala_juiz = gerar_resposta_juiz_ia(estado_s, acao_especifica="Encerrada oitiva das testemunhas do Réu. Passar para alegações finais do Autor.")
+            estado_s = adicionar_fala_transcricao(estado_s, "Juiz (IA)", fala_juiz)
+            fala_adv_autor = gerar_resposta_advogado_autor_ia(estado_s) # Adv Autor faz alegações
             estado_s = adicionar_fala_transcricao(estado_s, "Advogado do Autor (IA)", fala_adv_autor)
             estado_s["fase_aij"], estado_s["instrucao_para_usuario"] = FASE_ALEGACOES_FINAIS_REU, "Apresente suas Alegações Finais."
+
     elif fase_atual == FASE_ALEGACOES_FINAIS_AUTOR:
-        estado_s["fase_aij"], acao_juiz_txt = FASE_ALEGACOES_FINAIS_REU, "Adv. Autor concluiu. Passe palavra ao Adv. Réu."
-        fala_juiz = gerar_resposta_juiz_ia(estado_s, acao_especifica=acao_juiz_txt)
+        # Adv. Autor terminou alegações, Juiz passa palavra ao Réu
+        estado_s["fase_aij"] = FASE_ALEGACOES_FINAIS_REU
+        fala_juiz = gerar_resposta_juiz_ia(estado_s) # Juiz passa a palavra ao Réu
         estado_s = adicionar_fala_transcricao(estado_s, "Juiz (IA)", fala_juiz)
         estado_s["instrucao_para_usuario"] = "Apresente suas Alegações Finais."
-    else:
-        fala_juiz = gerar_resposta_juiz_ia(estado_s, acao_especifica="Conduza para próxima etapa.")
+    else: # Fallback para fases não explicitamente tratadas acima
+        fala_juiz = gerar_resposta_juiz_ia(estado_s, acao_especifica="Conduza para a próxima etapa lógica da audiência.")
         estado_s = adicionar_fala_transcricao(estado_s, "Juiz (IA)", fala_juiz)
-        estado_s["instrucao_para_usuario"] = "Siga instruções do Juiz."
+        estado_s["instrucao_para_usuario"] = "Siga as instruções do Juiz ou avance a fase."
 
     estado_s["feedback_para_usuario"] = analisar_atuacao_defesa_ia(estado_s)
+    gr.Info("Fase avançada. Interações da IA geradas.")
     return [estado_s, estado_s["transcricao_chat"], estado_s["feedback_para_usuario"], estado_s["instrucao_para_usuario"]] + mostrar_botoes_corretos(estado_s["fase_aij"])
 
 def chamar_testemunha_reu_selecionada(estado_s, nome_testemunha_selecionada):
+    # (Função mantida como no Script 1 original)
     estado_s = copy.deepcopy(estado_s)
     if not nome_testemunha_selecionada:
-        estado_s["instrucao_para_usuario"] = "Selecione uma testemunha."
+        estado_s["instrucao_para_usuario"] = "Nenhuma testemunha selecionada. Por favor, selecione uma testemunha da lista."
+        gr.Warning("Selecione uma testemunha da lista.")
         return [estado_s, estado_s["transcricao_chat"], estado_s["feedback_para_usuario"], estado_s["instrucao_para_usuario"]] + mostrar_botoes_corretos(estado_s["fase_aij"])
+
     idx_testemunha = next((i for i, t in enumerate(estado_s["testemunhas_reu_defs"]) if t["nome"] == nome_testemunha_selecionada), -1)
     if idx_testemunha == -1:
-        estado_s["instrucao_para_usuario"] = f"Testemunha '{nome_testemunha_selecionada}' não encontrada."
+        estado_s["instrucao_para_usuario"] = f"Testemunha '{nome_testemunha_selecionada}' não encontrada na configuração."
+        gr.Error(f"Testemunha '{nome_testemunha_selecionada}' não encontrada.")
         return [estado_s, estado_s["transcricao_chat"], estado_s["feedback_para_usuario"], estado_s["instrucao_para_usuario"]] + mostrar_botoes_corretos(estado_s["fase_aij"])
 
     estado_s["testemunha_reu_atual_idx"] = idx_testemunha
     testemunha_obj = estado_s["testemunhas_reu_defs"][idx_testemunha]
     estado_s["testemunha_em_depoimento"] = {"nome": testemunha_obj["nome"], "pontos_chave": testemunha_obj["pontos_chave"], "parte": "REU"}
-    estado_s = adicionar_fala_transcricao(estado_s, "Advogado do Réu (Você)", f"Chamo para depor minha testemunha, Sra./Sr. {testemunha_obj['nome']}.")
-    fala_juiz = gerar_resposta_juiz_ia(estado_s, acao_especifica=f"Adv. Réu chamou {testemunha_obj['nome']}. Qualifique e passe palavra para inquirição.")
+
+    gr.Info(f"Chamando testemunha {testemunha_obj['nome']}. Aguarde IA...")
+    estado_s = adicionar_fala_transcricao(estado_s, "Advogado do Réu (Você)", f"Chamo para depor minha testemunha, Sr(a). {testemunha_obj['nome']}.")
+    fala_juiz = gerar_resposta_juiz_ia(estado_s, acao_especifica=f"Advogado do Réu chamou a testemunha {testemunha_obj['nome']}. Qualifique-a e passe a palavra ao Advogado do Réu para inquirição inicial.")
     estado_s = adicionar_fala_transcricao(estado_s, "Juiz (IA)", fala_juiz)
-    estado_s["fase_aij"], estado_s["instrucao_para_usuario"] = FASE_TESTEMUNHAS_REU_PERGUNTAS_REU, f"Pergunte à sua testemunha {testemunha_obj['nome']}. Digite PERGUNTA e RESPOSTA."
+    estado_s["fase_aij"] = FASE_TESTEMUNHAS_REU_PERGUNTAS_REU
+    estado_s["instrucao_para_usuario"] = f"Faça sua primeira pergunta à sua testemunha, {testemunha_obj['nome']}. Após sua pergunta e a resposta (que você digitará no chat como se fosse a testemunha), o Advogado do Autor (IA) poderá inquirir."
     estado_s["feedback_para_usuario"] = analisar_atuacao_defesa_ia(estado_s)
+    gr.Info("Testemunha chamada. Interações da IA geradas.")
     return [estado_s, estado_s["transcricao_chat"], estado_s["feedback_para_usuario"], estado_s["instrucao_para_usuario"]] + mostrar_botoes_corretos(estado_s["fase_aij"])
 
-with gr.Blocks(theme=gr.themes.Soft(primary_hue="blue", secondary_hue="orange"), title="Simulador AIJ") as demo:
-    gr.Markdown("# ⚖️ Simulador de Audiência de Instrução e Julgamento (AIJ)")
-    gr.Markdown("Tema: **Direito ao Esquecimento vs. Liberdade de Imprensa**. Você é **Advogado(a) do Réu (Jornal)**.")
-    if not GEMINI_API_KEY: gr.Warning("API Key do Gemini não encontrada! Configure o Secret 'GEMINI_API_KEY' nas configurações deste Space.")
+# --- UI Callbacks para Novas Abas ---
+def avaliar_argumentos_defesa_ia_ui(fatos_caso_atual, provas_reu_atual, tipo_argumento_selecionado, argumento_digitado):
+    if not GEMINI_API_KEY: return "ERRO: API Key não configurada."
+    if not argumento_digitado or not tipo_argumento_selecionado:
+        return "Por favor, selecione o tipo de argumento e digite seu texto."
+    gr.Info(f"Avaliando seu argumento ({tipo_argumento_selecionado})... Aguarde.")
+    feedback = avaliar_argumentos_defesa_ia(fatos_caso_atual, provas_reu_atual, tipo_argumento_selecionado, argumento_digitado)
+    gr.Info("Avaliação concluída.")
+    return feedback
+
+_historico_treino_testemunha_atual = [] # Simples cache para o diálogo de treino
+def gerar_dialogo_testemunha_defesa_para_treino_ui(fatos_caso_atual, testemunhas_reu_defs_atual_str, testemunha_selecionada_nome, pergunta_adv_defesa):
+    global _historico_treino_testemunha_atual
+    if not GEMINI_API_KEY:
+        return _historico_treino_testemunha_atual + [ (None, "ERRO: API Key não configurada.") ]
+
+    if not testemunha_selecionada_nome:
+        return _historico_treino_testemunha_atual + [ (None, "Por favor, selecione uma testemunha da sua lista na aba 'Configuração'.") ]
+    if not pergunta_adv_defesa:
+        return _historico_treino_testemunha_atual + [ (None, "Por favor, digite sua pergunta para a testemunha.") ]
+
+    # Recriar testemunhas_reu_defs a partir da string (se fornecida e mudou) ou usar a padrão
+    testemunhas_reu_defs_usar = []
+    if testemunhas_reu_defs_atual_str:
+        try:
+            # Re-parse a string de testemunhas do réu da aba de configuração
+            linhas = testemunhas_reu_defs_atual_str.strip().split('\n')
+            for linha in linhas:
+                if linha.strip():
+                    partes = linha.split(':', 1)
+                    if len(partes) == 2:
+                        testemunhas_reu_defs_usar.append({"nome": partes[0].strip(), "pontos_chave": partes[1].strip()})
+                    elif len(partes) == 1: # Nome sem pontos chave
+                         testemunhas_reu_defs_usar.append({"nome": partes[0].strip(), "pontos_chave": "Não especificado."})
+        except Exception as e:
+            print(f"Erro ao parsear testemunhas_reu_defs_atual_str: {e}")
+            testemunhas_reu_defs_usar = TESTEMUNHAS_REU_PREDEFINIDAS # Fallback
+    else:
+        testemunhas_reu_defs_usar = TESTEMUNHAS_REU_PREDEFINIDAS
+
+
+    testemunha_obj = next((t for t in testemunhas_reu_defs_usar if t["nome"] == testemunha_selecionada_nome), None)
+
+    if not testemunha_obj:
+         # Se não achou na lista dinâmica, tenta na lista padrão
+        testemunha_obj = next((t for t in TESTEMUNHAS_REU_PREDEFINIDAS if t["nome"] == testemunha_selecionada_nome), None)
+        if not testemunha_obj:
+            return _historico_treino_testemunha_atual + [ (None, f"Testemunha '{testemunha_selecionada_nome}' não encontrada. Verifique a aba 'Configuração'.") ]
+
+    # Reinicia o histórico se a testemunha mudou (simplificado)
+    if not _historico_treino_testemunha_atual or \
+       (_historico_treino_testemunha_atual and not _historico_treino_testemunha_atual[0][1].startswith(f"**{testemunha_obj['nome']}**:")):
+        _historico_treino_testemunha_atual = []
+        _historico_treino_testemunha_atual.append( (None, f"Iniciando inquirição de **{testemunha_obj['nome']}**. Pontos chave: {testemunha_obj['pontos_chave']}") )
+
+    gr.Info(f"Gerando resposta da testemunha {testemunha_obj['nome']}... Aguarde.")
+    resposta_testemunha = gerar_resposta_testemunha_defesa_para_treino_ia(
+        fatos_caso_atual if fatos_caso_atual else CASO_FATOS_COMPLETO_PREDEFINIDO,
+        testemunha_obj['nome'],
+        testemunha_obj['pontos_chave'],
+        [(q,r) for q,r in _historico_treino_testemunha_atual if q is not None], # Passa apenas Q/A anteriores
+        pergunta_adv_defesa
+    )
+    _historico_treino_testemunha_atual.append( (pergunta_adv_defesa, resposta_testemunha) )
+    gr.Info("Resposta da testemunha gerada.")
+    return _historico_treino_testemunha_atual, "" # Retorna o histórico e limpa o campo de pergunta
+
+
+# --- Interface Gráfica (Gradio UI) ---
+with gr.Blocks(theme=gr.themes.Soft(primary_hue="blue", secondary_hue="orange"), title="Simulador AIJ Interativo") as demo:
+    gr.Markdown("# ⚖️ Simulador Interativo de Audiência de Instrução e Julgamento (AIJ)")
+    gr.Markdown("Tema: **Direito ao Esquecimento vs. Liberdade de Imprensa**. Você assume o papel de **Advogado(a) do Réu (Jornal)**.")
+    if not GEMINI_API_KEY:
+        gr.Warning("API Key do Gemini (GEMINI_API_KEY) não encontrada! O aplicativo pode não funcionar corretamente. Configure-a como Secret neste Space ou localmente como variável de ambiente.")
+
     sim_state = gr.State(value=estado_inicial_simulacao())
 
     with gr.Tabs() as abas_principais:
-        with gr.TabItem("1. Configuração", id=0):
-            gr.Markdown("## Detalhes do Caso")
-            btn_gerar_caso_ia = gr.Button("✨ Gerar Caso Fictício com IA (Experimental)", icon="🧠")
+        with gr.TabItem("1. Configuração do Caso", id=0):
+            gr.Markdown("## Detalhes do Caso para Simulação")
+            gr.Markdown("Preencha os campos abaixo ou use os botões para gerar/carregar um caso.")
+            with gr.Row():
+                btn_gerar_caso_ia = gr.Button("✨ Gerar Novo Caso com IA", icon="🧠", scale=1)
+                btn_carregar_caso_padrao = gr.Button("📄 Carregar Caso Padrão (Esquecimento)", icon="📜", scale=1)
             with gr.Row():
                 with gr.Column(scale=2):
-                    fatos_input = gr.Textbox(lines=7, label="Resumo dos Fatos:", placeholder="Descreva ou gere com IA.")
-                    provas_reu_input = gr.Textbox(lines=4, label="Provas/Argumentos do Réu (Seu Grupo):")
-                    provas_autor_input = gr.Textbox(lines=4, label="Provas/Argumentos (Supostos) do Autor:")
+                    fatos_input = gr.Textbox(lines=7, label="Resumo dos Fatos, Partes e Título:", placeholder="Descreva o caso ou gere/carregue.")
+                    provas_reu_input = gr.Textbox(lines=4, label="Argumentos e Provas do Réu (Seu Cliente - Jornal):", placeholder="Ex: Arg: Liberdade de imprensa. Prova: Art. 5 CF.")
+                    provas_autor_input = gr.Textbox(lines=4, label="Argumentos e Provas (Supostas) do Autor:", placeholder="Ex: Arg: Dano à imagem. Prova: Laudo X.")
                 with gr.Column(scale=1):
-                    testemunhas_reu_input = gr.Textbox(lines=5, label="Suas Testemunhas (Réu) - Nome: Pontos Chave", placeholder="João Silva: Viu X.\nMaria Costa: Sabe Y.")
-                    testemunhas_autor_supostas_input = gr.Textbox(lines=5, label="Supostas Testemunhas do Autor - Nome: Pontos Chave", placeholder="Carlos Lima: Sofreu Z.\nAna B.: Irrelevante.")
-            btn_config_iniciar = gr.Button("💾 Salvar e Iniciar Simulação", variant="primary")
-            status_config_output = gr.Label(value="Aguardando configuração...")
-        with gr.TabItem("2. Audiência", id=1):
-            gr.Markdown("## Andamento")
-            instrucao_usuario_output = gr.Markdown("Instrução: Preencha a configuração para começar.")
-            chat_aij_output = gr.Chatbot(label="Transcrição", height=450, bubble_full_width=False, show_copy_button=True)
-            fala_usuario_input = gr.Textbox(show_label=False, placeholder="Sua fala ou use botões...", scale=4, lines=3)
+                    testemunhas_reu_input = gr.Textbox(lines=5, label="Suas Testemunhas (Réu) - Formato: Nome: Pontos Chave a Depor", placeholder="João Silva: Viu X e Y.\nMaria Costa: Sabe Z.")
+                    testemunhas_autor_supostas_input = gr.Textbox(lines=5, label="Supostas Testemunhas do Autor - Formato: Nome: Pontos Chave", placeholder="Carlos Lima: Sofreu Z.\nAna B.: Testemunhará sobre Q.")
+            btn_config_iniciar = gr.Button("💾 Salvar Configurações e Iniciar Simulação Interativa", variant="primary")
+            status_config_output = gr.Label(value="Aguardando configuração do caso...")
+
+            outputs_gerar_caso = [fatos_input, provas_reu_input, provas_autor_input, testemunhas_reu_input, testemunhas_autor_supostas_input, status_config_output]
+            btn_gerar_caso_ia.click(acao_gerar_caso_ficticio_ui, inputs=None, outputs=outputs_gerar_caso)
+            btn_carregar_caso_padrao.click(acao_carregar_caso_padrao_ui, inputs=None, outputs=outputs_gerar_caso)
+
+        with gr.TabItem("2. Audiência Interativa", id=1):
+            gr.Markdown("## Andamento da Audiência Simulada")
+            instrucao_usuario_output = gr.Markdown("Instrução: Configure o caso na aba 'Configuração' e clique em 'Salvar e Iniciar' para começar.")
+            chat_aij_output = gr.Chatbot(label="Transcrição da Audiência", height=500, bubble_full_width=False, show_copy_button=True, avatar_images=(None, "https://img.icons8.com/fluency/96/robot-2.png"))
+            fala_usuario_input = gr.Textbox(show_label=False, placeholder="Digite sua fala aqui ou use os botões de ação abaixo...", scale=4, lines=3)
             btn_enviar_fala_usuario = gr.Button("🎤 Enviar Fala / Ação", variant="stop")
-            with gr.Accordion("Ações Contextuais (Adv. Réu)", open=False):
+
+            with gr.Accordion("Ações Contextuais do Advogado do Réu (Você)", open=True):
+                with gr.Row():
+                    btn_responder_conciliacao = gr.Button("Responder à Conciliação", visible=False)
+                    dropdown_testemunhas_reu_select = gr.Dropdown(label="Sua Testemunha a Chamar:", choices=[], visible=False, interactive=True)
+                    btn_chamar_testemunha_reu_action = gr.Button("Chamar Testemunha Selecionada", visible=False)
                 with gr.Row():
-                    btn_responder_conciliacao = gr.Button("Conciliação", visible=False)
-                    dropdown_testemunhas_reu_select = gr.Dropdown(label="Sua Testemunha", choices=[], visible=False)
-                    btn_chamar_testemunha_reu_action = gr.Button("Chamar Testemunha", visible=False)
-                    btn_perguntar_testemunha_autor_action = gr.Button("Perguntar Test. Autor", visible=False)
-                    btn_adv_reu_pergunta_sua_testemunha_action = gr.Button("Perguntar Minha Test.", visible=False)
-                    btn_adv_reu_responde_pela_sua_testemunha_action = gr.Button("Responder por Minha Test.", visible=False)
-                    btn_apresentar_alegacoes_finais_reu_action = gr.Button("Alegações Finais", visible=False)
-                    btn_juiz_avancar_fase_action = gr.Button("⚖️ Juiz (IA): Avançar", visible=False, variant="secondary")
+                    btn_perguntar_testemunha_autor_action = gr.Button("Perguntar à Test. do Autor", visible=False)
+                    btn_adv_reu_pergunta_sua_testemunha_action = gr.Button("Perguntar à Minha Testemunha", visible=False)
+                    btn_adv_reu_responde_pela_sua_testemunha_action = gr.Button("Responder pela Minha Testemunha (à IA)", visible=False)
+                    btn_apresentar_alegacoes_finais_reu_action = gr.Button("Apresentar Alegações Finais", visible=False)
+            btn_juiz_avancar_fase_action = gr.Button("⚖️ Juiz (IA): Concluir Etapa / Avançar Fase", visible=False, variant="secondary")
             lista_botoes_feedback = [btn_responder_conciliacao, btn_chamar_testemunha_reu_action, dropdown_testemunhas_reu_select, btn_perguntar_testemunha_autor_action, btn_adv_reu_pergunta_sua_testemunha_action, btn_adv_reu_responde_pela_sua_testemunha_action, btn_apresentar_alegacoes_finais_reu_action, btn_juiz_avancar_fase_action]
-        with gr.TabItem("3. Feedback IA", id=2):
-            gr.Markdown("## 💡 Análise (Professor IA)")
-            feedback_output = gr.Textbox(lines=15, label="Feedback sobre sua atuação:", interactive=False, show_copy_button=True)
 
-    outputs_gerar_caso = [fatos_input, provas_reu_input, provas_autor_input, testemunhas_reu_input, testemunhas_autor_supostas_input, status_config_output]
-    btn_gerar_caso_ia.click(acao_gerar_caso_ficticio_ui, inputs=None, outputs=outputs_gerar_caso)
+        with gr.TabItem("3. Feedback da Atuação (Professor IA)", id=2):
+            gr.Markdown("## 💡 Análise da Sua Atuação na Audiência Interativa")
+            gr.Markdown("Este feedback é gerado pela IA com base na sua participação na aba 'Audiência Interativa'.")
+            feedback_output = gr.Textbox(lines=20, label="Feedback Detalhado:", interactive=False, show_copy_button=True)
 
+        with gr.TabItem("4. Treinamento de Argumentação (Defesa)", id=3):
+            gr.Markdown("## 🗣️ Pratique e Avalie Seus Argumentos (Advogado de Defesa)")
+            gr.Markdown("Use esta seção para redigir e obter feedback sobre argumentos específicos para o caso configurado.")
+            with gr.Row():
+                fatos_caso_treino_arg_display = gr.Textbox(label="Fatos do Caso (da Configuração):", value=CASO_FATOS_COMPLETO_PREDEFINIDO, lines=5, interactive=False) # Mostra fatos do caso padrão ou o configurado
+                provas_reu_treino_arg_display = gr.Textbox(label="Provas do Réu (da Configuração):", value=PROVAS_REU_TEXTO_PREDEFINIDO, lines=5, interactive=False)
+            tipo_argumento_treino = gr.Radio(
+                ["Contestação (teses principais)", "Perguntas para Testemunha do Autor", "Perguntas para Testemunha do Réu", "Alegações Finais (memoriais)"],
+                label="Selecione o Tipo de Argumento/Peça para Treinar:", value="Alegações Finais (memoriais)"
+            )
+            argumento_input_treino = gr.Textbox(lines=10, label="Digite seu argumento aqui:", placeholder="Ex: 'Excelência, a matéria jornalística é um retrato fiel dos fatos públicos...'")
+            btn_avaliar_argumento_treino = gr.Button("🤖 Avaliar Argumento com IA", variant="primary")
+            avaliacao_output_treino = gr.Markdown(label="Feedback da IA sobre o Argumento:")
+
+            # Atualizar displays quando a configuração mudar
+            fatos_input.change(lambda x: x, inputs=fatos_input, outputs=fatos_caso_treino_arg_display)
+            provas_reu_input.change(lambda x: x, inputs=provas_reu_input, outputs=provas_reu_treino_arg_display)
+
+            btn_avaliar_argumento_treino.click(
+                avaliar_argumentos_defesa_ia_ui,
+                inputs=[fatos_caso_treino_arg_display, provas_reu_treino_arg_display, tipo_argumento_treino, argumento_input_treino],
+                outputs=avaliacao_output_treino
+            )
+
+        with gr.TabItem("5. Preparar Testemunhas (Defesa)", id=4):
+            gr.Markdown("## 🎙️ Simule a Inquirição das Suas Testemunhas (Defesa)")
+            gr.Markdown("Pratique como você (Advogado de Defesa) inquiriria suas próprias testemunhas. A IA responderá como a testemunha selecionada.")
+            fatos_caso_treino_test_display = gr.Textbox(label="Fatos do Caso (da Configuração):", value=CASO_FATOS_COMPLETO_PREDEFINIDO, lines=5, interactive=False)
+            testemunhas_reu_config_treino_display = gr.Textbox(label="Definição das Testemunhas do Réu (da Configuração):", value=TESTEMUNHAS_REU_TEXTO_PREDEFINIDO, lines=3, interactive=False)
+
+            # Atualizar displays quando a configuração mudar
+            fatos_input.change(lambda x: x, inputs=fatos_input, outputs=fatos_caso_treino_test_display)
+            testemunhas_reu_input.change(lambda x: x, inputs=testemunhas_reu_input, outputs=testemunhas_reu_config_treino_display)
+
+            # Dropdown para selecionar testemunha do réu para treino
+            dropdown_testemunhas_reu_treino = gr.Dropdown(label="Selecione Sua Testemunha para Inquirir:", choices=[t['nome'] for t in TESTEMUNHAS_REU_PREDEFINIDAS], interactive=True)
+            # Atualizar choices do dropdown quando testemunhas_reu_input mudar
+            def update_dropdown_treino_choices(t_reu_str):
+                nomes = []
+                if t_reu_str and t_reu_str.strip():
+                    for linha in t_reu_str.strip().split('\n'):
+                        if linha.strip():
+                            partes = linha.split(':', 1)
+                            nomes.append(partes[0].strip())
+                return gr.Dropdown(choices=nomes if nomes else [t['nome'] for t in TESTEMUNHAS_REU_PREDEFINIDAS], value=nomes[0] if nomes else None)
+            testemunhas_reu_input.change(update_dropdown_treino_choices, inputs=testemunhas_reu_input, outputs=dropdown_testemunhas_reu_treino)
+
+
+            chat_treino_testemunha = gr.Chatbot(label="Simulação de Depoimento (Treino)", height=300, show_copy_button=True, bubble_full_width=False, avatar_images=(None, "https://img.icons8.com/officel/80/person-male.png"))
+            pergunta_testemunha_treino_input = gr.Textbox(label="Sua Pergunta para a Testemunha:", placeholder="Ex: 'Senhor Silva, poderia descrever o procedimento editorial?'")
+            btn_perguntar_testemunha_treino = gr.Button("💬 Perguntar à Testemunha (IA)", variant="primary")
+            btn_limpar_chat_treino_testemunha = gr.Button("🗑️ Limpar Chat de Treino")
+
+            def limpar_chat_treino():
+                global _historico_treino_testemunha_atual
+                _historico_treino_testemunha_atual = []
+                return [], ""
+            btn_limpar_chat_treino_testemunha.click(limpar_chat_treino, outputs=[chat_treino_testemunha, pergunta_testemunha_treino_input])
+
+            btn_perguntar_testemunha_treino.click(
+                gerar_dialogo_testemunha_defesa_para_treino_ui,
+                inputs=[fatos_caso_treino_test_display, testemunhas_reu_config_treino_display, dropdown_testemunhas_reu_treino, pergunta_testemunha_treino_input],
+                outputs=[chat_treino_testemunha, pergunta_testemunha_treino_input] # Limpa input após envio
+            )
+
+
+        with gr.TabItem("ℹ️ Ajuda / Sobre o Caso Padrão", id=5):
+            gr.Markdown("## Sobre o Caso Padrão: Direito ao Esquecimento vs. Liberdade de Imprensa")
+            gr.Markdown(f"**Título:** {CASO_TITULO_PREDEFINIDO}")
+            gr.Markdown(f"**Partes:**\n{CASO_PARTES_PREDEFINIDO.replace('\n', '\n\n')}")
+            gr.Markdown(f"**Resumo do Caso:**\n{CASO_DESCRICAO_PREDEFINIDO}")
+            with gr.Accordion("Argumentos Principais do Autor (Caso Padrão)", open=False):
+                gr.Markdown("\n".join([f"- {arg}" for arg in ARGUMENTOS_AUTOR_PREDEFINIDOS]))
+            with gr.Accordion("Argumentos Principais do Réu/Jornal (Caso Padrão)", open=False):
+                gr.Markdown("\n".join([f"- {arg}" for arg in CONTRA_ARGUMENTOS_REU_PREDEFINIDOS]))
+            with gr.Accordion("Testemunhas do Réu/Jornal (Caso Padrão)", open=False):
+                gr.Markdown("\n".join([f"- **{t['nome']}**: {t['pontos_chave']}" for t in TESTEMUNHAS_REU_PREDEFINIDAS]))
+
+            gr.Markdown("### Legislação e Precedentes Relevantes (Geral)")
+            with gr.Row():
+                with gr.Column():
+                    gr.Markdown("**Potencialmente Favoráveis ao Réu (Jornal):**")
+                    gr.Markdown("\n".join([f"- {lei}" for lei in LEGISLACAO_PRECEDENTES_PREDEFINIDO["favoraveis_ao_reu"]]))
+                with gr.Column():
+                    gr.Markdown("**Potencialmente Favoráveis ao Autor:**")
+                    gr.Markdown("\n".join([f"- {lei}" for lei in LEGISLACAO_PRECEDENTES_PREDEFINIDO["favoraveis_ao_autor"]]))
+            gr.Markdown("""
+            ## Como utilizar este simulador:
+            1.  **Configuração (Aba 1):**
+                *   **Gerar Novo Caso com IA:** Cria um caso fictício aleatório sobre o tema.
+                *   **Carregar Caso Padrão:** Preenche os campos com o "Caso da Reportagem Revisitada".
+                *   Ou preencha manualmente os detalhes do seu próprio caso.
+                *   **Salve e Inicie:** Fundamental para começar a simulação interativa.
+            2.  **Audiência Interativa (Aba 2):**
+                *   O núcleo da simulação. Siga as instruções e interaja como Advogado(a) do Réu.
+                *   Use o campo de texto para suas falas ou os botões de ação contextual.
+                *   O "Juiz (IA): Avançar Fase" é usado para progredir quando você conclui sua parte em uma etapa ou quando a IA indica.
+            3.  **Feedback da Atuação (Aba 3):**
+                *   Após interagir na Aba 2, verifique aqui a análise da IA sobre sua performance.
+            4.  **Treinamento de Argumentação (Aba 4):**
+                *   Use para praticar a redação de argumentos específicos (ex: para contestação, alegações finais) e receber feedback da IA. Baseia-se nos fatos e provas configurados na Aba 1.
+            5.  **Preparar Testemunhas (Aba 5):**
+                *   Treine a inquirição das suas testemunhas (do Réu). Você faz as perguntas, e a IA responde como se fosse a testemunha selecionada, baseando-se nos "pontos chave" definidos na Aba 1.
+            ## Dicas para Atuação como Advogado(a) do Réu (Jornal):
+            *   **Liberdade de Imprensa:** Seu principal argumento. Fundamente com a Constituição.
+            *   **Interesse Público:** Demonstre a relevância da matéria.
+            *   **Veracidade dos Fatos:** Crucial. A matéria deve ser factualmente correta.
+            *   **Ausência de Dolo/Culpa:** Argumente que não houve intenção de prejudicar, apenas informar.
+            *   **Menção à Absolvição:** Se o autor foi absolvido e a matéria menciona isso, é um ponto forte para a defesa.
+            *   **Precedentes (STF):** Cite o RE 1.010.606, que ponderou o direito ao esquecimento com a liberdade de informação.
+            *   **Contraditório:** Explore as perguntas às testemunhas do Autor para enfraquecer a tese dele.
+            *   **Suas Testemunhas:** Prepare-as para reforçar a tese da defesa.
+            """)
+
+    # --- Conexões dos Componentes da UI (Event Handlers) ---
     outputs_config = [sim_state, chat_aij_output, feedback_output, instrucao_usuario_output, dropdown_testemunhas_reu_select] + lista_botoes_feedback
-    btn_config_iniciar.click(configurar_e_iniciar_simulacao, inputs=[sim_state, fatos_input, provas_reu_input, provas_autor_input, testemunhas_reu_input, testemunhas_autor_supostas_input], outputs=outputs_config).then(lambda: gr.Textbox(value=""), outputs=[fala_usuario_input]).then(lambda: gr.Tabs(selected=1), outputs=[abas_principais])
+    btn_config_iniciar.click(
+        configurar_e_iniciar_simulacao,
+        inputs=[sim_state, fatos_input, provas_reu_input, provas_autor_input, testemunhas_reu_input, testemunhas_autor_supostas_input],
+        outputs=outputs_config
+    ).then(lambda: gr.Textbox(value=""), outputs=[fala_usuario_input] # Limpa o campo de fala
+    ).then(lambda: gr.Tabs(selected=1), outputs=[abas_principais]) # Muda para aba Audiência
 
     outputs_fala_usuario = [sim_state, chat_aij_output, feedback_output, instrucao_usuario_output, fala_usuario_input] + lista_botoes_feedback
     btn_enviar_fala_usuario.click(lidar_com_fala_usuario, inputs=[sim_state, fala_usuario_input], outputs=outputs_fala_usuario)
     fala_usuario_input.submit(lidar_com_fala_usuario, inputs=[sim_state, fala_usuario_input], outputs=outputs_fala_usuario)
-    
+
     outputs_acao_juiz = [sim_state, chat_aij_output, feedback_output, instrucao_usuario_output] + lista_botoes_feedback
     btn_juiz_avancar_fase_action.click(acao_botao_juiz_avancar, inputs=[sim_state], outputs=outputs_acao_juiz).then(lambda: gr.Textbox(value=""), outputs=[fala_usuario_input])
     btn_chamar_testemunha_reu_action.click(chamar_testemunha_reu_selecionada, inputs=[sim_state, dropdown_testemunhas_reu_select], outputs=outputs_acao_juiz).then(lambda: gr.Textbox(value=""), outputs=[fala_usuario_input])
 
-    # Links dos botões restantes para lidar_com_fala_usuario
-    for btn in [btn_responder_conciliacao, btn_perguntar_testemunha_autor_action, btn_adv_reu_pergunta_sua_testemunha_action, btn_adv_reu_responde_pela_sua_testemunha_action, btn_apresentar_alegacoes_finais_reu_action]:
-        btn.click(lidar_com_fala_usuario, inputs=[sim_state, fala_usuario_input], outputs=outputs_fala_usuario)
-
-    def setup_initial_ui_state(s): return [gr.Dropdown(choices=[], value=None)] + mostrar_botoes_corretos(s["fase_aij"])
-    demo.load(lambda s: (s, s["transcricao_chat"], s["feedback_para_usuario"], s["instrucao_para_usuario"]) + tuple(setup_initial_ui_state(s)), inputs=[sim_state], outputs=[sim_state, chat_aij_output, feedback_output, instrucao_usuario_output, dropdown_testemunhas_reu_select] + lista_botoes_feedback)
+    # Links dos botões de ação específicos para lidar_com_fala_usuario (eles apenas enviam o texto do botão como "fala")
+    # Estes botões agora estão mais para indicar o contexto da fala do usuário no input principal.
+    # A lógica de o que fazer com a fala do usuário está centralizada em `lidar_com_fala_usuario`.
+    # Se o botão for para uma ação específica que não envolve fala direta, ele precisa de seu próprio handler.
+    # Ex: Responder conciliação, apresentar alegações finais - podem usar o `lidar_com_fala_usuario` se o usuário digitar no campo.
+    # Se forem "ações puras" sem texto, podem precisar de lógica adaptada ou de um `fala_usuario_txt` especial.
+    # Para simplificar, vamos assumir que o usuário digita a resposta no campo de texto principal após clicar nesses botões (que agora servem mais como lembretes visuais).
+    # A alternativa seria esses botões passarem um placeholder de texto para `lidar_com_fala_usuario`.
+    # Por exemplo, btn_responder_conciliacao.click(lambda s: lidar_com_fala_usuario(s, "Réu se manifesta sobre conciliação (detalhes no campo de texto)."), ...)
+    # Mas a implementação atual já faz o `lidar_com_fala_usuario` receber o texto do `fala_usuario_input`.
+
+    # Botões que enviam a fala do input principal
+    btn_responder_conciliacao.click(lambda: gr.Info("Digite sua resposta à conciliação no campo de fala e envie."), inputs=[], outputs=[]).then(
+        lidar_com_fala_usuario, inputs=[sim_state, fala_usuario_input], outputs=outputs_fala_usuario
+    )
+    btn_perguntar_testemunha_autor_action.click(lambda: gr.Info("Digite sua pergunta à testemunha do Autor no campo de fala e envie."), inputs=[], outputs=[]).then(
+        lidar_com_fala_usuario, inputs=[sim_state, fala_usuario_input], outputs=outputs_fala_usuario
+    )
+    btn_adv_reu_pergunta_sua_testemunha_action.click(lambda: gr.Info("Digite sua pergunta à sua testemunha no campo de fala e envie. Você também digitará a RESPOSTA dela em seguida."), inputs=[], outputs=[]).then(
+        lidar_com_fala_usuario, inputs=[sim_state, fala_usuario_input], outputs=outputs_fala_usuario
+    )
+    btn_adv_reu_responde_pela_sua_testemunha_action.click(lambda: gr.Info("Digite a resposta da sua testemunha (à pergunta do Adv. Autor) no campo de fala e envie."), inputs=[], outputs=[]).then(
+        lidar_com_fala_usuario, inputs=[sim_state, fala_usuario_input], outputs=outputs_fala_usuario
+    )
+    btn_apresentar_alegacoes_finais_reu_action.click(lambda: gr.Info("Digite suas alegações finais no campo de fala e envie."), inputs=[], outputs=[]).then(
+        lidar_com_fala_usuario, inputs=[sim_state, fala_usuario_input], outputs=outputs_fala_usuario
+    )
+
+    # Estado inicial da UI no carregamento
+    def setup_initial_ui_state_load(s):
+        initial_fase = s["fase_aij"]
+        dropdown_choices = [t["nome"] for t in s.get("testemunhas_reu_defs", [])] if s.get("testemunhas_reu_defs") else []
+        return [gr.Dropdown(choices=dropdown_choices, value=None, interactive=True)] + mostrar_botoes_corretos(initial_fase)
+
+    demo.load(
+        lambda s: (s, s["transcricao_chat"], s["feedback_para_usuario"], s["instrucao_para_usuario"]) + tuple(setup_initial_ui_state_load(s)),
+        inputs=[sim_state],
+        outputs=[sim_state, chat_aij_output, feedback_output, instrucao_usuario_output, dropdown_testemunhas_reu_select] + lista_botoes_feedback
+    )
 
 if __name__ == "__main__":
     if not GEMINI_API_KEY:
@@ -467,4 +991,4 @@ if __name__ == "__main__":
         print("Para rodar localmente, edite o script e insira sua chave ou defina a variável de ambiente.")
         print("Para Hugging Face Spaces, configure o Secret 'GEMINI_API_KEY'.")
         print("#####################################################################")
-    demo.queue().launch()
+    demo.queue(max_size=20).launch(debug=False) # Adicionado max_size para melhor gerenciamento de fila.