primocode 10.17.1 → 10.19.0

package/lib/plano-previo.js

@@ -0,0 +1,53 @@
+/**
+ * plano-previo.js — o /plan: o agente mostra os passos e só começa quando a pessoa deixa.
+ *
+ *   pedidoDoPlano(pedido)            → o pedido da 1ª fase (roda no modo plano: só lê)       (puro)
+ *   extrairPassos(texto)             → ['passo', …] (3 a 5, tirados da lista numerada)        (puro)
+ *   resposta(texto, passos)          → { acao: 'comecar' | 'cancelar' | 'editar' | 'invalida', n? }   (puro)
+ *   comoPassos(pedido, passos)       → [{ titulo, pedido }] no formato do enviarPedido        (puro)
+ *
+ * Nada de planejador novo: a 1ª fase usa o modo "plano" de lib/perigo.js (recusa escrita), e a 2ª entrega os passos
+ * aprovados ao laço de passos que o enviarPedido já tem (checkpoint do pedido inteiro, fatos passados de um passo
+ * pro outro, retomada). Quem não programa não precisa saber disso: vê 3 a 5 frases e aperta Enter.
+ */
+
+'use strict';
+
+const MAX = 5;
+
+function pedidoDoPlano(pedido) {
+    return `Ainda NÃO faça nada: só planeje. Pode ler arquivos do projeto para entender, mas não mude nada.\n\n`
+        + `O pedido é: ${String(pedido || '').trim()}\n\n`
+        + `Responda SÓ com uma lista numerada de 3 a ${MAX} passos, uma frase curta por passo, em linguagem simples, `
+        + `sem jargão e sem código. Cada passo diz o que vai ficar diferente para quem usa. Sem introdução e sem despedida.`;
+}
+
+function extrairPassos(texto) {
+    const linhas = String(texto || '').split('\n');
+    const passos = [];
+    for (const l of linhas) {
+        const m = l.match(/^\s*(?:\d+[.)]|[-*•])\s+(.+?)\s*$/);
+        if (m) passos.push(m[1].replace(/\*\*/g, '').trim());
+    }
+    return passos.filter(Boolean).slice(0, MAX);
+}
+
+function resposta(texto, passos) {
+    const t = String(texto || '').trim().toLowerCase();
+    if (!t || /^(s|sim|y|yes|ok|vai|bora|começa|comeca)$/.test(t)) return { acao: 'comecar' };
+    if (/^(n|nao|não|no|cancela|cancelar|para|parar)$/.test(t)) return { acao: 'cancelar' };
+    const n = /^\d+$/.test(t) ? Number(t) : 0;
+    if (n >= 1 && n <= passos.length) return { acao: 'editar', n };
+    return { acao: 'invalida' };
+}
+
+function comoPassos(pedido, passos) {
+    const lista = passos.map((p, i) => `${i + 1}. ${p}`).join('\n');
+    return passos.map((p, i) => ({
+        titulo: `passo ${i + 1} de ${passos.length}: ${p}`.slice(0, 90),
+        pedido: `${String(pedido).trim()}\n\nO PLANO que a pessoa aprovou:\n${lista}\n\n`
+            + `Faça AGORA só o passo ${i + 1} (${p}). Não faça os outros ainda; eles vêm nos próximos passos.`,
+    }));
+}
+
+module.exports = { MAX, pedidoDoPlano, extrairPassos, resposta, comoPassos };

package/lib/planos.js

@@ -93,7 +93,7 @@ function desenhar({ planos, gratis, ok }, { cores: c, atual = null, site }) {
     } else {
         linhas.push(c.dim('  (sem resposta do servidor: valores de referência, sem link de compra)'), '');
     }
-    linhas.push(c.dim('  Também em ') + c.brand(`${site}/planos`) + c.dim(' · já assinou? ') + c.brand('/account') + c.dim(' atualiza.'));
+    linhas.push(c.dim('  Também em ') + c.brand(`${site}/account plans`) + c.dim(' · já assinou? ') + c.brand('/account') + c.dim(' atualiza.'));
     linhas.push('');
     return linhas;
 }

package/lib/porta.js

