primocode 8.4.0 → 8.4.1

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/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.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 && 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"
   },
   "engines": {
     "node": ">=18.17.0"