primocode 9.7.0 → 9.8.0-beta.0

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,29 @@ 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 ───────────────────────────────────────────────────
@@ -591,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
@@ -996,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;
             }
@@ -1027,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;
@@ -1079,6 +1092,7 @@ 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
@@ -1133,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/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,10 +22,24 @@ 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 };
 }

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'
@@ -575,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.7.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/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"
+    "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/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/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: