primocode 10.19.0 → 11.0.0

package/lib/plugin/preview-cli.js

@@ -0,0 +1,38 @@
+/**
+ * preview-cli.js — `primocode preview [pasta] [--visual] [--tunel]`
+ * Sobe o app, imprime a URL local. --visual liga a edição por clique; --tunel pede link público (só com cloudflared).
+ */
+'use strict';
+
+const path = require('path');
+const P = require('./preview.js');
+
+async function main(args, deps = {}) {
+    const dir = path.resolve(args.find((a) => !a.startsWith('-')) || process.cwd());
+    const visual = args.includes('--visual'), tunel = args.includes('--tunel');
+    const { sh } = require('../cli/util.js');
+    const bin = path.join(__dirname, '..', '..', 'bin', 'primocode.js');
+    const V = visual ? require('./edicao-visual.js') : null;
+    const aoEditar = deps.aoEditar || (async (pedido) => { console.log('  ✎ edição recebida, mandando pro agente…'); sh(process.execPath, [bin, '-p', pedido], { cwd: dir }); console.log('  pronto, recarregue a página.'); });
+    const app = await (deps.subir || P.subir)(dir, visual ? { estatico: { transformar: V.injetar, extra: V.tratar(dir, aoEditar) } } : {});
+    if (!app.ok) { console.log('  ' + app.erro); return 1; }
+    let url = app.url, parar = app.parar;
+    if (visual && app.tipo === 'script') {
+        const porta = await P.portaLivre();
+        const px = await V.proxiar(app.url, porta, { dir, aoEditar });
+        url = `http://localhost:${porta}`; const antes = parar; parar = () => { px.close(); antes(); };
+    }
+    console.log(`  Preview: ${url}${visual ? '  (botão "Editar" no canto da página)' : ''}`);
+    let t = null;
+    if (tunel) {
+        t = await require('./tunel.js').abrir(url, deps.tunel || {});
+        console.log(t.ok ? `  Link público: ${t.url}  (quem tem o link vê o app enquanto isto estiver rodando)` : `  Sem link público: ${t.motivo}`);
+    }
+    if (deps.sair) { parar(); if (t && t.ok) t.parar(); return 0; }
+    console.log('  Ctrl+C encerra.');
+    await new Promise((r) => process.on('SIGINT', r));
+    parar(); if (t && t.ok) t.parar();
+    return 0;
+}
+
+module.exports = { main };

package/lib/plugin/preview.js

