primocode 8.34.1 → 8.36.0

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);

package/lib/icone.js

@@ -82,56 +82,72 @@ function caixa(t, x0, y0, l, a, r, cor) {
 
 // ── o mascote ────────────────────────────────────────────────────────────
 
-/* O Primo, o mesmo do terminal: cabeça de topo arredondado, ombros largos,
- * dois pezinhos. Lá ele é feito de glifos de bloco:
+/* O DESENHO VEM DE UM LUGAR SÓ.
  *
- *      ▐▛███▜▌        a cabeça
- *     ▝▜█████▛▘       o corpo, mais largo
- *       ▘▘ ▝▝         os pés
+ * Antes esta função desenhava um bicho à mão — cabeça arredondada, ombros,
+ * dois pés, olhos no negativo — e o app e o site desenhavam OUTRO, a matriz de
+ * pixels do logo que o dono mandou. Dois desenhos com o mesmo nome: o ícone no
+ * Dock não era o bicho que aparecia dentro do programa.
  *
- * Aqui são as mesmas três peças em proporção, e não uma transliteração dos
- * glifos: meio bloco de terminal vira escada num ícone de 512px. O que faz
- * reconhecer é a SILHUETA — topo redondo, ombro saliente, dois pés —, e ela é
- * a mesma.
- */
+ * Agora os dois leem a mesma `MATRIZ` do `app/primo-marca.js`. Mudar o logo é
+ * mudar onze linhas de texto, e o Dock, a janela e o site mudam juntos.
+ *
+ * (Aquele arquivo é escrito para o navegador, mas se pendura no `globalThis`
+ * quando não há `window` — então dá para carregá-lo aqui sem uma segunda
+ * versão dele.) */
+require('../app/primo-marca.js');
+const MARCA = (typeof globalThis !== 'undefined' && globalThis.PrimoMarca) || null;
+
+/** #5ec8ef → [94, 200, 239] */
+function doHex(h) {
+    const n = parseInt(String(h).replace('#', ''), 16);
+    return [(n >> 16) & 255, (n >> 8) & 255, n & 255];
+}
+
 function desenharPrimo(n) {
     const t = tela(n);
-    const u = n / 32;                      // a grade do desenho, em pixels
 
-    // A base: o quadrado escuro do app, com o mesmo arredondado do ícone de
-    // sistema (22% do lado é o raio que o macOS e o Windows usam hoje).
+    // A base: o quadrado escuro do app, com o mesmo arredondado que o macOS e
+    // o Windows usam hoje (22% do lado). É o formato de azulejo do estilo
+    // pedido — glifo chapado, centrado, sobre cor sólida.
     caixa(t, 0, 0, n, n, n * 0.22, FUNDO);
 
-    // Um brilho fraco atrás do bicho — o mesmo halo do fundo do app.
+    // Um brilho fraco atrás do bicho, para o azulejo não ficar chapado.
     for (let y = 0; y < n; y++) {
         for (let x = 0; x < n; x++) {
-            const dx = (x - n / 2) / (n * 0.6);
-            const dy = (y - n * 0.34) / (n * 0.6);
+            const dx = (x - n / 2) / (n * 0.62);
+            const dy = (y - n * 0.42) / (n * 0.62);
             const d = Math.sqrt(dx * dx + dy * dy);
-            if (d < 1) ponto(t, x, y, AZUL, 0.11 * (1 - d) * (1 - d));
+            if (d < 1) ponto(t, x, y, AZUL, 0.10 * (1 - d) * (1 - d));
         }
     }
 
-    // Cabeça: topo arredondado, ombros retos embaixo (raio só em cima é o que
-    // dá a silhueta do ▐▛███▜▌ — redondo por cima, quadrado por baixo).
-    caixa(t, 9 * u, 7 * u, 14 * u, 11 * u, 3.4 * u, AZUL);
-    caixa(t, 9 * u, 14 * u, 14 * u, 4 * u, 0.6 * u, AZUL);
-
-    // Corpo: mais largo que a cabeça, que é o ombro marcado do desenho.
-    caixa(t, 6 * u, 17.6 * u, 20 * u, 7.6 * u, 2.2 * u, AZUL);
+    if (!MARCA) return t;                 // sem a matriz, fica o azulejo
 
-    // Os dois pés.
-    caixa(t, 10 * u, 24.6 * u, 4.4 * u, 2.6 * u, 1 * u, AZUL_FUNDO);
-    caixa(t, 17.6 * u, 24.6 * u, 4.4 * u, 2.6 * u, 1 * u, AZUL_FUNDO);
+    const linhas = MARCA.MATRIZ;
+    const colunas = linhas[0].length;
+    const corpo = doHex(MARCA.CORPO);
+    const detalhe = doHex(MARCA.DETALHE);
 
-    // Os olhos, no negativo — é o que faz o bloco virar bicho.
-    caixa(t, 12.4 * u, 10.6 * u, 2.6 * u, 3.2 * u, 1.1 * u, FUNDO);
-    caixa(t, 17 * u, 10.6 * u, 2.6 * u, 3.2 * u, 1.1 * u, FUNDO);
+    /* O bicho ocupa 62% do azulejo. Mais que isso ele encosta na borda
+     * arredondada e o ícone fica apertado; menos, e some no tamanho de 16px da
+     * barra de tarefas — que é onde ele mais aparece. */
+    const lado = Math.floor((n * 0.62) / colunas);
+    const largura = lado * colunas;
+    const altura = lado * linhas.length;
+    const x0 = Math.round((n - largura) / 2);
+    const y0 = Math.round((n - altura) / 2);
 
-    // A luz de cima: uma faixa clara na testa e no ombro. Sem ela o bicho é
-    // uma silhueta chapada — é o mesmo bisel do "vidro" do estúdio.
-    caixa(t, 10.4 * u, 8.2 * u, 11.2 * u, 1.4 * u, 0.7 * u, BRILHO);
-    caixa(t, 7.6 * u, 18.6 * u, 16.8 * u, 1.2 * u, 0.6 * u, BRILHO);
+    for (let f = 0; f < linhas.length; f++) {
+        for (let cIdx = 0; cIdx < colunas; cIdx++) {
+            const ch = linhas[f][cIdx];
+            if (ch !== 'C' && ch !== 'D') continue;
+            // Sem raio: pixel art com canto redondo deixa de ser pixel art, e
+            // vira um monte de bolinhas quando o quadrado é pequeno.
+            caixa(t, x0 + cIdx * lado, y0 + f * lado, lado, lado, 0,
+                ch === 'C' ? corpo : detalhe);
+        }
+    }
 
     return t;
 }

package/lib/memoria-conversa.js

@@ -115,10 +115,33 @@ function paraEnviar(memoria, history) {
 }
 
 /** Quanto este jeito economiza — para o /status e para o teste provarem. */
+/* ── O QUANTO DA CONVERSA JÁ ESTÁ NA MESA ────────────────────────────────
+ * A barra do terminal mostra isso em porcentagem, e a porcentagem precisa de
+ * um teto para ser porcentagem DE alguma coisa.
+ *
+ * O teto de verdade é do servidor e muda com o modelo e com o minuto (ele
+ * divide o orçamento entre prompt, ferramentas e conversa a cada pedido). O
+ * CLI não vê esse número, e fingir que vê seria pior que não mostrar: a barra
+ * diria 20% no exato momento em que o pedido não coubesse.
+ *
+ * Então o teto aqui é declarado e é DA CONVERSA: quanto de histórico vale a
+ * pena carregar antes de resumir. É uma régua honesta — quem chega perto de
+ * 100% está mesmo com a conversa pesada, e `/compact` resolve. */
+const TETO_CONVERSA = 4000;
+
+function usoDoContexto(memoria, history) {
+    const tokens = tokensDe(paraEnviar(memoria, history));
+    return {
+        tokens,
+        teto: TETO_CONVERSA,
+        pct: Math.min(999, Math.round((tokens / TETO_CONVERSA) * 100)),
+    };
+}
+
 function economia(memoria, history) {
     const cheio = tokensDe((history || []).slice(-20));
     const enxuto = tokensDe(paraEnviar(memoria, history));
     return { cheio, enxuto, poupado: Math.max(0, cheio - enxuto) };
 }
 
-module.exports = { nova, pendentes, precisaResumir, atualizar, paraEnviar, economia, tokensDe, inicioSeguro, CRUAS, LIMITE_TOKENS };
+module.exports = { nova, pendentes, usoDoContexto, TETO_CONVERSA, precisaResumir, atualizar, paraEnviar, economia, tokensDe, inicioSeguro, CRUAS, LIMITE_TOKENS };