primocode 8.35.0 → 8.37.0

package/lib/act.js

@@ -616,6 +616,24 @@ async function runAct(userPrompt, opts) {
                 continue;
             }
 
+            /* O PIPELINE DE QUATRO PAPÉIS mora aqui pelo mesmo motivo que o
+               `spawn_agent`: ele PRECISA rodar agentes, e quem sabe rodar
+               agente é este arquivo. Pôr isto no `tools.execute` obrigaria
+               aquele módulo a conhecer o loop do agente — e um segundo lugar
+               que sabe abrir conversa com o modelo é um segundo lugar para
+               esquecer de passar o token, a pasta ou o motor. */
+            if (tc.name === 'construir_app') {
+                algoRodou = true;
+                console.log(ident(profundidade) + actionHeader(tc.name, tc.arguments));
+                const r = await rodarPipeline(tc.arguments || {}, {
+                    server, model, token, projectDir: pastaAtual, projectName, profundidade, motor,
+                });
+                logResult(tc.name, r, profundidade);
+                messages.push({ role: 'tool', tool_call_id: tc.id, content: JSON.stringify(r) });
+                if (r && r.ok && catalogo.escreveArquivo(tc.name)) temPasta = true;
+                continue;
+            }
+
             // Repetiu a mesma chamada? Não executa de novo. Rodar outra vez
             // gastaria a cota para devolver exatamente o mesmo texto, e é
             // esse texto que convence o modelo a repetir mais uma vez.
@@ -798,5 +816,55 @@ async function runSubagent(args, ctx) {
     return resumo;
 }
 
+/* ══ O PIPELINE DE QUATRO PAPÉIS ═══════════════════════════════════════════
+ *
+ *   "Engenheiro de Prompt → Construtor 1 (protótipo) → Construtor 2 (MVP) →
+ *    Revisador (testa ocultamente) → loop de correção → abre no navegador."
+ *
+ * As regras dos papéis, os prompts e o revisor que abre a página moram em
+ * `pipeline.js`, que não conhece o loop do agente. O que esta função faz é a
+ * costura: dar a ele uma forma de RODAR um agente, uma de escrever na tela e
+ * uma de abrir o navegador da pessoa.
+ *
+ * Cada papel roda com `history: []` — conversa própria, sem ver a do usuário
+ * nem a do papel anterior. É essa separação que faz o revisor valer alguma
+ * coisa: quem acabou de escrever o código é o pior revisor dele, porque lê o
+ * que quis escrever em vez do que escreveu.
+ */
+async function rodarPipeline(args, ctx) {
+    const { server, model, token, projectDir, projectName, profundidade, motor } = ctx;
+    if (profundidade > 0) {
+        return { ok: false, error: 'Recusado: o pipeline não roda dentro de um subagente — '
+            + 'os papéis dele já são subagentes. Faça a parte que te cabe.' };
+    }
+
+    const pipeline = require('./pipeline.js');
+    const path = require('path');
+    const pedido = args.pedido || args.prompt || '';
+    const base = projectDir || cfg.ROOT_DIR;
+    const pasta = args.pasta
+        ? path.resolve(base, args.pasta)
+        : pipeline.pastaPara(pedido, base);
+
+    const correr = async (prompt, rotulo) => {
+        if (PARAR) return '';
+        console.log(ident(profundidade) + `  ${c.magenta('◆')} ${c.bold(c.magenta('Agente'))} ${c.muted(rotulo)}`);
+        const r = await runAct(prompt, {
+            server, model, token, projectDir: pasta, projectName,
+            history: [], profundidade: profundidade + 1, subagent: true, motor,
+        });
+        return (r && r.assistantMessage && r.assistantMessage.content) || '';
+    };
+
+    return pipeline.construir({
+        pedido,
+        pasta,
+        rodadas: args.rodadas,
+        correr,
+        mostrar: (linha) => console.log(ident(profundidade) + `  ${c.muted('⎿ ' + linha)}`),
+        abrir: tools.openInBrowser,
+    });
+}
+
 module.exports = { runAct, interromper, compactar, motivoDaParada, ehTetoDeToken, esperaDoErro,
     anotacaoDoQueJaFoi, encolherParaContinuar, MAX_ITERATIONS };

