primocode 9.8.0-beta.6 → 9.8.0-beta.8

package/lib/act.js

@@ -24,6 +24,8 @@ const permissao = require('./permissao');
 const perigo = require('./perigo');
 const skills = require('./skills');
 const checkpoint = require('./checkpoint');
+const tempos = require('./tempos');
+const preLeitura = require('./pre-leitura');
 
 // 40, não 15: com o freio de repetição (repeticao.js) e o de rodada parada,
 // volta a mais não é volta em círculo — é trabalho. Quinze acabavam no meio
@@ -35,6 +37,8 @@ const MAX_EMPURROES = 3;
 // Voltas seguidas sem executar nada antes de desistir.
 const MAX_RODADAS_PARADAS = 3;
 const MAX_PROFUNDIDADE = 2; // principal + 1 nível de subagente
+// As leituras que, repetidas sem mudança no meio, devolvem o guardado.
+const RELEITURA = new Set(['read_file', 'list_dir']);
 
 // ── Interrupção (Esc Esc) ─────────────────────────────────────────────────
 // O usuário aperta Esc duas vezes e o agente PARA — entre uma rodada e outra
@@ -134,6 +138,9 @@ function limparParaOModelo(result) {
 
 function logResult(kind, result, profundidade) {
     const p = fala.resultado(profundidade);
+    // A linha da janela (lib/app.js) fecha aqui: o mesmo resultado que o
+    // terminal desenha embaixo, resumido. Ver o canal em lib/fala.js.
+    fala.avisar('resultado', fala.resumoDoResultado(kind, result));
     if (!result) return;
     // Uma tool que falhou é informação para o AGENTE, que vai consertar na
     // volta seguinte — não é o erro do usuário. Âmbar, uma linha, sem o
@@ -382,6 +389,7 @@ async function pausar(ms, subagent) {
     const sp = subagent ? null : new Spinner(PENSANDO).start();
     await new Promise((r) => setTimeout(r, ms));
     if (sp) sp.stop();
+    tempos.somar('espera de cota/rede', ms);
 }
 
 /**
@@ -451,10 +459,10 @@ function motivoDaParada({ voltas, voltasEmFalso, falhasPendentes, travou }) {
 const PULAR_NO_MAPA = new Set(['node_modules', '.git', 'dist', 'build', '.next', '.nuxt', 'out',
     '.cache', 'coverage', '__pycache__', '.venv', 'venv', '.turbo', '.vercel', '.idea', '.vscode']);
 
-function mapaDoProjeto(dir, limite = 80) {
+function arquivosDoProjeto(dir, limite = 80) {
     const path = require('path');
     const fs = require('fs');
-    if (!dir || path.resolve(dir) === path.resolve(cfg.ROOT_DIR)) return '';
+    if (!dir || path.resolve(dir) === path.resolve(cfg.ROOT_DIR)) return [];
     const achados = [];
     const andar = (atual, fundo) => {
         if (fundo > 4 || achados.length >= limite) return;
@@ -470,12 +478,18 @@ function mapaDoProjeto(dir, limite = 80) {
         }
     };
     andar(dir, 0);
+    return achados;
+}
+
+function mapaDoProjeto(dir, limite = 80, achados = arquivosDoProjeto(dir, limite)) {
     if (!achados.length) return '';
     const mais = achados.length >= limite ? `\n… (mais arquivos — use glob para achar)` : '';
     return `Arquivos que JÁ existem neste projeto (edite-os em vez de recriar):\n${achados.join('\n')}${mais}`;
 }
 
-function buildMemoryContext(projectDir, projectName) {
+/* `pedido` é opcional: com ele, o arquivo citado no pedido é o primeiro a
+   entrar já lido (ver lib/pre-leitura.js). */
+function buildMemoryContext(projectDir, projectName, pedido = '') {
     const parts = [];
     // As instruções vêm primeiro: são regra de quem manda no projeto, e a
     // memória é o que o agente anotou. Entram aqui (e não no bin) para valer
@@ -486,8 +500,11 @@ function buildMemoryContext(projectDir, projectName) {
     if (geral.trim()) parts.push(`[memory-geral.md]\n${geral}`);
     const projeto = cfg.readProjectMemory(projectDir);
     if (projeto.trim()) parts.push(`[${projectName || 'projeto'}/memory.md]\n${projeto}`);
-    const mapa = mapaDoProjeto(projectDir);
-    if (mapa) parts.push(`[${projectName || 'projeto'}/arquivos]\n${mapa}`);
+    const arquivos = arquivosDoProjeto(projectDir);
+    const mapa = mapaDoProjeto(projectDir, 80, arquivos);
+    if (mapa) parts.push(`[${projectName || 'projeto'}/arquivos]\n${mapa}\n\n${preLeitura.JUNTAR_LEITURAS}`);
+    const lidos = preLeitura.bloco(preLeitura.escolher(projectDir, arquivos, pedido));
+    if (lidos) parts.push(lidos);
     return parts.join('\n\n');
 }
 
@@ -520,6 +537,11 @@ async function runAct(userPrompt, opts) {
         /* Quem abre a página para conferir antes do "pronto". Injetável pelo
            mesmo motivo do `motor`: o teste mede a regra sem abrir um Chrome. */
         medirPagina = (dir) => require('./pipeline.js').medirNoNavegador(dir),
+        /* Quem LIGA o navegador escondido antes da hora. Injetável pelo mesmo
+           motivo do `medirPagina` — e só vale junto com o padrão dele: um
+           teste que troca o medidor não pode subir um Chrome de verdade. */
+        aquecerPagina = opts && opts.medirPagina ? null
+            : () => require('./browser.js').aquecerRevisor(),
     } = opts || {};
 
     // A pasta de projeto só nasce quando o agente for mesmo MEXER EM ARQUIVO.
@@ -550,6 +572,7 @@ async function runAct(userPrompt, opts) {
     let mexeuNaPagina = false;       // mexeu desde a última conferência?
     let conferencias = 0;            // até duas: entregar, e conferir o conserto
     let avisoDaPagina = '';          // o que ainda estava quebrado na última
+    let msConferindo = 0;            // para o PRIMOCODE_TEMPOS separar as fases
     /* Abre a página e devolve o relato quando é para VOLTAR (achou problema e
        ainda cabe uma volta); null quando é para entregar. O que ficar
        quebrado na última conferência fica em `avisoDaPagina`, e a entrega sai
@@ -560,10 +583,13 @@ async function runAct(userPrompt, opts) {
         conferencias++;
         mexeuNaPagina = false;
         let medida = null;
+        const t = Date.now();
         try {
             fala.pensamento('abrindo a página para conferir antes de entregar', profundidade);
             medida = await medirPagina(pastaAtual);
         } catch { medida = null; }
+        msConferindo += Date.now() - t;
+        tempos.somar('conferir página', Date.now() - t);
         if (!medida || !medida.testou) return null;
         avisoDaPagina = medida.limpo ? ''
             : String(medida.relato || '').split('\n').filter((l) => /·|BRANCO/.test(l)).slice(0, 3).join(' ');
@@ -574,6 +600,8 @@ async function runAct(userPrompt, opts) {
         ? `${texto}\n\nAtenção: abri a página e ela ainda tem problema — ${avisoDaPagina.trim()}` : texto);
     // Quem já foi chamado, e quantas vezes. Ver lib/repeticao.js.
     const jaChamado = repeticao.novo();
+    // O que read_file/list_dir devolveram, pela chave da época (repeticao.js).
+    const leiturasGuardadas = new Map();
     /* O livro deste pedido: arquivos, comandos, links, testes e falhas. Sai
        no fim como balanço (ver lib/registro.js). O subagente tem o seu, que
        não se mistura com o do principal — mas o que ele fez também precisa
@@ -623,7 +651,7 @@ async function runAct(userPrompt, opts) {
 
     const messages = [];
     if (!subagent) {
-        const memory = buildMemoryContext(projectDir, projectName);
+        const memory = buildMemoryContext(projectDir, projectName, userPrompt);
         if (memory) messages.push({ role: 'system', content: `Memória persistente:\n\n${memory}` });
         for (const m of (history || []).slice(-20)) {
             if (m && m.role && m.content) messages.push({ role: m.role, content: m.content });
@@ -735,6 +763,7 @@ async function runAct(userPrompt, opts) {
         let fluxo = null;
 
         emVoo = new AbortController();
+        const tRodada = Date.now();
         try {
             await motor.requestAct(server, { messages: compactar(messages), model, effort, token, projectDir: pastaAtual, projectName, subagent, sinal: emVoo.signal }, (evt) => {
                 if (evt.erro) { streamError = evt.erro; return; }
@@ -781,6 +810,7 @@ async function runAct(userPrompt, opts) {
         }
         sp.stop();
         emVoo = null;
+        tempos.somar(subagent ? 'rodada do subagente' : 'rodada do modelo', Date.now() - tRodada);
         if (PARAR) { if (fluxo) fluxo.fechar(); break; }
 
         // Chamada de função malformada: o modelo errou a SINTAXE da chamada,
@@ -957,6 +987,8 @@ async function runAct(userPrompt, opts) {
 
         let finished = null;
         let algoRodou = false;
+        const tTools = Date.now();
+        const conferindoAntes = msConferindo;
 
         // ORQUESTRAÇÃO: subagentes da MESMA rodada rodam juntos. O modelo que
         // pede "3 agentes, um por arquivo" esperava paralelismo e recebia uma
@@ -1064,7 +1096,18 @@ async function runAct(userPrompt, opts) {
             const eco = repeticao.ver(jaChamado, tc.name, tc.arguments);
             if (eco.repetida) {
                 voltasEmFalso++;
-                messages.push({ role: 'tool', tool_call_id: tc.id, content: eco.aviso });
+                /* RELER SEM MUDANÇA devolve o que já foi lido, uma vez.
+                   O aviso seco ("o resultado está na conversa acima") mentia
+                   depois do `compactar`: a leitura velha já tinha virado 300
+                   caracteres, e o modelo gastava OUTRA ida ao servidor para
+                   achar o arquivo por outro caminho (um `cat`, um grep). Na
+                   segunda vez vai o conteúdo guardado — ler de novo sem nada
+                   mudar dá o mesmo texto, então não há o que executar. Da
+                   terceira em diante é laço, e o freio segue como era. */
+                const guardado = eco.vezes === 2 && leiturasGuardadas.get(eco.chave);
+                messages.push({ role: 'tool', tool_call_id: tc.id, content: guardado
+                    ? `(sem mudança desde a última leitura — é o mesmo conteúdo; não precisa ler de novo)\n${guardado}`
+                    : eco.aviso });
                 continue;
             }
 
@@ -1091,6 +1134,7 @@ async function runAct(userPrompt, opts) {
                 const porta = await permissao.pedir(portaoControle, tc.name, tc.arguments, autorizar);
                 if (!porta.ok) {
                     fala.acao(tc.name, tc.arguments, profundidade);
+                    fala.avisar('resultado', { nome: tc.name, ok: false, resumo: 'não autorizado' });
                     console.log(fala.resultado(profundidade) + c.warn('não autorizado'));
                     registro.anotar(livro, tc.name, tc.arguments, { ok: false, error: porta.error });
                     messages.push({ role: 'tool', tool_call_id: tc.id, content: JSON.stringify({ ok: false, error: porta.error }) });
@@ -1108,6 +1152,7 @@ async function runAct(userPrompt, opts) {
             });
             if (!risco.ok) {
                 fala.acao(tc.name, tc.arguments, profundidade);
+                fala.avisar('resultado', { nome: tc.name, ok: false, resumo: `não autorizado — ${risco.motivo}` });
                 console.log(fala.resultado(profundidade) + c.warn(`não autorizado — ${risco.motivo}`));
                 registro.anotar(livro, tc.name, tc.arguments, { ok: false, error: risco.error });
                 messages.push({ role: 'tool', tool_call_id: tc.id, content: JSON.stringify({ ok: false, error: risco.error }) });
@@ -1125,6 +1170,9 @@ async function runAct(userPrompt, opts) {
             const result = await tools.execute(tc.name, tc.arguments, { projectDir: pastaAtual });
             logResult(tc.name, result, profundidade);
             repeticao.executou(jaChamado, tc.name, tc.arguments);
+            if (RELEITURA.has(tc.name) && result && result.ok !== false) {
+                leiturasGuardadas.set(eco.chave, summarizeForModel(result));
+            }
             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 +1181,19 @@ async function runAct(userPrompt, opts) {
             if (result && result.ok !== false && catalogo.criaProjeto(tc.name, tc.arguments)
                 && /\.(html?|css|m?jsx?|tsx?|vue|svelte)$/i.test(String((tc.arguments && tc.arguments.path) || ''))) {
                 mexeuNaPagina = true;
+                /* O NAVEGADOR ESCONDIDO SOBE AGORA, e não no `finish`.
+                   A conferência só roda quando o agente diz "pronto", e até
+                   lá ainda há pelo menos uma rodada do modelo. Subir o Chrome
+                   ali, em paralelo com ela, tira do "pronto" o tempo de ligar
+                   o navegador e de fazer a PRIMEIRA navegação dele, que é a
+                   parte cara (ver `aquecerRevisor` em lib/browser.js). Medido
+                   em 24/09: a conferência num Chrome recém-aberto levava de
+                   2,1 a 4,6s; aquecido antes, 1,24s — que é o assentar de
+                   1,2s, e nada mais. Sem `await` e sem erro: se não subir, a
+                   conferência tenta de novo e diz o que houve. */
+                if (aquecerPagina && !subagent && conferencias < 2) {
+                    try { Promise.resolve(aquecerPagina()).catch(() => {}); } catch { /* segue */ }
+                }
             }
 
             // Uma escrita bem-sucedida limpa a dívida — mas só a do MESMO
@@ -1174,6 +1235,9 @@ async function runAct(userPrompt, opts) {
             messages.push({ role: 'tool', tool_call_id: tc.id, content: summarizeForModel(result) });
         }
 
+        // A conferência da página tem linha própria: aqui fica só o resto.
+        tempos.somar('ferramentas', Date.now() - tTools - (msConferindo - conferindoAntes));
+
         // 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.