primocode 10.17.1 → 11.0.0

package/lib/checkpoint-git.js

@@ -43,6 +43,8 @@ const TEMPO_MAXIMO_MS = 20000;
 const IGNORAR_SEMPRE = [
     'node_modules/', '.git/', 'dist/', 'build/', '.next/', '.nuxt/', '.turbo/',
     '.cache/', 'coverage/', '__pycache__/', '.venv/', 'venv/', '*.log', '.DS_Store',
+    // a cópia do banco e as travas do /lock moram na pasta: voltar a foto não pode levá-las embora
+    '.primocode/backup/', '.primocode/travados.json',
 ];
 
 let _temGit = null;
@@ -103,7 +105,7 @@ function preparar(gitDir, workTree) {
     git(gitDir, workTree, ['init', '-q']);
     fs.mkdirSync(path.join(gitDir, 'info'), { recursive: true });
     fs.writeFileSync(path.join(gitDir, 'info', 'exclude'),
-        '# o que o /desfazer nunca fotografa (o .gitignore do projeto vale também)\n'
+        '# o que o /undo nunca fotografa (o .gitignore do projeto vale também)\n'
         + IGNORAR_SEMPRE.join('\n') + '\n');
     // Os hooks de exemplo do template não rodam, mas não precisam ficar lá.
     fs.rmSync(path.join(gitDir, 'hooks'), { recursive: true, force: true });
@@ -178,10 +180,11 @@ function podarVazias(workTree, rel) {
 /** Volta o disco para a foto `sha`: o que mudou ou sumiu volta, o que nasceu
     depois sai. Só se apaga o que a sombra VIU nascer — arquivo ignorado
     (node_modules, .gitignore, grande demais) nunca entra no index, então nunca
-    aparece como A, então nunca é apagado. */
-function restaurar(gitDir, workTree, sha) {
+    aparece como A, então nunca é apagado. Com `so`, volta só aqueles. */
+function restaurar(gitDir, workTree, sha, { so = null } = {}) {
     const feitos = [];
-    const lista = mudancas(gitDir, workTree, sha);
+    // `so`: só estes caminhos relativos (o "/desfazer fora": o resto do pedido fica)
+    const lista = mudancas(gitDir, workTree, sha).filter((m) => !so || so.has(m.rel));
     const statusDe = new Map(lista.map((m) => [m.rel, m.status]));
     const voltar = lista.filter((m) => m.status !== 'A').map((m) => m.rel);
     // Em lotes: um projeto com milhares de mudanças estouraria a linha de comando.

package/lib/checkpoint.js

@@ -108,7 +108,7 @@ function iniciar(pedido, projectDir) {
 
 /** Fecha o pedido. Com foto, anota o que mudou (é o que o `/desfazer lista`
     mostra) — e, se nada mudou, o checkpoint some: uma pergunta não pode
-    ocupar o lugar de um pedido que o /desfazer deveria voltar. */
+    ocupar o lugar de um pedido que o /undo deveria voltar. */
 function encerrar() {
     const g = atual && atual.git;
     atual = null;
@@ -116,6 +116,7 @@ function encerrar() {
     try {
         const m = foto.mudancas(g.gitDir, g.projectDir, g.manifest.git.sha);
         if (!m.length && !g.manifest.arquivos.length) { fs.rmSync(g.dir, { recursive: true, force: true }); return; }
+        esquecerRefazer(g.projectDir);   // mudou depois do /undo: refazer agora apagaria trabalho novo
         g.manifest.mudancas = m;
         gravarManifest(g);
     } catch { /* sem a conta, a lista calcula na hora */ }
@@ -127,6 +128,7 @@ function guardarOriginal(cp, abs) {
     if (cp.manifest.arquivos.some((a) => a.caminho === abs)) return;
     const existia = fs.existsSync(abs) && fs.statSync(abs).isFile();
     const item = { caminho: abs, existia };
+    if (cp.manifest.arquivos.length === 0) esquecerRefazer(cp.manifest.projectDir);
     if (existia) {
         item.copia = String(cp.manifest.arquivos.length);
         fs.copyFileSync(abs, path.join(cp.dir, item.copia));
@@ -211,11 +213,12 @@ function previa(projectDir, n = 1) {
 
 /** Desfaz os N pedidos mais recentes, do mais novo para o mais velho — assim,
     se dois pedidos mexeram no mesmo arquivo, o que sobra é o original do mais
-    antigo. Cada checkpoint desfeito é apagado: o próximo /desfazer volta mais
+    antigo. Cada checkpoint desfeito é apagado: o próximo /undo volta mais
     um pedido, em vez de repetir o mesmo. */
 function desfazer(projectDir, n = 1) {
     const feitos = new Map();   // um arquivo, uma linha: vale a última ação
     const anotar = (caminho, acao, erro) => { feitos.delete(caminho); feitos.set(caminho, erro ? { caminho, acao, erro } : { caminho, acao }); };
+    guardarRefazer(projectDir, n);
     for (const cp of lista(projectDir).slice(0, Math.max(1, n))) {
         if (cp.git) {
             try {
@@ -243,7 +246,121 @@ function desfazer(projectDir, n = 1) {
     return [...feitos.values()];
 }
 
+/** Volta só ALGUNS arquivos do pedido mais novo (o "/desfazer fora" do
+    lib/escopo.js): o resto do pedido fica, e o checkpoint também — um
+    /undo depois ainda volta o pedido inteiro. O /redo de antes é
+    esquecido: ele passaria por cima do que voltou agora. */
+function desfazerArquivos(projectDir, caminhos) {
+    const cp = lista(projectDir)[0];
+    if (!cp || !caminhos || !caminhos.length) return [];
+    const quer = new Set(caminhos.map((c) => path.resolve(cp.projectDir, c)));
+    const feitos = [];
+    esquecerRefazer(projectDir);
+    if (cp.git) {
+        const so = new Set([...quer].map((abs) => path.relative(cp.projectDir, abs)));
+        try {
+            for (const f of foto.restaurar(path.join(path.dirname(cp.dir), 'git'), cp.projectDir, cp.git.sha, { so })) {
+                feitos.push({ ...f, caminho: path.join(cp.projectDir, f.rel) });
+            }
+        } catch (e) { feitos.push({ caminho: cp.projectDir, acao: 'falhou', erro: e.message }); }
+    }
+    for (const a of cp.arquivos || []) {
+        if (!quer.has(a.caminho) || feitos.some((f) => f.caminho === a.caminho)) continue;
+        try {
+            if (a.existia) { fs.copyFileSync(path.join(cp.dir, a.copia), a.caminho); feitos.push({ caminho: a.caminho, acao: 'restaurado' }); }
+            else { fs.rmSync(a.caminho, { force: true }); feitos.push({ caminho: a.caminho, acao: 'apagado' }); }
+        } catch (e) { feitos.push({ caminho: a.caminho, acao: 'falhou', erro: e.message }); }
+    }
+    return feitos;
+}
+
+/* O /refazer: antes de o /desfazer voltar os arquivos, o estado de AGORA de
+   cada um vai para <projeto>/refazer/. Só o último /undo tem volta, e só
+   enquanto nada mudou depois — um pedido novo que mexe no disco apaga a volta,
+   senão o /redo passaria por cima do trabalho novo. */
+function pastaRefazer(projectDir) { return path.join(pastaDoProjeto(projectDir), 'refazer'); }
+
+function esquecerRefazer(projectDir) {
+    try { if (projectDir) fs.rmSync(pastaRefazer(projectDir), { recursive: true, force: true }); } catch {}
+}
+
+function guardarRefazer(projectDir, n) {
+    const dir = pastaRefazer(projectDir);
+    esquecerRefazer(projectDir);
+    const pedidos = lista(projectDir).slice(0, Math.max(1, n)).map((cp) => cp.pedido);
+    const arquivos = [];
+    try {
+        fs.mkdirSync(dir, { recursive: true });
+        for (const { caminho } of previa(projectDir, n)) {
+            const existia = fs.existsSync(caminho) && fs.statSync(caminho).isFile();
+            const item = { caminho, existia };
+            if (existia) { item.copia = String(arquivos.length); fs.copyFileSync(caminho, path.join(dir, item.copia)); }
+            arquivos.push(item);
+        }
+        fs.writeFileSync(path.join(dir, 'manifest.json'), JSON.stringify({ quando: Date.now(), pedidos, arquivos }));
+    } catch { /* sem a volta do refazer, o desfazer ainda funciona */ }
+}
+
+/** O que o /refazer devolveria (null = nada a refazer). */
+function refazerDisponivel(projectDir) {
+    try { return JSON.parse(fs.readFileSync(path.join(pastaRefazer(projectDir), 'manifest.json'), 'utf8')); }
+    catch { return null; }
+}
+
+/** Devolve os arquivos ao estado de antes do último /desfazer. */
+function refazer(projectDir) {
+    const m = refazerDisponivel(projectDir);
+    if (!m) return [];
+    const dir = pastaRefazer(projectDir);
+    const feitos = [];
+    for (const a of m.arquivos) {
+        try {
+            if (a.existia) {
+                fs.mkdirSync(path.dirname(a.caminho), { recursive: true });
+                fs.copyFileSync(path.join(dir, a.copia), a.caminho);
+                feitos.push({ caminho: a.caminho, acao: 'refeito' });
+            } else {
+                fs.rmSync(a.caminho, { force: true });
+                feitos.push({ caminho: a.caminho, acao: 'apagado' });
+            }
+        } catch (e) { feitos.push({ caminho: a.caminho, acao: 'falhou', erro: e.message }); }
+    }
+    esquecerRefazer(projectDir);
+    return feitos;
+}
+
+/* O /conferir e o /voltar: quando o projeto passa nos testes, o checkpoint
+   mais novo (o do último pedido, já feito) ganha `funcionava` no manifest.
+   Pedidos que vierem depois ficam com índice menor; `desfazer(indice)` desfaz
+   exatamente esses, e o projeto volta a como estava logo após o pedido marcado. */
+function marcarFuncionando(projectDir, como) {
+    const cp = lista(projectDir)[0];
+    if (!cp) return null;
+    try {
+        const arq = path.join(cp.dir, 'manifest.json');
+        const m = JSON.parse(fs.readFileSync(arq, 'utf8'));
+        m.funcionava = new Date().toISOString();
+        // COMO foi conferido ("npm test", "a página abriu"): o /voltar e a lista mostram, e "funcionava" sozinho não dizia
+        if (como) { m.funcionava_como = String(como).slice(0, 60); cp.funcionava_como = m.funcionava_como; }
+        /* O pedido EM ANDAMENTO tem o manifest em memória, e o encerrar() regrava ele por cima do disco: sem isto, a
+           marca que o teste do agente põe antes do "pronto" sumia no fim do pedido (achado da revisão de 24/10). */
+        for (const vivo of [atual && atual.git, atual && atual.arq]) {
+            if (vivo && vivo.dir === cp.dir && vivo.manifest) { vivo.manifest.funcionava = m.funcionava; if (m.funcionava_como) vivo.manifest.funcionava_como = m.funcionava_como; }
+        }
+        fs.writeFileSync(arq, JSON.stringify(m, null, 2));
+        cp.funcionava = m.funcionava;
+        return cp;
+    } catch { return null; }
+}
+
+/** O ponto mais novo marcado como funcionando: { indice, cp } (0 = o mais novo). */
+function ultimoQueFuncionava(projectDir) {
+    const cps = lista(projectDir);
+    const indice = cps.findIndex((cp) => cp.funcionava);
+    return indice < 0 ? null : { indice, cp: cps[indice] };
+}
+
 /** Qual jeito de guardar vale nesta pasta — o /desfazer lista conta à pessoa. */
 function modo(projectDir) { return podeFotografar(projectDir) ? 'foto' : 'arquivo'; }
 
-module.exports = { MAXIMO, MUDAM_ARQUIVO, iniciar, encerrar, antesDeMudar, lista, previa, desfazer, modo, pastaDoProjeto };
+module.exports = { MAXIMO, MUDAM_ARQUIVO, iniciar, encerrar, antesDeMudar, lista, previa, desfazer, desfazerArquivos, refazer, refazerDisponivel, marcarFuncionando, ultimoQueFuncionava, modo, pastaDoProjeto };

package/lib/cli/review.js

@@ -0,0 +1,64 @@
+/**
+ * review.js — `primocode review --pr <n> [--postar]` (ideia do Bugbot): lê o diff do PR com `gh`, pede ao modelo
+ * uma revisão e devolve comentários em markdown. Postar no PR só com --postar (o padrão só mostra e grava em
+ * .primocode/review/pr-<n>.md). Nada de aprovar nem pedir mudanças no PR: só um comentário.
+ *
+ * NÃO é o /review de dentro da sessão (esse é da branch rebuild/paridade-cc). Este roda sem sessão, em CI.
+ * `gh` e o modelo são injetáveis. O workflow do GitHub: .github/workflows/primocode-review.yml.
+ */
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const { sh, perguntarPadrao } = require('./util.js');
+
+const MAX_DIFF = 60000;
+const SISTEMA = 'Você é um revisor de código. Leia o diff e aponte SÓ problemas reais: bugs, falhas de segurança, casos de borda sem tratamento, testes que faltam. '
+    + 'Formato markdown: uma seção "### arquivo:linha — título curto" por problema, com 1-3 frases do porquê e a correção sugerida. '
+    + 'Ordene do mais grave ao menos. Sem elogio, sem resumir o diff. Se não achou nada relevante, escreva exatamente: "Nada relevante encontrado."';
+
+function analisar(args) {
+    const r = { pr: null, postar: false, erro: null };
+    for (let i = 0; i < args.length; i++) {
+        if (args[i] === '--pr') r.pr = args[++i];
+        else if (args[i].startsWith('--pr=')) r.pr = args[i].slice(5);
+        else if (args[i] === '--postar') r.postar = true;
+    }
+    if (!r.pr || !/^\d+$/.test(String(r.pr))) r.erro = 'Uso: primocode review --pr <número> [--postar]';
+    return r;
+}
+
+function cortar(diff) {
+    if (diff.length <= MAX_DIFF) return { diff, cortado: false };
+    return { diff: diff.slice(0, MAX_DIFF), cortado: true };
+}
+
+async function revisar({ pr, dir = process.cwd(), postar = false, gh = (a) => sh('gh', a, { cwd: dir }), perguntar = perguntarPadrao }) {
+    const d = gh(['pr', 'diff', String(pr)]);
+    if (!d.ok) return { ok: false, erro: `não consegui ler o diff do PR #${pr} (${(d.err || 'gh falhou').trim().split('\n')[0]})` };
+    if (!d.out.trim()) return { ok: false, erro: `o PR #${pr} não tem diff` };
+    const { diff, cortado } = cortar(d.out);
+    const corpo = String(await perguntar(null, SISTEMA, `Diff do PR #${pr}:\n\n${diff}`)).trim();
+    const md = `## Revisão do PrimoCode — PR #${pr}\n\n${corpo}\n` + (cortado ? `\n_O diff passou de ${MAX_DIFF} caracteres: revisei só o começo._\n` : '')
+        + '\n<sub>Revisão automática: pode errar. Quem decide é a pessoa.</sub>\n';
+    const arquivo = path.join(dir, '.primocode', 'review', `pr-${pr}.md`);
+    fs.mkdirSync(path.dirname(arquivo), { recursive: true }); fs.writeFileSync(arquivo, md);
+    let postado = false, erroPost = null;
+    if (postar) {
+        const r = gh(['pr', 'comment', String(pr), '--body-file', arquivo]);
+        postado = r.ok; if (!r.ok) erroPost = (r.err || '').trim().split('\n')[0];
+    }
+    return { ok: true, md, arquivo, postado, erroPost };
+}
+
+async function main(args, deps = {}) {
+    const a = analisar(args);
+    if (a.erro) { console.error(a.erro); return 1; }
+    const r = await revisar({ pr: a.pr, postar: a.postar, ...deps });
+    if (!r.ok) { console.error('  ' + r.erro); return 1; }
+    console.log(r.md);
+    console.log(a.postar ? (r.postado ? `  Comentário postado no PR #${a.pr}.` : `  Não consegui postar: ${r.erroPost}`) : `  Não postei nada (use --postar). Salvo em ${r.arquivo}`);
+    return a.postar && !r.postado ? 1 : 0;
+}
+
+module.exports = { analisar, revisar, main, SISTEMA, MAX_DIFF };

package/lib/cli/subcomandos.js

@@ -0,0 +1,34 @@
+/**
+ * subcomandos.js — as entradas `primocode <nome> ...` que saem ANTES da sessão (sem tela):
+ *   autoteste · preview · review · pesquisar
+ * Cada uma chama o módulo de lib/plugin/ ou lib/cli/. O bin só faz `if (NOMES.includes(argv[2]))`.
+ */
+'use strict';
+
+const path = require('path');
+const { sh } = require('./util.js');
+
+const NOMES = ['autoteste', 'preview', 'review', 'pesquisar'];
+
+async function autoteste(args) {
+    const A = require('../plugin/autoteste.js');
+    const dir = path.resolve(args.find((a) => !a.startsWith('-')) || process.cwd());
+    const bin = path.join(__dirname, '..', '..', 'bin', 'primocode.js');
+    const r = await A.testar({
+        dir, log: (l) => console.log('  ' + l),
+        consertar: async (erros, prints) => { console.log('  mandando as falhas pro agente consertar…'); sh(process.execPath, [bin, '-p', A.pedidoDeConserto(erros, prints)], { cwd: dir }); },
+    });
+    if (r.ok) console.log(`  Passou${r.rodadas ? ` depois de ${r.rodadas} conserto(s)` : ''}.`);
+    else { console.log('  ' + r.erro); (r.relatorio.slice(-1)[0] || { erros: [] }).erros.forEach((e) => console.log('   - ' + e)); }
+    return r.ok ? 0 : 1;
+}
+
+async function main(nome, args) {
+    if (nome === 'autoteste') return autoteste(args);
+    if (nome === 'preview') return require('../plugin/preview-cli.js').main(args);
+    if (nome === 'review') return require('./review.js').main(args);
+    if (nome === 'pesquisar') return require('../plugin/pesquisar.js').main(args);
+    return 1;
+}
+
+module.exports = { NOMES, main };

package/lib/cli/tentativas.js

@@ -0,0 +1,107 @@
+/**
+ * tentativas.js — `primocode --tentativas N "pedido"` (ideia do Codex, "best of N"): roda a tarefa N vezes, cada
+ * uma num git worktree separado, roda o check do projeto em cada uma, e fica com a que passou e mexeu menos.
+ *
+ *   N: padrão 3, máximo 4.   Check: `npm test` se o package.json tiver script "test" (ou --check "<comando>").
+ *   Uma linha por tentativa: "#2 passou · +12 −3 · 2 arquivos".
+ *
+ * `executar(dirDoWorktree, pedido)` e `checar(dir)` são injetáveis (os testes usam falsos; o padrão roda
+ * `primocode -p`). O vencedor vira um patch aplicado na pasta principal; os worktrees são apagados no fim.
+ */
+'use strict';
+
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+const { sh } = require('./util.js');
+
+const PADRAO = 3, MAX = 4;
+const limitar = (n) => { const v = Number(n); return Number.isFinite(v) && v >= 1 ? Math.min(MAX, Math.floor(v)) : PADRAO; };
+
+/** Tira `--tentativas N` / `--tentativas=N` / `--check cmd` dos argumentos. null = a flag não veio. */
+function analisar(argv) {
+    const r = { tentativas: null, check: null, resto: [] };
+    for (let i = 0; i < argv.length; i++) {
+        const a = argv[i];
+        if (a === '--tentativas') { r.tentativas = limitar(argv[i + 1]); i++; }
+        else if (a.startsWith('--tentativas=')) r.tentativas = limitar(a.split('=')[1]);
+        else if (a === '--check') { r.check = argv[++i]; }
+        else r.resto.push(a);
+    }
+    return r;
+}
+
+/** O comando de check do projeto, ou null. */
+function comandoDeCheck(dir, forcado) {
+    if (forcado) return ['sh', ['-c', forcado]];
+    try {
+        const p = JSON.parse(fs.readFileSync(path.join(dir, 'package.json'), 'utf8'));
+        const t = p.scripts && p.scripts.test;
+        if (t && !/no test specified/.test(t)) return ['npm', ['test', '--silent']];
+    } catch { /* sem package.json */ }
+    return null;
+}
+
+/** Tamanho do diff do worktree contra o HEAD, contando arquivos novos. { mais, menos, arquivos, patch }. */
+function medirDiff(dir) {
+    sh('git', ['add', '-A', '-N'], { cwd: dir });
+    const ns = sh('git', ['diff', '--numstat', 'HEAD'], { cwd: dir }).out.trim().split('\n').filter(Boolean);
+    let mais = 0, menos = 0;
+    for (const l of ns) { const [a, b] = l.split('\t'); mais += Number(a) || 0; menos += Number(b) || 0; }
+    return { mais, menos, arquivos: ns.length, patch: sh('git', ['diff', '--binary', 'HEAD'], { cwd: dir }).out };
+}
+
+const linha = (t) => `#${t.n} ${t.erro ? 'falhou (' + t.erro + ')' : t.passou ? 'passou' : 'reprovou no check'}`
+    + (t.erro ? '' : ` · +${t.diff.mais} −${t.diff.menos} · ${t.diff.arquivos} arquivo${t.diff.arquivos === 1 ? '' : 's'}`);
+
+/** A melhor: passou, e com o menor diff (linhas mexidas, depois arquivos). null se nenhuma passou. */
+function escolher(ts) {
+    const ok = ts.filter((t) => t.passou && !t.erro);
+    ok.sort((a, b) => (a.diff.mais + a.diff.menos) - (b.diff.mais + b.diff.menos) || a.diff.arquivos - b.diff.arquivos || a.n - b.n);
+    return ok[0] || null;
+}
+
+async function rodar({ dir, pedido, n = PADRAO, check, executar, checar, log = () => {}, aplicar = true }) {
+    n = limitar(n);
+    if (!sh('git', ['rev-parse', '--is-inside-work-tree'], { cwd: dir }).ok) return { ok: false, erro: 'precisa de um repositório git (as tentativas usam git worktree)' };
+    const cmd = comandoDeCheck(dir, check);
+    executar = executar || ((d, p) => sh(process.execPath, [path.join(__dirname, '..', '..', 'bin', 'primocode.js'), '-p', p], { cwd: d }));
+    checar = checar || ((d) => (cmd ? sh(cmd[0], cmd[1], { cwd: d }).ok : true));
+    const base = fs.mkdtempSync(path.join(os.tmpdir(), 'primocode-tentativas-'));
+    const ts = [];
+    for (let i = 1; i <= n; i++) {
+        const wt = path.join(base, `t${i}`);
+        const t = { n: i, dir: wt };
+        const add = sh('git', ['worktree', 'add', '--detach', wt, 'HEAD'], { cwd: dir });
+        if (!add.ok) { t.erro = 'worktree: ' + add.err.trim().split('\n')[0]; t.diff = { mais: 0, menos: 0, arquivos: 0, patch: '' }; ts.push(t); log(linha(t)); continue; }
+        try {
+            await executar(wt, pedido);
+            t.diff = medirDiff(wt);
+            t.passou = t.diff.arquivos > 0 && !!(await checar(wt));
+        } catch (e) { t.erro = String(e.message || e).slice(0, 60); t.diff = t.diff || { mais: 0, menos: 0, arquivos: 0, patch: '' }; }
+        ts.push(t); log(linha(t));
+    }
+    const melhor = escolher(ts);
+    let aplicado = false, patchPath = null;
+    if (melhor) {
+        patchPath = path.join(dir, '.primocode', 'tentativas', `${Date.now()}-melhor.patch`);
+        fs.mkdirSync(path.dirname(patchPath), { recursive: true }); fs.writeFileSync(patchPath, melhor.diff.patch);
+        if (aplicar) aplicado = sh('git', ['apply', patchPath], { cwd: dir }).ok;
+    }
+    for (const t of ts) { sh('git', ['worktree', 'remove', '--force', t.dir], { cwd: dir }); }
+    try { fs.rmSync(base, { recursive: true, force: true }); } catch { /* */ }
+    return { ok: !!melhor, melhor: melhor && melhor.n, resumo: ts.map(linha), aplicado, patchPath,
+        erro: melhor ? null : 'nenhuma tentativa passou no check — nada foi aplicado' };
+}
+
+async function main(argv, deps = {}) {
+    const a = analisar(argv);
+    const pedido = a.resto.filter((x) => !x.startsWith('-')).join(' ').trim();
+    if (!pedido) { console.error('Uso: primocode --tentativas 3 "pedido" [--check "npm test"]'); return 1; }
+    const r = await rodar({ dir: process.cwd(), pedido, n: a.tentativas, check: a.check, log: (l) => console.log('  ' + l), ...deps });
+    if (r.ok) console.log(`  Fiquei com a #${r.melhor}. ` + (r.aplicado ? 'Aplicada na pasta.' : `Não consegui aplicar sozinho; o patch está em ${r.patchPath}`));
+    else console.log('  ' + r.erro);
+    return r.ok ? 0 : 1;
+}
+
+module.exports = { analisar, limitar, comandoDeCheck, medirDiff, escolher, rodar, main, PADRAO, MAX };

package/lib/cli/util.js

@@ -0,0 +1,51 @@
+/**
+ * util.js — peças pequenas que os subcomandos `primocode issue|review|headless|...` dividem.
+ * Tudo que fala com o mundo (shell, modelo) é injetável: os testes trocam por falsos.
+ */
+'use strict';
+
+const { spawnSync } = require('child_process');
+
+/** Roda um comando sem shell. Devolve { ok, status, out, err }. */
+function sh(cmd, args = [], { cwd, input, timeout = 10 * 60 * 1000, env } = {}) {
+    const r = spawnSync(cmd, args, { cwd, input, encoding: 'utf8', timeout, env: env || process.env, maxBuffer: 64 * 1024 * 1024 });
+    return { ok: r.status === 0, status: r.status, out: r.stdout || '', err: (r.stderr || '') + (r.error ? String(r.error.message) : '') };
+}
+
+const temComando = (nome) => sh(process.platform === 'win32' ? 'where' : 'which', [nome]).ok;
+
+/**
+ * O modelo, de fora da sessão: pergunta única, sem ferramentas.
+ * `modelo` vazio = o modelo da conta. Falha com mensagem clara (nunca inventa resposta).
+ */
+async function perguntarPadrao(modelo, sistema, usuario) {
+    const cfg = require('../config.js');
+    const api = require('../api.js');
+    const conf = cfg.loadConfig();
+    let resposta = '';
+    await api.requestChat(conf.server, {
+        prompt: sistema ? `${sistema}\n\n${usuario}` : usuario, history: [], model: modelo || conf.model, token: conf.token || cfg.tokenDaConta(),
+    }, (evt) => { if (evt.delta) resposta += evt.delta; });
+    return resposta;
+}
+
+/** Tira cerca de código (```json ... ```) e acha o primeiro JSON do texto. */
+function acharJson(texto) {
+    const t = String(texto || '');
+    const cerca = t.match(/```(?:json)?\s*([\s\S]*?)```/);
+    const candidatos = [cerca && cerca[1], t];
+    for (const c of candidatos) {
+        if (!c) continue;
+        const i = c.search(/[[{]/);
+        if (i < 0) continue;
+        for (let fim = c.length; fim > i; fim = c.lastIndexOf(c[i] === '{' ? '}' : ']', fim - 1) + 1) {
+            if (fim <= 0) break;
+            try { return JSON.parse(c.slice(i, fim)); } catch { /* tenta mais curto */ }
+        }
+    }
+    return null;
+}
+
+const slug = (s) => String(s || '').normalize('NFD').replace(/[̀-ͯ]/g, '').toLowerCase().replace(/[^a-z0-9]+/g, '-').replace(/^-+|-+$/g, '').slice(0, 40) || 'tarefa';
+
+module.exports = { sh, temComando, perguntarPadrao, acharJson, slug };

package/lib/comandos-extra.js

@@ -228,17 +228,36 @@ const UM_GB = 1024 ** 3;
  *
  * Tudo injetável (`dep`), para o teste passar os casos sem rede nem Chrome.
  */
+/* O servidor atrás da CLI foi o que travou as tarefas em segundo plano em 22/10: a CLI 10.18 mandava as
+   ferramentas novas, e o servidor 10.17.1 nem sabia delas. O /health traz `primocode` (a versão que o
+   servidor acompanha) desde a 10.18; sem o campo, ele é mais velho que isso. Compara major.minor. Pura. */
+function servidorAtrasado(h, local) {
+    const mm = (v) => { const m = String(v || '').match(/^(\d+)\.(\d+)/); return m ? [Number(m[1]), Number(m[2])] : null; };
+    const l = mm(local);
+    if (!h || !l) return null;
+    const conserto = 'quem cuida do servidor publica a versão nova (railway up); até lá, o que é novo nesta versão pode não funcionar';
+    const s = mm(h.primocode);
+    if (!s) return { detalhe: `o servidor é anterior à 10.18 e esta CLI é a ${local}`, conserto };
+    if (s[0] < l[0] || (s[0] === l[0] && s[1] < l[1])) return { detalhe: `o servidor acompanha a ${h.primocode} e esta CLI é a ${local}`, conserto };
+    return null;
+}
+
 async function diagnosticar(dep = {}) {
     const d = {
         versaoNode: process.version,
         minimaNode: '18.17.0',
         plataforma: process.platform,
         saude: null,                 // async () => objeto do /health
+        versaoLocal: (() => { try { return require('../package.json').version; } catch { return null; } })(),
         prazoServidor: 15000,
         provedor: () => null,        // provedor do /api, ou null
         conferirChave: null,         // async (id, chave) => { ok, error }
         cliInstalado: () => false,   // (id) => bool
         acharChrome: () => null,
+        // o olho do vídeo pronto e o texto do gosto (lib/estudio/visao.js); null = não se aplica (fora do Mac)
+        visao: () => { try { const V = require('./estudio/visao.js'); return process.platform === 'darwin' ? V.disponivel() : null; } catch { return false; } },
+        // o Python do editor de vídeo (lib/editor-pro.js): nasce sozinho no 1º uso; aqui só se diz se já existe
+        editorPronto: () => { try { const E = require('./editor-pro.js'); return fs.existsSync(E.venvPython()); } catch { return false; } },
         pythonQuartz: pythonComQuartz,
         raiz: null,
         espaco: espacoLivre,
@@ -257,6 +276,8 @@ async function diagnosticar(dep = {}) {
         try {
             const h = await comPrazo(d.saude(), d.prazoServidor);
             poe(true, 'Servidor', `${h && h.status || 'ok'}${h && h.version ? ' · v' + h.version : ''}`);
+            const atraso = servidorAtrasado(h, d.versaoLocal);
+            if (atraso) poe(false, 'Servidor atrás', atraso.detalhe, atraso.conserto);
         } catch (e) {
             poe(false, 'Servidor', e.message, 'confira a internet; se acabou de ligar, ele acorda em até 1 min — rode /doctor de novo');
         }
@@ -283,6 +304,16 @@ async function diagnosticar(dep = {}) {
     poe(!!chrome, 'Navegador', chrome || 'nenhum Chrome/Edge/Brave encontrado',
         'instale o Google Chrome (google.com/chrome), ou aponte PRIMOCODE_CHROME para o seu');
 
+    // O olho do vídeo e o Python do editor: sem eles, a conferência e a medida do motion ficam pela metade, em silêncio
+    let olho = null;
+    try { olho = d.visao(); } catch { olho = false; }
+    if (olho === null) poe(null, 'Olho do vídeo', 'só no macOS: a conferência visual e o texto do gosto ficam de fora');
+    else poe(!!olho, 'Olho do vídeo', olho ? 'Vision do macOS' : 'sem o Vision do macOS',
+        'instale as ferramentas de linha de comando: xcode-select --install (sem elas, o vídeo pronto não é conferido por texto e rosto)');
+    let editor = false;
+    try { editor = d.editorPronto(); } catch { editor = false; }
+    poe(editor ? true : null, 'Editor de vídeo', editor ? 'Python do editor pronto' : 'ainda não instalado: nasce sozinho no 1º vídeo editado (uns minutos)');
+
     // Cursor (Python + PyObjC) — só existe no macOS
     if (d.plataforma !== 'darwin') {
         poe(null, 'Cursor do Primo', 'só no macOS');
@@ -320,7 +351,7 @@ async function diagnosticar(dep = {}) {
    plano — todo mundo que conversa com o modelo.
 
    Token exato só quando o provedor manda `usage`. Sem isso, a conta é a de
-   bolso: 4 caracteres ≈ 1 token. O /custo diz qual das duas está mostrando. */
+   bolso: 4 caracteres ≈ 1 token. O /usage diz qual das duas está mostrando. */
 function novoContador() { return { porProvedor: {}, desde: Date.now() }; }
 
 const tam = (x) => { try { return typeof x === 'string' ? x.length : JSON.stringify(x || '').length; } catch { return 0; } };
@@ -348,6 +379,7 @@ function medirEvento(b, evt) {
         b.tokEnviados += Number(u.prompt_tokens || u.input_tokens || 0);
         b.tokRecebidos += Number(u.completion_tokens || u.output_tokens || 0);
         b.exatos++;
+        b.tokEmCache = (b.tokEmCache || 0) + Number(u.cached_tokens || (u.prompt_tokens_details && u.prompt_tokens_details.cached_tokens) || u.cache_read_input_tokens || 0);
     }
 }
 
@@ -384,21 +416,57 @@ function instalarContador(api, cont, quemAtende) {
 /** As linhas do /custo: por provedor, e o total. */
 function resumoCusto(cont) {
     const linhas = [];
-    let total = { pedidos: 0, enviados: 0, recebidos: 0 };
+    let total = { pedidos: 0, enviados: 0, recebidos: 0, emCache: 0 };
     for (const [provedor, b] of Object.entries(cont.porProvedor)) {
         // Com `usage` em todos os pedidos, vale o número do provedor; senão a
         // estimativa inteira, para não somar exato com chute.
         const exato = b.exatos > 0 && b.exatos === b.pedidos;
         const enviados = exato ? b.tokEnviados : Math.ceil(b.charsEnviados / 4);
         const recebidos = exato ? b.tokRecebidos : Math.ceil(b.charsRecebidos / 4);
-        linhas.push({ provedor, pedidos: b.pedidos, enviados, recebidos, exato });
+        linhas.push({ provedor, pedidos: b.pedidos, enviados, recebidos, exato, emCache: exato ? (b.tokEmCache || 0) : 0 });
         total.pedidos += b.pedidos; total.enviados += enviados; total.recebidos += recebidos;
+        total.emCache += exato ? (b.tokEmCache || 0) : 0;
     }
     return { linhas, total };
 }
 
 function fmtNumero(n) { return Number(n || 0).toLocaleString('pt-BR'); }
 
+/* O /custo pra quem não sabe o que é token: em páginas (≈ 650 tokens numa
+   página de livro em português) e em quem paga. Pelo servidor, o plano cobre;
+   pela chave ou assinatura da pessoa (/api), quem cobra é o provedor dela. */
+const TOKENS_POR_PAGINA = 650;
+function paginas(tokens) {
+    const p = tokens / TOKENS_POR_PAGINA;
+    if (p < 1) return 'menos de 1 página';
+    const n = p < 10 ? Math.round(p) : Math.round(p / 5) * 5;
+    return `~${fmtNumero(n)} ${n === 1 ? 'página' : 'páginas'}`;
+}
+function resumoSimples({ linhas, total }) {
+    if (!linhas.length) return null;
+    const soServidor = linhas.every((l) => l.provedor === 'Servidor PrimoCode');
+    return {
+        frase: `${total.pedidos} ${total.pedidos === 1 ? 'pedido' : 'pedidos'} à IA · ela leu ${paginas(total.enviados)} e escreveu ${paginas(total.recebidos)}`,
+        quemPaga: soServidor ? 'Coberto pelo seu plano: nada a mais sai do seu bolso.'
+            : 'Parte foi pela sua chave ou assinatura (/api): esse uso aparece no painel do provedor.',
+    };
+}
+
+/* O custo de UM pedido, no fim dele: a diferença entre o contador antes e depois. A pesquisa de concorrentes
+   (brechas-2 #1): no Replit o preço só se sabe depois, e assusta. Aqui sai sempre, em páginas e em quem paga.
+   `antes` e `depois` são o que o resumoCusto devolve. Puro. */
+function custoDoPedido(antes, depois) {
+    const ant = new Map(((antes && antes.linhas) || []).map((l) => [l.provedor, l]));
+    const linhas = ((depois && depois.linhas) || []).map((l) => {
+        const a = ant.get(l.provedor) || { pedidos: 0, enviados: 0, recebidos: 0 };
+        return { provedor: l.provedor, pedidos: l.pedidos - a.pedidos, enviados: l.enviados - a.enviados, recebidos: l.recebidos - a.recebidos };
+    }).filter((l) => l.pedidos > 0);
+    if (!linhas.length) return null;
+    const total = linhas.reduce((s, l) => ({ pedidos: s.pedidos + l.pedidos, enviados: s.enviados + l.enviados, recebidos: s.recebidos + l.recebidos }), { pedidos: 0, enviados: 0, recebidos: 0 });
+    const r = resumoSimples({ linhas, total });
+    return `Este pedido: ${r.frase}. ${r.quemPaga.replace(/: nada a mais sai do seu bolso\./, ', nada a mais.')}`;
+}
+
 // ── /copiar ──────────────────────────────────────────────────────────────
 
 /* Quem copia em cada sistema. No Linux há dois mundos (Wayland e X11) e três
@@ -475,10 +543,11 @@ const ATALHOS = [
 ];
 
 module.exports = {
+    servidorAtrasado, custoDoPedido,
     fmtTamanho, quandoFoi, medirPasta, listarProjetos,
     nomeDoNovo, pedidoDoNovo,
     portasDoProjeto, sondarPorta, acharAlvoAbrir,
     diagnosticar, versaoMinima, espacoLivre,
-    novoContador, instalarContador, resumoCusto, fmtNumero,
+    novoContador, instalarContador, resumoCusto, resumoSimples, paginas, fmtNumero,
     copiar, copiadores, buscarHistorico, ATALHOS,
 };