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

package/lib/fala.js

@@ -37,9 +37,95 @@
 
 'use strict';
 
+const { EventEmitter } = require('events');
 const { c, actionHeader, friendlyError } = require('./ui');
 const markdown = require('./markdown.js');
 
+/* ── O CANAL ESTRUTURADO ─────────────────────────────────────────────────
+ * A janela do app (lib/app.js) mostra a conversa como CHAT: a fala do Primo
+ * em texto e cada ação dele numa linha cinza ("Leu index.html", "Rodou npm
+ * test ✓"). Adivinhar isso relendo a saída colorida do terminal seria frágil
+ * — um rótulo que muda aqui quebraria a janela calado. Então a MESMA função
+ * que desenha no terminal também avisa, por este canal, o que desenhou.
+ *
+ * Sem ouvinte (terminal puro), `avisar` não faz nada: nenhum custo para quem
+ * não abriu a janela. */
+const eventos = new EventEmitter();
+eventos.setMaxListeners(20);
+function avisar(tipo, dados) {
+    if (!eventos.listenerCount('evento')) return;
+    try { eventos.emit('evento', Object.assign({ tipo }, dados || {})); } catch { /* a janela nunca derruba o agente */ }
+}
+
+/* O que a linha de ação da janela diz, por ferramenta. Verbo no passado
+   porque a linha fica na conversa depois que a ação acabou — "Lendo" viraria
+   mentira um segundo depois. O ícone é uma família, não um desenho por tool:
+   a página tem dez ícones, não setenta. */
+const VERBOS = {
+    read_file: ['Leu', 'ler'], write_file: ['Escreveu', 'escrever'], edit_file: ['Editou', 'editar'],
+    multi_edit: ['Editou', 'editar'], list_dir: ['Listou', 'buscar'], glob: ['Procurou', 'buscar'],
+    grep: ['Buscou', 'buscar'], run_shell: ['Rodou', 'rodar'], run_in_new_terminal: ['Abriu um terminal com', 'rodar'],
+    open_in_browser: ['Abriu', 'web'], spawn_agent: ['Chamou um agente', 'agente'], write_todos: ['Planejou', 'plano'],
+    finish: ['Concluiu', 'plano'], pesquisar_referencia: ['Pesquisou', 'web'], remember_general: ['Guardou na memória', 'plano'],
+    planejar_producao: ['Planejou a produção', 'agente'], construir_app: ['Construiu', 'agente'],
+};
+
+/** Verbo, alvo e ícone de uma ação — só o que cabe numa linha, nunca o
+ *  conteúdo inteiro de um write_file. */
+function resumoDaAcao(name, args) {
+    const a = args || {};
+    let [verbo, icone] = VERBOS[name] || [];
+    if (!verbo) {
+        if (/^browser_/.test(name)) { verbo = 'Navegador · ' + name.slice(8); icone = 'web'; }
+        else if (/^desktop_/.test(name)) { verbo = 'Computador · ' + name.slice(8).replace(/_/g, ' '); icone = 'computador'; }
+        else if (/^estudio_/.test(name)) { verbo = 'Estúdio · ' + name.slice(8); icone = 'agente'; }
+        else { verbo = name; icone = 'outro'; }
+    }
+    let alvo = a.path || a.command || a.pattern || a.consulta || a.url || a.target || a.app || a.selector
+        || a.titulo || a.description || a.arquivo || (a.todos ? `${a.todos.length} tarefas` : '') || '';
+    if (typeof alvo !== 'string') alvo = '';
+    alvo = alvo.replace(/\s+/g, ' ').trim();
+    if (alvo.length > 120) alvo = alvo.slice(0, 119) + '…';
+    return { nome: name, verbo, alvo, icone };
+}
+
+/** O resultado de uma ação, resumido para a linha da janela: ok ou não, o
+ *  "+12 −3" das edições e até 40 linhas de detalhe para quem expandir. */
+function resumoDoResultado(name, r) {
+    if (!r || typeof r !== 'object') return { nome: name, ok: true };
+    if (r.ok === false) {
+        return { nome: name, ok: false, resumo: String(r.error || `exit ${r.code ?? 'erro'}`).replace(/\s+/g, ' ').trim().slice(0, 300) };
+    }
+    const fora = { nome: name, ok: true };
+    if (typeof r._antes === 'string' && typeof r._depois === 'string') {
+        try {
+            const diff = require('./diff.js');
+            const n = r._antes.split('\n').length + r._depois.split('\n').length;
+            if (n <= diff.MAX_LINHAS_ARQUIVO * 2) {
+                const ops = diff.operacoes(r._antes, r._depois);
+                Object.assign(fora, diff.contar(ops));
+                fora.detalhe = ops.filter((o) => o.tipo !== ' ').slice(0, 40).map((o) => o.tipo + ' ' + o.texto).join('\n');
+            }
+        } catch { /* sem diff: a linha sai sem os números */ }
+    }
+    if (name === 'write_file') fora.criado = !!r.created;
+    if (name === 'run_shell' || name === 'run_in_new_terminal') {
+        const saida = String(r.stdout || '').trim() + (r.stderr ? '\n' + String(r.stderr).trim() : '');
+        fora.detalhe = saida.split('\n').slice(-40).join('\n').trim();
+        fora.codigo = r.code ?? 0;
+    }
+    const plural = (n, um, varios) => `${n} ${n === 1 ? um : varios}`;
+    if (name === 'read_file') fora.resumo = plural(r.linhas || 0, 'linha', 'linhas');
+    if (name === 'grep') fora.resumo = plural(r.total || 0, 'ocorrência', 'ocorrências');
+    if (name === 'glob') fora.resumo = plural(r.total || 0, 'arquivo', 'arquivos');
+    if (name === 'list_dir' && r.tree) fora.detalhe = String(r.tree).split('\n').slice(0, 40).join('\n');
+    if (name === 'write_todos' && Array.isArray(r.todos)) {
+        fora.detalhe = r.todos.map((t) => (t.status === 'completed' ? '✓ ' : '○ ') + t.content).join('\n');
+        fora.resumo = `${r.feitos}/${r.total}`;
+    }
+    return fora;
+}
+
 /* Até este tamanho, o texto que o modelo escreve antes de chamar uma tool é
    guardado e sai de uma vez, como pensamento. Passou disso sem tool à vista,
    é resposta — e volta a correr na tela conforme chega. Uma frase de
@@ -58,6 +144,7 @@ function pensamento(texto, profundidade) {
     if (!ls.length || !ls[0]) return '';
     const p = ident(profundidade);
     const saida = ls.map((l, i) => `${p}  ${i === 0 ? c.dim('✦') : ' '} ${c.muted(l)}`).join('\n');
+    avisar('pensamento', { texto: ls.join('\n'), prof: profundidade || 0 });
     console.log(saida);
     return saida;
 }
@@ -65,6 +152,7 @@ function pensamento(texto, profundidade) {
 /** A ação (tool) que ele decidiu fazer. */
 function acao(name, args, profundidade) {
     const saida = ident(profundidade) + actionHeader(name, args);
+    avisar('acao', Object.assign(resumoDaAcao(name, args), { prof: profundidade || 0 }));
     console.log(saida);
     return saida;
 }
