primocode 9.4.0 → 9.6.0

package/lib/config.js

@@ -21,6 +21,7 @@ const CONFIG_FILE = path.join(CONFIG_DIR, 'config.json');
 const HISTORY_FILE = path.join(CONFIG_DIR, 'history.jsonl');
 const CONTA_FILE = path.join(CONFIG_DIR, 'conta.json');
 const GENERAL_MEMORY = path.join(ROOT_DIR, 'memory-geral.md');
+const PROJETO_ATIVO_FILE = path.join(CONFIG_DIR, 'projeto-ativo.json');
 
 /* O token da conta, lido DIRETO do arquivo.
  *
@@ -309,7 +310,35 @@ function appendHistory(entry) {
     } catch {}
 }
 
+/* ── O PROJETO EM QUE SE ESTAVA ─────────────────────────────────────────
+ * "Eu peço o jogo de carro, depois peço pra editar ou continuar, e ele cria
+ * outro projeto." Nada sobrevivia entre uma sessão e outra: cada abertura
+ * começava em ~/primocode, e o "continua" virava projeto novo. Agora o projeto
+ * ativo fica guardado aqui, num arquivo só dele (a config tem lista fechada de
+ * campos), e a próxima sessão continua nele. Vale por uma semana: depois
+ * disso, abrir o PrimoCode e cair num projeto esquecido seria a surpresa. */
+function lembrarProjeto(dir, origem = 'projeto') {
+    try {
+        fs.mkdirSync(CONFIG_DIR, { recursive: true });
+        fs.writeFileSync(PROJETO_ATIVO_FILE, JSON.stringify({ dir, origem, quando: Date.now() }, null, 2), 'utf-8');
+    } catch { /* lembrar é conveniência: falhou, a sessão segue igual */ }
+}
+
+function projetoLembrado(maxDias = 7) {
+    try {
+        const j = JSON.parse(fs.readFileSync(PROJETO_ATIVO_FILE, 'utf-8'));
+        if (!j || !j.dir || !fs.existsSync(j.dir) || !fs.statSync(j.dir).isDirectory()) return null;
+        if (Date.now() - Number(j.quando || 0) > maxDias * 86400000) return null;
+        return { dir: j.dir, origem: j.origem || 'projeto' };
+    } catch { return null; }
+}
+
+function esquecerProjeto() {
+    try { fs.rmSync(PROJETO_ATIVO_FILE, { force: true }); } catch { /* nada a esquecer */ }
+}
+
 module.exports = {
+    lembrarProjeto, projetoLembrado, esquecerProjeto, PROJETO_ATIVO_FILE,
     loadConfig, saveConfig, appendHistory,
     CONFIG_DIR, CONFIG_FILE, HISTORY_FILE, ROOT_DIR, GENERAL_MEMORY,
     ensureStructure, slugify, stripAccents,

package/lib/cursor.js

@@ -0,0 +1,120 @@
+/**
+ * cursor.js — o lado Node do cursor do Primo (só macOS).
+ *
+ *   "Quando ele tá no modo, eu consigo ver o cursor dele, o mouse, ver ele
+ *    digitando, abrindo as coisas, ver ele fazer as coisas em tempo real."
+ *
+ * O cursor mora em voz/primo_voz/cursor.py: um processo Python que mexe no
+ * mouse e no teclado de verdade (Quartz) e desenha a seta dele por cima. Aqui
+ * é a ponta de cá: subir o processo na PRIMEIRA ação no computador (não antes
+ * — quem só escreve código nunca paga por ele), mandar os comandos e esperar
+ * cada um terminar.
+ *
+ * ── POR QUE ELE, E NÃO O cliclick ───────────────────────────────────────
+ * O cliclick precisava de Homebrew, e sem ele TODO clique do agente falhava —
+ * foi o que fez "mostra o teu mouse" virar uma página HTML com coordenadas. O
+ * Quartz vem com o sistema; o que falta instalar é o PyObjC, pelo pip, e isso
+ * este módulo faz sozinho.
+ *
+ * Fora do macOS, ou se o Python/PyObjC não estiverem lá, `disponivel()` diz
+ * que não e o desktop.js segue com o caminho de sempre.
+ */
+
+'use strict';
+
+const path = require('path');
+const { spawn, execFileSync } = require('child_process');
+
+const PASTA = path.join(__dirname, '..', 'voz');
+
+let proc = null;          // o processo do cursor, quando de pé
+let pronto = null;        // Promise<boolean> da subida
+let fila = new Map();     // id → { resolve, timer }
+let proximo = 1;
+let semCursor = null;     // motivo, quando não dá para ter cursor nesta máquina
+
+function pythonComQuartz() {
+    let py = null;
+    try { py = require('./voz.js').python(); } catch { /* sem voz.js: sem cursor */ }
+    if (!py) return { py: null };
+    try {
+        execFileSync(py, ['-c', 'import Quartz, AppKit, PyObjCTools'], { stdio: 'ignore', timeout: 20000 });
+        return { py, tem: true };
+    } catch {
+        return { py, tem: false };
+    }
+}
+
+/** Sobe o processo do cursor, instalando o PyObjC se faltar. Uma vez. */
+function subir() {
+    if (pronto) return pronto;
+    pronto = (async () => {
+        if (process.platform !== 'darwin') { semCursor = 'só no macOS'; return false; }
+        let { py, tem } = pythonComQuartz();
+        if (!py) { semCursor = 'sem Python 3'; return false; }
+        if (!tem) {
+            const voz = require('./voz.js');
+            const r = await voz.instalar(py, ['pyobjc-framework-Quartz', 'pyobjc-framework-Cocoa']);
+            if (!r.ok || !pythonComQuartz().tem) { semCursor = `não instalou o PyObjC: ${r.error || ''}`; return false; }
+        }
+        return await new Promise((resolve) => {
+            proc = spawn(py, ['-m', 'primo_voz.cursor'], {
+                cwd: PASTA,
+                env: { ...process.env, PYTHONPATH: PASTA, PYTHONUNBUFFERED: '1' },
+                stdio: ['pipe', 'pipe', 'ignore'],
+            });
+            let buffer = '';
+            let subiu = false;
+            proc.stdout.on('data', (d) => {
+                buffer += d.toString();
+                const linhas = buffer.split('\n');
+                buffer = linhas.pop();
+                for (const linha of linhas) {
+                    let msg;
+                    try { msg = JSON.parse(linha); } catch { continue; }
+                    if (msg.pronto && !subiu) { subiu = true; resolve(true); continue; }
+                    const espera = fila.get(msg.id);
+                    if (espera) { clearTimeout(espera.timer); fila.delete(msg.id); espera.resolve(msg); }
+                }
+            });
+            const morreu = () => {
+                proc = null;
+                pronto = null;           // a próxima ação tenta subir de novo
+                for (const [, e] of fila) { clearTimeout(e.timer); e.resolve({ ok: false, error: 'o cursor fechou' }); }
+                fila = new Map();
+                if (!subiu) { semCursor = 'o processo do cursor não subiu'; resolve(false); }
+            };
+            proc.on('exit', morreu);
+            proc.on('error', morreu);
+            setTimeout(() => { if (!subiu) { semCursor = 'o cursor demorou demais para abrir'; resolve(false); } }, 20000);
+            // O cursor não pode segurar o PrimoCode aberto na saída.
+            proc.unref();
+            proc.stdout.unref && proc.stdout.unref();
+        });
+    })();
+    return pronto;
+}
+
+/** Manda um comando e espera a resposta (a animação inteira, no caso do mouse). */
+async function mandar(cmd, args = {}, tetoMs = 60000) {
+    const ok = await subir();
+    if (!ok || !proc) return { ok: false, semCursor: true, error: semCursor || 'cursor indisponível' };
+    const id = proximo++;
+    return new Promise((resolve) => {
+        const timer = setTimeout(() => { fila.delete(id); resolve({ ok: false, error: 'o cursor não respondeu a tempo' }); }, tetoMs);
+        fila.set(id, { resolve, timer });
+        try { proc.stdin.write(JSON.stringify({ id, cmd, ...args }) + '\n'); }
+        catch (e) { clearTimeout(timer); fila.delete(id); resolve({ ok: false, error: e.message }); }
+    });
+}
+
+/** Esta máquina pode ter o cursor do Primo? (sem subir nada) */
+function disponivel() {
+    return process.platform === 'darwin' && process.env.PRIMOCODE_SEM_CURSOR !== '1';
+}
+
+function fechar() {
+    if (proc) { try { proc.stdin.end(); } catch { /* já fechou */ } }
+}
+
+module.exports = { disponivel, mandar, subir, fechar };

package/lib/memoria-conversa.js

@@ -17,10 +17,17 @@
  * O custo fica limitado por construção: a entrada do resumo é sempre
  * "resumo de antes + o que aconteceu desde então", nunca a conversa inteira.
  *
- * ── O QUE NUNCA É RESUMIDO ───────────────────────────────────────────────
- * As últimas rodadas vão CRUAS. Resumo é bom para lembrar do que foi feito,
- * péssimo para continuar de onde parou: "agora põe música de fundo" precisa da
- * frase anterior literal, não de um tópico dizendo que houve um vídeo.
+ * ── RESUMO A CADA MENSAGEM (23/09/2026) ──────────────────────────────────
+ *   "Pra não demorar tanto as respostas, quero que ela gere um resumo a cada
+ *    mensagem, pra daí na próxima mensagem ela ler só esse resumo, não precisa
+ *    ler a conversa inteira."
+ *
+ * Antes, o resumo só nascia quando a conversa passava de ~700 tokens, e as
+ * últimas quatro mensagens iam sempre cruas. Agora TODA resposta é dobrada no
+ * resumo logo depois de terminar (em segundo plano, sem segurar o prompt), e o
+ * pedido seguinte leva só o resumo — mais o que, por falha ou pressa, ainda
+ * não entrou nele. O resumo é que carrega o "de onde parei": ele é instruído a
+ * guardar o último pedido, o que foi feito e o projeto em que se estava.
  *
  * Este arquivo é puro — quem fala com o servidor é quem chama `atualizar`.
  * Assim o teste mede a política inteira sem rede e sem chave de API.
@@ -34,10 +41,10 @@ function tokensDe(x) {
     return Math.ceil(texto.length / 4);
 }
 
-// Quantas mensagens do fim ficam sempre cruas (o "de onde parei").
-const CRUAS = 4;
-// Acima disto, a cauda vira resumo. Abaixo, não compensa pagar a chamada.
-const LIMITE_TOKENS = 700;
+// Nenhuma mensagem fica de fora do resumo: ele é atualizado a cada rodada.
+const CRUAS = 0;
+// Qualquer coisa nova já vale o resumo — é o que deixa o pedido seguinte leve.
+const LIMITE_TOKENS = 1;
 
 /** Estado inicial — o que o CLI guarda entre um pedido e outro. */
 function nova() {
@@ -103,13 +110,15 @@ function inicioSeguro(todas, alvo) {
  * O resumo entra como mensagem de sistema, não como fala do usuário — o modelo
  * precisa saber que aquilo é memória, e não algo que alguém acabou de dizer.
  */
-function paraEnviar(memoria, history) {
+function paraEnviar(memoria, history, contexto = '') {
     const todas = history || [];
     if (!memoria || !memoria.resumo) return todas.slice(inicioSeguro(todas, todas.length - 20));
 
-    const cruas = todas.slice(inicioSeguro(todas, todas.length - CRUAS));
+    // Só o que ainda NÃO entrou no resumo vai cru — normalmente, nada.
+    const cruas = todas.slice(inicioSeguro(todas, Math.min(memoria.resumidasAte, todas.length)));
+    const extra = contexto ? `\n\n${contexto}` : '';
     return [
-        { role: 'system', content: `Resumo da conversa até aqui (memória, não é fala de ninguém):\n${memoria.resumo}` },
+        { role: 'system', content: `Resumo da conversa até aqui (memória, não é fala de ninguém):\n${memoria.resumo}${extra}` },
         ...cruas,
     ];
 }

package/lib/tools.js

@@ -15,6 +15,29 @@ const os = require('os');
 const { exec, execFile } = require('child_process');
 const browser = require('./browser');
 const desktop = require('./desktop');
+const cursor = require('./cursor');
+
+/* ── O CURSOR DO PRIMO NO MAC ────────────────────────────────────────────
+ * No macOS, mouse e teclado passam pelo cursor dele (lib/cursor.js): a mesma
+ * ação acontece de verdade, e a pessoa VÊ a seta dele indo até lá, clicando,
+ * digitando. Sem o cursor (outro sistema, ou o Python não subiu), vale o
+ * caminho antigo do desktop.js. */
+async function peloCursor(cmd, args, reserva) {
+    if (!cursor.disponivel()) return reserva();
+    const r = await cursor.mandar(cmd, args);
+    if (r.semCursor) return reserva();
+    if (!r.ok) return { ok: false, error: r.error || 'o cursor não conseguiu', ...(r.permissao === false ? { permissao: false } : {}) };
+    return { ok: true };
+}
+
+function numero(v) { const n = Number(v); return Number.isFinite(n) ? n : null; }
+
+async function clicarPeloCursor(x, y, { botao = 'left', duplo = false, rotulo } = {}) {
+    const [nx, ny] = [numero(x), numero(y)];
+    if (nx == null || ny == null) return { ok: false, error: `Coordenada inválida: x=${x}, y=${y}` };
+    return peloCursor('clicar', { x: nx, y: ny, botao: botao === 'right' ? 'direito' : 'esquerdo', duplo, rotulo },
+        () => (duplo ? desktop.doubleClick(nx, ny) : desktop.click(nx, ny, botao)));
+}
 const referencia = require('./referencia');
 const estudio = require('./estudio');
 const cfg = require('./config');
@@ -538,19 +561,46 @@ async function despachar(name, args, ctx) {
                 // resolver dentro do projeto, não do cwd real do processo.
                 return desktop.screenshot(resolveInProject(args.path || `desktop-${Date.now()}.png`, projectDir));
             case 'desktop_click':
-                return desktop.click(args.x, args.y, args.button || 'left');
-            case 'desktop_move':
-                return desktop.move(args.x, args.y);
-            case 'desktop_drag':
-                return desktop.drag(args.from_x, args.from_y, args.to_x, args.to_y);
+                return clicarPeloCursor(args.x, args.y, { botao: args.button || 'left', rotulo: 'clicando' });
+            case 'desktop_move': {
+                const [x, y] = [numero(args.x), numero(args.y)];
+                if (x == null || y == null) return { ok: false, error: `Coordenada inválida: x=${args.x}, y=${args.y}` };
+                return peloCursor('mover', { x, y }, () => desktop.move(x, y));
+            }
+            case 'desktop_drag': {
+                const c4 = [args.from_x, args.from_y, args.to_x, args.to_y].map(numero);
+                if (c4.some((v) => v == null)) return { ok: false, error: 'Coordenada inválida no drag' };
+                return peloCursor('arrastar', { x1: c4[0], y1: c4[1], x2: c4[2], y2: c4[3], rotulo: 'arrastando' },
+                    () => desktop.drag(...c4));
+            }
             case 'desktop_type':
-                return desktop.type(args.text || '');
-            case 'desktop_key':
-                return desktop.key(args.key);
+                return peloCursor('digitar', { texto: args.text || '', rotulo: 'digitando' },
+                    () => desktop.type(args.text || ''));
+            case 'desktop_key': {
+                const r = await peloCursor('tecla', { combo: args.key || '', rotulo: String(args.key || '') },
+                    () => desktop.key(args.key));
+                // Tecla SOLTA que o cursor não conhece: o desktop.js sabe mais
+                // nomes. Combinação com tecla desconhecida ("cmd+xyz") NÃO cai
+                // lá: o osascript digitaria x, y e z com Command apertado —
+                // recortar e desfazer no app da frente.
+                if (!r.ok && /tecla desconhecida/.test(r.error || '') && !String(args.key || '').includes('+')) {
+                    return desktop.key(args.key);
+                }
+                return r;
+            }
             case 'desktop_scroll':
-                return desktop.scroll(args.dy != null ? args.dy : 300);
-            case 'desktop_size':
+                return peloCursor('rolar', { dy: args.dy != null ? Number(args.dy) : 300, rotulo: 'rolando' },
+                    () => desktop.scroll(args.dy != null ? args.dy : 300));
+            case 'desktop_size': {
+                // No Mac, em PONTOS — a mesma unidade dos cliques e das posições
+                // dos botões. O system_profiler dava pixels físicos (2880 num
+                // Retina de 1440), e o clique caía no lugar errado.
+                if (cursor.disponivel()) {
+                    const t = await cursor.mandar('tamanho');
+                    if (t.ok) return { ok: true, width: t.largura, height: t.altura, unidade: 'pontos' };
+                }
                 return desktop.getScreenSize();
+            }
             /* ── O ESTÚDIO ─────────────────────────────────────────────────
              * Sete ferramentas, e nenhuma delas fala com servidor nenhum: o
              * Studio antigo subia um Python em localhost:7777 porque tinha
@@ -583,21 +633,42 @@ async function despachar(name, args, ctx) {
                 return estudio.ferramentaSite(args);
 
             case 'desktop_double_click':
-                return desktop.doubleClick(args.x, args.y);
-            case 'desktop_open_app':
-                return desktop.openApp(args.app || args.name || '');
+                return clicarPeloCursor(args.x, args.y, { duplo: true, rotulo: 'abrindo' });
+            case 'desktop_open_app': {
+                const app = args.app || args.name || '';
+                if (cursor.disponivel()) await cursor.mandar('rotulo', { texto: `abrindo ${app}` });
+                return desktop.openApp(app);
+            }
             case 'desktop_windows':
                 return desktop.listWindows();
             case 'desktop_focus':
                 return desktop.focusWindow(args.window || args.title || '');
             case 'desktop_elements':
                 return desktop.uiElements(args.window);
-            case 'desktop_click_element':
-                return desktop.clickElement(args.name || args.text || '', {
-                    window: args.window,
-                    double: !!args.double,
-                    button: args.button,
+            case 'desktop_click_element': {
+                if (!cursor.disponivel()) {
+                    return desktop.clickElement(args.name || args.text || '', {
+                        window: args.window, double: !!args.double, button: args.button,
+                    });
+                }
+                // Mesma escolha do desktop.clickElement, mas o clique vai pelo
+                // cursor: a pessoa vê a seta ir até o botão pelo nome.
+                const pedido = String(args.name || args.text || '').trim();
+                if (!pedido) return { ok: false, error: 'Diga o nome do elemento (o texto do botão, ícone ou campo).' };
+                const lidos = desktop.uiElements(args.window);
+                if (!lidos.ok) return lidos;
+                const alvo = desktop.escolherElemento(lidos.elementos, pedido);
+                if (!alvo) {
+                    return { ok: false, error: `Nenhum elemento parecido com "${pedido}" na janela "${lidos.janela}".`,
+                        elementosDisponiveis: lidos.elementos.slice(0, 40).map((e) => e.nome),
+                        comoCorrigir: 'Chame de novo com um nome de "elementosDisponiveis", copiado literalmente.' };
+                }
+                const r = await clicarPeloCursor(alvo.x, alvo.y, {
+                    botao: args.button || 'left', duplo: !!args.double, rotulo: `clicando em ${alvo.nome}`.slice(0, 44),
                 });
+                if (!r.ok) return r;
+                return { ok: true, clicado: alvo.nome, tipo: alvo.tipo, x: alvo.x, y: alvo.y, duplo: !!args.double };
+            }
 
             default:
                 /* O MODELO PRECISA CONSEGUIR SE CORRIGIR AQUI.

package/lib/ui.js

@@ -319,6 +319,9 @@ const ROTULOS = {
 function actionHeader(name, args) {
     const label = ROTULOS[name] || name;
     let argStr = args ? (args.consulta || args.path || args.pattern || args.command || args.target || args.url || args.selector || args.text || args.app || args.window || args.name || args.ferramenta || args.titulo || args.description || (args.todos ? `${args.todos.length} tarefas` : '') || (args.x != null ? `${args.x},${args.y}` : '') || args.key || args.arquivo || args.id || JSON.stringify(args).slice(0,60)) : '';
+    // Campo que veio como objeto (o modelo às vezes manda {"window": {}})
+    // virava "[object Object]" na tela.
+    if (argStr && typeof argStr === 'object') argStr = JSON.stringify(argStr).slice(0, 60);
     argStr = String(argStr || '').replace(/\s+/g, ' ').trim();
     // Uma tool sem argumento nenhum caía no JSON.stringify e desenhava "{}"
     // ao lado do nome — ruído que não diz nada.

package/lib/voz.js

@@ -32,10 +32,23 @@ const { spawn, execFileSync } = require('child_process');
 
 const PASTA = path.join(__dirname, '..', 'voz');
 
+/* ── A DICA DO COMPUTADOR ────────────────────────────────────────────────
+ * Duas razões para existir, e as duas foram medidas:
+ *
+ * 1. O servidor só oferece as ferramentas desktop_* ao modelo quando o pedido
+ *    cita palavras como "mouse", "teclado", "ícone", "atalho", "janela" (o
+ *    grupo "computador" em lib/orcamento-entrada.js do servidor). "Abre o
+ *    Safari e pesquisa X" não cita nenhuma — e o modelo ficava sem as mãos.
+ *    Esta dica as cita de propósito.
+ * 2. "Mostra o teu mouse" virou uma página HTML com as coordenadas do mouse
+ *    DA PESSOA. O certo é mexer o cursor dele, que ela vê na tela.
+ */
+const DICA_COMPUTADOR = `[COMPUTADOR] Você pode usar o mouse, o teclado, as janelas e os ícones do computador da pessoa com as ferramentas desktop_* (desktop_open_app, desktop_click_element, desktop_click, desktop_type, desktop_key para atalho, desktop_scroll). Cada movimento aparece na tela como o SEU cursor. Para abrir um app, use desktop_open_app; para clicar em algo, prefira desktop_click_element pelo nome (leia os nomes com desktop_elements); coordenadas são em pontos da tela (desktop_size). Se pedirem para "mostrar o seu mouse/cursor", MEXA o cursor com desktop_move — nunca crie uma página ou arquivo para isso.`;
+
 /* A instrução de FORMA. Ela não muda o que o agente faz — muda como ele
    conta. O que está proibido aqui é o que não existe em voz: marcador,
    caminho, código, e parágrafo que ninguém segura de ouvido. */
-const COMO_FALAR = `[MODO VOZ] A sua resposta vai ser LIDA EM VOZ ALTA para a pessoa, e ela não vê tela nenhuma.
+const COMO_FALAR = `[MODO VOZ] A sua resposta vai ser LIDA EM VOZ ALTA. A pessoa está olhando a tela: ela vê o SEU cursor (o mouse e o teclado do computador dela, que você controla) se mexendo em tempo real.
 
 Responda em no máximo 3 frases curtas, em português falado. Nada de lista com
 marcador, nada de caminho de arquivo, nada de bloco de código, nada de
@@ -44,6 +57,8 @@ markdown — nada disso existe no ouvido de alguém.
 Diga o que você FEZ e o que mudou, não como. Se algo deu errado, diga em uma
 frase o que foi e o que você precisa.
 
+${DICA_COMPUTADOR}
+
 Faça o trabalho inteiro normalmente, com as ferramentas de sempre. O que muda
 é só o jeito de contar no fim.`;
 
@@ -237,6 +252,10 @@ function abrir({ python: py, servidor, token, voz, pensar, mostrar = () => {}, e
                 // Dormir até ouvir o nome, em vez de já entrar ouvindo.
                 PRIMOCODE_VOZ_ESPERA: esperando ? '1' : '',
                 PYTHONUNBUFFERED: '1',
+                // O Whisper deixa um semáforo para o sistema recolher na saída,
+                // e o Python avisa disso no stderr — que aqui vira texto no
+                // terminal da pessoa. É inofensivo; o aviso é que não é.
+                PYTHONWARNINGS: 'ignore::UserWarning:multiprocessing.resource_tracker',
             },
         });
 
@@ -387,4 +406,172 @@ print(json.dumps(desperta.baixar_modelo()))
     });
 }
 
-module.exports = { conferir, instalar, porqueOPipFalhou, abrir, conferirEspera, baixarEspera, python, COMO_FALAR, PASTA };
+/* ── PREPARAR TUDO, SEM PERGUNTAR ────────────────────────────────────────
+ *
+ *   "Instale tudo que precisa, rode tudo que precisa, então fica redondinho,
+ *    já funcionando." (23/09/2026)
+ *
+ * O /voice perguntava duas vezes ("Instalar agora?", "Baixar agora?") e
+ * parava em cada falta com um comando para a pessoa copiar. Agora ele mesmo
+ * resolve o que dá para resolver, nesta ordem:
+ *
+ *   1. bibliotecas do SISTEMA (PortAudio e o Tk do Python) — pelo Homebrew no
+ *      macOS; no Linux, `sudo -n` (só funciona sem senha; senão, o comando);
+ *   2. pacotes do Python — os obrigatórios (numpy, sounddevice) e os que
+ *      deixam tudo bonito e local (faster-whisper, vosk, PyObjC no macOS);
+ *   3. os modelos — o Whisper (transcrição local) e o reconhecedor do nome.
+ *
+ * Só o que é OBRIGATÓRIO faltar impede o modo voz de abrir. Faltar um opcional
+ * vira um aviso de uma linha, e o modo voz abre mesmo assim.
+ */
+const OPCIONAIS = () => [
+    ['faster_whisper', 'faster-whisper', 'a transcrição local (Whisper)'],
+    ['vosk', 'vosk', 'o reconhecedor local do "ei, primo"'],
+    ...(process.platform === 'darwin' ? [
+        ['AppKit', 'pyobjc-framework-Cocoa', 'a orb transparente do macOS'],
+        ['Quartz', 'pyobjc-framework-Quartz', 'o cursor do Primo na tela'],
+    ] : []),
+];
+
+function temModulo(py, modulo) {
+    try {
+        execFileSync(py, ['-c', `import ${modulo}`], { stdio: ['ignore', 'pipe', 'pipe'], timeout: 30000 });
+        return true;
+    } catch { return false; }
+}
+
+function rodar(cmd, args, timeout = 15 * 60 * 1000) {
+    return new Promise((resolve) => {
+        let saida = '';
+        let p;
+        try { p = spawn(cmd, args, { stdio: ['ignore', 'pipe', 'pipe'] }); }
+        catch (e) { return resolve({ ok: false, saida: e.message }); }
+        const t = setTimeout(() => { try { p.kill(); } catch {} }, timeout);
+        p.stdout.on('data', (d) => { saida += d.toString(); });
+        p.stderr.on('data', (d) => { saida += d.toString(); });
+        p.on('close', (code) => { clearTimeout(t); resolve({ ok: code === 0, saida }); });
+        p.on('error', (e) => { clearTimeout(t); resolve({ ok: false, saida: e.message }); });
+    });
+}
+
+function brew() {
+    for (const b of ['brew', '/opt/homebrew/bin/brew', '/usr/local/bin/brew']) {
+        try { execFileSync(b, ['--version'], { stdio: 'ignore', timeout: 10000 }); return b; } catch { /* próximo */ }
+    }
+    return null;
+}
+
+/** As bibliotecas do sistema que faltam, instaladas por quem der. */
+async function instalarSistema(py, falta, aoFalar) {
+    const avisos = [];
+    const precisa = [];
+    if (falta.some((f) => f.modulo === 'sounddevice' && f.sistema)) precisa.push('portaudio');
+    if (falta.some((f) => f.modulo === 'tkinter')) precisa.push('tkinter');
+    if (!precisa.length) return avisos;
+
+    if (process.platform === 'darwin') {
+        const b = brew();
+        if (!b) {
+            avisos.push('o Homebrew não está instalado, então não deu para instalar '
+                + precisa.join(' e ') + ' sozinho — instale em brew.sh e rode /voice de novo.');
+            return avisos;
+        }
+        // O Tk do Homebrew tem versão casada com a do Python: python-tk@3.14
+        // serve ao python3.14, e só a ele.
+        let versao = '';
+        try { versao = execFileSync(py, ['-c', 'import sys;print("%d.%d"%sys.version_info[:2])']).toString().trim(); } catch {}
+        const formulas = precisa.map((x) => (x === 'tkinter' ? (versao ? `python-tk@${versao}` : 'python-tk') : x));
+        aoFalar(`instalando ${formulas.join(', ')} pelo Homebrew`);
+        const r = await rodar(b, ['install', ...formulas]);
+        if (!r.ok) avisos.push(`o Homebrew não instalou ${formulas.join(', ')}: ${porqueOPipFalhou(r.saida)}`);
+        return avisos;
+    }
+    if (process.platform === 'linux') {
+        const pacotes = precisa.map((x) => (x === 'tkinter' ? 'python3-tk' : 'libportaudio2'));
+        aoFalar(`instalando ${pacotes.join(', ')}`);
+        const r = await rodar('sudo', ['-n', 'apt-get', 'install', '-y', ...pacotes]);
+        if (!r.ok) avisos.push(`precisa de senha para instalar: sudo apt install ${pacotes.join(' ')}`);
+        return avisos;
+    }
+    avisos.push(precisa.map((x) => COMO_SISTEMA[x === 'tkinter' ? 'tkinter' : 'portaudio'].win32).join(' · '));
+    return avisos;
+}
+
+/** O Whisper local, baixado antes da primeira frase. ~480 MB, uma vez. */
+async function baixarWhisper(py) {
+    const r = await new Promise((resolve) => {
+        const p = spawn(py, ['-m', 'primo_voz.transcrever', 'baixar'], {
+            cwd: PASTA, env: { ...process.env, PYTHONPATH: PASTA },
+        });
+        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.trim().split('\n').pop() || 'o download não respondeu' }); }
+        });
+        p.on('error', (e) => resolve({ ok: false, error: e.message }));
+    });
+    return r;
+}
+
+/**
+ * Deixa o modo voz pronto: instala e baixa tudo o que falta, sem perguntar.
+ *
+ * @param {(msg:string)=>void} aoFalar   uma linha de progresso por etapa
+ * @returns {Promise<{ok:boolean, python?:string, esperando?:boolean,
+ *                    avisos:string[], error?:string, comoResolver?:string}>}
+ */
+async function preparar(aoFalar = () => {}) {
+    const py = python();
+    if (!py) {
+        return { ok: false, avisos: [], error: 'o modo voz precisa do Python 3, e não achei nenhum nesta máquina.',
+            comoResolver: process.platform === 'darwin' ? 'brew install python' : 'instale em python.org e abra o terminal de novo' };
+    }
+    const avisos = [];
+
+    // 1. sistema, depois 2. os obrigatórios pelo pip.
+    let falta = faltando(py);
+    avisos.push(...await instalarSistema(py, falta, aoFalar));
+    falta = faltando(py);
+    const pipObrigatorio = falta.filter((f) => f.pacote).map((f) => f.pacote);
+    if (pipObrigatorio.length) {
+        const r = await instalar(py, pipObrigatorio, aoFalar);
+        if (!r.ok) avisos.push(`o pip não instalou ${pipObrigatorio.join(', ')}: ${r.error}`);
+        falta = faltando(py);
+    }
+    if (falta.length) {
+        const c = conferir();
+        return { ok: false, python: py, avisos, error: c.error, comoResolver: c.comoResolver };
+    }
+
+    // 2b. os opcionais: faltar um deles não impede o modo voz de abrir.
+    const opcionais = OPCIONAIS().filter(([m]) => !temModulo(py, m));
+    if (opcionais.length) {
+        const r = await instalar(py, opcionais.map(([, pacote]) => pacote), aoFalar);
+        for (const [m, , para] of opcionais) {
+            if (!temModulo(py, m)) avisos.push(`sem ${para}: ${r.ok ? 'o pacote não carregou' : r.error}`);
+        }
+    }
+
+    // 3. os modelos.
+    if (temModulo(py, 'faster_whisper')) {
+        aoFalar('preparando a transcrição local (Whisper, ~480 MB na primeira vez)');
+        const w = await baixarWhisper(py);
+        if (!w.ok) avisos.push(`a transcrição local não ficou pronta (${w.error}) — vai pelo servidor.`);
+    }
+    let esperando = false;
+    const espera = conferirEspera(py);
+    if (espera.ok) esperando = true;
+    else if (espera.baixavel) {
+        aoFalar('baixando o reconhecedor do "ei, primo" (~31 MB)');
+        const r = await baixarEspera(py);
+        if (r.ok) esperando = true;
+        else avisos.push(`sem o "ei, primo": ${r.error} — o modo voz abre já ouvindo.`);
+    }
+
+    return { ok: true, python: py, esperando, avisos };
+}
+
+module.exports = { DICA_COMPUTADOR, conferir, instalar, preparar, porqueOPipFalhou, abrir, conferirEspera, baixarEspera, python, COMO_FALAR, PASTA };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "primocode",
-  "version": "9.4.0",
+  "version": "9.6.0",
   "description": "PrimoCode — agente de engenharia com IA e cursor próprio. Requer conta Conecta Primo AI (Premium ou Super). Cria arquivos, roda comandos, controla navegador e desktop: abre apps, clica em botões e ícones pelo nome, digita e usa atalhos.",
   "main": "bin/primocode.js",
   "bin": {
@@ -8,7 +8,7 @@
   },
   "scripts": {
     "start": "node bin/primocode.js",
-    "test": "node test/tools.test.js && node test/ui.test.js && node test/entrada.test.js && node test/transparencia.test.js && node test/permissao.test.js && node test/compatibilidade.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/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"
+    "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/compatibilidade.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/projeto.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/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"