primocode 9.6.0 → 9.8.0-beta.0

package/README.md

@@ -1,4 +1,4 @@
-# PrimoCode v9.6.0
+# PrimoCode v9.7.0
 
 Agente de engenharia brasileiro para o terminal, no estilo Claude Code.
 Cria arquivos de verdade, roda comandos, **controla o navegador e o desktop** —
@@ -9,7 +9,7 @@ OpenRouter, e cada apelido (`top`/`main`/`fast`) é uma **corrente**: se um mode
 está no limite de pedidos, o próximo atende. Você não vê o erro, e não paga nada.
 
 ```
- ▐▛███▜▌   Primo Code v9.6.0
+ ▐▛███▜▌   Primo Code v9.7.0
 ▝▜█████▛▘  Bem-vindo de volta, Joel
   ▘▘ ▝▝    ~/primocode  · /dir <pasta> muda
 ```

package/bin/primocode.js

@@ -20,6 +20,7 @@ const { escolherModo } = require('../lib/modo.js');
 const api = require('../lib/api');
 const tools = require('../lib/tools');
 const cfg = require('../lib/config');
+const nomeProjeto = require('../lib/nome-projeto');
 const { runAct, interromper, ehTetoDeToken, ehTransitorio, esperaDoErro } = require('../lib/act');
 const fala = require('../lib/fala');
 const boasVindas = require('../lib/boas-vindas');
@@ -563,8 +564,25 @@ function planWorkDir(userText) {
     return { dir: cfg.ROOT_DIR, projeto: cfg.getProjectDir(proposto), pending: true, name: proposto };
 }
 
