primocode 9.8.0-beta.6 → 9.8.0-beta.7

package/README.md

@@ -1,4 +1,4 @@
-# PrimoCode v9.8.0-beta.6
+# PrimoCode v9.8.0-beta.7
 
 Agente de engenharia brasileiro para o terminal, no estilo Claude Code.
 Cria arquivos de verdade, roda comandos, **controla o navegador e o desktop** —
@@ -9,7 +9,7 @@ OpenRouter, e cada apelido (`top`/`main`/`fast`) é uma **corrente**: se um mode
 está no limite de pedidos, o próximo atende. Você não vê o erro, e não paga nada.
 
 ```
- ▐▛███▜▌   Primo Code v9.8.0-beta.6
+ ▐▛███▜▌   Primo Code v9.8.0-beta.7
 ▝▜█████▛▘  Bem-vindo de volta, Joel
   ▘▘ ▝▝    ~/primocode  · /dir <pasta> muda
 ```

package/bin/primocode.js

@@ -53,6 +53,7 @@ extra.instalarContador(api, contadorDaSessao, () => {
     const p = provedorLocal.atual();
     return p ? p.nome : 'Servidor PrimoCode';
 });
+const tempos = require('../lib/tempos');
 
 // 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
@@ -1055,6 +1056,16 @@ async function sendPrompt(userText) {
         return;
     }
 
