primocode 8.4.0 → 8.5.0

package/bin/primocode.js

@@ -538,7 +538,11 @@ async function sendPrompt(userText) {
         // conversa inteira.
         await comprimirConversa();
 
-        const r = await runAct(prompt, {
+        // O pedido passa por uma cabeça antes de virar trabalho: conserta o
+        // que está torto, diz qual é o entregável e o que conta como pronto.
+        const prompt2 = await refinarPedido(prompt);
+
+        const r = await runAct(prompt2, {
             server: state.config.server,
             model: state.config.model,
             effort: state.config.effort,
@@ -564,6 +568,39 @@ async function sendPrompt(userText) {
     refreshPrompt();
 }
 
+/**
+ * Estrutura o pedido antes de mandar o agente executar.
+ *
+ * Gente pede curto e torto — "cria um vidro anunciando o founders ai". Sem
+ * isto o agente adivinha, e adivinha errado: sai o genérico, ou ele pesquisa
+ * em círculo porque não sabe o que é "pronto". Uma passada barata antes de
+ * começar vira ordem de serviço: o que entregar, com que fatos, quando parar.
+ *
+ * Mostra o que mudou — o usuário precisa poder discordar do que foi entendido,
+ * não descobrir no fim que o agente fez outra coisa.
+ *
+ * Nunca bloqueia: se o refino falhar ou vier estranho, vale o pedido original.
+ */
+async function refinarPedido(cru) {
+    if (!cru || cru.trim().length < 12) return cru;
+    const sp = new Spinner('entendendo o pedido').start();
+    try {
+        const r = await api.requestRefino(state.config.server, {
+            prompt: cru, model: state.config.model, token: state.config.token,
+        });
+        sp.stop();
+        if (!r || !r.refinado || !r.prompt) return cru;
+        console.log(c.dim('  ⎿ entendi assim:'));
+        for (const linha of String(r.prompt).split('\n')) {
+            if (linha.trim()) console.log(c.dim('    ' + linha.trim()));
+        }
+        return r.prompt;
+    } catch {
+        sp.stop();   // refinar é melhoria, não requisito
+        return cru;
+    }
+}
+
 /**
  * Atualiza o resumo da conversa, se já compensar.
  *
@@ -585,7 +622,12 @@ async function comprimirConversa() {
     }
 }
 
+// O chat também precisa parar no Esc Esc. Sem isto o texto continuava saindo
+// na tela depois de o usuário ter mandado parar.
+let chatEmVoo = null;
+
 async function runChat(promptForModel, userTextForMemory) {
+    chatEmVoo = new AbortController();
     const sp = new Spinner('pensando').start();
     let started = false;
     let text = '';
@@ -595,6 +637,7 @@ async function runChat(promptForModel, userTextForMemory) {
             history: memoria.paraEnviar(state.memoria, state.history),
             model: state.config.model,
             token: state.config.token,
+            sinal: chatEmVoo.signal,
         }, (evt) => {
             if (evt.erro) { if (!started) sp.stop(); console.log('\n' + c.err(ui.friendlyError(evt.erro))); return; }
             if (evt.delta) {
@@ -1066,6 +1109,7 @@ async function main() {
                 if (key.sequence === '\x1b\x1b' || agora - ultimoEsc < 2000) {
                     ultimoEsc = 0;
                     interromper();
+                    if (chatEmVoo) { try { chatEmVoo.abort(); } catch {} }
                     process.stdout.write('\n' + c.warn('  ⏹ parando o agente…') + '\n');
                 } else {
                     ultimoEsc = agora;

package/lib/act.js

@@ -15,8 +15,11 @@ const tools = require('./tools');
 const api = require('./api');
 const cfg = require('./config');
 const catalogo = require('./catalogo');
+const repeticao = require('./repeticao');
 
 const MAX_ITERATIONS = 15;
+// Voltas seguidas sem executar nada antes de desistir.
+const MAX_RODADAS_PARADAS = 3;
 const MAX_PROFUNDIDADE = 2; // principal + 1 nível de subagente
 
 // ── Interrupção (Esc Esc) ─────────────────────────────────────────────────
@@ -25,7 +28,14 @@ const MAX_PROFUNDIDADE = 2; // principal + 1 nível de subagente
 // fez, ficou feito). A flag é do módulo de propósito: parar o principal para
 // os subagentes junto.
 let PARAR = false;
-function interromper() { PARAR = true; }
+// O pedido que está em voo agora. Sem isto o Esc Esc só valia entre uma
+// rodada e outra: o modelo seguia escrevendo do outro lado e o usuário ficava
+// vendo o spinner girar depois de ter mandado parar.
+let emVoo = null;
+function interromper() {
+    PARAR = true;
+    if (emVoo) { try { emVoo.abort(); } catch {} }
+}
 
 function ident(profundidade) {
     return '  '.repeat(profundidade);
@@ -164,6 +174,13 @@ function summarizeForModel(result) {
 // que o modelo precisa para decidir o próximo passo; os velhos viram peso.
 const RESULTADOS_INTEIROS = 3;
 const RESTO_DO_RESULTADO = 300;
+// A pesquisa é MATÉRIA-PRIMA, não passo intermediário: é dela que saem os
+// fatos do vídeo, do post, do slide. Ela sempre fica velha (pesquisa-se no
+// começo, escreve-se no fim), e a 300 caracteres não sobrava fato nenhum — o
+// modelo escrevia genérico, que foi exatamente a reclamação de "está tudo
+// padrão". Encolhe também, mas com espaço para os fatos sobreviverem.
+const RESTO_DA_PESQUISA = 1500;
+const MATERIA_PRIMA = new Set(['pesquisar_referencia']);
 
 /**
  * Encolhe os resultados de tool ANTIGOS antes de mandar a conversa.
@@ -174,23 +191,64 @@ const RESTO_DO_RESULTADO = 300;
  * 27.454 tokens contra um teto de 6.000 por minuto do plano grátis — a tarefa
  * morreu no meio, depois de todo o trabalho de pesquisa já feito.
  *
+ * MAS: encolher REFERÊNCIA cria um loop. O manual e as specs do estúdio são o
+ * formato que o modelo precisa ter em mãos na hora de escrever o documento;
+ * encolhidos, ele pede de novo — e é encolhido de novo. Foi assim que um
+ * pedido de vídeo pesquisou e leu a mesma spec sete vezes sem criar nada. A
+ * cópia mais nova de cada referência fica INTEIRA; as velhas, que são o mesmo
+ * texto repetido, viram um ponteiro para ela.
+ *
  * Nenhuma mensagem é REMOVIDA: a API exige que cada role:'tool' continue
  * pareada com o tool_call que a pediu. Só o texto encolhe.
  */
 function compactar(messages) {
+    const { inteiras, duplicadas } = repeticao.referenciasNaConversa(messages);
+
     const indices = [];
     for (let i = 0; i < messages.length; i++) if (messages[i].role === 'tool') indices.push(i);
-    if (indices.length <= RESULTADOS_INTEIROS) return messages;
+    if (indices.length <= RESULTADOS_INTEIROS && !duplicadas.size) return messages;
 
+    const chamadas = repeticao.chamadasPorId(messages);
     const encolher = new Set(indices.slice(0, -RESULTADOS_INTEIROS));
     return messages.map((m, i) => {
-        if (!encolher.has(i)) return m;
+        if (duplicadas.has(i)) {
+            return { ...m, content: '(a mesma referência aparece inteira mais adiante nesta conversa — use aquela)' };
+        }
+        if (inteiras.has(i) || !encolher.has(i)) return m;
+        const chamada = chamadas.get(m.tool_call_id);
+        const limite = chamada && MATERIA_PRIMA.has(chamada.nome) ? RESTO_DA_PESQUISA : RESTO_DO_RESULTADO;
         const texto = String(m.content || '');
-        if (texto.length <= RESTO_DO_RESULTADO) return m;
-        return { ...m, content: texto.slice(0, RESTO_DO_RESULTADO) + `…(resultado antigo encurtado; eram ${texto.length} caracteres)` };
+        if (texto.length <= limite) return m;
+        return { ...m, content: texto.slice(0, limite) + `…(resultado antigo encurtado; eram ${texto.length} caracteres)` };
     });
 }
 
+/**
+ * Por que parou, quando o modelo não disse.
+ *
+ * "Parei sem concluir e sem explicação do modelo" era a resposta para tudo, e
+ * quase sempre mentia: na prática o agente tinha gastado as 15 voltas dando
+ * murro em ponta de faca. Dizer o motivo certo é a diferença entre o usuário
+ * saber o que fazer e ficar no escuro.
+ */
+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.';
+    }
+    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 'Parei sem concluir e sem explicação do modelo. Tente pedir de novo, em partes menores.';
+}
+
 function buildMemoryContext(projectDir, projectName) {
     const parts = [];
     const geral = cfg.readGeneralMemory();
@@ -216,6 +274,10 @@ async function runAct(userPrompt, opts) {
     let temPasta = !criarPasta;       // já é a pasta definitiva?
     const falhasPendentes = [];
     let tentativasDeEncerrar = 0;
+    // Quem já foi chamado, e quantas vezes. Ver lib/repeticao.js.
+    const jaChamado = repeticao.novo();
+    let voltasEmFalso = 0;
+    let rodadasParadas = 0;
 
     const messages = [];
     if (!subagent) {
@@ -232,7 +294,9 @@ async function runAct(userPrompt, opts) {
     // Pedido novo zera o pedido de parada anterior.
     if (!subagent) PARAR = false;
 
+    let voltas = 0;
     for (let iteration = 0; iteration < MAX_ITERATIONS && !PARAR; iteration++) {
+        voltas++;
         const sp = new Spinner(subagent ? 'subagente trabalhando' : 'Primo Code pensando').start();
 
         const toolCalls = [];
@@ -240,8 +304,9 @@ async function runAct(userPrompt, opts) {
         let streamError = null;
         let streaming = false;
 
+        emVoo = new AbortController();
         try {
-            await motor.requestAct(server, { messages: compactar(messages), model, effort, token, projectDir, projectName, subagent }, (evt) => {
+            await motor.requestAct(server, { messages: compactar(messages), model, effort, token, projectDir, projectName, subagent, sinal: emVoo.signal }, (evt) => {
                 if (evt.erro) { streamError = evt.erro; return; }
                 if (evt.tool_call) { toolCalls.push(evt.tool_call); return; }
                 if (evt.delta) {
@@ -259,6 +324,8 @@ async function runAct(userPrompt, opts) {
             throw e;
         }
         sp.stop();
+        emVoo = null;
+        if (PARAR) break;
 
         if (streamError) {
             const amigavel = friendlyError(streamError);
@@ -292,6 +359,7 @@ async function runAct(userPrompt, opts) {
         });
 
         let finished = null;
+        let algoRodou = false;
         for (const tc of toolCalls) {
             if (PARAR) break;
             if (tc.name === 'finish') {
@@ -307,12 +375,14 @@ async function runAct(userPrompt, opts) {
                     });
                     continue;
                 }
+                algoRodou = true;
                 finished = (tc.arguments && tc.arguments.summary) || 'Concluído.';
                 messages.push({ role: 'tool', tool_call_id: tc.id, content: 'ok' });
                 continue;
             }
 
             if (tc.name === 'spawn_agent') {
+                algoRodou = true;
                 const r = await runSubagent(tc.arguments || {}, {
                     server, model, token, projectDir: pastaAtual, projectName, profundidade, motor,
                 });
@@ -320,6 +390,18 @@ async function runAct(userPrompt, opts) {
                 continue;
             }
 
+            // Repetiu a mesma chamada? Não executa de novo. Rodar outra vez
+            // gastaria a cota para devolver exatamente o mesmo texto, e é
+            // esse texto que convence o modelo a repetir mais uma vez.
+            const eco = repeticao.ver(jaChamado, tc.name, tc.arguments);
+            if (eco.repetida) {
+                voltasEmFalso++;
+                console.log(ident(profundidade) + actionHeader(tc.name, tc.arguments));
+                console.log(ident(profundidade) + c.muted('  ⎿ ') + c.warn(`repetido (${eco.vezes}ª vez) — não rodei de novo`));
+                messages.push({ role: 'tool', tool_call_id: tc.id, content: eco.aviso });
+                continue;
+            }
+
             if (criarPasta && catalogo.escreveArquivo(tc.name)) {
                 const nova = criarPasta();
                 if (nova) pastaAtual = nova;
@@ -327,6 +409,7 @@ async function runAct(userPrompt, opts) {
                 temPasta = true;
             }
 
+            algoRodou = true;
             console.log(ident(profundidade) + actionHeader(tc.name, tc.arguments));
             const result = await tools.execute(tc.name, tc.arguments, { projectDir: pastaAtual });
             logResult(tc.name, result, profundidade);
@@ -365,6 +448,19 @@ async function runAct(userPrompt, opts) {
             messages.push({ role: 'tool', tool_call_id: tc.id, content: summarizeForModel(result) });
         }
 
+        // Uma volta inteira sem executar nada é o modelo preso. Insistir custa
+        // um pedido ao servidor por volta, e as 15 voltas saíam caras para
+        // terminar no mesmo lugar — melhor parar e devolver a vez ao usuário.
+        if (!algoRodou && toolCalls.length) {
+            rodadasParadas++;
+            if (rodadasParadas >= MAX_RODADAS_PARADAS) {
+                if (!subagent) console.log('\n' + c.warn(`Travei repetindo as mesmas chamadas ${rodadasParadas} voltas seguidas — parei aqui.`));
+                break;
+            }
+        } else {
+            rodadasParadas = 0;
+        }
+
         if (finished) {
             finalText = finished;
             if (!subagent) console.log('\n' + c.white(finished));
@@ -382,9 +478,7 @@ async function runAct(userPrompt, opts) {
     // não dá nem para saber que acabou. Medido: um pedido de navegador morria assim
     // depois de a primeira tentativa de seletor falhar.
     if (!finalText) {
-        finalText = falhasPendentes.length
-            ? `Parei sem concluir. A última falha foi: ${falhasPendentes[falhasPendentes.length - 1].texto}`
-            : 'Parei sem concluir e sem explicação do modelo. Tente pedir de novo, em partes menores.';
+        finalText = motivoDaParada({ voltas, voltasEmFalso, falhasPendentes, travou: rodadasParadas >= MAX_RODADAS_PARADAS });
         if (!subagent) console.log('\n' + c.warn(finalText));
     }
 
@@ -430,4 +524,4 @@ async function runSubagent(args, ctx) {
     return resumo;
 }
 
-module.exports = { runAct, interromper, compactar };
+module.exports = { runAct, interromper, compactar, motivoDaParada, MAX_ITERATIONS };

package/lib/api.js

@@ -57,8 +57,17 @@ function request(serverUrl, endpoint, payload, token) {
     });
 }
 
-function requestStream(serverUrl, endpoint, payload, onEvent, token) {
+/**
+ * `sinal` (AbortSignal) corta o pedido NA HORA.
+ *
+ * Sem ele o Esc Esc só era visto entre uma rodada e outra: o modelo continuava
+ * escrevendo do outro lado e o usuário ficava olhando o spinner girar depois
+ * de ter mandado parar. Abortar não é erro — resolve normal, e quem chamou
+ * segue para a checagem de parada.
+ */
+function requestStream(serverUrl, endpoint, payload, onEvent, token, sinal) {
     return new Promise((resolve, reject) => {
+        if (sinal && sinal.aborted) return resolve();
         const url = new URL(endpoint, serverUrl);
         const data = JSON.stringify(payload);
         const client = url.protocol === 'https:' ? https : http;
@@ -110,7 +119,19 @@ function requestStream(serverUrl, endpoint, payload, onEvent, token) {
             res.on('error', reject);
         });
 
-        req.on('error', reject);
+        // Abortar fecha o socket e encerra a promessa como sucesso: quem pediu
+        // para parar não quer ver mensagem de erro.
+        let cortado = false;
+        const cortar = () => {
+            if (cortado) return;
+            cortado = true;
+            try { req.destroy(); } catch {}
+            resolve();
+        };
+        if (sinal) sinal.addEventListener('abort', cortar, { once: true });
+
+        req.on('error', (e) => { if (!cortado) reject(e); });
+        req.on('close', () => { if (sinal) sinal.removeEventListener('abort', cortar); });
         req.write(data);
         req.end();
     });
@@ -118,14 +139,14 @@ function requestStream(serverUrl, endpoint, payload, onEvent, token) {
 
 // Agente autônomo. `payload` carrega a conversa completa (messages).
 function requestAct(serverUrl, payload, onEvent) {
-    const { token, ...body } = payload;
-    return requestStream(serverUrl, '/api/act/stream', body, onEvent, token);
+    const { token, sinal, ...body } = payload;
+    return requestStream(serverUrl, '/api/act/stream', body, onEvent, token, sinal);
 }
 
 // Chat puro.
 function requestChat(serverUrl, payload, onEvent) {
-    const { token, ...body } = payload;
-    return requestStream(serverUrl, '/api/chat/stream', body, onEvent, token);
+    const { token, sinal, ...body } = payload;
+    return requestStream(serverUrl, '/api/chat/stream', body, onEvent, token, sinal);
 }
 
 // Resumo incremental da conversa. Vai e volta pequeno: manda o resumo de
@@ -135,6 +156,12 @@ function requestResumo(serverUrl, payload) {
     return request(serverUrl, '/api/resumir', body, token);
 }
 
+// Refino do pedido: manda o texto cru, recebe a ordem de serviço.
+function requestRefino(serverUrl, payload) {
+    const { token, ...body } = payload;
+    return request(serverUrl, '/api/refinar', body, token);
+}
+
 function getHealth(serverUrl, token) {
     return new Promise((resolve, reject) => {
         const url = new URL('/health', serverUrl);
@@ -151,4 +178,4 @@ function getHealth(serverUrl, token) {
     });
 }
 
-module.exports = { request, requestStream, requestAct, requestChat, requestResumo, getHealth };
+module.exports = { request, requestStream, requestAct, requestChat, requestResumo, requestRefino, getHealth };

package/lib/referencia.js

@@ -59,6 +59,10 @@ function hostBloqueado(hostname) {
 const TIMEOUT_MS = 12000;
 const MAX_POR_FONTE = 4;
 const MAX_TEXTO = 4500;
+// Quanto HTML baixar antes de parar. Só os primeiros MAX_TEXTO caracteres de
+// TEXTO viram referência, e 400 KB de HTML dão isso com folga em qualquer
+// página — inclusive nas de Wikipédia, que passam desse tamanho.
+const LIMITE_CORPO = 400000;
 
 // Rede de empresa costuma exigir proxy. Sem isto, a pesquisa simplesmente não
 // funciona em metade dos computadores corporativos — e o usuário nunca
@@ -136,13 +140,25 @@ function pegar(url, { timeout = TIMEOUT_MS, saltos = 0 } = {}) {
                 }
                 if (res.statusCode !== 200) { res.resume(); return resolve(null); }
                 let corpo = '';
+                let pronto = false;
+                const entregar = (valor) => { if (!pronto) { pronto = true; resolve(valor); } };
                 res.setEncoding('utf8');
                 res.on('data', (c) => {
                     corpo += c;
-                    if (corpo.length > 400000) { req.destroy(); }   // página gigante não serve
+                    // Página grande: PARA de baixar e entrega o que já veio.
+                    //
+                    // Antes isto era `req.destroy()` sem entregar nada, e o
+                    // destroy caía no req.on('error') -> resolve(null). Ou
+                    // seja: TODA página acima de 400 KB era jogada fora
+                    // inteira. Artigo de Wikipédia passa desse tamanho, então
+                    // toda pesquisa que caía nela voltava "achei os links mas
+                    // não consegui abrir nenhum" — com a página no ar e o
+                    // conteúdo já na mão. E precisamos só dos primeiros
+                    // milhares de caracteres.
+                    if (corpo.length > LIMITE_CORPO) { res.destroy(); entregar(corpo); }
                 });
-                    res.on('end', () => resolve(corpo));
-                    res.on('error', () => resolve(null));
+                    res.on('end', () => entregar(corpo));
+                    res.on('error', () => entregar(corpo || null));
                 });
             } catch { return resolve(null); }
             req.on('timeout', () => { req.destroy(); resolve(null); });
@@ -151,6 +167,21 @@ function pegar(url, { timeout = TIMEOUT_MS, saltos = 0 } = {}) {
     });
 }
 
+/**
+ * Isto é texto para ler, ou sobra de código?
+ *
+ * Site feito em construtor visual despeja CSS e JSON no corpo da página. Sem
+ * este filtro o "trecho" entregue ao modelo começava com
+ * `{"css":"@media all { *#dm .dmInner ...` — e era isso que ele levava como
+ * referência para escrever o vídeo.
+ */
+function pareceCodigo(texto) {
+    const amostra = texto.slice(0, 1200);
+    if (!amostra) return true;
+    const simbolos = (amostra.match(/[{};:_#]/g) || []).length;
+    return simbolos / amostra.length > 0.08;
+}
+
 /** HTML → texto legível. Sem dependência: corta script/style e as tags. */
 function textoDe(html) {
     return String(html || '')
@@ -165,6 +196,67 @@ function textoDe(html) {
         .trim();
 }
 
+/**
+ * ── FONTE ERRADA É PIOR QUE FONTE NENHUMA ────────────────────────────────
+ * Pedido real: "pesquise sobre a Paris Group e crie um vídeo para anunciar a
+ * imersão founders ai". Os buscadores não acharam a empresa e a busca de
+ * texto da Wikipédia devolveu o que continha aquelas palavras soltas: Milan,
+ * History of autism, Berlitz Corporation, 42 (school). O agente ia escrever
+ * um vídeo com AQUILO. Melhor devolver "não achei" e deixar o modelo dizer
+ * isso ao usuário do que entregar fonte que não é sobre o assunto.
+ */
+function palavrasDaConsulta(consulta) {
+    return String(consulta || '')
+        .normalize('NFD').replace(/[\u0300-\u036f]/g, '').toLowerCase()
+        .split(/[^a-z0-9]+/)
+        .filter((p) => p.length >= 3 && !GENERICAS.has(p));
+}
+
+// Palavras que aparecem em qualquer pesquisa e não provam relevância nenhuma.
+const GENERICAS = new Set(['sobre', 'empresa', 'company', 'overview', 'about', 'the', 'and',
+    'para', 'com', 'que', 'dos', 'das', 'quem', 'programa', 'program', 'site', 'oficial']);
+
+/**
+ * O link fala mesmo do que foi pedido?
+ *
+ * Exige DUAS palavras distintas da consulta no título ou na URL — uma só é
+ * coincidência ("Paris - Wikipedia" para "Paris Group founders AI" bate em
+ * "paris" e não tem nada a ver). Consulta de uma palavra só se contenta com
+ * ela mesma.
+ */
+function relevante(cand, palavras) {
+    if (!palavras.length) return true;
+    const alvo = `${cand.titulo || ''} ${cand.url || ''}`
+        .normalize('NFD').replace(/[\u0300-\u036f]/g, '').toLowerCase();
+    let batidas = 0;
+    for (const p of palavras) if (alvo.includes(p)) batidas++;
+    return batidas >= Math.min(2, palavras.length);
+}
+
+/**
+ * O site provável de uma empresa, tentado direto — sem buscador nenhum.
+ *
+ * É como uma pessoa faria: "Paris Group" -> parisgroup.com, parisgroup.ai.
+ * Foi o que salvou este caso — parisgroup.ai abre e tem o texto todo, enquanto
+ * DuckDuckGo devolvia 202 e o Bing devolvia Paris, a cidade.
+ *
+ * Só dispara quando a consulta tem DUAS PALAVRAS COM INICIAL MAIÚSCULA
+ * seguidas, que é como se escreve nome de empresa. "react hooks tutorial" não
+ * dispara; "Paris Group" dispara.
+ */
+function sitesProvaveis(consulta) {
+    const nome = /\b([A-ZÀ-Ý][\w\u00C0-\u024F]{1,})\s+([A-ZÀ-Ý][\w\u00C0-\u024F]{1,})\b/.exec(String(consulta || ''));
+    if (!nome) return [];
+    const slug = `${nome[1]}${nome[2]}`
+        .normalize('NFD').replace(/[\u0300-\u036f]/g, '').toLowerCase().replace(/[^a-z0-9]/g, '');
+    if (slug.length < 5) return [];
+    return ['com', 'ai', 'com.br', 'io', 'co'].map((tld) => ({
+        titulo: `${nome[1]} ${nome[2]} — site oficial`,
+        url: `https://www.${slug}.${tld}`,
+        nota: 'site provável da empresa',
+    }));
+}
+
 // Links que não são referência de nada — resultado de busca sujo.
 const LIXO = /(facebook|twitter|x)\.com|instagram|pinterest|youtube\.com\/(?!watch)|\/search\?|duckduckgo|bing\.com\/(?!ck)|google\./i;
 
@@ -256,6 +348,15 @@ async function buscarBing(consulta, limite) {
     const html = await pegar(`https://www.bing.com/search?q=${encodeURIComponent(consulta)}&setlang=en`);
     if (!html) return [];
     const pares = [];
+    // O Bing largou o <h2><a href> e hoje mostra a URL num <cite>, com " › "
+    // no lugar da barra. O parser antigo casava ZERO resultados numa página
+    // que trazia dez — e a pesquisa caía na Wikipédia, que era o lixo.
+    const cites = html.match(/<cite[^>]*>[\s\S]{0,200}?<\/cite>/gi) || [];
+    for (const bruto of cites) {
+        const mostrado = textoDe(bruto);
+        if (!/^https?:\/\//i.test(mostrado) || /[…]/.test(mostrado)) continue;
+        pares.push({ titulo: mostrado.replace(/\s*›\s*/g, ' / '), url: mostrado.replace(/\s*›\s*/g, '/') });
+    }
     const re = /<h2>\s*<a[^>]+href="(https?:\/\/[^"]+)"[^>]*>([\s\S]*?)<\/a>/gi;
     let m;
     while ((m = re.exec(html))) pares.push({ titulo: textoDe(m[2]), url: m[1] });
@@ -352,8 +453,19 @@ async function pesquisar({ consulta, paginas = 3 }) {
     // portas vieram vazias: ela é a melhor fonte, e é o que salva a pesquisa
     // quando os links do buscador não abrem (rede corporativa, site fora do
     // ar, bloqueio). Foi assim que a pesquisa falhava mesmo achando links.
-    const candidatos = [...web, ...so, ...docsConhecidas(termo)]
-        .slice(0, Math.max(2, Math.min(8, paginas + 4)));
+    // O site provável da empresa vai NA FRENTE: quando a consulta nomeia um
+    // negócio, o site dele é a melhor fonte que existe, e não depende de
+    // buscador nenhum estar de bom humor.
+    const chutes = sitesProvaveis(termo);
+    const palavras = palavrasDaConsulta(termo);
+    const brutos = [...chutes, ...web, ...so, ...docsConhecidas(termo)];
+
+    // Fora o que não é sobre o assunto. Sem isto o modelo recebia "Milan" e
+    // "History of autism" para uma pesquisa sobre uma empresa, e escrevia o
+    // vídeo com aquilo.
+    const filtrados = brutos.filter((cand) => cand.nota === 'site provável da empresa' || relevante(cand, palavras));
+    const candidatos = filtrados.slice(0, Math.max(2, Math.min(10, paginas + 6)));
+    const descartados = brutos.length - filtrados.length;
     if (!candidatos.length) {
         return {
             ok: false,
@@ -362,7 +474,9 @@ async function pesquisar({ consulta, paginas = 3 }) {
             // "sem internet?" era o palpite errado, e mandava o usuário conferir
             // a conexão dele: medido, os buscadores devolvem 202/302 e página
             // vazia para quem não parece navegador, com a rede perfeita.
-            provavelCausa: 'Os buscadores costumam recusar chamadas automáticas (bloqueio ou limite por excesso de buscas seguidas), e não a sua conexão.',
+            provavelCausa: descartados
+                ? `Vieram ${descartados} link(s), mas nenhum era sobre "${termo}" — o buscador não achou o assunto e devolveu página aleatória. Fonte errada é pior que fonte nenhuma, então foram descartadas.`
+                : 'Os buscadores costumam recusar chamadas automáticas (bloqueio ou limite por excesso de buscas seguidas), e não a sua conexão.',
             comoCorrigir: 'Tente OUTRA consulta, mais curta e específica. Se souber o site do assunto, vá direto nele com browser_open + browser_read — é o caminho mais confiável para fato de empresa.',
         };
     }
@@ -374,6 +488,12 @@ async function pesquisar({ consulta, paginas = 3 }) {
         if (!html) continue;
         const texto = textoDe(html);
         if (texto.length < 200) continue;
+        if (pareceCodigo(texto)) continue;
+        // O chute de domínio precisa PROVAR que acertou. "Paris Group" tem
+        // parisgroup.com (um grupo de varejo no exterior) e parisgroup.ai (a
+        // empresa que o usuário quis). O nome não distingue os dois — o texto
+        // da página, sim. Sem esta prova o agente escreveria sobre a errada.
+        if (cand.nota === 'site provável da empresa' && !relevante({ titulo: texto.slice(0, 3000), url: cand.url }, palavras)) continue;
         lidas.push({
             titulo: cand.titulo,
             url: cand.url,
@@ -383,7 +503,14 @@ async function pesquisar({ consulta, paginas = 3 }) {
     }
 
     if (!lidas.length) {
-        return { ok: false, error: 'achei os links mas não consegui abrir nenhum', consulta: termo, links: candidatos.map((c) => c.url) };
+        return {
+            ok: false,
+            error: 'achei os links mas não consegui abrir nenhum',
+            consulta: termo,
+            links: candidatos.map((c) => c.url),
+            comoCorrigir: 'Tente browser_open + browser_read num desses links, ou pesquise com outras palavras. '
+                + 'Se nada abrir, diga ao usuário que não conseguiu confirmar os fatos — NUNCA invente dado sobre empresa, data, preço ou pessoa.',
+        };
     }
 
     return {
@@ -396,4 +523,5 @@ async function pesquisar({ consulta, paginas = 3 }) {
     };
 }
 
-module.exports = { pesquisar, buscar, stackoverflow, textoDe, buscarWikipedia, buscarRespostaDDG };
+module.exports = { pesquisar, buscar, stackoverflow, textoDe, buscarWikipedia, buscarRespostaDDG, pegar,
+    relevante, palavrasDaConsulta, sitesProvaveis, pareceCodigo };

package/lib/repeticao.js

@@ -0,0 +1,186 @@
+/**
+ * repeticao.js — o agente não pode ficar dando voltas.
+ *
+ * ── O QUE ACONTECEU DE VERDADE ───────────────────────────────────────────
+ * Pedido real: "pesquise sobre a paris group e crie um vídeo para anunciar a
+ * imersão founders ai". O agente pesquisou, leu a spec da ferramenta de vídeo,
+ * pesquisou de novo, leu a spec de novo — sete vezes — e morreu sem criar nada.
+ *
+ * A culpa não era do modelo. Era nossa. `compactar` encolhe os resultados
+ * antigos para a conversa caber no teto do plano, e a spec do estúdio é um
+ * resultado como outro qualquer: depois de três tools novas, ela virava 300
+ * caracteres. O modelo então não tinha mais o formato do documento para
+ * escrever o vídeo — e fazia a única coisa sensata: pedir a spec de novo. Que
+ * era encolhida de novo. Para sempre.
+ *
+ * ── AS DUAS DEFESAS ──────────────────────────────────────────────────────
+ * 1. REFERÊNCIA NÃO ENCOLHE. O manual e as specs do estúdio são documentos
+ *    fixos: mesma pergunta, mesma resposta, sempre. A cópia mais nova de cada
+ *    uma fica INTEIRA, e as cópias velhas somem (viram um ponteiro). Isso
+ *    corta o motivo do loop e ainda economiza — sete cópias da mesma spec
+ *    eram sete vezes o mesmo texto.
+ *
+ * 2. CHAMADA REPETIDA NÃO EXECUTA. Se ainda assim o modelo repetir a mesma
+ *    tool com os mesmos argumentos, não roda de novo: ele leva um aviso que
+ *    aperta a cada volta, até virar "produza agora com o que você já tem".
+ *    Vale também para pesquisa quase igual — "paris group founders ai
+ *    immersion" e "paris group company ai founders immersion" são a mesma
+ *    busca, e as duas devolviam as mesmas três fontes.
+ *
+ * Puro de propósito: sem rede e sem I/O, para o teste medir a política inteira.
+ */
+
+'use strict';
+
+/** Tools cuja resposta é documento fixo — repetir é sempre desperdício. */
+const REFERENCIAS = new Set(['studio_manual', 'studio_spec']);
+
+/** Acima disto, duas buscas são a mesma busca. */
+const LIMITE_SEMELHANCA = 0.6;
+
+/** Palavras que não distinguem uma busca da outra. */
+const VAZIAS = new Set(['de', 'da', 'do', 'das', 'dos', 'a', 'o', 'as', 'os', 'e', 'em',
+    'para', 'por', 'com', 'sobre', 'the', 'of', 'and', 'for', 'about', 'que', 'na', 'no']);
+
+function normalizar(texto) {
+    return String(texto == null ? '' : texto)
+        .normalize('NFD').replace(/[\u0300-\u036f]/g, '')
+        .toLowerCase().replace(/\s+/g, ' ').trim();
+}
+
+/** As palavras que de fato dizem o que a busca procura. */
+function palavras(texto) {
+    return new Set(normalizar(texto).split(/[^a-z0-9]+/)
+        .filter((p) => p.length >= 3 && !VAZIAS.has(p)));
+}
+
+/** Quanto duas buscas se sobrepõem, de 0 a 1. */
+function semelhanca(a, b) {
+    const A = palavras(a), B = palavras(b);
+    if (!A.size || !B.size) return A.size === B.size ? 1 : 0;
+    let juntos = 0;
+    for (const p of A) if (B.has(p)) juntos++;
+    return juntos / (A.size + B.size - juntos);
+}
+
+/** A mesma chamada com as chaves em qualquer ordem tem a mesma assinatura. */
+function assinatura(nome, args) {
+    const a = args && typeof args === 'object' ? args : {};
+    const partes = Object.keys(a).sort()
+        .map((k) => `${k}=${normalizar(typeof a[k] === 'string' ? a[k] : JSON.stringify(a[k]))}`);
+    return `${nome}(${partes.join('&')})`;
+}
+
+/** O texto que uma chamada de pesquisa procura, seja qual for o apelido do campo. */
+function consultaDe(nome, args) {
+    if (nome !== 'pesquisar_referencia') return null;
+    const a = args || {};
+    return String(a.consulta || a.query || '');
+}
+
+function novo() {
+    return { vistos: new Map(), buscas: [] };
+}
+
+/**
+ * Registra a chamada e diz se ela é repetição.
+ *
+ * Devolve { repetida, vezes, aviso }. Quando `repetida` é true, quem chamou
+ * 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);
+
+    let vezes = (registro.vistos.get(chave) || 0) + 1;
+    let parecidaCom = null;
+
+    // Pesquisa quase igual conta como a mesma pesquisa: o buscador devolve as
+    // mesmas fontes, e o modelo fica convencido de que "ainda não pesquisou".
+    if (vezes === 1 && busca) {
+        const irma = registro.buscas.find((b) => semelhanca(b.texto, busca) >= LIMITE_SEMELHANCA);
+        if (irma) {
+            irma.vezes++;
+            vezes = irma.vezes;
+            parecidaCom = irma.texto;
+        } else {
+            registro.buscas.push({ texto: busca, vezes: 1 });
+        }
+    }
+
+    registro.vistos.set(chave, vezes);
+    if (vezes === 1) return { repetida: false, vezes, aviso: null };
+
+    return { repetida: true, vezes, aviso: aviso(nome, vezes, parecidaCom) };
+}
+
+/** O recado, apertando a cada volta. */
+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.`;
+
+    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). '
+        + 'Se algo realmente impede, chame finish e diga ao usuário o que faltou.';
+}
+
+/**
+ * Mapa tool_call_id -> { nome, args }, lido dos turnos do assistente.
+ *
+ * A mensagem role:'tool' guarda só o id; para saber se ela é uma referência é
+ * preciso achar a chamada que a pediu.
+ */
+function chamadasPorId(messages) {
+    const mapa = new Map();
+    for (const m of messages || []) {
+        if (!m || !m.tool_calls) continue;
+        for (const tc of m.tool_calls) {
+            const f = tc.function || {};
+            let args = {};
+            try { args = typeof f.arguments === 'string' ? JSON.parse(f.arguments) : (f.arguments || {}); } catch {}
+            mapa.set(tc.id, { nome: f.name || tc.name, args });
+        }
+    }
+    return mapa;
+}
+
+/**
+ * Onde estão as referências na conversa.
+ *
+ * Devolve { inteiras, duplicadas }: os índices que NÃO podem encolher (a cópia
+ * mais nova de cada referência) e os que podem sumir de vez (as cópias velhas
+ * da mesma coisa — texto idêntico, repetido).
+ */
+function referenciasNaConversa(messages) {
+    const chamadas = chamadasPorId(messages);
+    const ultima = new Map();
+    const todas = new Map();
+
+    (messages || []).forEach((m, i) => {
+        if (!m || m.role !== 'tool') return;
+        const ch = chamadas.get(m.tool_call_id);
+        if (!ch || !REFERENCIAS.has(ch.nome)) return;
+        const chave = assinatura(ch.nome, ch.args);
+        ultima.set(chave, i);
+        if (!todas.has(chave)) todas.set(chave, []);
+        todas.get(chave).push(i);
+    });
+
+    const inteiras = new Set(ultima.values());
+    const duplicadas = new Set();
+    for (const [chave, indices] of todas) {
+        for (const i of indices) if (i !== ultima.get(chave)) duplicadas.add(i);
+    }
+    return { inteiras, duplicadas };
+}
+
+module.exports = {
+    REFERENCIAS, LIMITE_SEMELHANCA,
+    normalizar, palavras, semelhanca, assinatura, consultaDe,
+    novo, ver, chamadasPorId, referenciasNaConversa,
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "primocode",
-  "version": "8.4.0",
+  "version": "8.5.0",
   "description": "PrimoCode — agente de engenharia com IA e cursor próprio. Modelos grátis. 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/modo.test.js && node test/pasta.test.js && node test/catalogo.test.js && node test/desktop.test.js && node test/effort.test.js && node test/claude-engine.test.js && node test/regressao.test.js && node test/memoria-conversa.test.js"
+    "test": "node test/tools.test.js && node test/ui.test.js && node test/modo.test.js && node test/pasta.test.js && node test/catalogo.test.js && node test/desktop.test.js && node test/effort.test.js && node test/claude-engine.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"
   },
   "engines": {
     "node": ">=18.17.0"