primocode 8.37.0 → 8.38.0

package/bin/primocode.js

@@ -19,7 +19,8 @@ const { escolherModo } = require('../lib/modo.js');
 const api = require('../lib/api');
 const tools = require('../lib/tools');
 const cfg = require('../lib/config');
-const { runAct, interromper } = require('../lib/act');
+const { runAct, interromper, ehTetoDeToken, ehTransitorio, esperaDoErro } = require('../lib/act');
+const fala = require('../lib/fala');
 const claudeEngine = require('../lib/claude-engine');
 const codexEngine = require('../lib/codex-engine');
 const chaves = require('../lib/chaves');
@@ -38,10 +39,10 @@ const nuvem = require('../lib/nuvem');
 // via a resposta parar no meio e cair de volta pro shell, sem mensagem
 // nenhuma. Agora vira um erro visível, e o processo continua de pé.
 process.on('uncaughtException', (e) => {
-    console.log('\n' + c.err(ui.friendlyError(e)));
+    fala.problema(e);
 });
 process.on('unhandledRejection', (e) => {
-    console.log('\n' + c.err(ui.friendlyError(e instanceof Error ? e : new Error(String(e)))));
+    fala.problema(e instanceof Error ? e : new Error(String(e)));
 });
 
 // A pasta de onde o comando foi dado. Não é mais onde ele trabalha (o padrão é