package/lib/browser.js

@@ -27,6 +27,36 @@ const PROFILE_DIR = path.join(os.homedir(), '.primocode', 'chrome-profile');
 const DEBUG_PORT = Number(process.env.PRIMOCODE_CDP_PORT || 3199);
 
 // ---- Helpers ---------------------------------------------------
+/* O Chromium que o Playwright baixa. Ele não fica no PATH nem em /Applications
+   — mora numa pasta com o número da build no nome, que muda a cada versão —,
+   então achá-lo é olhar a pasta e escolher a mais nova. */
+function doPlaywright() {
+    const bases = [
+        process.env.PLAYWRIGHT_BROWSERS_PATH,
+        path.join(os.homedir(), '.cache', 'ms-playwright'),
+        path.join(os.homedir(), 'Library', 'Caches', 'ms-playwright'),
+        process.env.LOCALAPPDATA && path.join(process.env.LOCALAPPDATA, 'ms-playwright'),
+    ].filter(Boolean);
+    const dentro = process.platform === 'darwin'
+        ? ['chrome-mac/Chromium.app/Contents/MacOS/Chromium']
+        : process.platform === 'win32'
+            ? ['chrome-win\\chrome.exe']
+            : ['chrome-linux/chrome', 'chrome-linux/headless_shell'];
+    for (const base of bases) {
+        let pastas = [];
+        try { pastas = fs.readdirSync(base).filter((d) => d.startsWith('chromium')); } catch { continue; }
+        // A build mais nova primeiro: "chromium-1194" ganha de "chromium-1080".
+        pastas.sort((a, b) => (parseInt(b.split('-').pop(), 10) || 0) - (parseInt(a.split('-').pop(), 10) || 0));
+        for (const p of pastas) {
+            for (const d of dentro) {
+                const cheio = path.join(base, p, d);
+                try { if (fs.existsSync(cheio)) return cheio; } catch { /* próximo */ }
+            }
+        }
+    }
+    return null;
+}
+
 function findChrome() {
     const platform = process.platform;
     // 1) Respeita a variável de ambiente — aponta para qualquer Chrome/Chromium.
@@ -57,6 +87,11 @@ function findChrome() {
     for (const p of candidates) {
         try { if (p && fs.existsSync(p)) return p; } catch {}
     }
+    // Quem já tem Playwright instalado tem um Chromium no disco e não sabe o
+    // caminho. Sem esta busca, a máquina com navegador é tratada como máquina
+    // sem navegador — e o revisor recusa trabalhar por nada.
+    const dosTestes = doPlaywright();
+    if (dosTestes) return dosTestes;
 
     // Último recurso: o navegador pode estar num disco montado ou numa pasta de
     // aplicativos do usuário. Caso real medido nesta máquina: o Chrome 151 estava
@@ -295,6 +330,12 @@ class CDPSession {
         this.msgId = 0;
         this.pending = new Map(); // id -> { resolve, reject }
         this.targetId = null;
+        /* Quem quiser ouvir EVENTO do navegador (erro de JS, console, recurso
+           que não carregou) põe uma função aqui. Ela nasceu para o revisor
+           escondido: o defeito que ele existe para achar — a página que abre em
+           branco por causa de um TypeError — não aparece em resposta nenhuma de
+           comando, só em `Runtime.exceptionThrown`. */
+        this.onEvent = null;
     }
     async attach(wsUrl) {
         this.ws = new MiniWebSocket();
@@ -310,8 +351,11 @@ class CDPSession {
             this.pending.delete(msg.id);
             if (msg.error) reject(new Error(msg.error.message || 'erro CDP'));
             else resolve(msg.result || {});
+            return;
+        }
+        if (msg.method && this.onEvent) {
+            try { this.onEvent(msg.method, msg.params || {}); } catch { /* ouvinte não derruba a sessão */ }
         }
-        // eventos são ignorados (não usamos aqui)
     }
     send(method, params = {}, timeoutMs = 15000) {
         const id = ++this.msgId;
@@ -644,7 +688,254 @@ function close() {
     return { ok: true };
 }
 
+/* ══ O REVISOR ESCONDIDO ═══════════════════════════════════════════════════
+ *
+ *   "Revisador: testa o código ocultamente, identifica erros e reporta ao
+ *    Construtor 2."
+ *
+ * ── POR QUE UM SEGUNDO NAVEGADOR ─────────────────────────────────────────
+ * O daqui de cima é o navegador DA PESSOA: mesmo perfil, mesmos logins, e ela
+ * está olhando. Um revisor que rodasse ali abriria abas, navegaria e fecharia
+ * páginas no meio do trabalho de quem está usando o computador — e o pedido é
+ * justamente que ele teste SEM aparecer. Então é outro processo: porta
+ * própria, perfil próprio, sempre `--headless`, e ele nasce e morre com a
+ * revisão.
+ *
+ * ── O QUE ELE PROCURA ────────────────────────────────────────────────────
+ * O defeito que ele existe para achar não dá erro em lugar nenhum: a página
+ * abre, responde 200, tem título, e está EM BRANCO — um `TypeError` na
+ * primeira linha do script, um `<script src>` que não existe, uma tag mal
+ * fechada. Quem escreveu não vê, porque o modelo não abre o que escreveu; e
+ * quem pediu vê uma tela vazia e conclui que o PrimoCode não funciona.
+ *
+ * Por isso a leitura é de DUAS naturezas, e as duas são necessárias:
+ *
+ *   · O QUE O NAVEGADOR RECLAMOU — exceção de JavaScript, erro de console,
+ *     recurso que não carregou. É o sintoma direto e vem por evento, nunca
+ *     como resposta de comando.
+ *   · O QUE FICOU NA TELA — quantos elementos têm área de verdade e quanto
+ *     texto visível existe. Página sem erro nenhum e sem nada dentro é o caso
+ *     mais comum de todos, e sem esta metade ele aprovaria.
+ */
+
+/* ── PORTA E PERFIL SÃO DESTA EXECUÇÃO, e isso é conserto de defeito ────
+ *
+ * A primeira versão usava porta fixa (3198) e um perfil fixo em
+ * `~/.primocode/chrome-revisor`. Duas sessões do PrimoCode na mesma máquina —
+ * duas abas de terminal, ou a suíte de testes rodando enquanto alguém trabalha
+ * — disputavam os dois: a segunda achava a porta ocupada e se ligava ao
+ * navegador da PRIMEIRA, e quando qualquer uma terminasse, `fecharRevisor`
+ * matava o navegador da outra no meio de uma revisão. O sintoma foi medido:
+ * "não consegui abrir a página para testar", intermitente, sem causa visível.
+ *
+ * Porta ZERO é o Chrome escolhendo uma livre e escrevendo qual no arquivo
+ * `DevToolsActivePort` do perfil — é o jeito dele de responder isso, e não há
+ * corrida como haveria em pedir uma porta ao sistema e depois lançar.
+ *
+ * O perfil é temporário porque o revisor não tem o que guardar: ele não faz
+ * login em lugar nenhum, e um perfil que fica só acumula disco. */
+let PORTA_REVISOR = Number(process.env.PRIMOCODE_CDP_PORT_REVISOR || 0);
+let perfilRevisor = null;
+let revisorChild = null;
+
+function lerPortaDoPerfil(perfil) {
+    try {
+        const linhas = fs.readFileSync(path.join(perfil, 'DevToolsActivePort'), 'utf-8').split('\n');
+        const n = Number(linhas[0]);
+        return Number.isInteger(n) && n > 0 ? n : 0;
+    } catch { return 0; }
+}
+
+async function subirRevisor() {
+    if (PORTA_REVISOR) {
+        try {
+            const v = await httpGetJson(`http://127.0.0.1:${PORTA_REVISOR}/json/version`, 800);
+            if (v && v.webSocketDebuggerUrl) return true;
+        } catch {}
+    }
+
+    const chrome = findChrome();
+    if (!chrome) {
+        throw new Error('Sem navegador para revisar. O revisor abre a página num Chrome invisível '
+            + 'para ver o que quebra; instale Chrome, Edge, Brave ou Chromium, ou aponte o seu '
+            + 'com PRIMOCODE_CHROME=/caminho/do/navegador.');
+    }
+    perfilRevisor = fs.mkdtempSync(path.join(os.tmpdir(), 'primocode-revisor-'));
+
+    const args = [
+        // Zero: o Chrome escolhe uma porta livre e escreve qual no perfil.
+        `--remote-debugging-port=${process.env.PRIMOCODE_CDP_PORT_REVISOR || 0}`,
+        `--user-data-dir=${perfilRevisor}`,
+        // Sempre invisível: é o pedido, e é o que separa este do navegador da
+        // pessoa. Não há variável para ligar a janela aqui de propósito.
+        '--headless=new', '--disable-gpu', '--disable-dev-shm-usage',
+        '--hide-scrollbars', '--mute-audio',
+        '--no-first-run', '--no-default-browser-check',
+        '--disable-features=Translate',
+        'about:blank',
+    ];
+    if (process.platform === 'linux' && process.getuid && process.getuid() === 0) {
+        args.splice(3, 0, '--no-sandbox');
+    }
+    revisorChild = spawn(chrome, args, { detached: true, stdio: 'ignore' });
+    revisorChild.on('error', () => {});
+    revisorChild.unref();
+
+    const prazo = Date.now() + 15000;
+    while (Date.now() < prazo) {
+        const porta = Number(process.env.PRIMOCODE_CDP_PORT_REVISOR) || lerPortaDoPerfil(perfilRevisor);
+        if (porta) {
+            try {
+                const v = await httpGetJson(`http://127.0.0.1:${porta}/json/version`, 500);
+                if (v && v.webSocketDebuggerUrl) { PORTA_REVISOR = porta; return true; }
+            } catch { /* ainda subindo */ }
+        }
+        await sleep(250);
+    }
+    throw new Error('o navegador do revisor subiu mas não abriu a porta de controle');
+}
+
+/* O que o navegador reclamou vira uma linha legível. O texto volta para outro
+   MODELO ler, então ele precisa dizer o problema e onde — "TypeError: x is not
+   a function (app.js:14)" conserta; "erro no console" não. */
+function _falaDoErro(metodo, p) {
+    if (metodo === 'Runtime.exceptionThrown') {
+        const d = p.exceptionDetails || {};
+        const alvo = d.exception || {};
+        const onde = d.url ? ` (${String(d.url).split('/').pop()}:${(d.lineNumber || 0) + 1})` : '';
+        const texto = alvo.description || alvo.value || d.text || 'exceção sem descrição';
+        return { tipo: 'javascript', texto: String(texto).split('\n')[0] + onde };
+    }
+    if (metodo === 'Log.entryAdded') {
+        const e = p.entry || {};
+        if (e.level !== 'error') return null;
+        /* O NAVEGADOR PEDE ISTO SOZINHO, e a página não tem culpa. Sem esta
+           linha, TODA página sem favicon chegava ao revisor com um erro de
+           recurso — e um revisor que reprova o que está certo custa uma volta
+           inteira do pipeline, toda vez, para não mudar nada. Foi medido: a
+           página correta do teste era a única a reprovar. */
+        if (/\/favicon\.ico\b/.test(String(e.url || '')) || /\/\.well-known\//.test(String(e.url || ''))) {
+            return null;
+        }
+        const onde = e.url ? ` (${String(e.url).split('/').pop()})` : '';
+        return { tipo: e.source === 'network' ? 'recurso' : 'console', texto: String(e.text || '').slice(0, 220) + onde };
+    }
+    if (metodo === 'Runtime.consoleAPICalled') {
+        if (p.type !== 'error') return null;
+        const texto = (p.args || []).map((a) => a.description || a.value || a.type).join(' ');
+        return { tipo: 'console', texto: String(texto).slice(0, 220) };
+    }
+    return null;
+}
+
+/* A sonda roda DENTRO da página: é a única forma de saber se sobrou alguma
+   coisa na tela. Conta elemento com área de verdade — `display:none`,
+   `visibility:hidden` e opacidade zero não valem, e é assim que uma página
+   "cheia" de nós invisíveis deixa de passar por cheia. */
+const SONDA = `(() => {
+  const corpo = document.body;
+  if (!corpo) return { titulo: document.title || '', texto: '', visiveis: 0, altura: 0 };
+  let visiveis = 0;
+  const todos = corpo.querySelectorAll('*');
+  for (const el of todos) {
+    const r = el.getBoundingClientRect();
+    if (r.width <= 4 || r.height <= 4) continue;
+    const s = getComputedStyle(el);
+    if (s.visibility === 'hidden' || s.display === 'none' || parseFloat(s.opacity) < 0.05) continue;
+    visiveis++;
+  }
+  return { titulo: document.title || '', texto: (corpo.innerText || '').trim().slice(0, 600),
+           visiveis, altura: corpo.scrollHeight, nos: todos.length };
+})()`;
+
+/**
+ * Abre uma página num navegador invisível e conta o que deu errado.
+ *
+ * @param {string} url          endereço a abrir (http://… ou file://…)
+ * @param {object} op
+ * @param {number} op.assentar  ms de espera depois do load, para o JS rodar
+ * @returns {Promise<{ok:boolean,url:string,titulo:string,erros:Array,vazio:boolean,texto:string,visiveis:number}>}
+ */
+async function inspecionarEscondido(url, op = {}) {
+    await subirRevisor();
+    const aba = await comTeto(
+        httpPutJson(`http://127.0.0.1:${PORTA_REVISOR}/json/new?${encodeURIComponent('about:blank')}`, 5000),
+        8000, 'a aba do revisor');
+    if (!aba || !aba.webSocketDebuggerUrl) throw new Error('o revisor não abriu uma aba');
+
+    const s = new CDPSession();
+    const erros = [];
+    s.onEvent = (metodo, p) => {
+        const linha = _falaDoErro(metodo, p);
+        // Teto: uma página em laço de erro produz milhares de linhas iguais, e
+        // o que volta daqui vai para dentro do contexto de outro modelo.
+        if (linha && erros.length < 25 && !erros.some((e) => e.texto === linha.texto)) erros.push(linha);
+    };
+    try {
+        await comTeto(s.attach(aba.webSocketDebuggerUrl), 12000, 'o canal do revisor');
+        await s.send('Page.enable');
+        await s.send('Runtime.enable');
+        await s.send('Log.enable');
+        await s.send('Page.navigate', { url });
+
+        const prazo = Date.now() + (op.prazo || 20000);
+        while (Date.now() < prazo) {
+            const r = await s.send('Runtime.evaluate', {
+                expression: 'document.readyState', returnByValue: true,
+            }).catch(() => null);
+            if (r && r.result && r.result.value === 'complete') break;
+            await sleep(200);
+        }
+        // Depois do load ainda roda o que espera DOMContentLoaded, o que está
+        // num módulo e o que pede a primeira rede. Sem esta pausa o revisor
+        // aprovaria a página um instante antes de ela quebrar.
+        await sleep(op.assentar || 1200);
+
+        const sonda = await s.send('Runtime.evaluate', {
+            expression: SONDA, returnByValue: true, awaitPromise: false,
+        }).catch(() => null);
+        const v = (sonda && sonda.result && sonda.result.value) || {};
+
+        return {
+            ok: true,
+            url,
+            titulo: v.titulo || '',
+            texto: v.texto || '',
+            visiveis: v.visiveis || 0,
+            // Três elementos com área e dez letras é o piso do que se pode
+            // chamar de página. Abaixo disso, o que a pessoa vê é uma tela
+            // branca — com ou sem erro no console.
+            vazio: (v.visiveis || 0) < 3 && (v.texto || '').length < 10,
+            erros,
+        };
+    } finally {
+        try { s.close(); } catch {}
+        try { await httpGetJson(`http://127.0.0.1:${PORTA_REVISOR}/json/close/${aba.id}`, 2000); } catch {}
+    }
+}
+
+/* O revisor é ferramenta de uma tarefa, não um processo que fica. Deixá-lo de
+   pé come memória até a pessoa desligar o computador, e ele não é o navegador
+   dela — ninguém sentiria falta nem saberia que existe para fechar. */
+function fecharRevisor() {
+    if (revisorChild && revisorChild.pid) {
+        try { process.kill(-revisorChild.pid); } catch {
+            try { revisorChild.kill(); } catch {}
+        }
+    }
+    revisorChild = null;
+    PORTA_REVISOR = Number(process.env.PRIMOCODE_CDP_PORT_REVISOR || 0);
+    if (perfilRevisor) {
+        // O perfil é temporário: sem apagar, cada revisão deixa dezenas de MB
+        // em /tmp que ninguém sabe de quem são.
+        try { fs.rmSync(perfilRevisor, { recursive: true, force: true }); } catch { /* o SO limpa */ }
+        perfilRevisor = null;
+    }
+    return { ok: true };
+}
+
 module.exports = {
     open, click, clickText, clickSelector, type, typeInSelector,
     key, screenshot, evaluate, waitFor, wait, scroll, close,
+    inspecionarEscondido, fecharRevisor,
 };

package/lib/catalogo.js

@@ -93,8 +93,12 @@ const GRUPOS = [
               args: 'id da peça. pasta (opcional): nome da pasta. fps (opcional, padrão 30). renderizar: true só se o npm install já foi feito. '
                 + 'Use SÓ quando o usuário pedir Remotion pelo nome, ou quando precisar de render determinístico, vídeo longo, codec/fps específico ou o projeto em React. '
                 + 'O caminho normal continua sendo studio_criar + o botão de baixar, que sai em segundos sem instalar nada.' },
-            { tool: 'studio_analisar',  escreve: false, faz: 'ouve um vídeo já enviado e diz onde estão as pausas, para cortá-las',
-              args: 'arquivo: a URL "/midia/..." do vídeo. pausa (opcional): segundos a partir dos quais conta como pausa (padrão 0.6). Devolve "trechos": vire cada um numa cena com {"tipo":"clipe","de":...,"ate":...}.' },
+            { tool: 'studio_analisar',  escreve: false, faz: 'ouve um vídeo já enviado: encurta as pausas e tira a fala que a pessoa errou e refez',
+              args: 'arquivo: a URL "/midia/..." do vídeo. pausa (opcional): segundos a partir dos quais conta como pausa (padrão 0.6). '
+                + 'manter (opcional): quantos segundos de cada pausa ficam — sem isso ele decide sozinho (respiração fica quase inteira, pausa longa fica 0,7s). manter:0 corta seco. '
+                + 'repetida (opcional, padrão true): false desliga o corte de fala repetida. '
+                + 'Devolve "trechos": vire cada um numa cena com {"tipo":"clipe","de":...,"ate":...}. '
+                + 'Devolve também "repetidos": o que foi tirado por ter sido dito duas vezes — CONTE isso ao usuário, com os tempos, porque é fala dele que sumiu do vídeo.' },
         ],
     },
     {
@@ -143,6 +147,11 @@ const GRUPOS = [
             // Estas duas o loop do agente atende (lib/act.js), não o tools.execute.
             { tool: 'spawn_agent', escreve: false, faz: 'chama um subagente 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.' },
+            { 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. '
+                + 'USE quando pedirem um app, um site, uma página ou uma ferramenta INTEIRA, do zero. NÃO use para mexer no que já existe, para um arquivo só, nem para conserto: são seis a oito chamadas de agente, '
+                + 'e gastá-las para trocar a cor de um botão come o dia do usuário. O revisor ABRE a página num navegador invisível e mede — página em branco e erro de JavaScript reprovam sozinhos, o que ele achar volta para o construtor.' },
             { tool: 'finish',      escreve: false, faz: 'encerra dizendo o que fez', noLoop: true,
               args: 'summary (opcional): uma frase do que foi feito.' },
         ],

package/lib/claude-engine.js

@@ -14,6 +14,27 @@ const path = require('path');
 const os = require('os');
 const { execSync, execFileSync } = require('child_process');
 
+/* ── O MOTOR EXTERNO NÃO APARECE ────────────────────────────────────────
+ *
+ *   "O Primo Code abre esses processos ocultamente (em segundo plano) e usa
+ *    apenas o modelo dessas ferramentas. Toda a interface, comandos, agentes e
+ *    experiência continuam sendo 100% do Primo Code."
+ *
+ * `execFileSync` sem `stdio` HERDA o stderr do pai — é o padrão do Node, e não
+ * parece nada até o dia em que o motor imprime um aviso de versão, de
+ * atualização ou de configuração. Aquilo cai no meio da tela do PrimoCode, com
+ * a cara e o vocabulário de outro produto, no meio de uma tarefa.
+ *
+ * Com o stderr CAPTURADO ele some da tela e ganha um segundo uso: `e.stderr` só
+ * existe quando é canalizado, e o tratamento de erro daqui (e o do
+ * codex-engine) já lia esse campo — estava lendo `null` desde sempre, e a
+ * mensagem de falha do motor saía sem o motivo que ele mesmo tinha escrito.
+ *
+ * `windowsHide` é a outra metade do "ocultamente": sem ele, cada chamada
+ * pisca um console preto na frente de quem usa Windows. */
+const SEM_APARECER = { stdio: ['pipe', 'pipe', 'pipe'], windowsHide: true };
+
+
 const MARCA_INICIO = '<<<PRIMOCODE>>>';
 const MARCA_FIM = '<<<FIM>>>';
 
@@ -233,7 +254,8 @@ function escolherCaminho({ temClaude, temOrcaCli, orcaOk }) {
 let sessao = { handle: null, cursor: '0', bootstrapEnviado: false };
 
 function rodarOrca(args, opts = {}) {
-    return execFileSync('orca', args, { encoding: 'utf-8', timeout: opts.timeout || 15000 });
+    return execFileSync('orca', args,
+        { encoding: 'utf-8', timeout: opts.timeout || 15000, ...SEM_APARECER });
 }
 
 let contadorId = 0;
@@ -548,7 +570,7 @@ async function requestActViaHeadless(payload, onEvent) {
         '--dangerously-skip-permissions',
         ...argsDoModelo(),
     ], { encoding: 'utf-8', timeout: 180000, input: prompt, maxBuffer: 32 * 1024 * 1024,
-        env: chaves.ambienteDe('claude') });
+        env: chaves.ambienteDe('claude'), ...SEM_APARECER });
     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
