primocode 11.1.0 → 11.2.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'
@@ -258,6 +263,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;
@@ -920,7 +933,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 +1002,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 +1011,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 +1034,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 +1056,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 +1132,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 +1373,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 +1409,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 +1430,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 +1462,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 +1552,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 +1594,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 +1615,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 +1678,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 +1694,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 +1727,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 +1857,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 +1867,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 +1880,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 +1892,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 +1912,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 +1990,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 +2023,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 +2041,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 +2052,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 +2064,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 +2085,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 +2094,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 +2104,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 +2239,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 +2257,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 +2273,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 });
     }
 
@@ -2299,11 +2336,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 +2361,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 +2374,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 +2457,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 +2471,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 +2513,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 +2526,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 +2558,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

@@ -943,6 +943,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':

package/lib/tui/ui.js

@@ -566,7 +566,7 @@ const ROTULOS = {
         estudio_site:'Estúdio·marca',
         desktop_windows:'Desktop·janelas', desktop_focus:'Desktop·foco',
         desktop_elements:'Desktop·elementos', desktop_click_element:'Desktop·click',
-    estudio_midia:'Estúdio·mídia', estudio_ae:'Estúdio·After Effects', estudio_motion:'Estúdio·Motion', estudio_editar:'Estúdio·Editar', construir_app:'Construir',
+    estudio_midia:'Estúdio·mídia', estudio_ae:'Estúdio·After Effects', estudio_motion:'Estúdio·Motion', estudio_editar:'Estúdio·Editar', estudio_criar:'Estúdio·Criar', construir_app:'Construir',
     remember_general:'Lembrar', lembrar:'Memória',
     mcp_procurar:'MCP·procurar', mcp_conectar:'MCP·conectar', mcp_usar:'MCP',
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "primocode",
-  "version": "11.1.0",
+  "version": "11.2.0",
   "description": "PrimoCode — agente de engenharia com IA e cursor próprio. Requer conta Conecta Primo AI (Premium ou Super). Cria arquivos, roda comandos, controla navegador e desktop: abre apps, clica em botões e ícones pelo nome, digita e usa atalhos.",
   "main": "bin/primocode.js",
   "bin": {
@@ -10,7 +10,11 @@
     "start": "node bin/primocode.js",
     "postinstall": "node lib/preparar.js || true",
     "test:server": "cd server && npm test",
-    "test": "node scripts/testes.js"
+    "test": "node scripts/testes.js",
+    "test:app": "node test/app-fluxo.test.mjs && node test/app-primeira.test.mjs && node test/app-entrar.test.mjs",
+    "app:build": "cd app && npm run dist",
+    "app:dev": "cd app && npm start",
+    "mobile:build": "cd mobile && npm run build"
   },
   "engines": {
     "node": ">=18.17.0"