primocode 9.0.0 → 9.2.0

package/README.md

@@ -1,4 +1,4 @@
-# PrimoCode v9.0.0
+# PrimoCode v9.2.0
 
 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 v9.0.0
+ ▐▛███▜▌   Primo Code v9.2.0
 ▝▜█████▛▘  Bem-vindo de volta, Joel
   ▘▘ ▝▝    ~/primocode  · /dir <pasta> muda
 ```
@@ -33,25 +33,19 @@ Em uma frase: **é o poder de um agente de código no terminal, em português, c
 
 ## Instalação
 
-**macOS / Linux / WSL** — um comando, e ele resolve tudo (inclusive instalar o Node, se faltar):
-
-```bash
-curl -fsSL https://raw.githubusercontent.com/ConectaPrimoAI/primocode/main/install.sh | bash
-```
-
-**Windows** — baixe o repositório e rode:
-
-```cmd
-install.cmd
-```
-
-Já tem Node 18.17+? Então basta:
-
 ```bash
 npm install -g primocode
 ```
 
-Requer **Node.js 18.17+**. O CLI não tem dependências — só a stdlib do Node, por isso instala em segundos.
+Requer **Node.js 18.17+**. O CLI não tem dependência nenhuma — só a stdlib do
+Node — e por isso instala em segundos. Depois é só `primocode`: ele abre o
+login no navegador e, voltando, está pronto.
+
+Não tem Node? Instale em [nodejs.org](https://nodejs.org) e repita o comando
+acima. Quem já clonou este repositório pode usar os instaladores que moram
+aqui (`install.sh` no macOS/Linux/WSL, `install.cmd` no Windows): eles detectam
+o Node, oferecem instalar, e apontam o npm para `~/.npm-global` em vez da pasta
+do sistema — que é o que evita o `EACCES` da tabela abaixo.
 
 ### Se der erro
 

package/bin/primocode.js

@@ -151,7 +151,8 @@ const SLASH_COMANDOS = [
     ['/account', 'sua conta, plano e computadores conectados'],
     ['/chats', 'suas conversas salvas, as mesmas do app e do celular'],
     ['/logout', 'desconecta este computador da conta'],
-    ['/voice', 'o Primo Code em modo voz: você fala, ele faz'],
+    ['/voice', 'fica ouvindo em segundo plano — diga "ei, primo" e a orb aparece'],
+    ['/voice parar', 'desliga o modo voz e fecha o microfone'],
     ['/skills', 'o que ele sabe fazer bem — ligue e desligue'],
     ['/marketplace', 'a tela das skills: navegue, ligue, crie'],
     ['/install-skill', 'instala uma skill de um arquivo'],
@@ -966,6 +967,11 @@ async function comprimirConversa(forcado = false) {
 // na tela depois de o usuário ter mandado parar.
 let chatEmVoo = null;
 
+/* O ouvinte de voz em segundo plano.
+   Um por sessão: dois processos disputando o mesmo microfone dão um vazio
+   intermitente que parece defeito de hardware e não é. */
+let vozEmEspera = null;
+
 async function runChat(promptForModel, userTextForMemory) {
     chatEmVoo = new AbortController();
     const sp = new Spinner(ui.PENSANDO).start();
@@ -1405,6 +1411,24 @@ async function handleSlash(text) {
          * garantia de que um deles está errado.
          */
         case 'voice': case 'voz': {
+            /* ── /voice PARA ─────────────────────────────────────────────
+               Encerrar é o primeiro caso tratado de propósito: quem quer
+               desligar o microfone quer desligar AGORA, e não deve esbarrar
+               em checagem de dependência nem em download de modelo. */
+            if (/^(parar|stop|off|sair)$/i.test((rest || '').trim())) {
+                if (!vozEmEspera) { console.log(c.muted('  O modo voz não está ligado.')); break; }
+                try { vozEmEspera.kill(); } catch {}
+                vozEmEspera = null;
+                console.log(c.muted('  Modo voz desligado. O microfone fechou.'));
+                break;
+            }
+
+            if (vozEmEspera) {
+                console.log(c.muted('  O modo voz já está ouvindo. Diga "ei, primo".'));
+                console.log(c.dim('  /voice parar desliga.'));
+                break;
+            }
+
             const pronto = vozModo.conferir();
             if (!pronto.ok && !pronto.instalavel) {
                 console.log(c.err(`  ${pronto.error}`));
@@ -1430,29 +1454,59 @@ async function handleSlash(text) {
                 const conferido = vozModo.conferir();
                 if (!conferido.ok) {
                     console.log(c.err(`  ainda falta: ${conferido.error}`));
-                    if (conferido.comoResolver) console.log(c.muted(`  ${conferido.comoResolver}`));
                     break;
                 }
             }
 
             const py = (pronto.ok ? pronto : vozModo.conferir()).python;
+
+            /* ── O RECONHECEDOR LOCAL ────────────────────────────────────
+               Ele é o que permite o microfone ficar aberto sem o áudio sair
+               da máquina: o nome é reconhecido AQUI, e só depois disso a
+               frase viaja. São ~31 MB, uma vez, e ficam em ~/.primocode.
+
+               Se a pessoa recusar, o modo voz ainda abre — mas já ouvindo,
+               sem espera. O que NÃO acontece em hipótese nenhuma é cair para
+               "manda tudo para o servidor o dia inteiro": isso seria trocar
+               a privacidade dela por conveniência sem perguntar. */
+            const espera = await vozModo.conferirEspera(py);
+            let esperando = espera.ok;
+            if (!espera.ok && espera.baixavel) {
+                console.log('');
+                console.log('  ' + c.muted('Para ficar ouvindo só o nome, sem mandar áudio para lugar nenhum,'));
+                console.log('  ' + c.muted('ele precisa do reconhecedor local — ') + c.dim('~31 MB, uma vez.'));
+                if (await confirm('Baixar agora?')) {
+                    const sp = new Spinner('baixando o reconhecedor').start();
+                    const r = await vozModo.baixarEspera(py);
+                    sp.stop();
+                    if (r.ok) esperando = true;
+                    else {
+                        console.log(c.err(`  não deu: ${r.error}`));
+                        if (r.comoResolver) console.log(c.dim(`  ${r.comoResolver}`));
+                    }
+                }
+            } else if (!espera.ok && espera.error) {
+                console.log(c.dim(`  ${espera.error}`));
+            }
+
             console.log('');
             console.log('  ' + c.bold(c.brand('Primo Code Voice')));
-            console.log('  ' + c.muted('É só falar. A orb responde: ')
-                + c.dim('parada espera · pulsa ouvindo · respira pensando · brilha falando'));
-            console.log('  ' + c.dim('Falar por cima corta a resposta · Esc ou fechar a janela encerra'));
+            if (esperando) {
+                console.log('  ' + c.muted('Ouvindo em segundo plano. Diga ') + c.white('"ei, primo"') + c.muted(' e a orb aparece.'));
+                console.log('  ' + c.dim('Nada sai da máquina até você chamar · /voice parar desliga'));
+            } else {
+                console.log('  ' + c.muted('É só falar. A orb responde: ')
+                    + c.dim('parada espera · pulsa ouvindo · respira pensando · brilha falando'));
+                console.log('  ' + c.dim('Falar por cima corta a resposta · /voice parar desliga'));
+            }
             console.log('');
 
-            // A caixa de digitar sai da frente: quem está no modo voz não
-            // está digitando, e uma caixa piscando embaixo é ruído.
-            if (rl && rl.suspender) rl.suspender();
-            sliderAtivo = true;
-
-            const r = await vozModo.abrir({
+            const sessao = vozModo.abrir({
                 python: py,
                 servidor: state.config.server,
                 token: state.config.token,
                 voz: state.config.voz || 'antonio',
+                esperando,
                 mostrar: (texto, deErro) => {
                     if (deErro) console.log('  ' + c.dim(texto));
                     else console.log('  ' + c.brand('❯ ') + c.white(texto));
@@ -1485,10 +1539,17 @@ async function handleSlash(text) {
                 },
             });
 
-            sliderAtivo = false;
-            if (rl && rl.retomar) rl.retomar();
-            if (!r.ok) console.log(c.err(`  o modo voz fechou: ${r.error}`));
-            else console.log(c.muted('  Modo voz encerrado.'));
+            /* O TERMINAL CONTINUA SEU.
+               Aqui NÃO se espera o fim. Era isso que obrigava a digitar
+               /voice antes de cada pedido: o comando bloqueava o prompt, e a
+               única forma de voltar a digitar era encerrar o modo voz. Agora
+               ele vive ao lado — a pessoa fala quando quiser e digita quando
+               quiser, sem desligar um para usar o outro. */
+            vozEmEspera = sessao.processo;
+            sessao.pronto.then((r) => {
+                vozEmEspera = null;
+                if (r && !r.ok) console.log(c.err(`  o modo voz fechou: ${r.error}`));
+            });
             break;
         }
 
@@ -1971,6 +2032,18 @@ async function main() {
     function sayBye() {
         if (saidBye) return;
         saidBye = true;
+
+        /* O MICROFONE FECHA JUNTO.
+           O ouvinte de voz é um processo filho, e filho no POSIX não morre
+           porque o pai saiu: ficaria um Python segurando o microfone depois
+           de o terminal fechar — sem janela, sem jeito de desligar a não ser
+           pelo gerenciador de tarefas, e com a luzinha da câmera do lado
+           acesa. Matar aqui é o que faz "fechei o terminal" significar
+           "fechei tudo". */
+        if (vozEmEspera) {
+            try { vozEmEspera.kill(); } catch { /* já morreu */ }
+            vozEmEspera = null;
+        }
         // O último turno pode ainda estar subindo — gravar é de propósito
         // solto, para não segurar o prompt. Fechar o terminal em cima dele
         // perderia justamente a resposta que a pessoa acabou de ler, e ela

package/lib/act.js

@@ -539,7 +539,7 @@ async function runAct(userPrompt, opts) {
      * Num subagente não entra: ele já está fazendo uma parte de um plano, e
      * um diretor dentro do diretor é uma volta a mais para o mesmo lugar. */
     if (!subagent && profundidade === 0) {
-        const producao = require('./diretor.js').precisaDeProducao(pedido);
+        const producao = require('./estudio/diretor.js').precisaDeProducao(pedido);
         if (producao.producao) {
             messages.push({ role: 'system', content:
                 'ESTE PEDIDO É DE PRODUÇÃO AUDIOVISUAL. Antes de criar qualquer peça, chame '
@@ -1108,7 +1108,7 @@ async function rodarDiretor(args, ctx) {
         return { ok: false, error: 'Recusado: o diretor não roda dentro de um subagente. '
             + 'Produza com o plano que você já recebeu.' };
     }
-    const diretor = require('./diretor.js');
+    const diretor = require('./estudio/diretor.js');
     const correr = async (prompt, rotulo) => {
         if (PARAR) return '';
         fala.agente('Diretor', rotulo, profundidade);

package/lib/boas-vindas.js

@@ -122,8 +122,12 @@ async function rodar({ perguntar, mostrar, cores: c, interativo = true,
         return { liberado: false, motivo: 'sem-plano', plano };
     }
 
-    mostrar('');
-    mostrar(c.ok('  Conta liberada.') + c.muted(`  Plano ${plano}.`));
+    /* Nada de "Conta liberada." na abertura.
+       Estar logado é o estado NORMAL do produto — anunciar isso toda vez é
+       ruído, e ruído no primeiro instante empurra para baixo o que importa,
+       que é a caixa de digitar. O selo do plano continua existindo onde quem
+       procura vai olhar (/account, /status); a abertura só diz alguma coisa
+       quando há algo a resolver. */
 
     /* Não há etapa 3. O que vinha aqui era a escolha do provedor de IA, e
        ela morreu junto com o `/claude` e o `/gpt`: a API já vem com o
@@ -133,9 +137,13 @@ async function rodar({ perguntar, mostrar, cores: c, interativo = true,
     const primeira = !jaEscolheu();
     if (primeira) marcar({ plano });
 
-    mostrar('');
-    mostrar(c.muted(primeira ? '  Tudo pronto. Pode pedir a primeira coisa.'
-        : '  Pode pedir.'));
+    /* Na primeira vez a frase serve: a pessoa acabou de instalar e não sabe
+       que já pode pedir. Da segunda em diante ela é só mais uma linha entre
+       a pessoa e o cursor. */
+    if (primeira) {
+        mostrar('');
+        mostrar(c.muted('  Tudo pronto. Pode pedir a primeira coisa.'));
+    }
     mostrar('');
     return { liberado: true, plano, primeira, perguntou: false };
 }

package/lib/catalogo.js

@@ -206,4 +206,43 @@ function escreveArquivo(tool) {
     return ESCREVEM.has(tool);
 }
 
-module.exports = { GRUPOS, TODAS, ESCREVEM, escreveArquivo };
+
+/**
+ * As ferramentas de nome mais parecido com o que foi chamado.
+ *
+ * Serve a um caso só, e ele é real: o modelo chamou uma tool que não existe.
+ * Isso acontece quando a lista que o servidor oferece diverge deste catálogo
+ * — foi o que houve quando o Estúdio trocou de vocabulário e o servidor
+ * continuou oferecendo `studio_criar` e `studio_listar`. Sem esta lista, a
+ * resposta ao modelo era "Tool não implementada", ele não tinha como saber o
+ * que existe, e dizia ao usuário que a ferramenta "não está disponível".
+ *
+ * A semelhança é por prefixo e por pedaço de nome, não por distância de
+ * edição: os erros reais são de FAMÍLIA ("studio_criar" quando o certo é
+ * "estudio_plano"), não de digitação.
+ */
+function parecidasCom(nome) {
+    const alvo = String(nome || '').toLowerCase().replace(/^estudio_|^studio_/, '');
+    const familia = /^e?studio_/.test(String(nome || '').toLowerCase());
+    const pontos = TODAS.map((t) => {
+        let p = 0;
+        if (familia && /^estudio_|^planejar_/.test(t)) p += 3;
+        const semPrefixo = t.replace(/^estudio_/, '');
+        if (semPrefixo === alvo) p += 10;
+        else if (semPrefixo.includes(alvo) || alvo.includes(semPrefixo)) p += 5;
+        // pedaços em comum (criar/listar/plano/midia…)
+        for (const parte of alvo.split('_')) {
+            if (parte.length >= 4 && t.includes(parte)) p += 2;
+        }
+        return { t, p };
+    }).filter((x) => x.p > 0).sort((a, b) => b.p - a.p);
+    // Sem nada parecido, a resposta honesta é o grupo inteiro a que ele
+    // provavelmente queria chegar — melhor que uma lista vazia.
+    if (!pontos.length) {
+        return familia ? TODAS.filter((t) => /^estudio_|^planejar_/.test(t)) : TODAS.slice(0, 8);
+    }
+    return pontos.slice(0, 6).map((x) => x.t);
+}
+
+module.exports = {
+    parecidasCom, GRUPOS, TODAS, ESCREVEM, escreveArquivo };

package/lib/entrada.js

@@ -93,7 +93,7 @@ function montar(e) {
     const colunas = Math.max(24, Math.min(e.colunas || 80, 200));
     const largura = colunas - 1;    // a última coluna fica livre: escrever nela
                                     // faz o terminal quebrar a linha sozinho
-    const w = Math.max(8, largura - 6);   // │ + espaço + recuo(2) + … + espaço + │
+    const w = Math.max(8, largura - 3);   // espaço + '❯ ' — e mais nada à direita
 
     const cursor = Math.max(0, Math.min(e.cursor | 0, String(e.texto).length));
     const linhas = quebrar(e.texto, w);
@@ -108,9 +108,16 @@ function montar(e) {
         if (cursor >= l.de && cursor <= fim) { cursorLinha = i; cursorColuna = cursor - l.de; }
     }
 
+    /* DUAS RÉGUAS, NÃO UMA CAIXA.
+       Era uma caixa fechada — cantos e barras laterais. O Claude Code, que é a
+       referência pedida, usa só a linha de cima e a de baixo, e a diferença
+       não é gosto: a barra lateral direita obriga a reservar duas colunas em
+       toda linha e a preencher o resto com espaço, e é ela que faz o texto
+       colado parecer desalinhado quando o terminal é estreito. Sem as laterais
+       o campo ganha as colunas de volta e a emenda some. */
     const out = [];
-    const regua = c.dim(BORDA.h.repeat(largura - 2));
-    out.push(c.dim(BORDA.ne) + regua + c.dim(BORDA.no));
+    const regua = c.dim(BORDA.h.repeat(largura));
+    out.push(regua);
 
     const vazio = !String(e.texto).length;
     linhas.forEach((l, i) => {
@@ -124,10 +131,12 @@ function montar(e) {
             conteudo += c.dim(e.fantasma);
         }
         if (i === 0 && vazio && e.vazio) conteudo = c.dim(e.vazio);
-        out.push(c.dim(BORDA.v) + ' ' + marca + encher(conteudo, w) + ' ' + c.dim(BORDA.v));
+        // Sem `encher`: sem barra à direita não há nada para alinhar, e o
+        // espaço sobrando só apagaria o que estivesse embaixo.
+        out.push(' ' + marca + conteudo);
     });
 
-    out.push(c.dim(BORDA.se) + regua + c.dim(BORDA.so));
+    out.push(regua);
 
     // ── o menu dos comandos ──────────────────────────────────────────────
     // Fica ABAIXO da caixa, não dentro: dentro, ele empurraria o campo de
@@ -157,8 +166,8 @@ function montar(e) {
 
     return {
         linhas: out,
-        cursorLinha: 1 + cursorLinha,                   // +1 pela borda de cima
-        cursorColuna: 1 + 1 + 2 + cursorColuna,         // │ + espaço + recuo
+        cursorLinha: 1 + cursorLinha,                   // +1 pela régua de cima
+        cursorColuna: 1 + 2 + cursorColuna,             // espaço + '❯ '
     };
 }
 
@@ -221,10 +230,27 @@ class Entrada extends EventEmitter {
         this._stdoutOriginal = process.stdout.write;
         const eu = this;
         process.stdout.write = function (texto, ...resto) {
-            if (eu._pintando || !eu.desenhado) return eu._stdoutOriginal.call(this, texto, ...resto);
+            if (eu._pintando) return eu._stdoutOriginal.call(this, texto, ...resto);
             eu._apagar();
             const r = eu._stdoutOriginal.call(this, texto, ...resto);
-            eu._desenhar();
+            /* ── O TEXTO QUE CHEGA EM PEDAÇOS ────────────────────────────
+               A resposta do chat sai em fluxo: dezenas de `write` pequenos,
+               nenhum deles terminando em quebra de linha. Cada um deixa o
+               cursor NO MEIO da linha — e o desenho da caixa começa com
+               "\r\x1b[0J", que volta ao início da linha e limpa dali para
+               baixo. Ou seja: redesenhar ali apagava o pedaço que acabara de
+               ser escrito, e o seguinte apagava o próximo.
+
+               O efeito para quem usa era o pior possível: no modo chat a
+               mensagem ia, o modelo respondia, e a tela não mostrava NADA —
+               parecia que o programa tinha ignorado a pessoa.
+
+               Então a caixa espera a linha fechar. Enquanto o cursor estiver
+               no meio de uma, ela não é redesenhada; quando a quebra de linha
+               chega (o `fechar()` do fluxo manda uma), ela volta. */
+            const t = String(texto == null ? '' : texto);
+            eu._meiaLinha = t.length > 0 && !t.endsWith('\n');
+            if (!eu._meiaLinha) eu._desenhar();
             return r;
         };
         return this;
@@ -311,6 +337,11 @@ class Entrada extends EventEmitter {
         if (!this.tty || this.suspenso || this.fechado) return;
         const q = this._quadro();
         this._pintando = true;
+        /* Cursor no meio de uma linha (fluxo que ainda não fechou): desce uma
+           antes de desenhar. Vale para quem chama `_desenhar` por fora do
+           embrulho do stdout — `prompt()`, o fim de uma tela suspensa — e é o
+           que garante que a caixa nunca começa em cima de texto pela metade. */
+        if (this._meiaLinha) { this.escreverCru('\n'); this._meiaLinha = false; }
         // `\x1b[0J` limpa daqui até o fim da tela: sem isso, um quadro mais
         // curto que o anterior (menu que fechou) deixa lixo embaixo.
         this.escreverCru('\r\x1b[0J' + q.linhas.join('\n'));

package/lib/{acervo.js → estudio/acervo.js}

@@ -73,7 +73,7 @@ function buscarJSON(url, { timeout = 15000, cabecalhos = {} } = {}) {
    política deles pede. */
 function agente() {
     let v = '?';
-    try { v = require('../package.json').version; } catch { /* sem package: tanto faz */ }
+    try { v = require('../../package.json').version; } catch { /* sem package: tanto faz */ }
     return `PrimoCode/${v} (https://github.com/parisgroup-ai/primocode)`;
 }
 

package/lib/estudio/assets.js

@@ -58,7 +58,7 @@ function pegar(url, { json = false, binario = false, cabecalhos = {} } = {}) {
             path: u.pathname + u.search,
             headers: {
                 // O Openverse recusa quem não se identifica, e com razão.
-                'User-Agent': 'PrimoCode-Studio/1.0 (+https://github.com/ConectaPrimoAI/primocode)',
+                'User-Agent': 'PrimoCode-Studio/1.0 (+https://www.npmjs.com/package/primocode)',
                 Accept: json ? 'application/json' : '*/*',
                 ...cabecalhos,
             },

package/lib/estudio/identidade.js

@@ -36,8 +36,8 @@ const path = require('path');
 const https = require('https');
 const referencia = require('../referencia.js');
 const assets = require('./assets.js');
-const marca = require('../marca.js');
-const acervo = require('../acervo.js');
+const marca = require('./marca.js');
+const acervo = require('./acervo.js');
 const http = require('http');
 const { URL } = require('url');
 

package/lib/estudio/index.js

@@ -33,7 +33,7 @@ const path = require('path');
 const { spawn } = require('child_process');
 
 const projeto = require('./projeto.js');
-const acervo = require('../acervo.js');
+const acervo = require('./acervo.js');
 const plano = require('./plano.js');
 const remotion = require('./remotion.js');
 const assets = require('./assets.js');

package/lib/{marca.js → estudio/marca.js}

@@ -33,7 +33,7 @@
 
 const fs = require('fs');
 const path = require('path');
-const referencia = require('./referencia.js');
+const referencia = require('../referencia.js');
 
 const GENERICAS_FONTE = /^(sans-serif|serif|monospace|system-ui|-apple-system|blinkmacsystemfont|segoe ui|arial|helvetica( neue)?|roboto|inherit|initial|ui-sans-serif|ui-serif|ui-monospace|apple color emoji|segoe ui emoji|noto color emoji|times new roman|courier new|verdana|tahoma|georgia)$/i;
 

package/lib/estudio/remotion.js

@@ -570,6 +570,20 @@ function fontesCSS(plano) {
  * `npm install` roda uma vez por projeto e demora minutos — é o preço do
  * Remotion, e está dito no README. Daí em diante, só o render.
  */
+/**
+ * Cita um argumento para a linha de comando do cmd.exe.
+ *
+ * Só serve ao Windows, e só porque o `shell: true` é obrigatório ali (o Node
+ * recusa spawnar npm.cmd/npx.cmd sem ele desde a correção do CVE-2024-27980).
+ * Quem não tem espaço nem metacaractere passa intacto: citar tudo deixaria a
+ * linha ilegível no log sem ganhar nada.
+ */
+function citarWin(a) {
+    const t = String(a);
+    if (!/[\s&|<>^"()]/.test(t)) return t;
+    return '"' + t.replace(/"/g, '""') + '"';
+}
+
 function renderizar({ raiz, saida, minutos = 30, aoFalar = () => {} }) {
     return new Promise((resolve) => {
         const temNodeModules = fs.existsSync(path.join(raiz, 'node_modules'));
@@ -582,7 +596,17 @@ function renderizar({ raiz, saida, minutos = 30, aoFalar = () => {} }) {
             aoFalar(i === 0 && !temNodeModules
                 ? 'instalando o Remotion nesta pasta (uma vez só, alguns minutos)'
                 : 'renderizando quadro a quadro');
-            const p = spawn(cmd, args, { cwd: raiz, shell: process.platform === 'win32' });
+            /* NO WINDOWS O `shell: true` NÃO CITA NADA.
+               Ele monta a linha do cmd.exe concatenando os argumentos crus, e
+               o `saida` é um caminho de arquivo que quase sempre tem espaço
+               (C:\Users\Joel Silva\primocode\...\saida\video.mp4). Sem
+               aspas, aquilo vira dois argumentos e o render falha — ou, pior,
+               escreve num lugar que ninguém pediu.
+               O `shell: true` não dá para tirar: desde a correção do
+               CVE-2024-27980 o Node recusa spawnar npm.cmd/npx.cmd sem shell.
+               Então as aspas entram na mão, só onde o shell existe. */
+            const citados = process.platform === 'win32' ? args.map(citarWin) : args;
+            const p = spawn(cmd, citados, { cwd: raiz, shell: process.platform === 'win32' });
             let erro = '';
             p.stderr.on('data', (d) => { erro += d.toString().slice(0, 2000); });
             p.stdout.on('data', (d) => {
@@ -597,7 +621,21 @@ function renderizar({ raiz, saida, minutos = 30, aoFalar = () => {} }) {
                 }
                 correr(i + 1);
             });
-            p.on('error', (e) => { clearTimeout(relogio); resolve({ ok: false, error: e.message }); });
+            p.on('error', (e) => {
+                clearTimeout(relogio);
+                /* "spawn npx ENOENT" não diz nada a quem instalou pelo ícone.
+                   Aplicativo aberto pela interface gráfica não herda o PATH do
+                   terminal: o node vem por caminho absoluto (lib/instalar-app.js),
+                   mas o npm e o npx não estão em lugar nenhum que ele enxergue. */
+                if (e.code === 'ENOENT') {
+                    return resolve({ ok: false,
+                        error: `não achei o "${cmd}" nesta máquina — o Remotion precisa dele para renderizar.`,
+                        comoResolver: 'instale o Node.js completo em nodejs.org (o npm vem junto). '
+                            + 'Se ele já está instalado e isto apareceu com o PrimoCode aberto pelo ícone, '
+                            + 'abra pelo terminal: o aplicativo não herda o PATH.' });
+                }
+                resolve({ ok: false, error: e.message });
+            });
         };
         correr(0);
     });

package/lib/fala.js

@@ -38,6 +38,7 @@
 'use strict';
 
 const { c, actionHeader, friendlyError } = require('./ui');
+const markdown = require('./markdown.js');
 
 /* Até este tamanho, o texto que o modelo escreve antes de chamar uma tool é
    guardado e sai de uma vez, como pensamento. Passou disso sem tool à vista,
@@ -89,10 +90,18 @@ function formatar(texto, marca) {
     return linhas(texto).map((l, i) => (i === 0 ? `${marca} ${c.white(l)}` : `  ${c.white(l)}`)).join('\n');
 }
 
-/** A resposta final, pronta. Espelha o ❯ de quem perguntou. */
+/** A resposta final, pronta. Espelha o ❯ de quem perguntou.
+ *
+ *  Passa pelo desenhador de Markdown pelo mesmo motivo do fluxo: o modelo
+ *  escreve com negrito, lista, tabela e bloco de código, e sem desenhar isso
+ *  a resposta chega com a marcação à mostra. `formatar` continua servindo ao
+ *  que NÃO é resposta do modelo (aviso, erro), que é texto nosso e já vem
+ *  pronto. */
 function resposta(texto) {
     if (!String(texto || '').trim()) return '';
-    const saida = '\n' + formatar(texto, c.brand('●'));
+    const largura = Math.max(40, (process.stdout.columns || 80) - 4);
+    const linhasMd = markdown.renderizar(texto, largura);
+    const saida = '\n' + linhasMd.map((l, i) => (i === 0 ? `${c.brand('●')} ${l}` : `  ${l}`)).join('\n');
     console.log(saida);
     return saida;
 }
@@ -120,15 +129,37 @@ const frase = friendlyError;
  * recuo, para o bloco continuar alinhado ao marcador.
  */
 function fluxo() {
+    /* A resposta do modelo vem em MARKDOWN — é o que ele escreve, e é o que o
+       prompt pede. Antes ela saía crua: "**importante**" aparecia com os
+       asteriscos, a tabela virava um monte de barras desalinhadas e o bloco de
+       código vinha com as três crases à mostra. Quem lia recebia o material
+       bruto e formatava de cabeça.
+
+       O desenho é por LINHA, não no fim: a resposta continua aparecendo
+       enquanto chega. Só a tabela e o bloco de código esperam fechar, porque
+       meia tabela na tela é pior que a tabela um segundo depois. */
     let escreveu = false;
+    const largura = Math.max(40, (process.stdout.columns || 80) - 4);
+    const desenho = markdown.fluxo(largura);
+
+    const sair = (linhas) => {
+        for (const linha of linhas) {
+            if (!escreveu) { process.stdout.write('\n' + c.brand('●') + ' '); escreveu = true; }
+            else process.stdout.write('\n  ');
+            process.stdout.write(linha);
+        }
+    };
+
     return {
         escrever(delta) {
             const t = String(delta || '');
             if (!t) return;
-            if (!escreveu) { process.stdout.write('\n' + c.brand('●') + ' '); escreveu = true; }
-            process.stdout.write(c.white(t.replace(/\n/g, '\n  ')));
+            sair(desenho.pedaco(t));
+        },
+        fechar() {
+            sair(desenho.fim());
+            if (escreveu) process.stdout.write('\n');
         },
-        fechar() { if (escreveu) process.stdout.write('\n'); },
         escreveu: () => escreveu,
     };
 }