primocode 8.35.0 → 8.37.0

package/lib/pipeline.js

@@ -0,0 +1,447 @@
+/**
+ * pipeline.js — os quatro papéis que constroem um app.
+ *
+ *   "1. Engenheiro de Prompt: recebe o prompt simples do usuário e monta um
+ *    prompt completo e detalhado. 2. Construtor 1: cria um protótipo. 3.
+ *    Construtor 2: transforma o protótipo em um MVP. 4. Revisador: testa o
+ *    código ocultamente, identifica erros e reporta ao Construtor 2. 5. Loop
+ *    de correção. 6. Entrega final: abre automaticamente no navegador."
+ *
+ * ── POR QUE UMA PEÇA E NÃO UM CONSELHO NO PROMPT ─────────────────────────
+ * Dá para escrever tudo isso na instrução do agente e torcer. Não funciona, e
+ * o motivo é medível: o modelo que acabou de escrever o código é o pior
+ * revisor dele — ele "lê" o que quis escrever, não o que escreveu, e aprova.
+ * O que separa os papéis aqui é que cada um roda numa CONVERSA PRÓPRIA, sem
+ * ver a do anterior: o revisor recebe o pedido e os arquivos, e mais nada.
+ *
+ * ── O REVISOR TEM DUAS METADES, E A PRIMEIRA NÃO É UM MODELO ─────────────
+ * Perguntar a um modelo "esse código funciona?" devolve opinião. O que decide
+ * é ABRIR a página e olhar: um Chrome invisível carrega o resultado e conta o
+ * que o navegador reclamou e o que sobrou na tela. Esse relatório é FATO, e é
+ * ele que o revisor lê antes de dizer qualquer coisa. Sem essa metade, o
+ * defeito clássico passa inteiro — a página abre, responde 200, tem título, e
+ * está em branco por causa de um TypeError na primeira linha.
+ *
+ * ── O QUE ESTA PEÇA NÃO FAZ ──────────────────────────────────────────────
+ * Ela não é o caminho normal. São de seis a oito chamadas de agente, e usá-la
+ * para "muda a cor do botão" gasta o dia da pessoa para fazer o que uma edição
+ * resolve. Quem decide chamá-la é o agente, e o catálogo diz quando.
+ */
+
+'use strict';
+
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+const http = require('http');
+
+const browser = require('./browser.js');
+
+const TIPOS = {
+    '.html': 'text/html; charset=utf-8',
+    '.htm': 'text/html; charset=utf-8',
+    '.css': 'text/css; charset=utf-8',
+    '.js': 'text/javascript; charset=utf-8',
+    '.mjs': 'text/javascript; charset=utf-8',
+    '.json': 'application/json; charset=utf-8',
+    '.svg': 'image/svg+xml',
+    '.png': 'image/png',
+    '.jpg': 'image/jpeg',
+    '.jpeg': 'image/jpeg',
+    '.gif': 'image/gif',
+    '.webp': 'image/webp',
+    '.ico': 'image/x-icon',
+    '.woff': 'font/woff',
+    '.woff2': 'font/woff2',
+    '.mp3': 'audio/mpeg',
+    '.mp4': 'video/mp4',
+    '.txt': 'text/plain; charset=utf-8',
+};
+
+/**
+ * Serve a pasta em 127.0.0.1, numa porta que o sistema escolhe.
+ *
+ * Por que servir em vez de abrir `file://`: em `file://` o navegador recusa
+ * `fetch`, módulos ES e a maior parte do que uma página moderna faz. O revisor
+ * encheria o relatório de erros de CORS que não existem quando a pessoa
+ * publicar — e erro inventado é pior que erro nenhum, porque manda o
+ * construtor consertar o que não está quebrado.
+ */
+function servirPasta(dir) {
+    const raiz = path.resolve(dir);
+    const srv = http.createServer((req, res) => {
+        let alvo;
+        try {
+            const caminho = decodeURIComponent((req.url || '/').split('?')[0]);
+            alvo = path.resolve(raiz, '.' + caminho);
+        } catch { alvo = raiz; }
+        // Ninguém sai da pasta. O conteúdo daqui foi escrito por um modelo, e
+        // um `../../.ssh/id_rsa` num src não pode virar leitura de disco.
+        if (alvo !== raiz && !alvo.startsWith(raiz + path.sep)) {
+            res.statusCode = 403; return res.end('fora da pasta');
+        }
+        try {
+            if (fs.existsSync(alvo) && fs.statSync(alvo).isDirectory()) {
+                alvo = path.join(alvo, 'index.html');
+            }
+            if (!fs.existsSync(alvo)) { res.statusCode = 404; return res.end('não achei'); }
+            res.setHeader('Content-Type', TIPOS[path.extname(alvo).toLowerCase()] || 'application/octet-stream');
+            res.setHeader('Cache-Control', 'no-store');
+            return res.end(fs.readFileSync(alvo));
+        } catch (e) {
+            res.statusCode = 500;
+            return res.end(String((e && e.message) || 'erro'));
+        }
+    });
+    return new Promise((ok) => {
+        srv.listen(0, '127.0.0.1', () => {
+            ok({
+                url: `http://127.0.0.1:${srv.address().port}/`,
+                fechar: () => { try { srv.close(); } catch { /* já fechou */ } },
+            });
+        });
+    });
+}
+
+/** A página que se abre primeiro. `index.html` manda; senão, o único .html. */
+function acharEntrada(dir) {
+    try {
+        if (fs.existsSync(path.join(dir, 'index.html'))) return 'index.html';
+        const htmls = fs.readdirSync(dir).filter((f) => /\.html?$/i.test(f));
+        if (htmls.length === 1) return htmls[0];
+        // Com vários .html e sem index, escolher um seria adivinhar qual é a
+        // home — e revisar a página errada aprova o que ninguém vai abrir. Sem
+        // nenhum, também não há o que abrir. Os dois casos são "não sei", e o
+        // relatório do revisor diz isso em vez de fingir que testou.
+        return null;
+    } catch { return null; }
+}
+
+/** Todos os arquivos da pasta, para o revisor saber o que existe. */
+function listar(dir, base = dir, fundo = 0) {
+    if (fundo > 3) return [];
+    let saida = [];
+    let itens = [];
+    try { itens = fs.readdirSync(dir, { withFileTypes: true }); } catch { return []; }
+    for (const it of itens) {
+        if (it.name === 'node_modules' || it.name.startsWith('.')) continue;
+        const cheio = path.join(dir, it.name);
+        if (it.isDirectory()) saida = saida.concat(listar(cheio, base, fundo + 1));
+        else saida.push(path.relative(base, cheio));
+        if (saida.length > 80) break;
+    }
+    return saida;
+}
+
+/**
+ * A metade mecânica do revisor: abre a página escondido e conta o que quebrou.
+ *
+ * Devolve SEMPRE um texto para outro modelo ler — inclusive quando não deu
+ * para abrir. "Não consegui testar" é uma informação; silêncio vira aprovação.
+ */
+async function medirNoNavegador(dir) {
+    const entrada = acharEntrada(dir);
+    if (!entrada) {
+        return { testou: false, limpo: false,
+            relato: 'Não há uma página de entrada clara na pasta (nenhum index.html, ou vários .html '
+                + 'sem um index). Não deu para abrir e testar. Se este projeto é uma página, crie '
+                + 'index.html; se não é, o teste no navegador não se aplica.' };
+    }
+    /* Daqui para baixo existe página, então o que sair do navegador é medida de
+       verdade — e é só medida de verdade que pode vetar um "APROVADO". */
+
+    let servidor = null;
+    try {
+        servidor = await servirPasta(dir);
+        const r = await browser.inspecionarEscondido(servidor.url + entrada);
+        const linhas = [];
+        linhas.push(`Abri ${entrada} num navegador invisível.`);
+        linhas.push(`Título: ${r.titulo || '(sem <title>)'}`);
+        linhas.push(`Elementos visíveis na tela: ${r.visiveis}`);
+        if (r.vazio) {
+            linhas.push('A PÁGINA ABRIU EM BRANCO. Quem abrir isso vê uma tela vazia — '
+                + 'é o pior desfecho possível, porque não parece erro, parece produto quebrado.');
+        }
+        if (r.erros.length) {
+            linhas.push(`O navegador reclamou de ${r.erros.length} coisa(s):`);
+            r.erros.forEach((e) => linhas.push(`  · [${e.tipo}] ${e.texto}`));
+        } else {
+            linhas.push('Nenhum erro de JavaScript, de console ou de recurso.');
+        }
+        if (r.texto) linhas.push(`Texto que apareceu: ${JSON.stringify(r.texto.slice(0, 300))}`);
+        return { testou: true, limpo: !r.vazio && r.erros.length === 0, relato: linhas.join('\n'), medida: r };
+    } catch (e) {
+        return { testou: false, limpo: false,
+            relato: `Não consegui abrir a página para testar: ${(e && e.message) || e}. `
+                + 'Siga sem o teste automático, mas NÃO diga que está testado.' };
+    } finally {
+        if (servidor) servidor.fechar();
+    }
+}
+
+// ── os papéis ────────────────────────────────────────────────────────────
+
+const ENGENHEIRO = (pedido) => `Você é o ENGENHEIRO DE PROMPT.
+
+O usuário pediu isto, com as palavras dele:
+
+"""
+${pedido}
+"""
+
+Sua tarefa é transformar esse pedido numa ESPECIFICAÇÃO que outro programador
+consiga seguir sem perguntar nada. Você NÃO escreve código e NÃO cria arquivo
+nenhum — se você criar arquivo, atrapalha quem vem depois.
+
+Escreva, em português, e nesta ordem:
+
+1. O QUE É, em uma frase.
+2. QUEM USA e o que essa pessoa quer fazer na tela.
+3. AS TELAS ou seções, uma a uma, com o que tem em cada uma.
+4. O QUE PRECISA FUNCIONAR — as ações de verdade, com o que acontece em cada
+   uma, inclusive quando dá errado (campo vazio, sem dados, sem conexão).
+5. OS DADOS: o que se guarda, onde (localStorage, memória, arquivo) e o
+   formato.
+6. O VISUAL: paleta com valores, tipografia, densidade. Escolha de verdade —
+   "moderno e bonito" não é instrução.
+7. O QUE FICA DE FORA desta versão.
+
+Duas regras que valem mais que o resto:
+
+· NÃO INVENTE ESCOPO. Se pediram uma calculadora, é uma calculadora — não uma
+  calculadora com contas de usuário e histórico na nuvem. Acrescente só o que
+  torna o que foi pedido utilizável de verdade.
+· SEJA CONCRETO. Números, textos dos botões, nomes dos campos, mensagens de
+  erro escritas. Quem lê a sua especificação não vai perguntar o que você quis
+  dizer: vai chutar.
+
+Responda com a especificação e mais nada.`;
+
+const CONSTRUTOR_1 = (spec, pasta) => `Você é o CONSTRUTOR 1, e o seu trabalho é
+o PROTÓTIPO que FUNCIONA.
+
+Construa na pasta: ${pasta}
+
+Especificação:
+
+"""
+${spec}
+"""
+
+Regras:
+
+· SE o que foi pedido se abre no navegador (site, página, app, jogo,
+  ferramenta com tela), a entrada é ${'`index.html`'} na raiz dessa pasta, e sem ela
+  ninguém abre o que você fez. Se o que foi pedido roda no terminal, escreva o
+  programa e um ${'`LEIA.md`'} de cinco linhas dizendo como rodar — e não invente uma
+  página para ele.
+· Sem instalar nada. Sem npm, sem build, sem framework baixado — o que roda
+  abrindo o arquivo (ou com um ${'`node arquivo.js`'}). Se precisar de biblioteca,
+  escreva a parte que você usa.
+· Faça FUNCIONAR antes de ficar bonito: o caminho principal inteiro, de ponta a
+  ponta, com dados de exemplo já na tela. Uma tela vazia esperando alguém
+  digitar não mostra nada.
+· Não deixe função pela metade nem "TODO". O que não der para fazer, não
+  prometa na tela.
+
+Escreva os arquivos e diga em uma linha o que ficou pronto.`;
+
+const CONSTRUTOR_2 = (spec, pasta, relato) => `Você é o CONSTRUTOR 2, e o seu
+trabalho é virar o protótipo em PRODUTO.
+
+A pasta é: ${pasta}
+LEIA os arquivos que já estão lá antes de mexer. Não recomece do zero: o que
+está funcionando fica.
+
+Especificação:
+
+"""
+${spec}
+"""
+
+${relato ? `O revisor testou o que existe e achou isto:\n\n"""\n${relato}\n"""\n\n` : ''}\
+O que você faz:
+
+· CONSERTA o que o revisor apontou. Isso vem primeiro; nada de recurso novo com
+  erro aberto.
+· COMPLETA o que a especificação pede e o protótipo não faz.
+· REDESENHA: hierarquia de tamanhos, espaço para respirar, estados de foco e de
+  toque, e o que aparece quando não há dados. Escolha uma paleta e mantenha.
+· CUIDA DO ERRO: campo vazio, valor impossível, lista vazia. Cada um com uma
+  mensagem que diz o que fazer, não "erro".
+· RESPONSIVO de verdade: nada de rolagem horizontal em 390px de largura.
+
+As três últimas valem para o que TEM TELA. Se isto roda no terminal, o
+equivalente é: mensagem de uso quando faltar argumento, saída legível, e código
+de saída diferente de zero quando der errado.
+
+Não escreva "pronto" sem ter aberto os arquivos e mudado o que precisa.
+Diga em uma linha o que mudou.`;
+
+const REVISOR = (spec, pasta, arquivos, relato) => `Você é o REVISADOR, e você
+NÃO escreveu esse código. Não conserte nada — o seu trabalho é dizer o que está
+errado, para quem escreveu consertar.
+
+A pasta é: ${pasta}
+Arquivos: ${arquivos.join(', ') || '(nenhum)'}
+
+O que foi pedido:
+
+"""
+${spec}
+"""
+
+O QUE A MÁQUINA MEDIU ABRINDO A PÁGINA (isto é fato, não opinião):
+
+"""
+${relato}
+"""
+
+LEIA os arquivos antes de julgar. Depois responda em UMA das duas formas:
+
+APROVADO
+seguido de uma linha dizendo o que a pessoa vai ver ao abrir.
+
+ou
+
+REPROVADO
+seguido de uma lista, um item por linha, cada um com ARQUIVO, o que está errado
+e o que deveria acontecer. Máximo de seis itens, os mais graves primeiro.
+
+Reprove sem pensar duas vezes se: a página abriu em branco, há erro de
+JavaScript, um botão da especificação não existe ou não faz nada, ou a tela
+mostra texto de exemplo no lugar de conteúdo de verdade.
+
+Não reprove por gosto pessoal de cor, por falta de recurso que a especificação
+não pediu, nem por código que você escreveria diferente. Reprovar o que está
+certo custa uma rodada inteira e não muda nada.`;
+
+const APROVOU = /^\s*APROVAD[OA]\b/im;
+
+/**
+ * Roda o pipeline inteiro.
+ *
+ * @param {object} op
+ * @param {string} op.pedido    o que o usuário pediu, nas palavras dele
+ * @param {string} op.pasta     onde construir
+ * @param {(prompt:string,rotulo:string)=>Promise<string>} op.correr  roda um agente
+ * @param {(linha:string)=>void} op.mostrar   escreve na tela do usuário
+ * @param {(alvo:string)=>any} [op.abrir]     abre no navegador da pessoa
+ * @param {number} [op.rodadas]               voltas de correção (padrão 2)
+ */
+async function construir(op) {
+    const { pedido, pasta, correr, mostrar = () => {}, abrir } = op;
+    const rodadasMax = Math.max(1, Math.min(4, op.rodadas == null ? 2 : op.rodadas));
+    if (!pedido) return { ok: false, error: 'Diga o que construir.' };
+    if (!pasta) return { ok: false, error: 'Diga em que pasta construir.' };
+    fs.mkdirSync(pasta, { recursive: true });
+
+    const etapas = [];
+    try {
+        mostrar('engenheiro de prompt');
+        const spec = await correr(ENGENHEIRO(pedido), 'engenheiro de prompt');
+        etapas.push({ papel: 'engenheiro', texto: (spec || '').slice(0, 400) });
+        if (!spec || spec.length < 80) {
+            return { ok: false, error: 'O engenheiro de prompt não devolveu especificação. Faça você mesmo.' };
+        }
+
+        mostrar('construtor 1 — protótipo');
+        await correr(CONSTRUTOR_1(spec, pasta), 'construtor 1');
+        etapas.push({ papel: 'construtor 1', arquivos: listar(pasta).length });
+
+        let relato = null;
+        let aprovado = false;
+        let ultimoRevisor = '';
+
+        for (let volta = 1; volta <= rodadasMax; volta++) {
+            mostrar(`construtor 2 — ${volta === 1 ? 'MVP' : `correção ${volta - 1}`}`);
+            await correr(CONSTRUTOR_2(spec, pasta, relato), `construtor 2 (${volta})`);
+
+            mostrar('revisador — testando escondido');
+            const medida = await medirNoNavegador(pasta);
+            const arquivos = listar(pasta);
+            ultimoRevisor = await correr(
+                REVISOR(spec, pasta, arquivos, medida.relato), `revisador (${volta})`);
+
+            etapas.push({ papel: `revisador ${volta}`, testou: medida.testou,
+                limpo: medida.limpo, veredito: (ultimoRevisor || '').split('\n')[0] });
+
+            /* O veredito do modelo NÃO passa por cima do que a máquina mediu.
+               Página em branco ou erro de JavaScript é reprovação, e um
+               "APROVADO" escrito em cima disso é o revisor lendo o que ele
+               queria que estivesse lá — que é exatamente o defeito que separar
+               os papéis existe para evitar.
+
+               Mas o VETO precisa de MEDIDA: quando não deu para abrir nada —
+               porque o projeto não é uma página, ou porque não há navegador
+               nesta máquina — o que a máquina tem a dizer é "não sei", e "não
+               sei" não reprova. Sem esta distinção, um app de linha de comando
+               nunca seria aprovado: gastaria as voltas todas e terminaria
+               dizendo que não está pronto, sobre um trabalho que está. */
+            aprovado = APROVOU.test(ultimoRevisor || '') && !(medida.testou && !medida.limpo);
+            if (aprovado) { mostrar('aprovado'); break; }
+
+            relato = medida.limpo ? ultimoRevisor : `${medida.relato}\n\n${ultimoRevisor || ''}`;
+            if (volta < rodadasMax) mostrar('reprovado — voltando para o construtor');
+        }
+
+        const entrada = acharEntrada(pasta);
+        let abriu = false;
+        /* "Se o código gerado for HTML, abre automaticamente no navegador."
+           Só quando passou: abrir sozinho uma página quebrada entrega o defeito
+           em tela cheia e sem aviso. Reprovado a pessoa recebe o relatório, e
+           decide se quer olhar. */
+        if (aprovado && entrada && abrir) {
+            try { abrir(path.join(pasta, entrada)); abriu = true; } catch { /* segue sem abrir */ }
+        }
+
+        return {
+            ok: true,
+            aprovado,
+            pasta,
+            entrada,
+            abriu,
+            arquivos: listar(pasta),
+            /* CORTADOS de propósito: isto volta INTEIRO para dentro do contexto
+               do agente principal, e a especificação sozinha passa de mil
+               tokens. O que ele precisa é saber que houve especificação e o que
+               o revisor achou — o texto completo está nos arquivos e no que ele
+               vai contar ao usuário, não aqui. */
+            especificacao: spec.slice(0, 600),
+            revisao: (ultimoRevisor || '').slice(0, 1200),
+            etapas,
+            comoUsar: aprovado
+                ? `Pronto e revisado em ${pasta}.${abriu ? ' Já abri no navegador.' : ''} `
+                  + 'Conte ao usuário o que foi construído e o que dá para fazer na tela.'
+                : `Ficou de pé em ${pasta}, mas o revisor NÃO aprovou depois de ${rodadasMax} `
+                  + 'volta(s). NÃO diga que está pronto: conte ao usuário o que ainda está '
+                  + 'errado (está em "revisao") e pergunte se ele quer que você conserte.',
+        };
+    } finally {
+        // O navegador do revisor não é o da pessoa: ninguém sentiria falta dele
+        // nem saberia que existe para fechar.
+        try { browser.fecharRevisor(); } catch { /* já morreu */ }
+    }
+}
+
+/* As palavras com que se PEDE, e que não dizem nada sobre o que é. Sem tirá-las
+   a pasta se chama "faca-uma-calculadora-de", que é o pedido e não o produto. */
+const SO_PEDIDO = new Set(['faca', 'faz', 'faça', 'cria', 'crie', 'criar', 'monta',
+    'monte', 'montar', 'constroi', 'construa', 'construir', 'quero', 'preciso',
+    'me', 'um', 'uma', 'uns', 'umas', 'o', 'a', 'os', 'as', 'de', 'do', 'da',
+    'para', 'pra', 'com', 'que', 'app', 'aplicativo', 'site', 'pagina', 'por',
+    'favor', 'e', 'em', 'no', 'na']);
+
+/** Uma pasta nova dentro da do projeto, com nome derivado do pedido. */
+function pastaPara(pedido, base) {
+    const limpo = String(pedido || 'app').toLowerCase()
+        .normalize('NFD').replace(/[̀-ͯ]/g, '')
+        .replace(/[^a-z0-9]+/g, ' ').trim().split(/\s+/);
+    const uteis = limpo.filter((p) => p && !SO_PEDIDO.has(p));
+    // Sem nada de útil sobrando (um pedido feito só de verbos), o pedido cru
+    // ainda é melhor nome que "app": pelo menos diz de qual conversa veio.
+    const nome = (uteis.length ? uteis : limpo).slice(0, 4).join('-') || 'app';
+    return path.join(base || os.homedir(), nome);
+}
+
+module.exports = { construir, medirNoNavegador, servirPasta, acharEntrada, pastaPara, listar };