+    // PRIMOCODE_TEMPOS=1: uma linha no fim com o custo de cada fase.
+    tempos.comecar();
+    try { await enviarPedido(userText); }
+    finally {
+        const linha = tempos.relatorio();
+        if (linha) console.log(c.dim(`  ⏱ ${linha}`));
+    }
+}
+
+async function enviarPedido(userText) {
     let prompt = userText;
     // "@index.html" no pedido é um /attach só deste pedido: vai junto dos
     // anexos, mas não fica em state.attachedFiles para o próximo.
@@ -1091,15 +1102,22 @@ async function sendPrompt(userText) {
 
         // O resumo da rodada anterior é feito em segundo plano logo depois
         // dela; aqui só se espera ele terminar, para não sair com memória velha.
-        await esperarResumo();
-
+        //
         // 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.
         // UMA chamada faz as duas coisas: arruma o pedido torto e, se fizer
         // sentido, divide em passos. Eram duas idas ao modelo por pedido, e
         // num plano limitado por REQUISIÇÕES (o grátis da Groq são 30 por
         // minuto) cada chamada extra custa tanto quanto token.
-        const passos = await dividirTarefa(prompt);
+        //
+        // As duas esperas correm JUNTAS. Uma não lê o que a outra escreve: o
+        // plano só olha o texto do pedido, e o resumo só a conversa de antes.
+        // Em fila, o pedido de duas fases pagava o resumo e DEPOIS o plano —
+        // duas idas ao modelo em série antes da primeira rodada.
+        const [, passos] = await Promise.all([
+            tempos.medir('espera do resumo', () => esperarResumo()),
+            tempos.medir('plano', () => dividirTarefa(prompt)),
+        ]);
         const instrucaoKit = await prepararKit(plan, userText);
 
         let r = null;
@@ -1214,8 +1232,8 @@ async function sendPrompt(userText) {
         state.gravador.turno(userText, r.assistantMessage.content,
             { modo: 'primocode', projeto: state.currentProject || null });
     } else {
-        await esperarResumo();
-        await runChat(prompt, userText);
+        await tempos.medir('espera do resumo', () => esperarResumo());
+        await tempos.medir('chat', () => runChat(prompt, userText));
     }
 
     state.attachedFiles = [];

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
@@ -382,6 +386,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 +456,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 +475,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 +497,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 +534,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 +569,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 +580,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 +597,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 +648,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 +760,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 +807,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 +984,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 +1093,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;
             }
 
@@ -1125,6 +1165,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 +1176,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 +1230,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.

package/lib/browser.js

@@ -821,6 +821,7 @@ function close() {
 let PORTA_REVISOR = Number(process.env.PRIMOCODE_CDP_PORT_REVISOR || 0);
 let perfilRevisor = null;
 let revisorChild = null;
+let saidaRegistrada = false;
 
 function lerPortaDoPerfil(perfil) {
     try {
@@ -830,7 +831,20 @@ function lerPortaDoPerfil(perfil) {
     } catch { return 0; }
 }
 
-async function subirRevisor() {
+/* Quem está subindo o revisor AGORA. O agente liga o navegador escondido
+   adiantado, quando escreve a primeira página (lib/act.js), e a conferência
+   do "pronto" chama isto de novo — às vezes com o primeiro ainda subindo.
+   Sem esta promessa em comum, a segunda chamada via PORTA_REVISOR zerada e
+   lançava um SEGUNDO Chrome, que ficava órfão. */
+let subindoRevisor = null;
+
+function subirRevisor() {
+    if (subindoRevisor) return subindoRevisor;
+    subindoRevisor = _subirRevisor().finally(() => { subindoRevisor = null; });
+    return subindoRevisor;
+}
+
+async function _subirRevisor() {
     if (PORTA_REVISOR) {
         try {
             const v = await httpGetJson(`http://127.0.0.1:${PORTA_REVISOR}/json/version`, 800);
@@ -880,6 +894,17 @@ async function subirRevisor() {
     revisorChild = spawn(chrome, args, { detached: true, stdio: 'ignore' });
     revisorChild.on('error', () => {});
     revisorChild.unref();
+    /* O REVISOR MORRE COM O PROCESSO. Ele é `detached` + `unref` para não
+       segurar o CLI de pé — e por isso mesmo sobrevivia a ele: só o pipeline
+       (construir_app) chamava fecharRevisor, e toda sessão que conferiu uma
+       página deixava um Chrome invisível para trás. Medido em 24/09 nesta
+       máquina: 7 revisores órfãos somando ~2 GB de memória, um deles com 3
+       minutos de CPU. É o tipo de lentidão que a pessoa sente no computador
+       inteiro e não liga ao PrimoCode. */
+    if (!saidaRegistrada) {
+        saidaRegistrada = true;
+        process.on('exit', () => { try { fecharRevisor(); } catch { /* saindo */ } });
+    }
 
     const prazo = Date.now() + 15000;
     while (Date.now() < prazo) {
@@ -1110,6 +1135,44 @@ async function abrirEscondido(url) {
 /* O revisor é ferramenta de uma tarefa, não um processo que fica. Deixá-lo de
    pé come memória até a pessoa desligar o computador, e ele não é o navegador
    dela — ninguém sentiria falta nem saberia que existe para fechar. */
+/* LIGAR O REVISOR ANTES DA HORA — e não só ligar: navegar uma vez.
+ *
+ * Medido em 24/09, cada fase da conferência num Chrome recém-aberto:
+ * subir 313ms · abrir aba 24ms · canal 29ms · PRIMEIRA navegação 3.019ms ·
+ * assentar 1.200ms. Na segunda página, no mesmo Chrome, a navegação levou
+ * 4ms. O caro não é o processo, é a primeira ida à rede (o Chrome sobe o
+ * serviço de rede e o primeiro renderizador nela) — navegar para about:blank
+ * ou data: não aquece isso (a conferência seguinte continuou em ~2,1s);
+ * navegar para um http local aquece (caiu para 1.240ms, que é o assentar).
+ *
+ * Por isso isto abre uma aba num servidor de uma linha, em 127.0.0.1, e fecha.
+ * Uma vez por navegador: depois da primeira, não há o que aquecer. Nunca
+ * rejeita — aquecer é atalho, e quem confere de verdade tenta de novo e diz
+ * o que houve. */
+let aquecido = null;   // a porta do revisor que já foi aquecido
+let aquecendo = null;
+function aquecerRevisor() {
+    if (aquecendo) return aquecendo;
+    aquecendo = (async () => {
+        await subirRevisor();
+        if (aquecido && aquecido === PORTA_REVISOR) return true;
+        const srv = http.createServer((req, res) => {
+            res.writeHead(200, { 'Content-Type': 'text/html; charset=utf-8' });
+            res.end('<!doctype html><title>.</title>');
+        });
+        try {
+            await new Promise((ok, falhou) => { srv.once('error', falhou); srv.listen(0, '127.0.0.1', ok); });
+            const aba = await abaEscondida(`http://127.0.0.1:${srv.address().port}/`, { assentar: 0, prazoLoad: 10000 });
+            await aba.fechar();
+            aquecido = PORTA_REVISOR;
+            return true;
+        } finally {
+            try { srv.close(); } catch { /* já fechou */ }
+        }
+    })().catch(() => false).finally(() => { aquecendo = null; });
+    return aquecendo;
+}
+
 function fecharRevisor() {
     if (revisorChild && revisorChild.pid) {
         try { process.kill(-revisorChild.pid); } catch {
@@ -1132,5 +1195,5 @@ module.exports = {
     scriptDaSeta, verSeta, findChrome,
     open, click, clickText, clickSelector, type, typeInSelector,
     key, screenshot, evaluate, waitFor, wait, scroll, close,
-    inspecionarEscondido, rodarEscondido, abrirEscondido, fecharRevisor,
+    inspecionarEscondido, rodarEscondido, abrirEscondido, fecharRevisor, subirRevisor, aquecerRevisor,
 };

package/lib/pre-leitura.js

@@ -0,0 +1,118 @@
+/**
+ * pre-leitura.js — os arquivos que o agente ia ler, já lidos.
+ *
+ *   "Toda vez a IA lê as pastas novamente, só pra ler vão 30 chamadas de API."
+ *   (dono, 24/09/2026)
+ *
+ * O caro não é o disco — ler index.html leva 1ms. O caro é a IDA AO MODELO: o
+ * servidor grátis conta pedidos por dia, e cada "deixa eu ler o style.css"
+ * numa resposta própria é um pedido. Medido com um modelo de mentira que
+ * segue uma política fixa (lê o que ainda não viu, um arquivo por resposta,
+ * e confere o index.html antes de editar), num "muda a cor do botão" em
+ * projeto de 10 arquivos: 9 pedidos ao modelo antes, 2 depois. Com todos os
+ * arquivos grandes demais para entrar aqui, a ordem de juntar leituras e a
+ * releitura sem mudança (lib/act.js, RELEITURA) ainda levam de 9 para 4.
+ *
+ * O mapa do projeto já dava os NOMES. Isto põe o CONTEÚDO dos poucos arquivos
+ * que quase todo pedido de página lê — o citado no pedido primeiro, depois
+ * index.html, o css e o js principais, package.json, README — dentro de um
+ * orçamento. Pequeno pelo servidor grátis (o teto é de ~6 mil tokens por
+ * MINUTO, e isto vai em toda rodada); folgado com um provedor próprio.
+ *
+ * Fica de fora o que não se lê como texto ou não vale o espaço: binário,
+ * minificado, lockfile, arquivo grande, e o que já entra por outro caminho
+ * (memory.md, PRIMO.md/AGENTS.md/CLAUDE.md). Arquivo que não cabe inteiro no
+ * que sobrou do orçamento NÃO entra cortado: meio arquivo marcado como
+ * "conteúdo atual" faria o modelo editar às cegas a metade que não viu.
+ *
+ * Puro, menos a leitura do disco — o teste mede a escolha sem rede.
+ */
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+
+const ORCAMENTO_SERVIDOR = 6 * 1024;
+const ORCAMENTO_LOCAL = 40 * 1024;
+const MAIOR_ARQUIVO = 20 * 1024;
+
+const TEXTO = /\.(html?|css|scss|m?jsx?|tsx?|vue|svelte|json|md|txt|py|toml|ya?ml)$/i;
+const LOCKFILES = new Set(['package-lock.json', 'yarn.lock', 'pnpm-lock.yaml', 'bun.lockb',
+    'composer.lock', 'Cargo.lock', 'poetry.lock', 'Gemfile.lock']);
+// Já entram no contexto por outro caminho (buildMemoryContext / mencoes.js).
+const JA_ENTRAM = new Set(['memory.md', 'PRIMO.md', 'AGENTS.md', 'CLAUDE.md']);
+
+/** O orçamento de agora: folgado só com provedor próprio (/api). */
+function orcamento() {
+    try { return require('./local/provedor.js').atual() ? ORCAMENTO_LOCAL : ORCAMENTO_SERVIDOR; }
+    catch { return ORCAMENTO_SERVIDOR; }
+}
+
+/** Quanto o arquivo importa: menor é mais importante; null = não entra. */
+function prioridade(rel, pedido) {
+    const nome = path.basename(rel);
+    if (JA_ENTRAM.has(nome) || LOCKFILES.has(nome) || /\.min\./i.test(nome) || !TEXTO.test(nome)) return null;
+    const fundo = rel.split(/[\\/]/).length - 1;
+    const texto = String(pedido || '').toLowerCase();
+    // Citado no pedido ("muda o style.css") é o que ele vai ler com certeza.
+    if (texto && (texto.includes(rel.toLowerCase()) || texto.includes(nome.toLowerCase()))) return 0;
+    if (fundo > 1) return null;
+    if (/^index\.html?$/i.test(nome)) return 1 + fundo;
+    if (/\.(css|scss)$/i.test(nome)) return 3 + fundo;
+    if (/\.(m?jsx?|tsx?|vue|svelte)$/i.test(nome) && !/\.(test|spec|config)\./i.test(nome)) return 5 + fundo;
+    if (nome === 'package.json' && fundo === 0) return 7;
+    if (/^readme\.md$/i.test(nome) && fundo === 0) return 8;
+    return null;
+}
+
+/**
+ * Escolhe e lê. Devolve [{ rel, conteudo }] na ordem de importância.
+ * @param {string} dir        a pasta do projeto
+ * @param {string[]} arquivos caminhos relativos (o mesmo que o mapa listou)
+ * @param {string} pedido     o texto do pedido — o citado nele vem primeiro
+ * @param {number} limite     bytes no total
+ */
+function escolher(dir, arquivos, pedido, limite = orcamento()) {
+    const candidatos = (arquivos || [])
+        .map((rel) => ({ rel, p: prioridade(rel, pedido) }))
+        .filter((x) => x.p !== null)
+        .sort((a, b) => a.p - b.p || a.rel.localeCompare(b.rel));
+    const lidos = [];
+    let soma = 0;
+    for (const { rel } of candidatos) {
+        const abs = path.join(dir, rel);
+        let st;
+        try { st = fs.statSync(abs); } catch { continue; }
+        if (!st.isFile() || st.size === 0 || st.size > MAIOR_ARQUIVO || soma + st.size > limite) continue;
+        let buf;
+        try { buf = fs.readFileSync(abs); } catch { continue; }
+        if (buf.includes(0)) continue;   // binário com nome de texto
+        const conteudo = buf.toString('utf-8');
+        // Uma linha de milhares de caracteres é minificado sem ".min" no nome.
+        if (conteudo.split('\n').some((l) => l.length > 2000)) continue;
+        lidos.push({ rel, conteudo });
+        soma += st.size;
+    }
+    return lidos;
+}
+
+/** O bloco que vai no contexto, ou '' quando não há nada que valha. */
+function bloco(lidos) {
+    if (!lidos || !lidos.length) return '';
+    const partes = lidos.map(({ rel, conteudo }) =>
+        `[conteúdo atual de ${rel} — não precisa ler de novo]\n${conteudo.replace(/\s+$/, '')}\n[fim de ${rel}]`);
+    return 'Estes arquivos estão aqui como estavam no COMEÇO deste pedido — use o que está abaixo em vez de '
+        + 'chamar read_file neles. Depois que você editar um deles, o texto abaixo fica velho: aí, sim, leia.\n\n'
+        + partes.join('\n\n');
+}
+
+/* A ordem de juntar. Vai junto do mapa porque é ali que o modelo decide o que
+   ler. Cada resposta dele é uma ida ao servidor; cinco leituras em cinco
+   respostas custam cinco pedidos, e as mesmas cinco numa resposta só custam
+   um. */
+const JUNTAR_LEITURAS = 'Precisa ler, listar ou buscar mais de uma coisa? Peça TUDO na MESMA resposta, '
+    + 'com várias chamadas de ferramenta juntas — nunca uma leitura por resposta. Cada resposta sua é '
+    + 'uma ida ao servidor, e o plano conta idas.';
+
+module.exports = { escolher, bloco, prioridade, orcamento, JUNTAR_LEITURAS,
+    ORCAMENTO_SERVIDOR, ORCAMENTO_LOCAL, MAIOR_ARQUIVO };

package/lib/repeticao.js

@@ -173,9 +173,11 @@ function ver(registro, nome, args) {
     }
 
     registro.vistos.set(chave, vezes);
-    if (vezes === 1) return { repetida: false, vezes, aviso: null };
+    // `chave` volta para quem chamou guardar o resultado da leitura pela
+    // mesma época em que ela foi vista (lib/act.js, RELEITURA).
+    if (vezes === 1) return { repetida: false, vezes, aviso: null, chave };
 
-    return { repetida: true, vezes, aviso: aviso(nome, vezes, parecidaCom) };
+    return { repetida: true, vezes, aviso: aviso(nome, vezes, parecidaCom), chave };
 }
 
 /** O recado, apertando a cada volta. */

package/lib/tempos.js

@@ -0,0 +1,62 @@
+/**
+ * tempos.js — para onde foi o tempo de um pedido.
+ *
+ *   PRIMOCODE_TEMPOS=1 primo
+ *
+ * No fim de cada pedido sai UMA linha com o que custou cada fase: o plano, a
+ * espera do resumo, o nome da pasta, cada rodada do modelo, as ferramentas e
+ * a conferência da página. Existe porque "está lento" sem número vira chute:
+ * medido em 24/09 com um servidor de mentira que responde na hora, o que o
+ * PrimoCode gastava sozinho num pedido de página era quase todo a conferência
+ * no navegador escondido (2,1 a 4,6s num Chrome recém-aberto), e não o que
+ * parecia: as ferramentas de três rodadas somaram 7 a 23ms, e o planejador
+ * nem é chamado em pedido de uma fase só.
+ *
+ * Desligado, não custa nada: `medir` chama a função e devolve, sem relógio.
+ *
+ * Um pedido por vez (é assim que o CLI trabalha), então o registro é do
+ * módulo. Subagente soma no mesmo pedido, com o nome da fase.
+ */
+'use strict';
+
+let atual = null;
+
+function ligado() { return process.env.PRIMOCODE_TEMPOS === '1'; }
+
+/** Começa o registro de um pedido. Desligado, não faz nada. */
+function comecar() {
+    atual = ligado() ? { inicio: Date.now(), fases: new Map() } : null;
+    return atual;
+}
+
+/** Soma `ms` à fase `nome` (várias rodadas somam na mesma linha, com contagem). */
+function somar(nome, ms) {
+    if (!atual) return;
+    const f = atual.fases.get(nome) || { ms: 0, vezes: 0 };
+    f.ms += ms;
+    f.vezes++;
+    atual.fases.set(nome, f);
+}
+
+/** Mede uma função (síncrona ou async) e soma o tempo à fase. */
+async function medir(nome, fn) {
+    if (!atual) return fn();
+    const t = Date.now();
+    try { return await fn(); } finally { somar(nome, Date.now() - t); }
+}
+
+function fmt(ms) { return ms >= 1000 ? `${(ms / 1000).toFixed(1)}s` : `${ms}ms`; }
+
+/** A linha do fim. Encerra o registro. null se estava desligado. */
+function relatorio() {
+    if (!atual) return null;
+    const total = Date.now() - atual.inicio;
+    const partes = [...atual.fases].map(([nome, f]) =>
+        `${nome} ${fmt(f.ms)}${f.vezes > 1 ? ` (${f.vezes}x)` : ''}`);
+    atual = null;
+    return `tempos · ${partes.join(' · ')}${partes.length ? ' · ' : ''}total ${fmt(total)}`;
+}
+
+function ativo() { return !!atual; }
+
+module.exports = { ligado, comecar, somar, medir, relatorio, ativo };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "primocode",
-  "version": "9.8.0-beta.6",
+  "version": "9.8.0-beta.7",
   "description": "PrimoCode — agente de engenharia com IA e cursor próprio. Requer conta Conecta Primo AI (Premium ou Super). 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/entrada.test.js && node test/transparencia.test.js && node test/permissao.test.js && node test/compatibilidade.test.js && node test/skills.test.js && node test/skills-de-fora.test.js && node test/skills-novas.test.js && node test/comandos.test.js && node test/estudio.test.js && node test/voz.test.js && node test/voz-conversa.test.js && node test/modo.test.js && node test/pasta.test.js && node test/projeto.test.js && node test/nome-projeto.test.js && node test/kits.test.js && node test/api-propria.test.js && node test/claude-engine.test.js && node test/codex.test.js && node test/conferir.test.js && node test/catalogo.test.js && node test/desktop.test.js && node test/seta.test.js && node test/effort.test.js && node test/regressao.test.js && node test/memoria-conversa.test.js && node test/repeticao.test.js && node test/autonomia.test.js && node test/desfazer.test.js && node test/desfazer-git.test.js && node test/referencia.test.js && node test/parar.test.js && node test/continuar.test.js && node test/pipeline.test.js && node test/app.test.js && node test/ide.test.js && node test/aplicativo.test.js && node test/conta.test.mjs && node test/nuvem.test.js && node test/prazo.test.js && node test/primeira-vez.test.js && node test/janela.test.js && node test/fala.test.js && node test/especialistas.test.js && node test/empurrao.test.js && node test/terminal-novo.test.js && node test/markdown.test.js && node test/coerencia.test.js && node test/contexto.test.js && node test/perigo.test.js && node test/mascotes.test.js && node test/comandos-extra.test.js"
+    "test": "node test/tools.test.js && node test/ui.test.js && node test/entrada.test.js && node test/transparencia.test.js && node test/permissao.test.js && node test/compatibilidade.test.js && node test/skills.test.js && node test/skills-de-fora.test.js && node test/skills-novas.test.js && node test/comandos.test.js && node test/estudio.test.js && node test/voz.test.js && node test/voz-conversa.test.js && node test/modo.test.js && node test/pasta.test.js && node test/projeto.test.js && node test/nome-projeto.test.js && node test/kits.test.js && node test/api-propria.test.js && node test/claude-engine.test.js && node test/codex.test.js && node test/conferir.test.js && node test/catalogo.test.js && node test/desktop.test.js && node test/seta.test.js && node test/effort.test.js && node test/regressao.test.js && node test/memoria-conversa.test.js && node test/repeticao.test.js && node test/autonomia.test.js && node test/desfazer.test.js && node test/desfazer-git.test.js && node test/referencia.test.js && node test/parar.test.js && node test/continuar.test.js && node test/pipeline.test.js && node test/app.test.js && node test/ide.test.js && node test/aplicativo.test.js && node test/conta.test.mjs && node test/nuvem.test.js && node test/prazo.test.js && node test/primeira-vez.test.js && node test/janela.test.js && node test/fala.test.js && node test/especialistas.test.js && node test/empurrao.test.js && node test/terminal-novo.test.js && node test/markdown.test.js && node test/coerencia.test.js && node test/contexto.test.js && node test/perigo.test.js && node test/rapidez.test.js && node test/mascotes.test.js && node test/comandos-extra.test.js"
   },
   "engines": {
     "node": ">=18.17.0"