primocode 9.7.0 → 9.8.0-beta.1

package/README.md

@@ -1,4 +1,4 @@
-# PrimoCode v9.7.0
+# PrimoCode v9.8.0-beta.1
 
 Agente de engenharia brasileiro para o terminal, no estilo Claude Code.
 Cria arquivos de verdade, roda comandos, **controla o navegador e o desktop** —
@@ -9,7 +9,7 @@ OpenRouter, e cada apelido (`top`/`main`/`fast`) é uma **corrente**: se um mode
 está no limite de pedidos, o próximo atende. Você não vê o erro, e não paga nada.
 
 ```
- ▐▛███▜▌   Primo Code v9.7.0
+ ▐▛███▜▌   Primo Code v9.8.0-beta.1
 ▝▜█████▛▘  Bem-vindo de volta, Joel
   ▘▘ ▝▝    ~/primocode  · /dir <pasta> muda
 ```
@@ -27,7 +27,7 @@ veja `/mascot` e `/name`.
 | **Memória** | Cada projeto lembra o que foi feito, entre sessões | Esquece ao fechar |
 | **Instalação** | Node puro, **zero dependências** — segundos | Pacotes e dependências |
 | **Cara própria** | Mascote, nome e temas que você escolhe | Fixo |
-| **Modelos** | Escolhidos pelo produto, não por você: `/effort` regula o esforço e o modelo sai daí | Preso ao provedor do fabricante |
+| **Modelos** | Escolhidos pelo produto (`/effort` regula o esforço), ou a sua própria chave com `/api` | Preso ao provedor do fabricante |
 
 Em uma frase: **é o poder de um agente de código no terminal, em português, controlando o seu computador de verdade — sem você precisar configurar chave de API nenhuma.**
 
@@ -287,7 +287,8 @@ primocode -f app.js "onde está o bug?" # com arquivo anexado
 | `/voice` | Modo voz: uma orb, você fala, ele faz. O cérebro é o mesmo do terminal |
 | `/skills` · `/marketplace` | O que ele sabe fazer bem. Tela navegável pelas setas, e "New Skill" para escrever a sua |
 | `/connectors` | Quem está atendendo os seus pedidos (só mostra — não há o que configurar) |
-| `/effort` | O esforço do agente, num slider (←/→, Enter confirma): do `low` ao `ultracode`. O modelo sai daí — não há provedor nem chave para configurar |
+| `/effort` | O esforço do agente, num slider (←/→, Enter confirma): do `low` ao `ultracode`. O modelo sai daí |
+| `/api` | Roda com a SUA chave (Gemini, ChatGPT, Claude, Groq, OpenRouter, DeepSeek), direto do seu computador, sem o limite do servidor. `/api modelo <nome>` troca o modelo · `/api off` volta ao servidor |
 | `/attach <arquivo>` | Anexa arquivo ao próximo pedido |
 | `/detach` · `/files` | Remove / lista anexos |
 | `/all` | Lista as 46 ferramentas que ele sabe usar, por grupo |

package/bin/primocode.js

@@ -20,6 +20,8 @@ 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 provedorLocal = require('../lib/local/provedor');
 const { runAct, interromper, ehTetoDeToken, ehTransitorio, esperaDoErro } = require('../lib/act');
 const fala = require('../lib/fala');
 const boasVindas = require('../lib/boas-vindas');