@@ -690,33 +691,49 @@ let chatEmVoo = null;
 
 async function runChat(promptForModel, userTextForMemory) {
     chatEmVoo = new AbortController();
-    const sp = new Spinner('pensando').start();
-    let started = false;
+    const sp = new Spinner(ui.PENSANDO).start();
+    const saida = fala.fluxo();
     let text = '';
-    try {
-        await api.requestChat(state.config.server, {
-            prompt: promptForModel,
-            history: memoria.paraEnviar(state.memoria, state.history),
-            model: state.config.model,
-            token: state.config.token,
-            sinal: chatEmVoo.signal,
-        }, (evt) => {
-            if (evt.erro) { if (!started) sp.stop(); console.log('\n' + c.err(ui.friendlyError(evt.erro))); return; }
-            if (evt.delta) {
-                if (!started) { sp.stop(); process.stdout.write('\n'); started = true; }
-                text += evt.delta;
-                process.stdout.write(c.white(evt.delta));
-            }
-            if (evt.done && !started) sp.stop();
-        });
-    } catch (e) {
+    // O chat não tinha a paciência do agente: o primeiro 429 ou teto do
+    // minuto saía em vermelho na tela, na primeira recusa. Agora o que é
+    // passageiro (minuto, 429, 5xx, rede) espera a janela e repete calado,
+    // com o spinner de pensar girando — até seis vezes. O que NÃO é
+    // passageiro (crédito, chave, cota do dia) continua saindo, como aviso.
+    // Texto já na tela não se repete: se o erro veio no meio da resposta, ela
+    // fica como está e o aviso vem embaixo.
+    for (let tentativa = 0; ; tentativa++) {
+        let erro = null;
+        try {
+            await api.requestChat(state.config.server, {
+                prompt: promptForModel,
+                history: memoria.paraEnviar(state.memoria, state.history),
+                model: state.config.model,
+                token: state.config.token,
+                sinal: chatEmVoo.signal,
+            }, (evt) => {
+                if (evt.erro) { erro = evt.erro; return; }
+                if (evt.delta) {
+                    if (!saida.escreveu()) sp.stop();
+                    text += evt.delta;
+                    saida.escrever(evt.delta);
+                }
+            });
+        } catch (e) { erro = e; }
+        if (!erro) break;
+        const passageiro = ehTetoDeToken(erro) || ehTransitorio(erro);
+        if (passageiro && tentativa < 6 && !text && !chatEmVoo.signal.aborted) {
+            await new Promise((r) => setTimeout(r, esperaDoErro(erro, tentativa + 1)));
+            continue;
+        }
         sp.stop();
-        console.log('\n' + c.err(ui.friendlyError(e)));
-        return;
+        saida.fechar();
+        if (!chatEmVoo.signal.aborted) fala.problema(erro);
+        if (!text) return;
+        break;
     }
     sp.stop();
+    saida.fechar();
     if (text) {
-        process.stdout.write('\n');
         state.history.push({ role: 'user', content: userTextForMemory });
         state.history.push({ role: 'assistant', content: text });
         state.lastResponse = text;
@@ -1248,32 +1265,30 @@ async function handleSlash(text) {
             if (rest === 'trocar') conta.sair();
 
             const sp = new Spinner('abrindo o login').start();
-            let primeiro = true;
             const r = await conta.entrar({
                 abrir: (u) => tools.openInBrowser(u),
-                contar: (msg) => {
-                    if (primeiro) {
-                        sp.stop();
-                        console.log(c.muted('  Abrindo no navegador:'));
-                        console.log('  ' + c.brand(msg));
-                        primeiro = false;
-                    } else {
-                        /* O código é para DIGITAR na página, e é ele que
-                           protege: como não vai no link, quem não está olhando
-                           este terminal não tem o que digitar — e um link
-                           mandado por outra pessoa não conecta o computador
-                           dela à sua conta.
-
-                           Por isso ele aparece grande e sozinho, com o traço
-                           no meio: o que se lê de uma tela e se digita noutra
-                           erra menos partido em dois. */
-                        const meio = msg.length === 8 ? msg.slice(0, 4) + '-' + msg.slice(4) : msg;
-                        console.log('');
-                        console.log(c.muted('  Digite este código na página:'));
-                        console.log('    ' + c.bold(c.brand(meio.split('').join(' '))));
-                        console.log('');
-                        console.log(c.dim('  Esperando você aprovar…'));
-                    }
+                contar: (info) => {
+                    sp.stop();
+                    /* O código continua aparecendo — grande, partido em dois,
+                       porque é o que se lê de uma tela e se confere noutra. Mas
+                       agora ele já FOI para a página: o CLI serve o código em
+                       127.0.0.1 e a página pergunta ali; e foi para a área de
+                       transferência, para o "Colar" de um toque onde o
+                       navegador bloqueia o 127.0.0.1 (Safari). Digitar virou a
+                       terceira saída, não a primeira. */
+                    const meio = info.codigo.length === 8
+                        ? info.codigo.slice(0, 4) + '-' + info.codigo.slice(4) : info.codigo;
+                    console.log(c.muted('  Abrindo no navegador:'));
+                    console.log('  ' + c.brand(info.url.replace(/[?&]porta=\d+/, '')));
+                    console.log('');
+                    console.log('    ' + c.bold(c.brand(meio.split('').join(' '))));
+                    console.log('');
+                    const como = [];
+                    if (info.porta) como.push('a página preenche sozinha');
+                    if (info.copiado) como.push('e o código já está copiado');
+                    console.log(c.dim('  ' + (como.length ? como.join(', ').replace(/^e /, '') + '.'
+                        : 'Digite o código na página.')));
+                    console.log(c.dim('  Esperando você aprovar…'));
                 },
             });
             sp.stop();
@@ -1619,7 +1634,7 @@ async function main() {
                 if (isSlash(text)) await handleSlash(text);
                 else await sendPrompt(text);
             } catch (e) {
-                console.log('\n' + c.err(ui.friendlyError(e)));
+                fala.problema(e);
             }
         }
         busy = false;

package/lib/act.js

@@ -10,7 +10,9 @@
 
 'use strict';
 
-const { c, actionHeader, Spinner, friendlyError } = require('./ui');
+const { c, Spinner, PENSANDO } = require('./ui');
+const fala = require('./fala');
+const especialistas = require('./especialistas');
 const tools = require('./tools');
 const api = require('./api');
 const cfg = require('./config');
@@ -49,6 +51,21 @@ function ehTetoDeToken(e) {
     return /não cabe no teto|conversa passou do teto|request too large|tokens per minute|\btpm\b|reduce your message size/.test(s);
 }
 
+/**
+ * Este erro é PASSAGEIRO — daqui a alguns segundos a mesma chamada passa?
+ *
+ * 429 por pedidos, 5xx do provedor ou do servidor, conexão que caiu no meio.
+ * Nada disso é do usuário, e nada disso ele precisa ver: espera-se um pouco
+ * e repete-se, com o spinner de pensar girando. O que NÃO entra aqui, de
+ * propósito: cota do DIA (esperar minutos não resolve), crédito, chave e o
+ * teto de tokens (esse tem a função acima e o conserto próprio, encolher).
+ */
+function ehTransitorio(e) {
+    const s = String((e && e.message) || e || '').toLowerCase();
+    if (/tokens per day|\btpd\b|free-models-per-day|per day|\b402\b|\b401\b|\b403\b|afford|credit/.test(s)) return false;
+    return /rate.?limit|too many requests|\b429\b|\b50[234]\b|bad gateway|service unavailable|gateway timeout|overloaded|socket hang up|econnreset|etimedout|aborted|internal server error|\b500\b/.test(s);
+}
+
 /**
  * O /compact automático, feito no meio da tarefa.
  *
@@ -81,9 +98,16 @@ function ident(profundidade) {
 }
 
 function logResult(kind, result, profundidade) {
-    const p = ident(profundidade) + c.muted('  ⎿ ');
+    const p = fala.resultado(profundidade);
     if (!result) return;
-    if (result.ok === false) { console.log(p + c.err(result.error || `exit ${result.code ?? 'erro'}`)); return; }
+    // Uma tool que falhou é informação para o AGENTE, que vai consertar na
+    // volta seguinte — não é o erro do usuário. Âmbar, uma linha, sem o
+    // vermelho que faz parecer que a tarefa morreu.
+    if (result.ok === false) {
+        const texto = String(result.error || `exit ${result.code ?? 'erro'}`).replace(/\s+/g, ' ').trim();
+        console.log(p + c.warn(texto.length > 160 ? texto.slice(0, 159) + '…' : texto));
+        return;
+    }
 
     switch (kind) {
         case 'write_file':
@@ -297,10 +321,21 @@ function encolherParaContinuar(messages) {
  * ("Please try again in 7.664s"); sem isso, meio minuto é seguro. */
 function esperaDoErro(e, tentativa = 0) {
     const m = /try again in ([0-9.]+)s/i.exec(String((e && e.message) || e || ''));
+    if (m) return Math.min(70, Math.max(5, Math.ceil(parseFloat(m[1])) + 2)) * 1000;
     // Sem o tempo do provedor, cresce a passada a cada tentativa: bater na
     // mesma porta a cada 30s por horas só esquenta o rate limit.
-    const s = m ? Math.ceil(parseFloat(m[1])) + 2 : Math.min(70, 30 + tentativa * 10);
-    return Math.min(70, Math.max(5, s)) * 1000;
+    if (ehTetoDeToken(e)) return Math.min(70, Math.max(5, 30 + tentativa * 10)) * 1000;
+    // Rede e 5xx voltam em segundos, não em minutos: 3, 6, 12, 20, 20…
+    // Esperar meio minuto para um servidor que já voltou é a tela parada à toa.
+    return Math.min(20, 3 * 2 ** Math.max(0, tentativa - 1)) * 1000;
+}
+
+/** Espera com o spinner de PENSAR girando — nunca um de "limite" ou
+ *  "continuando em Ns". Quem olha vê o Primo pensando um pouco mais, e só. */
+async function pausar(ms, subagent) {
+    const sp = subagent ? null : new Spinner(PENSANDO).start();
+    await new Promise((r) => setTimeout(r, ms));
+    if (sp) sp.stop();
 }
 
 function motivoDaParada({ voltas, voltasEmFalso, falhasPendentes, travou }) {
@@ -396,16 +431,27 @@ async function runAct(userPrompt, opts) {
     // Esc, é "espera até dar".
     // O teste derruba para 2 via env; em produção são 200.
     const MAX_ESPERAS = Number(process.env.PRIMOCODE_MAX_ESPERAS || 200);
+    // Rede e 5xx têm teto menor: seis esperas curtas (~1 min) e aí é o
+    // servidor que caiu de verdade, e a pessoa merece saber.
+    const MAX_ESPERAS_REDE = Number(process.env.PRIMOCODE_MAX_ESPERAS_REDE || 6);
 
     let voltas = 0;
     for (let iteration = 0; iteration < MAX_ITERATIONS && !PARAR; iteration++) {
         voltas++;
-        const sp = new Spinner(subagent ? 'subagente trabalhando' : 'Primo Code pensando').start();
+        const sp = new Spinner(subagent ? 'subagente trabalhando' : PENSANDO).start();
 
         const toolCalls = [];
         let assistantText = '';
         let streamError = null;
-        let streaming = false;
+        // O texto do modelo NÃO sai letra a letra enquanto chega: fica guardado
+        // até o fim da rodada, porque só ali se sabe o que ele É. Vieram
+        // tool_calls junto? É PENSAMENTO ("o vídeo veio em .avi, vou
+        // converter") e sai recuado, em cinza, com ✦. Não veio tool nenhuma? É
+        // a RESPOSTA, e sai com ● na cor da marca. Antes tudo saía em branco
+        // no mesmo lugar, e "vou converter" e "pronto, converti" tinham a
+        // mesma cara. A exceção é texto longo: passou do limiar sem tool à
+        // vista, é resposta — e aí volta a correr na tela conforme chega.
+        let fluxo = null;
 
         emVoo = new AbortController();
         try {
@@ -413,51 +459,48 @@ async function runAct(userPrompt, opts) {
                 if (evt.erro) { streamError = evt.erro; return; }
                 if (evt.tool_call) { toolCalls.push(evt.tool_call); return; }
                 if (evt.delta) {
-                    if (!streaming) { sp.stop(); streaming = true; }
                     assistantText += evt.delta;
-                    if (!subagent) process.stdout.write(c.white(evt.delta));
+                    if (!subagent && !toolCalls.length) {
+                        if (!fluxo && assistantText.length > fala.LIMIAR_PENSAMENTO) {
+                            sp.stop();
+                            fluxo = fala.fluxo();
+                            fluxo.escrever(assistantText);
+                        } else if (fluxo) fluxo.escrever(evt.delta);
+                    }
                 }
                 if (evt.assistant_message) assistantText = evt.assistant_message.content || assistantText;
             });
         } catch (e) {
             sp.stop();
             emVoo = null;
+            if (fluxo) fluxo.fechar();
             // Estourou o minuto: encolhe o que já foi feito e CONTINUA, em vez
             // de devolver erro e jogar fora o trabalho. O usuário não precisa
-            // saber que isso aconteceu — a tarefa é dele, o encanamento é nosso.
-            if (ehTetoDeToken(e) && !PARAR) {
-                if (messages.length > 8 && compactacoes < MAX_COMPACTACOES) {
-                    compactacoes++;
-                    const antes = messages.length;
-                    encolherParaContinuar(messages);
-                    if (!subagent) {
-                        console.log(ident(profundidade) + c.dim(`  ⎿ conversa encolhida para continuar (${antes} → ${messages.length} mensagens)`));
-                    }
-                    iteration--;          // esta volta não contou: nada foi decidido
-                    continue;
-                }
-                if (esperas < MAX_ESPERAS) {
+            // saber que isso aconteceu — a tarefa é dele, o encanamento é
+            // nosso. E não sabe MESMO: nada disto vai para a tela; o spinner de
+            // pensar segue girando com as frases de sempre.
+            if (ehTetoDeToken(e) && !PARAR && messages.length > 8 && compactacoes < MAX_COMPACTACOES) {
+                compactacoes++;
+                encolherParaContinuar(messages);
+                iteration--;          // esta volta não contou: nada foi decidido
+                continue;
+            }
+            if ((ehTetoDeToken(e) || ehTransitorio(e)) && !PARAR) {
+                const teto = ehTetoDeToken(e) ? MAX_ESPERAS : MAX_ESPERAS_REDE;
+                if (esperas < teto) {
                     esperas++;
-                    const ms = esperaDoErro(e, esperas);
-                    if (!subagent) {
-                        const sp2 = new Spinner(`limite do minuto — continuando em ${Math.round(ms / 1000)}s`).start();
-                        await new Promise((r) => setTimeout(r, ms));
-                        sp2.stop();
-                    } else {
-                        await new Promise((r) => setTimeout(r, ms));
-                    }
+                    await pausar(esperaDoErro(e, esperas), subagent);
                     iteration--;
                     continue;
                 }
             }
-            const amigavel = friendlyError(e);
-            if (subagent) return { assistantMessage: { role: 'assistant', content: `Subagente falhou: ${amigavel}` } };
-            console.log('\n' + c.err(amigavel));
+            if (subagent) return { assistantMessage: { role: 'assistant', content: `Subagente falhou: ${fala.frase(e)}` } };
+            fala.problema(e);
             throw e;
         }
         sp.stop();
         emVoo = null;
-        if (PARAR) break;
+        if (PARAR) { if (fluxo) fluxo.fechar(); break; }
 
         // Chamada de função malformada: o modelo errou a SINTAXE da chamada,
         // não a tarefa. Repetir a mesma rodada quase sempre resolve — e sem
@@ -468,47 +511,44 @@ async function runAct(userPrompt, opts) {
         // tropeço: o provedor recusou o JSON que o MODELO gerou. Medido em
         // produção num "crie um vídeo" — o documento grande saía torto e o
         // erro cru parava a tarefa com a corrente inteira ainda de pé.
+        // Tudo o que é encanamento daqui para baixo acontece EM SILÊNCIO: o
+        // tropeço, o encolhimento, a espera. Antes cada um escrevia uma linha
+        // cinza ("o modelo tropeçou", "conversa encolhida (12 → 4)"), e quem
+        // lia via a máquina engasgando no meio do trabalho.
         if (streamError && /failed to call a function|failed to parse tool call|failed_generation|tool_use_failed/i.test(String(streamError))
             && funcoesQuebradas < 4 && !PARAR) {
             funcoesQuebradas++;
-            if (!subagent) console.log(ident(profundidade) + c.dim('  ⎿ o modelo tropeçou na chamada — tentando de novo'));
+            if (fluxo) fluxo.fechar();
             iteration--;
             continue;
         }
 
-        if (streamError && ehTetoDeToken(streamError) && !PARAR) {
+        if (streamError && !PARAR && (ehTetoDeToken(streamError) || ehTransitorio(streamError))) {
+            if (fluxo) fluxo.fechar();
             // Conversa longa: encolher resolve, porque o peso é o histórico.
-            if (messages.length > 8 && compactacoes < MAX_COMPACTACOES) {
+            if (ehTetoDeToken(streamError) && messages.length > 8 && compactacoes < MAX_COMPACTACOES) {
                 compactacoes++;
-                const antes = messages.length;
                 encolherParaContinuar(messages);
-                if (!subagent) {
-                    console.log(ident(profundidade) + c.dim(`  ⎿ conversa encolhida para continuar (${antes} → ${messages.length} mensagens)`));
-                }
                 iteration--;
                 continue;
             }
             // Conversa curta: o peso é o MINUTO, não o histórico — as chamadas
-            // anteriores gastaram a cota. Espera a janela virar e repete.
-            if (esperas < MAX_ESPERAS) {
+            // anteriores gastaram a cota. Espera a janela virar e repete. O
+            // 5xx e a rede caem no mesmo lugar, com o teto menor.
+            const teto = ehTetoDeToken(streamError) ? MAX_ESPERAS : MAX_ESPERAS_REDE;
+            if (esperas < teto) {
                 esperas++;
-                const ms = esperaDoErro(streamError, esperas);
-                if (!subagent) {
-                    const sp2 = new Spinner(`limite do minuto — continuando em ${Math.round(ms / 1000)}s`).start();
-                    await new Promise((r) => setTimeout(r, ms));
-                    sp2.stop();
-                } else {
-                    await new Promise((r) => setTimeout(r, ms));
-                }
+                await pausar(esperaDoErro(streamError, esperas), subagent);
                 iteration--;
                 continue;
             }
         }
 
         if (streamError) {
-            const amigavel = friendlyError(streamError);
+            if (fluxo) fluxo.fechar();
+            const amigavel = fala.frase(streamError);
             if (subagent) return { assistantMessage: { role: 'assistant', content: `Subagente falhou: ${amigavel}` }, concluiu: false };
-            console.log('\n' + c.err(amigavel));
+            fala.problema(streamError);
             // concluiu: false — o plano de passos não pode tratar um erro de
             // provedor como resultado e passá-lo adiante como "fato".
             return { assistantMessage: { role: 'assistant', content: amigavel }, concluiu: false };
@@ -523,7 +563,6 @@ async function runAct(userPrompt, opts) {
             // resolve — visto em produção no primeiro pedido de vídeo.
             if (!finalText && respostasVazias < 3 && !PARAR) {
                 respostasVazias++;
-                if (!subagent) console.log(ident(profundidade) + c.dim('  ⎿ o modelo respondeu vazio — tentando de novo'));
                 // Repetir o MESMO contexto costuma produzir o mesmo vazio: se
                 // o turno anterior já engasgou, o que falta é um empurrão
                 // curto e concreto. A partir da segunda vez, entra um pedido
@@ -541,14 +580,18 @@ async function runAct(userPrompt, opts) {
                 continue;
             }
             if (!subagent) {
-                if (finalText && !streaming) console.log('\n' + c.white(finalText));
-                else if (streaming) process.stdout.write('\n');
+                if (fluxo) fluxo.fechar();
+                else fala.resposta(finalText);
             }
             break;
         }
         respostasVazias = 0;
 
-        if (streaming && !subagent) process.stdout.write('\n');
+        // O que o modelo disse ANTES de agir é pensamento, e sai como tal.
+        if (!subagent) {
+            if (fluxo) fluxo.fechar();
+            else if (assistantText.trim()) fala.pensamento(assistantText, profundidade);
+        }
 
         // Registra o turno do assistente COM os tool_calls. A API exige que
         // cada mensagem role:'tool' venha logo depois deste turno.
@@ -576,7 +619,7 @@ async function runAct(userPrompt, opts) {
         const resultadosSpawn = new Map();
         if (spawns.length > 1 && !PARAR) {
             const juntos = spawns.slice(0, 4);
-            console.log(ident(profundidade) + `  ${c.magenta('◆')} ${c.bold(c.magenta('Agentes'))} ${c.muted(`${juntos.length} em paralelo`)}`);
+            fala.paralelo(juntos.length, profundidade);
             const rs = await Promise.all(juntos.map((tc) =>
                 runSubagent(tc.arguments || {}, {
                     server, model, token, projectDir: pastaAtual, projectName, profundidade, motor,
@@ -624,7 +667,7 @@ async function runAct(userPrompt, opts) {
                esquecer de passar o token, a pasta ou o motor. */
             if (tc.name === 'construir_app') {
                 algoRodou = true;
-                console.log(ident(profundidade) + actionHeader(tc.name, tc.arguments));
+                fala.acao(tc.name, tc.arguments, profundidade);
                 const r = await rodarPipeline(tc.arguments || {}, {
                     server, model, token, projectDir: pastaAtual, projectName, profundidade, motor,
                 });
@@ -636,12 +679,12 @@ async function runAct(userPrompt, opts) {
 
             // Repetiu a mesma chamada? Não executa de novo. Rodar outra vez
             // gastaria a cota para devolver exatamente o mesmo texto, e é
-            // esse texto que convence o modelo a repetir mais uma vez.
+            // esse texto que convence o modelo a repetir mais uma vez. Sem
+            // linha na tela: o freio é nosso, não do usuário — o modelo recebe
+            // o aviso e segue, e quem olha vê o trabalho continuar.
             const eco = repeticao.ver(jaChamado, tc.name, tc.arguments);
             if (eco.repetida) {
                 voltasEmFalso++;
-                console.log(ident(profundidade) + actionHeader(tc.name, tc.arguments));
-                console.log(ident(profundidade) + c.muted('  ⎿ ') + c.warn(`repetido (${eco.vezes}ª vez) — não rodei de novo`));
                 messages.push({ role: 'tool', tool_call_id: tc.id, content: eco.aviso });
                 continue;
             }
@@ -655,8 +698,6 @@ async function runAct(userPrompt, opts) {
 
             if (tc.name === 'pesquisar_referencia' && pesquisasSecas >= 3) {
                 voltasEmFalso++;
-                console.log(ident(profundidade) + actionHeader(tc.name, tc.arguments));
-                console.log(ident(profundidade) + c.muted('  ⎿ ') + c.warn('3 pesquisas sem resultado — siga com o que já tem'));
                 messages.push({
                     role: 'tool',
                     tool_call_id: tc.id,
@@ -670,7 +711,7 @@ async function runAct(userPrompt, opts) {
             }
 
             algoRodou = true;
-            console.log(ident(profundidade) + actionHeader(tc.name, tc.arguments));
+            fala.acao(tc.name, tc.arguments, profundidade);
             const result = await tools.execute(tc.name, tc.arguments, { projectDir: pastaAtual });
             logResult(tc.name, result, profundidade);
 
@@ -718,17 +759,16 @@ async function runAct(userPrompt, opts) {
         // terminar no mesmo lugar — melhor parar e devolver a vez ao usuário.
         if (!algoRodou && toolCalls.length) {
             rodadasParadas++;
-            if (rodadasParadas >= MAX_RODADAS_PARADAS) {
-                if (!subagent) console.log('\n' + c.warn(`Travei repetindo as mesmas chamadas ${rodadasParadas} voltas seguidas — parei aqui.`));
-                break;
-            }
+            // Quem fala é o motivoDaParada, uma vez só — aqui havia uma
+            // segunda frase de "travei", e as duas saíam em sequência.
+            if (rodadasParadas >= MAX_RODADAS_PARADAS) break;
         } else {
             rodadasParadas = 0;
         }
 
         if (finished) {
             finalText = finished;
-            if (!subagent) console.log('\n' + c.white(finished));
+            if (!subagent) fala.resposta(finished);
             break;
         }
     }
@@ -740,7 +780,7 @@ async function runAct(userPrompt, opts) {
 
     if (PARAR && !finalText) {
         finalText = 'Parado por você (Esc Esc). O que já foi feito, ficou feito.';
-        if (!subagent) console.log('\n' + c.warn('⏹ ' + finalText));
+        if (!subagent) fala.aviso(finalText);
     }
 
     // Nunca terminar em silêncio. Quando o modelo devolvia resposta vazia sem
@@ -749,7 +789,7 @@ async function runAct(userPrompt, opts) {
     // depois de a primeira tentativa de seletor falhar.
     if (!finalText) {
         finalText = motivoDaParada({ voltas, voltasEmFalso, falhasPendentes, travou: rodadasParadas >= MAX_RODADAS_PARADAS });
-        if (!subagent) console.log('\n' + c.warn(finalText));
+        if (!subagent) fala.aviso(finalText);
     }
 
     // Nada de arquivo mexido = nada para lembrar. E grava em `pastaAtual`, não em
@@ -801,9 +841,12 @@ async function runSubagent(args, ctx) {
     }
     if (!args.prompt) return 'Recusado: prompt do subagente vazio.';
 
-    console.log(ident(profundidade) + `  ${c.magenta('◆')} ${c.bold(c.magenta('Agente'))} ${c.muted(descricao)}`);
+    // O ofício: o modelo diz quem faz (`especialista`), ou a tarefa sugere. O
+    // briefing vai na frente da tarefa, na mesma mensagem — ver especialistas.js.
+    const esp = especialistas.escolher(args.especialista, args.prompt);
+    fala.agente(especialistas.rotulo(esp), descricao, profundidade);
 
-    const r = await runAct(args.prompt, {
+    const r = await runAct(especialistas.montarTarefa(esp, args.prompt), {
         server, model, token, projectDir, projectName,
         history: [],
         profundidade: profundidade + 1,
@@ -812,7 +855,7 @@ async function runSubagent(args, ctx) {
     });
 
     const resumo = r.assistantMessage.content || 'sem resultado';
-    console.log(ident(profundidade) + `  ${c.magenta('◆')} ${c.muted(resumo.slice(0, 120))}`);
+    fala.agenteVoltou(resumo, profundidade);
     return resumo;
 }
 
@@ -848,7 +891,7 @@ async function rodarPipeline(args, ctx) {
 
     const correr = async (prompt, rotulo) => {
         if (PARAR) return '';
-        console.log(ident(profundidade) + `  ${c.magenta('◆')} ${c.bold(c.magenta('Agente'))} ${c.muted(rotulo)}`);
+        fala.agente('Agente', rotulo, profundidade);
         const r = await runAct(prompt, {
             server, model, token, projectDir: pasta, projectName,
             history: [], profundidade: profundidade + 1, subagent: true, motor,
@@ -861,10 +904,10 @@ async function rodarPipeline(args, ctx) {
         pasta,
         rodadas: args.rodadas,
         correr,
-        mostrar: (linha) => console.log(ident(profundidade) + `  ${c.muted('⎿ ' + linha)}`),
+        mostrar: (linha) => console.log(fala.resultado(profundidade) + c.muted(linha)),
         abrir: tools.openInBrowser,
     });
 }
 
-module.exports = { runAct, interromper, compactar, motivoDaParada, ehTetoDeToken, esperaDoErro,
+module.exports = { runAct, interromper, compactar, motivoDaParada, ehTetoDeToken, ehTransitorio, esperaDoErro,
     anotacaoDoQueJaFoi, encolherParaContinuar, MAX_ITERATIONS };