@@ -102,6 +190,7 @@ function resposta(texto) {
     const largura = Math.max(40, (process.stdout.columns || 80) - 4);
     const linhasMd = markdown.renderizar(texto, largura);
     const saida = '\n' + linhasMd.map((l, i) => (i === 0 ? `${c.brand('●')} ${l}` : `  ${l}`)).join('\n');
+    avisar('resposta', { texto: String(texto) });
     console.log(saida);
     return saida;
 }
@@ -111,6 +200,7 @@ function resposta(texto) {
 function aviso(texto) {
     if (!String(texto || '').trim()) return '';
     const saida = '\n' + formatar(texto, c.warn('●'));
+    avisar('aviso', { texto: String(texto) });
     console.log(saida);
     return saida;
 }
@@ -154,9 +244,11 @@ function fluxo() {
         escrever(delta) {
             const t = String(delta || '');
             if (!t) return;
+            avisar('pedaco', { texto: t });
             sair(desenho.pedaco(t));
         },
         fechar() {
+            avisar('fim', {});
             sair(desenho.fim());
             if (escreveu) process.stdout.write('\n');
         },
@@ -174,6 +266,7 @@ function paralelo(quantos, profundidade) {
 /** Um agente delegado começando: "◆ Agente·frontend  a folha de estilo". */
 function agente(rotulo, descricao, profundidade) {
     const saida = `${ident(profundidade)}  ${c.brand('◆')} ${c.bold(rotulo || 'Agente')}${descricao ? '  ' + c.muted(descricao) : ''}`;
+    avisar('acao', { nome: 'agente', verbo: rotulo || 'Agente', alvo: String(descricao || '').slice(0, 120), icone: 'agente', prof: profundidade || 0 });
     console.log(saida);
     return saida;
 }
@@ -182,8 +275,9 @@ function agente(rotulo, descricao, profundidade) {
 function agenteVoltou(resumo, profundidade) {
     const texto = String(resumo || 'sem resultado').replace(/\s+/g, ' ').trim();
     const saida = resultado(profundidade) + c.muted(texto.length > 140 ? texto.slice(0, 139) + '…' : texto);
+    avisar('resultado', { nome: 'agente', ok: true, detalhe: texto.slice(0, 2000) });
     console.log(saida);
     return saida;
 }
 
-module.exports = { LIMIAR_PENSAMENTO, pensamento, acao, resultado, recuo, resposta, aviso, problema, frase, fluxo, paralelo, agente, agenteVoltou };
+module.exports = { eventos, avisar, resumoDaAcao, resumoDoResultado, LIMIAR_PENSAMENTO, pensamento, acao, resultado, recuo, resposta, aviso, problema, frase, fluxo, paralelo, agente, agenteVoltou };

package/lib/{ide.js → painel.js}

@@ -1,27 +1,30 @@
 /**
- * ide.js — a PrimoCode IDE: árvore, editor, prévia e chat, na mesma janela.
+ * painel.js — o painel da direita da janela: a prévia do site e os arquivos.
  *
- *   "Um app ao invés de CLI, aí fica uma IDE e uma CLI."
+ *   "Remove a IDE ou deixa idêntico ao Codex."
  *
- * ── POR QUE MORA DENTRO DO SERVIDOR DO /rc ───────────────────────────────
- * A janela do /rc já resolveu o difícil: servidor em 127.0.0.1 com chave
- * sorteada, fluxo de eventos (SSE) ao vivo e o espelho da saída do terminal.
- * Uma IDE com servidor próprio seria uma segunda chave, uma segunda porta e um
- * segundo fluxo — e as duas janelas mostrariam agentes que parecem diferentes
- * sendo o mesmo. Aqui só entram as rotas que a IDE precisa a mais (árvore,
- * ler, salvar, prévia) e o vigia da pasta, que empurra eventos pelo MESMO
- * fluxo do /rc.
+ * Antes isto era a PrimoCode IDE: árvore, EDITOR de código, prévia e chat. O
+ * editor saiu. Quem usa o PrimoCode não programa — um editor de código na
+ * cara dessa pessoa é uma porta para quebrar o que o agente fez, sem saber
+ * como voltar. O que ficou é o que ela usa de verdade: ver o site que está
+ * nascendo (Prévia) e olhar o que tem na pasta (Arquivos), só leitura.
+ *
+ * ── POR QUE MORA DENTRO DO SERVIDOR DA JANELA ────────────────────────────
+ * A janela (lib/app.js) já resolveu o difícil: 127.0.0.1, chave sorteada e o
+ * fluxo de eventos (SSE). Aqui só entram as rotas do painel (árvore, ler,
+ * prévia) e o vigia da pasta, que empurra "arquivo mudou" pelo MESMO fluxo —
+ * é o que faz a prévia recarregar enquanto o agente escreve.
  *
  * ── SEGURANÇA ────────────────────────────────────────────────────────────
- * Estas rotas leem e ESCREVEM no disco do usuário. Três travas:
  *   · a chave do app.js vale aqui também (tudo mora em /api/);
  *   · todo caminho é resolvido DENTRO da pasta do projeto — "../", caminho
  *     absoluto e link simbólico que aponta para fora são recusados;
+ *   · nada aqui escreve no disco: sem editor, não há rota de salvar;
  *   · a prévia roda num iframe sandbox SEM allow-same-origin, e o servidor
  *     manda o mesmo sandbox no cabeçalho. O código da prévia foi escrito pelo
- *     agente (ou pela pessoa); se ele herdasse a origem da IDE, poderia chamar
- *     /api/enviar e dar ordens ao agente. Com origem opaca, o fetch dele sai
- *     com `Origin: null` e o app.js recusa.
+ *     agente; se ele herdasse a origem da janela, poderia chamar /api/enviar
+ *     e dar ordens ao agente. Com origem opaca, o fetch dele sai com
+ *     `Origin: null` e o app.js recusa.
  */
 
 'use strict';
@@ -36,9 +39,9 @@ const IGNORADOS = new Set(['node_modules', '.git', '.DS_Store', '.next', '.cache
     '__pycache__', '.venv', 'venv', '.turbo', '.parcel-cache']);
 const MAX_ITENS = 4000;
 const MAX_PROFUNDIDADE = 12;
-// 1 MB: acima disso um <textarea> engasga a cada tecla, e arquivo desse
-// tamanho num projeto de iniciante é quase sempre gerado (bundle, dado).
-const MAX_EDITOR = 1024 * 1024;
+// 1 MB: acima disso o visualizador engasga, e arquivo desse tamanho num
+// projeto de iniciante é quase sempre gerado (bundle, dado).
+const MAX_LEITURA = 1024 * 1024;
 
 // ── caminhos ─────────────────────────────────────────────────────────────
 
@@ -46,12 +49,12 @@ const MAX_EDITOR = 1024 * 1024;
  *
  * `path.relative` pega o "../" e o caminho absoluto; o `realpath` pega o link
  * simbólico, que passa pelo primeiro teste com cara de arquivo de dentro e
- * aponta para ~/.ssh. Arquivo que ainda não existe (salvar um novo) é checado
+ * aponta para ~/.ssh. Caminho que ainda não existe é checado
  * pela pasta onde vai nascer. */
 function dentro(raiz, relativo) {
     if (typeof relativo !== 'string' || relativo.includes('\0')) return null;
     // Absoluto é recusado de cara, e não "reinterpretado" como relativo:
-    // quem manda /etc/hosts quer o /etc/hosts, e salvar em <projeto>/etc/hosts
+    // quem manda /etc/hosts quer o /etc/hosts, e ler <projeto>/etc/hosts
     // no lugar seria uma surpresa. `C:\` e `\\servidor` também contam.
     if (path.isAbsolute(relativo) || path.win32.isAbsolute(relativo)) return null;
     const base = path.resolve(raiz);
@@ -113,11 +116,10 @@ function arvore(raiz) {
     return { itens, cortada };
 }
 
-// ── ler e salvar ─────────────────────────────────────────────────────────
+// ── ler ──────────────────────────────────────────────────────────────────
 
 /* Binário é o que tem byte zero nos primeiros 8 KB — o mesmo teste do git.
-   Mostrar um PNG como texto no editor e deixar a pessoa salvar por cima
-   destruiria a imagem sem aviso. */
+   Mostrar um PNG como texto é uma tela de lixo que parece arquivo quebrado. */
 function ehBinario(buf) {
     const n = Math.min(buf.length, 8000);
     for (let i = 0; i < n; i++) if (buf[i] === 0) return true;
@@ -131,35 +133,12 @@ function ler(raiz, rel) {
     try { st = fs.statSync(abs); } catch { return { status: 404, corpo: { ok: false, error: 'não existe' } }; }
     if (!st.isFile()) return { status: 400, corpo: { ok: false, error: 'não é arquivo' } };
     const base = { ok: true, caminho: relativoDe(raiz, abs), tamanho: st.size, mtime: st.mtimeMs };
-    if (st.size > MAX_EDITOR) return { status: 200, corpo: Object.assign(base, { grande: true }) };
+    if (st.size > MAX_LEITURA) return { status: 200, corpo: Object.assign(base, { grande: true }) };
     const buf = fs.readFileSync(abs);
     if (ehBinario(buf)) return { status: 200, corpo: Object.assign(base, { binario: true }) };
     return { status: 200, corpo: Object.assign(base, { conteudo: buf.toString('utf8') }) };
 }
 
-/* `mtimeBase` é o mtime que a página viu ao abrir o arquivo. Se o disco está
-   mais novo, alguém (quase sempre o agente) mexeu no meio — e salvar por cima
-   apagaria o trabalho dele sem ninguém perceber. A página decide: recarregar
-   ou mandar de novo com `forcar`. */
-function salvar(raiz, dados) {
-    const rel = dados && dados.caminho;
-    const conteudo = dados && dados.conteudo;
-    if (typeof conteudo !== 'string') return { status: 400, corpo: { ok: false, error: 'conteúdo faltando' } };
-    if (Buffer.byteLength(conteudo) > MAX_EDITOR) return { status: 413, corpo: { ok: false, error: 'maior que 1 MB' } };
-    const abs = dentro(raiz, rel);
-    if (!abs || abs === path.resolve(raiz)) return { status: 403, corpo: { ok: false, error: 'fora da pasta do projeto' } };
-    if (ignorado(relativoDe(raiz, abs))) return { status: 403, corpo: { ok: false, error: 'pasta protegida' } };
-    let st = null;
-    try { st = fs.statSync(abs); } catch { /* arquivo novo */ }
-    if (st && !st.isFile()) return { status: 400, corpo: { ok: false, error: 'não é arquivo' } };
-    if (st && dados.mtimeBase && !dados.forcar && st.mtimeMs > Number(dados.mtimeBase) + 1) {
-        return { status: 409, corpo: { ok: false, conflito: true, error: 'mudou no disco depois que você abriu', mtime: st.mtimeMs } };
-    }
-    fs.mkdirSync(path.dirname(abs), { recursive: true });
-    fs.writeFileSync(abs, conteudo);
-    return { status: 200, corpo: { ok: true, caminho: relativoDe(raiz, abs), mtime: fs.statSync(abs).mtimeMs } };
-}
-
 // ── prévia ───────────────────────────────────────────────────────────────
 
 const TIPOS = {
@@ -193,7 +172,7 @@ function servirPrevia(raiz, rel, res) {
         'Content-Type': TIPOS[path.extname(alvo).toLowerCase()] || 'application/octet-stream',
         'Cache-Control': 'no-store',
         // O mesmo sandbox do iframe, dito pelo servidor: vale até se alguém
-        // abrir o endereço da prévia fora da IDE.
+        // abrir o endereço da prévia fora da janela.
         'Content-Security-Policy': 'sandbox allow-scripts allow-forms allow-modals allow-popups allow-pointer-lock',
     });
     fs.createReadStream(alvo).pipe(res);
@@ -237,7 +216,7 @@ function vigiar(raiz, aoMudar, espera = 150) {
 // ── as rotas ─────────────────────────────────────────────────────────────
 
 /**
- * Monta a IDE num servidor do app.js.
+ * Monta o painel num servidor do app.js.
  *
  * @param {object} op
  * @param {()=>string} op.pasta   a pasta do projeto AGORA (o /dir muda ela)
@@ -247,9 +226,6 @@ function vigiar(raiz, aoMudar, espera = 150) {
 function montar(op) {
     let pastaVigiada = null;
     let pararVigia = () => {};
-    // O que a própria IDE acabou de salvar, para a página não pintar como
-    // "o agente mexeu" a mudança que a pessoa fez.
-    const salvosAgora = new Map();
 
     function conferirPasta() {
         const atual = op.pasta && op.pasta();
@@ -257,19 +233,14 @@ function montar(op) {
         pararVigia();
         pastaVigiada = atual;
         if (!fs.existsSync(atual)) { pararVigia = () => {}; return atual; }
-        pararVigia = vigiar(atual, (mudados) => {
-            const agora = Date.now();
-            const deVoce = mudados.filter((m) => (salvosAgora.get(m) || 0) > agora - 1500);
-            op.emitir('arquivos', { pasta: atual, mudados, deVoce });
-        });
+        pararVigia = vigiar(atual, (mudados) => op.emitir('arquivos', { pasta: atual, mudados }));
         op.emitir('arquivos', { pasta: atual, mudados: [], trocou: true });
         return atual;
     }
-    // O /dir troca a pasta pelo terminal, sem passar por aqui: sem esta volta
-    // a IDE continuaria vigiando o projeto anterior.
-    /* E só depois que a IDE foi aberta de verdade: quem abriu só o chat do
-       /rc não precisa de ninguém vigiando o ~/primocode inteiro — no Linux
-       o fs.watch recursivo custa um aviso do sistema por pasta. */
+    /* O /dir e os projetos da barra lateral trocam a pasta sem passar por
+       aqui: sem esta ronda o painel vigiaria o projeto anterior. E só depois
+       que o painel foi aberto de verdade — no Linux o fs.watch recursivo custa
+       um aviso do sistema por pasta, e quem só conversa não precisa disso. */
     let usada = false;
     const ronda = setInterval(() => { if (usada) conferirPasta(); }, 2000);
     if (ronda.unref) ronda.unref();
@@ -279,48 +250,31 @@ function montar(op) {
         res.end(JSON.stringify(corpo));
     }
 
-    function lerCorpo(req) {
-        return new Promise((ok) => {
-            let corpo = '';
-            let grande = false;
-            req.on('data', (c) => { corpo += c; if (corpo.length > MAX_EDITOR * 2) { grande = true; req.destroy(); } });
-            req.on('end', () => { try { ok(grande ? null : JSON.parse(corpo)); } catch { ok(null); } });
-        });
-    }
-
-    /* Devolve true se a rota era da IDE. A chave já foi conferida pelo
-       app.js antes de chegar aqui — só as rotas com /api/ passam por ela, e
-       por isso a prévia também mora debaixo de /api/. */
+    /* Devolve true se a rota era do painel. A chave já foi conferida pelo
+       app.js antes de chegar aqui — por isso a prévia também mora em /api/. */
     async function atender(req, res, url) {
         const rota = url.pathname;
-        if (!rota.startsWith('/api/ide/')) return false;
+        const ehArquivos = rota.startsWith('/api/arquivos/');
+        const m = rota.match(/^\/api\/previa\/[0-9a-f]+\/?(.*)$/);
+        if (!ehArquivos && !m) return false;
         usada = true;
         const raiz = conferirPasta();
         if (!raiz || !fs.existsSync(raiz)) { json(res, 404, { ok: false, error: 'sem pasta de projeto' }); return true; }
 
-        if (rota === '/api/ide/arvore') {
+        if (rota === '/api/arquivos/arvore') {
             const a = arvore(raiz);
             json(res, 200, { ok: true, pasta: raiz, nome: path.basename(raiz), itens: a.itens,
                 cortada: a.cortada, entrada: entradaDaPrevia(raiz) });
             return true;
         }
-        if (rota === '/api/ide/arquivo') {
+        if (rota === '/api/arquivos/ler') {
             const r = ler(raiz, url.searchParams.get('p') || '');
             json(res, r.status, r.corpo);
             return true;
         }
-        if (rota === '/api/ide/salvar' && req.method === 'POST') {
-            const dados = await lerCorpo(req);
-            if (!dados) { json(res, 400, { ok: false, error: 'pedido ilegível ou maior que 1 MB' }); return true; }
-            const r = salvar(raiz, dados);
-            if (r.corpo.ok) salvosAgora.set(r.corpo.caminho, Date.now());
-            json(res, r.status, r.corpo);
-            return true;
-        }
-        /* /api/ide/previa/<chave>/<caminho>: a chave vai no CAMINHO, não na
+        /* /api/previa/<chave>/<caminho>: a chave vai no CAMINHO, não na
            query, porque a página da prévia pede style.css e script.js por
            endereço relativo — e o relativo herda o caminho, não a query. */
-        const m = rota.match(/^\/api\/ide\/previa\/[0-9a-f]+\/?(.*)$/);
         if (m) { servirPrevia(raiz, m[1], res); return true; }
 
         json(res, 404, { ok: false, error: 'rota desconhecida' });
@@ -334,4 +288,4 @@ function montar(op) {
     };
 }
 
-module.exports = { montar, dentro, arvore, ler, salvar, vigiar, ehBinario, entradaDaPrevia, MAX_EDITOR };
+module.exports = { montar, dentro, arvore, ler, vigiar, ehBinario, entradaDaPrevia, MAX_LEITURA };

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.8",
   "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/app-janela.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"