@@ -0,0 +1,147 @@
+/**
+ * porta.js — o /porta: "o app não abre" por causa da porta, dito em português.
+ *
+ *   declaradas(projectDir)          → [{ porta, de }]           (o que o projeto diz que usa; só lê, sem modelo)
+ *   olhar(portas, { tempo })        → Promise<[{ porta, titulo }]>  (as que respondem em localhost, e o <title>)
+ *   diagnostico(projectDir)         → Promise<{ declaradas, abertas, linhas, url }>
+ *   frase({ declaradas, abertas, rodar }) → { linhas, url }       (puro)
+ *
+ * Fórum do Replit, abril de 2026: o preview não carrega porque o servidor está numa porta e a configuração aponta outra
+ * (replit.discourse.group/t/8734 e /9515). O iniciante não sabe o que é porta: ele só vê "não abre". Aqui a gente lê o
+ * que o projeto declara (package.json, vite.config, PORT= do .env — só essa linha, nada mais sai do .env), bate em
+ * 127.0.0.1 e ::1 com um connect curto e diz qual endereço abrir. O <title> da página que responde mostra se é o SEU app
+ * ou outro programa que pegou a porta.
+ *
+ * O /open (lib/comandos-extra.js, acharAlvoAbrir) só abre a primeira porta viva e, sem nenhuma, diz "não achei". O /porta
+ * é o porquê: ele usa as mesmas portas do /open e mais as escritas no vite.config, no .env e no server.js.
+ */
+
+'use strict';
+
+const fs = require('fs');
+const net = require('net');
+const http = require('http');
+const path = require('path');
+
+// a porta que cada ferramenta usa quando ninguém diz nada
+const PADRAO = [[/\bvite\b/, 5173, 'o Vite'], [/\bnext\b/, 3000, 'o Next'], [/react-scripts/, 3000, 'o React'], [/\bastro\b/, 4321, 'o Astro'],
+    [/\bng\s+serve\b/, 4200, 'o Angular'], [/\bflask\b/, 5000, 'o Flask'], [/http\.server/, 8000, 'o servidor do Python'], [/\bserve\b/, 3000, 'o serve']];
+const COMUNS = [3000, 5173, 8080, 8000, 5000, 4321, 4200, 3001, 5174];
+const ler = (f) => { try { return fs.readFileSync(f, 'utf8'); } catch { return ''; } };
+
+function declaradas(projectDir) {
+    const out = [];
+    const poe = (porta, de) => { const n = Number(porta); if (n > 0 && n < 65536 && !out.some((d) => d.porta === n)) out.push({ porta: n, de }); };
+    let pkg = null;
+    try { pkg = JSON.parse(ler(path.join(projectDir, 'package.json'))); } catch { /* sem package.json */ }
+    const scripts = (pkg && pkg.scripts) || {};
+    for (const nome of ['dev', 'start', 'serve', 'preview']) {
+        const s = scripts[nome];
+        if (!s) continue;
+        const m = s.match(/(?:--port[= ]|-p\s+|PORT=)(\d{2,5})/);
+        if (m) poe(m[1], `o "npm run ${nome}"`);
+    }
+    for (const f of ['vite.config.js', 'vite.config.ts', 'vite.config.mjs']) {
+        const m = ler(path.join(projectDir, f)).match(/\bport\s*:\s*(\d{2,5})/);
+        if (m) poe(m[1], f);
+    }
+    const env = ler(path.join(projectDir, '.env')).match(/^\s*PORT\s*=\s*["']?(\d{2,5})/m);   // só a linha da porta
+    if (env) poe(env[1], 'o PORT do .env');
+    for (const f of ['server.js', 'app.js', 'index.js', 'main.py', 'app.py']) {
+        const m = ler(path.join(projectDir, f)).match(/\b(?:listen\(\s*|port\s*=\s*|PORT\s*\|\|\s*)(\d{2,5})/);
+        if (m) poe(m[1], f);
+    }
+    for (const nome of ['dev', 'start']) {
+        const s = scripts[nome];
+        if (!s) continue;
+        const p = PADRAO.find(([re]) => re.test(s));
+        if (p) poe(p[1], p[2]);   // sem porta escrita: a de sempre da ferramenta
+    }
+    // e as que o /open já procura (lib/comandos-extra.js): o /porta nunca olha menos que ele
+    for (const n of require('./comandos-extra.js').portasDoProjeto(projectDir)) poe(n, 'o padrão das ferramentas do projeto');
+    return out;
+}
+
+function responde(porta, host, tempo) {
+    return new Promise((resolve) => {
+        const s = net.connect({ port: porta, host });
+        const fim = (ok) => { s.destroy(); resolve(ok); };
+        s.setTimeout(tempo, () => fim(false));
+        s.once('connect', () => fim(true));
+        s.once('error', () => fim(false));
+    });
+}
+
+// quem responde e não é app de ninguém: o cabeçalho Server entrega
+const PROGRAMAS = [[/AirTunes/i, 'o AirPlay do Mac']];
+
+function pagina(porta, tempo) {
+    return new Promise((resolve) => {
+        const req = http.get({ host: 'localhost', port: porta, path: '/', timeout: tempo }, (res) => {
+            const prog = PROGRAMAS.find(([re]) => re.test(String(res.headers.server || '')));
+            let corpo = '';
+            res.setEncoding('utf8');
+            res.on('data', (d) => { corpo += d; if (corpo.length > 64 * 1024) res.destroy(); });
+            res.on('close', () => resolve({ titulo: ((corpo.match(/<title[^>]*>([^<]{1,80})<\/title>/i) || [])[1] || '').trim() || null, programa: prog ? prog[1] : null }));
+        });
+        req.on('timeout', () => { req.destroy(); resolve({ titulo: null, programa: null }); });
+        req.on('error', () => resolve({ titulo: null, programa: null }));
+    });
+}
+
+async function olhar(portas, { tempo = 300 } = {}) {
+    const lista = [...new Set(portas)];
+    // o Node 18+ e o Vite às vezes escutam só no ::1 (o "localhost" do IPv6): olha os dois
+    const vivas = await Promise.all(lista.map(async (p) => (await responde(p, '127.0.0.1', tempo)) || (await responde(p, '::1', tempo)) ? p : null));
+    return Promise.all(vivas.filter(Boolean).map(async (p) => ({ porta: p, ...(await pagina(p, tempo * 3)) })));
+}
+
+function frase({ declaradas: dec, abertas, rodar }) {
+    const url = (p) => `http://localhost:${p}`;
+    const nome = (a) => (a.titulo ? ` ("${a.titulo}")` : '');
+    const maiuscula = (s) => s[0].toUpperCase() + s.slice(1);
+    const linhas = [];
+    const esperada = dec[0];
+    const doMac = abertas.filter((a) => a.programa);
+    const apps = abertas.filter((a) => !a.programa);
+    const ocupada = esperada && doMac.find((a) => a.porta === esperada.porta);
+    if (ocupada) {
+        // o caso do Flask no Mac: a 5000 é do AirPlay desde o Monterey, e o app "não abre" com um 403 vazio
+        linhas.push(`A ${ocupada.porta}, que ${esperada.de} diz, é ${ocupada.programa}, não o seu app.`,
+            `Rode o app em outra porta (por exemplo a ${ocupada.porta + 1}), ou desligue em Ajustes do Sistema › Geral › AirDrop e Handoff › Receptor AirPlay.`);
+        return { linhas, url: null };
+    }
+    const viva = esperada && apps.find((a) => a.porta === esperada.porta);
+    if (viva) {
+        linhas.push(`Está rodando na ${viva.porta}${nome(viva)}, a porta que ${esperada.de} diz.`, `Abra: ${url(viva.porta)}`);
+        return { linhas, url: url(viva.porta) };
+    }
+    if (esperada && apps.length) {
+        const outra = apps[0];
+        linhas.push(`${maiuscula(esperada.de)} diz que o app usa a ${esperada.porta}, mas a ${esperada.porta} está vazia.`,
+            `A ${outra.porta} está respondendo${nome(outra)}. Se for o seu app, abra: ${url(outra.porta)}`,
+            'Se não for, outro programa está nessa porta: feche ele, ou rode o seu app de novo.');
+        return { linhas, url: url(outra.porta) };
+    }
+    if (apps.length) {
+        linhas.push('O projeto não diz qual porta usa. Estas estão respondendo agora:');
+        for (const a of apps.slice(0, 4)) linhas.push(`  ${url(a.porta)}${nome(a)}`);
+        return { linhas, url: url(apps[0].porta) };
+    }
+    linhas.push(esperada ? `Nada está rodando na ${esperada.porta} (a porta que ${esperada.de} diz), nem nas portas comuns.` : 'Nada está rodando nas portas comuns.');
+    if (doMac.length) linhas.push(`(A ${doMac.map((a) => a.porta).join(' e a ')} responde, mas é ${doMac[0].programa}: não é app seu.)`);
+    linhas.push(rodar ? `Abra o app primeiro: ${rodar}, e deixe aquela janela aberta. Depois, /port de novo.` : 'Este projeto pode não ter servidor: se é uma página, /open index.html abre direto.');
+    return { linhas, url: null };
+}
+
+async function diagnostico(projectDir, { tempo } = {}) {
+    const dec = declaradas(projectDir);
+    const abertas = await olhar([...dec.map((d) => d.porta), ...COMUNS], { tempo });
+    const passo = require('./como-rodar.js').passos(projectDir).find((p) => p.comando && /run dev|start|python3/.test(p.comando));
+    return { declaradas: dec, abertas, ...frase({ declaradas: dec, abertas, rodar: passo && passo.comando }) };
+}
+
+// o pedido que talvez seja de porta: só SUGERE ao modelo rodar `primocode porta` (lib/act.js); quem decide é ele
+const PEDE_PORTA = /n[ãa]o (abre|carrega|aparece|funciona)|tela (branca|em branco)|localhost|\bporta\b|servidor/i;
+
+module.exports = { declaradas, olhar, frase, diagnostico, COMUNS, PEDE_PORTA };

package/lib/publicar.js

@@ -0,0 +1,112 @@
+/**
+ * publicar.js — o /ship de verdade: coloca o projeto no ar e entrega o link.
+ *
+ *   detectar(dir)                 → { tipo: 'estatico'|'next'|'node'|'outro', pasta, quem }
+ *   publicar(dir, deps)           → { ok, url } | { ok:false, erro } | { recusou:true } | { guiado:true }
+ *   arquivosDoEnvio(dir)          → { total, bytes }   (o que subiria; sem .env, sem node_modules)
+ *
+ * Vale para site estático, Next e app Node simples. Escolhe UM host grátis: a Vercel, pelo `vercel` (ou `npx vercel`
+ * quando o npx existe). Antes de subir qualquer coisa pergunta (`confirmar`) e protege chave: `.env` entra no
+ * .vercelignore. O que só a pessoa faz (entrar na conta) vira UMA linha. Projeto de outro tipo (Python, etc.) devolve
+ * `guiado` e o bin cai no texto antigo (comandos/ship.md), que guia passo a passo.
+ * Os testes trocam `run` e `confirmar`: nada de rede.
+ */
+
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const { spawnSync } = require('child_process');
+const protecao = require('./protecao.js');
+
+const SERVIDORES = /^(express|fastify|koa|hono|@hono\/node-server|restify|hapi|@hapi\/hapi)$/;
+const PULAR = new Set(['node_modules', '.git', '.vercel', '.next', '.primocode']);
+
+function lerPkg(dir) { try { return JSON.parse(fs.readFileSync(path.join(dir, 'package.json'), 'utf8')); } catch { return null; } }
+
+function detectar(dir) {
+    const pkg = lerPkg(dir);
+    const deps = pkg ? { ...pkg.dependencies, ...pkg.devDependencies } : {};
+    if (deps.next) return { tipo: 'next', pasta: '.', quem: 'um site feito com Next' };
+    if (Object.keys(deps).some((d) => SERVIDORES.test(d)) && pkg.scripts && pkg.scripts.start) return { tipo: 'node', pasta: '.', quem: 'um app Node com servidor' };
+    if (pkg && pkg.scripts && pkg.scripts.build && (deps.vite || deps['react-scripts'] || deps.astro)) {
+        return { tipo: 'estatico', pasta: '.', quem: 'um site que se monta com `npm run build`' };
+    }
+    if (fs.existsSync(path.join(dir, 'index.html'))) return { tipo: 'estatico', pasta: '.', quem: 'um site estático (HTML, CSS e JS)' };
+    return { tipo: 'outro', pasta: '.', quem: 'um projeto que não consigo publicar sozinho' };
+}
+
+/** Quantos arquivos e bytes subiriam (sem o que a lib/protecao.js chama de segredo). */
+function arquivosDoEnvio(dir) {
+    let total = 0, bytes = 0;
+    const andar = (d) => {
+        let itens = [];
+        try { itens = fs.readdirSync(d, { withFileTypes: true }); } catch { return; }
+        for (const it of itens) {
+            if (it.isDirectory()) { if (!PULAR.has(it.name)) andar(path.join(d, it.name)); continue; }
+            if (protecao.nomeDeSegredo(it.name)) continue;
+            total++;
+            try { bytes += fs.statSync(path.join(d, it.name)).size; } catch { /* sumiu no meio */ }
+        }
+    };
+    andar(dir);
+    return { total, bytes };
+}
+
+const tamanho = (b) => (b >= 1048576 ? `${(b / 1048576).toFixed(1)} MB` : `${Math.max(1, Math.round(b / 1024))} KB`);
+
+/** .env e companhia fora do envio. Devolve true se mexeu. */
+function protegerEnvio(dir) {
+    const temSegredo = fs.readdirSync(dir).some((n) => protecao.nomeDeSegredo(n));
+    if (!temSegredo) return false;
+    const f = path.join(dir, '.vercelignore');
+    const atual = fs.existsSync(f) ? fs.readFileSync(f, 'utf8') : '';
+    if (/^\.env/m.test(atual)) return false;
+    fs.writeFileSync(f, atual + (atual && !atual.endsWith('\n') ? '\n' : '') + '.env\n.env.*\n*.pem\n*.key\n');
+    return true;
+}
+
+function rodar(cmd, args, { cwd } = {}) {
+    const r = spawnSync(cmd, args, { cwd, encoding: 'utf8', timeout: 10 * 60 * 1000, stdio: ['ignore', 'pipe', 'pipe'] });
+    return { status: r.error ? 127 : r.status, stdout: r.stdout || '', stderr: (r.stderr || '') + (r.error ? String(r.error.message) : '') };
+}
+
+/** Qual comando da Vercel existe aqui: `vercel`, ou `npx --yes vercel`. null = nenhum. */
+function ferramenta(run, dir) {
+    if (run('vercel', ['--version'], { cwd: dir }).status === 0) return ['vercel'];
+    if (run('npx', ['--version'], { cwd: dir }).status === 0) return ['npx', '--yes', 'vercel'];
+    return null;
+}
+
+async function publicar(dir, { run = rodar, confirmar = async () => false, log = () => {} } = {}) {
+    const d = detectar(dir);
+    if (d.tipo === 'outro') return { guiado: true };
+    log(`Isto parece ${d.quem}. Recomendo a Vercel: é grátis e dá um link público.`);
+    if (d.tipo === 'node') log('App com servidor roda na Vercel como função. Se o link abrir com erro, me diga que eu ajusto.');
+
+    const ferr = ferramenta(run, dir);
+    if (!ferr) return { ok: false, erro: 'Falta o Node com npm neste computador (https://nodejs.org). Depois rode /ship de novo.' };
+    const vercel = (...a) => run(ferr[0], [...ferr.slice(1), ...a], { cwd: dir });
+    if (vercel('whoami').status !== 0) {
+        return { ok: false, erro: `Falta entrar na Vercel: rode \`${ferr.join(' ')} login\` no terminal (a conta é grátis, com e-mail ou GitHub) e depois /ship de novo.` };
+    }
+
+    const { total, bytes } = arquivosDoEnvio(dir);
+    if (!total) return { ok: false, erro: 'A pasta está vazia: não tem nada para publicar.' };
+    if (protegerEnvio(dir)) log('Achei um arquivo de chave (.env) e pus no .vercelignore: ele não sobe.');
+    if (!(await confirmar(`Vou enviar ${total} ${total === 1 ? 'arquivo' : 'arquivos'} (${tamanho(bytes)}) para a Vercel. O endereço fica público, qualquer pessoa com o link abre. Posso enviar?`))) {
+        return { recusou: true };
+    }
+
+    log('Enviando… isso leva de 30 segundos a alguns minutos.');
+    const r = vercel('deploy', '--prod', '--yes');
+    // a Vercel escreve o endereço de produção na saída; o texto de progresso (Inspect, Production…) vai pro erro
+    const url = ((r.stdout || '').match(/https:\/\/[^\s]+/) || (r.stderr || '').match(/Production: (https:\/\/[^\s]+)/) || []).slice(-1)[0];
+    if (r.status !== 0 || !url) {
+        const motivo = (r.stderr || r.stdout || '').trim().split('\n').filter(Boolean).pop() || 'sem explicação';
+        return { ok: false, erro: `A Vercel não terminou o envio: ${motivo.slice(0, 160)}` };
+    }
+    return { ok: true, url };
+}
+
+module.exports = { detectar, publicar, arquivosDoEnvio, protegerEnvio, ferramenta, tamanho };

package/lib/registro.js

@@ -36,7 +36,7 @@ const { c, truncate, padRight } = require('./ui.js');
 
 /* Comando que é teste. Deliberadamente restrito: `npm run build` não é
    teste, e chamar de teste o que não é seria pior que não contar nada. */
-const EH_TESTE = /(^|\s|&&|\|\|)(npm\s+(run\s+)?tests?\b|npm\s+t\b|yarn\s+tests?\b|pnpm\s+tests?\b|pytest\b|python\s+-m\s+pytest\b|jest\b|vitest\b|mocha\b|go\s+test\b|cargo\s+test\b|mvn\s+test\b|rspec\b|phpunit\b)/i;
+const EH_TESTE = /(^|\s|&&|\|\|)(npm\s+(run\s+)?tests?\b|npm\s+t\b|yarn\s+tests?\b|pnpm\s+(run\s+)?tests?\b|bun\s+(run\s+)?test\b|node\s+--test\b|pytest\b|python\s+-m\s+pytest\b|jest\b|vitest\b|mocha\b|go\s+test\b|cargo\s+test\b|mvn\s+test\b|rspec\b|phpunit\b)/i;
 
 /* As contagens que os corredores de teste escrevem. Nenhuma é obrigatória:
    quando nada casa, vale o código de saída, que é o que não mente. */
@@ -72,8 +72,8 @@ function resumoDeTeste(saida) {
     const falhou = (texto.match(CONTAGENS[1]) || [])[1];
     if (!passou && !falhou) return '';
     const partes = [];
-    if (passou) partes.push(`${passou} passaram`);
-    if (falhou && Number(falhou) > 0) partes.push(`${falhou} falharam`);
+    if (passou) partes.push(`${passou} ${Number(passou) === 1 ? 'passou' : 'passaram'}`);
+    if (falhou && Number(falhou) > 0) partes.push(`${falhou} ${Number(falhou) === 1 ? 'falhou' : 'falharam'}`);
     return partes.join(', ');
 }
 
@@ -99,6 +99,10 @@ function anotar(reg, nome, args, r) {
         const alvo = String(a.path || a.command || a.target || a.url || a.consulta || '')
             .replace(/\s+/g, ' ').trim();
         if (reg.falhas.length < 20) reg.falhas.push({ acao: nome, alvo, motivo });
+        // teste vermelho também é TESTE: sem isto o registro dizia "nenhum teste" numa tarefa com npm test falhando
+        if (nome === 'run_shell' && EH_TESTE.test(String(a.command || '')) && reg.testes.length < 20) {
+            reg.testes.push({ comando: String(a.command).replace(/\s+/g, ' ').trim(), ok: false, code: r.code ?? 1, resumo: resumoDeTeste(r.stdout || r.saida || r.output || '') });
+        }
         // Uma tool que falhou não criou nem alterou nada. Continuar daqui
         // faria um write_file recusado aparecer na lista de criados.
         return reg;
@@ -128,6 +132,7 @@ function anotar(reg, nome, args, r) {
             return reg;
         }
 
+        case 'run_background':
         case 'run_in_new_terminal':
             if (reg.comandos.length < 40) {
                 reg.comandos.push({ comando: String(a.command || '').trim(), ok: true, code: 0, solto: true });
@@ -226,4 +231,33 @@ function resumo(reg, { colunas = 80 } = {}) {
     return out.join('\n');
 }
 
-module.exports = { novo, anotar, juntar, resumo, vazio, resumoDeTeste, EH_TESTE };
+/** O teste que o PrimoCode rodou sozinho no fim da tarefa (lib/act.js conferirTestes): entra na mesma seção de prova
+    do balanço, marcado, pra a pessoa ver que foi conferido mesmo quando o agente não rodou nada. */
+function anotarTeste(reg, { comando, ok, code, saida } = {}) {
+    if (!reg || !comando || reg.testes.length >= 20) return reg;
+    reg.testes.push({ comando: `${comando} · pelo PrimoCode`, ok: !!ok, code: code ?? (ok ? 0 : 1), resumo: resumoDeTeste(saida) });
+    return reg;
+}
+
+/**
+ * Uma linha do que o pedido FEZ, pra ficar na memória da conversa (o histórico guarda só o texto final).
+ * Sem isto, no pedido seguinte ("continua", "conserta o teste") o modelo não sabia quais arquivos mexeu
+ * nem que o teste tinha ficado vermelho, a não ser que a entrega dissesse. '' quando não fez nada.
+ */
+function paraMemoria(reg, teto = 500) {
+    if (!reg || vazio(reg)) return '';
+    const p = [];
+    const lista = (xs) => xs.slice(0, 8).join(', ') + (xs.length > 8 ? ` (+${xs.length - 8})` : '');
+    if (reg.criados && reg.criados.length) p.push(`criou ${lista(reg.criados)}`);
+    if (reg.alterados && reg.alterados.length) p.push(`alterou ${lista(reg.alterados)}`);
+    if (reg.testes && reg.testes.length) {
+        const u = reg.testes[reg.testes.length - 1];
+        p.push(`último teste: ${String(u.comando).replace(/ · pelo PrimoCode$/, '')} ${u.ok ? 'passou' : 'FALHOU'}${u.resumo ? ` (${u.resumo})` : ''}`);
+    }
+    if (reg.falhas && reg.falhas.length) p.push(`falhou: ${reg.falhas.slice(-2).map((f) => `${f.acao} ${f.alvo || ''}`.trim()).join('; ')}`);
+    if (!p.length) return '';
+    const t = `[o que este pedido fez no disco: ${p.join(' · ')}]`;
+    return t.length > teto ? t.slice(0, teto - 2) + '…]' : t;
+}
+
+module.exports = { novo, anotar, anotarTeste, juntar, resumo, vazio, resumoDeTeste, paraMemoria, EH_TESTE };

package/lib/regras.js

@@ -0,0 +1,88 @@
+/**
+ * regras.js — o /regra: "nunca mexa em X" que não some quando a conversa é resumida.
+ *
+ *   ler(projectDir)               → [texto]                         (as regras, na ordem)
+ *   adicionar(projectDir, texto)  → { arquivo, regras, ja_tinha }   (repetida não entra duas vezes)
+ *   tirar(projectDir, n)          → { tirada, regras } | null        (n começa em 1)
+ *   garantir(projectDir, lista)   → as regras de volta, se alguém reescreveu o PRIMO.md (o /init)
+ *   bloco(lista)                  → o markdown do bloco, entre marcas (puro)
+ *   sugerir(pedido, existentes)   → a regra que o pedido ditou ("nunca mexa no logo"), ou null (puro: só SUGERE o /regra)
+ *
+ * A regra dita no chat vira resumo quando a conversa enche, e o resumo pode perder ela (issue 67500 do Claude Code,
+ * 11/06/2026, lida num espelho [VERIFICAR]). O PRIMO.md entra inteiro em todo pedido (lib/mencoes.js), então a regra
+ * mora nele. E mora no TOPO: o mencoes.js corta o rabo de um PRIMO.md grande, e é a cabeça que sempre entra.
+ */
+
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+
+const INICIO = '<!-- primocode:regras -->', FIM = '<!-- /primocode:regras -->';
+const arquivoDe = (projectDir) => path.join(projectDir, 'PRIMO.md');
+const lerArquivo = (f) => { try { return fs.readFileSync(f, 'utf8'); } catch { return ''; } };
+const limpa = (t) => String(t || '').replace(/\s+/g, ' ').trim();
+
+function separar(texto) {
+    const i = texto.indexOf(INICIO), f = texto.indexOf(FIM);
+    if (i < 0 || f < i) return { antes: '', dentro: '', depois: texto };
+    return { antes: texto.slice(0, i), dentro: texto.slice(i + INICIO.length, f), depois: texto.slice(f + FIM.length) };
+}
+
+function ler(projectDir) {
+    return separar(lerArquivo(arquivoDe(projectDir))).dentro.split('\n')
+        .map((l) => (l.match(/^\s*\d+\.\s+(.+)$/) || [])[1]).filter(Boolean).map(limpa);
+}
+
+function bloco(lista) {
+    return [INICIO, '## Regras (siga sempre, mesmo depois de resumir a conversa)', '',
+        ...lista.map((r, i) => `${i + 1}. ${r}`), '', '_Escritas com /rule no PrimoCode._', FIM].join('\n');
+}
+
+function gravar(projectDir, lista) {
+    const arquivo = arquivoDe(projectDir);
+    const { antes, depois } = separar(lerArquivo(arquivo));
+    const resto = (antes + depois).replace(/^\s+/, '');
+    // sem regra nenhuma, o bloco sai inteiro: seção vazia não fica
+    const texto = lista.length ? bloco(lista) + '\n' + (resto ? '\n' + resto : '') : resto;
+    fs.writeFileSync(arquivo, texto);
+    return arquivo;
+}
+
+function adicionar(projectDir, texto) {
+    const nova = limpa(texto);
+    const lista = ler(projectDir);
+    if (!nova) return { arquivo: arquivoDe(projectDir), regras: lista, ja_tinha: false };
+    const ja = lista.some((r) => r.toLowerCase() === nova.toLowerCase());
+    if (!ja) lista.push(nova);
+    return { arquivo: gravar(projectDir, lista), regras: lista, ja_tinha: ja };
+}
+
+function tirar(projectDir, n) {
+    const lista = ler(projectDir);
+    const i = Number(n) - 1;
+    if (!Number.isInteger(i) || i < 0 || i >= lista.length) return null;
+    const [tirada] = lista.splice(i, 1);
+    gravar(projectDir, lista);
+    return { tirada, regras: lista };
+}
+
+function garantir(projectDir, lista) {
+    const agora = ler(projectDir);
+    const faltam = (lista || []).filter((r) => !agora.some((a) => a.toLowerCase() === r.toLowerCase()));
+    if (faltam.length) gravar(projectDir, [...agora, ...faltam]);
+    return faltam;
+}
+
+// "nunca mexa…", "não apague…", "sempre responda…": uma ordem que vale além deste pedido, até o fim da frase
+const ORDEM = /(?:^|[.!?;,]\s*|\s)((?:nunca|jamais)\s+(?:mais\s+)?\S+|n[ãa]o\s+(?:mexa|mexe|toque|toca|apague|apaga|altere|altera|mude|muda|use|usa|delete|remova|remove)\b|sempre\s+(?:use|usa|responda|responde|fale|fala|escreva|escreve|mantenha|mant[ée]m|deixe|deixa)\b)([^.!?;\n]{2,100})/i;
+
+function sugerir(pedido, existentes = []) {
+    const m = String(pedido || '').match(ORDEM);
+    if (!m) return null;
+    const regra = limpa(m[1] + m[2]).replace(/[,\s]+(?:e|mas|por favor|pfv|pf)$/i, '');
+    if (regra.split(' ').length < 3) return null;   // "nunca mais" sozinho não é regra
+    return existentes.some((r) => r.toLowerCase() === regra.toLowerCase()) ? null : regra;
+}
+
+module.exports = { ler, adicionar, tirar, garantir, bloco, sugerir, INICIO, FIM };

package/lib/saida.js

@@ -0,0 +1,83 @@
+/**
+ * saida.js — o que o modelo vê da saída de um comando.
+ *
+ * Antes o resultado inteiro virava JSON e era cortado nos primeiros 6 mil caracteres: num `npm test`
+ * longo o modelo via só os testes que passaram (o começo), e a falha (no meio), o placar (no fim) e o
+ * stderr (depois do stdout no JSON) sumiam. Consertava às cegas, ou dizia "pronto" com teste vermelho.
+ *
+ * Agora: começo + as linhas de falha do meio (com uma linha de contexto) + o fim, em cada campo,
+ * e o stderr tem a sua própria cota.
+ */
+'use strict';
+
+const FALHA = /\b(fail(ed|ure|ing)?|error|erro|exception|traceback|panic|assert(ion)?|expected|esperado|not ok|falha|falhou|cannot|undefined is not|is not a function|segmentation)\b|✗|✖|×|❌/i;
+
+/** Corta `texto` em até `teto` caracteres guardando o começo, as linhas de falha e o fim. */
+function cortar(texto, teto) {
+    const s = String(texto == null ? '' : texto);
+    if (s.length <= teto) return s;
+    const cabeca = Math.floor(teto * 0.2), cauda = Math.floor(teto * 0.45), meioTeto = teto - cabeca - cauda - 120;
+    const ini = s.slice(0, cabeca), fim = s.slice(-cauda);
+    const meio = s.slice(cabeca, s.length - cauda).split('\n');
+    const achadas = [];
+    let usado = 0;
+    for (let i = 0; i < meio.length && usado < meioTeto; i++) {
+        if (!FALHA.test(meio[i])) continue;
+        const bloco = meio.slice(Math.max(0, i - 1), i + 2).join('\n');
+        if (achadas.length && achadas[achadas.length - 1].fim >= i - 1) { achadas[achadas.length - 1].txt = meio.slice(achadas[achadas.length - 1].ini, i + 2).join('\n'); achadas[achadas.length - 1].fim = i + 1; }
+        else achadas.push({ ini: Math.max(0, i - 1), fim: i + 1, txt: bloco });
+        usado = achadas.reduce((t, a) => t + a.txt.length + 1, 0);
+    }
+    const cortados = s.length - ini.length - fim.length;
+    const corpo = achadas.length
+        ? `\n…(${cortados} caracteres cortados; as linhas de falha do meio:)\n${achadas.map((a) => a.txt.slice(0, meioTeto)).join('\n…\n')}\n…(o fim:)\n`
+        : `\n…(${cortados} caracteres cortados do meio)…\n`;
+    return ini + corpo + fim;
+}
+
+/** O resultado de um comando (stdout/stderr) cabendo em ~`teto` caracteres de JSON. */
+function resumirComando(result, teto = 5600) {
+    if (!result || typeof result !== 'object' || (typeof result.stdout !== 'string' && typeof result.stderr !== 'string')) return result;
+    const out = String(result.stdout || ''), err = String(result.stderr || '');
+    const resto = JSON.stringify({ ...result, stdout: '', stderr: '' }).length;
+    const livre = Math.max(1500, teto - resto - 200);
+    // o stderr curto vai inteiro; o longo divide a cota
+    const tetoErr = err.length <= livre * 0.3 ? err.length : Math.floor(livre * (out.length ? 0.35 : 1));
+    const tetoOut = Math.max(800, livre - Math.min(err.length, tetoErr));
+    return { ...result, stdout: cortar(out, tetoOut), stderr: cortar(err, tetoErr) };
+}
+
+/**
+ * Faz o resultado caber em `teto` caracteres de JSON SEM quebrar o JSON: encolhe o maior campo de cada vez
+ * (lista perde os itens do fim e ganha "omitidos"; texto vira começo + falhas + fim). Antes o corte era
+ * `json.slice(0, 6000)`: um grep com 100 resultados chegava como JSON partido no meio de uma linha, e o
+ * modelo via "total: 100" sem saber que só ~20 tinham chegado.
+ */
+function caber(result, teto = 5800) {
+    if (!result || typeof result !== 'object') return result;
+    let r = { ...result };
+    for (let volta = 0; volta < 12 && JSON.stringify(r).length > teto; volta++) {
+        let maior = null, tam = 0;
+        for (const [k, v] of Object.entries(r)) {
+            if (v == null || typeof v === 'number' || typeof v === 'boolean') continue;
+            const t = JSON.stringify(v).length;
+            if (t > tam) { tam = t; maior = k; }
+        }
+        if (!maior) break;
+        const excesso = JSON.stringify(r).length - teto;
+        const v = r[maior];
+        if (Array.isArray(v)) {
+            let n = v.length;
+            while (n > 1 && JSON.stringify(v.slice(0, n)).length > tam - excesso - 80) n = Math.floor(n * 0.8);
+            r = { ...r, [maior]: v.slice(0, n), omitidos: (r.omitidos || 0) + (v.length - n), dica: r.dica || `vieram ${n} de ${v.length} em "${maior}": refine o padrão (glob, pasta) pra ver o resto` };
+        } else if (typeof v === 'string') {
+            r = { ...r, [maior]: cortar(v, Math.max(400, v.length - excesso - 200)) };
+        } else {
+            const j = JSON.stringify(v);
+            r = { ...r, [maior]: cortar(j, Math.max(400, j.length - excesso - 200)) };
+        }
+    }
+    return r;
+}
+
+module.exports = { cortar, resumirComando, caber, FALHA };