@@ -0,0 +1,89 @@
+/**
+ * preview.js — sobe o app web da pasta e devolve uma URL local.
+ *   - package.json com script "dev" (ou "start"): roda o script com PORT livre e espera responder
+ *   - senão, index.html: um servidor estático pequeno (node, sem dependência)
+ * Usado pelo autoteste (lib/plugin/autoteste.js), pelo `primocode preview` e pela edição visual.
+ * Não instala nada: sem node_modules num projeto que precisa, avisa em vez de rodar `npm install` sozinho.
+ */
+'use strict';
+
+const fs = require('fs');
+const http = require('http');
+const net = require('net');
+const path = require('path');
+const { spawn } = require('child_process');
+
+const TIPOS = { '.html': 'text/html; charset=utf-8', '.js': 'text/javascript', '.mjs': 'text/javascript', '.css': 'text/css', '.json': 'application/json', '.svg': 'image/svg+xml', '.png': 'image/png', '.jpg': 'image/jpeg', '.ico': 'image/x-icon', '.txt': 'text/plain' };
+
+function portaLivre() {
+    return new Promise((res, rej) => { const s = net.createServer(); s.listen(0, '127.0.0.1', () => { const p = s.address().port; s.close(() => res(p)); }); s.on('error', rej); });
+}
+
+/** Como subir esta pasta: { tipo: 'script'|'estatico', script? } ou { tipo: null, motivo }. */
+function detectar(dir) {
+    try {
+        const p = JSON.parse(fs.readFileSync(path.join(dir, 'package.json'), 'utf8'));
+        const s = p.scripts || {};
+        const nome = s.dev ? 'dev' : s.start ? 'start' : null;
+        if (nome) {
+            if (!fs.existsSync(path.join(dir, 'node_modules')) && (p.dependencies || p.devDependencies)) return { tipo: null, motivo: 'faltam as dependências: rode `npm install` (não instalo sozinho)' };
+            return { tipo: 'script', script: nome };
+        }
+    } catch { /* sem package.json */ }
+    if (fs.existsSync(path.join(dir, 'index.html'))) return { tipo: 'estatico' };
+    return { tipo: null, motivo: 'não achei script dev/start nem index.html' };
+}
+
+/** Servidor estático. `transformar(html, req)` deixa injetar algo nas páginas; `extra(req,res)` devolve true se tratou. */
+function servirEstatico(dir, porta, { transformar, extra } = {}) {
+    const raiz = path.resolve(dir);
+    const srv = http.createServer((req, res) => {
+        if (extra && extra(req, res)) return;
+        let rel = decodeURIComponent((req.url || '/').split('?')[0]);
+        if (rel.endsWith('/')) rel += 'index.html';
+        const p = path.resolve(raiz, '.' + rel);
+        if (p !== raiz && !p.startsWith(raiz + path.sep)) { res.writeHead(403); return res.end('fora da pasta'); }
+        fs.readFile(p, (err, buf) => {
+            if (err) { res.writeHead(404); return res.end('não achei'); }
+            const tipo = TIPOS[path.extname(p).toLowerCase()] || 'application/octet-stream';
+            if (tipo.startsWith('text/html') && transformar) buf = Buffer.from(transformar(buf.toString('utf8'), req));
+            res.writeHead(200, { 'content-type': tipo }); res.end(buf);
+        });
+    });
+    return new Promise((res) => srv.listen(porta, '127.0.0.1', () => res(srv)));
+}
+
+function responde(url, ms = 800) {
+    return new Promise((res) => { const r = http.get(url, (x) => { x.resume(); res(true); }); r.on('error', () => res(false)); r.setTimeout(ms, () => { r.destroy(); res(false); }); });
+}
+
+/**
+ * Sobe e espera responder. Devolve { ok, url, parar(), log() } ou { ok: false, erro }.
+ * `opcoes.estatico` = { transformar, extra } passa pro servidor estático.
+ */
+async function subir(dir, { espera = 30000, estatico } = {}) {
+    const d = detectar(dir);
+    if (!d.tipo) return { ok: false, erro: d.motivo };
+    if (d.tipo === 'estatico') {
+        const porta = await portaLivre();
+        const srv = await servirEstatico(dir, porta, estatico);
+        return { ok: true, url: `http://localhost:${porta}`, tipo: 'estatico', parar: () => srv.close(), log: () => '' };
+    }
+    const porta = await portaLivre();
+    let saida = '';
+    const filho = spawn('npm', ['run', d.script], { cwd: dir, env: { ...process.env, PORT: String(porta), BROWSER: 'none', FORCE_COLOR: '0' }, stdio: ['ignore', 'pipe', 'pipe'], detached: true });
+    filho.stdout.on('data', (b) => { saida += b; }); filho.stderr.on('data', (b) => { saida += b; });
+    let morreu = false; filho.on('exit', () => { morreu = true; });
+    const parar = () => { try { process.kill(-filho.pid); } catch { try { filho.kill(); } catch { /* */ } } };
+    const fim = Date.now() + espera;
+    while (Date.now() < fim && !morreu) {
+        const m = saida.match(/https?:\/\/(?:localhost|127\.0\.0\.1|\[::1\]|0\.0\.0\.0):(\d+)/);
+        const url = `http://localhost:${m ? m[1] : porta}`;
+        if (await responde(url)) return { ok: true, url, tipo: 'script', parar, log: () => saida };
+        await new Promise((r) => setTimeout(r, 300));
+    }
+    parar();
+    return { ok: false, erro: morreu ? 'o servidor do app fechou sozinho' : `o app não respondeu em ${Math.round(espera / 1000)}s`, log: saida.slice(-600) };
+}
+
+module.exports = { detectar, subir, servirEstatico, portaLivre, responde };

package/lib/plugin/tunel.js

@@ -0,0 +1,27 @@
+/**
+ * tunel.js — link público opcional pro preview. SÓ se o `cloudflared` já estiver instalado e a pessoa pediu (--tunel).
+ * Nunca instala nada: sem ele, diz como instalar e segue só com o link local.
+ */
+'use strict';
+
+const { spawn } = require('child_process');
+const { temComando } = require('../cli/util.js');
+
+const RE_URL = /https:\/\/[a-z0-9-]+\.trycloudflare\.com/;
+
+/** Devolve { ok, url, parar() } ou { ok: false, motivo }. `temFerramenta` e `iniciar` são injetáveis. */
+async function abrir(urlLocal, { temFerramenta = () => temComando('cloudflared'), iniciar = (u) => spawn('cloudflared', ['tunnel', '--url', u], { stdio: ['ignore', 'pipe', 'pipe'] }), espera = 20000 } = {}) {
+    if (!temFerramenta()) return { ok: false, motivo: 'o cloudflared não está instalado, então fico só com o link local (não instalo sozinho; no Mac: brew install cloudflared)' };
+    const filho = iniciar(urlLocal);
+    return new Promise((res) => {
+        let buf = '';
+        const parar = () => { try { filho.kill(); } catch { /* */ } };
+        const t = setTimeout(() => { parar(); res({ ok: false, motivo: 'o túnel não devolveu um link em ' + Math.round(espera / 1000) + 's' }); }, espera);
+        const le = (b) => { buf += b; const m = buf.match(RE_URL); if (m) { clearTimeout(t); res({ ok: true, url: m[0], parar }); } };
+        filho.stdout && filho.stdout.on('data', le); filho.stderr && filho.stderr.on('data', le);
+        filho.on('error', (e) => { clearTimeout(t); res({ ok: false, motivo: e.message }); });
+        filho.on('exit', () => { clearTimeout(t); res({ ok: false, motivo: 'o cloudflared fechou antes de dar o link' }); });
+    });
+}
+
+module.exports = { abrir, RE_URL };