package/lib/studio.js

@@ -519,9 +519,9 @@ function enviarArquivo(caminho, nome) {
  * `abrir` é injetado (é a função de abrir navegador do tools.js) para esta
  * camada não passar a conhecer o sistema operacional.
  */
-const analisarAudio = ({ arquivo, pausa, abrir }) => comStudio(async () => {
+const analisarAudio = ({ arquivo, pausa, manter, repetida, abrir }) => comStudio(async () => {
     if (!arquivo) return { ok: false, error: 'Diga qual mídia analisar (arquivo: "/midia/x.mp4").' };
-    const tarefa = await pedir('POST', '/api/analise', { arquivo, pausa });
+    const tarefa = await pedir('POST', '/api/analise', { arquivo, pausa, manter, repetida });
     if (abrir) { try { abrir(`${BASE}${tarefa.pagina}`); } catch { /* segue e expira */ } }
 
     // Um vídeo de meia hora leva alguns segundos para decodificar; três
@@ -537,15 +537,28 @@ const analisarAudio = ({ arquivo, pausa, abrir }) => comStudio(async () => {
         }
         if (estado.estado === 'pronto') {
             const r = estado.resultado || {};
+            const repetidos = r.repetidos || [];
+            /* O QUE FOI TIRADO É DITO, e não só cortado. O vídeo sai menor e a
+               diferença é fala da pessoa: um resultado que só entrega os
+               trechos deixa o agente montar o vídeo sem ter como contar que
+               dois segundos dela sumiram — e vídeo que encurta sem explicação é
+               indistinguível de vídeo quebrado. */
+            const aviso = repetidos.length
+                ? ` ${repetidos.length} trecho(s) saíram por terem sido ditos duas vezes `
+                  + `(${repetidos.map((x) => `${x.de}s–${x.ate}s, ${x.motivo}`).join('; ')}). `
+                  + 'DIGA isso ao usuário na sua resposta, com os tempos. Se ele quiser tudo de volta, '
+                  + 'chame de novo com repetida:false.'
+                : '';
             return {
                 ok: true,
                 duracao: r.duracao,
                 cortado: r.cortado,
                 pausas: r.pausas,
                 trechos: r.trechos,
+                repetidos,
                 comoUsar: `${(r.trechos || []).length} trecho(s) sem pausa. Escreva UMA CENA por trecho, `
                     + `cada uma com {"tipo":"clipe","src":"${arquivo}","de":<início>,"ate":<fim>}. `
-                    + 'NÃO escreva "duracao" nessas cenas: a cena já dura o trecho.',
+                    + 'NÃO escreva "duracao" nessas cenas: a cena já dura o trecho.' + aviso,
             };
         }
     }

package/lib/tools.js

@@ -576,7 +576,8 @@ async function despachar(name, args, ctx) {
                 // por isso passa a função de abrir, e por isso demora alguns
                 // segundos em vez de responder na hora.
                 return studio.analisarAudio({
-                    arquivo: args.arquivo, pausa: args.pausa, abrir: openInBrowser,
+                    arquivo: args.arquivo, pausa: args.pausa, manter: args.manter,
+                    repetida: args.repetida, abrir: openInBrowser,
                 });
 
             /* A MESMA peça, virando projeto Remotion.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "primocode",
-  "version": "8.35.0",
+  "version": "8.37.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": {
@@ -8,7 +8,7 @@
   },
   "scripts": {
     "start": "node bin/primocode.js",
-    "test": "node test/tools.test.js && node test/ui.test.js && node test/modo.test.js && node test/pasta.test.js && node test/catalogo.test.js && node test/desktop.test.js && node test/effort.test.js && node test/claude-engine.test.js && node test/regressao.test.js && node test/memoria-conversa.test.js && node test/repeticao.test.js && node test/referencia.test.js && node test/parar.test.js && node test/continuar.test.js && node test/studio-spec.test.js && node test/studio-versoes.test.js && node test/voz.test.js && node test/editor.test.js && node test/estudio-projeto.test.js && node test/vocabulario.test.js && node test/video-export.test.js && node test/monotonia.test.js && node test/clipe.test.js && node test/midia-envio.test.js && node test/pausas.test.js && node test/app.test.js && node test/elementos.test.js && node test/remotion.test.js && node test/aplicativo.test.js && node test/conta.test.mjs && node test/nuvem.test.js && node test/codex.test.js && node test/chaves.test.js && node test/prazo.test.js && node test/primeira-vez.test.js && node test/janela.test.js"
+    "test": "node test/tools.test.js && node test/ui.test.js && node test/modo.test.js && node test/pasta.test.js && node test/catalogo.test.js && node test/desktop.test.js && node test/effort.test.js && node test/claude-engine.test.js && node test/regressao.test.js && node test/memoria-conversa.test.js && node test/repeticao.test.js && node test/referencia.test.js && node test/parar.test.js && node test/continuar.test.js && node test/studio-spec.test.js && node test/studio-versoes.test.js && node test/voz.test.js && node test/editor.test.js && node test/estudio-projeto.test.js && node test/vocabulario.test.js && node test/video-export.test.js && node test/monotonia.test.js && node test/clipe.test.js && node test/midia-envio.test.js && node test/pausas.test.js && node test/fala-repetida.test.js && node test/trilha.test.js && node test/anuncio.test.js && node test/pipeline.test.js && node test/app.test.js && node test/elementos.test.js && node test/remotion.test.js && node test/aplicativo.test.js && node test/conta.test.mjs && node test/nuvem.test.js && node test/codex.test.js && node test/chaves.test.js && node test/prazo.test.js && node test/primeira-vez.test.js && node test/janela.test.js"
   },
   "engines": {
     "node": ">=18.17.0"