primocode 9.5.0 → 9.7.0

package/lib/catalogo.js

@@ -206,6 +206,25 @@ function escreveArquivo(tool) {
     return ESCREVEM.has(tool);
 }
 
+/* ── O QUE FAZ NASCER UMA PASTA DE PROJETO ──────────────────────────────
+ * "Ela deve saber quando criar pasta do projeto e quando não criar — só vai
+ * criar quando fizer código." `escreve` era largo demais para isso: um print
+ * de tela, uma narração do estúdio e um vídeo também escrevem arquivo, e cada
+ * um deles criava um projeto com o nome da frase. Aqui só o que é CÓDIGO:
+ * escrever ou editar arquivo, montar um app, delegar a um especialista, e o
+ * comando de terminal que cria arquivo (o agente que faz `npm create` ou
+ * `mkdir` estava pondo o projeto solto na raiz de ~/primocode). */
+const CRIAM_PROJETO = new Set(['write_file', 'edit_file', 'multi_edit', 'construir_app', 'spawn_agent']);
+const SHELL_QUE_CRIA = /\b(mkdir|touch|git\s+clone|npm\s+(init|create)|npx\s+(create-|degit|nuxi\s+init)|yarn\s+create|pnpm\s+(create|dlx\s+create-)|bun\s+create|cargo\s+(new|init)|python3?\s+-m\s+venv|django-admin\s+startproject|rails\s+new|flutter\s+create|dotnet\s+new|composer\s+create-project|expo\s+init)\b|(^|[^<>&|0-9])>>?\s*[\w./~-]/;
+
+function criaProjeto(tool, args) {
+    if (CRIAM_PROJETO.has(tool)) return true;
+    if (tool === 'run_shell' || tool === 'run_in_new_terminal') {
+        return SHELL_QUE_CRIA.test(String((args && (args.command || args.comando)) || ''));
+    }
+    return false;
+}
+
 
 /**
  * As ferramentas de nome mais parecido com o que foi chamado.
@@ -244,5 +263,5 @@ function parecidasCom(nome) {
     return pontos.slice(0, 6).map((x) => x.t);
 }
 
-module.exports = {
+module.exports = { criaProjeto,
     parecidasCom, GRUPOS, TODAS, ESCREVEM, escreveArquivo };

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,129 @@
+/**
+ * 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 });
+    } catch {
+        return { py, tem: false };
+    }
+    // O Vision (ler a tela) é um extra: sem ele o mouse funciona igual.
+    try {
+        execFileSync(py, ['-c', 'import Vision'], { stdio: 'ignore', timeout: 20000 });
+        return { py, tem: true, vision: true };
+    } catch {
+        return { py, tem: true, vision: 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', 'pyobjc-framework-Vision']);
+            if (!r.ok || !pythonComQuartz().tem) { semCursor = `não instalou o PyObjC: ${r.error || ''}`; return false; }
+        } else if (!pythonComQuartz().vision) {
+            // Falhar aqui não impede o cursor; só "clicar pelo texto" fica sem OCR.
+            await require('./voz.js').instalar(py, ['pyobjc-framework-Vision']).catch(() => {});
+        }
+        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,37 @@ 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; }
+
+/** Os textos visíveis na tela, pelo OCR do cursor, no formato dos elementos. */
+async function textosDaTela() {
+    if (!cursor.disponivel()) return { ok: false, error: 'ler a tela é só no macOS' };
+    const r = await cursor.mandar('ler_tela', {}, 30000);
+    if (!r.ok) return { ok: false, error: r.error || 'não consegui ler a tela' };
+    return { ok: true, elementos: (r.textos || []).map((t) => ({ nome: t.texto, tipo: 'texto na tela', x: t.x, y: t.y })) };
+}
+
+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 +569,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 +641,60 @@ 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_elements': {
+                const lidos = desktop.uiElements(args.window);
+                if (!cursor.disponivel()) return lidos;
+                // No Mac, junto dos botões da acessibilidade vão os TEXTOS
+                // que aparecem na tela (OCR), com a posição de cada um.
+                const naTela = await textosDaTela();
+                if (!naTela.ok) return lidos.ok ? { ...lidos, telaIndisponivel: naTela.error } : lidos;
+                return { ...(lidos.ok ? lidos : { ok: true, elementos: [] }),
+                    textosNaTela: naTela.elementos.slice(0, 120).map((e) => ({ texto: e.nome, x: e.x, y: e.y })) };
+            }
+            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);
+                let alvo = lidos.ok ? desktop.escolherElemento(lidos.elementos, pedido) : null;
+                /* A acessibilidade não achou (ou o app não expõe botões): procura
+                   o TEXTO na tela, pelo OCR do cursor. É o que faz "clica em
+                   Salvar" funcionar em qualquer app, como no Jarvis. */
+                let naTela = null;
+                if (!alvo) {
+                    naTela = await textosDaTela();
+                    if (naTela.ok) alvo = desktop.escolherElemento(naTela.elementos, pedido);
+                }
+                if (!alvo) {
+                    return { ok: false,
+                        error: `Nenhum elemento parecido com "${pedido}"${lidos.ok ? ` na janela "${lidos.janela}"` : ''}, nem como texto na tela.`,
+                        elementosDisponiveis: [...(lidos.ok ? lidos.elementos : []), ...((naTela && naTela.ok) ? naTela.elementos : [])]
+                            .slice(0, 50).map((e) => e.nome),
+                        ...(naTela && !naTela.ok ? { telaIndisponivel: naTela.error } : {}),
+                        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.`;
 
@@ -412,7 +427,11 @@ print(json.dumps(desperta.baixar_modelo()))
 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']] : []),
+    ...(process.platform === 'darwin' ? [
+        ['AppKit', 'pyobjc-framework-Cocoa', 'a orb transparente do macOS'],
+        ['Quartz', 'pyobjc-framework-Quartz', 'o cursor do Primo na tela'],
+        ['Vision', 'pyobjc-framework-Vision', 'ler o texto da tela (clicar pelo nome em qualquer app)'],
+    ] : []),
 ];
 
 function temModulo(py, modulo) {
@@ -556,4 +575,4 @@ async function preparar(aoFalar = () => {}) {
     return { ok: true, python: py, esperando, avisos };
 }
 
-module.exports = { conferir, instalar, preparar, porqueOPipFalhou, abrir, conferirEspera, baixarEspera, python, COMO_FALAR, PASTA };
+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.5.0",
+  "version": "9.7.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/conferir.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"

package/skills/projeto-no-github/SKILL.md

@@ -0,0 +1,32 @@
+---
+nome: Projeto no GitHub
+descricao: criar o repositório, subir o projeto e abrir pull request pelo gh
+quando: github, repositório, repositorio, repo, subir pro github, sobe pro github, pull request, pr, gh, versionar, push, clonar
+autor: PrimoCode
+---
+Tudo pelo `gh` (GitHub CLI) e pelo `git`, rodando no terminal do projeto.
+
+**Antes de tudo:** `gh auth status`. Sem login, diga à pessoa para rodar
+`gh auth login` e pare — NUNCA peça token ou senha no chat.
+
+**Projeto novo no GitHub:**
+1. Se não houver `.git`: `git init -b main`.
+2. `.gitignore` antes do primeiro commit (node_modules, dist, build, .env,
+   .DS_Store, __pycache__, .venv). Confira com `git status` que nenhum segredo
+   ou pasta pesada vai junto.
+3. README curto: o que é, como rodar.
+4. `git add -A` e `git commit -m "<o que o projeto é>"`.
+5. `gh repo create <nome-do-projeto> --private --source . --push` (privado
+   por padrão; público só se a pessoa pedir). Diga o link do repositório.
+
+**Mudança num repositório que já existe (pull request):**
+1. `git status` e `git pull` primeiro. Branch nova com nome que diz a
+   mudança: `git switch -c feat/<assunto>`.
+2. Rode o que o projeto roda (teste, lint, build) antes de commitar.
+3. Commit com a mensagem dizendo o que MUDA; `git push -u origin <branch>`.
+4. `gh pr create --fill` (ou `--title` e `--body` dizendo o que e por quê).
+   Diga o link do PR.
+
+**Nunca** faça `push --force` em `main`, nunca apague branch dos outros, nunca
+commite `.env`. Conflito: resolva lendo os dois lados, não escolhendo um às
+cegas.

package/skills/publicar-na-internet/SKILL.md

@@ -0,0 +1,36 @@
+---
+nome: Publicar na internet
+descricao: colocar o projeto no ar com um link público, conferido depois de subir
+quando: publicar, publica, deploy, colocar no ar, coloca no ar, no ar, subir o site, sobe o site, hospedar, hospedagem, link público, link publico, vercel, netlify, github pages, railway, dominio, domínio
+autor: PrimoCode
+---
+Publicar é terminar com um LINK que abre. Nada de "pronto, publicado" sem ter
+aberto o link.
+
+**1. Descubra o que é o projeto** (leia a pasta): página estática (index.html
+solto), app com build (package.json com `build`: Vite, React, Next) ou servidor
+(Express, Python). Rode o build antes (`npm install` e `npm run build`) e
+conserte o que quebrar — publicar build quebrado é publicar tela branca.
+
+**2. Escolha onde, nesta ordem, conferindo o login ANTES:**
+- **Vercel** (sites e Next): `npx --yes vercel whoami`. Logado →
+  `npx --yes vercel --prod --yes` na pasta do projeto. A URL de produção sai no
+  fim da saída.
+- **Netlify** (sites estáticos): `npx --yes netlify-cli status`. Logado →
+  `npx --yes netlify-cli deploy --prod --dir <pasta do build ou .>`.
+- **GitHub Pages** (só estático, sem build de servidor): `gh auth status`.
+  Logado → publique o repositório (ver a skill "Projeto no GitHub") e ligue o
+  Pages com `gh api -X POST repos/<dono>/<repo>/pages -f "source[branch]=main" -f "source[path]=/"`.
+- **Servidor** (API, backend): Railway (`npx --yes @railway/cli whoami`, depois
+  `railway up`) ou Render. Precisa de conta; não invente.
+
+**Sem login em nenhum:** NÃO peça senha nem token no chat. Diga à pessoa, em
+uma frase, o comando para ela entrar (ex.: `npx vercel login`) e pare ali. É
+ela quem entra na conta dela.
+
+**3. Confira:** abra a URL publicada com browser_open e leia a página. Só diga
+que está no ar se ela abriu com o conteúdo certo. Termine dizendo o LINK.
+
+**Nunca** publique `.env`, chave ou senha: confira se `.gitignore` e o
+`.vercelignore`/`.netlifyignore` os deixam de fora. Variáveis secretas vão no
+painel do serviço (ou `vercel env add`), não no código.