primocode 10.0.0 → 10.0.9

package/README.md

@@ -1,4 +1,4 @@
-# PrimoCode v10.0.0
+# PrimoCode v10.0.9
 
 Agente de engenharia brasileiro para o terminal, no estilo Claude Code.
 Cria arquivos de verdade, roda comandos, **controla o navegador e o desktop** —
@@ -9,7 +9,7 @@ OpenRouter, e cada apelido (`top`/`main`/`fast`) é uma **corrente**: se um mode
 está no limite de pedidos, o próximo atende. Você não vê o erro, e não paga nada.
 
 ```
- ▐▛███▜▌   Primo Code v10.0.0
+ ▐▛███▜▌   Primo Code v10.0.9
 ▝▜█████▛▘  Bem-vindo de volta, Joel
   ▘▘ ▝▝    ~/primocode  · /dir <pasta> muda
 ```

package/bin/primocode.js

@@ -62,6 +62,17 @@ const tempos = require('../lib/tempos');
 process.on('uncaughtException', (e) => {
     fala.problema(e);
 });
+/* O Node sai com 0 quando o laço de eventos esvazia — e uma promessa que
+   nunca resolve, sem timer nem socket vivo, faz exatamente isso: o pedido
+   "termina" calado no meio (visto no vídeo de escopo fechado, 01/10). Com
+   tarefa em andamento, sair assim é bug: diz, e sai com erro. */
+process.on('beforeExit', () => {
+    if (global.__primocodeTarefa) {
+        process.stderr.write(`\n  ⚠ o PrimoCode ia sair no meio da tarefa (${global.__primocodeTarefa}). Diga "continua" para retomar.\n`);
+        process.exitCode = 3;
+        global.__primocodeTarefa = null;
+    }
+});
 process.on('unhandledRejection', (e) => {
     fala.problema(e instanceof Error ? e : new Error(String(e)));
 });
