primocode 9.1.0 → 9.2.1

package/README.md

@@ -1,4 +1,4 @@
-# PrimoCode v9.0.0
+# PrimoCode v9.2.1
 
 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.1
 ▝▜█████▛▘  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/{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/repeticao.js

@@ -33,7 +33,12 @@
 'use strict';
 
 /** Tools cuja resposta é documento fixo — repetir é sempre desperdício. */
-const REFERENCIAS = new Set(['studio_manual', 'studio_spec']);
+/* O documento fixo que NÃO pode encolher na conversa. Eram o manual e a spec
+   do Estúdio antigo; o Estúdio novo não tem manual porque não tem formato a
+   decorar. Quem ocupa esse lugar é a PAUTA do diretor, escrita uma vez, que o
+   produtor relê enquanto monta as cenas — encolhê-la faz o modelo chamar o
+   diretor de novo, que é o laço que isto existe para evitar. */
+const REFERENCIAS = new Set(['planejar_producao', 'estudio_site']);
 
 /** Acima disto, duas buscas são a mesma busca. */
 const LIMITE_SEMELHANCA = 0.6;

package/lib/tools.js

@@ -429,8 +429,9 @@ async function despachar(name, args, ctx) {
                     return {
                         ok: false,
                         error: `"${args.path}" é arquivo de vídeo/áudio, e write_file só escreve TEXTO — isso criaria um arquivo falso que não abre. `
-                            + 'Vídeo se faz no Studio: studio_criar com ferramenta "corte" (leia studio_spec antes). '
-                            + 'O Studio devolve o link "ver" — é ESSE o vídeo. Não use ffmpeg: não é preciso.',
+                            + 'Vídeo se faz no Estúdio: estudio_projeto (criar) → planejar_producao → estudio_plano → '
+                            + 'estudio_render. O render devolve o CAMINHO do arquivo — é esse o vídeo. '
+                            + 'Não monte vídeo com ffmpeg à mão.',
                     };
                 }
                 const filePath = resolveInProject(args.path, projectDir);
@@ -610,14 +611,38 @@ async function despachar(name, args, ctx) {
                    divergir do catálogo daqui, e ela se conserta lá. Mas a rede
                    é o que separa uma tarefa que se recupera de uma que morre
                    com o usuário esperando. */
-                return {
-                    ok: false,
-                    error: `A ferramenta "${name}" não existe.`,
-                    parecidas: catalogo.parecidasCom(name),
-                    comoResolver: 'chame uma das ferramentas que existem de verdade — as "parecidas" '
-                        + 'acima são as de nome mais próximo. Não invente nome de ferramenta, e não '
-                        + 'desista da tarefa por causa disto.',
-                };
+                {
+                    /* O CASO QUE ACONTECE DE VERDADE tem nome: o servidor
+                       está desatualizado e continua oferecendo o Estúdio
+                       antigo (studio_criar, studio_spec…). Visto ao vivo, e a
+                       reação do modelo foi a pior possível: chutou nomes de
+                       outro produto (`repo_browser.read_file`), tentou
+                       escrever um .mp4 com write_file, e desistiu com "parei
+                       sem concluir" — sem nunca dizer ao usuário qual era o
+                       problema.
+
+                       Então a resposta separa os dois casos. Para o Estúdio
+                       velho ela EXPLICA o que houve e manda diagnosticar em
+                       voz alta se as novas não estiverem na lista dele: um
+                       "o servidor está desatualizado" é acionável; um "parei
+                       sem concluir" não é. */
+                    const velhoEstudio = /^studio_/.test(String(name));
+                    return {
+                        ok: false,
+                        error: `A ferramenta "${name}" não existe.`,
+                        parecidas: catalogo.parecidasCom(name),
+                        comoResolver: velhoEstudio
+                            ? 'O Estúdio foi TROCADO: studio_* não existe mais. As ferramentas de hoje são '
+                              + 'planejar_producao, estudio_projeto, estudio_plano, estudio_midia, estudio_narrar, '
+                              + 'estudio_video, estudio_render e estudio_site. Use-as. '
+                              + 'Se ELAS não estiverem na sua lista de ferramentas, o servidor está desatualizado: '
+                              + 'PARE de tentar outros nomes e diga isso ao usuário em uma frase — é o que ele '
+                              + 'precisa saber para resolver.'
+                            : 'Chame uma das ferramentas que existem de verdade; as "parecidas" acima são as de '
+                              + 'nome mais próximo. NÃO invente nome de ferramenta e não tente variações — se '
+                              + 'nenhuma servir, diga ao usuário o que faltou, em vez de desistir calado.',
+                    };
+                }
         }
     }
 }

