primocode 10.19.0 → 11.0.0

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

@@ -379,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);
     }
 }
 
@@ -415,15 +416,16 @@ 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 };
 }

package/lib/editor-pro-maquina.js

@@ -0,0 +1,165 @@
+/* A máquina de vídeo do editor: entende cada frase, escolhe gancho e estilo pelo CONTEÚDO (e pela variante),
+   e confere o plano com uma régua numérica (criticar). Sem rede, sem Python: só texto e números.
+   Ver docs/rebuild/editor-maquina-arquitetura.md. */
+'use strict';
+
+const FRACAS = new Set('a o e é de da do das dos em no na nos nas um uma uns umas que para pra por com como eu você ele ela isso esse essa este esta hoje vou vai ou se mas'.split(' '));
+const NEGACAO = /\b(nunca|n[aã]o|ningu[eé]m|nada|jamais|zero|sem)\b/i;
+const NUMERO = /\d|\b(dobro|metade|triplo|mil|milh[aã]o|dez|cem|vinte|trinta)\b/i;
+const PROMESSA = /\b(como|jeito|segredo|passo|m[eé]todo|f[aá]cil|r[aá]pido|grátis|gr[aá]tis|consegui|descobri)\b/i;
+const URGENCIA = /\b(agora|hoje|[uú]ltim[ao]s?|acaba|corre|r[aá]pido|j[aá])\b/i;
+const EMOCAO_FORTE = /\b(erro|medo|perd[ei]|caro|problema|pior|absurdo|chocante|incr[ií]vel|louco|nunca|dobro|segredo)\b/i;
+
+const limpar = (l) => String(l || '').replace(/^[\d.]+-[\d.]+\s+/, '').trim();
+const tempos = (l) => { const m = /^([\d.]+)-([\d.]+)/.exec(String(l || '')); return m ? [Number(m[1]), Number(m[2])] : [null, null]; };
+
+/** O que cada frase quer: intenção, emoção, palavra-chave e energia (0 a 1). Tudo medido no texto. */
+function entenderFrases(fala) {
+    return (fala || []).map((linha, i) => {
+        const texto = limpar(linha);
+        const [t0, t1] = tempos(linha);
+        const palavras = texto.replace(/[.,!?;:]/g, '').split(/\s+/).filter(Boolean);
+        const fortes = palavras.filter((p) => !FRACAS.has(p.toLowerCase()) && (p.length > 2 || /\d/.test(p) || /^[A-ZÀ-Ú]{2}$/.test(p)));
+        const chave = fortes.slice().sort((a, b) => (NUMERO.test(b) - NUMERO.test(a)) || (b.length - a.length))[0] || null;
+        let intencao = 'afirma';
+        if (/\?\s*$/.test(texto)) intencao = 'pergunta';
+        else if (NUMERO.test(texto)) intencao = 'prova';
+        else if (NEGACAO.test(texto)) intencao = 'nega';
+        else if (PROMESSA.test(texto)) intencao = 'promete';
+        else if (URGENCIA.test(texto)) intencao = 'urge';
+        const energia = Math.min(1, 0.25 + (/!/.test(texto) ? 0.25 : 0) + (EMOCAO_FORTE.test(texto) ? 0.25 : 0) + (NUMERO.test(texto) ? 0.15 : 0) + (NEGACAO.test(texto) ? 0.1 : 0));
+        return { i, texto, t0, t1, palavras, fortes, chave, intencao, energia, emocao: energia >= 0.6 ? 'forte' : energia >= 0.4 ? 'media' : 'calma' };
+    }).filter((f) => f.texto);
+}
+
+const marcar = (ps, ult) => (ps.length ? ps.join(' ') + ' ' : '') + `*${ult}*`;
+
+/** Candidatos a gancho, de tipos DIFERENTES, tirados das primeiras frases (o gancho pode nascer de qualquer uma). */
+function ganchosCandidatos(fala) {
+    const frases = entenderFrases(fala);
+    const out = [];
+    const jaTem = new Set();
+    const por = (tipo, f, nota, fn) => {
+        if (!f || !f.fortes.length) return;
+        const texto = fn(f);
+        if (!texto || jaTem.has(texto.toLowerCase())) return;
+        jaTem.add(texto.toLowerCase());
+        out.push({ tipo, texto, de: f.i, nota });
+    };
+    for (const f of frases.slice(0, 6)) {
+        if (f.intencao === 'prova') por('numero', f, 3 + f.energia, (x) => { const c = x.fortes.find((p) => NUMERO.test(p)) || x.chave; const ix = x.fortes.indexOf(c); return marcar(x.fortes.slice(Math.max(0, ix - 2), ix), c); });
+        if (f.intencao === 'nega') por('negacao', f, 2.5 + f.energia, (x) => marcar(x.fortes.slice(-3, -1), x.fortes[x.fortes.length - 1]));
+        if (f.intencao === 'pergunta') por('pergunta', f, 2 + f.energia, (x) => marcar(x.fortes.slice(0, 3).slice(0, -1), x.fortes.slice(0, 3).slice(-1)[0]));
+        if (f.intencao === 'promete') por('promessa', f, 2 + f.energia, (x) => marcar(x.fortes.slice(0, 3), x.chave || x.fortes[x.fortes.length - 1]).replace(/\*\*/g, '*'));
+        if (f.intencao === 'urge') por('urgencia', f, 1.5 + f.energia, (x) => marcar(x.fortes.slice(-3, -1), x.fortes[x.fortes.length - 1]));
+    }
+    if (frases[0]) por('palavra-forte', frases[0], 1, (x) => { const fs = x.fortes.slice(-4); const u = fs.pop(); return marcar(fs, u); });
+    return out.sort((a, b) => b.nota - a.nota);
+}
+
+/** O gancho da variante `variante` (0 = o de maior nota; 1 = o próximo TIPO; e assim por diante, girando). */
+function escolherGancho(fala, variante = 0) {
+    const c = ganchosCandidatos(fala);
+    if (!c.length) return null;
+    return c[((variante % c.length) + c.length) % c.length].texto;
+}
+
+const hash = (s) => { let h = 2166136261; for (const ch of String(s)) { h ^= ch.charCodeAt(0); h = Math.imul(h, 16777619); } return h >>> 0; };
+
+/** O estilo vem da energia do que é dito, não de um padrão fixo: conteúdo forte pede escuro/laranja; calmo, limpo.
+    A variante gira entre os estilos que servem, e o mesmo roteiro sempre dá a mesma resposta (sem sorteio). */
+function escolherEstilo(fala, variante = 0) {
+    const fr = entenderFrases(fala);
+    const e = fr.length ? fr.reduce((s, f) => s + f.energia, 0) / fr.length : 0.3;
+    const ordem = e >= 0.55 ? ['laranja', 'noite', 'papelaria', 'limpo'] : e >= 0.38 ? ['noite', 'laranja', 'limpo', 'papelaria'] : ['limpo', 'papelaria', 'noite', 'laranja'];
+    const sal = hash(fr.map((f) => f.texto).join('|')) % 2;
+    return ordem[(variante + sal) % ordem.length];
+}
+
+// ── a régua (autocrítica) ────────────────────────────────────────────────
+
+const REGUA = {
+    parado_max_s: 3.0,            // nenhum trecho maior que isso sem mudança visual
+    tratamentos_min_por_min: 12,  // eventos visuais (peça, bloco, zoom) por minuto
+    tipos_distintos_min: 4,       // famílias de tratamento diferentes no vídeo
+    sfx_no_corte_s: 0.15,         // todo corte de bloco tem som a até 150 ms
+    sfx_min_por_min: 10,          // camadas de som por minuto
+    gancho_ate_s: 1.0,            // o gancho aparece no primeiro segundo
+    zooms_distintos_min: 3,       // escalas de enquadramento diferentes
+    legenda_sobre_rosto: 0,       // trechos com texto sobre o rosto
+};
+const POS_ROSTO = new Set(['centro', 'rosto', 'meio-rosto']);
+const num = (x) => (typeof x === 'number' && isFinite(x) ? x : null);
+
+/** Pontos do tempo em que a imagem muda: começo e fim de peça, bloco e zoom. */
+function mudancasVisuais(cfg, duracao) {
+    const pts = [0, duracao];
+    const tipos = new Set();
+    let eventos = 0;
+    for (const a of cfg.animacoes || []) {
+        const e = num(a.em) ?? num(a.depois_de); const s = num(a.sai);
+        if (e != null) { pts.push(e); eventos++; } if (s != null) pts.push(s);
+        tipos.add('anim:' + (a.tipo || '?'));
+    }
+    for (const b of cfg.blocos || []) {
+        const d = num(b.de); const t = num(b.ate);
+        if (d != null) { pts.push(d); eventos++; } if (t != null) pts.push(t);
+        tipos.add('bloco:' + (b.cena || '?'));
+        for (const z of b.zooms || []) { if (num(z.em) != null) { pts.push(z.em); eventos++; } if (num(z.ate) != null) pts.push(z.ate); tipos.add('punch'); }
+    }
+    return { pts: pts.filter((p) => p >= 0 && p <= duracao).sort((a, b) => a - b), tipos, eventos };
+}
+
+/** Dá nota (0 a 100) a um plano montado (o projeto.json) e devolve as falhas, cada uma com o número e o que fazer. */
+function criticar(cfg, { duracao } = {}, regua = REGUA) {
+    const dur = duracao || Math.max(0, ...(cfg.blocos || []).map((b) => num(b.ate) || 0), ...(cfg.animacoes || []).map((a) => num(a.sai) || 0));
+    const falhas = [];
+    const m = {};
+    if (!dur) return { nota: 0, falhas: [{ regra: 'duracao', valor: 0, limite: '>0', conserto: 'sem duração não há o que conferir' }], metricas: m };
+    const { pts, tipos, eventos } = mudancasVisuais(cfg, dur);
+    let parado = 0; let onde = 0;
+    for (let k = 1; k < pts.length; k++) if (pts[k] - pts[k - 1] > parado) { parado = pts[k] - pts[k - 1]; onde = pts[k - 1]; }
+    m.parado_max_s = Math.round(parado * 100) / 100;
+    if (parado > regua.parado_max_s) falhas.push({ regra: 'parado_max_s', valor: m.parado_max_s, limite: regua.parado_max_s, em: onde, conserto: `ponha peça, zoom ou b-roll a partir de ${onde.toFixed(1)} s` });
+    m.tratamentos_por_min = Math.round((eventos / dur) * 60 * 10) / 10;
+    if (m.tratamentos_por_min < regua.tratamentos_min_por_min) falhas.push({ regra: 'tratamentos_por_min', valor: m.tratamentos_por_min, limite: regua.tratamentos_min_por_min, conserto: 'mais mudanças de imagem ligadas ao que se diz' });
+    m.tipos_distintos = tipos.size;
+    if (tipos.size < regua.tipos_distintos_min) falhas.push({ regra: 'tipos_distintos', valor: tipos.size, limite: regua.tipos_distintos_min, conserto: 'misture famílias: lettering, moldura, contador, b-roll, punch' });
+    const sons = (cfg.sons || []).map((s) => num(s.em)).filter((x) => x != null);
+    m.sfx_por_min = Math.round((sons.length / dur) * 60 * 10) / 10;
+    if (m.sfx_por_min < regua.sfx_min_por_min) falhas.push({ regra: 'sfx_por_min', valor: m.sfx_por_min, limite: regua.sfx_min_por_min, conserto: 'rode o plano_sfx com --variar e mais camadas' });
+    const cortes = (cfg.blocos || []).map((b) => num(b.de)).filter((x) => x != null && x > 0.05);
+    const semSom = cortes.filter((c) => !sons.some((s) => Math.abs(s - c) <= regua.sfx_no_corte_s));
+    m.cortes_sem_som = semSom.length;
+    if (semSom.length) falhas.push({ regra: 'sfx_no_corte', valor: semSom.length, limite: 0, em: semSom[0], conserto: `som nos cortes: ${semSom.slice(0, 4).join(', ')} s` });
+    const g = (cfg.animacoes || []).find((a) => a.id === 'gancho' || a.tipo === 'lettering');
+    m.gancho_em_s = g ? num(g.em) : null;
+    if (!g || (num(g.em) ?? 99) > regua.gancho_ate_s) falhas.push({ regra: 'gancho_ate_s', valor: m.gancho_em_s, limite: regua.gancho_ate_s, conserto: 'o gancho entra no primeiro segundo' });
+    const escalas = new Set();
+    for (const b of cfg.blocos || []) { if (num(b.zoom) != null) escalas.add(b.zoom); for (const z of b.zooms || []) if (num(z.escala) != null) escalas.add(z.escala); }
+    m.zooms_distintos = escalas.size;
+    if (escalas.size < regua.zooms_distintos_min) falhas.push({ regra: 'zooms_distintos', valor: escalas.size, limite: regua.zooms_distintos_min, conserto: 'varie o enquadramento (mais de duas escalas)' });
+    const sobreRosto = (cfg.animacoes || []).filter((a) => POS_ROSTO.has(a.posicao) || a.cobre_rosto === true);
+    m.texto_sobre_rosto = sobreRosto.length;
+    if (sobreRosto.length > regua.legenda_sobre_rosto) falhas.push({ regra: 'texto_sobre_rosto', valor: sobreRosto.length, limite: regua.legenda_sobre_rosto, conserto: 'mova o texto para baixo do rosto ou ponha o rosto em moldura' });
+    const nota = Math.max(0, Math.round(100 - falhas.length * (100 / 8)));
+    return { nota, passou: falhas.length === 0, falhas, metricas: m };
+}
+
+/** Duas variantes não podem abrir igual nem ter o mesmo jeito (gancho, estilo e ritmo). */
+function compararVariantes(cfgs) {
+    const falhas = [];
+    const sig = (c) => {
+        const g = (c.animacoes || []).find((a) => a.id === 'gancho');
+        const t = (c.blocos || []).length;
+        return { gancho: g ? JSON.stringify(g.principal || g.texto || g.titulo || '').toLowerCase() : '', estilo: c.estilo || '', ritmo: Math.round(t / 3) };
+    };
+    const s = cfgs.map(sig);
+    for (let a = 0; a < s.length; a++) for (let b = a + 1; b < s.length; b++) {
+        if (s[a].gancho && s[a].gancho === s[b].gancho) falhas.push({ regra: 'mesmo_gancho', entre: [a, b], valor: s[a].gancho });
+        if (s[a].estilo === s[b].estilo && s[a].ritmo === s[b].ritmo) falhas.push({ regra: 'mesmo_estilo_e_ritmo', entre: [a, b], valor: `${s[a].estilo}/${s[a].ritmo}` });
+    }
+    return { passou: falhas.length === 0, falhas };
+}
+
+module.exports = { REGUA, entenderFrases, ganchosCandidatos, escolherGancho, escolherEstilo, criticar, compararVariantes, mudancasVisuais };