@@ -639,6 +650,12 @@ function pedeProjetoNovo(texto) {
 const RE_COMPUTADOR = /\b(abr[ae]|abrir|clica|clique|clicar|digita|digite|digitar|mouse|cursor|teclado|meu computador|no (meu )?mac|na (minha )?tela|aplicativo|spotify|safari|finder|whatsapp|mensagens|m[úu]sica|configura[çc][õo]es|ajustes)\b/i;
 function querComputador(texto) { return RE_COMPUTADOR.test(String(texto || '')); }
 
+/* Pedido de VER o navegador ("abre o youtube", "entra no site x", "testa no
+   Chrome"). Sem isto as ferramentas browser_* rodam escondidas: pesquisar e
+   conferir não precisam abrir aba na tela da pessoa (02/10). */
+const RE_NAVEGADOR = /\b(navegador|chrome|browser|edge|brave|aba|abas|youtube|gmail|instagram|facebook|linkedin|login|loga|logar|(abr[ae]|abrir|entr[ae]|entrar|acess[ae]|acessar|mostr[ae]|testa|testar)\b[^.?!]{0,25}\b(site|p[áa]gina|link|url|google|navegador))\b/i;
+function querNavegador(texto) { return RE_NAVEGADOR.test(String(texto || '')); }
+
 /* Guarda onde se está, para a próxima sessão continuar aqui. */
 function entrarNoProjeto(dir, origem = 'projeto') {
     state.workDir = dir;
@@ -1051,6 +1068,42 @@ async function enviarPedido(userText) {
 
         const plan = prepararPasta(userText);
 
+        // O Chrome só aparece na tela quando o pedido é de navegador (lib/browser.js, definirVisivel).
+        require('../lib/browser.js').definirVisivel(querNavegador(userText));
+
+        /* AS REFERÊNCIAS DO VÍDEO, decididas pela pessoa antes de começar
+           (lib/estudio/referencias.js): web aberta, só o escopo que ela der,
+           ou nenhuma — só motion. No pedido único não há quem responda, e
+           vale o aberto. */
+        const referencias = require('../lib/estudio/referencias.js');
+        referencias.limpar();
+        const producao = require('../lib/estudio/diretor.js').precisaDeProducao(userText);
+        if (producao.producao && producao.formato === 'video') {
+            /* O modo sai do próprio pedido quando ele diz ("só motion", "só do
+               site x.com", "web aberta"). Quando NÃO diz, pergunta antes de
+               começar — "vídeo" às vezes quer dizer só o motion (02/10). No
+               pedido único não há quem responda, e vale o aberto. */
+            const r = referencias.inferir(userText);
+            if (!r.explicito && process.stdin.isTTY && !state.semTerminal) {
+                console.log('');
+                console.log('  ' + c.brand('▸') + ' ' + c.bold(c.white('Que vídeo você quer?')));
+                console.log('  ' + c.dim('1') + c.muted(' só motion — animação pura, nenhuma foto nem vídeo de fora'));
+                console.log('  ' + c.dim('2') + c.muted(' motion + web aberta — ele pesquisa e busca imagem e vídeo à vontade'));
+                console.log('  ' + c.dim('3') + c.muted(' motion + escopo fechado — só os sites e termos que você disser'));
+                const dito = String(await ask('  ' + c.brand('❯ ') + c.muted('1, 2 ou 3 '))).trim();
+                // Aqui 1 é o motion (a ordem da pergunta), não o 1 = aberto do entender().
+                const modo = { 1: 'sem', 2: 'aberto', 3: 'fechado' }[(/^\s*([123])\b/.exec(dito) || [])[1]] || referencias.entender(dito) || 'aberto';
+                r.modo = modo;
+                r.escopo = modo === 'fechado'
+                    ? String(await ask('  ' + c.brand('❯ ') + c.muted('quais sites ou termos? (separados por vírgula) '))).trim()
+                    : '';
+                if (modo === 'fechado' && !r.escopo) r.modo = 'aberto';
+            }
+            referencias.definir(r.modo, r.escopo);
+            console.log(c.dim(`  ⎿ referências: ${{ aberto: 'web aberta', fechado: 'só ' + r.escopo, sem: 'nenhuma, só motion' }[r.modo]}`)
+                + (r.modo === 'aberto' ? c.dim(' · diga "só motion" ou "só do site x.com" para mudar') : ''));
+        }
+
         // O resumo da rodada anterior é feito em segundo plano logo depois
         // dela; aqui só se espera ele terminar, para não sair com memória velha.
         //
@@ -1117,7 +1170,8 @@ async function enviarPedido(userText) {
                 permissoes: state.config.permissoes,
                 // Pedido de mexer no computador leva a dica que libera as
                 // ferramentas desktop_* no servidor (ver DICA_COMPUTADOR).
-                instrucao: i === 0 && querComputador(userText) ? vozModo.DICA_COMPUTADOR : '',
+                instrucao: [i === 0 && querComputador(userText) ? vozModo.DICA_COMPUTADOR : '',
+                    i === 0 ? require('../lib/estudio/referencias.js').instrucao() : ''].filter(Boolean).join('\n\n'),
             });
 
             r = await rodarPasso();
@@ -2569,6 +2623,13 @@ async function main() {
     if (process.argv[2] === 'video') {
         process.exit(await require('../lib/video/cli.js').main(process.argv.slice(3)));
     }
+    // `primocode mcp …`: os servidores MCP pelo run_shell (lib/mcp.js).
+    if (process.argv[2] === 'skill' || process.argv[2] === 'skills') {
+        process.exit(require('../lib/skills.js').main(process.argv.slice(3)));
+    }
+    if (process.argv[2] === 'mcp') {
+        process.exit(await require('../lib/mcp.js').main(process.argv.slice(3)));
+    }
     cfg.ensureStructure();
 
     // Padrão fixo: ~/primocode, não importa de onde o comando foi dado. Antes ele
@@ -2626,7 +2687,9 @@ async function main() {
            runAct próprio, e por isso ficava sem tudo o que vive lá: o plano em
            passos, a retomada automática, o @arquivo, o checkpoint do /desfazer. */
         state.semTerminal = true;
+        global.__primocodeTarefa = promptText.slice(0, 60);
         await sendPrompt(promptText);
+        global.__primocodeTarefa = null;
         process.exit(0);
     }
 
@@ -2641,6 +2704,9 @@ async function main() {
         comandos: comandosDoMenu,
         vazio: 'peça alguma coisa, ou / para os comandos',
     });
+    // O spinner desenha dentro da caixa (lib/entrada.js mostrarSpinner).
+    if (rl.tty) Spinner.caixa = rl;
+    ui.titulo('PrimoCode');
 
     rl.prompt();
 
@@ -2717,6 +2783,7 @@ async function main() {
         while (queue.length) {
             const text = queue.shift().trim();
             if (!text) continue;
+            ui.titulo(`⠋ PrimoCode — ${text}`);
             try {
                 if (ehBash(text)) await rodarBash(text);
                 else if (isSlash(text)) await handleSlash(text);
@@ -2740,6 +2807,7 @@ async function main() {
         busy = false;
         state.trabalhando = false;
         if (rl.trabalhando) rl.trabalhando(false);
+        ui.titulo('PrimoCode');
         // Se o stdin já fechou (pipe, Ctrl+D), a despedida espera a fila terminar
         // — senão ela aparece antes do resultado do último pedido.
         if (closed) sayBye();

package/lib/act.js

@@ -31,6 +31,7 @@ const preLeitura = require('./pre-leitura');
 // volta a mais não é volta em círculo — é trabalho. Quinze acabavam no meio
 // de um vídeo de dez cenas com pesquisa, e a pessoa lia "gastei as voltas".
 const MAX_ITERATIONS = Number(process.env.PRIMOCODE_MAX_VOLTAS || 40);
+const MAX_VOLTAS_AGENTE = Number(process.env.PRIMOCODE_MAX_VOLTAS_AGENTE || 20);
 // Quantas vezes o agente é EMPURRADO quando para no meio para narrar
 // ("agora vou criar o arquivo…") em vez de fazer. Ver `pareceParadaNoMeio`.
 const MAX_EMPURROES = 3;
@@ -39,6 +40,10 @@ const MAX_RODADAS_PARADAS = 3;
 const MAX_PROFUNDIDADE = 2; // principal + 1 nível de subagente
 // As leituras que, repetidas sem mudança no meio, devolvem o guardado.
 const RELEITURA = new Set(['read_file', 'list_dir']);
+/* O que só lê: pode rodar junto com as outras leituras da mesma rodada. */
+const SO_LEITURA = new Set(['read_file', 'list_dir', 'glob', 'grep', 'pesquisar_referencia', 'estudio_site']);
+const ehLeitura = (tc) => SO_LEITURA.has(tc.name)
+    || (tc.name === 'run_shell' && /^\s*primocode\s+(skill|mcp\s+list|video\s+(help|get_timeline|get_transcript))\b/.test(String((tc.arguments && tc.arguments.command) || '')));
 
 // ── Interrupção (Esc Esc) ─────────────────────────────────────────────────
 // O usuário aperta Esc duas vezes e o agente PARA — entre uma rodada e outra
@@ -526,7 +531,7 @@ const TROCA_DE_ROTA = 'Você ficou três voltas sem conseguir rodar nada, repeti
     + '(write_todos) e faça AGORA o primeiro passo, por um caminho diferente: outra ferramenta, outro arquivo, '
     + 'outro comando. Se não houver caminho, chame finish e diga em uma frase o que impediu.';
 
-function motivoDaParada({ voltas, voltasEmFalso, falhasPendentes, travou }) {
+function motivoDaParada({ voltas, voltasEmFalso, falhasPendentes, travou, teto = MAX_ITERATIONS }) {
     if (falhasPendentes.length) {
         return `Parei sem concluir. A última falha foi: ${falhasPendentes[falhasPendentes.length - 1].texto}`;
     }
@@ -534,11 +539,11 @@ function motivoDaParada({ voltas, voltasEmFalso, falhasPendentes, travou }) {
         return 'Fiquei preso: tentei dois caminhos e os dois voltaram ao mesmo lugar, então parei antes de gastar sua cota à toa. '
             + 'O que já fiz está salvo. Diga "continua" que eu retomo daqui.';
     }
-    if (voltas >= MAX_ITERATIONS) {
+    if (voltas >= teto) {
         const emFalso = voltasEmFalso
             ? ` ${voltasEmFalso} ${voltasEmFalso === 1 ? 'chamada foi repetida' : 'chamadas foram repetidas'} e não rodaram de novo.`
             : '';
-        return `Usei as ${MAX_ITERATIONS} voltas deste pedido sem chegar ao fim.${emFalso}`
+        return `Usei as ${teto} voltas deste pedido sem chegar ao fim.${emFalso}`
             + ' O que já fiz está salvo. Diga "continua" que eu retomo daqui.';
     }
     return 'Parei sem concluir e sem explicação do modelo. Diga "continua" que eu tento de novo daqui.';
@@ -632,7 +637,18 @@ const RITMO = '[ritmo]\n'
     + '- O resultado de write_file/edit_file é a verdade. Não releia um arquivo que você acabou de escrever para conferir (nem com cat/sed/head): a conferência é do PrimoCode.\n'
     + '- Várias ações independentes vão na MESMA resposta (ex.: escrever index.html, style.css e script.js juntos).\n'
     + '- Leia um arquivo inteiro uma vez, não em pedaços pequenos; não leia de novo o que não mudou.\n'
-    + '- Não narre o próximo passo: faça. Termine com finish("o que foi feito").';
+    + '- Não narre o próximo passo: faça. Termine com finish("o que foi feito").\n'
+    + '- VOCÊ DECIDE O CAMINHO. Pedido simples: faça direto. Pedido grande com partes independentes: write_todos com as partes, '
+    + 'depois spawn_agent — um por parte, até 8 NA MESMA resposta (rodam juntos), cada um com o especialista e tudo que ele precisa saber. '
+    + 'Cada um volta com uma ENTREGA: confira; o que falhou volta para conserto; a parte que depende de outra recebe a entrega dela no prompt.\n'
+    + '- Antes de dizer pronto, PROVE: rode o teste ou o comando, abra o resultado, olhe a imagem. Sem prova, não está pronto.';
+
+/* O ritmo do subagente: o mesmo, sem a parte de orquestrar (ele não abre outro agente). */
+const RITMO_AGENTE = '[ritmo]\n'
+    + '- O resultado de write_file/edit_file é a verdade. Não releia o que acabou de escrever.\n'
+    + '- Leia um arquivo INTEIRO uma vez (read_file sem offset). Não leia aos pedaços, não leia de novo o que não mudou.\n'
+    + '- Várias ações independentes na MESMA resposta.\n'
+    + '- Faça o que a sua parte pede, prove (teste ou comando) e chame finish. Polimento além do pedido não é sua parte.';
 
 /* `pedido` é opcional: com ele, o arquivo citado no pedido é o primeiro a
    entrar já lido (ver lib/pre-leitura.js). */
@@ -653,6 +669,11 @@ function buildMemoryContext(projectDir, projectName, pedido = '') {
     const lidos = preLeitura.bloco(preLeitura.escolher(projectDir, arquivos, pedido));
     if (lidos) parts.push(lidos);
     parts.push(RITMO);
+    // Os servidores MCP configurados, numa linha (lib/mcp.js).
+    try { const m = require('./mcp.js').dica(projectDir); if (m) parts.push(m); } catch { /* sem mcp */ }
+    // A equipe calada (lib/personas.js): o olhar do especialista que o pedido pede.
+    const equipe = require('./personas.js').bloco(pedido);
+    if (equipe) parts.push(equipe);
     return parts.join('\n\n');
 }
 
@@ -778,12 +799,9 @@ async function runAct(userPrompt, opts) {
      * não é uma opção num plano limitado por token. */
     let pedido = userPrompt;
     if (!subagent) {
-        const comSkills = skills.montar(userPrompt);
+        const comSkills = skills.cardapio(userPrompt);
         pedido = comSkills.texto;
         if (instrucao) pedido = `${instrucao}\n\nPEDIDO: ${pedido}`;
-        if (comSkills.skills.length) {
-            fala.pensamento(`seguindo: ${comSkills.skills.map((s) => s.titulo).join(', ')}`, profundidade);
-        }
     }
     let voltasEmFalso = 0;
     // Pesquisas que voltaram de mãos vazias. A partir da terceira, a tool
@@ -807,6 +825,9 @@ async function runAct(userPrompt, opts) {
         const memory = buildMemoryContext(projectDir, projectName, userPrompt);
         if (memory) messages.push({ role: 'system', content: `Memória persistente:\n\n${memory}` });
         for (const m of historicoEnxuto(history)) messages.push(m);
+    } else {
+        // O subagente também trabalha no ritmo: sem isto ele relia o mesmo arquivo aos pedaços.
+        messages.push({ role: 'system', content: RITMO_AGENTE });
     }
     /* O que VAI para o modelo é `pedido` (com as skills na frente); o que
        fica guardado na memória e no histórico é `userPrompt`, o que a pessoa
@@ -832,8 +853,14 @@ async function runAct(userPrompt, opts) {
         if (diretor.precisaDeEdicao(pedido)) {
             // A gravação da pessoa: o editor por linha do tempo (lib/video/), pelo run_shell.
             messages.push({ role: 'system', content: 'PARA EDITAR A GRAVAÇÃO DA PESSOA use o editor por linha do tempo via run_shell: '
+                + 'SE A PESSOA SÓ DISSE "edite esse vídeo" (sem dizer o quê), O VÍDEO É O PEDIDO: `primocode video import --json \'{"path":"<arquivo>"}\'`, '
+                + 'depois `primocode video auto --json \'{}\'` (lê o que ela FALA na gravação e aplica cada efeito no momento em que diz), inspect, export e abra o mp4. '
+                + 'Senão: '
                 + 'rode `primocode video help` UMA vez (lista as operações), depois import → remove_silence/remove_words → add_captions → inspect (olhe o png) → export. '
-                + 'Cada edição devolve um delta curto e tem undo: edite sem pedir licença a cada passo.' });
+                + 'Cada edição devolve um delta curto e tem undo: edite sem pedir licença a cada passo.\n'
+                + 'EFEITOS que seguem a pessoa: separate_layers (recorte + momento 3D), replace_background (fundo novo no estalo), '
+                + 'attach_3d (logo 3D na mão, segue a mão), merge_on_join (mãos juntas → fusão → cérebro), cut_silence_at (silêncio depois do estalo), '
+                + 'style_captions (cor, legenda em cima da cabeça) — detalhe em `primocode video help efeitos`. Atalho: `primocode video do --json \'{"pedido":"<o pedido em português>"}\'`.' });
         } else if (producao.producao) {
             /* "SE ESTIVER NA SUA LISTA" não é hesitação — é a diferença entre
                a tarefa seguir e a tarefa morrer.
@@ -854,8 +881,14 @@ async function runAct(userPrompt, opts) {
                com as primitivas" — o modelo escrevia posição em pixel e o
                vídeo saía quebrado, além de custar três ou quatro rodadas a
                mais de modelo (medido em 25/09). */
+            /* A IA DECIDE (01/10): "pedi um roteiro de vídeo e ela já ia fazer o
+               motion". A regra só sabe que a palavra "vídeo" apareceu; quem sabe
+               se a pessoa quer o vídeo PRONTO ou só o roteiro, a ideia ou uma
+               resposta é o modelo. Então isto é o caminho SE for produzir, e não
+               mais uma ordem de produzir. */
             messages.push({ role: 'system', content:
-                `ESTE PEDIDO É DE PRODUÇÃO (formato "${producao.formato === 'apresentacao' ? 'slides' : 'video'}"). Faça em três passos: `
+                'VOCÊ DECIDE o que entregar, pelo que a pessoa pediu: se ela quer só o roteiro, a ideia, um texto ou uma resposta, ESCREVA isso e pare — não produza vídeo. '
+                + `SE ela quer a peça pronta (formato "${producao.formato === 'apresentacao' ? 'slides' : 'video'}"), faça em três passos: `
                 + `estudio_projeto acao:"criar" com formato "${producao.formato === 'apresentacao' ? 'slides' : 'video'}" → `
                 + 'estudio_plano com "roteiro" (partes com tipo e fala; o PrimoCode faz layout, voz, ícones, música e sons) → '
                 + 'estudio_render. Se a peça for de uma marca de verdade, estudio_site antes, e use as cores e a logo em roteiro.marca. '
@@ -906,10 +939,22 @@ async function runAct(userPrompt, opts) {
     const MAX_ESPERAS_REDE = Number(process.env.PRIMOCODE_MAX_ESPERAS_REDE || 6);
 
     let voltas = 0;
+    const teto = subagent ? MAX_VOLTAS_AGENTE : MAX_ITERATIONS;
+    let avisouTeto = false;
     if (!subagent) TRABALHANDO = true;
     try {
-    for (let iteration = 0; iteration < MAX_ITERATIONS && !PARAR; iteration++) {
+    /* O AGENTE TEM TETO PRÓPRIO. No teste da loja (01/10) o "fechar
+       pendências do painel" passou de 38 voltas lendo o mesmo app.js aos
+       pedaços — a conversa dele inchou para 45 mil caracteres e uma resposta
+       levou 22 minutos. Uma parte de um plano cabe em 20 voltas; na 15ª ele
+       é avisado para fechar, e no teto volta com a entrega do que fez. */
+    for (let iteration = 0; iteration < teto && !PARAR; iteration++) {
         voltas++;
+        if (subagent && !avisouTeto && voltas >= teto - 5) {
+            avisouTeto = true;
+            messages.push({ role: 'user', content: `Faltam ${teto - voltas + 1} voltas para o seu limite. Feche o essencial do que foi pedido agora, `
+                + 'prove (rode o teste ou o comando) e chame finish dizendo o que ficou de fora. Nada de polimento extra.' });
+        }
         // 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);
@@ -1178,13 +1223,13 @@ async function runAct(userPrompt, opts) {
         // fila — cada subagente só começava quando o anterior terminava, e a
         // rodada custava a soma dos três. Agora as chamadas spawn_agent da
         // rodada disparam de uma vez (Promise.all) e cada resultado volta na
-        // posição certa da conversa. Limite de 4 por rodada: acima disso é
-        // sinal de decomposição ruim, e o excedente roda em série mesmo.
+        // posição certa da conversa. Limite de 8 por rodada (era 4: o laço do
+        // Qwen despacha várias direções de uma vez); o excedente roda em série.
         const spawns = toolCalls.filter((tc) => tc.name === 'spawn_agent');
         const resultadosSpawn = new Map();
         if (spawns.length && !PARAR) garantirPasta();
         if (spawns.length > 1 && !PARAR) {
-            const juntos = spawns.slice(0, 4);
+            const juntos = spawns.slice(0, 8);
             fala.paralelo(juntos.length, profundidade);
             const rs = await Promise.all(juntos.map((tc) =>
                 runSubagent(tc.arguments || {}, {
@@ -1193,6 +1238,22 @@ async function runAct(userPrompt, opts) {
             juntos.forEach((tc, i) => resultadosSpawn.set(tc.id, rs[i]));
         }
 
+        /* LEITURAS JUNTAS. O RITMO pede ao modelo para juntar as ações
+           independentes numa resposta só — e ele junta: três read_file, um
+           grep e uma pesquisa. Só que o laço abaixo rodava uma de cada vez, e
+           a rodada custava a soma. O que só LÊ (não muda arquivo, tela nem
+           conta) roda tudo de uma vez aqui; o laço usa o resultado pronto,
+           passando pelos mesmos freios de sempre (repetição, registro). */
+        const adiantadas = new Map();
+        const leituras = toolCalls.filter(ehLeitura);
+        if (leituras.length > 1 && !PARAR) {
+            const rs = await Promise.all(leituras.slice(0, 8).map((tc) =>
+                tools.execute(tc.name, tc.arguments, { projectDir: pastaAtual, server, token, api })
+                    .catch((e) => ({ ok: false, error: e && e.message }))));
+            leituras.slice(0, 8).forEach((tc, i) => adiantadas.set(tc.id, rs[i]));
+            traco(`${adiantadas.size} leituras em paralelo`);
+        }
+
         for (const tc of toolCalls) {
             if (PARAR) break;
             if (tc.name === 'finish') {
@@ -1234,7 +1295,7 @@ async function runAct(userPrompt, opts) {
                         server, model, token, projectDir: pastaAtual, projectName, profundidade, motor, permissoes,
                     });
                 repeticao.executou(jaChamado, tc.name, tc.arguments);
-                messages.push({ role: 'tool', tool_call_id: tc.id, content: r });
+                messages.push({ role: 'tool', tool_call_id: tc.id, content: r + lembreteDeParalelo(todosDaTarefa, spawns.length) });
                 continue;
             }
 
@@ -1383,7 +1444,10 @@ async function runAct(userPrompt, opts) {
             /* O servidor, o token e o cliente da API vão junto: a legenda do
                estudio_video transcreve no servidor, e sem eles a ferramenta
                respondia "a transcrição precisa do servidor". */
-            const result = await tools.execute(tc.name, tc.arguments, { projectDir: pastaAtual, server, token, api });
+            traco(`executando ${tc.name}`);
+            const result = adiantadas.has(tc.id) ? adiantadas.get(tc.id)
+                : await tools.execute(tc.name, tc.arguments, { projectDir: pastaAtual, server, token, api });
+            traco(`${tc.name} devolveu ok=${result && result.ok}`);
             logResult(tc.name, result, profundidade);
             repeticao.executou(jaChamado, tc.name, tc.arguments);
             if (RELEITURA.has(tc.name) && result && result.ok !== false) {
@@ -1511,7 +1575,7 @@ async function runAct(userPrompt, opts) {
     // não dá nem para saber que acabou. Medido: um pedido de navegador morria assim
     // depois de a primeira tentativa de seletor falhar.
     if (!finalText) {
-        finalText = motivoDaParada({ voltas, voltasEmFalso, falhasPendentes, travou: rodadasParadas >= MAX_RODADAS_PARADAS });
+        finalText = motivoDaParada({ voltas, voltasEmFalso, falhasPendentes, travou: rodadasParadas >= MAX_RODADAS_PARADAS, teto });
         if (!subagent) fala.aviso(finalText);
     }
 
@@ -1589,7 +1653,42 @@ async function runSubagent(args, ctx) {
 
     const resumo = r.assistantMessage.content || 'sem resultado';
     fala.agenteVoltou(resumo, profundidade);
-    return resumo;
+    return entregaDoAgente(especialistas.rotulo(esp), resumo, r.registro);
+}
+
+/* UM AGENTE DE CADA VEZ é o padrão do modelo grátis: no teste da loja
+   (API + site + painel, 01/10) ele despachou os três em fila — 6 + 8 + 5
+   minutos — quando o site e o painel só dependiam do contrato, que já
+   existia. Quem decide continua sendo ele; a volta só lembra que as partes
+   que faltam podem ir JUNTAS. Pura. */
+function lembreteDeParalelo(todos, naRodada) {
+    const faltam = (todos || []).filter((t) => t && t.status !== 'completed' && t.status !== 'concluida');
+    if (naRodada > 1 || faltam.length < 2) return '';
+    return `\n\n(Faltam ${faltam.length} partes do plano. As que não dependem uma da outra vão JUNTAS: `
+        + 'vários spawn_agent na MESMA resposta rodam em paralelo.)';
+}
+
+/* O SALTO ENTRE AGENTES. O pai recebia só o texto final do especialista —
+   "pronto, fiz a API" — e, para passar a vez ao próximo (o do front, o
+   revisor), tinha de adivinhar o que existia. Agora a volta é uma ENTREGA:
+   quem fez, o que disse, os arquivos que nasceram e mudaram, os comandos, o
+   que falhou. É o contexto que o próximo especialista precisa no prompt
+   dele, e é o que deixa o pai mandar a falha de volta para conserto (o laço
+   do Qwen: planeja → despacha → confere → conserta). Pura, para o teste. */
+function entregaDoAgente(quem, texto, reg) {
+    const linhas = [`ENTREGA DO ${String(quem).toUpperCase()}`, String(texto).trim().slice(0, 4000)];
+    if (reg) {
+        const lista = (nome, xs) => { if (xs && xs.length) linhas.push(`${nome}: ${xs.slice(0, 15).join(', ')}`); };
+        lista('criou', reg.criados);
+        lista('alterou', reg.alterados);
+        lista('rodou', (reg.comandos || []).map((x) => `${x.comando}${x.ok === false ? ` (saiu ${x.code})` : ''}`));
+        lista('testes', (reg.testes || []).map((x) => `${x.comando}: ${x.ok ? 'passou' : 'FALHOU'}`));
+        if (reg.falhas && reg.falhas.length) linhas.push('FALHOU: ' + reg.falhas.slice(0, 6).map((f) => `${f.acao} ${f.alvo}: ${f.motivo}`.slice(0, 200)).join(' | '));
+    }
+    linhas.push(reg && ((reg.falhas && reg.falhas.length) || (reg.testes || []).some((x) => !x.ok))
+        ? 'PRÓXIMO: há falha acima — mande de volta para conserto (spawn_agent com o erro no prompt) ou conserte você, antes de seguir.'
+        : 'PRÓXIMO: se outra parte depende desta, passe a vez (spawn_agent) com esta entrega no prompt; senão, confira e siga.');
+    return linhas.join('\n');
 }
 
 /* ══ O PIPELINE DE QUATRO PAPÉIS ═══════════════════════════════════════════
@@ -1702,5 +1801,5 @@ async function rodarPipeline(args, ctx) {
     });
 }
 
-module.exports = { runAct, buildMemoryContext, leituraPeloShell, historicoEnxuto, interromper, mandarDuranteATarefa, trabalhando, sobrasDaCaixa, entregarRecados, compactar, motivoDaParada, pareceParadaNoMeio, ehTetoDeToken, ehTransitorio, esperaDoErro,
+module.exports = { runAct, entregaDoAgente, lembreteDeParalelo, buildMemoryContext, leituraPeloShell, historicoEnxuto, interromper, mandarDuranteATarefa, trabalhando, sobrasDaCaixa, entregarRecados, compactar, motivoDaParada, pareceParadaNoMeio, ehTetoDeToken, ehTransitorio, esperaDoErro,
     anotacaoDoQueJaFoi, encolherParaContinuar, MAX_ITERATIONS };

package/lib/browser.js

@@ -23,9 +23,36 @@ const http = require('http');
 const crypto = require('crypto');
 const { spawn, execSync } = require('child_process');
 
-const PROFILE_DIR = path.join(os.homedir(), '.primocode', 'chrome-profile');
+const PERFIL_VISIVEL = path.join(os.homedir(), '.primocode', 'chrome-profile');
 // Dentro da faixa 3100-3199 do ambiente local, para o start.sh cuidar dela.
-const DEBUG_PORT = Number(process.env.PRIMOCODE_CDP_PORT || 3199);
+const PORTA_VISIVEL = Number(process.env.PRIMOCODE_CDP_PORT || 3199);
+
+/* ── VISÍVEL SÓ QUANDO A PESSOA PEDIU ────────────────────────────────────
+ *   "toda vez que eu mando alguma coisa pra ele ele abre umas 10.000 abas
+ *    do Chrome — ele nem usa — e eu fecho e ele abre de novo" (Joel, 02/10)
+ * As ferramentas browser_* vão para o modelo em todo pedido, e ele as usa
+ * para PESQUISAR (o motion da Paris Group subiu o Chrome às 09:41 sem
+ * ninguém pedir navegador). Agora o terminal diz, por pedido, se a pessoa
+ * quer ver (definirVisivel): sem pedido de navegador, as mesmas ferramentas
+ * rodam num Chrome --headless de perfil e porta próprios, que nunca abre
+ * janela nem aba na tela — e morre com o processo. */
+const PERFIL_ESCONDIDO = path.join(os.homedir(), '.primocode', 'chrome-escondido');
+const PORTA_ESCONDIDA = Number(process.env.PRIMOCODE_CDP_PORT_ESCONDIDO || 3197);
+let visivel = true;
+let DEBUG_PORT = PORTA_VISIVEL;
+let PROFILE_DIR = PERFIL_VISIVEL;
+
+function definirVisivel(sim) {
+    const quer = sim !== false;
+    if (quer === visivel) return visivel;
+    visivel = quer;
+    DEBUG_PORT = quer ? PORTA_VISIVEL : PORTA_ESCONDIDA;
+    PROFILE_DIR = quer ? PERFIL_VISIVEL : PERFIL_ESCONDIDO;
+    // A sessão aberta é do outro navegador: a próxima ação conecta no certo.
+    if (currentSession) { try { currentSession.close(); } catch { /* já fechou */ } currentSession = null; }
+    return visivel;
+}
+function estaVisivel() { return visivel; }
 
 // ---- Helpers ---------------------------------------------------
 /* O Chromium que o Playwright baixa. Ele não fica no PATH nem em /Applications
@@ -414,12 +441,20 @@ async function ensureChromeRunning() {
         args.push('--no-sandbox');
     }
     // Sem interface gráfica (CI, servidor): PRIMOCODE_BROWSER_HEADLESS=1.
-    if (process.env.PRIMOCODE_BROWSER_HEADLESS === '1' || process.env.PRIMOCODE_BROWSER_HEADLESS === 'true') {
-        args.push('--headless=new', '--disable-gpu', '--disable-dev-shm-usage');
+    // E sempre que a pessoa não pediu para ver (definirVisivel).
+    const escondido = !visivel;
+    if (escondido || process.env.PRIMOCODE_BROWSER_HEADLESS === '1' || process.env.PRIMOCODE_BROWSER_HEADLESS === 'true') {
+        args.push('--headless=new', '--disable-gpu', '--disable-dev-shm-usage', '--mute-audio');
     }
     args.push('about:blank');
     chromeChild = spawn(chrome, args, { detached: true, stdio: 'ignore' });
     chromeChild.on('error', () => {});
+    /* O escondido morre com o processo: ninguém o vê para fechar, e um
+       headless órfão por sessão era o que o revisor deixava em 24/09. */
+    if (escondido) {
+        const filho = chromeChild;
+        process.once('exit', () => { try { process.kill(-filho.pid); } catch { try { filho.kill(); } catch { /* já morreu */ } } });
+    }
     chromeChild.unref();
 
     // Espera a porta responder
@@ -492,6 +527,55 @@ async function open(url) {
     return { ok: true, url };
 }
 
+/* ── ABRIR À VISTA ────────────────────────────────────────────────────────
+ *   "Peço pra ele abrir o Chrome e o YouTube: em vez de só abrir, ele mostra
+ *    o mouse dele abrindo o Chrome, pesquisando…" (30/09)
+ * O cursor do PrimoCode (voz/primo_voz/cursor.py, macOS) vai até a barra de
+ * endereço da janela de verdade, clica, digita o endereço letra por letra e
+ * aperta Enter — quem olha vê o computador sendo usado. A janela vem do CDP
+ * (Browser.getWindowForTarget), então o clique cai na barra mesmo com a
+ * janela em qualquer lugar da tela. Sem cursor (outro SO, sem permissão),
+ * navega direto, como antes. */
+async function abrirVisivel(url) {
+    // Escondido não tem janela para o cursor ir: navega direto.
+    if (!visivel) return open(url);
+    await ensure();
+    const cursor = require('./cursor.js');
+    if (!verSeta() || !cursor.disponivel()) return open(url);
+    try { await currentSession.send('Page.bringToFront'); } catch { /* segue */ }
+    let janela = null;
+    try {
+        const alvo = await currentSession.send('Target.getTargetInfo');
+        const w = await currentSession.send('Browser.getWindowForTarget', alvo && alvo.targetInfo ? { targetId: alvo.targetInfo.targetId } : {});
+        janela = w && w.bounds;
+    } catch { janela = null; }
+    if (!janela || janela.left == null) return open(url);
+    // A barra fica uns 58 pt abaixo do topo da janela (abas + barra), a ~30% da largura.
+    const x = Math.round(janela.left + Math.min(420, janela.width * 0.3));
+    const y = Math.round(janela.top + 58);
+    const passos = [
+        ['clicar', { x, y, botao: 'esquerdo', rotulo: 'barra de endereço' }],
+        ['tecla', { combo: 'cmd+a' }],
+        ['digitar', { texto: url.replace(/^https?:\/\//, ''), rotulo: 'digitando o endereço' }],
+        ['tecla', { combo: 'enter' }],
+    ];
+    for (const [cmd, args] of passos) {
+        const r = await cursor.mandar(cmd, args);
+        if (!r || r.ok === false) return open(url);      // sem permissão de Acessibilidade: navega direto
+    }
+    const deadline = Date.now() + 20000;
+    await sleep(600);
+    while (Date.now() < deadline) {
+        try {
+            const r = await currentSession.send('Runtime.evaluate', { expression: 'document.readyState + "|" + location.href', returnByValue: true });
+            const [estado, href] = String((r.result && r.result.value) || '').split('|');
+            if (estado === 'complete' && href && href !== 'about:blank') return { ok: true, url: href, visivel: true };
+        } catch { /* a página está trocando */ }
+        await sleep(200);
+    }
+    return { ok: true, url, visivel: true };
+}
+
 async function evaluate(js) {
     await ensure();
     const r = await currentSession.send('Runtime.evaluate', {
@@ -1207,7 +1291,7 @@ function fecharRevisor() {
 }
 
 module.exports = {
-    retrato,
+    retrato, abrirVisivel, definirVisivel, estaVisivel,
     SEM_KEYCHAIN,
     scriptDaSeta, verSeta, findChrome,
     open, click, clickText, clickSelector, type, typeInSelector,

package/lib/catalogo.js

@@ -89,7 +89,7 @@ const GRUPOS = [
                 + 'Tipos: abertura{titulo,sub} titulo{titulo,sub} numero{valor,rotulo,sub} lista{titulo,itens} passos{titulo,itens} '
                 + 'contraste{nao,sim} citacao{texto,autor} imagem{busca,titulo,sub} grafico{titulo,barras:[{rotulo,valor}]} cta{titulo,link} '
                 + 'logo{titulo} cores{cores:[{nome,hex}]} produto{titulo,texto,destaque,selo,barras}. Em qualquer parte: destaque (a palavra-tese), fonte (a fonte citada). '
-                + 'estilo: motion (padrão, 3D contínuo) | vox (explainer editorial: tinta sobre papel, câmera que conta a frase) | '
+                + 'estilo: hibrido (PADRÃO: foto e vídeo reais que não param + o motion por cima; dê busca:"termo em inglês" por parte para o b-roll) | gerativo (= motion: sem template — a tipografia anima nos eixos da fonte numa linha do tempo contínua, composição, fonte, cor e som sorteados do roteiro; é o do modo sem referências e o de quem pede motion/animação; com modelo3d o produto 3D entra numa batida) | classico (o motion 3D antigo) | vox (explainer editorial: tinta sobre papel, câmera que conta a frase) | '
                 + 'marca (brand reveal: brilho, letras em vetor, marca cromada, padrão) | lancamento (produto: cartões, painel, calendário) | impacto | cinema. '
                 + 'marca e lancamento aceitam visual:orbe|vetor|estrela|esfera|grade|site|padrao|cromo|cartoes|painel|cores numa parte. marca.nome dá o nome. '
                 + 'voz (thalita|antonio|francisca). Ajuste fino: plano: {formato:{largura,altura,fps}, cenas:[…], audio:{…}} — ou cenas direto. '

package/lib/claude-engine.js

@@ -575,6 +575,40 @@ function promptDoProtocolo(payload) {
         + '\n\nResponda com exatamente UM bloco marcado.';
 }
 
+/* O `claude -p` ASSÍNCRONO. Era execFileSync: enquanto o Claude pensava (um
+   minuto, dois), o PrimoCode inteiro parava — sem spinner, sem recado, sem
+   Esc Esc. E o teto de 180 s estourava justo quando ele escrevia um arquivo
+   grande, e o erro saía cru na tela ("Command failed: claude -p …"). Agora
+   roda em paralelo, com 10 min de teto, uma segunda tentativa, e o erro
+   diz o que o Claude disse. */
+function rodarClaude(args, input, { timeout = 600000, tentativas = 2 } = {}) {
+    const { spawn } = require('child_process');
+    const umaVez = () => new Promise((resolve, reject) => {
+        const p = spawn('claude', args, { env: process.env, stdio: ['pipe', 'pipe', 'pipe'], ...(SEM_APARECER.windowsHide ? { windowsHide: true } : {}) });
+        let out = '', err = '';
+        const relogio = setTimeout(() => { try { p.kill(); } catch {} reject(new Error(`o Claude Code não respondeu em ${Math.round(timeout / 60000)} min`)); }, timeout);
+        p.stdout.on('data', (d) => { out += d; });
+        p.stderr.on('data', (d) => { err += d; });
+        p.on('error', (e) => { clearTimeout(relogio); reject(e); });
+        p.on('close', (code) => {
+            clearTimeout(relogio);
+            if (code === 0) return resolve(out);
+            // O JSON às vezes vem com is_error e o motivo, mesmo com código != 0.
+            let motivo = '';
+            try { const j = JSON.parse(out); motivo = j.result || j.error || ''; } catch { /* sem json */ }
+            reject(new Error(`o Claude Code saiu com ${code}: ${String(motivo || err || out).replace(/\s+/g, ' ').trim().slice(0, 300)}`));
+        });
+        p.stdin.end(input);
+    });
+    return (async () => {
+        let ultimo;
+        for (let i = 0; i < tentativas; i++) {
+            try { return await umaVez(); } catch (e) { ultimo = e; }
+        }
+        throw ultimo;
+    })();
+}
+
 async function requestActViaHeadless(payload, onEvent) {
     const corpoBootstrap = corpoDoProtocolo();
     const prompt = promptDoProtocolo(payload);
@@ -585,27 +619,14 @@ async function requestActViaHeadless(payload, onEvent) {
     // O prompt vai por STDIN, nunca por argumento: argumento tem limite de
     // tamanho (a conversa cresce) e qualquer conteúdo começando com traço
     // seria lido como opção. stdin não tem nenhum dos dois problemas.
-    const saida = execFileSync('claude', [
-        '-p',
-        '--output-format', 'json',
-        '--dangerously-skip-permissions',
-        ...argsDoMotor(),
-    ], { encoding: 'utf-8', timeout: 180000, input: prompt, maxBuffer: 32 * 1024 * 1024,
-        env: process.env, ...SEM_APARECER });
+    const saida = await rodarClaude(['-p', '--output-format', 'json', '--dangerously-skip-permissions', ...argsDoMotor()], prompt);
     const r = JSON.parse(saida);
     // A correção é uma segunda ida ao motor, com o mesmo protocolo e o
     // diagnóstico do que saiu errado. Barata: o prompt é curto, e evita que
     // um erro de sintaxe do motor vire erro na cara do usuário.
-    const pedirCorrecao = (aviso) => {
-        const s = execFileSync('claude', [
-            '-p', '--output-format', 'json', '--dangerously-skip-permissions',
-            ...argsDoMotor(),
-        ], {
-            encoding: 'utf-8', timeout: 120000, maxBuffer: 32 * 1024 * 1024,
-            env: process.env,
-            input: promptDeCorrecao(aviso),
-            ...SEM_APARECER,
-        });
+    const pedirCorrecao = async (aviso) => {
+        const s = await rodarClaude(['-p', '--output-format', 'json', '--dangerously-skip-permissions', ...argsDoMotor()],
+            promptDeCorrecao(aviso), { timeout: 300000, tentativas: 1 });
         return JSON.parse(s).result || '';
     };
     await emitirDecisao(r.result || '', onEvent, pedirCorrecao, 0, nomesDasTools(payload));