package/lib/ui.js

@@ -295,12 +295,18 @@ const ROTULOS = {
         desktop_drag:'Desktop·drag', desktop_type:'Desktop·type', desktop_key:'Desktop·key',
         desktop_scroll:'Desktop·scroll', desktop_size:'Desktop·size',
         desktop_double_click:'Desktop·2click', desktop_open_app:'Desktop·app',
-        studio_manual:'Estúdio·manual', studio_spec:'Estúdio·spec', studio_criar:'Estúdio·criar',
-        studio_ler:'Estúdio·ler', studio_atualizar:'Estúdio·ajustar', studio_listar:'Estúdio·lista',
-        studio_versoes:'Estúdio·histórico',
+        /* Os nomes do Estúdio ATUAL. Os antigos (studio_manual, studio_spec,
+           studio_criar…) saíram daqui de propósito: enquanto estavam, uma
+           chamada a ferramenta que não existe mais aparecia na tela com
+           rótulo bonito ("Estúdio·spec corte"), como se fosse trabalho
+           legítimo — e só a linha de baixo revelava que tinha falhado. */
+        planejar_producao:'Diretor', estudio_projeto:'Estúdio·projeto',
+        estudio_plano:'Estúdio·plano', estudio_narrar:'Estúdio·narração',
+        estudio_video:'Estúdio·vídeo', estudio_render:'Estúdio·render',
+        estudio_site:'Estúdio·marca',
         desktop_windows:'Desktop·janelas', desktop_focus:'Desktop·foco',
         desktop_elements:'Desktop·elementos', desktop_click_element:'Desktop·click',
-    studio_midia:'Estúdio·mídia', studio_analisar:'Estúdio·analisar', construir_app:'Construir',
+    estudio_midia:'Estúdio·mídia', construir_app:'Construir',
     remember_general:'Lembrar',
 };
 

package/lib/voz.js

