primocode 8.2.2 → 8.4.1

package/bin/primocode.js

@@ -24,6 +24,7 @@ const claudeEngine = require('../lib/claude-engine');
 const pasta = require('../lib/pasta');
 const catalogo = require('../lib/catalogo');
 const effort = require('../lib/effort');
+const memoria = require('../lib/memoria-conversa');
 
 // Rede de segurança de último recurso: sem isto, uma exceção fora de um
 // try/catch (ex.: dentro de um callback de socket, como o parser de SSE) não
@@ -50,6 +51,9 @@ const state = {
     mode: null,        // 'primocode' | 'chat' | 'auto' — vem da config em main()
     modoEfetivo: null, // no auto, o modo que o último pedido usou de fato
     attachedFiles: [],
+    // O resumo incremental da conversa — um /compact automático. O porquê
+    // está em lib/memoria-conversa.js.
+    memoria: memoria.nova(),
     lastResponse: '',
     currentProject: null,
     workDir: null,     // pasta onde o agente trabalha nesta sessão
@@ -529,12 +533,17 @@ async function sendPrompt(userText) {
     if (modo === 'primocode') {
         const plan = prepararPasta(userText);
 
+        // Antes de gastar com a tarefa, dobra no resumo o que já passou. A
+        // conta é pequena: entra "resumo de antes + o que é novo", não a
+        // conversa inteira.
+        await comprimirConversa();
+
         const r = await runAct(prompt, {
             server: state.config.server,
             model: state.config.model,
             effort: state.config.effort,
             token: state.config.token,
-            history: state.history,
+            history: memoria.paraEnviar(state.memoria, state.history),
             projectDir: plan.dir,
             projectName: plan.name || state.currentProject,
             // Só chamado se o agente for mesmo MEXER EM ARQUIVO — abrir o Chrome
@@ -547,6 +556,7 @@ async function sendPrompt(userText) {
         state.lastResponse = r.assistantMessage.content;
         cfg.appendHistory({ mode: 'primocode', project: state.currentProject, prompt: userText });
     } else {
+        await comprimirConversa();
         await runChat(prompt, userText);
     }
 
@@ -554,6 +564,27 @@ async function sendPrompt(userText) {
     refreshPrompt();
 }
 
+/**
+ * Atualiza o resumo da conversa, se já compensar.
+ *
+ * Silencioso quando não há o que fazer: nas primeiras rodadas a conversa é
+ * curta e o resumo não pagaria a chamada.
+ */
+async function comprimirConversa() {
+    if (!memoria.precisaResumir(state.memoria, state.history)) return;
+    const sp = new Spinner('resumindo a conversa').start();
+    try {
+        state.memoria = await memoria.atualizar(state.memoria, state.history, ({ resumo, mensagens }) =>
+            api.requestResumo(state.config.server, { resumo, mensagens, token: state.config.token })
+                .then((r) => r.resumo));
+        sp.stop();
+        const e = memoria.economia(state.memoria, state.history);
+        if (e.poupado > 0) console.log(c.dim(`  ⎿ conversa resumida · ${e.cheio} → ${e.enxuto} tokens por pedido`));
+    } catch {
+        sp.stop();   // resumo é economia, não requisito: falhou, segue a vida
+    }
+}
+
 async function runChat(promptForModel, userTextForMemory) {
     const sp = new Spinner('pensando').start();
     let started = false;
@@ -561,7 +592,7 @@ async function runChat(promptForModel, userTextForMemory) {
     try {
         await api.requestChat(state.config.server, {
             prompt: promptForModel,
-            history: state.history.slice(-20),
+            history: memoria.paraEnviar(state.memoria, state.history),
             model: state.config.model,
             token: state.config.token,
         }, (evt) => {
@@ -854,7 +885,7 @@ async function handleSlash(text) {
             break;
         }
 
-        case 'clear': state.history = []; console.log(c.ok('Conversa limpa.')); break;
+        case 'clear': state.history = []; state.memoria = memoria.nova(); console.log(c.ok('Conversa limpa.')); break;
         case 'cls': process.stdout.write('\x1Bc'); break;
 
         case 'status': {
@@ -872,6 +903,14 @@ async function handleSlash(text) {
                     console.log(c.dim(`  Reservas: ${fila.length - 1}`));
                 }
             } catch (e) { sp.stop(); console.log(c.err(`Indisponível: ${e.message}`)); }
+            // A memória da conversa: quanto ela está poupando por pedido.
+            if (state.history.length) {
+                const e = memoria.economia(state.memoria, state.history);
+                console.log(c.muted(`  Conversa: ${state.history.length} mensagens`)
+                    + (state.memoria.resumo
+                        ? c.dim(`  · resumida, ${e.enxuto} tokens por pedido em vez de ${e.cheio}`)
+                        : c.dim(`  · ${e.enxuto} tokens por pedido`)));
+            }
             break;
         }
 

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) ─────────────────────────────────────────────────
@@ -164,6 +167,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 +184,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 +267,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 +287,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 = [];
@@ -292,6 +349,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 +365,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 +380,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 +399,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 +438,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 +468,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 +514,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

@@ -128,6 +128,13 @@ function requestChat(serverUrl, payload, onEvent) {
     return requestStream(serverUrl, '/api/chat/stream', body, onEvent, token);
 }
 
+// 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 { token, ...body } = payload;
+    return request(serverUrl, '/api/resumir', body, token);
+}
+
 function getHealth(serverUrl, token) {
     return new Promise((resolve, reject) => {
         const url = new URL('/health', serverUrl);
@@ -144,4 +151,4 @@ function getHealth(serverUrl, token) {
     });
 }
 
-module.exports = { request, requestStream, requestAct, requestChat, getHealth };
+module.exports = { request, requestStream, requestAct, requestChat, requestResumo, getHealth };

package/lib/memoria-conversa.js

@@ -0,0 +1,124 @@
+/**
+ * memoria-conversa.js — a conversa que não engorda.
+ *
+ * ── O PROBLEMA ───────────────────────────────────────────────────────────
+ * O histórico ia inteiro (as últimas 20 mensagens) em todo pedido. Numa
+ * conversa de trabalho isso vira milhares de tokens repetidos a cada rodada, e
+ * num plano com teto por minuto a tarefa morre no meio — depois de o esforço
+ * já ter sido gasto. Cortar pelas últimas N é pior ainda: some justamente o
+ * começo, onde está o que o usuário pediu.
+ *
+ * ── A IDEIA (do dono) ────────────────────────────────────────────────────
+ * Resumo INCREMENTAL, como um /compact automático: guarda-se um resumo do que
+ * já passou e, a cada rodada, só o PEDAÇO NOVO é dobrado nele. A primeira vez
+ * custa; da segunda em diante o resumo já existe e só o que foi dito a mais
+ * precisa ser lido.
+ *
+ * O custo fica limitado por construção: a entrada do resumo é sempre
+ * "resumo de antes + o que aconteceu desde então", nunca a conversa inteira.
+ *
+ * ── O QUE NUNCA É RESUMIDO ───────────────────────────────────────────────
+ * As últimas rodadas vão CRUAS. Resumo é bom para lembrar do que foi feito,
+ * péssimo para continuar de onde parou: "agora põe música de fundo" precisa da
+ * frase anterior literal, não de um tópico dizendo que houve um vídeo.
+ *
+ * Este arquivo é puro — quem fala com o servidor é quem chama `atualizar`.
+ * Assim o teste mede a política inteira sem rede e sem chave de API.
+ */
+
+'use strict';
+
+/** ~4 caracteres por token. Mesma conta do servidor, e boa o bastante aqui. */
+function tokensDe(x) {
+    const texto = typeof x === 'string' ? x : JSON.stringify(x || '');
+    return Math.ceil(texto.length / 4);
+}
+
+// Quantas mensagens do fim ficam sempre cruas (o "de onde parei").
+const CRUAS = 4;
+// Acima disto, a cauda vira resumo. Abaixo, não compensa pagar a chamada.
+const LIMITE_TOKENS = 700;
+
+/** Estado inicial — o que o CLI guarda entre um pedido e outro. */
+function nova() {
+    return { resumo: '', resumidasAte: 0 };
+}
+
+/**
+ * O que ainda não foi resumido e já não cabe entre as cruas.
+ * É exatamente o que a próxima chamada de resumo precisa ler.
+ */
+function pendentes(memoria, history) {
+    const fim = Math.max(0, (history || []).length - CRUAS);
+    if (fim <= memoria.resumidasAte) return [];
+    return history.slice(memoria.resumidasAte, fim);
+}
+
+/** Vale a pena pagar uma chamada de resumo agora? */
+function precisaResumir(memoria, history) {
+    const novas = pendentes(memoria, history);
+    if (!novas.length) return false;
+    return tokensDe(novas) >= LIMITE_TOKENS;
+}
+
+/**
+ * Dobra o pedaço novo no resumo. `resumir` é quem fala com o servidor:
+ * recebe { resumo, mensagens } e devolve o texto do resumo atualizado.
+ *
+ * Devolve SEMPRE uma memória utilizável — se o resumo falhar (rede, cota), a
+ * anterior continua valendo e a conversa segue com o histórico cru.
+ */
+async function atualizar(memoria, history, resumir) {
+    const novas = pendentes(memoria, history);
+    if (!novas.length) return memoria;
+
+    let texto;
+    try {
+        texto = await resumir({ resumo: memoria.resumo, mensagens: novas });
+    } catch {
+        return memoria;
+    }
+    const limpo = String(texto || '').trim();
+    if (!limpo) return memoria;
+
+    return { resumo: limpo, resumidasAte: (history || []).length - CRUAS };
+}
+
+/**
+ * Onde a parte crua pode começar sem deixar resultado órfão.
+ *
+ * A API recusa um `role:'tool'` sem o turno do assistente que o pediu. Cortar
+ * "as últimas N" cai nisso na hora em que a conta não bate — então o começo
+ * recua até um ponto onde a rodada está inteira.
+ */
+function inicioSeguro(todas, alvo) {
+    let i = Math.max(0, Math.min(alvo, todas.length));
+    while (i > 0 && todas[i] && todas[i].role === 'tool') i--;
+    return i;
+}
+
+/**
+ * O histórico que vai no pedido: o resumo (se houver) + as últimas cruas.
+ *
+ * O resumo entra como mensagem de sistema, não como fala do usuário — o modelo
+ * precisa saber que aquilo é memória, e não algo que alguém acabou de dizer.
+ */
+function paraEnviar(memoria, history) {
+    const todas = history || [];
+    if (!memoria || !memoria.resumo) return todas.slice(inicioSeguro(todas, todas.length - 20));
+
+    const cruas = todas.slice(inicioSeguro(todas, todas.length - CRUAS));
+    return [
+        { role: 'system', content: `Resumo da conversa até aqui (memória, não é fala de ninguém):\n${memoria.resumo}` },
+        ...cruas,
+    ];
+}
+
+/** Quanto este jeito economiza — para o /status e para o teste provarem. */
+function economia(memoria, history) {
+    const cheio = tokensDe((history || []).slice(-20));
+    const enxuto = tokensDe(paraEnviar(memoria, history));
+    return { cheio, enxuto, poupado: Math.max(0, cheio - enxuto) };
+}
+
+module.exports = { nova, pendentes, precisaResumir, atualizar, paraEnviar, economia, tokensDe, inicioSeguro, CRUAS, LIMITE_TOKENS };

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.2.2",
+  "version": "8.4.1",
   "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"
+    "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"
   },
   "engines": {
     "node": ">=18.17.0"