@@ -159,6 +161,7 @@ const SLASH_COMANDOS = [
     ['/skills', 'o que ele sabe fazer bem — ligue e desligue'],
     ['/marketplace', 'a tela das skills: navegue, ligue, crie'],
     ['/install-skill', 'instala uma skill de um arquivo'],
+    ['/api', 'usa a SUA chave (Gemini, ChatGPT, Claude…) direto daqui, sem o limite do servidor'],
     ['/status', 'checa o servidor'],
     ['/connectors', 'quem está atendendo os seus pedidos'],
     ['/name', 'como ele te chama'],
@@ -171,6 +174,56 @@ const SLASH_COMANDOS = [
     ['/exit', 'sair'],
 ];
 
+/* ── /api: a chave da própria pessoa ──────────────────────────────
+ *   "Fica batendo no limite. Coloca um /provider onde você seleciona se é
+ *    Gemini, ChatGPT etc., cola a key e ela roda local." (23/09/2026)
+ * Com provedor, o agente fala direto com a API da pessoa (lib/local/motor.js);
+ * sem, tudo segue pelo servidor como sempre. */
+async function comandoApi(rest) {
+    const P = provedorLocal.PROVEDORES;
+    const ids = Object.keys(P);
+    const arg = String(rest || '').trim();
+    const atual = provedorLocal.atual();
+
+    if (/^(off|desliga[r]?|servidor|nenhum|sair)$/i.test(arg)) {
+        provedorLocal.desligar();
+        console.log(c.ok('  De volta ao servidor do PrimoCode.') + c.muted('  (a chave foi apagada desta máquina)'));
+        return;
+    }
+    const trocaModelo = arg.match(/^(modelo|model)\s+(\S+)$/i);
+    if (trocaModelo) {
+        if (!atual) { console.log(c.warn('  Nenhum provedor configurado. Rode /api primeiro.')); return; }
+        provedorLocal.trocarModelo(trocaModelo[2]);
+        console.log(c.ok(`  ${atual.nome} · modelo ${trocaModelo[2]}`));
+        return;
+    }
+
+    let id = ids.find((k) => k === arg.toLowerCase() || P[k].nome.toLowerCase().startsWith(arg.toLowerCase()) && arg);
+    if (!id) {
+        console.log('');
+        console.log('  ' + c.bold('Com qual IA você quer rodar?') + c.muted('  a sua chave, direto daqui, sem o limite do servidor'));
+        if (atual) console.log('  ' + c.muted('agora: ') + c.white(`${atual.nome} · ${atual.modelo} · chave ${provedorLocal.mascarar(atual.chave)}`));
+        ids.forEach((k, i) => console.log(`  ${c.brand(String(i + 1))}  ${c.white(P[k].nome.padEnd(24))}${c.dim(P[k].dica)}`));
+        console.log(`  ${c.brand('0')}  ${c.white('Servidor do PrimoCode'.padEnd(24))}${c.dim('sem chave, com o limite do plano')}`);
+        const escolha = String(await ask(`  ${c.brand('?')} Número: `)).trim();
+        if (escolha === '0') return comandoApi('off');
+        id = ids[Number(escolha) - 1];
+        if (!id) { console.log(c.muted('  Nada mudou.')); return; }
+    }
+
+    const p = P[id];
+    console.log(c.muted(`  Pegue a chave em `) + c.white(p.onde));
+    const chave = String(await askSecret(`  ${c.brand('?')} Cole a chave do ${p.nome} (não aparece na tela): `)).trim();
+    if (!chave) { console.log(c.muted('  Nada mudou.')); return; }
+    const sp = new Spinner('conferindo a chave').start();
+    const r = await provedorLocal.conferir(id, chave);
+    sp.stop();
+    if (!r.ok) { console.log(c.warn(`  ${r.error}`)); return; }
+    const salvo = provedorLocal.salvar({ provedor: id, chave, modelo: r.modelo });
+    console.log(c.ok(`  Pronto: ${salvo.nome} · ${salvo.modelo}`) + c.muted(`  · chave ${provedorLocal.mascarar(chave)}`));
+    console.log(c.dim('  Agora os pedidos vão direto daqui, com a sua cota. /api modelo <nome> troca o modelo · /api off volta ao servidor'));
+}
+
 // ── /effort: o slider de esforço (estilo Claude Code) ──────────────────
 // Régua com os níveis, o marcador ▲ embaixo do escolhido, "Faster" à
 // esquerda e "Smarter" à direita. ←/→ move, Enter confirma, Esc cancela.
@@ -563,8 +616,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 +689,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 +985,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 +1008,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 +1096,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 +1144,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 +1818,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,
@@ -1988,6 +2136,11 @@ async function handleSlash(text) {
          * Eles não somem calados. Quem tem o dedo viciado em `/claude` e
          * bate num "comando não existe" conclui que a atualização quebrou
          * alguma coisa — e não vai procurar no /help, vai desinstalar. */
+        case 'api': {
+            await comandoApi(rest);
+            break;
+        }
+
         case 'claude': case 'gpt': case 'codex': case 'key': case 'keys': {
             console.log(c.muted('  Não existe mais provedor para configurar.'));
             console.log(c.muted('  A API já vem com o PrimoCode: entrou na conta, pode usar.'));
@@ -2045,6 +2198,9 @@ function conferirServidor() {
     jaConferiu = true;
     const minimo = (pkg.primocode && pkg.primocode.servidorMinimo) || '';
     if (!minimo) return;
+    // Com a chave própria (/api), quem pensa não é o servidor: a versão dele
+    // não muda nada no que a pessoa pede.
+    if (provedorLocal.atual()) return;
     const servidor = state.config.server;
     Promise.resolve()
         .then(() => api.getHealth(servidor, state.config.token))

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/api.js

@@ -201,14 +201,28 @@ function requestStream(serverUrl, endpoint, payload, onEvent, token, sinal) {
     });
 }
 
+/* Com um provedor configurado (/api), estas quatro rotas rodam AQUI,
+   com a chave da pessoa, em vez de ir ao servidor — ver lib/local/motor.js.
+   O resto (login, transcrição, conectores) continua no servidor. */
+function local() {
+    try {
+        const motor = require('./local/motor.js');
+        return motor.ativo() ? motor : null;
+    } catch { return null; }
+}
+
 // Agente autônomo. `payload` carrega a conversa completa (messages).
 function requestAct(serverUrl, payload, onEvent) {
+    const m = local();
+    if (m) return m.requestAct(serverUrl, payload, onEvent);
     const { token, sinal, ...body } = payload;
     return requestStream(serverUrl, '/api/act/stream', body, onEvent, token, sinal);
 }
 
 // Chat puro.
 function requestChat(serverUrl, payload, onEvent) {
+    const m = local();
+    if (m) return m.requestChat(serverUrl, payload, onEvent);
     const { token, sinal, ...body } = payload;
     return requestStream(serverUrl, '/api/chat/stream', body, onEvent, token, sinal);
 }
@@ -216,6 +230,8 @@ function requestChat(serverUrl, payload, onEvent) {
 // Resumo incremental da conversa. Vai e volta pequeno: manda o resumo de
 // antes + o que é novo, recebe o resumo atualizado.
 function requestResumo(serverUrl, payload) {
+    const m = local();
+    if (m) return m.requestResumo(serverUrl, payload);
     const { token, ...body } = payload;
     return request(serverUrl, '/api/resumir', body, token);
 }
@@ -236,6 +252,8 @@ function requestRefino(serverUrl, payload) {
 
 // O plano: a tarefa grande dividida em passos, para uma chamada por pedaço.
 function requestPlano(serverUrl, payload) {
+    const m = local();
+    if (m) return m.requestPlano(serverUrl, payload);
     const { token, ...body } = payload;
     return request(serverUrl, '/api/plano', body, token);
 }

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,