primocode 10.17.1 → 11.0.0

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

package/lib/segredos.js

@@ -0,0 +1,103 @@
+/**
+ * segredos.js — o /secrets: as chaves que o projeto usa, SÓ OS NOMES.
+ *
+ *   listar(dir)                 → [{ nome, noEnv, vazia, usadaEm: ['server.js'] }]   (nunca o valor)
+ *   nomeValido('openai_key')    → 'OPENAI_KEY' | null
+ *   gravar(dir, nome, valor)    → { criou, gitignore }   (escreve no .env, que nunca vai pro git)
+ *
+ * "Chave" é a senha que um serviço te dá (OpenAI, Stripe, banco de dados…). Quem escreve
+ * isso no código e sobe pro GitHub perde a chave em minutos. Por isso o valor só entra pelo
+ * teclado, escondido, e só vai para o `.env`; a tela mostra nome e nada mais.
+ * O agente escrevendo no .env continua passando pelo portão de sempre (lib/perigo.js): este
+ * módulo só serve ao /secrets, não abre porta nenhuma para ele.
+ */
+
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const protecao = require('./protecao.js');
+
+const IGNORAR = new Set(['node_modules', '.git', '.next', 'dist', 'build', '.primocode', '.venv', '__pycache__']);
+const CODIGO = /\.(m?js|cjs|jsx|tsx?|py|rb|php|go|html|vue|svelte)$/i;
+const USOS = [/process\.env\.([A-Z][A-Z0-9_]+)/g, /process\.env\[['"]([A-Z][A-Z0-9_]+)['"]\]/g, /import\.meta\.env\.([A-Z][A-Z0-9_]+)/g,
+    /os\.environ(?:\.get)?[[(]['"]([A-Z][A-Z0-9_]+)['"]/g, /getenv\(['"]([A-Z][A-Z0-9_]+)['"]/g];
+const PADRAO_NOME = /^[A-Z_][A-Z0-9_]*$/;
+
+function nomeValido(nome) {
+    const n = String(nome || '').trim().toUpperCase().replace(/[-\s]+/g, '_');
+    return PADRAO_NOME.test(n) ? n : null;
+}
+
+/** As linhas NOME=valor de um arquivo .env → { NOME: valorVazio? } (o valor em si nunca sai daqui). */
+function nomesDoEnv(arquivo) {
+    const out = {};
+    let txt = '';
+    try { txt = fs.readFileSync(arquivo, 'utf8'); } catch { return out; }
+    for (const l of txt.split('\n')) {
+        const m = l.match(/^\s*(?:export\s+)?([A-Za-z_][A-Za-z0-9_]*)\s*=(.*)$/);
+        if (m) out[m[1]] = !m[2].trim().replace(/^["']|["']$/g, '');
+    }
+    return out;
+}
+
+function usosNoCodigo(dir, limite = 400) {
+    const achou = {};
+    let vistos = 0;
+    const andar = (d, fundo) => {
+        let itens = [];
+        try { itens = fs.readdirSync(d, { withFileTypes: true }); } catch { return; }
+        for (const it of itens) {
+            if (vistos >= limite) return;
+            if (it.isDirectory()) { if (!IGNORAR.has(it.name) && fundo < 6) andar(path.join(d, it.name), fundo + 1); continue; }
+            if (!CODIGO.test(it.name)) continue;
+            vistos++;
+            let txt = '';
+            try { txt = fs.readFileSync(path.join(d, it.name), 'utf8').slice(0, 300000); } catch { continue; }
+            const rel = path.relative(dir, path.join(d, it.name));
+            for (const re of USOS) for (const m of txt.matchAll(re)) (achou[m[1]] = achou[m[1]] || new Set()).add(rel);
+        }
+    };
+    andar(dir, 0);
+    return achou;
+}
+
+function listar(dir) {
+    const env = { ...nomesDoEnv(path.join(dir, '.env.example')), ...nomesDoEnv(path.join(dir, '.env')) };
+    const noEnv = nomesDoEnv(path.join(dir, '.env'));
+    const codigo = usosNoCodigo(dir);
+    const nomes = new Set([...Object.keys(env), ...Object.keys(codigo)]);
+    return [...nomes].sort().map((nome) => ({
+        nome,
+        noEnv: Object.prototype.hasOwnProperty.call(noEnv, nome),
+        vazia: !!noEnv[nome],
+        usadaEm: codigo[nome] ? [...codigo[nome]].slice(0, 3) : [],
+    }));
+}
+
+const guardaValor = (v) => (/^[\w.:/@+-]*$/.test(v) ? v : JSON.stringify(v));
+
+function gravar(dir, nome, valor) {
+    const n = nomeValido(nome);
+    if (!n) throw new Error('Nome de chave inválido: use letras, números e _ (ex.: OPENAI_API_KEY).');
+    if (/[\r\n]/.test(String(valor))) throw new Error('A chave não pode ter quebra de linha.');
+    const f = path.join(dir, '.env');
+    const criou = !fs.existsSync(f);
+    const linhas = criou ? [] : fs.readFileSync(f, 'utf8').split('\n');
+    const nova = `${n}=${guardaValor(String(valor))}`;
+    const i = linhas.findIndex((l) => new RegExp(`^\\s*(export\\s+)?${n}\\s*=`).test(l));
+    if (i >= 0) linhas[i] = nova;
+    else { while (linhas.length && linhas[linhas.length - 1] === '') linhas.pop(); linhas.push(nova); }
+    fs.writeFileSync(f, linhas.join('\n') + '\n', { mode: 0o600 });
+    try { fs.chmodSync(f, 0o600); } catch { /* sistema sem permissão de arquivo */ }
+    let gitignore = false;
+    if (!protecao.envFicaDeFora(dir)) {
+        const g = path.join(dir, '.gitignore');
+        const atual = fs.existsSync(g) ? fs.readFileSync(g, 'utf8') : '';
+        fs.writeFileSync(g, atual + (atual && !atual.endsWith('\n') ? '\n' : '') + '.env\n');
+        gitignore = true;
+    }
+    return { criou, gitignore, nome: n, substituiu: i >= 0 };
+}
+
+module.exports = { listar, gravar, nomeValido, nomesDoEnv };

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