package/lib/review.js

@@ -0,0 +1,134 @@
+/**
+ * review.js — /review em duas passadas (ideia: revisão do Claude Code; código nosso).
+ *
+ *   passada 1  lê o diff (com o número de linha de cada linha nova) e lista achados {arquivo, linha, gravidade, problema, porque}
+ *   passada 2  UM chamado por achado: recebe o achado + o trecho real do arquivo e diz se é verdade. Não confirmou → cai.
+ *   saída      só os confirmados, do mais grave ao menos, cada um com arquivo:linha.
+ *
+ * Quem fala com o modelo é `chamar(prompt) → Promise<texto>` (injetado: o teste roda sem rede).
+ */
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const { execFileSync } = require('child_process');
+
+const TETO_DIFF = 24000;
+const MAX_ACHADOS = 10;
+const GRAVIDADE = { alta: 0, media: 1, média: 1, baixa: 2 };
+
+function git(dir, args) {
+    try { return execFileSync('git', args, { cwd: dir, encoding: 'utf-8', maxBuffer: 8 * 1024 * 1024, stdio: ['ignore', 'pipe', 'ignore'] }); } catch { return ''; }
+}
+
+/** O que mudou: tudo que ainda não foi commitado (staged + não staged) contra o HEAD. */
+function coletarDiff(dir) {
+    let d = git(dir, ['diff', 'HEAD', '--no-color', '-U3']);
+    if (!d.trim()) d = git(dir, ['diff', '--no-color', '-U3']);
+    return d;
+}
+
+/** Põe `L<n>|` na frente de cada linha nova/contexto, pra o modelo citar a linha certa. Linhas removidas ficam com `-`. */
+function anotarDiff(diff) {
+    const out = [];
+    let n = 0;
+    for (const linha of String(diff).split('\n')) {
+        const h = /^@@ -\d+(?:,\d+)? \+(\d+)(?:,\d+)? @@/.exec(linha);
+        if (h) { n = Number(h[1]); out.push(linha); continue; }
+        if (/^(diff --git|index |--- |\+\+\+ |new file|deleted file)/.test(linha)) { out.push(linha); continue; }
+        if (linha.startsWith('-')) { out.push(`   |${linha}`); continue; }
+        if (linha.startsWith('+') || linha.startsWith(' ')) { out.push(`L${n}|${linha}`); n++; continue; }
+        out.push(linha);
+    }
+    return out.join('\n');
+}
+
+function extrairJson(texto) {
+    const t = String(texto || '');
+    const cerca = /```(?:json)?\s*([\s\S]*?)```/i.exec(t);
+    const candidatos = [cerca && cerca[1], t].filter(Boolean);
+    for (const c of candidatos) {
+        const ini = Math.min(...['[', '{'].map((k) => { const i = c.indexOf(k); return i < 0 ? Infinity : i; }));
+        if (!Number.isFinite(ini)) continue;
+        const fim = Math.max(c.lastIndexOf(']'), c.lastIndexOf('}'));
+        if (fim <= ini) continue;
+        try { return JSON.parse(c.slice(ini, fim + 1)); } catch { /* tenta o próximo */ }
+    }
+    return null;
+}
+
+function prompt1(diffAnotado, foco) {
+    return 'Você é um revisor de código rigoroso. Abaixo está um diff; cada linha nova começa com L<número>| (a linha no arquivo novo).\n'
+        + 'Ache SÓ problemas reais que o diff introduz: bug, erro de lógica, caso de borda que quebra, falha de segurança, perda de dado, '
+        + 'chamada com argumento errado. NÃO aponte estilo, nome, falta de comentário nem gosto.\n'
+        + (foco ? `Foco pedido: ${foco}\n` : '')
+        + `Devolva SÓ um JSON, uma lista (no máximo ${MAX_ACHADOS}, vazia [] se não há nada): `
+        + '[{"arquivo":"caminho","linha":12,"gravidade":"alta|media|baixa","problema":"uma frase","porque":"o que acontece com quem usa"}]\n\n'
+        + `DIFF:\n${diffAnotado}`;
+}
+
+function prompt2(a, trecho) {
+    return 'Você é o verificador. Outro revisor apontou o problema abaixo. Confira contra o código REAL e seja cético: '
+        + 'confirme só se der pra explicar o caminho exato em que o erro acontece. Se for suposição, se o código já trata o caso, ou se a linha não é isso, rejeite.\n'
+        + `ACHADO: ${a.arquivo}:${a.linha} [${a.gravidade}] ${a.problema} — ${a.porque}\n\n`
+        + `CÓDIGO (${a.arquivo}, linhas em volta de ${a.linha}):\n${trecho || '(arquivo não encontrado)'}\n\n`
+        + 'Devolva SÓ um JSON: {"confirmado":true|false,"motivo":"uma frase com a prova ou a razão de rejeitar"}';
+}
+
+function trechoDoArquivo(dir, arquivo, linha, raio = 12) {
+    try {
+        const p = path.resolve(dir, arquivo);
+        if (!p.startsWith(path.resolve(dir) + path.sep)) return '';
+        const ls = fs.readFileSync(p, 'utf-8').split('\n');
+        const de = Math.max(0, (Number(linha) || 1) - 1 - raio);
+        return ls.slice(de, de + 2 * raio + 1).map((l, i) => `${de + i + 1}| ${l}`).join('\n');
+    } catch { return ''; }
+}
+
+function normalizar(lista) {
+    if (!Array.isArray(lista)) return [];
+    return lista.filter((a) => a && a.arquivo && a.problema).slice(0, MAX_ACHADOS).map((a) => ({
+        arquivo: String(a.arquivo).replace(/^[ab]\//, ''), linha: Number(a.linha) || 1,
+        gravidade: GRAVIDADE[String(a.gravidade || '').toLowerCase()] !== undefined ? String(a.gravidade).toLowerCase().replace('é', 'e') : 'media',
+        problema: String(a.problema).slice(0, 300), porque: String(a.porque || '').slice(0, 300),
+    }));
+}
+
+async function emLotes(itens, n, fn) {
+    const out = new Array(itens.length);
+    for (let i = 0; i < itens.length; i += n) {
+        await Promise.all(itens.slice(i, i + n).map(async (it, j) => { out[i + j] = await fn(it); }));
+    }
+    return out;
+}
+
+/** @returns {Promise<{ok:boolean, vazio?:boolean, achados:Array, descartados:number, total:number, erro?:string}>} */
+async function revisar({ dir, foco = '', chamar, diff = null, concorrencia = 3 }) {
+    const bruto = diff != null ? diff : coletarDiff(dir);
+    if (!bruto.trim()) return { ok: true, vazio: true, achados: [], descartados: 0, total: 0 };
+    const recorte = bruto.length > TETO_DIFF ? bruto.slice(0, TETO_DIFF) : bruto;
+    const resp1 = await chamar(prompt1(anotarDiff(recorte), foco));
+    const lista = extrairJson(resp1);
+    if (!Array.isArray(lista)) return { ok: false, erro: 'a primeira passada não devolveu uma lista legível', achados: [], descartados: 0, total: 0 };
+    const candidatos = normalizar(lista);
+    const veredictos = await emLotes(candidatos, concorrencia, async (a) => {
+        try {
+            const v = extrairJson(await chamar(prompt2(a, trechoDoArquivo(dir, a.arquivo, a.linha))));
+            return v && v.confirmado === true ? { ...a, verificacao: String(v.motivo || '').slice(0, 300) } : null;
+        } catch { return null; }   // verificador que falha não confirma: na dúvida, cai
+    });
+    const achados = veredictos.filter(Boolean)
+        .sort((x, y) => GRAVIDADE[x.gravidade] - GRAVIDADE[y.gravidade] || x.arquivo.localeCompare(y.arquivo) || x.linha - y.linha);
+    return { ok: true, achados, descartados: candidatos.length - achados.length, total: candidatos.length, cortado: bruto.length > TETO_DIFF };
+}
+
+function formatar(r) {
+    if (!r.ok) return `Não consegui revisar: ${r.erro}.`;
+    if (r.vazio) return 'Nada mudou desde o último commit: não há o que revisar.';
+    if (!r.achados.length) return `Nenhum problema confirmado (${r.total} suspeita${r.total === 1 ? '' : 's'} da 1ª passada, todas derrubadas na verificação).`;
+    const l = r.achados.map((a, i) => `${i + 1}. [${a.gravidade}] ${a.arquivo}:${a.linha}  ${a.problema}\n   ${a.porque}${a.verificacao ? `\n   conferido: ${a.verificacao}` : ''}`);
+    l.push(`\n${r.achados.length} confirmado${r.achados.length === 1 ? '' : 's'} de ${r.total}; ${r.descartados} derrubado${r.descartados === 1 ? '' : 's'} na verificação.${r.cortado ? ' (diff grande: só o começo foi lido)' : ''}`);
+    return l.join('\n');
+}
+
+module.exports = { revisar, formatar, coletarDiff, anotarDiff, extrairJson, prompt1, prompt2, trechoDoArquivo };

package/lib/session/compactacao.js

@@ -0,0 +1,124 @@
+/**
+ * compactacao.js — resumo automático no MEIO da tarefa (ideia: session/compaction.ts do OpenCode, MIT).
+ *
+ * Quando a conversa do agente passa de ~80% da janela do modelo, as mensagens antigas viram UM resumo
+ * feito pelo próprio modelo (objetivo, decisões, arquivos mexidos, to-dos em aberto) e saem da conversa.
+ * As últimas mensagens ficam cruas, e as de sistema não se perdem.
+ *
+ * Mesmo caminho do /compact: `resumirComFatos` é o `resumir` que os dois usam (resumo do modelo +
+ * bloco de fatos tirado das próprias mensagens: arquivos escritos e to-dos abertos — isso não se confia ao modelo).
+ *
+ * O que já existia e continua: lib/memoria-conversa.js (resumo entre pedidos) e compactar() do act.js
+ * (encolhe resultado de ferramenta antigo, sem modelo). Isto é a camada de cima: quando só encolher não basta.
+ */
+'use strict';
+
+const LIMIAR = 0.8;
+const MANTER = 6;                 // mensagens finais que ficam cruas
+const JANELA_PADRAO = 32000;      // não sabemos o modelo: ser conservador é o lado seguro
+
+// [padrão no id do modelo, janela em tokens]. A primeira que casar vale.
+const JANELAS = [
+    [/gemini/i, 1000000], [/claude|anthropic/i, 200000], [/gpt-4\.1|gpt-5|o[134]-/i, 200000], [/gpt-4o|gpt-4/i, 128000],
+    [/llama-?3\.[1-3]|llama-?4/i, 128000], [/qwen|deepseek|kimi|mistral|gpt-oss/i, 128000],
+];
+
+function janelaDe(modelo) {
+    const env = Number(process.env.PRIMOCODE_JANELA);
+    if (env > 0) return env;
+    const id = String(modelo || '');
+    for (const [re, n] of JANELAS) if (re.test(id)) return n;
+    return JANELA_PADRAO;
+}
+
+function tokensDe(messages) {
+    let chars = 0;
+    for (const m of messages || []) { try { chars += (typeof m.content === 'string' ? m.content : JSON.stringify(m.content || '')).length + (m.tool_calls ? JSON.stringify(m.tool_calls).length : 0); } catch { /* */ } }
+    return Math.ceil(chars / 4);
+}
+
+function precisaCompactar(messages, { janela = JANELA_PADRAO, limiar = LIMIAR } = {}) {
+    return tokensDe(messages) >= janela * limiar;
+}
+
+/** Onde cortar: tudo antes de `corte` vira resumo. Nunca no meio de um assistant+tool (corta antes do assistant). */
+function acharCorte(messages, manter = MANTER) {
+    let corte = messages.length - manter;
+    while (corte > 0 && messages[corte] && messages[corte].role === 'tool') corte--;
+    return corte;
+}
+
+const ESCRITA = new Set(['write_file', 'edit_file', 'multi_edit']);
+
+function arquivosMexidos(mensagens) {
+    const set = new Set();
+    for (const m of mensagens || []) {
+        for (const tc of (m && m.tool_calls) || []) {
+            const nome = (tc.function && tc.function.name) || tc.name;
+            if (!ESCRITA.has(nome)) continue;
+            let a = (tc.function && tc.function.arguments) || tc.arguments;
+            if (typeof a === 'string') { try { a = JSON.parse(a); } catch { a = null; } }
+            if (a && a.path) set.add(String(a.path));
+        }
+    }
+    return [...set];
+}
+
+function todosAbertos(mensagens, todosAtuais) {
+    let lista = Array.isArray(todosAtuais) && todosAtuais.length ? todosAtuais : null;
+    if (!lista) {
+        for (const m of mensagens || []) for (const tc of (m && m.tool_calls) || []) {
+            const nome = (tc.function && tc.function.name) || tc.name;
+            if (nome !== 'write_todos') continue;
+            let a = (tc.function && tc.function.arguments) || tc.arguments;
+            if (typeof a === 'string') { try { a = JSON.parse(a); } catch { a = null; } }
+            if (a && Array.isArray(a.todos)) lista = a.todos;
+        }
+    }
+    return (lista || []).filter((t) => t && t.status !== 'completed' && t.content).map((t) => String(t.content).slice(0, 120));
+}
+
+/** O bloco que não depende do modelo lembrar. */
+function blocoDeFatos(mensagens, todosAtuais) {
+    const arq = arquivosMexidos(mensagens);
+    const abertos = todosAbertos(mensagens, todosAtuais);
+    const linhas = [];
+    if (arq.length) linhas.push(`Arquivos que você já mexeu (estão no disco; releia antes de editar): ${arq.slice(0, 30).join(', ')}`);
+    if (abertos.length) linhas.push(`To-dos em aberto: ${abertos.slice(0, 12).join(' | ')}`);
+    return linhas.join('\n');
+}
+
+/**
+ * O `resumir` que /compact e a compactação automática compartilham.
+ * `chamar({resumo, mensagens}) → Promise<string>` é quem fala com o servidor (api.requestResumo).
+ */
+async function resumirComFatos({ resumo, mensagens }, chamar, todosAtuais) {
+    const texto = String(await chamar({ resumo, mensagens }) || '').trim();
+    if (!texto) return '';
+    const fatos = blocoDeFatos(mensagens, todosAtuais);
+    return fatos && !texto.includes(fatos) ? `${texto}\n\n${fatos}` : texto;
+}
+
+/**
+ * Substitui, EM LUGAR, as mensagens antigas por um resumo. Devolve { ok, antes, depois, resumidas } (tokens).
+ * Se o resumo falhar ou não houver o que cortar, não mexe em nada (ok:false).
+ */
+async function compactarMensagens(messages, { resumir, todos, manter = MANTER } = {}) {
+    const antes = tokensDe(messages);
+    let inicio = 0;
+    while (inicio < messages.length && messages[inicio].role === 'system') inicio++;
+    const corte = acharCorte(messages, manter);
+    if (corte - inicio < 2) return { ok: false, antes, depois: antes, resumidas: 0, motivo: 'pouca coisa pra resumir' };
+    const velhas = messages.slice(inicio, corte);
+    const sistema = velhas.filter((m) => m.role === 'system');
+    const conversa = velhas.filter((m) => m.role !== 'system');
+    let texto = '';
+    try { texto = await resumir({ resumo: '', mensagens: conversa }, todos); } catch { texto = ''; }
+    if (!String(texto || '').trim()) return { ok: false, antes, depois: antes, resumidas: 0, motivo: 'o resumo falhou' };
+    const nota = { role: 'user', content: `[Resumo automático: a conversa antiga foi trocada por este resumo para caber na janela. Siga a tarefa de onde parou.]\n${texto}` };
+    messages.splice(inicio, corte - inicio, ...sistema, nota);
+    const depois = tokensDe(messages);
+    return { ok: depois < antes, antes, depois, resumidas: conversa.length };
+}
+
+module.exports = { janelaDe, tokensDe, precisaCompactar, acharCorte, arquivosMexidos, todosAbertos, blocoDeFatos, resumirComFatos, compactarMensagens, LIMIAR, MANTER };

package/lib/statusline.js

@@ -0,0 +1,52 @@
+/**
+ * statusline.js — as peças da linha de status do terminal: modelo, contexto usado, tokens de hoje, ramo.
+ * Puro (as cores entram por parâmetro) e barato: o que vem do disco (uso de hoje) fica em cache por 3 s,
+ * porque a barra se redesenha a cada tecla.
+ *
+ *   registrarModelo(id)   o act.js chama quando o servidor diz quem respondeu
+ *   modelo()              → nome curto do último modelo que respondeu, ou ''
+ *   tokensDeHoje()        → número (do arquivo do /usage: lib/limite.js)
+ *   partes({...})         → lista de textos já coloridos, na ordem da linha
+ */
+'use strict';
+
+let ultimo = '';
+let cache = { quando: 0, tokens: 0 };
+
+function registrarModelo(id) { ultimo = String(id || ''); }
+
+/** "anthropic/claude-sonnet-4:free" → "claude-sonnet-4"; "gemini:gemini-2.5-flash" → "gemini-2.5-flash". */
+function nomeCurto(id) {
+    return String(id || '').replace(/^[a-z0-9-]+:/i, '').replace(/^.*\//, '').replace(/:free$/i, '').slice(0, 28);
+}
+function modelo() { return nomeCurto(ultimo); }
+
+function tokensDeHoje(agora = Date.now(), ler = () => require('./limite.js').usoDeHoje().tokens) {
+    if (agora - cache.quando > 3000) {
+        try { cache = { quando: agora, tokens: Number(ler()) || 0 }; } catch { cache = { quando: agora, tokens: cache.tokens }; }
+    }
+    return cache.tokens;
+}
+
+function compacto(n) {
+    n = Number(n) || 0;
+    if (n >= 1e6) return `${(n / 1e6).toFixed(1).replace(/\.0$/, '')}M`;
+    if (n >= 1e3) return `${(n / 1e3).toFixed(n >= 1e4 ? 0 : 1).replace(/\.0$/, '')}k`;
+    return String(n);
+}
+
+/**
+ * @param {{modelo?:string, ctxPct?:number, tokensHoje?:number, c:object}} o  `c` = as cores do ui
+ * Sem dado, a peça some: linha de status cheia de "0" vira ruído.
+ */
+function partes({ modelo: m, ctxPct = 0, tokensHoje = 0, c }) {
+    const out = [];
+    if (m) out.push(c.muted(m));
+    if (ctxPct >= 5) out.push((ctxPct >= 100 ? c.err : ctxPct >= 70 ? c.warn : c.dim)(`${ctxPct}% ctx`));
+    if (tokensHoje > 0) out.push(c.dim(`${compacto(tokensHoje)} tok hoje`));
+    return out;
+}
+
+function _reset() { ultimo = ''; cache = { quando: 0, tokens: 0 }; }
+
+module.exports = { registrarModelo, modelo, nomeCurto, tokensDeHoje, partes, compacto, _reset };

package/lib/tool/diagnostico.js

@@ -0,0 +1,100 @@
+/**
+ * diagnostico.js — depois que edit_file/write_file/multi_edit mexe num arquivo, roda o verificador
+ * mais barato da linguagem e devolve os erros (com teto) pra irem no resultado da ferramenta.
+ * O modelo vê o erro na MESMA volta, em vez de descobrir só no fim. (Ideia: diagnósticos do OpenCode.)
+ *
+ *   .js .mjs .cjs → node --check (+ eslint se o projeto configurou e instalou)
+ *   .py → compile() do python3     .ts .tsx → tsc local, se há tsconfig.json
+ *   .json → JSON.parse             .sh → bash -n
+ * Sem verificador, ferramenta ausente ou timeout → null (nunca atrapalha a edição).
+ * PRIMOCODE_SEM_DIAGNOSTICO=1 desliga.
+ */
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const { spawnSync } = require('child_process');
+
+const TETO_CHARS = 1500;
+const TETO_LINHAS = 12;
+const PRAZO_MS = 8000;
+
+function rodar(cmd, args, cwd, prazo = PRAZO_MS) {
+    const r = spawnSync(cmd, args, { cwd, encoding: 'utf-8', timeout: prazo, maxBuffer: 2 * 1024 * 1024 });
+    if (r.error) return null; // ferramenta ausente ou estourou o prazo: sem diagnóstico
+    return { code: r.status, out: `${r.stdout || ''}\n${r.stderr || ''}`.trim() };
+}
+
+function achar(dir, nome, ate) {
+    for (let d = dir; ; d = path.dirname(d)) {
+        if (fs.existsSync(path.join(d, nome))) return d;
+        if (d === ate || d === path.dirname(d)) return null;
+    }
+}
+
+function cortar(texto, arquivo) {
+    const linhas = String(texto).split('\n').map((l) => l.trimEnd()).filter(Boolean);
+    let s = linhas.slice(0, TETO_LINHAS).join('\n');
+    if (s.length > TETO_CHARS) s = s.slice(0, TETO_CHARS) + '…';
+    if (linhas.length > TETO_LINHAS) s += `\n… e mais ${linhas.length - TETO_LINHAS} linhas`;
+    return s.split(arquivo).join(path.basename(arquivo));
+}
+
+function eslintConfigurado(raiz) {
+    if (!raiz) return false;
+    const tem = fs.readdirSync(raiz).some((f) => /^(\.eslintrc(\..+)?|eslint\.config\.(js|mjs|cjs|ts))$/.test(f));
+    return tem && fs.existsSync(path.join(raiz, 'node_modules', '.bin', 'eslint'));
+}
+
+/** @returns {{verificador:string, erros:string}|null}  null = sem verificador ou sem erro */
+function diagnosticar(arquivo, projectDir) {
+    try {
+        if (process.env.PRIMOCODE_SEM_DIAGNOSTICO === '1') return null;
+        if (!fs.existsSync(arquivo) || fs.statSync(arquivo).size > 2 * 1024 * 1024) return null;
+        const ext = path.extname(arquivo).toLowerCase();
+        const dir = path.dirname(arquivo);
+        let r = null; let nome = '';
+        if (['.js', '.mjs', '.cjs'].includes(ext)) {
+            nome = 'node --check'; r = rodar(process.execPath, ['--check', arquivo], dir);
+            if (r && r.code === 0) {
+                const raiz = achar(dir, 'package.json', projectDir);
+                if (eslintConfigurado(raiz)) {
+                    nome = 'eslint';
+                    r = rodar(path.join(raiz, 'node_modules', '.bin', 'eslint'), ['--no-warn-ignored', '-f', 'unix', arquivo], raiz, 15000);
+                }
+            }
+        } else if (ext === '.py') {
+            nome = 'python compile';
+            r = rodar('python3', ['-c', 'import sys;compile(open(sys.argv[1],encoding="utf-8").read(),sys.argv[1],"exec")', arquivo], dir);
+        } else if (ext === '.ts' || ext === '.tsx') {
+            const raiz = achar(dir, 'tsconfig.json', projectDir);
+            const tsc = raiz && path.join(raiz, 'node_modules', '.bin', 'tsc');
+            if (!tsc || !fs.existsSync(tsc)) return null;
+            nome = 'tsc';
+            r = rodar(tsc, ['--noEmit', '-p', raiz, '--pretty', 'false'], raiz, 30000);
+            if (r && r.code !== 0) { // só os erros deste arquivo
+                const rel = path.relative(raiz, arquivo).replace(/\\/g, '/');
+                r.out = r.out.split('\n').filter((l) => l.startsWith(rel)).join('\n');
+                if (!r.out) return null;
+            }
+        } else if (ext === '.json') {
+            nome = 'JSON.parse';
+            try { JSON.parse(fs.readFileSync(arquivo, 'utf-8')); return null; } catch (e) { return { verificador: nome, erros: String(e.message).slice(0, 300) }; }
+        } else if (ext === '.sh') {
+            nome = 'bash -n'; r = rodar('bash', ['-n', arquivo], dir);
+        }
+        if (!r || r.code === 0 || !r.out) return null;
+        return { verificador: nome, erros: cortar(r.out, arquivo) };
+    } catch { return null; }
+}
+
+/** Anexa `diagnosticos` ao resultado de uma ferramenta de escrita. Não mexe no que não for ok. */
+function anexar(resultado, projectDir) {
+    if (!resultado || resultado.ok !== true || !resultado.path) return resultado;
+    const d = diagnosticar(path.resolve(projectDir, resultado.path), projectDir);
+    if (!d) return resultado;
+    return { ...resultado, diagnosticos: `${d.verificador} achou erro neste arquivo depois da edição:\n${d.erros}`,
+        comoCorrigir: 'Corrija o erro acima com edit_file antes de seguir. Não diga que terminou com o arquivo quebrado.' };
+}
+
+module.exports = { diagnosticar, anexar };

package/lib/tool/perguntar.js

@@ -0,0 +1,60 @@
+/**
+ * perguntar.js — a ferramenta `perguntar`: pergunta + 2 a 4 opções (+ texto livre).
+ * Só pra quando o agente está BLOQUEADO (duas saídas razoáveis, não dá pra escolher sozinho).
+ *
+ * Quem desenha na tela é o terminal (ctx.escolher, vem do bin/primocode.js). Sem terminal
+ * (primocode -p, pipe, subagente) devolve a PRIMEIRA opção e registra no log — nunca trava esperando.
+ */
+'use strict';
+
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+
+const LOG = () => path.join(process.env.PRIMOCODE_HOME || path.join(os.homedir(), '.primocode'), 'perguntas-automaticas.log');
+
+function limparOpcoes(opcoes) {
+    let o = opcoes;
+    if (typeof o === 'string') { try { o = JSON.parse(o); } catch { o = o.split(/\n|;|\|/); } }
+    if (!Array.isArray(o)) return [];
+    return o.map((x) => String(x && (x.label || x.texto || x.opcao) || x || '').trim()).filter(Boolean).slice(0, 4);
+}
+
+async function perguntar(args, ctx = {}) {
+    const pergunta = String((args && (args.pergunta || args.question)) || '').trim();
+    const opcoes = limparOpcoes(args && (args.opcoes || args.options));
+    if (!pergunta) return { ok: false, error: 'faltou "pergunta".' };
+    if (opcoes.length < 2) return { ok: false, error: 'passe de 2 a 4 "opcoes" (lista de textos curtos).', comoResolver: 'perguntar pergunta:"...", opcoes:["A","B"]. Se não está bloqueado, escolha você e siga.' };
+    const livre = args.texto_livre !== false && args.texto_livre !== 'false';
+
+    if (typeof ctx.escolher !== 'function') {
+        const escolha = opcoes[0];
+        try {
+            fs.mkdirSync(path.dirname(LOG()), { recursive: true });
+            fs.appendFileSync(LOG(), `${new Date().toISOString()}\t${pergunta}\t[${opcoes.join(' | ')}]\t=> ${escolha}\n`);
+        } catch { /* log é só rastro */ }
+        return { ok: true, escolha, indice: 0, automatico: true,
+            aviso: 'Sem terminal: ninguém pode responder, então valeu a primeira opção. Siga com ela e diga isso no fim.' };
+    }
+    const r = await ctx.escolher(pergunta, opcoes, { livre });
+    if (r == null) return { ok: true, escolha: opcoes[0], indice: 0, automatico: true, aviso: 'A pessoa não respondeu; valeu a primeira opção.' };
+    if (typeof r === 'number') return { ok: true, escolha: opcoes[r] || opcoes[0], indice: opcoes[r] ? r : 0 };
+    return { ok: true, escolha: String(r), indice: -1, texto_livre: true };
+}
+
+/** O desenho no terminal: lista numerada + "ou escreva". `ask(prompt) → Promise<string>`. Enter = opção 1. */
+async function escolherNoTerminal(ask, c, pergunta, opcoes, { livre = true } = {}) {
+    console.log('');
+    console.log('  ' + c.brand('?') + ' ' + c.bold(c.white(pergunta)));
+    opcoes.forEach((o, i) => console.log('  ' + c.brand(String(i + 1)) + c.muted(' › ') + c.white(o)));
+    console.log('  ' + c.dim(livre ? `Enter = 1 · ou escreva a sua resposta` : 'Enter = 1'));
+    const dito = String(await ask('  ' + c.brand('❯ ') + c.muted(`1-${opcoes.length} `))).trim();
+    if (!dito) return 0;
+    const n = Number(dito);
+    if (Number.isInteger(n) && n >= 1 && n <= opcoes.length) return n - 1;
+    const igual = opcoes.findIndex((o) => o.toLowerCase() === dito.toLowerCase());
+    if (igual >= 0) return igual;
+    return livre ? dito : 0;
+}
+
+module.exports = { perguntar, escolherNoTerminal, limparOpcoes };