@@ -561,6 +583,7 @@ async function requestActViaHeadless(payload, onEvent) {
             encoding: 'utf-8', timeout: 120000, maxBuffer: 32 * 1024 * 1024,
             env: chaves.ambienteDe('claude'),
             input: promptDeCorrecao(aviso),
+            ...SEM_APARECER,
         });
         return JSON.parse(s).result || '';
     };

package/lib/codex-engine.js

@@ -32,6 +32,13 @@
 
 const { execSync, execFileSync } = require('child_process');
 
+/* O MOTOR EXTERNO NÃO APARECE — a mesma regra do claude-engine, e o mesmo
+   comentário longo mora lá. Em resumo: `execFileSync` sem `stdio` HERDA o
+   stderr, e um aviso do Codex cairia no meio da tela do PrimoCode com a cara de
+   outro produto. Capturado, ele some da tela e `e.stderr` passa a existir — o
+   `catch` daqui já lia esse campo e estava lendo `null` desde sempre. */
+const SEM_APARECER = { stdio: ['pipe', 'pipe', 'pipe'], windowsHide: true };
+
 const claude = require('./claude-engine');
 const chaves = require('./chaves');
 
@@ -78,7 +85,7 @@ let _ajuda = null;
 function ajudaDoExec(executor) {
     if (_ajuda !== null) return _ajuda;
     const rodar = executor || ((args) => execFileSync(CODEX, args,
-        { encoding: 'utf-8', timeout: 20000, stdio: ['ignore', 'pipe', 'ignore'] }));
+        { encoding: 'utf-8', timeout: 20000, ...SEM_APARECER }));
     try { _ajuda = String(rodar(['exec', '--help']) || ''); }
     catch { _ajuda = ''; }        // sem ajuda: segue com o mínimo
     return _ajuda;
@@ -132,7 +139,7 @@ function chamarCodex(prompt, { executor, avisar = () => {} } = {}) {
     // sido "configurado".
     const rodar = executor || ((args, entrada) => execFileSync(CODEX, args, {
         encoding: 'utf-8', timeout: TEMPO, input: entrada, maxBuffer: BUFFER,
-        env: chaves.ambienteDe('codex'),
+        env: chaves.ambienteDe('codex'), ...SEM_APARECER,
     }));
     try {
         return rodar(argsDoExec(), prompt);