primocode 9.8.0-beta.2 → 9.8.0-beta.21

package/lib/perigo.js

@@ -0,0 +1,256 @@
+/**
+ * perigo.js — o que não tem volta pede licença antes.
+ *
+ * Até aqui o PrimoCode rodava qualquer `run_shell` e escrevia qualquer arquivo
+ * sem perguntar. Para quase tudo isso é certo: quem não programa não sabe
+ * responder "autoriza `npm install`?", e uma pergunta que ninguém sabe
+ * responder vira um "sim" automático. O problema é o resto — o `rm -rf ~`, o
+ * `git push --force`, o `curl … | sh`. Esses não se desfazem.
+ *
+ * Por isso a régua é estreita DE PROPÓSITO: perigoso é o que apaga, reescreve
+ * história ou sai da pasta do projeto. `rm -rf node_modules` dentro do projeto
+ * NÃO é perigoso — se fosse, o Primo perguntaria dez vezes por dia, e na
+ * décima primeira a pessoa diria sim sem ler. Falso positivo aqui é tão ruim
+ * quanto falso negativo: ele treina a pessoa a não ler a pergunta.
+ *
+ * Os três modos (/permissoes):
+ *   auto      — o padrão. Roda tudo, mas SEMPRE pergunta antes do perigoso.
+ *   perguntar — pergunta antes de todo comando e de toda escrita de arquivo.
+ *   livre     — nunca pergunta. Nem o perigoso.
+ */
+
+'use strict';
+
+const os = require('os');
+const path = require('path');
+
+const MODOS = ['auto', 'perguntar', 'livre'];
+const COMANDOS = new Set(['run_shell', 'run_in_new_terminal']);
+const ESCRITAS = new Set(['write_file', 'edit_file', 'multi_edit']);
+
+function normalizarModo(m) {
+    const s = String(m || '').trim().toLowerCase();
+    const apelido = { ask: 'perguntar', suggest: 'perguntar', full: 'livre', 'full-auto': 'livre', yolo: 'livre' };
+    const n = apelido[s] || s;
+    return MODOS.includes(n) ? n : 'auto';
+}
+
+/* Quebra o comando em trechos (separados por ; && || | e quebra de linha) e
+   cada trecho em palavras — respeitando aspas. Sem respeitar aspas,
+   `git commit -m "tira o rm -rf /"` viraria um trecho `rm -rf /` e o Primo
+   pararia para perguntar sobre uma mensagem de commit. */
+function trechos(cmd) {
+    const saida = [];
+    let palavras = [], atual = '', aspa = null, temPalavra = false;
+    const fechaPalavra = () => { if (temPalavra) palavras.push(atual); atual = ''; temPalavra = false; };
+    const fechaTrecho = (sep) => { fechaPalavra(); if (palavras.length) saida.push({ palavras, sep }); palavras = []; };
+    const s = String(cmd || '');
+    for (let i = 0; i < s.length; i++) {
+        const ch = s[i];
+        if (aspa) {
+            if (ch === aspa) aspa = null;
+            else if (ch === '\\' && aspa === '"' && i + 1 < s.length) atual += s[++i];
+            else atual += ch;
+            continue;
+        }
+        if (ch === '"' || ch === "'") { aspa = ch; temPalavra = true; continue; }
+        if (ch === '\\' && i + 1 < s.length) { atual += s[++i]; temPalavra = true; continue; }
+        if (ch === ';' || ch === '\n') { fechaTrecho(';'); continue; }
+        if (ch === '&' && s[i + 1] === '&') { fechaTrecho(';'); i++; continue; }
+        if (ch === '|' && s[i + 1] === '|') { fechaTrecho(';'); i++; continue; }
+        if (ch === '|') { fechaTrecho('|'); continue; }
+        if (ch === '&') { fechaTrecho(';'); continue; }
+        if (/\s/.test(ch)) { fechaPalavra(); continue; }
+        atual += ch; temPalavra = true;
+    }
+    fechaTrecho(';');
+    return saida;
+}
+
+const TEMPORARIAS = [...new Set(['/tmp', '/private/tmp', os.tmpdir()])];
+
+function dentro(pai, filho) {
+    const r = path.relative(pai, filho);
+    return !!r && !r.startsWith('..') && !path.isAbsolute(r);
+}
+
+function expandir(alvo) {
+    const home = os.homedir();
+    return String(alvo).replace(/^~(?=\/|$)/, home).replace(/^\$\{?HOME\}?(?=\/|$)/, home);
+}
+
+/** O alvo cai FORA do projeto (ou é o projeto inteiro, ou um curinga que o esvazia)? */
+function alvoRuim(alvo, cwd, projeto, { recursivo, raizOk = false }) {
+    const a = String(alvo);
+    if (/^\.?\/?\*$|^\.\*$/.test(a)) return recursivo ? 'apaga tudo o que tem na pasta' : null;
+    const e = expandir(a);
+    // Variável que não é o HOME: não dá para saber aonde aponta, e "não sei"
+    // num rm é motivo de perguntar.
+    if (/\$/.test(e)) return 'apaga um caminho que depende de variável';
+    const alvoAbs = path.resolve(cwd, e.replace(/\/\*$/, ''));
+    const rel = path.relative(projeto, alvoAbs);
+    if (e === '/' || alvoAbs === path.parse(alvoAbs).root) return 'apaga a partir da raiz do computador';
+    if (alvoAbs === os.homedir()) return 'apaga a sua pasta pessoal inteira';
+    if (rel === '') return raizOk ? null : 'apaga a pasta do projeto inteira';
+    // A pasta temporária é descartável por definição: limpar lá não é perigo.
+    // (Mas nunca o que mora dentro da sua pasta pessoal.)
+    if (!dentro(os.homedir(), alvoAbs) && TEMPORARIAS.some((t) => dentro(t, alvoAbs))) return null;
+    if (rel.startsWith('..') || path.isAbsolute(rel)) return `apaga algo fora da pasta do projeto (${a})`;
+    return null;
+}
+
+// Palavras que vêm ANTES do comando de verdade e não mudam o que ele faz.
+const PREFIXOS = new Set(['env', 'nohup', 'time', 'command', 'exec', 'nice', 'xargs']);
+
+function analisarTrecho(palavras, estado) {
+    let p = palavras.slice();
+    // `VAR=x cmd`, `env -i cmd`, `xargs -0 rm`: pula até o comando.
+    while (p.length && (PREFIXOS.has(p[0]) || /^[A-Za-z_]\w*=/.test(p[0]) || (estado.pulandoFlags && /^-/.test(p[0])))) {
+        estado.pulandoFlags = PREFIXOS.has(p[0]) && p[0] !== 'command';
+        p.shift();
+    }
+    estado.pulandoFlags = false;
+    if (!p.length) return null;
+    const cmd = path.basename(p[0]);
+    const args = p.slice(1);
+    const flags = args.filter((x) => /^-/.test(x));
+    const alvos = args.filter((x) => !/^-/.test(x));
+    const tem = (re) => flags.some((f) => re.test(f));
+
+    if (cmd === 'sudo' || cmd === 'doas') return 'usa sudo: mexe como administrador no computador inteiro';
+    if (cmd === 'cd') { estado.cwd = path.resolve(estado.cwd, expandir(alvos[0] || os.homedir())); return null; }
+    if ((cmd === 'sh' || cmd === 'bash' || cmd === 'zsh') && args[0] === '-c' && args[1]) {
+        return analisarComando(args[1], estado.cwd, estado.projeto);
+    }
+    if (cmd === 'rm' || cmd === 'rmdir' || cmd === 'trash') {
+        const recursivo = cmd === 'rmdir' || tem(/^-[a-zA-Z]*[rR]|^--recursive$/);
+        for (const a of alvos) {
+            const r = alvoRuim(a, estado.cwd, estado.projeto, { recursivo });
+            if (r) return r;
+        }
+        return null;
+    }
+    if (cmd === 'find' && args.includes('-delete')) {
+        for (const a of alvos.slice(0, 1)) {
+            const r = alvoRuim(a, estado.cwd, estado.projeto, { recursivo: true, raizOk: true });
+            if (r) return r.replace(/^apaga/, 'apaga com find');
+        }
+        return null;
+    }
+    if (cmd === 'git') {
+        const sub = alvos[0];
+        if (sub === 'push' && (tem(/^--force$|^-[a-zA-Z]*f/) || alvos.some((a) => /^\+/.test(a)))) {
+            return 'git push --force: reescreve o histórico no GitHub, e o que estava lá some';
+        }
+        if (sub === 'reset' && flags.includes('--hard')) return 'git reset --hard: joga fora o que não foi salvo em commit';
+        if (sub === 'clean' && tem(/^-[a-zA-Z]*f/) && !tem(/^-[a-zA-Z]*n|^--dry-run$/)) {
+            return 'git clean: apaga arquivos que o git não guardou';
+        }
+        return null;
+    }
+    if (cmd === 'dd') return 'dd: escreve direto no disco';
+    if (/^mkfs(\.|$)/.test(cmd) || cmd === 'newfs' || cmd === 'fdisk') return 'formata um disco';
+    if (cmd === 'diskutil' && /^(erase|zero|secureErase|partitionDisk|reformat)/i.test(alvos[0] || '')) return 'diskutil: apaga um disco';
+    if ((cmd === 'chmod' || cmd === 'chown') && tem(/^-[a-zA-Z]*R/)) {
+        for (const a of alvos) {
+            const e = path.resolve(estado.cwd, expandir(a));
+            if (e === '/' || e === os.homedir()) return `${cmd} -R em ${a}: muda a permissão de tudo`;
+        }
+        return null;
+    }
+    if (cmd === 'kill' && args.includes('-1')) return 'kill -1: encerra todos os seus programas';
+    if (['shutdown', 'reboot', 'halt', 'poweroff'].includes(cmd)) return 'desliga ou reinicia o computador';
+    if (['npm', 'pnpm', 'yarn'].includes(cmd) && alvos[0] === 'publish' && !flags.includes('--dry-run')) return `${cmd} publish: publica o pacote para o mundo inteiro`;
+    return null;
+}
+
+function analisarComando(comando, cwd, projeto) {
+    const s = String(comando || '');
+    // Baixar e rodar na hora: o que roda é o que o site mandar naquele segundo.
+    if (/\b(curl|wget)\b[^;&]*\|\s*(sudo\s+)?(env\s+)?(ba|z|da|k)?sh\b/.test(s)) {
+        return 'baixa um script da internet e roda sem ler';
+    }
+    const estado = { cwd, projeto, pulandoFlags: false };
+    for (const t of trechos(s)) {
+        const r = analisarTrecho(t.palavras, estado);
+        if (r) return r;
+    }
+    return null;
+}
+
+/**
+ * Esta ação é perigosa?
+ * @returns {{perigoso: boolean, motivo: string}}
+ */
+function classificar(nome, args, { projectDir } = {}) {
+    const a = args || {};
+    const projeto = path.resolve(projectDir || process.cwd());
+    let motivo = null;
+    if (COMANDOS.has(nome)) {
+        const cwd = a.cwd ? path.resolve(projeto, expandir(a.cwd)) : projeto;
+        motivo = analisarComando(a.command, cwd, projeto);
+    } else if (ESCRITAS.has(nome) && a.path) {
+        const alvo = path.resolve(projeto, expandir(a.path));
+        const rel = path.relative(projeto, alvo);
+        if (rel.startsWith('..') || path.isAbsolute(rel) || /^[a-zA-Z]:[\\/]/.test(String(a.path))) {
+            motivo = `mexe num arquivo fora da pasta do projeto (${a.path})`;
+        }
+    }
+    return { perigoso: !!motivo, motivo: motivo || '' };
+}
+
+function novo() { return { liberados: new Set(), negados: new Set() }; }
+
+/* Uma pergunta por vez. Subagentes rodam em paralelo (Promise.all) e dois
+   pedidos ao mesmo tempo no mesmo terminal se atropelariam. */
+let fila = Promise.resolve();
+function emFila(fn) { const p = fila.then(fn, fn); fila = p.catch(() => {}); return p; }
+
+/**
+ * O portão. Devolve {ok:true} ou {ok:false, error, motivo}.
+ *
+ * `perguntar(frase, {tipo, motivo, primeira})` → 'agora' | 'sessao' | 'nao',
+ * o mesmo contrato do portão do desktop (lib/permissao.js).
+ */
+async function portao(estado, { modo, nome, args, projectDir, subagent = false, perguntar = null }) {
+    const m = normalizarModo(modo);
+    if (m === 'livre') return { ok: true };
+    const { perigoso, motivo: motivoPerigo } = classificar(nome, args, { projectDir });
+    const tipo = perigoso ? 'perigo' : (m === 'perguntar' && COMANDOS.has(nome)) ? 'comando'
+        : (m === 'perguntar' && ESCRITAS.has(nome)) ? 'arquivo' : null;
+    if (!tipo) return { ok: true };
+
+    const motivo = perigoso ? motivoPerigo
+        : tipo === 'comando' ? `rodar: ${String((args || {}).command || '').slice(0, 80)}`
+            : `escrever ${String((args || {}).path || 'um arquivo')}`;
+    const recusa = (texto) => ({ ok: false, motivo, error: texto });
+
+    // Escrever fora da pasta o tools.js já recusa sozinho: perguntar seria
+    // pedir um "sim" que não serve para nada.
+    if (perigoso && ESCRITAS.has(nome)) {
+        return recusa(`Recusado: ${motivo}. O PrimoCode só escreve dentro da pasta do projeto — use /dir se a pessoa quiser trabalhar em outra pasta.`);
+    }
+    if (subagent) {
+        return recusa(`Recusado: ${motivo}. Subagente não tem como pedir autorização — `
+            + 'deixe esse passo para o agente principal e diga no seu resumo o que falta fazer.');
+    }
+    const chave = `${nome}:${JSON.stringify(args || {})}`;
+    const negado = `A pessoa não autorizou: ${motivo}. Siga por outro caminho ou pergunte.`;
+    if (estado.negados.has(chave)) return recusa(negado);
+    // "A sessão inteira" libera o TIPO de pergunta: no perigoso, aquele motivo
+    // (um push --force autorizado não autoriza um rm -rf ~); no modo
+    // perguntar, os comandos ou as escritas comuns.
+    const liberacao = perigoso ? `perigo:${motivo}` : tipo;
+    if (estado.liberados.has(liberacao)) return { ok: true };
+    if (typeof perguntar !== 'function') {
+        return recusa(`Recusado: ${motivo}. Isso precisa de autorização e não há ninguém para autorizar neste modo.`);
+    }
+
+    const resposta = await emFila(() => perguntar(motivo, { tipo, motivo, primeira: false }));
+    if (resposta === 'sessao') { estado.liberados.add(liberacao); return { ok: true }; }
+    if (resposta === 'agora') return { ok: true };
+    estado.negados.add(chave);
+    return recusa(negado);
+}
+
+module.exports = { classificar, portao, novo, normalizarModo, trechos, MODOS };

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/skills.js

@@ -345,9 +345,14 @@ const semAcento = (v) => String(v || '').toLowerCase()
 function pontuar(skill, texto) {
     const t = semAcento(texto);
     let pontos = 0;
+    // "página, pagina" no gatilho é UMA palavra escrita de dois jeitos: sem
+    // acento as duas são iguais e contavam dois pontos, e a skill que listava
+    // as duas grafias ganhava das outras só por isso.
+    const vistas = new Set();
     for (const palavra of skill.quando) {
         const p = semAcento(palavra).trim();
-        if (!p) continue;
+        if (!p || vistas.has(p)) continue;
+        vistas.add(p);
         const escapado = p.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
         // A borda e escrita a mao em vez de `\b`: o gatilho pode comecar ou
         // terminar em simbolo ("e-mail"), e ali o `\b` nao vale.

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 };