package/lib/editor-pro.js

@@ -45,6 +45,7 @@ const crypto = require('crypto');
 const { spawn, spawnSync } = require('child_process');
 
 const ORIGEM = path.join(__dirname, '..', 'editor');
+const MAQ = require('./editor-pro-maquina.js');
 const casa = () => process.env.PRIMOCODE_EDITOR_CASA || path.join(os.homedir(), '.primocode', 'editor');
 const venvDir = () => process.env.PRIMOCODE_EDITOR_VENV || path.join(os.homedir(), '.primocode', 'editor-venv');
 const WIN = process.platform === 'win32';
@@ -641,7 +642,7 @@ function aplicarPlano(cfg, plano, { fala, duracao, broll = [], marca = null }) {
     cfg.titulo = plano.titulo || cfg.titulo;
     cfg.formato = plano.formato || cfg.formato || '9:16';
     // limpo (a régua: chão claro, cartão branco, sem brilho) é o padrão; papelaria, noite e laranja continuam
-    cfg.estilo = plano.estilo || 'limpo';
+    cfg.estilo = plano.estilo || MAQ.escolherEstilo(fala, plano.variante || 0);
     // a legenda cinética é o padrão (Inter 800, palavra por palavra, a palavra-chave no degradê); padrao e discreta continuam
     cfg.legenda = Object.assign({ ligada: true, estilo: 'cinetica', max_palavras: 3, na_moldura: false }, cfg.legenda || {}, typeof plano.legenda === 'string' ? { estilo: plano.legenda } : (plano.legenda || {}));
     const pedida = typeof plano.legenda === 'string' ? plano.legenda : (plano.legenda && plano.legenda.estilo);
@@ -653,7 +654,7 @@ function aplicarPlano(cfg, plano, { fala, duracao, broll = [], marca = null }) {
     if (Array.isArray(grad) && grad.length >= 2) cfg.gradiente = grad.slice(0, 2);
     if (plano.correcoes) cfg.correcoes = Object.assign({}, cfg.correcoes || {}, plano.correcoes);
     const animacoes = [];
-    const gancho = plano.gancho === false ? null : (plano.gancho || ganchoAutomatico(fala));
+    const gancho = plano.gancho === false ? null : (plano.gancho || MAQ.escolherGancho(fala, plano.variante || 0) || ganchoAutomatico(fala));
     if (gancho) {
         const prim = fala[0] ? Number(fala[0].split('-')[0]) : 0;
         const fimFrase = fala[0] ? Number(fala[0].split(' ')[0].split('-')[1]) : 3;
@@ -817,11 +818,13 @@ async function montar(opts = {}, ctx = {}) {
         }
         await passo('montando a edição…', () => build(E, P.proj, ['completo']));
         if (plano.sons !== false) {
-            await passo('escolhendo os efeitos sonoros casados com cada animação…', () => helper(E, 'plano_sfx', ['--projeto', P.proj]));
+            await passo('escolhendo os efeitos sonoros casados com cada animação…', () => helper(E, 'plano_sfx', ['--projeto', P.proj, '--variar']));
             await passo('montando a edição com os sons…', () => build(E, P.proj, ['completo']));
         }
+        const critica = MAQ.criticar(lerJson(cfgPath, {}), { duracao: tl.duration || 0 });
+        for (const f of critica.falhas) avisosPlano.push(`régua: ${f.regra} = ${f.valor} (limite ${f.limite}): ${f.conserto}`);
         const lint = await build(E, P.proj, ['hf', 'lint']);
-        if (opts.render === false) return { ok: true, pasta: P.pasta, projeto: P.proj, lint: cauda(lint.saida, 6), broll, camera, avisos: avisosPlano };
+        if (opts.render === false) return { ok: true, pasta: P.pasta, projeto: P.proj, lint: cauda(lint.saida, 6), broll, camera, critica, avisos: avisosPlano };
         await passo('renderizando o vídeo (leva alguns minutos)…', () => build(E, P.proj, ['hf', 'render', '--quality', 'delivery', '--output', 'renders/final.mp4'], { timeout: 5400000 }));
         let final = path.join(P.proj, 'renders', 'final.mp4');
         // trilha: arquivo da pessoa, ou a busca do PrimoCode (energia alta), ou nenhuma
@@ -856,7 +859,7 @@ async function montar(opts = {}, ctx = {}) {
             ok: !!(rel && rel.passou), passou: !!(rel && rel.passou), video: saida, quadros: fotos,
             audio, portao: rel ? { passou: rel.passou, falhas: rel.falhas, modos: rel.modos_do_volume, clipadas: rel.amostras_clipadas, folha: rel.folha, leitor: rel.leitor_de_texto } : cauda(portao.saida),
             trilha: trilha ? { arquivo: trilha.arquivo, titulo: trilha.titulo, creditos: trilha.creditos } : null,
-            broll, avisos: avisosPlano, camera, projeto: P.proj, pasta: P.pasta,
+            broll, avisos: avisosPlano, camera, critica, projeto: P.proj, pasta: P.pasta,
             ...(rel && !rel.passou ? { error: 'o portão REPROVOU: ' + (rel.falhas || []).join(' | ') + ' — conserte no plano e chame montar de novo' } : {}),
         };
     } catch (e) {
@@ -882,7 +885,7 @@ const AJUDA = `editor_pro — edição completa de VÍDEO FALADO (motor EDIT IA
   acao "montar"  {pasta, plano?, trilha?}            gancho, peças, b-roll, câmera viva, sons, render, trilha com ducking, portão
   acao "preparar"                                    baixa os arquivos e cria o Python do editor (sem editar nada)
   acao "estado"  {pasta}                             onde a edição parou
-plano: {gancho:"Texto *destaque*", pecas:[peças do catálogo], broll:[{busca,de,ate,rotulo?}], moldura?, comparar?, blocos?, estilo?, legenda?, correcoes?, trilha?}
+plano: {gancho:"Texto *destaque*", pecas:[peças do catálogo], broll:[{busca,de,ate,rotulo?}], moldura?, comparar?, blocos?, estilo?, variante? (0,1,2…: outro gancho e outro estilo, pelo conteúdo), legenda?, correcoes?, trilha?}
 estilo: "limpo" (padrão: chão claro, cartão branco, sem brilho) | "laranja" | "noite" | "papelaria"
 moldura: [{de, ate, fundo?:"papel"|"desfocado"}]  a pessoa num quadro arredondado que flutua devagar sobre o chão
 comparar: [{de, ate, arranjo:"lado"|"empilhado"|"auto", a:{arquivo|"corte", inicio, rotulo}, b:{...}}]  dois vídeos na mesma escala, rótulo literal
@@ -923,5 +926,5 @@ module.exports = {
     ORIGEM, AJUDA, casa, venvDir, venvPython, impressao, instalarArquivos, garantirArquivo, garantirVenv, gerarSintetizados,
     dependencias, acharUv, acharPython, garantir, helper, cortar, montar, editar, ferramenta, main,
     limparTrechos, trechosDoModelo, ganchoAutomatico, pecasDasSugestoes, aplicarPlano, prepararPasta, falaCompacta, urlDoEspelho,
-    palavrasDoCorte, naOnda, limiaresDaOnda, resumoCamera, palavrasChave, gradienteDaMarca,
+    palavrasDoCorte, naOnda, limiaresDaOnda, resumoCamera, palavrasChave, gradienteDaMarca, maquina: MAQ,
 };

package/lib/entregaveis/cli.js

@@ -0,0 +1,26 @@
+#!/usr/bin/env node
+/**
+ * cli.js — a linha de comando que a skill e os especialistas chamam.
+ *   node lib/entregaveis/cli.js conferir plano.json
+ *   node lib/entregaveis/cli.js exportar plano.json [pasta] [--forcar] [--sem-pdf]
+ * Sai com 1 se a conferência reprova (ou se não exportou).
+ */
+'use strict';
+const fs = require('fs');
+const path = require('path');
+const slides = require('./slides');
+
+async function main(argv) {
+    const [cmd, arq, pasta] = argv.filter((a) => !a.startsWith('--'));
+    if (!['conferir', 'exportar'].includes(cmd) || !arq) { console.error('uso: cli.js conferir|exportar plano.json [pasta]'); return 2; }
+    let plano;
+    try { plano = JSON.parse(fs.readFileSync(arq, 'utf8')); } catch (e) { console.error('plano ilegível: ' + e.message); return 2; }
+    if (cmd === 'conferir') { const r = slides.conferirDeck(plano); console.log(slides.relatorio(r)); return r.passou ? 0 : 1; }
+    const r = await slides.exportarDeck(plano, path.resolve(pasta || path.dirname(arq)), { forcar: argv.includes('--forcar'), pdf: !argv.includes('--sem-pdf') });
+    console.log(slides.relatorio(r.conferencia));
+    if (!r.exportado) { console.log('NÃO exportou: conserte as falhas (ou --forcar).'); return 1; }
+    r.arquivos.forEach((a) => console.log('arquivo: ' + a));
+    if (r.erroPdf) console.log('sem PDF: ' + r.erroPdf);
+    return 0;
+}
+main(process.argv.slice(2)).then((c) => process.exit(c));

package/lib/entregaveis/especialistas.js

@@ -0,0 +1,50 @@
+/**
+ * especialistas.js (entregáveis) — quem faz cada parte do slide, do cartaz e do documento.
+ *
+ * Mesmo formato de lib/especialistas.js (faz + briefing curto que vai na frente da tarefa).
+ * Ficam separados de propósito: os nomes de lib/especialistas.js são um acordo com o enum
+ * do spawn_agent do servidor (test/especialistas.test.js), e aqui os papéis são de ofício
+ * de entregável. O briefing termina sempre em como PROVAR que acabou.
+ */
+'use strict';
+
+const NUCLEO = 'Conferência é código: rode `node lib/entregaveis/cli.js conferir plano.json` e só diga "pronto" com nota >= 80 e sem falha de bloqueio.';
+
+const ESPECIALISTAS_ENTREGAVEIS = {
+    roteirista: {
+        tipos: ['slides', 'documento', 'cartaz'],
+        faz: 'transforma o brief em estrutura: uma ideia por slide/seção, título que é afirmação',
+        briefing: `Você é o ROTEIRISTA. Parta do brief (tema, público, objetivo). Escreva primeiro a história em uma frase, depois a lista de slides com UMA afirmação cada (3 a 12 palavras, nunca "Visão geral"). O texto do slide é o que se lê de longe; o que se fala vai em "nota". Abra com capa, feche com ação concreta (campo "acao"). Cada número citado tem fonte [LI] ou vira "[VERIFICAR]". Prova: plano.json com slides e notas, sem conferência de texto ainda.`,
+    },
+    'diretor-de-arte': {
+        tipos: ['slides', 'cartaz', 'documento'],
+        faz: 'escolhe a direção visual a partir de material solto, nunca de modelo pronto',
+        briefing: `Você é o DIRETOR DE ARTE. NÃO use template: junte material solto (objetos, cores e textura do assunto; referências que o dono aprovou) e escreva a direção em "direcao": conceito (por que este visual é DESTE assunto, >= 6 palavras), paleta {fundo,texto,destaque,destaque2?,suave?} em hex, fonteTitulo, fonteCorpo (fonte que a outra máquina tem, ou a que será embutida no PDF). Título gigante em cor de destaque (degradê de texto ainda não sai no PDF). Todo elemento visual extra leva "visual.motivo": o que ele tem a ver com o conteúdo. Prova: contraste texto/fundo >= 4.5 calculado, não olhado.`,
+    },
+    tipografo: {
+        tipos: ['slides', 'cartaz', 'documento'],
+        faz: 'hierarquia, tamanhos e encaixe do texto',
+        briefing: `Você é o TIPÓGRAFO. Defina a escala (título 40-80pt, corpo >= 24pt em slide) e dê UM peso de destaque por slide. Encurte até o texto caber na caixa (a conferência estima o encaixe). Nada de três fontes. Prova: regras "tamanho-da-letra" e "encaixe" sem falha.`,
+    },
+    revisor: {
+        tipos: ['slides', 'cartaz', 'documento'],
+        faz: 'confere o resultado com os números e aponta; não reescreve',
+        briefing: `Você é o REVISOR e não fez este plano: aponte, não conserte. ${NUCLEO} Depois abra o PDF exportado e olhe de verdade 3 slides (capa, o mais cheio, o último): texto vazando, contraste, layout repetido. Liste falha por slide com o número. Prova: relatório da conferência + o que viu no PDF.`,
+    },
+};
+
+const NOMES = Object.keys(ESPECIALISTAS_ENTREGAVEIS);
+
+function porNome(nome) {
+    const n = String(nome || '').trim().toLowerCase().normalize('NFD').replace(/[̀-ͯ]/g, '').replace(/\s+/g, '-');
+    const mapa = { diretor: 'diretor-de-arte', arte: 'diretor-de-arte', designer: 'diretor-de-arte', roteiro: 'roteirista', tipografia: 'tipografo', review: 'revisor', reviewer: 'revisor' };
+    const k = mapa[n] || n;
+    return ESPECIALISTAS_ENTREGAVEIS[k] ? { nome: k, ...ESPECIALISTAS_ENTREGAVEIS[k] } : null;
+}
+
+/** A ordem em que os especialistas trabalham num tipo de entregável. */
+function equipe(tipo) {
+    return ['roteirista', 'diretor-de-arte', 'tipografo', 'revisor'].filter((n) => ESPECIALISTAS_ENTREGAVEIS[n].tipos.includes(tipo));
+}
+
+module.exports = { ESPECIALISTAS_ENTREGAVEIS, NOMES, porNome, equipe };