primocode 11.1.0 → 11.3.0

package/lib/session/runner/act.js

@@ -40,6 +40,7 @@ const tempos = require('../../tempos');
 const preLeitura = require('../../pre-leitura');
 const travado = require('../../travado');
 const auditoria = require('../../auditoria');
+const eventosMotor = require('../../motor/eventos');
 const chamadaTorta = require('../../chamada-torta');
 const idioma = require('../../idioma');
 const entregaveis = require('../../plugin/entregaveis');
@@ -103,10 +104,14 @@ function trabalhando() { return TRABALHANDO; }
 /** O que ficou na caixa sem ser lido — o terminal roda como pedido novo. */
 function sobrasDaCaixa() { return CAIXA.splice(0); }
 /* Esvazia a caixa dentro da conversa. Devolve quantos recados entraram. */
-function entregarRecados(messages, profundidade) {
+function entregarRecados(messages, profundidade, emitir) {
     if (!CAIXA.length) return 0;
     const recados = CAIXA.splice(0);
-    for (const r of recados) fala.pensamento(`recado recebido — entrando na tarefa: ${r}`, profundidade);
+    for (const r of recados) {
+        const texto = `recado recebido — entrando na tarefa: ${r}`;
+        if (emitir) emitir(eventosMotor.montar('pensamento', { profundidade, texto }));
+        else fala.pensamento(texto, profundidade);
+    }
     messages.push({
         role: 'user',
         content: (recados.length === 1 ? 'MENSAGEM NOVA do usuário, enviada enquanto você trabalhava:\n'
@@ -241,6 +246,17 @@ function ident(profundidade) {
  * duas versões do texto, que o `limparParaOModelo` apaga antes de a conversa
  * seguir. Sem essa limpeza, cada edição mandaria o arquivo inteiro de volta
  * ao modelo — que acabou de escrevê-lo e não aprende nada relendo. */
+/* +N −M de uma escrita ou edição: o diff de verdade (linhas que entraram e saíram). Arquivo
+   novo conta todas as linhas como entradas. Sem as duas versões nem a contagem, null. */
+function contarMudanca(result) {
+    if (!result) return null;
+    if (typeof result._antes === 'string' && typeof result._depois === 'string') {
+        try { return diff.contar(diff.operacoes(result._antes, result._depois)); } catch { return null; }
+    }
+    if (result.created && Number.isFinite(result.linhas)) return { mais: result.linhas, menos: 0 };
+    return null;
+}
+
 function mostrarDiff(result, profundidade) {
     if (!result || typeof result._antes !== 'string' || typeof result._depois !== 'string') return;
     const bloco = diff.desenhar(result._antes, result._depois, {
@@ -258,6 +274,14 @@ function limparParaOModelo(result) {
     return limpo;
 }
 
+/* Os eventos do subagente, do diretor e do pipeline vão para o mesmo emissor
+   do pedido principal (vem no ctx). Sem ele, uma tela de terminal nova. */
+function emitirDe(ctx) {
+    if (!ctx.emitir) ctx.emitir = require('../../motor/tela-terminal.js').criar();
+    return ctx.emitir;
+}
+const telaDe = (ctx, vista, dados) => emitirDe(ctx)(eventosMotor.montar(vista, { profundidade: ctx.profundidade, ...dados }));
+
 function logResult(kind, result, profundidade) {
     const p = fala.resultado(profundidade);
     if (!result) return;
@@ -274,17 +298,24 @@ function logResult(kind, result, profundidade) {
     }
 
     switch (kind) {
-        case 'write_file':
-            console.log(p + c.muted(`${result.created ? 'criado' : 'atualizado'} · ${tools.fmtBytes(result.bytes)}`));
+        case 'write_file': {
+            const k = contarMudanca(result);
+            if (k) require('../../tui/ui').registrarArquivo(result.path, k.mais, k.menos);
+            console.log(p + c.muted(`${result.created ? 'criado' : 'atualizado'} · ${tools.fmtBytes(result.bytes)}`)
+                + (k ? c.muted(' · ') + c.ok(`+${k.mais}`) + ' ' + c.err(`−${k.menos}`) : ''));
             // Reescrever arquivo que já existia apaga o que estava lá. O
             // número de bytes não conta isso; o bloco embaixo conta.
             mostrarDiff(result, profundidade);
             return;
+        }
         case 'edit_file':
         case 'multi_edit': {
             const delta = result.linhasDepois - result.linhasAntes;
             const sinal = delta > 0 ? c.ok(`+${delta}`) : delta < 0 ? c.err(`${delta}`) : c.muted('±0');
-            console.log(p + c.muted(`${result.substituicoes} troca${result.substituicoes > 1 ? 's' : ''} · `) + sinal + c.muted(' linhas'));
+            const k = contarMudanca(result);
+            if (k) require('../../tui/ui').registrarArquivo(result.path, k.mais, k.menos);
+            console.log(p + c.muted(`${result.substituicoes} troca${result.substituicoes > 1 ? 's' : ''} · `) + sinal + c.muted(' linhas')
+                + (k ? c.muted(' · ') + c.ok(`+${k.mais}`) + ' ' + c.err(`−${k.menos}`) : ''));
             mostrarDiff(result, profundidade);
             return;
         }
@@ -329,6 +360,7 @@ function logResult(kind, result, profundidade) {
             return;
         }
         case 'write_todos': {
+            require('../../tui/ui').estadoSessao.todos = result.todos || [];
             const marca = { completed: c.ok('✔'), in_progress: c.brand('▶'), pending: c.dim('○') };
             for (const t of result.todos || []) {
                 const texto = t.status === 'completed' ? c.dim(t.content) : c.white(t.content);
@@ -920,7 +952,28 @@ async function runActInterno(userPrompt, opts) {
             : () => require('../../browser.js').aquecerRevisor(),
         /* Quem é este agente no livro de ações (auditoria.js). */
         rotulo = subagent ? 'subagente' : 'principal',
+        /* Para onde vão os eventos do turno (lib/motor/eventos.js). O motor
+           não escreve na tela: quem desenha assina. Sem ninguém de fora, nasce
+           uma tela de terminal (lib/motor/tela-terminal.js) — a saída de sempre. */
+        emitir: emitirDeFora = null,
     } = opts || {};
+    const emitir = emitirDeFora || require('../../motor/tela-terminal.js').criar();
+    const ev = (vista, dados) => emitir(eventosMotor.montar(vista, { profundidade, ...dados }));
+    /* Spinner por evento: a tela decide se gira (terminal) ou se mostra "trabalhando" (app). */
+    const girar = (rotulo) => {
+        const id = eventosMotor.novoId();
+        ev('spinner-inicia', { id, rotulo });
+        return {
+            set detalhe(v) { ev('spinner-detalhe', { id, detalhe: v }); },
+            stop() { ev('spinner-para', { id }); },
+        };
+    };
+    /* O texto que corre na tela conforme chega: mesma interface do fala.fluxo(). */
+    const abrirFluxo = (texto) => {
+        const id = eventosMotor.novoId();
+        ev('fluxo-inicia', { id, texto });
+        return { escrever: (t) => ev('fluxo-escreve', { id, texto: t }), fechar: () => ev('fluxo-fecha', { id }) };
+    };
 
     // A pasta de projeto só nasce quando o agente for mesmo MEXER EM ARQUIVO.
     // Antes ela nascia na primeira tool qualquer — pedir "abre o Chrome" criava
@@ -968,7 +1021,7 @@ async function runActInterno(userPrompt, opts) {
         const t = Date.now();
         // Com spinner: eram segundos de tela parada entre o último arquivo e o
         // "pronto", e parecia que tinha travado ali.
-        const sp = new Spinner('abrindo a página escondido para conferir').start();
+        const sp = girar('abrindo a página escondido para conferir');
         try {
             medida = await medirPagina(pastaAtual);
         } catch { medida = null; } finally { sp.stop(); }
@@ -977,7 +1030,7 @@ async function runActInterno(userPrompt, opts) {
         if (!medida || !medida.testou) return null;
         avisoDaPagina = medida.limpo ? ''
             : String(medida.relato || '').split('\n').filter((l) => /·|BRANCO/.test(l)).slice(0, 3).join(' ');
-        if (medida.limpo) { fala.pensamento('a página abriu sem erro', profundidade); return null; }
+        if (medida.limpo) { ev('pensamento', { texto: 'a página abriu sem erro' }); return null; }
         return conferencias >= 2 ? null : medida.relato;
     };
     /* ── RODAR OS TESTES ANTES DE DIZER "PRONTO" (lib/conferir.js) ──────
@@ -1000,7 +1053,7 @@ async function runActInterno(userPrompt, opts) {
         const achados = K.procurar([...arquivosDaTarefa], { raiz: pastaAtual });
         avisoDaChave = K.relato(achados);
         if (!avisoDaChave) return null;
-        console.log(c.warn(`  ⚠ ${avisoDaChave}`));
+        ev('linha', { texto: `  ⚠ ${avisoDaChave}`, nivel: 'aviso' });
         return conferiuChaves >= 2 ? null : `${avisoDaChave} Tire a chave do código: leia de um .env (process.env) ou do servidor, e ponha o .env no .gitignore.`;
     };
     const conferirTestes = async () => {
@@ -1022,14 +1075,14 @@ async function runActInterno(userPrompt, opts) {
         if (r.ok) {
             avisoDosTestes = '';
             if (erroQueHavia) notaDoConserto = `O que estava errado: os testes falhavam (${erroQueHavia}); depois do conserto, passaram.`;
-            console.log(c.ok(`  ✓ ${ex.titulo}`) + c.dim(` (${como.comando})`));
+            ev('linha', { texto: `  ✓ ${ex.titulo} (${como.comando})`, nivel: 'ok' });
             try { checkpoint.marcarFuncionando(pastaAtual, `${como.comando}, pelo agente`); } catch { /* sem ponto pra marcar */ }
             return null;
         }
         avisoDosTestes = `${ex.titulo} ${ex.linhas.slice(0, 2).join(' ')}`.trim();
         // a frase que explica (a do Error:, se houver), não a do stack: é a que a pessoa entende
         if (!erroQueHavia) erroQueHavia = String(ex.linhas.find((l) => /error|erro|assert|fail|falh/i.test(l)) || ex.linhas[0] || '').trim().slice(0, 140);
-        console.log(c.warn(`  ✗ ${ex.titulo}`) + c.dim(` (${como.comando})`));
+        ev('linha', { texto: `  ✗ ${ex.titulo} (${como.comando})`, nivel: 'aviso' });
         return rodadasDeTeste >= 2 ? null : `Rodei \`${como.comando}\` e falhou:\n${r.saida}`;
     };
     /* O ARQUIVO QUE O PEDIDO MANDA GRAVAR (lib/plugin/entregaveis.js): "grave o
@@ -1098,7 +1151,7 @@ async function runActInterno(userPrompt, opts) {
         if (decisao !== 'recusada' && decisao !== 'negada') require('../../plugin/voz-ponte').ferramenta(tc.name, tc.arguments);
         const id = auditoria.antes({ agente: rotulo, ferramenta: tc.name, args: tc.arguments, decisao, motivo });
         const falhou = auditoria.problema();
-        if (falhou) console.log(c.warn(`⚠ ${falhou}`));
+        if (falhou) ev('linha', { texto: `⚠ ${falhou}`, nivel: 'aviso' });
         return id;
     };
     // O que read_file/list_dir devolveram, pela chave da época (repeticao.js).
@@ -1339,10 +1392,10 @@ async function runActInterno(userPrompt, opts) {
         }
         // Recado digitado durante o passo anterior entra AGORA, antes da ida
         // ao modelo — o resultado das ferramentas já está na conversa.
-        if (!subagent) entregarRecados(messages, profundidade);
+        if (!subagent) entregarRecados(messages, profundidade, emitir);
         // Tarefa em segundo plano que acabou desde a última volta (lib/fundo.js): o modelo fica sabendo.
         if (!subagent) for (const av of require('../../fundo').pegarAvisos()) messages.push({ role: 'user', content: av.texto });
-        const sp = new Spinner(subagent ? 'subagente trabalhando' : PENSANDO).start();
+        const sp = girar(subagent ? 'subagente trabalhando' : PENSANDO);
 
         const toolCalls = [];
         let assistantText = '';
@@ -1375,7 +1428,7 @@ async function runActInterno(userPrompt, opts) {
                             resumir: ({ resumo, mensagens }, todos) => comp.resumirComFatos({ resumo, mensagens },
                                 (p) => motor.requestResumo(server, { ...p, token }).then((x) => x && x.resumo), todos),
                         });
-                        if (r.ok) console.log(ident(profundidade) + c.dim(`  ⎿ conversa passou de 80% da janela: ${r.resumidas} mensagens viraram resumo (${r.antes} → ${r.depois} tokens)`));
+                        if (r.ok) ev('linha', { texto: `  ⎿ conversa passou de 80% da janela: ${r.resumidas} mensagens viraram resumo (${r.antes} → ${r.depois} tokens)`, nivel: 'dim' });
                     }
                 } catch { /* resumo é economia, não requisito */ }
             }
@@ -1396,8 +1449,7 @@ async function runActInterno(userPrompt, opts) {
                     if (!subagent && !toolCalls.length) {
                         if (!fluxo && assistantText.length > fala.LIMIAR_PENSAMENTO) {
                             sp.stop();
-                            fluxo = fala.fluxo();
-                            fluxo.escrever(assistantText);
+                            fluxo = abrirFluxo(assistantText);
                         } else if (fluxo) fluxo.escrever(evt.delta);
                     }
                 }
@@ -1429,14 +1481,14 @@ async function runActInterno(userPrompt, opts) {
                 }
             }
             if (subagent) return { assistantMessage: { role: 'assistant', content: `Subagente falhou: ${fala.frase(e)}` } };
-            fala.problema(e);
+            ev('problema', { erro: e });
             throw e;
         }
         sp.stop();
         emVoo = null;
         if (!subagent && !avisouReserva && modeloDaVolta && modeloDaVolta.reserva) {
             avisouReserva = true;
-            console.log(c.dim(`  ⎿ ${linhaDaReserva(modeloDaVolta.modelo)}`));
+            ev('linha', { texto: `  ⎿ ${linhaDaReserva(modeloDaVolta.modelo)}`, nivel: 'dim' });
         }
         traco(`volta ${voltas} voltou em ${Math.round((Date.now() - tRodada) / 1000)}s · ${toolCalls.map((t) => t.name).join(', ') || 'texto'}${streamError ? ' · erro: ' + String(streamError).slice(0, 160) : ''}`);
         tempos.somar(subagent ? 'rodada do subagente' : 'rodada do modelo', Date.now() - tRodada);
@@ -1519,7 +1571,7 @@ async function runActInterno(userPrompt, opts) {
             if (fluxo) fluxo.fechar();
             const amigavel = fala.frase(streamError);
             if (subagent) return { assistantMessage: { role: 'assistant', content: `Subagente falhou: ${amigavel}` }, concluiu: false };
-            fala.problema(streamError);
+            ev('problema', { erro: 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 };
@@ -1561,7 +1613,7 @@ async function runActInterno(userPrompt, opts) {
                 if (pendentes) cobrouPlano = true;   // este empurrão já cobrou o plano aberto
                 if (!subagent) {
                     if (fluxo) fluxo.fechar();
-                    else fala.pensamento(finalText, profundidade);
+                    else ev('pensamento', { texto: finalText });
                 }
                 messages.push({ role: 'assistant', content: finalText });
                 messages.push({
@@ -1582,7 +1634,7 @@ async function runActInterno(userPrompt, opts) {
                 try { const K = require('../../plugin/kits.js'); if (K.continuaVideo(userPrompt)) falta = K.batidasFaltando(pastaAtual); } catch { /* sem kits */ }
                 if (falta.length) {
                     empurroesDoKit++;
-                    if (fluxo) fluxo.fechar(); else fala.pensamento(finalText, profundidade);
+                    if (fluxo) fluxo.fechar(); else ev('pensamento', { texto: finalText });
                     messages.push({ role: 'assistant', content: finalText });
                     messages.push({ role: 'user', content: `O vídeo ainda não está montado: faltam as batidas ${falta.join(', ')} em motion/plano.json. Não explique — mande agora a batida ${falta[0]}: run_shell "primocode kit batida ${falta[0]} --camadas '[…]'" (o formulário: "primocode kit batida ${falta[0]}"), e siga até o cartão (primocode kit plano).` });
                     finalText = '';
@@ -1645,7 +1697,7 @@ async function runActInterno(userPrompt, opts) {
             }
             if (!subagent) {
                 if (fluxo) fluxo.fechar();
-                else fala.resposta(finalText);
+                else ev('resposta', { texto: finalText });
             }
             /* Ia terminar, mas chegou recado no meio: a tarefa não acaba com
                a pessoa esperando resposta. A volta seguinte entrega o recado. */
@@ -1661,7 +1713,7 @@ async function runActInterno(userPrompt, opts) {
         // 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);
+            else if (assistantText.trim()) ev('pensamento', { texto: assistantText });
         }
 
         // Registra o turno do assistente COM os tool_calls. A API exige que
@@ -1694,14 +1746,14 @@ async function runActInterno(userPrompt, opts) {
         /* O plano decide quantos subagentes rodam JUNTOS (lib/config/limites.js; grátis e
            Primo: um de cada vez, o resto continua em fila). Nunca recusa: só diz o porquê. */
         const par = spawns.length > 1 ? await limites.paralelo() : null;
-        if (par) { const av = par.aviso(spawns.length); if (av && !avisouParalelo) { avisouParalelo = true; console.log(`  ${av}`); } }
+        if (par) { const av = par.aviso(spawns.length); if (av && !avisouParalelo) { avisouParalelo = true; ev('linha', { texto: `  ${av}` }); } }
         if (spawns.length > 1 && par.max > 1 && !PARAR) {
             const juntos = spawns.slice(0, par.max);
-            fala.paralelo(juntos.length, profundidade);
+            ev('paralelo', { quantos: juntos.length });
             const ids = juntos.map((tc) => anotar(tc, 'permitida'));
             const rs = await Promise.all(juntos.map((tc) =>
                 runSubagent(tc.arguments || {}, {
-                    server, model, token, projectDir: pastaAtual, projectName, profundidade, motor, permissoes,
+                    server, model, token, projectDir: pastaAtual, projectName, profundidade, motor, permissoes, emitir,
                 }).catch((e) => `Subagente falhou: ${e && e.message}`)));
             juntos.forEach((tc, i) => { resultadosSpawn.set(tc.id, rs[i]); auditoria.depois(ids[i], { ok: true }); });
         }
@@ -1824,7 +1876,7 @@ async function runActInterno(userPrompt, opts) {
                usuário (o bin). Sem a resposta dele, não troca. */
             if (tc.name === 'mudar_pasta') {
                 algoRodou = true;
-                fala.acao(tc.name, tc.arguments, profundidade);
+                ev('acao', { nome: tc.name, args: tc.arguments });
                 const idA = anotar(tc, 'permitida');
                 const r = await require('../../outra-pasta.js').pedirTroca(tc.arguments || {}, {
                     atual: pastaAtual, subagent, trocar: mudarPasta,
@@ -1834,7 +1886,7 @@ async function runActInterno(userPrompt, opts) {
                     criarPasta = null;
                     temPasta = true;
                 }
-                logResult(tc.name, r, profundidade);
+                ev('resultado', { nome: tc.name, resultado: r });
                 auditoria.depois(idA, r);
                 repeticao.executou(jaChamado, tc.name, tc.arguments);
                 messages.push({ role: 'tool', tool_call_id: tc.id, content: JSON.stringify(r) });
@@ -1847,7 +1899,7 @@ async function runActInterno(userPrompt, opts) {
                 const r = resultadosSpawn.has(tc.id)
                     ? resultadosSpawn.get(tc.id)
                     : await runSubagent(tc.arguments || {}, {
-                        server, model, token, projectDir: pastaAtual, projectName, profundidade, motor, permissoes,
+                        server, model, token, projectDir: pastaAtual, projectName, profundidade, motor, permissoes, emitir,
                     });
                 if (idA) auditoria.depois(idA, { ok: true });
                 repeticao.executou(jaChamado, tc.name, tc.arguments);
@@ -1859,12 +1911,12 @@ async function runActInterno(userPrompt, opts) {
                nova, e quem sabe abrir conversa é este arquivo. */
             if (tc.name === 'planejar_producao') {
                 algoRodou = true;
-                fala.acao(tc.name, tc.arguments, profundidade);
+                ev('acao', { nome: tc.name, args: tc.arguments });
                 const idA = anotar(tc, 'permitida');
                 const r = await rodarDiretor(tc.arguments || {}, {
-                    server, model, token, projectDir: pastaAtual, projectName, profundidade, motor, permissoes,
+                    server, model, token, projectDir: pastaAtual, projectName, profundidade, motor, permissoes, emitir,
                 });
-                logResult(tc.name, r, profundidade);
+                ev('resultado', { nome: tc.name, resultado: r });
                 auditoria.depois(idA, r);
                 messages.push({ role: 'tool', tool_call_id: tc.id, content: JSON.stringify(r) });
                 continue;
@@ -1879,12 +1931,12 @@ async function runActInterno(userPrompt, opts) {
             if (tc.name === 'construir_app') {
                 algoRodou = true;
                 garantirPasta();
-                fala.acao(tc.name, tc.arguments, profundidade);
+                ev('acao', { nome: tc.name, args: tc.arguments });
                 const idA = anotar(tc, 'permitida');
                 const r = await rodarPipeline(tc.arguments || {}, {
-                    server, model, token, projectDir: pastaAtual, projectName, profundidade, motor, permissoes, livro, autorizar, controle: portaoControle,
+                    server, model, token, projectDir: pastaAtual, projectName, profundidade, motor, permissoes, emitir, livro, autorizar, controle: portaoControle,
                 });
-                logResult(tc.name, r, profundidade);
+                ev('resultado', { nome: tc.name, resultado: r });
                 auditoria.depois(idA, r);
                 repeticao.executou(jaChamado, tc.name, tc.arguments);
                 messages.push({ role: 'tool', tool_call_id: tc.id, content: JSON.stringify(r) });
@@ -1957,8 +2009,8 @@ async function runActInterno(userPrompt, opts) {
                     igual = !!e && voltas - e.volta <= 1 && require('fs').readFileSync(abs, 'utf8') === e.texto;
                 } catch { igual = false; }
                 if (igual) {
-                    fala.acao(tc.name, tc.arguments, profundidade);
-                    console.log(fala.resultado(profundidade) + c.muted('igual ao que ele escreveu — não precisou ler'));
+                    ev('acao', { nome: tc.name, args: tc.arguments });
+                    ev('resultado-linha', { texto: 'igual ao que ele escreveu — não precisou ler' });
                     messages.push({ role: 'tool', tool_call_id: tc.id, content: JSON.stringify({
                         ok: true, igualAoQueVoceEscreveu: true,
                         aviso: 'Este arquivo está EXATAMENTE como você o escreveu nesta tarefa — o conteúdo é o da sua '
@@ -1990,8 +2042,8 @@ async function runActInterno(userPrompt, opts) {
                 const porta = await permissao.pedir(portaoControle, tc.name, tc.arguments, autorizar);
                 if (!porta.ok) {
                     anotar(tc, 'recusada', porta.error);
-                    fala.acao(tc.name, tc.arguments, profundidade);
-                    console.log(fala.resultado(profundidade) + c.warn('não autorizado'));
+                    ev('acao', { nome: tc.name, args: tc.arguments });
+                    ev('resultado-linha', { texto: 'não autorizado', nivel: 'aviso' });
                     registro.anotar(livro, tc.name, tc.arguments, { ok: false, error: porta.error });
                     messages.push({ role: 'tool', tool_call_id: tc.id, content: JSON.stringify({ ok: false, error: porta.error }) });
                     continue;
@@ -2008,8 +2060,8 @@ async function runActInterno(userPrompt, opts) {
             });
             if (!risco.ok) {
                 anotar(tc, 'recusada', risco.motivo || risco.error);
-                fala.acao(tc.name, tc.arguments, profundidade);
-                console.log(fala.resultado(profundidade) + c.warn(`não autorizado — ${risco.motivo}`));
+                ev('acao', { nome: tc.name, args: tc.arguments });
+                ev('resultado-linha', { texto: `não autorizado — ${risco.motivo}`, nivel: 'aviso' });
                 registro.anotar(livro, tc.name, tc.arguments, { ok: false, error: risco.error });
                 messages.push({ role: 'tool', tool_call_id: tc.id, content: JSON.stringify({ ok: false, error: risco.error }) });
                 continue;
@@ -2019,8 +2071,8 @@ async function runActInterno(userPrompt, opts) {
             const gancho = hooks.rodar('PreToolUse', { nome: tc.name, args: tc.arguments, projectDir: pastaAtual });
             if (gancho.bloqueado) {
                 anotar(tc, 'recusada', gancho.motivo);
-                fala.acao(tc.name, tc.arguments, profundidade);
-                console.log(fala.resultado(profundidade) + c.warn(`bloqueado por hook — ${gancho.motivo.slice(0, 80)}`));
+                ev('acao', { nome: tc.name, args: tc.arguments });
+                ev('resultado-linha', { texto: `bloqueado por hook — ${gancho.motivo.slice(0, 80)}`, nivel: 'aviso' });
                 registro.anotar(livro, tc.name, tc.arguments, { ok: false, error: gancho.motivo });
                 messages.push({ role: 'tool', tool_call_id: tc.id, content: JSON.stringify({ ok: false, error: `Bloqueado por hook: ${gancho.motivo}` }) });
                 continue;
@@ -2031,13 +2083,13 @@ async function runActInterno(userPrompt, opts) {
             if (['run_shell', 'run_in_new_terminal', 'run_background'].includes(tc.name) && perigo.apagaBancoNoComando((tc.arguments || {}).command)) {
                 try {
                     const copia = require('../../backup-banco.js').fazer(pastaAtual);
-                    if (copia) console.log(c.ok('  ⎿ fiz uma cópia do banco antes') + c.dim(` (${copia.arquivos.join(', ')}) · /undo devolve`));
+                    if (copia) ev('linha', { texto: `  ⎿ fiz uma cópia do banco antes (${copia.arquivos.join(', ')}) · /undo devolve`, nivel: 'ok' });
                 } catch { /* sem cópia o comando segue: ela é rede de segurança, não condição */ }
             }
 
             algoRodou = true;
             rodouTool = true;
-            fala.acao(tc.name, tc.arguments, profundidade);
+            ev('acao', { nome: tc.name, args: tc.arguments });
             /* Antes de mexer no arquivo, guarda o original — é o que o /desfazer
                devolve. Caminho inválido não é problema nosso: a tool recusa. */
             let antesDaEdicao = null, arquivoDaEdicao = null;   // pro alarme do arquivo que encolheu (lib/session/encolheu.js)
@@ -2052,7 +2104,7 @@ async function runActInterno(userPrompt, opts) {
                 catch (e) {
                     // Caminho inválido a tool recusa sozinha. O resto (disco cheio, sem permissão)
                     // quer dizer que o /desfazer não vai devolver este arquivo: a pessoa tem que saber.
-                    if (tc.arguments && tc.arguments.path) console.log(c.warn(`  ⚠ não guardei o original de ${tc.arguments.path}: o /undo não vai voltar este arquivo (${e.message})`));
+                    if (tc.arguments && tc.arguments.path) ev('linha', { texto: `  ⚠ não guardei o original de ${tc.arguments.path}: o /undo não vai voltar este arquivo (${e.message})`, nivel: 'aviso' });
                 }
             }
             /* O servidor, o token e o cliente da API vão junto: a legenda do
@@ -2061,7 +2113,9 @@ async function runActInterno(userPrompt, opts) {
             traco(`executando ${tc.name}`);
             const idAcao = idsAdiantados.get(tc.id) || anotar(tc, 'permitida');
             const result = adiantadas.has(tc.id) ? adiantadas.get(tc.id)
-                : await tools.execute(tc.name, tc.arguments, { projectDir: pastaAtual, server, token, api, escolher: subagent ? undefined : escolher });
+                : await tools.execute(tc.name, tc.arguments, { projectDir: pastaAtual, server, token, api, escolher: subagent ? undefined : escolher,
+                    // estudio_criar conta o andamento: a tela desenha a barra do item `estudio`.
+                    progresso: tc.name === 'estudio_criar' ? (pct, etapa) => ev('estudio-progresso', { pct, etapa }) : undefined });
             auditoria.depois(idAcao, result);
             if (sinais && result && result.ok && /^(write_file|edit_file|multi_edit)$/.test(tc.name)) sinais.diagSujo = !!result.diagnosticos;   // diagnóstico depois da edição
             if (antesDaEdicao != null && result && result.ok !== false) {
@@ -2069,19 +2123,21 @@ async function runActInterno(userPrompt, opts) {
                 try { depois = require('fs').readFileSync(arquivoDaEdicao, 'utf8'); } catch { depois = null; }
                 const encolheu = require('../encolheu.js').julgar(antesDaEdicao, depois);
                 if (encolheu) {
-                    console.log(c.warn(`  ⚠ ${tc.arguments.path}: ${encolheu.texto}. Se sumiu código sem querer, /undo volta.`));
+                    ev('linha', { texto: `  ⚠ ${tc.arguments.path}: ${encolheu.texto}. Se sumiu código sem querer, /undo volta.`, nivel: 'aviso' });
                     result.aviso_encolheu = `ATENÇÃO: ${tc.arguments.path} ${encolheu.texto}. Confira se você não apagou código sem querer; se apagou, refaça a edição sem cortar nada.`;
                 }
             }
-            for (const aviso of hooks.rodar('PostToolUse', { nome: tc.name, args: tc.arguments, resultado: result, projectDir: pastaAtual }).avisos) console.log(c.dim(`  ⎿ ${aviso}`));
+            for (const aviso of hooks.rodar('PostToolUse', { nome: tc.name, args: tc.arguments, resultado: result, projectDir: pastaAtual }).avisos) ev('linha', { texto: `  ⎿ ${aviso}`, nivel: 'dim' });
             traco(`${tc.name} devolveu ok=${result && result.ok}`);
             if (/^estudio_|^planejar_producao$/.test(tc.name) && result && result.ok !== false) {
                 const id = result.id || (result.projeto && result.projeto.id) || (tc.arguments && tc.arguments.id);
                 if (typeof id === 'string' && id) estudioDaTarefa = id;
             }
-            logResult(tc.name, result, profundidade);
+            ev('resultado', { nome: tc.name, resultado: result });
+            // Render é lento e roda solto: ao fim, o sino avisa (vira notice/created no app).
+            if (tc.name === 'estudio_criar' && result && result.ok !== false && result.arquivo) ev('aviso', { texto: `${result.resumo || 'Pronto'} ${require('path').basename(result.arquivo)}` });
             if (/^estudio_render/.test(tc.name) && result && result.conferencia && !subagent) {
-                for (const l of require('../../plugin/estudio/conferencia.js').linhasPraPessoa(result.conferencia)) console.log(c.warn(`  ⎿ ${l}`));
+                for (const l of require('../../plugin/estudio/conferencia.js').linhasPraPessoa(result.conferencia)) ev('linha', { texto: `  ⎿ ${l}`, nivel: 'aviso' });
             }
             repeticao.executou(jaChamado, tc.name, tc.arguments);
             if (RELEITURA.has(tc.name) && result && result.ok !== false) {
@@ -2202,7 +2258,7 @@ async function runActInterno(userPrompt, opts) {
 
         if (finished) {
             finalText = finished;
-            if (!subagent) fala.resposta(finished);
+            if (!subagent) ev('resposta', { texto: finished });
             // Recado chegou enquanto ele fechava: entrega e segue.
             if (!subagent && CAIXA.length && !PARAR) { finalText = ''; continue; }
             break;
@@ -2220,14 +2276,14 @@ async function runActInterno(userPrompt, opts) {
     let passagemDaParada = null;
     if (paradoPorTravar && !finalText) {
         finalText = paradoPorTravar;
-        if (!subagent) fala.aviso(finalText);
+        if (!subagent) ev('aviso', { texto: finalText });
         // Parou sem terminar: a memória leva o estado, não só "parei" (lib/passagem.js).
         passagemDaParada = require('../../passagem').montar({ pedido: userPrompt, motivo: finalText, registro: livro, falhasPendentes });
     }
 
     if (PARAR && !finalText) {
         finalText = 'Parado por você (Esc Esc). O que já foi feito, ficou feito.';
-        if (!subagent) fala.aviso(finalText);
+        if (!subagent) ev('aviso', { texto: finalText });
     }
 
     // Nunca terminar em silêncio. Quando o modelo devolvia resposta vazia sem
@@ -2236,7 +2292,7 @@ async function runActInterno(userPrompt, opts) {
     // depois de a primeira tentativa de seletor falhar.
     if (!finalText) {
         finalText = motivoDaParada({ voltas, voltasEmFalso, falhasPendentes, travou: rodadasParadas >= MAX_RODADAS_PARADAS, teto });
-        if (!subagent) fala.aviso(finalText);
+        if (!subagent) ev('aviso', { texto: finalText });
         passagemDaParada = require('../../passagem').montar({ pedido: userPrompt, motivo: finalText, registro: livro, falhasPendentes });
     }
 
@@ -2250,7 +2306,7 @@ async function runActInterno(userPrompt, opts) {
     // arquivo de verdade — a memória era descartada nesse caso, sempre.
     // A raiz de trabalho não é projeto: um memory.md solto em ~/primocode
     // era o que um pedido de vídeo (que trabalha na raiz) deixava para trás.
-    if (!subagent && temPasta && require('path').resolve(pastaAtual) !== require('path').resolve(cfg.ROOT_DIR)) {
+    if (!subagent && temPasta && pastaAtual && require('path').resolve(pastaAtual) !== require('path').resolve(cfg.ROOT_DIR)) {
         cfg.appendProjectMemory(pastaAtual, passagemDaParada || `**Pedido:** ${userPrompt.slice(0, 300)}\n**Resultado:** ${finalText.slice(0, 500)}`);
     }
 
@@ -2299,11 +2355,13 @@ async function runSubagent(args, ctx) {
     // 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.
     // Novo catálogo (agentes/): "id" ou "id1,id2" (até 3 olhares na mesma tarefa); o que não existe cai no legado.
-    const novos = require('../../agentes').refinar(args.especialista, args.prompt);   // o catálogo confere o chute do modelo
-    const esp = novos.length ? null : especialistas.escolher(args.especialista, args.prompt);
+    // `agente`: um agente da pessoa (~/.primocode/agentes, lib/agentes-pessoais.js) ganha do catálogo e do legado.
+    const meu = args.agente ? require('../../agentes-pessoais').ler(args.agente) : null;
+    const novos = meu ? [] : require('../../agentes').refinar(args.especialista, args.prompt);   // o catálogo confere o chute do modelo
+    const esp = meu ? require('../../agentes-pessoais').comoEspecialista(meu) : novos.length ? null : especialistas.escolher(args.especialista, args.prompt);
     const agentes = require('../../agentes');
-    const rot = novos.length ? agentes.rotulo(novos) : especialistas.rotulo(esp);
-    fala.agente(rot, descricao, profundidade);
+    const rot = meu ? meu.nome : novos.length ? agentes.rotulo(novos) : especialistas.rotulo(esp);
+    telaDe(ctx, 'agente', { rotulo: rot, descricao });
 
     // modelo_sugerido do briefing vale quando o placar ainda não tem dado desse tipo de tarefa.
     let modeloDoAgente = model;
@@ -2322,6 +2380,7 @@ async function runSubagent(args, ctx) {
         subagent: true,
         motor,
         permissoes,
+        emitir: emitirDe(ctx),
         autorizar: ctx.autorizar,
         controle: ctx.controle,   // o mesmo objeto: a resposta vale para todos
         rotulo: `subagente: ${String(descricao).slice(0, 60)}`,
@@ -2334,7 +2393,7 @@ async function runSubagent(args, ctx) {
     if (ctx.livro && r.registro) registro.juntar(ctx.livro, r.registro);
 
     const resumo = r.assistantMessage.content || 'sem resultado';
-    fala.agenteVoltou(resumo, profundidade);
+    telaDe(ctx, 'agente-voltou', { texto: resumo });
     return entregaDoAgente(rot, resumo, r.registro, { pasta: projectDir });
 }
 
@@ -2417,10 +2476,10 @@ async function rodarDiretor(args, ctx) {
     const diretor = require('../../plugin/estudio/diretor.js');
     const correr = async (prompt, rotulo) => {
         if (PARAR) return '';
-        fala.agente('Diretor', rotulo, profundidade);
+        telaDe(ctx, 'agente', { rotulo: 'Diretor', descricao: rotulo });
         const r = await runAct(prompt, {
             server, model, token, projectDir, projectName,
-            history: [], profundidade: profundidade + 1, subagent: true, motor, permissoes,
+            history: [], profundidade: profundidade + 1, subagent: true, motor, permissoes, emitir: emitirDe(ctx),
         });
         return (r && r.assistantMessage && r.assistantMessage.content) || '';
     };
@@ -2431,7 +2490,7 @@ async function rodarDiretor(args, ctx) {
         formato: args.formato === 'apresentacao' ? 'apresentacao' : 'video',
         contexto: args.contexto || '',
         correr,
-        mostrar: (t) => fala.agente('Diretor', t, profundidade),
+        mostrar: (t) => telaDe(ctx, 'agente', { rotulo: 'Diretor', descricao: t }),
     });
     if (!r.ok) return r;
 
@@ -2473,10 +2532,10 @@ async function rodarPipeline(args, ctx) {
 
     const correr = async (prompt, rotulo) => {
         if (PARAR) return '';
-        fala.agente('Agente', rotulo, profundidade);
+        telaDe(ctx, 'agente', { rotulo: 'Agente', descricao: rotulo });
         const r = await runAct(prompt, {
             server, model, token, projectDir: pasta, projectName,
-            history: [], profundidade: profundidade + 1, subagent: true, motor, permissoes,
+            history: [], profundidade: profundidade + 1, subagent: true, motor, permissoes, emitir: emitirDe(ctx),
         });
         return (r && r.assistantMessage && r.assistantMessage.content) || '';
     };
@@ -2486,7 +2545,7 @@ async function rodarPipeline(args, ctx) {
         pasta,
         rodadas: args.rodadas,
         correr,
-        mostrar: (linha) => console.log(fala.resultado(profundidade) + c.muted(linha)),
+        mostrar: (linha) => telaDe(ctx, 'resultado-linha', { texto: linha }),
         abrir: tools.openInBrowser,
     });
 }
@@ -2518,5 +2577,5 @@ function novoPortaoDeProva() {
     };
 }
 
-module.exports = { summarizeForModel, mesmoComando, EDICAO_DE_VIDEO_FALADO, novoPortaoDeProva, runAct, erroDaCorrente, linhaDaReserva, videoForaDeEdicao, entregaDoAgente, lembreteDeParalelo, buildMemoryContext, leituraPeloShell, historicoEnxuto, interromper, interrompido, mandarDuranteATarefa, trabalhando, sobrasDaCaixa, entregarRecados, compactar, motivoDaParada, pareceParadaNoMeio, ehTetoDeToken, ehTransitorio, esperaDoErro,
+module.exports = { summarizeForModel, mesmoComando, EDICAO_DE_VIDEO_FALADO, novoPortaoDeProva, runAct, logResult, interrompido: () => PARAR, erroDaCorrente, linhaDaReserva, videoForaDeEdicao, entregaDoAgente, lembreteDeParalelo, buildMemoryContext, leituraPeloShell, historicoEnxuto, interromper, interrompido, mandarDuranteATarefa, trabalhando, sobrasDaCaixa, entregarRecados, compactar, motivoDaParada, pareceParadaNoMeio, ehTetoDeToken, ehTransitorio, esperaDoErro,
     anotacaoDoQueJaFoi, resumoDoQueJaFoi, encolherParaContinuar, recadoDoPlanoAberto, MAX_ITERATIONS };

package/lib/skill/catalogo.js

@@ -82,6 +82,8 @@ const GRUPOS = [
         nome: 'Estúdio',
         resumo: 'vídeo, motion, slides e arte — a IA faz, e no fim abre o resultado pronto',
         itens: [
+            { tool: 'estudio_criar', escreve: true, faz: 'a porta simples: cria slides, vídeo, motion, anúncio ou abertura do pedido ao arquivo, e abre o resultado',
+              args: 'tipo (slides|video|motion|anuncio|abertura). briefing (uma frase). duracao (s, opcional). formato (9:16|16:9|1:1, opcional). Para controle fino use as outras estudio_*.' },
             { tool: 'estudio_projeto', escreve: true, faz: 'abre, acha e lista os projetos do estúdio — cada peça é uma pasta que não some',
               args: 'acao: criar | abrir | procurar | listar | anotar | editar | assinatura. '
                 + 'assinatura: quando o usuário diz o que achou de um vídeo ("adorei a virada", "texto demais"), grave com texto (e o id) — o próximo vídeo parte disso; sem texto, lê as faixas e as notas. '
@@ -282,7 +284,7 @@ const GRUPOS = [
                 + 'Para só LER lá não precisa trocar: read_file/list_dir com o caminho absoluto, glob/grep com padrão absoluto.' },
             // Estas duas o loop do agente atende (lib/session/runner/act.js), não o tools.execute.
             { tool: 'spawn_agent', escreve: false, faz: 'chama um subagente especialista para uma parte da tarefa', noLoop: true,
-              args: 'description: 3 a 5 palavras, aparece na tela do usuário. prompt: instrução completa e autossuficiente — o subagente não vê esta conversa. especialista (opcional): id EXATO que agentes_buscar devolveu — não chute o nome (o mais específico vence: css-layout, pagamentos, kubernetes, regex…, não frontend/backend/devops) ou dois separados por vírgula — cada um chega com o briefing da profissão (lib/skill/especialistas.js); sem ele, a tarefa sugere.' },
+              args: 'description: 3 a 5 palavras, aparece na tela do usuário. prompt: instrução completa e autossuficiente — o subagente não vê esta conversa. especialista (opcional): id EXATO que agentes_buscar devolveu — não chute o nome (o mais específico vence: css-layout, pagamentos, kubernetes, regex…, não frontend/backend/devops) ou dois separados por vírgula — cada um chega com o briefing da profissão (lib/skill/especialistas.js); sem ele, a tarefa sugere. agente (opcional): nome de um agente da pessoa (@nome); ganha do especialista.' },
             { tool: 'construir_app', escreve: true, noLoop: true,
               faz: 'constrói um app ou site inteiro com quatro papéis: engenheiro de prompt → protótipo → MVP → revisor que testa escondido, em laço até passar',
               args: 'pedido: o que o usuário quer, com as palavras dele. pasta (opcional): onde construir — sem ela, uma pasta nova com o nome do pedido. rodadas (opcional, 1 a 4, padrão 2): quantas voltas de correção. '

package/lib/tool/tools.js

@@ -688,6 +688,7 @@ async function despachar(name, args, ctx) {
                     ok: true, created,
                     path: path.relative(projectDir, filePath).replace(/\\/g, '/'),
                     bytes: content.length,
+                    linhas: content.split('\n').length,
                     ...(created ? {} : { _antes: antes, _depois: content }),
                 };
             }
@@ -943,6 +944,12 @@ async function despachar(name, args, ctx) {
                 return estudio.ferramentaMidia(args);
             case 'estudio_ae':
                 return estudio.ferramentaAE(args);
+            case 'estudio_criar':
+                // A porta simples: abre o projeto e chama plano, motion e render por dentro. ctx.progresso alimenta a tela.
+                return estudio.ferramentaCriar(args, {
+                    ...ctx, projectDir,
+                    abrir: (arquivo) => { try { openInBrowser(arquivo); } catch {} },
+                });
             case 'estudio_motion':
                 return estudio.ferramentaMotion(args);
             case 'estudio_editar':