@@ -169,10 +169,13 @@ function instalar(py, pacotes, aoFalar = () => {}) {
  * @param {string} op.voz
  * @param {(texto:string)=>Promise<string>} op.pensar   o agente de verdade
  * @param {(texto:string)=>void} op.mostrar             o que aparece no terminal
+ * @param {boolean} op.esperando                        fica dormindo até ouvir o nome
+ * @returns {{processo, pronto: Promise}}               o processo, e a promessa do fim
  */
-function abrir({ python: py, servidor, token, voz, pensar, mostrar = () => {} }) {
-    return new Promise((resolve) => {
-        const p = spawn(py, ['-m', 'primo_voz'], {
+function abrir({ python: py, servidor, token, voz, pensar, mostrar = () => {}, esperando = false }) {
+    let p;
+    const pronto = new Promise((resolve) => {
+        p = spawn(py, ['-m', 'primo_voz'], {
             cwd: PASTA,
             env: {
                 ...process.env,
@@ -180,6 +183,8 @@ function abrir({ python: py, servidor, token, voz, pensar, mostrar = () => {} })
                 PRIMOCODE_SERVER: servidor,
                 PRIMOCODE_TOKEN: token || '',
                 PRIMOCODE_VOZ: voz || 'antonio',
+                // Dormir até ouvir o nome, em vez de já entrar ouvindo.
+                PRIMOCODE_VOZ_ESPERA: esperando ? '1' : '',
                 PYTHONUNBUFFERED: '1',
             },
         });
@@ -234,6 +239,101 @@ function abrir({ python: py, servidor, token, voz, pensar, mostrar = () => {} })
         p.on('close', () => resolve({ ok: true }));
         p.on('error', (e) => resolve({ ok: false, error: e.message }));
     });
+
+    /* O PROCESSO VOLTA JUNTO COM A PROMESSA, e não é preciosismo de API.
+       No modo de espera o /voice não bloqueia o terminal: ele sobe o ouvinte
+       e devolve o prompt. Quem chamou precisa de um jeito de ENCERRAR aquilo
+       depois (/voice parar, ou a saída do programa) — e, sem o handle, o
+       único jeito seria matar pelo nome do processo, que atropela outra
+       sessão do PrimoCode aberta na mesma máquina. */
+    return { processo: p, pronto };
+}
+
+
+/* ── O RECONHECEDOR LOCAL DO NOME ────────────────────────────────────────
+ *
+ * Duas funções, e a razão de existirem é a mesma: no modo de espera o
+ * microfone fica ABERTO o tempo todo, e há dois jeitos de saber se alguém
+ * disse "ei, primo" — mandar tudo o que ele ouve para um servidor, ou
+ * reconhecer a palavra aqui dentro.
+ *
+ * O primeiro é mais fácil de escrever e significa a conversa da casa inteira
+ * subindo para a rede o dia inteiro. O segundo custa ~31 MB de modelo, uma
+ * vez. Não é escolha difícil, e não é escolha que o programa faça sozinho:
+ * `conferirEspera` só RESPONDE o que falta; quem pergunta à pessoa é o CLI.
+ */
+function conferirEspera(py) {
+    const perguntar = `
+import json, sys
+sys.path.insert(0, ${JSON.stringify(PASTA)})
+try:
+    from primo_voz import desperta
+except Exception as e:
+    print(json.dumps({"ok": False, "error": "não consegui ler o módulo: %s" % e})); raise SystemExit
+try:
+    import vosk  # noqa: F401
+    temVosk = True
+except ImportError:
+    temVosk = False
+print(json.dumps({
+    "ok": bool(temVosk and desperta.tem_modelo()),
+    "temVosk": temVosk,
+    "temModelo": desperta.tem_modelo(),
+    "onde": str(desperta.caminho_do_modelo()),
+}))
+`;
+    try {
+        const saida = execFileSync(py, ['-c', perguntar],
+            { stdio: ['ignore', 'pipe', 'pipe'], timeout: 30000 }).toString();
+        const r = JSON.parse(saida.trim().split('\n').pop());
+        if (r.ok) return { ok: true };
+        // Falta só o modelo (ou o vosk, que o pip resolve): dá para oferecer.
+        return { ok: false, baixavel: true, temVosk: r.temVosk, onde: r.onde,
+            error: r.error || 'o reconhecedor local do nome não está instalado' };
+    } catch (e) {
+        return { ok: false, baixavel: false,
+            error: `não consegui conferir o reconhecedor: ${String(e.message || e).slice(-160)}` };
+    }
+}
+
+/** Instala o vosk (se faltar) e baixa o modelo. Uma vez, ~31 MB. */
+function baixarEspera(py) {
+    return new Promise((resolve) => {
+        const script = `
+import json, subprocess, sys
+sys.path.insert(0, ${JSON.stringify(PASTA)})
+try:
+    import vosk  # noqa: F401
+except ImportError:
+    # As mesmas estratégias do narrar.py: o pip do sistema recusa instalar
+    # em Debian/Ubuntu e no Homebrew (PEP 668), e uma tentativa só, calada,
+    # é a falha que ninguém vê.
+    for args in (["-m","pip","install","--user","--quiet","vosk"],
+                 ["-m","pip","install","--user","--quiet","--break-system-packages","vosk"],
+                 ["-m","pip","install","--quiet","vosk"],
+                 ["-m","pip","install","--quiet","--break-system-packages","vosk"]):
+        r = subprocess.run([sys.executable] + args, capture_output=True)
+        if r.returncode == 0:
+            break
+    try:
+        import vosk  # noqa: F401
+    except ImportError as e:
+        print(json.dumps({"ok": False, "error": "não consegui instalar o vosk: %s" % e}))
+        raise SystemExit
+from primo_voz import desperta
+print(json.dumps(desperta.baixar_modelo()))
+`;
+        const p = spawn(py, ['-c', script]);
+        let fora = '';
+        let erro = '';
+        p.stdout.on('data', (d) => { fora += d.toString(); });
+        p.stderr.on('data', (d) => { erro += d.toString(); });
+        p.on('close', () => {
+            try { resolve(JSON.parse(fora.trim().split('\n').pop())); }
+            catch { resolve({ ok: false, error: erro.slice(-300).trim() || 'o download não devolveu resposta' }); }
+        });
+        p.on('error', (e) => resolve({ ok: false, error: e.message }));
+    });
 }
 
-module.exports = { conferir, instalar, abrir, python, COMO_FALAR, PASTA };
+module.exports = { conferir, instalar, abrir, conferirEspera, baixarEspera, python, COMO_FALAR, PASTA };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "primocode",
-  "version": "9.1.0",
+  "version": "9.2.1",
   "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/entrada.test.js && node test/transparencia.test.js && node test/permissao.test.js && node test/skills.test.js && node test/estudio.test.js && node test/voz.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/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/pipeline.test.js && node test/app.test.js && node test/aplicativo.test.js && node test/conta.test.mjs && node test/nuvem.test.js && node test/prazo.test.js && node test/primeira-vez.test.js && node test/janela.test.js && node test/pareamento.test.js && node test/fala.test.js && node test/especialistas.test.js && node test/empurrao.test.js && node test/terminal-novo.test.js && node test/markdown.test.js"
+    "test": "node test/tools.test.js && node test/ui.test.js && node test/entrada.test.js && node test/transparencia.test.js && node test/permissao.test.js && node test/skills.test.js && node test/estudio.test.js && node test/voz.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/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/pipeline.test.js && node test/app.test.js && node test/aplicativo.test.js && node test/conta.test.mjs && node test/nuvem.test.js && node test/prazo.test.js && node test/primeira-vez.test.js && node test/janela.test.js && node test/pareamento.test.js && node test/fala.test.js && node test/especialistas.test.js && node test/empurrao.test.js && node test/terminal-novo.test.js && node test/markdown.test.js && node test/coerencia.test.js"
   },
   "engines": {
     "node": ">=18.17.0"

package/voz/primo_voz/__main__.py

@@ -50,7 +50,7 @@ from pathlib import Path
 AQUI = Path(__file__).resolve().parent
 sys.path.insert(0, str(AQUI.parent))
 
-from primo_voz import escuta, orbe  # noqa: E402
+from primo_voz import desperta, escuta, orbe  # noqa: E402
 
 
 def falar_para_o_node(obj: dict) -> None:
@@ -106,11 +106,34 @@ PS_TOCAR_MP3 = (
 class Voz:
     """A costura: microfone → transcrição → Node → voz → microfone."""
 
-    def __init__(self, servidor: str, token: str, voz_escolhida: str = "antonio"):
+    def __init__(self, servidor: str, token: str, voz_escolhida: str = "antonio",
+                 esperando: bool = False):
         self.servidor = servidor
         self.token = token
         self.voz = voz_escolhida
 
+        # ── MODO DE ESPERA ───────────────────────────────────────────
+        #
+        # Ligado, ele fica dormindo com a orbe escondida até ouvir o nome, e
+        # volta a dormir depois de atender. Desligado (o padrão antigo), ele
+        # já entra ouvindo — que é o certo para quem digitou /voice e vai
+        # falar agora.
+        #
+        # A espera exige o reconhecedor local. Sem ele instalado, não cai
+        # para "mandar tudo para o servidor": cai para o modo de sempre, e
+        # DIZ por quê. Silenciosamente transformar uma coisa na outra seria
+        # abrir o microfone da pessoa para a internet sem ela saber.
+        #
+        self.esperando = bool(esperando)
+        self.desperta = None
+        if self.esperando:
+            self.desperta = desperta.Desperta(ao_despertar=lambda: None)
+            if not self.desperta.pronto:
+                avisar(f"modo de espera indisponível: {self.desperta.motivo} — "
+                       "abrindo no modo normal, já ouvindo.")
+                self.esperando = False
+                self.desperta = None
+
         self.orb = orbe.Orbe(ao_fechar=self.parar)
         self.gravador = escuta.Gravador()
         self.corte = escuta.Corte()
@@ -122,6 +145,19 @@ class Voz:
         self._parar_fala = threading.Event()
         self._do_node = queue.Queue()
 
+    def _esvaziar_blocos(self) -> None:
+        """Joga fora o áudio que está na fila.
+
+        Depois de despertar, os blocos do próprio "ei primo" ainda estão
+        enfileirados — e sem isto eles entram na gravação do PEDIDO, que chega
+        ao agente com o nome colado na frente.
+        """
+        while True:
+            try:
+                self._blocos.get_nowait()
+            except queue.Empty:
+                return
+
     # ── microfone ────────────────────────────────────────────────────────
     def _ao_receber(self, bloco) -> None:
         if not self._vivo:
@@ -153,6 +189,31 @@ class Voz:
             return
 
         while self._vivo:
+            # ── O SONO ───────────────────────────────────────────────
+            # No modo de espera a orbe some e o microfone fica ouvindo SÓ o
+            # nome, aqui dentro, sem nada sair da máquina (ver desperta.py).
+            # Sem isso, o modo de espera seria o microfone da pessoa aberto
+            # para a internet o dia inteiro.
+            if self.esperando and self.desperta is not None:
+                self.orb.esconder()
+                self.desperta.zerar()
+                acordou = False
+                while self._vivo and not acordou:
+                    try:
+                        bloco = self._blocos.get(timeout=0.3)
+                    except queue.Empty:
+                        continue
+                    acordou = self.desperta.alimentar(bloco)
+                if not self._vivo:
+                    break
+                # Chamou: a orbe aparece e ele passa a ouvir o PEDIDO.
+                self.orb.mostrar()
+                self.orb.mudar(estado="ouvindo", nivel=0)
+                # Sem esvaziar a fila, os blocos do próprio "ei primo" entram
+                # na gravação do pedido — e o pedido chega com o nome colado
+                # na frente.
+                self._esvaziar_blocos()
+
             self.orb.mudar(estado="esperando", nivel=0)
             self.gravador.comecar()
 
@@ -362,6 +423,9 @@ def main() -> int:
     servidor = os.environ.get("PRIMOCODE_SERVER", "").strip()
     token = os.environ.get("PRIMOCODE_TOKEN", "").strip()
     voz = os.environ.get("PRIMOCODE_VOZ", "antonio").strip() or "antonio"
+    # O modo de espera vem por variável, como o resto: quem abre este programa
+    # é o /voice do Node, não uma pessoa numa linha de comando.
+    esperando = os.environ.get("PRIMOCODE_VOZ_ESPERA", "") == "1"
 
     if not servidor:
         avisar("falta PRIMOCODE_SERVER — este programa é aberto pelo /voice do PrimoCode.")
@@ -375,7 +439,7 @@ def main() -> int:
                f"{sys.executable} -m pip install sounddevice numpy")
         return 3
 
-    Voz(servidor, token, voz).rodar()
+    Voz(servidor, token, voz, esperando=esperando).rodar()
     return 0
 
 

package/voz/primo_voz/desperta.py

@@ -0,0 +1,195 @@
+"""desperta.py — ouvir o nome, e só o nome, sem mandar áudio para lugar nenhum.
+
+── POR QUE OFFLINE, E POR QUE ISSO NÃO É DETALHE ───────────────────────────
+No modo de espera o microfone fica ABERTO o tempo todo. Existem dois jeitos de
+saber se alguém disse "ei, primo":
+
+  1. Mandar tudo o que o microfone ouve para um servidor transcrever.
+  2. Reconhecer a palavra aqui dentro, sem nada sair da máquina.
+
+O primeiro funciona e é mais simples de escrever. Também significa que TODA
+conversa perto do computador — a ligação, a reunião, a briga em casa — sobe
+para um servidor, o dia inteiro, para que uma vez por hora alguém diga o nome
+do programa. Isso não é uma troca aceitável, e não é decisão que um programa
+toma pelo dono da máquina.
+
+Então é o segundo. O Vosk roda local, o modelo mora no disco da pessoa, e
+NADA sai daqui enquanto o nome não for dito. Depois do nome, sim: a frase vai
+para a transcrição, como no modo normal — mas aí foi a pessoa que chamou.
+
+── A GRAMÁTICA RESTRITA ────────────────────────────────────────────────────
+O reconhecedor é criado sabendo APENAS as palavras de despertar. Não é
+otimização: é o que impede ele de "ouvir" o nome no meio de uma frase
+qualquer. Um reconhecedor livre transcreve tudo e depois se procura a palavra
+no texto — e aí "prima", "primeiro" e "exprimo" acordam o assistente. Com a
+gramática restrita ele só pode devolver uma das palavras da lista ou "[unk]".
+
+Herdado do Jarvis (src/jarvis/core/wake.py), que resolveu isto primeiro; o
+modelo aqui é o de PORTUGUÊS, porque "primo" é palavra portuguesa — ao
+contrário de "Jarvis", que é nome inglês e por isso lá usava o modelo de
+inglês.
+"""
+from __future__ import annotations
+
+import json
+import os
+import threading
+import urllib.request
+import zipfile
+from pathlib import Path
+from typing import Callable, Optional
+
+TAXA = 16000
+
+# Onde o modelo mora. Fora do pacote npm de propósito: são 31 MB, e um pacote
+# que engorda 31 MB para todo mundo por causa de um modo que nem todos usam é
+# um pacote que demora a instalar para todo mundo.
+PASTA_MODELO = Path.home() / ".primocode" / "modelos"
+NOME_MODELO = "vosk-model-small-pt-0.3"
+URL_MODELO = f"https://alphacephei.com/vosk/models/{NOME_MODELO}.zip"
+
+# O que ACORDA. Variantes porque o reconhecedor pequeno erra a vogal átona, e
+# porque as pessoas falam de jeitos diferentes ("ei primo", "oi primo", "ô
+# primo"). O "primo" sozinho entra: dentro da gramática restrita ele não
+# dispara em conversa comum, porque o reconhecedor não transcreve conversa
+# comum — só consegue devolver estas palavras.
+VOCABULARIO = ("primo", "ei", "oi", "olá", "ô")
+DESPERTA = ("primo",)
+
+
+def caminho_do_modelo() -> Path:
+    return PASTA_MODELO / NOME_MODELO
+
+
+def tem_modelo() -> bool:
+    caminho = caminho_do_modelo()
+    return caminho.is_dir() and any(caminho.iterdir())
+
+
+def baixar_modelo(aoFalar: Optional[Callable[[str], None]] = None) -> dict:
+    """Traz o modelo, uma vez. ~31 MB.
+
+    Baixa para um arquivo temporário e só então move para o lugar: interromper
+    no meio deixaria uma pasta pela metade que `tem_modelo()` daria por boa, e
+    o erro apareceria depois, como "falha ao carregar o Vosk".
+    """
+    fala = aoFalar or (lambda _t: None)
+    if tem_modelo():
+        return {"ok": True, "jaTinha": True}
+    try:
+        PASTA_MODELO.mkdir(parents=True, exist_ok=True)
+        temporario = PASTA_MODELO / (NOME_MODELO + ".zip.parcial")
+        fala("baixando o reconhecedor de voz (uma vez, ~31 MB)")
+        with urllib.request.urlopen(URL_MODELO, timeout=120) as resposta, open(temporario, "wb") as saida:
+            while True:
+                pedaco = resposta.read(1 << 16)
+                if not pedaco:
+                    break
+                saida.write(pedaco)
+        fala("descompactando")
+        with zipfile.ZipFile(temporario) as z:
+            z.extractall(PASTA_MODELO)
+        temporario.unlink(missing_ok=True)
+        if not tem_modelo():
+            return {"ok": False, "error": "o modelo baixou mas não apareceu onde devia"}
+        return {"ok": True}
+    except Exception as e:
+        return {"ok": False, "error": str(e),
+                "comoResolver": f"baixe {URL_MODELO} à mão e descompacte em {PASTA_MODELO}"}
+
+
+def contem_nome(texto: str) -> bool:
+    """O texto que o reconhecedor devolveu contém o nome?
+
+    Comparação por PALAVRA INTEIRA. Com `in` de substring, "prima" e
+    "primeiro" acordariam o assistente — e a gramática restrita não protege
+    disso sozinha, porque ela devolve as palavras da lista e o resto vira
+    "[unk]", que pode vir colado.
+    """
+    palavras = set(str(texto or "").lower().replace("[unk]", " ").split())
+    return any(n in palavras for n in DESPERTA)
+
+
+class Desperta:
+    """Escuta o nome. Nada sai da máquina até ele ser dito."""
+
+    def __init__(self, ao_despertar: Callable[[], None]) -> None:
+        self.ao_despertar = ao_despertar
+        self._rec = None
+        self._modelo = None
+        self.pronto = False
+        self.ligado = True
+        self.motivo = ""
+        # O reconhecedor do Vosk NÃO é seguro entre threads: a do áudio chama
+        # process() dez vezes por segundo enquanto o laço principal pode
+        # chamar reset() ao despertar. Sem trava, o estado interno corrompe e
+        # ele passa a levantar "Failed to process waveform" — sintoma que não
+        # fala de thread nenhuma, e por isso custa caro de achar.
+        self._trava = threading.Lock()
+        self._carregar()
+
+    def _carregar(self) -> None:
+        if not tem_modelo():
+            self.motivo = "o reconhecedor de voz não está baixado"
+            return
+        try:
+            import vosk
+            vosk.SetLogLevel(-1)
+            self._modelo = vosk.Model(str(caminho_do_modelo()))
+            self._rec = self._novo()
+            self.pronto = True
+        except ImportError:
+            self.motivo = "falta o vosk (pip install vosk)"
+        except Exception as e:
+            self.motivo = f"não consegui carregar o reconhecedor: {e}"
+
+    def _novo(self):
+        import vosk
+        gramatica = json.dumps(sorted({*VOCABULARIO, "[unk]"}))
+        return vosk.KaldiRecognizer(self._modelo, TAXA, gramatica)
+
+    def alimentar(self, bloco) -> bool:
+        """Um bloco de áudio. Devolve True se o nome foi dito."""
+        if not self.pronto or self._rec is None or not self.ligado:
+            return False
+        with self._trava:
+            try:
+                if self._rec.AcceptWaveform(bloco.tobytes()):
+                    texto = json.loads(self._rec.Result()).get("text", "")
+                else:
+                    texto = json.loads(self._rec.PartialResult()).get("partial", "")
+            except Exception:
+                # Reconhecedor travado: recria e segue. Desligar o modo de
+                # espera por causa de um bloco ruim seria perder o recurso
+                # inteiro por um soluço de áudio.
+                try:
+                    self._rec = self._novo()
+                except Exception:
+                    self.pronto = False
+                    self.motivo = "o reconhecedor parou e não voltou"
+                return False
+
+            achou = bool(texto and contem_nome(texto))
+            if achou:
+                self._rec.Reset()
+
+        if achou:
+            try:
+                self.ao_despertar()
+            except Exception:
+                pass
+        return achou
+
+    def zerar(self) -> None:
+        """Esquece o que ouviu até agora.
+
+        Chamado ao voltar do atendimento: sem isso, o resto da frase que a
+        pessoa falou DEPOIS do nome ainda está no reconhecedor, e ele desperta
+        de novo no instante seguinte.
+        """
+        with self._trava:
+            if self._rec is not None:
+                try:
+                    self._rec.Reset()
+                except Exception:
+                    pass

package/voz/primo_voz/escuta.py

@@ -20,10 +20,11 @@ mas CONTINUAR gravando exige bem menos. Sem isso, a sílaba fraca no fim ("…pr
 mim") cai abaixo do limiar e a frase é cortada antes de acabar.
 
 ── O QUE SAIU DO JARVIS ────────────────────────────────────────────────────
-A wake word. Lá ela existia porque o assistente ficava ligado o dia inteiro
-esperando ser chamado. Aqui a pessoa abriu o modo voz de propósito: ele já
-está ouvindo, e não há nome para dizer. Some com isso o Vosk e os 40 MB de
-modelo que ele baixava.
+A wake word saiu DAQUI, não do produto. Este módulo cuida de uma coisa só:
+achar o começo e o fim de uma frase. Quem reconhece o nome é o desperta.py, e
+ele só entra no modo de espera — quando a pessoa pediu para ele ficar ouvindo
+em segundo plano. Quem digita /voice e vai falar agora não diz nome nenhum: a
+orbe já está ouvindo.
 """
 from __future__ import annotations
 

package/voz/primo_voz/orbe.py

@@ -39,6 +39,7 @@ from __future__ import annotations
 
 import math
 import queue
+import sys
 import threading
 import tkinter as tk
 from typing import Callable, Optional
@@ -63,6 +64,7 @@ class Orbe:
         self.raiz = tk.Tk()
         self.raiz.title("Primo Code Voice")
         self.estado = "esperando"
+        self.visivel = True
         self.nivel = 0.0          # 0..1, o quanto a pessoa está falando
         self._fase = 0.0
         self._fila = queue.Queue()
@@ -130,6 +132,12 @@ class Orbe:
         while True:
             try:
                 estado, nivel = self._fila.get_nowait()
+                if estado == '__esconder__':
+                    self._aplicar_visibilidade(False)
+                    continue
+                if estado == '__mostrar__':
+                    self._aplicar_visibilidade(True)
+                    continue
             except queue.Empty:
                 break
             if estado:
@@ -197,6 +205,40 @@ class Orbe:
         principal, então o que chega vai para uma fila e é lido no desenho."""
         self._fila.put((estado, nivel))
 
+    def esconder(self) -> None:
+        """Some da tela sem morrer.
+
+        O modo de espera fica MINUTOS ou horas sem nada acontecer, e uma orbe
+        parada no meio do monitor todo esse tempo é um estorvo — ela cobre o
+        que a pessoa está fazendo. Então ela some e volta quando chamada.
+
+        Destruir e recriar a janela a cada despertar seria o caminho óbvio, e é
+        o errado: recriar uma Tk leva centenas de milissegundos, pisca, e em
+        alguns sistemas rouba o foco da janela onde a pessoa estava digitando.
+        `withdraw` tira da tela e guarda tudo de pé.
+        """
+        self._fila.put(("__esconder__", None))
+
+    def mostrar(self) -> None:
+        """Volta para a tela, no centro, por cima de tudo."""
+        self._fila.put(("__mostrar__", None))
+
+    def _aplicar_visibilidade(self, visivel: bool) -> None:
+        # Só na thread da interface: tkinter não perdoa chamada de fora.
+        try:
+            if visivel:
+                self.veu.deiconify()
+                self.raiz.deiconify()
+                self.raiz.lift()
+                if sys.platform != "linux":
+                    self.raiz.attributes("-topmost", True)
+            else:
+                self.raiz.withdraw()
+                self.veu.withdraw()
+        except Exception:
+            pass          # janela já fechando: nada a fazer
+        self.visivel = visivel
+
     def fechar(self) -> None:
         if not self._vivo:
             return