+/* O nome da pasta nova vem do modelo (lib/nome-projeto.js), pedido em
+   paralelo com o trabalho: a pasta só nasce na primeira escrita, e até lá a
+   resposta já chegou. Só pergunta quando o pedido é de CRIAR algo — pedir
+   para abrir o Chrome não gasta chamada com nome de pasta. */
+function batizarDepois(plan, userText) {
+    if (!plan.pending || !(RE_CRIAR_UM.test(semAcento(userText)) || PEDIDO_DE_CODIGO.test(userText))) return;
+    const perguntar = async (texto) => {
+        let resposta = '';
+        await api.requestChat(state.config.server, {
+            prompt: texto, history: [], model: state.config.model, token: state.config.token,
+        }, (evt) => { if (evt.delta) resposta += evt.delta; });
+        return resposta;
+    };
+    nomeProjeto.escolher({ pedido: userText, nomes: cfg.listProjects(), perguntar })
+        .then((nome) => { if (nome) plan.nomeEscolhido = nome; });
+}
+
 function createPendingProject(plan) {
-    const dir = cfg.createProjectDir(plan.name);
+    const dir = cfg.createProjectDir(plan.nomeEscolhido || plan.name);
     entrarNoProjeto(dir, 'projeto');
     const rotulo = plan.similar ? 'Continuando em' : 'Projeto novo:';
     console.log(c.ok(`  ${rotulo} ${state.currentProject}`) + c.muted(`  (${dir})`));
@@ -619,6 +637,7 @@ function prepararPasta(userText) {
     talvezTrocarDePasta(userText);
 
     const plan = planWorkDir(userText);
+    batizarDepois(plan, userText);
 
     // Projeto que já existe: entra nele AGORA. Se deixasse para depois, o
     // buildMemoryContext deste turno leria a pasta errada e a memória do projeto
@@ -914,7 +933,7 @@ async function sendPrompt(userText) {
                 : '';
             const pedido = passos[i].pedido + contexto + semFatos;
 
-            const rodarPasso = () => runAct(pedido, {
+            const rodarPasso = (texto = pedido) => runAct(texto, {
                 server: state.config.server,
                 model: state.config.model,
                 effort: state.config.effort,
@@ -937,15 +956,38 @@ async function sendPrompt(userText) {
             });
 
             r = await rodarPasso();
-            // Passo que desistiu (modelo mudo, voltas esgotadas) ganha UMA
-            // segunda chance — costuma ser tropeço transitório do modelo
-            // grátis. Falhou de novo: o plano segue com o aviso de "sem
-            // fatos", nunca com o texto da falha fantasiado de resultado.
-            if (!r.parado && r.concluiu === false && passos.length > 1) {
-                console.log(c.dim('  ⎿ o passo não concluiu — tentando de novo'));
-                r = await rodarPasso();
+            /* Passo que parou no meio NÃO devolve a tarefa para a pessoa
+               dividir. Se ele já tinha feito alguma coisa (arquivo, comando),
+               o próprio CLI pede a continuação — com a lista do que já existe
+               no disco, para não refazer. Até CONTINUACOES vezes, e só
+               enquanto cada volta produz algo: continuação que não mexe em
+               nada é laço, e laço para.
+               Num plano de vários passos, o passo que desistiu sem fazer nada
+               ganha UMA segunda chance — costuma ser tropeço transitório do
+               modelo grátis. Falhou de novo: o
+               plano segue com o aviso de "sem fatos", nunca com o texto da
+               falha fantasiado de resultado. */
+            let continuacoes = 0;
+            let tentouDeNovo = false;
+            while (!r.parado && r.concluiu === false) {
+                registro.juntar(livro, r.registro);
+                // Sem registro é erro do provedor (cota, rede): retomar só bate
+                // no mesmo muro.
+                if (r.registro && !registro.vazio(r.registro) && continuacoes < CONTINUACOES) {
+                    continuacoes++;
+                    console.log(c.dim('  ⎿ continuando de onde parou'));
+                    r = await rodarPasso(pedidoDeContinuacao(passos[i].pedido, livro));
+                    continue;
+                }
+                if (!tentouDeNovo && passos.length > 1 && registro.vazio(r.registro) && continuacoes === 0) {
+                    tentouDeNovo = true;
+                    console.log(c.dim('  ⎿ o passo não concluiu — tentando de novo'));
+                    r = await rodarPasso();
+                    continue;
+                }
+                break;
             }
-            registro.juntar(livro, r.registro);
+            if (r.concluiu !== false || r.parado) registro.juntar(livro, r.registro);
             jaFeito = (r.concluiu !== false)
                 ? String((r.assistantMessage && r.assistantMessage.content) || '').slice(0, 1200)
                 : '';
@@ -1002,6 +1044,18 @@ async function sendPrompt(userText) {
 const RE_DESCOBRIR = /\b(pesquis|busca|procur|descubr|investig|analis|leia|estud|olh[ae] (o site|a p[áa]gina)|ver o que)\w*/i;
 const RE_CRIAR_DEPOIS = /\b(cri[ae]|faz|faça|mont[ae]|ger[ae]|escrev[ae]|produz|desenvolv)\w*/i;
 
+/* A outra divisão que compensa: o pedido LONGO que emenda entregas diferentes
+   ("cria o site, depois põe login e publica"). Estreita de propósito — o
+   planejador dividindo pedido de uma fase só era o "faz coisas nada a ver" —
+   e o servidor ainda devolve passo único na dúvida. */
+const RE_ACAO = /\b(cri[ae]r?|fa[zç]a?|fazer|mont[ae]r?|ger[ae]r?|escrev[ae]r?|adicion[ae]r?|coloc[ae]r?|p[oõ]e|implement[ae]r?|public[ae]r?|sob[ea]|instal[ae]r?|configur[ae]r?|test[ae]r?|corrig[ei]r?|arrum[ae]r?|mud[ae]r?|integr[ae]r?|conect[ae]r?)\b/gi;
+function pedidoDeVariasPartes(pedido) {
+    const t = String(pedido || '');
+    if (t.length < 200) return false;
+    const acoes = new Set((t.match(RE_ACAO) || []).map((x) => x.toLowerCase().slice(0, 4)));
+    return acoes.size >= 3 && /\b(depois|em seguida|e tamb[ée]m|al[ée]m disso|por fim|e ent[ãa]o)\b|\n\s*(\d+[.)]|[-*•])\s/i.test(t);
+}
+
 /* "me manda o vídeo" resolvido na hora, sem gastar modelo.
  *
  * Antes isso abria a última criação do Studio no navegador com `#gravar`, e a
@@ -1038,12 +1092,33 @@ async function baixarCriacaoDireto(texto) {
     }
 }
 
+/* Quantas vezes um passo que parou no meio é retomado sozinho. */
+const CONTINUACOES = 2;
+
+/**
+ * O pedido de retomada: o pedido original + o que já existe, para o agente
+ * seguir em vez de recomeçar. A conversa do passo anterior não vai junto (é
+ * ela que estourou) — vai o que aconteceu no disco, que é o que importa.
+ */
+function pedidoDeContinuacao(original, livro) {
+    const linhas = [];
+    if (livro.criados.length) linhas.push(`Arquivos criados: ${livro.criados.slice(0, 20).join(', ')}`);
+    if (livro.alterados.length) linhas.push(`Arquivos alterados: ${livro.alterados.slice(0, 20).join(', ')}`);
+    const cmds = livro.comandos.slice(-8).map((x) => `${x.comando} (${x.ok ? 'ok' : 'falhou'})`);
+    if (cmds.length) linhas.push(`Comandos rodados: ${cmds.join('; ')}`);
+    const falhas = livro.falhas.slice(-3).map((f) => `${f.acao}: ${f.motivo}`);
+    if (falhas.length) linhas.push(`Falhas: ${falhas.join('; ')}`);
+    return `CONTINUAÇÃO — a tarefa abaixo já foi começada e parou no meio. NÃO recomece do zero: `
+        + `leia o que já existe, veja o que falta, divida o que falta em passos pequenos (write_todos) e termine.\n\n`
+        + `O QUE JÁ FOI FEITO:\n${linhas.join('\n') || '(nada registrado)'}\n\nA TAREFA:\n${original}`;
+}
+
 async function dividirTarefa(pedido) {
     const inteiro = [{ titulo: 'tarefa', pedido }];
     if (!pedido || pedido.trim().length < 12) return inteiro;
     // Sem as duas fases no texto, nem chama o servidor: mais rápido, e sem
     // dar ao modelo a chance de dividir o que não devia.
-    if (!(RE_DESCOBRIR.test(pedido) && RE_CRIAR_DEPOIS.test(pedido))) return inteiro;
+    if (!(RE_DESCOBRIR.test(pedido) && RE_CRIAR_DEPOIS.test(pedido)) && !pedidoDeVariasPartes(pedido)) return inteiro;
     const sp = new Spinner('Primo Code pensando').start();
     try {
         const r = await api.requestPlano(state.config.server, {
@@ -1691,6 +1766,27 @@ async function handleSlash(text) {
                     // Mesma memória do terminal: espera o resumo da rodada
                     // anterior e leva só ele, com o projeto atual.
                     await esperarResumo();
+                    /* O mesmo roteador do terminal: cumprimento e pergunta vão
+                       para a conversa, curta; só pedido de trabalho vai para o
+                       agente. Antes TUDO ia para o agente — até um "oi". */
+                    const escolha = escolherModo(texto, { ultimoModo: state.modoVoz });
+                    state.modoVoz = escolha.modo;
+                    if (escolha.modo === 'chat') {
+                        let resposta = '';
+                        try {
+                            await api.requestChat(state.config.server, {
+                                prompt: `${vozModo.COMO_CONVERSAR}\n\nA PESSOA DISSE: ${texto}`,
+                                history: state.history.slice(-4),
+                                model: state.config.model,
+                                token: state.config.token,
+                            }, (evt) => { if (evt.delta) resposta += evt.delta; });
+                        } catch { /* sem resposta: a orb volta a ouvir */ }
+                        resposta = resposta.trim();
+                        state.history.push({ role: 'user', content: texto });
+                        state.history.push({ role: 'assistant', content: resposta });
+                        resumirDepois();
+                        return resposta;
+                    }
                     const plan = prepararPasta(texto);
                     const resultado = await runAct(texto, {
                         instrucao: vozModo.COMO_FALAR,

package/lib/act.js

@@ -138,7 +138,10 @@ function logResult(kind, result, profundidade) {
     // vermelho que faz parecer que a tarefa morreu.
     if (result.ok === false) {
         const texto = String(result.error || `exit ${result.code ?? 'erro'}`).replace(/\s+/g, ' ').trim();
-        console.log(p + c.warn(texto.length > 160 ? texto.slice(0, 159) + '…' : texto));
+        // Erro de permissão não corta: a instrução que resolve ("Acessibilidade…
+        // peça de novo") fica justamente depois do 160º caractere.
+        const teto = result.permissao === false ? 400 : 160;
+        console.log(p + c.warn(texto.length > teto ? texto.slice(0, teto - 1) + '…' : texto));
         return;
     }
 
@@ -411,22 +414,63 @@ function pareceParadaNoMeio(texto, { todosPendentes = 0, rodouTool = false } = {
     return false;
 }
 
+/* O recado da troca de rota: não repete o que já tentou, quebra o que falta
+   em pedaços e faz o primeiro. Quem divide a tarefa é o agente, não a pessoa. */
+const TROCA_DE_ROTA = 'Você ficou três voltas sem conseguir rodar nada, repetindo chamadas que já tinha feito. '
+    + 'Não repita nenhuma delas. Olhe o que já está pronto na conversa, divida o que falta em passos pequenos '
+    + '(write_todos) e faça AGORA o primeiro passo, por um caminho diferente: outra ferramenta, outro arquivo, '
+    + 'outro comando. Se não houver caminho, chame finish e diga em uma frase o que impediu.';
+
 function motivoDaParada({ voltas, voltasEmFalso, falhasPendentes, travou }) {
     if (falhasPendentes.length) {
         return `Parei sem concluir. A última falha foi: ${falhasPendentes[falhasPendentes.length - 1].texto}`;
     }
     if (travou) {
-        return 'Travei repetindo as mesmas chamadas sem sair do lugar, e parei antes de gastar sua cota à toa. '
-            + 'Peça em partes: primeiro a pesquisa, depois o que criar com ela.';
+        return 'Fiquei preso: tentei dois caminhos e os dois voltaram ao mesmo lugar, então parei antes de gastar sua cota à toa. '
+            + 'O que já fiz está salvo. Diga "continua" que eu retomo daqui.';
     }
     if (voltas >= MAX_ITERATIONS) {
         const emFalso = voltasEmFalso
             ? ` ${voltasEmFalso} ${voltasEmFalso === 1 ? 'chamada foi repetida' : 'chamadas foram repetidas'} e não rodaram de novo.`
             : '';
-        return `Gastei as ${MAX_ITERATIONS} voltas sem chegar ao fim.${emFalso}`
-            + ' Peça em partes: primeiro a pesquisa, depois o que criar com ela.';
+        return `Usei as ${MAX_ITERATIONS} voltas deste pedido sem chegar ao fim.${emFalso}`
+            + ' O que já fiz está salvo. Diga "continua" que eu retomo daqui.';
     }
-    return 'Parei sem concluir e sem explicação do modelo. Tente pedir de novo, em partes menores.';
+    return 'Parei sem concluir e sem explicação do modelo. Diga "continua" que eu tento de novo daqui.';
+}
+
+/* ── O MAPA DO PROJETO ───────────────────────────────────────────────────
+ * "Continua o jogo" num projeto de vinte arquivos: o agente começava às
+ * cegas, gastava uma volta listando a pasta — ou, pior, escrevia um index.html
+ * novo por cima do que existia. Agora ele recebe, junto da memória, a lista dos
+ * arquivos do projeto (até 80, sem node_modules nem build), e sabe de saída
+ * onde está cada coisa. Só em pasta de projeto: a raiz ~/primocode lista
+ * outros projetos, não este. */
+const PULAR_NO_MAPA = new Set(['node_modules', '.git', 'dist', 'build', '.next', '.nuxt', 'out',
+    '.cache', 'coverage', '__pycache__', '.venv', 'venv', '.turbo', '.vercel', '.idea', '.vscode']);
+
+function mapaDoProjeto(dir, limite = 80) {
+    const path = require('path');
+    const fs = require('fs');
+    if (!dir || path.resolve(dir) === path.resolve(cfg.ROOT_DIR)) return '';
+    const achados = [];
+    const andar = (atual, fundo) => {
+        if (fundo > 4 || achados.length >= limite) return;
+        let itens = [];
+        try { itens = fs.readdirSync(atual, { withFileTypes: true }); } catch { return; }
+        itens.sort((a, b) => (a.isDirectory() === b.isDirectory() ? a.name.localeCompare(b.name) : a.isDirectory() ? 1 : -1));
+        for (const it of itens) {
+            if (achados.length >= limite) return;
+            if (PULAR_NO_MAPA.has(it.name) || (it.name.startsWith('.') && it.name !== '.env.example')) continue;
+            const cheio = path.join(atual, it.name);
+            if (it.isDirectory()) andar(cheio, fundo + 1);
+            else if (it.name !== 'memory.md') achados.push(path.relative(dir, cheio));
+        }
+    };
+    andar(dir, 0);
+    if (!achados.length) return '';
+    const mais = achados.length >= limite ? `\n… (mais arquivos — use glob para achar)` : '';
+    return `Arquivos que JÁ existem neste projeto (edite-os em vez de recriar):\n${achados.join('\n')}${mais}`;
 }
 
 function buildMemoryContext(projectDir, projectName) {
@@ -435,6 +479,8 @@ function buildMemoryContext(projectDir, projectName) {
     if (geral.trim()) parts.push(`[memory-geral.md]\n${geral}`);
     const projeto = cfg.readProjectMemory(projectDir);
     if (projeto.trim()) parts.push(`[${projectName || 'projeto'}/memory.md]\n${projeto}`);
+    const mapa = mapaDoProjeto(projectDir);
+    if (mapa) parts.push(`[${projectName || 'projeto'}/arquivos]\n${mapa}`);
     return parts.join('\n\n');
 }
 
@@ -460,6 +506,9 @@ async function runAct(userPrompt, opts) {
            Antes ela ia colada no texto, e a memória do projeto enchia de
            "[MODO VOZ] A sua resposta vai ser lida em voz alta…". */
         instrucao = '',
+        /* Quem abre a página para conferir antes do "pronto". Injetável pelo
+           mesmo motivo do `motor`: o teste mede a regra sem abrir um Chrome. */
+        medirPagina = (dir) => require('./pipeline.js').medirNoNavegador(dir),
     } = opts || {};
 
     // A pasta de projeto só nasce quando o agente for mesmo MEXER EM ARQUIVO.
@@ -481,6 +530,37 @@ async function runAct(userPrompt, opts) {
     };
     const falhasPendentes = [];
     let tentativasDeEncerrar = 0;
+    /* ── CONFERIR ANTES DE DIZER "PRONTO" ───────────────────────────────
+     * Mexeu em página (html, css, js) nesta tarefa? Antes de aceitar o
+     * `finish`, o PrimoCode abre a página num navegador invisível e olha: tela
+     * em branco, erro de JavaScript, recurso que não carregou. Achou problema,
+     * a tarefa volta para o agente com o relato — uma vez só, para não virar
+     * laço. É a diferença entre "pronto!" e "pronto, e abre". */
+    let mexeuNaPagina = false;       // mexeu desde a última conferência?
+    let conferencias = 0;            // até duas: entregar, e conferir o conserto
+    let avisoDaPagina = '';          // o que ainda estava quebrado na última
+    /* Abre a página e devolve o relato quando é para VOLTAR (achou problema e
+       ainda cabe uma volta); null quando é para entregar. O que ficar
+       quebrado na última conferência fica em `avisoDaPagina`, e a entrega sai
+       com ele — nunca "pronto" seco sobre uma página com erro. Vale para os
+       dois jeitos de terminar: a ferramenta finish e a resposta em texto. */
+    const conferirPagina = async () => {
+        if (subagent || !mexeuNaPagina || conferencias >= 2 || PARAR) return null;
+        conferencias++;
+        mexeuNaPagina = false;
+        let medida = null;
+        try {
+            fala.pensamento('abrindo a página para conferir antes de entregar', profundidade);
+            medida = await medirPagina(pastaAtual);
+        } catch { medida = null; }
+        if (!medida || !medida.testou) return null;
+        avisoDaPagina = medida.limpo ? ''
+            : String(medida.relato || '').split('\n').filter((l) => /·|BRANCO/.test(l)).slice(0, 3).join(' ');
+        if (medida.limpo) { fala.pensamento('a página abriu sem erro', profundidade); return null; }
+        return conferencias >= 2 ? null : medida.relato;
+    };
+    const comAviso = (texto) => (avisoDaPagina
+        ? `${texto}\n\nAtenção: abri a página e ela ainda tem problema — ${avisoDaPagina.trim()}` : texto);
     // Quem já foi chamado, e quantas vezes. Ver lib/repeticao.js.
     const jaChamado = repeticao.novo();
     /* O livro deste pedido: arquivos, comandos, links, testes e falhas. Sai
@@ -521,6 +601,7 @@ async function runAct(userPrompt, opts) {
     // assim que "crie um vídeo para a tostudy" morreu sem entregar nada.
     let pesquisasSecas = 0;
     let rodadasParadas = 0;
+    let trocouDeRota = false;
     /* Para o `pareceParadaNoMeio`: se alguma tool já rodou nesta tarefa, e o
        último plano que o modelo escreveu (write_todos) — desta TAREFA, não da
        sessão: um plano velho, de um pedido interrompido, não pode empurrar o
@@ -822,6 +903,21 @@ async function runAct(userPrompt, opts) {
                 finalText = '';
                 continue;
             }
+            // Terminou falando, sem chamar finish: confere a página do mesmo jeito.
+            if (finalText) {
+                const relato = await conferirPagina();
+                if (relato) {
+                    messages.push({ role: 'assistant', content: finalText });
+                    messages.push({
+                        role: 'user',
+                        content: `AINDA NÃO. Abri a página para conferir e ela tem problema:\n${relato}\n\n`
+                            + 'Conserte (leia o arquivo antes de editar) e finalize de novo.',
+                    });
+                    finalText = '';
+                    continue;
+                }
+                finalText = comAviso(finalText);
+            }
             if (!subagent) {
                 if (fluxo) fluxo.fechar();
                 else fala.resposta(finalText);
@@ -873,6 +969,18 @@ async function runAct(userPrompt, opts) {
 
         for (const tc of toolCalls) {
             if (PARAR) break;
+            if (tc.name === 'finish') {
+                const relato = await conferirPagina();
+                if (relato) {
+                    messages.push({
+                        role: 'tool',
+                        tool_call_id: tc.id,
+                        content: `AINDA NÃO. Abri a página para conferir e ela tem problema:\n${relato}\n\n`
+                            + 'Conserte (leia o arquivo antes de editar) e chame finish de novo.',
+                    });
+                    continue;
+                }
+            }
             if (tc.name === 'finish') {
                 // Encerrar com falha pendente é como o agente dizia "pronto!"
                 // sem ter mudado nada. Devolvemos a tarefa para ele.
@@ -887,7 +995,7 @@ async function runAct(userPrompt, opts) {
                     continue;
                 }
                 algoRodou = true;
-                finished = (tc.arguments && tc.arguments.summary) || 'Concluído.';
+                finished = comAviso((tc.arguments && tc.arguments.summary) || 'Concluído.');
                 messages.push({ role: 'tool', tool_call_id: tc.id, content: 'ok' });
                 continue;
             }
@@ -899,6 +1007,7 @@ async function runAct(userPrompt, opts) {
                     : await runSubagent(tc.arguments || {}, {
                         server, model, token, projectDir: pastaAtual, projectName, profundidade, motor,
                     });
+                repeticao.executou(jaChamado, tc.name, tc.arguments);
                 messages.push({ role: 'tool', tool_call_id: tc.id, content: r });
                 continue;
             }
@@ -930,6 +1039,7 @@ async function runAct(userPrompt, opts) {
                     server, model, token, projectDir: pastaAtual, projectName, profundidade, motor, livro, autorizar, controle: portaoControle,
                 });
                 logResult(tc.name, r, profundidade);
+                repeticao.executou(jaChamado, tc.name, tc.arguments);
                 messages.push({ role: 'tool', tool_call_id: tc.id, content: JSON.stringify(r) });
                 if (r && r.ok && catalogo.escreveArquivo(tc.name)) temPasta = true;
                 continue;
@@ -982,11 +1092,16 @@ async function runAct(userPrompt, opts) {
             fala.acao(tc.name, tc.arguments, profundidade);
             const result = await tools.execute(tc.name, tc.arguments, { projectDir: pastaAtual });
             logResult(tc.name, result, profundidade);
+            repeticao.executou(jaChamado, tc.name, tc.arguments);
             if (tc.name === 'write_todos' && result && Array.isArray(result.todos)) todosDaTarefa = result.todos;
             // Além de narrar, ANOTA: no fim do pedido sai o balanço do que
             // nasceu, mudou, rodou e falhou. Narrar sozinho não basta — numa
             // tarefa de trinta ações, a primeira já saiu da tela.
             registro.anotar(livro, tc.name, tc.arguments, result);
+            if (result && result.ok !== false && catalogo.criaProjeto(tc.name, tc.arguments)
+                && /\.(html?|css|m?jsx?|tsx?|vue|svelte)$/i.test(String((tc.arguments && tc.arguments.path) || ''))) {
+                mexeuNaPagina = true;
+            }
 
             // Uma escrita bem-sucedida limpa a dívida — mas só a do MESMO
             // arquivo. Escrever algo sem relação (ou um run_shell qualquer)
@@ -1032,6 +1147,16 @@ async function runAct(userPrompt, opts) {
         // terminar no mesmo lugar — melhor parar e devolver a vez ao usuário.
         if (!algoRodou && toolCalls.length) {
             rodadasParadas++;
+            /* Antes de desistir, UMA troca de rota, sem aparecer na tela. Parar
+               aqui devolvia ao usuário o trabalho de dividir a tarefa — que é
+               justamente o que ele não sabe fazer e o sistema sabe: o que já
+               foi feito está na conversa, e o que falta é outro caminho. */
+            if (rodadasParadas >= MAX_RODADAS_PARADAS && !trocouDeRota) {
+                trocouDeRota = true;
+                rodadasParadas = 0;
+                messages.push({ role: 'user', content: TROCA_DE_ROTA });
+                continue;
+            }
             // Quem fala é o motivoDaParada, uma vez só — aqui havia uma
             // segunda frase de "travei", e as duas saíam em sequência.
             if (rodadasParadas >= MAX_RODADAS_PARADAS) break;

package/lib/browser.js

@@ -463,6 +463,9 @@ async function ensure(url) {
 // ---- Ações ------------------------------------------------------
 async function open(url) {
     await ensure(url);
+    // A janela vem para a frente: quem pediu "abre o youtube" quer VER abrir,
+    // não descobrir depois que havia um Chrome atrás do terminal.
+    if (verSeta()) { try { await currentSession.send('Page.bringToFront'); } catch { /* segue */ } }
     // Navega até URL solicitada
     await currentSession.send('Page.navigate', { url });
     // Espera "load" simples via polling do document.readyState
@@ -486,8 +489,73 @@ async function evaluate(js) {
     return r.result ? r.result.value : undefined;
 }
 
-async function click(x, y) {
+/* ── A SETA DO PRIMO DENTRO DA PÁGINA ────────────────────────────────────
+ *   "Quando a IA vai mexer no computador, eu não consigo ver ela mexendo."
+ *
+ * O clique no navegador vai pelo CDP (Input.dispatchMouseEvent): acontece de
+ * verdade, mas nada anda na tela — a página só muda, do nada. Medido no
+ * pedido "abra o youtube e abra o vídeo mais recente". Então, antes de cada
+ * clique e de cada digitação, uma seta desenhada NA página desliza até o
+ * alvo com o que ela vai fazer ("clicando em Pesquisar"), e o clique deixa
+ * uma onda. É DOM, não o mouse do sistema: funciona em qualquer SO, sem
+ * permissão, e não rouba o mouse de quem está usando o computador.
+ *
+ * PRIMOCODE_SEM_CURSOR=1 (e o navegador sem tela) desliga: nos testes e no
+ * servidor ninguém está olhando, e a animação só custaria tempo. */
+const DESLIZE_MS = 450;
+function verSeta() {
+    return process.env.PRIMOCODE_SEM_CURSOR !== '1'
+        && !(process.env.PRIMOCODE_BROWSER_HEADLESS === '1' || process.env.PRIMOCODE_BROWSER_HEADLESS === 'true');
+}
+
+function scriptDaSeta(x, y, rotulo, onda) {
+    return `(function(){
+        var id = '__primo_seta';
+        var s = document.getElementById(id);
+        if (!s) {
+            s = document.createElement('div');
+            s.id = id;
+            s.setAttribute('aria-hidden', 'true');
+            s.style.cssText = 'position:fixed;left:0;top:0;z-index:2147483647;pointer-events:none;'
+                + 'transition:transform ${DESLIZE_MS}ms cubic-bezier(.2,.7,.2,1);will-change:transform;'
+                + 'transform:translate(' + (innerWidth / 2) + 'px,' + (innerHeight / 2) + 'px)';
+            s.innerHTML = '<svg width="26" height="26" viewBox="0 0 24 24" style="display:block;filter:drop-shadow(0 2px 3px rgba(2,6,23,.45))">'
+                + '<path d="M3 2 L3 19 L8 14.5 L11.5 22 L14.5 20.6 L11 13.2 L18 13.2 Z" fill="#22d3ee" stroke="#0f172a" stroke-width="1.4" stroke-linejoin="round"/></svg>'
+                + '<div data-rotulo style="position:absolute;left:24px;top:18px;white-space:nowrap;font:600 12px/1 system-ui,sans-serif;'
+                + 'color:#0f172a;background:#22d3ee;padding:5px 8px;border-radius:6px;box-shadow:0 2px 6px rgba(2,6,23,.3)"></div>';
+            document.documentElement.appendChild(s);
+            s.getBoundingClientRect();
+        }
+        var r = s.querySelector('[data-rotulo]');
+        r.textContent = ${JSON.stringify(String(rotulo || '').slice(0, 48))};
+        r.style.display = r.textContent ? 'block' : 'none';
+        s.style.transform = 'translate(${Math.round(x)}px,${Math.round(y)}px)';
+        if (${onda ? 'true' : 'false'}) setTimeout(function(){
+            var o = document.createElement('div');
+            o.style.cssText = 'position:fixed;left:${Math.round(x) - 16}px;top:${Math.round(y) - 16}px;width:32px;height:32px;'
+                + 'border-radius:50%;border:3px solid #22d3ee;z-index:2147483646;pointer-events:none;'
+                + 'transition:transform .5s ease-out,opacity .5s ease-out;transform:scale(.3);opacity:1';
+            document.documentElement.appendChild(o);
+            o.getBoundingClientRect();
+            o.style.transform = 'scale(1.6)'; o.style.opacity = '0';
+            setTimeout(function(){ o.remove(); }, 600);
+        }, ${DESLIZE_MS});
+        return true;
+    })()`;
+}
+
+/** Leva a seta até (x, y) e espera ela chegar. Nunca falha a ação por causa dela. */
+async function mostrarSeta(x, y, rotulo = '', { onda = true } = {}) {
+    if (!verSeta() || !currentSession) return;
+    try {
+        await currentSession.send('Runtime.evaluate', { expression: scriptDaSeta(x, y, rotulo, onda) });
+        await sleep(DESLIZE_MS + 60);
+    } catch { /* a seta é para quem olha; a ação segue sem ela */ }
+}
+
+async function click(x, y, rotulo = 'clicando') {
     await ensure();
+    await mostrarSeta(x, y, rotulo);
     await currentSession.send('Input.dispatchMouseEvent', { type: 'mouseMoved', x, y });
     await currentSession.send('Input.dispatchMouseEvent', { type: 'mousePressed', x, y, button: 'left', clickCount: 1 });
     await currentSession.send('Input.dispatchMouseEvent', { type: 'mouseReleased', x, y, button: 'left', clickCount: 1 });
@@ -507,7 +575,8 @@ async function clickText(text) {
                 if (r.width && r.height) {
                     el.scrollIntoView({block:'center'});
                     const r2 = el.getBoundingClientRect();
-                    return { x: r2.left + r2.width/2, y: r2.top + r2.height/2, tag: el.tagName, text: s.slice(0,80) };
+                    const nome = (el.innerText || el.value || el.getAttribute('aria-label') || '').trim().replace(/\s+/g, ' ');
+                    return { x: r2.left + r2.width/2, y: r2.top + r2.height/2, tag: el.tagName, text: s.slice(0,80), nome: nome.slice(0,30) };
                 }
             }
         }
@@ -516,7 +585,7 @@ async function clickText(text) {
     const found = await evaluate(js);
     if (!found) throw new Error(`nenhum elemento clicável encontrado com texto: ${text}`);
     await sleep(200);
-    await click(found.x, found.y);
+    await click(found.x, found.y, `clicando em ${found.nome || found.text}`.slice(0, 44));
     return { ok: true, ...found };
 }
 
@@ -595,13 +664,14 @@ async function clickSelector(selector) {
         if (!el) return null;
         el.scrollIntoView({block:'center'});
         const r = el.getBoundingClientRect();
-        return { x: r.left + r.width/2, y: r.top + r.height/2, tag: el.tagName };
+        const nome = (el.getAttribute('aria-label') || el.innerText || el.value || el.placeholder || '').trim().replace(/\s+/g, ' ').slice(0, 30);
+        return { x: r.left + r.width/2, y: r.top + r.height/2, tag: el.tagName, nome };
     })()`;
     let found = await evaluate(js);
     if (!found && await esperarSeletor(selector)) found = await evaluate(js);
     if (!found) throw await erroDeSeletor(selector);
     await sleep(200);
-    await click(found.x, found.y);
+    await click(found.x, found.y, found.nome ? `clicando em ${found.nome}`.slice(0, 44) : 'clicando');
     return { ok: true, selector, ...found };
 }
 
@@ -619,13 +689,16 @@ async function typeInSelector(selector, text, clear = true) {
     const focar = () => evaluate(`(function(){
         const el = document.querySelector(${JSON.stringify(selector)});
         if (!el) return false;
+        el.scrollIntoView({block:'center'});
         el.focus();
         ${clear ? "if ('value' in el) el.value = '';" : ''}
-        return true;
+        const r = el.getBoundingClientRect();
+        return { x: r.left + Math.min(24, r.width / 2), y: r.top + r.height / 2 };
     })()`);
     let focused = await focar();
     if (!focused && await esperarSeletor(selector)) focused = await focar();
     if (!focused) throw await erroDeSeletor(selector);
+    await mostrarSeta(focused.x, focused.y, `digitando: ${text}`.slice(0, 44), { onda: false });
     await type(text);
     // dispara evento input para frameworks reativos
     await evaluate(`(function(){
@@ -1043,6 +1116,7 @@ function fecharRevisor() {
 }
 
 module.exports = {
+    scriptDaSeta, verSeta,
     open, click, clickText, clickSelector, type, typeInSelector,
     key, screenshot, evaluate, waitFor, wait, scroll, close,
     inspecionarEscondido, rodarEscondido, abrirEscondido, fecharRevisor,

package/lib/cursor.js

@@ -39,10 +39,16 @@ function pythonComQuartz() {
     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 };
     }
+    // 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. */
@@ -54,8 +60,11 @@ function subir() {
         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']);
+            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'], {

package/lib/nome-projeto.js

@@ -0,0 +1,97 @@
+/**
+ * nome-projeto.js — quem dá nome à pasta é quem entendeu o pedido.
+ *
+ *   "Quero que ele dê nome às pastas que criar. Ele escolhe o nome, ele
+ *    entendeu o contexto, ele analisa os outros projetos." (23/09/2026)
+ *
+ * O nome saía de `deriveProjectName`: cortar as palavras de abertura da frase
+ * e ficar com até quatro. Funciona para "crie um jogo de carro", e erra tudo
+ * que não começa assim — "aquela ideia do cardápio que falei, bora fazer" vira
+ * `aquela-ideia-do-cardapio`. Quem sabe o que está sendo feito é o modelo.
+ *
+ * ── COMO ─────────────────────────────────────────────────────────────────
+ * Uma pergunta curta ao modelo, com o pedido e os nomes das pastas que já
+ * existem, para ele seguir o mesmo jeito (idioma, tamanho, prefixo). Ela
+ * roda em PARALELO com o trabalho: a pasta só nasce na primeira escrita, e
+ * até lá a resposta já chegou. Se não chegou, ou veio lixo, vale o nome de
+ * antes — nome pior é melhor que pasta nenhuma.
+ *
+ * Puro, menos `escolher`, que recebe quem pergunta de fora (teste sem rede).
+ */
+
+'use strict';
+
+const { slugify } = require('./config.js');
+
+// Nome que não diz nada: o modelo devolveu isso, é como não ter respondido.
+const GENERICOS = new Set(['projeto', 'project', 'app', 'site', 'novo', 'teste', 'test', 'meu-projeto', 'my-project']);
+const TEMPO_MAXIMO_MS = 8000;
+
+/** O jeito das pastas que a pessoa já tem, para o modelo seguir. */
+function convencao(nomes) {
+    const lista = (nomes || []).filter((n) => n && !n.startsWith('.'));
+    if (!lista.length) return null;
+    const hifen = lista.filter((n) => n.includes('-')).length;
+    const sublinhado = lista.filter((n) => n.includes('_')).length;
+    const separador = sublinhado > hifen ? '_' : '-';
+    const palavras = lista.map((n) => n.split(/[-_]/).length);
+    const media = Math.round(palavras.reduce((a, b) => a + b, 0) / palavras.length);
+    return { separador, palavras: Math.min(4, Math.max(1, media)), exemplos: lista.slice(0, 12) };
+}
+
+/** A pergunta. Curta: vai numa chamada à parte, e cada token conta. */
+function pergunta(pedido, nomes) {
+    const c = convencao(nomes);
+    const jeito = c
+        ? `Pastas que a pessoa já tem: ${c.exemplos.join(', ')}. Siga o mesmo jeito (idioma, tamanho, separador "${c.separador}"), `
+          + 'e NÃO repita um nome que já existe.'
+        : 'Use kebab-case em português, de 1 a 3 palavras.';
+    return 'Dê um nome curto para a pasta do projeto deste pedido. O nome diz O QUE é '
+        + '(ex.: site-padaria, jogo-de-carro, loja-roupas), nunca o que a pessoa pediu para fazer. '
+        + `${jeito} Responda SÓ com o nome, sem aspas e sem explicação.\n\nPEDIDO: ${String(pedido || '').slice(0, 600)}`;
+}
+
+/** Limpa a resposta do modelo. Devolve null quando não dá para confiar nela. */
+function limpar(resposta, nomes) {
+    const primeira = String(resposta || '').trim().split('\n')[0]
+        .replace(/^[`"'*\s]+|[`"'*.\s]+$/g, '')
+        .replace(/^(nome|pasta)\s*:\s*/i, '');
+    if (!primeira || primeira.length > 60 || primeira.split(/\s+/).length > 5) return null;
+    const c = convencao(nomes);
+    let nome = slugify(primeira).split('-').filter(Boolean).slice(0, 4).join('-');
+    if (!nome || GENERICOS.has(nome)) return null;
+    if (c && c.separador === '_') nome = nome.replace(/-/g, '_');
+    return semColisao(nome, nomes);
+}
+
+/** Nome que já existe ganha -2, -3… — escrever na pasta de outro projeto é pior que um sufixo. */
+function semColisao(nome, nomes) {
+    const tomados = new Set((nomes || []).map((n) => String(n).toLowerCase()));
+    if (!tomados.has(nome)) return nome;
+    for (let i = 2; i < 100; i++) {
+        const outro = `${nome}-${i}`;
+        if (!tomados.has(outro)) return outro;
+    }
+    return `${nome}-${Date.now()}`;
+}
+
+/**
+ * Pergunta o nome ao modelo. Nunca rejeita: sem resposta boa a tempo,
+ * devolve null e quem chamou fica com o nome de antes.
+ *
+ * `perguntar(texto)` → Promise<string> é quem fala com o servidor.
+ */
+async function escolher({ pedido, nomes, perguntar, tempo = TEMPO_MAXIMO_MS }) {
+    let relogio;
+    const estourou = new Promise((r) => { relogio = setTimeout(() => r(null), tempo); });
+    try {
+        const resposta = await Promise.race([perguntar(pergunta(pedido, nomes)), estourou]);
+        return resposta == null ? null : limpar(resposta, nomes);
+    } catch {
+        return null;
+    } finally {
+        clearTimeout(relogio);
+    }
+}
+
+module.exports = { convencao, pergunta, limpar, semColisao, escolher, GENERICOS };

package/lib/repeticao.js

@@ -83,8 +83,61 @@ function consultaDe(nome, args) {
     return String(a.consulta || a.query || '');
 }
 
+/* ── A ÉPOCA: repetir depois de mudar algo não é repetir ────────────────
+ * Medido: "edita o arquivo → roda npm test → edita → roda npm test". O
+ * segundo `npm test` tinha os mesmos argumentos do primeiro e era barrado —
+ * o agente nunca via se o conserto funcionou, ficava três voltas sem rodar
+ * nada e morria com "peça em partes". O mesmo com reler um arquivo depois de
+ * editá-lo, ou tirar outra foto da tela depois de clicar.
+ *
+ * Então olhar o mundo (ler, listar, rodar teste, fotografar a tela) vale por
+ * ÉPOCA: cada mudança de verdade (escrever, editar, clicar, rodar um comando
+ * que não é só de leitura) abre uma época nova, e a mesma leitura volta a
+ * valer. O laço de verdade — a mesma chamada sem nada mudar no meio — segue
+ * barrado. Pesquisa na web e documento de referência não dependem do disco:
+ * ficam fora da época. */
+const OBSERVAM = new Set(['read_file', 'list_dir', 'glob', 'grep', 'browser_read', 'browser_screenshot',
+    'desktop_screenshot', 'desktop_size', 'desktop_windows', 'desktop_elements']);
+const NAO_MUDAM = new Set(['write_todos', 'remember_general', 'pesquisar_referencia', ...REFERENCIAS]);
+const SHELL_SO_LEITURA = /^\s*(ls|cat|head|tail|pwd|echo|grep|rg|find|wc|tree|stat|file|which|type|du|df|env|printenv|date|git\s+(status|log|diff|show|branch|remote))\b[^;&|>]*$/;
+
+function comandoDe(args) {
+    return String((args && (args.command || args.comando)) || '');
+}
+
+/** Só olha: ler de novo depois de uma mudança é trabalho, não laço. */
+function observa(nome, args) {
+    if (OBSERVAM.has(nome)) return true;
+    return nome === 'run_shell' && SHELL_SO_LEITURA.test(comandoDe(args));
+}
+
+/** Muda o mundo: abre uma época nova. */
+function muda(nome, args) {
+    return !observa(nome, args) && !NAO_MUDAM.has(nome);
+}
+
 function novo() {
-    return { vistos: new Map(), buscas: [] };
+    return { vistos: new Map(), buscas: [], epoca: 0, epocaDaMudanca: 0, ultimaMudanca: null, olhouDesde: false };
+}
+
+/**
+ * Avisa que a chamada RODOU. Quem chama faz isto depois de executar (e não
+ * de barrar): é o que abre a época nova.
+ *
+ * A mesma mudança repetida sem olhar nada no meio (escrever o mesmo conteúdo
+ * no mesmo arquivo, clicar no mesmo ponto às cegas) não abre época e é
+ * barrada já na segunda vez — senão o laço de escrita passaria livre.
+ */
+function executou(registro, nome, args) {
+    if (observa(nome, args)) { registro.olhouDesde = true; return; }
+    if (!muda(nome, args)) return;
+    const chave = assinatura(nome, args);
+    if (chave !== registro.ultimaMudanca || registro.olhouDesde) {
+        registro.epocaDaMudanca = registro.epoca;
+        registro.epoca++;
+    }
+    registro.ultimaMudanca = chave;
+    registro.olhouDesde = false;
 }
 
 /**
@@ -94,8 +147,14 @@ function novo() {
  * NÃO deve executar a tool: manda o `aviso` de volta como resultado.
  */
 function ver(registro, nome, args) {
-    const chave = assinatura(nome, args);
     const busca = consultaDe(nome, args);
+    const foraDaEpoca = busca !== null || REFERENCIAS.has(nome);
+    const base = assinatura(nome, args);
+    // A mesma mudança logo em seguida, sem olhar nada no meio, conta na época
+    // em que a primeira rodou — senão ela mesma abriria a porta da segunda.
+    const epoca = (base === registro.ultimaMudanca && !registro.olhouDesde)
+        ? registro.epocaDaMudanca : (registro.epoca || 0);
+    const chave = base + (foraDaEpoca ? '' : `@${epoca}`);
 
     let vezes = (registro.vistos.get(chave) || 0) + 1;
     let parecidaCom = null;
@@ -123,14 +182,15 @@ function ver(registro, nome, args) {
 function aviso(nome, vezes, parecidaCom) {
     const oQue = parecidaCom
         ? `Você já pesquisou isto: "${parecidaCom}". A busca de agora é a mesma coisa com outras palavras, e traria as mesmas fontes.`
-        : `Você já chamou ${nome} com estes mesmos argumentos.`;
+        : `Você já chamou ${nome} com estes mesmos argumentos, e nada mudou desde então.`;
 
     if (vezes === 2) {
         return `${oQue} O resultado está na conversa acima — role para cima e use o que já tem. `
             + 'Não chame esta tool de novo com os mesmos argumentos.';
     }
     return `${oQue} Esta é a ${vezes}ª vez, e a tool NÃO foi executada. PARE de repetir: `
-        + 'com o que você já tem, produza AGORA o resultado que o usuário pediu (crie o arquivo, o documento, o vídeo). '
+        + 'com o que você já tem, produza AGORA o resultado que o usuário pediu (crie o arquivo, o documento, o vídeo), '
+        + 'ou tente OUTRO caminho (outra ferramenta, outro arquivo, outro comando). '
         + 'Se algo realmente impede, chame finish e diga ao usuário o que faltou.';
 }
 
@@ -187,5 +247,5 @@ function referenciasNaConversa(messages) {
 module.exports = {
     REFERENCIAS, LIMITE_SEMELHANCA,
     normalizar, palavras, semelhanca, assinatura, consultaDe,
-    novo, ver, chamadasPorId, referenciasNaConversa,
+    novo, ver, executou, observa, muda, chamadasPorId, referenciasNaConversa,
 };

package/lib/tools.js

@@ -22,16 +22,38 @@ const cursor = require('./cursor');
  * 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. */
+/* Sem o cursor, a ação vai pelo caminho antigo, que NÃO aparece na tela. Isso
+   era calado: a pessoa via o terminal dizer "ok" e nada se mexer. Agora sai
+   uma linha, uma vez por sessão, dizendo por quê — e o modelo recebe o
+   mesmo aviso junto do resultado, para contar em vez de fingir. */
+let avisouSemCursor = false;
+function semCursorVisivel(resultado, motivo) {
+    const aviso = `o cursor do Primo não abriu (${motivo || 'motivo desconhecido'}): a ação roda, mas não aparece na tela`;
+    if (!avisouSemCursor) {
+        avisouSemCursor = true;
+        try { console.log(require('./ui.js').c.warn(`  ⎿ ${aviso}`)); } catch { /* sem tela */ }
+    }
+    return resultado && typeof resultado === 'object' ? { ...resultado, avisoCursor: aviso } : resultado;
+}
+
 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.semCursor) return semCursorVisivel(await reserva(), r.error);
     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}` };
@@ -643,8 +665,16 @@ async function despachar(name, args, ctx) {
                 return desktop.listWindows();
             case 'desktop_focus':
                 return desktop.focusWindow(args.window || args.title || '');
-            case 'desktop_elements':
-                return desktop.uiElements(args.window);
+            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 || '', {
@@ -656,11 +686,21 @@ async function despachar(name, args, ctx) {
                 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);
+                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}" na janela "${lidos.janela}".`,
-                        elementosDisponiveis: lidos.elementos.slice(0, 40).map((e) => e.nome),
+                    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, {

package/lib/voz.js

@@ -62,6 +62,12 @@ ${DICA_COMPUTADOR}
 Faça o trabalho inteiro normalmente, com as ferramentas de sempre. O que muda
 é só o jeito de contar no fim.`;
 
+/* A forma da resposta de CONVERSA por voz ("oi", "tudo bem?", "o que você
+   faz?"). Sem ferramenta e sem memória de tarefa: um "oi" ia para o agente
+   inteiro, com a lista das tarefas antigas e a ordem de mexer no cursor, e
+   ele respondia falando delas — "eu mandei oi e ele respondeu nada a ver". */
+const COMO_CONVERSAR = `[MODO VOZ] A sua resposta vai ser LIDA EM VOZ ALTA. Responda ao que a pessoa acabou de dizer, e só a isso, em uma ou duas frases curtas, em português falado, sem markdown. Não puxe assunto de tarefa antiga. Se for só um cumprimento, cumprimente de volta e pergunte o que ela quer fazer.`;
+
 /** Onde está o Python 3. Mesmo problema do Estúdio, mesma cura. */
 function python() {
     const nomes = process.platform === 'win32'
@@ -430,6 +436,7 @@ const OPCIONAIS = () => [
     ...(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)'],
     ] : []),
 ];
 
@@ -574,4 +581,4 @@ async function preparar(aoFalar = () => {}) {
     return { ok: true, python: py, esperando, avisos };
 }
 
-module.exports = { DICA_COMPUTADOR, conferir, instalar, preparar, porqueOPipFalhou, abrir, conferirEspera, baixarEspera, python, COMO_FALAR, PASTA };
+module.exports = { DICA_COMPUTADOR, COMO_CONVERSAR, conferir, instalar, preparar, porqueOPipFalhou, abrir, conferirEspera, baixarEspera, python, COMO_FALAR, PASTA };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "primocode",
-  "version": "9.6.0",
+  "version": "9.8.0-beta.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/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"
+    "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/voz-conversa.test.js && node test/modo.test.js && node test/pasta.test.js && node test/projeto.test.js && node test/nome-projeto.test.js && node test/conferir.test.js && node test/catalogo.test.js && node test/desktop.test.js && node test/seta.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/autonomia.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.

package/voz/primo_voz/__main__.py

@@ -243,8 +243,10 @@ class Voz:
                 continue
 
             self.orb.mudar(estado="pensando")
-            texto = self._transcrever(wav)
-            if not texto or len(texto.strip()) < 2:
+            # O servidor também transcreve com Whisper: a mesma limpeza vale.
+            texto = transcrever.limpar(self._transcrever(wav))
+            if not texto:
+                self.orb.mudar(estado="esperando")
                 continue
 
             falar_para_o_node({"tipo": "pedido", "texto": texto})

package/voz/primo_voz/cursor.py

@@ -171,6 +171,72 @@ def digitar(texto: str) -> None:
             time.sleep(0.008)
 
 
+# ── Ler a tela (OCR) ──────────────────────────────────────────────────────
+# "Clicar no texto X" em QUALQUER app, e não só nos que expõem botões pela
+# acessibilidade: fotografa a tela e reconhece o texto com o Vision do macOS
+# (o mesmo do Jarvis, motor/screen.py). Cada trecho volta com o CENTRO em
+# pontos da tela — a mesma unidade dos cliques.
+
+def tela_liberada() -> bool:
+    try:
+        return bool(Quartz.CGPreflightScreenCaptureAccess())
+    except Exception:
+        return True
+
+
+def ler_tela(largura: float, altura: float, arquivo: str = "") -> dict:
+    try:
+        import Vision
+    except Exception:
+        return {"ok": False, "error": "falta o pyobjc-framework-Vision para ler a tela"}
+    if arquivo:
+        # Só para o teste: lê uma imagem do disco em vez da tela.
+        from Foundation import NSURL
+        fonte = Quartz.CGImageSourceCreateWithURL(NSURL.fileURLWithPath_(arquivo), None)
+        img = Quartz.CGImageSourceCreateImageAtIndex(fonte, 0, None) if fonte else None
+    else:
+        if not tela_liberada():
+            try:
+                Quartz.CGRequestScreenCaptureAccess()
+            except Exception:
+                pass
+            return {"ok": False, "permissaoTela": False,
+                    "error": "o macOS não deixou ver a tela. Libere o Terminal (ou o app de onde você "
+                             "abriu o PrimoCode) em Ajustes do Sistema > Privacidade e Segurança > "
+                             "Gravação de Tela, e peça de novo."}
+        img = Quartz.CGWindowListCreateImage(Quartz.CGRectInfinite, Quartz.kCGWindowListOptionOnScreenOnly,
+                                             Quartz.kCGNullWindowID, Quartz.kCGWindowImageDefault)
+    if img is None:
+        return {"ok": False, "error": "não consegui fotografar a tela"}
+
+    pedido = Vision.VNRecognizeTextRequest.alloc().init()
+    pedido.setRecognitionLevel_(Vision.VNRequestTextRecognitionLevelAccurate)
+    pedido.setUsesLanguageCorrection_(True)
+    try:
+        pedido.setRecognitionLanguages_(["pt-BR", "en-US"])
+    except Exception:
+        pass
+    leitor = Vision.VNImageRequestHandler.alloc().initWithCGImage_options_(img, None)
+    ok, erro = leitor.performRequests_error_([pedido], None)
+    if not ok:
+        return {"ok": False, "error": f"o Vision não leu a tela: {erro}"}
+    textos = []
+    for obs in (pedido.results() or []):
+        candidatos = obs.topCandidates_(1)
+        if not candidatos:
+            continue
+        texto = str(candidatos[0].string()).strip()
+        if not texto:
+            continue
+        bb = obs.boundingBox()      # normalizado, origem embaixo à esquerda
+        cx = (bb.origin.x + bb.size.width / 2) * largura
+        cy = (1 - (bb.origin.y + bb.size.height / 2)) * altura
+        textos.append({"texto": texto, "x": round(cx), "y": round(cy),
+                       "confianca": round(float(candidatos[0].confidence()), 2)})
+    textos.sort(key=lambda t: (t["y"], t["x"]))
+    return {"ok": True, "textos": textos}
+
+
 # ── A janela do cursor ──────────────────────────────────────────────────────
 
 class VistaCursor(NSView):
@@ -431,6 +497,8 @@ def executar(cur: Cursor, msg: dict) -> dict:
         return {"ok": ok}
     if cmd == "tamanho":
         return {"ok": True, "largura": int(cur.largura), "altura": int(cur.altura)}
+    if cmd == "ler_tela":
+        return ler_tela(cur.largura, cur.altura, str(msg.get("arquivo") or ""))
     if cmd == "rotulo":
         cur._ui(rotulo=str(msg.get("texto") or "")[:48], visivel=True, x=posicao()[0], y=posicao()[1])
         return {"ok": True}

package/voz/primo_voz/transcrever.py

@@ -74,13 +74,49 @@ def aquecer() -> None:
     threading.Thread(target=_ir, daemon=True).start()
 
 
+# ── O QUE O WHISPER INVENTA ─────────────────────────────────────────────
+# Treinado em legenda de vídeo, ele "ouve" no ruído o fim de um vídeo do
+# YouTube. Essas frases chegavam ao agente como pedido, e ele respondia a
+# elas: "eu mandei oi e ele respondeu nada a ver" (23/09/2026).
+ALUCINACOES = (
+    "obrigado por assistir", "obrigada por assistir", "obrigado pela atenção",
+    "legendas pela comunidade", "amara.org", "inscreva-se", "se inscreva",
+    "deixe seu like", "ative o sininho", "até o próximo vídeo", "até a próxima",
+    "legendado por", "legenda por", "tradução e legendas", "transcrição por",
+    "www.", ".com.br",
+)
+# Acima disto o próprio Whisper acha que não havia fala no trecho.
+SEM_FALA = 0.6
+# Abaixo disto a confiança média é baixa demais para virar pedido.
+CONFIANCA_MINIMA = -1.0
+
+
+def limpar(texto: str) -> str:
+    """Tira a frase inventada. Devolve "" quando não sobra pedido."""
+    t = " ".join(str(texto or "").split())
+    baixo = t.lower()
+    if any(frase in baixo for frase in ALUCINACOES):
+        return ""
+    # Só pontuação ou uma letra solta não é pedido.
+    if len("".join(ch for ch in t if ch.isalnum())) < 2:
+        return ""
+    return t
+
+
+def aproveitavel(segmento) -> bool:
+    """O segmento tem fala de verdade, pelo que o próprio Whisper mediu?"""
+    sem_fala = getattr(segmento, "no_speech_prob", 0.0) or 0.0
+    confianca = getattr(segmento, "avg_logprob", 0.0) or 0.0
+    return not (sem_fala > SEM_FALA and confianca < CONFIANCA_MINIMA)
+
+
 def transcrever(wav: Path, idioma: str = "pt") -> str:
     modelo = carregar()
     # vad_filter corta o silêncio das pontas: sem ele, o Whisper às vezes
     # "ouve" uma frase inteira inventada no silêncio ("Obrigado por assistir").
     segmentos, _ = modelo.transcribe(str(wav), language=idioma, beam_size=5,
                                      vad_filter=True, condition_on_previous_text=False)
-    return " ".join(s.text.strip() for s in segmentos).strip()
+    return limpar(" ".join(s.text.strip() for s in segmentos if aproveitavel(s)))
 
 
 def main() -> int: