primocode 10.17.1 → 11.0.0

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';
@@ -383,14 +384,63 @@ function trechosDoModelo(trechos, fontes) {
     });
 }
 
-function falaCompacta(edit, max = 60) {
+const chaveTexto = (t) => String(t || '').normalize('NFD').replace(/[\u0300-\u036f]/g, '').toLowerCase().replace(/[^a-z0-9]/g, '');
+
+/**
+ * As palavras do corte com o começo MEDIDO NA ONDA (palavras_onda.json do helpers/palavras_na_onda.py): o Whisper
+ * adianta a palavra até 0,3 s, e a peça, o som e a legenda têm que cair NA palavra. Casa pela hora do Whisper e pelo
+ * texto (como o build.py); arquivo de outro corte (menos de 80% casadas) é ignorado e o tempo fica o do Whisper.
+ * { palavras: [{text, start, end, whisper}], tempos: 'onda'|'whisper'|null, limiar_db }
+ */
+function palavrasDoCorte(edit) {
     const tr = lerJson(path.join(edit, 'transcripts', 'cut.json'));
-    if (!tr || !Array.isArray(tr.words)) return [];
+    if (!tr || !Array.isArray(tr.words)) return { palavras: [], tempos: null };
+    const ws = tr.words.map((w) => ({ text: String(w.text || w.word || '').trim(), start: Number(w.start), end: Number(w.end) }))
+        .filter((w) => w.text && Number.isFinite(w.start));
+    const po = lerJson(path.join(edit, 'palavras_onda.json'));
+    const lista = po && Array.isArray(po.palavras) ? po.palavras : [];
+    if (!lista.length) return { palavras: ws, tempos: 'whisper' };
+    const porHora = new Map();
+    for (const r of lista) {
+        const k = Math.round(Number(r.whisper) * 100);
+        if (Number.isFinite(k)) porHora.set(k, [...(porHora.get(k) || []), r]);
+    }
+    let casadas = 0;
+    const novas = ws.map((w) => {
+        const k = Math.round(w.start * 100);
+        const r = [k, k - 1, k + 1].flatMap((x) => porHora.get(x) || [])
+            .find((x) => Math.abs(Number(x.whisper) - w.start) < 0.011 && chaveTexto(x.text) === chaveTexto(w.text));
+        if (!r) return { ...w, whisper: w.start };
+        casadas++;
+        const s = Number(r.start);
+        if (!Number.isFinite(s) || Math.abs(s - w.start) > 0.45) return { ...w, whisper: w.start };
+        return { text: w.text, start: r3(s), end: r3(Math.max(w.end, s + 0.05)), whisper: w.start };
+    });
+    if (casadas < 0.8 * ws.length) return { palavras: ws.map((w) => ({ ...w, whisper: w.start })), tempos: 'whisper', aviso: 'palavras_onda.json é de outro corte: tempos do Whisper' };
+    return { palavras: novas, tempos: 'onda', limiar_db: Number(po.limiar_db) };
+}
+
+/** Um tempo do Whisper (das sugestões do motion_sugerir) levado ao começo medido na onda da palavra que começa ali. */
+function naOnda(palavras) {
+    return (t) => {
+        if (typeof t !== 'number') return t;
+        let melhor = null;
+        for (const w of palavras || []) {
+            const d = Math.abs(w.whisper - t);
+            if (d <= 0.03 && (!melhor || d < melhor.d)) melhor = { d, w };
+        }
+        return melhor ? r3(t + (melhor.w.start - melhor.w.whisper)) : t;
+    };
+}
+
+/** A fala em linhas "de-fim texto" com o começo de cada linha NA ONDA: é com esses tempos que o modelo escreve o plano. */
+function falaCompacta(edit, max = 60) {
+    const { palavras } = palavrasDoCorte(edit);
+    if (!palavras.length) return [];
     const linhas = [];
     let atual = null;
-    for (const w of tr.words) {
-        const txt = String(w.text || w.word || '').trim();
-        if (!txt) continue;
+    for (const w of palavras) {
+        const txt = w.text;
         if (!atual || w.start - atual.fim > 0.6 || atual.palavras >= 12) {
             if (atual) linhas.push(atual);
             atual = { de: w.start, fim: w.end, texto: txt, palavras: 1 };
@@ -401,6 +451,15 @@ function falaCompacta(edit, max = 60) {
     return linhas.slice(0, max).map((l) => `${l.de.toFixed(2)}-${l.fim.toFixed(2)} ${l.texto}`);
 }
 
+/** O que o corte_por_onda mediu em cada fonte: o limiar de pausa sai do chão de ruído e da voz, não de um número fixo. */
+function limiaresDaOnda(saida) {
+    const out = [];
+    for (const m of String(saida || '').matchAll(/^(.+?): chão (-?\d+) dB, fala forte (-?\d+) dB, pausa abaixo de (-?\d+) dB/gm)) {
+        out.push({ fonte: m[1].trim(), chao_db: Number(m[2]), fala_db: Number(m[3]), limiar_db: Number(m[4]) });
+    }
+    return out;
+}
+
 async function respirosDe(E, video) {
     const r = await helper(E, 'respiros', [video, '--json']);
     try { return JSON.parse(r.saida.slice(r.saida.indexOf('{'), r.saida.lastIndexOf('}') + 1)); } catch { return null; }
@@ -458,8 +517,10 @@ async function cortar(opts = {}, ctx = {}) {
         // respiro é erro: corta pela onda e confere; se sobrou, sobe o limiar (no máximo 3 voltas)
         let limiar = null;
         let resp = null;
+        let onda = [];
         for (let volta = 0; volta < 4; volta++) {
-            await passo(volta ? `sobrou respiro: cortando de novo pela onda (limiar ${limiar} dB)…` : 'tirando os respiros pela onda do áudio…', 'corte_por_onda', [manual, '-o', path.join(P.edit, 'edl.json'), ...(limiar != null ? ['--limiar', limiar] : [])]);
+            const co = await passo(volta ? `sobrou respiro: cortando de novo pela onda (limiar ${limiar} dB)…` : 'tirando os respiros pela onda do áudio…', 'corte_por_onda', [manual, '-o', path.join(P.edit, 'edl.json'), ...(limiar != null ? ['--limiar', limiar] : [])]);
+            onda = limiaresDaOnda(co.saida);
             await passo('renderizando o corte…', 'render_cut', [path.join(P.edit, 'edl.json')]);
             resp = await respirosDe(E, path.join(P.edit, 'cut.mp4'));
             if (!resp || !resp.respiros || !resp.respiros.length || volta === 3) break;
@@ -478,6 +539,7 @@ async function cortar(opts = {}, ctx = {}) {
         await passo('medindo o tempo de cada palavra na onda…', 'palavras_na_onda', [P.edit]);
         const tl = lerJson(path.join(P.edit, 'cut_timeline.json'), {});
         const vl = lerJson(path.join(P.edit, 'verify', 'voz_limpa.json'), {});
+        const pc = palavrasDoCorte(P.edit);
         const estado = { fontes: P.fontes, cortado_em: new Date().toISOString(), duracao: tl.duration };
         gravarJson(path.join(P.edit, 'primocode.json'), estado);
         return {
@@ -485,6 +547,8 @@ async function cortar(opts = {}, ctx = {}) {
             duracao: r3(tl.duration || 0), trechos: (lerJson(path.join(P.edit, 'edl.json'), {}).ranges || []).length,
             volume: { ganho_base_db: ganho && ganho.ganho_base_db, voz_antes_lufs: ganho && ganho.referencia_lufs, ajuste: tl.loudnorm_modo, voz_limpa: (vl.relatorio || {}).loudnorm_modo || null },
             respiros: resp ? (resp.respiros || []).length : null,
+            // o limiar de pausa de cada fonte (chão de ruído + folga, abaixo da voz) e de onde vêm os tempos da fala
+            onda, tempos: pc.tempos, palavras_movidas: pc.palavras.filter((w) => Math.abs(w.start - w.whisper) >= 0.05).length,
             fala: falaCompacta(P.edit),
             proximo: 'escreva o plano (gancho, pecas, broll) com os tempos da fala e chame acao:"montar" com a mesma pasta',
         };
@@ -507,6 +571,43 @@ function ganchoAutomatico(fala) {
     return (fortes.length ? fortes.join(' ') + ' ' : '') + `*${ult}*`;
 }
 
+const NAO_CHAVE = new Set('fica ficar assim aqui coisa muito mais sobre então porque quando depois antes também isso esse essa está estou tenho fazer faz'.split(' '));
+const ENFASE = new Set('nunca zero nada ninguém todos todas tudo sempre grátis sozinho pronto agora rápido erro segredo dobro metade'.split(' '));
+
+/**
+ * As palavras-chave DESTE vídeo (as que a legenda cinética pinta no degradê): o que a fala repete, número, palavra de
+ * ênfase e palavra longa, nessa ordem. Cada vídeo tem as suas, e o modelo pode trocar (plano.legenda.chaves).
+ */
+function palavrasChave(fala, max = null) {
+    const conta = new Map();
+    const ordem = [];
+    for (const linha of fala || []) {
+        for (const cru of String(linha).replace(/^[\d.]+-[\d.]+\s+/, '').split(/\s+/)) {
+            const w = cru.replace(/^[^\p{L}\p{N}$]+|[^\p{L}\p{N}%]+$/gu, '');
+            const k = w.toLowerCase();
+            if (!k || PALAVRAS_FRACAS.has(k) || NAO_CHAVE.has(k) || (k.length < 4 && !/\d/.test(k))) continue;
+            if (!conta.has(k)) { conta.set(k, 0); ordem.push(k); }
+            conta.set(k, conta.get(k) + 1);
+        }
+    }
+    const nota = (k) => 2 * (conta.get(k) - 1) + (/\d/.test(k) ? 3 : 0) + (ENFASE.has(k) ? 2 : 0) + (k.length >= 7 ? 1 : 0);
+    const total = [...conta.values()].reduce((a, b) => a + b, 0);
+    const n = max || Math.max(3, Math.min(12, Math.round(total / 6)));
+    return ordem.map((k, i) => ({ k, i, n: nota(k) })).filter((x) => x.n > 0)
+        .sort((a, b) => b.n - a.n || a.i - b.i).slice(0, n).map((x) => x.k);
+}
+
+/** O degradê da marca: destaque → apoio do kit /marca ativo; sem kit, o build usa o rosa → violeta. */
+function gradienteDaMarca(pastas, marcaKit = require('./marca-kit.js')) {
+    try {
+        const k = marcaKit.ativa(pastas);
+        const c = (k && k.cores) || {};
+        const a = marcaKit.normHex(c.destaque);
+        const b = marcaKit.normHex(c.apoio) || marcaKit.normHex(c.tinta);
+        return a && b && a !== b ? [a, b] : null;
+    } catch { return null; }
+}
+
 function encurtar(texto, max = 22) {
     const ps = String(texto).split(/\s+/);
     let out = '';
@@ -515,11 +616,13 @@ function encurtar(texto, max = 22) {
 }
 
 /** As sugestões do motion_sugerir (fala → peça) no formato do catálogo do projeto HyperFrames. */
-function pecasDasSugestoes(motion) {
+function pecasDasSugestoes(motion, ajuste = (t) => t) {
     const out = [];
-    for (const [i, m] of (motion || []).entries()) {
+    for (let [i, m] of (motion || []).entries()) {
         const p = m.params || {};
-        const t = (k) => r3(m.start + ((p.times || [])[k] || 0));
+        const ini = m.start;                       // tempo do Whisper: cada item vai para a onda da palavra dele
+        const t = (k) => r3(ajuste(ini + ((p.times || [])[k] || 0)));
+        m = { ...m, start: ajuste(ini) };
         if ((m.template === 'checklist' || m.template === 'riscado') && Array.isArray(p.items) && p.items.length >= 2) {
             out.push({ id: 'lista' + i, tipo: 'lista_check', titulo: p.title || undefined, marca: m.template === 'riscado' ? 'x' : 'check', depois_de: r3(m.start - 0.1), sai: r3(m.end), itens: p.items.slice(0, 5).map((it, k) => ({ texto: encurtar(it), em: t(k) })) });
         } else if (m.template === 'passos' && Array.isArray(p.items) && p.items.length >= 2) {
@@ -535,19 +638,29 @@ const PECA_GRANDE = new Set(['lista_check', 'passo_a_passo', 'notificacao', 'pol
 const tempoNum = (x) => (typeof x === 'number' ? x : null);
 
 /** Monta o projeto.json a partir do plano (do modelo ou automático). */
-function aplicarPlano(cfg, plano, { fala, duracao, broll = [] }) {
+function aplicarPlano(cfg, plano, { fala, duracao, broll = [], marca = null }) {
     cfg.titulo = plano.titulo || cfg.titulo;
     cfg.formato = plano.formato || cfg.formato || '9:16';
-    cfg.estilo = plano.estilo || 'laranja';
-    cfg.legenda = Object.assign({ ligada: true, estilo: 'padrao', max_palavras: 3, na_moldura: false }, cfg.legenda || {}, typeof plano.legenda === 'string' ? { estilo: plano.legenda } : (plano.legenda || {}));
+    // limpo (a régua: chão claro, cartão branco, sem brilho) é o padrão; papelaria, noite e laranja continuam
+    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);
+    if (!pedida) cfg.legenda.estilo = 'cinetica';           // o 'padrao' do projeto novo não é escolha de ninguém
+    cfg.legenda.max_palavras = Math.min(3, Number(cfg.legenda.max_palavras) || 3);
+    // as chaves são do vídeo: o modelo escolhe (plano.legenda.chaves) ou saem da fala, de novo a cada montar
+    cfg.legenda.chaves = plano.legenda && Array.isArray(plano.legenda.chaves) ? plano.legenda.chaves : palavrasChave(fala);
+    const grad = plano.gradiente || marca;
+    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;
         const g = typeof gancho === 'object' ? gancho : { principal: gancho };
-        animacoes.push(Object.assign({ id: 'gancho', tipo: 'lettering', em: r3(Math.max(0, prim)), sai: r3(Math.min(Math.max(fimFrase, prim + 2.2), prim + 4.5)), posicao: 'topo', estilo: 'bloco' }, g));
+        // o título cinético vai embaixo do rosto, onde cabe gigante (no topo a cabeça encolhia a letra)
+        animacoes.push(Object.assign({ id: 'gancho', tipo: 'lettering', em: r3(Math.max(0, prim)), sai: r3(Math.min(Math.max(fimFrase, prim + 2.2), prim + 4.5)), posicao: cfg.legenda.estilo === 'cinetica' ? 'base' : 'topo', estilo: cfg.legenda.estilo === 'cinetica' ? 'cinetico' : 'bloco' }, g));
     }
     for (const p of plano.pecas || []) animacoes.push(p);
     cfg.animacoes = animacoes;
@@ -557,12 +670,21 @@ function aplicarPlano(cfg, plano, { fala, duracao, broll = [] }) {
     if (!Array.isArray(plano.blocos)) {
         const vagos = [];
         for (const b of broll) vagos.push(b);
+        // o chão da moldura: no limpo, o papel claro do estilo (a pessoa num quadro arredondado); nos outros, o vídeo desfocado
+        const chao = cfg.estilo === 'limpo' ? 'papel' : 'desfocado';
+        for (const m of [].concat(plano.moldura || [])) {
+            if (m && tempoNum(m.de) != null && tempoNum(m.ate) != null) vagos.push({ cena: 'moldura', de: m.de, ate: m.ate, fundo: m.fundo || chao, ...(m.flutua === false ? { flutua: false } : {}) });
+        }
+        for (const c of [].concat(plano.comparar || [])) {
+            if (!c || tempoNum(c.de) == null || tempoNum(c.ate) == null || !c.a || !c.b) continue;
+            vagos.push({ cena: 'comparar', de: c.de, ate: c.ate, modo: c.modo || 'lado_a_lado', arranjo: c.arranjo || 'auto', som: c.som || 'voz', a: c.a, b: c.b });
+        }
         for (const a of animacoes) {
             if (!PECA_GRANDE.has(a.tipo)) continue;
             const de = tempoNum(a.depois_de) ?? tempoNum(a.em);
             const ate = tempoNum(a.sai);
             if (de == null || ate == null || ate - de < 2) continue;
-            vagos.push({ cena: 'moldura', de: r3(Math.max(0, de - 0.15)), ate: r3(Math.min(duracao, ate + 0.25)), fundo: 'desfocado' });
+            vagos.push({ cena: 'moldura', de: r3(Math.max(0, de - 0.15)), ate: r3(Math.min(duracao, ate + 0.25)), fundo: chao });
         }
         vagos.sort((a, b) => a.de - b.de);
         for (const b0 of vagos) {
@@ -633,6 +755,15 @@ function medirAudio(video) {
     return { lufs: num(/I:\s+(-?[\d.]+)\s+LUFS/), pico_dbtp: num(/Peak:\s+(-?[\d.]+)\s+dBFS/), hz: Number(String(p.stdout).trim()) || null };
 }
 
+/** O que a câmera viva fez (a última linha JSON do camera_viva.py --json): aproximações, derivas e onde ficou parada. */
+function resumoCamera(saida) {
+    const linha = String(saida || '').trim().split('\n').reverse().find((l) => l.trim().startsWith('{'));
+    let r = null;
+    try { r = JSON.parse(linha); } catch { return null; }
+    return { aproximacoes: (r.punches || []).map((p) => ({ em: p.em, palavra: p.palavra })), derivas: r.derivas || 0,
+        maior_parado_s: r.maior_intervalo, parados: Array.isArray(r.parados) ? r.parados : [] };
+}
+
 /**
  * A montagem. opts: { pasta, plano, trilha ('auto' | arquivo | false), render (true) }.
  */
@@ -655,19 +786,19 @@ async function montar(opts = {}, ctx = {}) {
     };
     try {
         if (!fs.existsSync(path.join(P.proj, 'projeto.json'))) {
-            await passo('criando o projeto da edição…', () => correr(E.python, [path.join(E.destino, 'modelo-projeto', 'build.py'), 'novo', P.proj, '--edit', P.edit, '--estilo', plano.estilo || 'laranja'], { cwd: path.join(E.destino, 'modelo-projeto'), env: ambiente(E.destino, E.python) }).then((r) => ({ ok: r.code === 0, saida: r.saida })));
+            await passo('criando o projeto da edição…', () => correr(E.python, [path.join(E.destino, 'modelo-projeto', 'build.py'), 'novo', P.proj, '--edit', P.edit, '--estilo', plano.estilo || 'limpo'], { cwd: path.join(E.destino, 'modelo-projeto'), env: ambiente(E.destino, E.python) }).then((r) => ({ ok: r.code === 0, saida: r.saida })));
         }
         const fala = falaCompacta(P.edit, 400);
         const tl = lerJson(path.join(P.edit, 'cut_timeline.json'), {});
         let pecasAuto = [];
         if (!Array.isArray(plano.pecas)) {
             const s = await helper(E, 'motion_sugerir', ['--edit-dir', P.edit, '--json']);
-            try { pecasAuto = pecasDasSugestoes(JSON.parse(s.saida.trim().split('\n').pop()).motion); } catch { pecasAuto = []; }
+            try { pecasAuto = pecasDasSugestoes(JSON.parse(s.saida.trim().split('\n').pop()).motion, naOnda(palavrasDoCorte(P.edit).palavras)); } catch { pecasAuto = []; }
         }
         const broll = await buscarBroll(E, P, plano.broll, ctx);
         const cfgPath = path.join(P.proj, 'projeto.json');
         const cfg = lerJson(cfgPath, {});
-        aplicarPlano(cfg, { ...plano, pecas: Array.isArray(plano.pecas) ? plano.pecas : pecasAuto }, { fala, duracao: tl.duration || 0, broll: broll.filter((b) => b.ok).map((b) => b.bloco) });
+        aplicarPlano(cfg, { ...plano, pecas: Array.isArray(plano.pecas) ? plano.pecas : pecasAuto }, { fala, duracao: tl.duration || 0, broll: broll.filter((b) => b.ok).map((b) => b.bloco), marca: gradienteDaMarca([P.pasta, ctx.projectDir]) });
         if (Array.isArray(plano.blocos)) for (const b of broll) if (b.ok) cfg.blocos.push(b.bloco);
         cfg.blocos.sort((a, b) => (tempoNum(a.de) ?? 0) - (tempoNum(b.de) ?? 0));
         cfg.sons = [];
@@ -679,14 +810,21 @@ async function montar(opts = {}, ctx = {}) {
                 await passo(`recortando você do fundo de ${Number(b.de).toFixed(1)} s a ${Number(b.ate).toFixed(1)} s (uns minutos)…`, () => correr(E.python, [path.join(P.proj, 'ferramentas', 'pessoa_recortada.py'), '--edit', P.edit, '--de', Math.max(0, b.de - 0.5).toFixed(2), '--ate', (Number(b.ate) + 0.5).toFixed(2)], { cwd: P.proj, env: ambiente(E.destino, E.python), timeout: 3600000 }).then((r) => ({ ok: r.code === 0, saida: r.saida })));
             }
         }
-        if (plano.camera_viva !== false) await passo('pondo a câmera viva (zoom por frase e aproximação na ênfase)…', () => helper(E, 'camera_viva', [P.proj]));
+        let camera = null;
+        if (plano.camera_viva !== false) {
+            const cv = await passo('pondo a câmera viva (zoom por frase, aproximação na ênfase, deriva lenta no resto)…', () => helper(E, 'camera_viva', [P.proj, '--json']));
+            camera = resumoCamera(cv.saida);
+            for (const [de, ate] of (camera && camera.parados) || []) avisosPlano.push(`câmera parada de ${de} a ${ate} s (${(ate - de).toFixed(1)} s): ponha uma peça, um b-roll ou uma moldura nesse trecho`);
+        }
         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 };
+        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
@@ -721,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, 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) {
@@ -747,7 +885,12 @@ 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?}], 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
+legenda: "cinetica" (padrão: Inter 800, palavra por palavra, a palavra-chave no degradê) | "padrao" | "discreta";
+  {estilo, chaves:["palavra",...]} troca as palavras-chave (sem chaves, saem da fala); gradiente:["#rrggbb","#rrggbb"] (padrão: o kit /marca)`;
 
 async function ferramenta(args = {}, ctx = {}) {
     const acao = String(args.acao || 'editar');
@@ -783,4 +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, maquina: MAQ,
 };

package/lib/encolheu.js

@@ -0,0 +1,33 @@
+/**
+ * encolheu.js — o alarme do arquivo que a IA encolheu sem avisar.
+ *
+ *   julgar(antes, depois) → null | { texto }      (puro)
+ *
+ * A queixa nº 1 do fórum do Cursor ("cursor wiped most of the application code"): o modelo reescreve o arquivo
+ * inteiro e devolve metade, ou troca um bloco por "// rest of your code here". Quem não programa não percebe até
+ * o app quebrar. Aqui, depois de cada write_file/edit_file, compara o antes e o depois: encolheu muito, ou nasceu um
+ * marcador de "resto do código", avisa a pessoa (com o /desfazer) e o modelo (pra ele conferir o que cortou).
+ * Arquivo novo não conta, e arquivo pequeno também não: diminuir um de 10 linhas é edição normal.
+ */
+
+'use strict';
+
+const MIN_LINHAS = 30;        // abaixo disso, encolher é editar
+const SOBRA_MINIMA = 0.6;     // ficou com menos de 60% das linhas: encolheu demais
+const MARCADOR = /(rest of (your|the) (code|file)|existing code (here|remains|unchanged)|\.\.\. ?(existing|rest|previous) code|resto do (código|arquivo)|código (anterior|existente) (aqui|continua)|(\/\/|#|<!--) ?\.\.\. ?$)/im;
+
+const linhas = (t) => (t ? String(t).split('\n').length : 0);
+
+function julgar(antes, depois) {
+    if (antes == null || depois == null) return null;
+    const a = linhas(antes), d = linhas(depois);
+    if (MARCADOR.test(depois) && !MARCADOR.test(antes)) {
+        return { texto: `apareceu um "resto do código aqui" no lugar de código de verdade (${a} → ${d} linhas)` };
+    }
+    if (a >= MIN_LINHAS && d < a * SOBRA_MINIMA) {
+        return { texto: `encolheu de ${a} para ${d} linhas` };
+    }
+    return null;
+}
+
+module.exports = { julgar, MIN_LINHAS, SOBRA_MINIMA, MARCADOR };

package/lib/entrada.js

@@ -482,7 +482,7 @@ class Entrada extends EventEmitter {
        conversa, mas tirava do terminal o clique-e-arrasta: ninguém conseguia
        selecionar um trecho da resposta para copiar ("na CLI não consigo
        selecionar texto", 11/10). Selecionar vale mais que a roda: rolar fica
-       no PgUp/PgDn, e o /copiar copia a resposta inteira. */
+       no PgUp/PgDn, e o /copy copia a resposta inteira. */
     _entrarNaTela() {
         if (this._naTela) return;
         this._naTela = true;

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

package/lib/entregaveis/nucleo.js

@@ -0,0 +1,111 @@
+/**
+ * nucleo.js — a parte que slides, cartaz e documento dividem.
+ *
+ *   brief → direção de arte → conferência numérica → exportação
+ *
+ * Nada aqui sabe de "slide": só cor, texto, contagem e o corredor de checagem.
+ * Cada tipo de entregável (slides.js, depois cartaz.js e documento.js) entrega
+ * ao `conferir` uma lista de REGRAS, e recebe de volta { nota, falhas }.
+ * Sem modelo, sem rede: tudo é número que dá para testar.
+ */
+'use strict';
+
+/** Palavras de um texto (hífen e apóstrofo ficam dentro da palavra). */
+function palavras(t) {
+    return (String(t || '').match(/[\p{L}\p{N}][\p{L}\p{N}'’-]*/gu) || []).length;
+}
+
+function hex(h) {
+    const m = /^#?([0-9a-f]{6}|[0-9a-f]{3})$/i.exec(String(h || '').trim());
+    if (!m) return null;
+    let s = m[1];
+    if (s.length === 3) s = s.split('').map((c) => c + c).join('');
+    return [0, 2, 4].map((i) => parseInt(s.slice(i, i + 2), 16));
+}
+
+/** Luminância relativa WCAG 2.x. */
+function luminancia(h) {
+    const rgb = hex(h);
+    if (!rgb) return null;
+    const [r, g, b] = rgb.map((v) => { v /= 255; return v <= 0.03928 ? v / 12.92 : ((v + 0.055) / 1.055) ** 2.4; });
+    return 0.2126 * r + 0.7152 * g + 0.0722 * b;
+}
+
+/** Razão de contraste WCAG (1 a 21). null se uma das cores não for hex. */
+function contraste(a, b) {
+    const la = luminancia(a); const lb = luminancia(b);
+    if (la == null || lb == null) return null;
+    const [claro, escuro] = la >= lb ? [la, lb] : [lb, la];
+    return (claro + 0.05) / (escuro + 0.05);
+}
+
+/** O brief mínimo: sem tema e sem público não há o que desenhar. Devolve { ok, faltam }. */
+function conferirBrief(brief) {
+    const b = brief || {};
+    const faltam = ['tema', 'publico', 'objetivo'].filter((k) => !String(b[k] || '').trim());
+    return { ok: faltam.length === 0, faltam };
+}
+
+/**
+ * Direção de arte escolhida pela IA a partir de material solto, não de modelo pronto.
+ * A direção válida tem: conceito (a ideia visual, ligada ao assunto), paleta com
+ * fundo/texto/destaque, e duas fontes. Aqui só se confere; quem escolhe é o modelo.
+ */
+function conferirDirecao(d) {
+    const falhas = [];
+    const x = d || {};
+    if (palavras(x.conceito) < 6) falhas.push({ regra: 'direcao-conceito', msg: 'conceito visual com menos de 6 palavras: diga por que este visual é DESTE assunto' });
+    const p = x.paleta || {};
+    for (const k of ['fundo', 'texto', 'destaque']) if (!hex(p[k])) falhas.push({ regra: 'direcao-paleta', msg: `paleta.${k} não é cor hex` });
+    if (!x.fonteTitulo || !x.fonteCorpo) falhas.push({ regra: 'direcao-fontes', msg: 'faltam fonteTitulo e fonteCorpo' });
+    const c = contraste(p.texto, p.fundo);
+    if (c != null && c < 4.5) falhas.push({ regra: 'contraste', msg: `texto sobre fundo: contraste ${c.toFixed(2)} < 4.5` });
+    const cd = contraste(p.destaque, p.fundo);
+    if (cd != null && cd < 3) falhas.push({ regra: 'contraste-destaque', msg: `destaque sobre fundo: contraste ${cd.toFixed(2)} < 3 (texto grande)` });
+    return falhas;
+}
+
+/**
+ * O corredor de checagem. `regras` é uma lista de { id, peso, testa(alvo) → falhas[] }.
+ * Nota = 100 menos o peso de cada regra que falhou; passa quando nenhuma regra de
+ * peso 'bloqueia' falha e a nota é >= minimo.
+ */
+function conferir(alvo, regras, { minimo = 80 } = {}) {
+    const falhas = [];
+    let nota = 100;
+    for (const r of regras) {
+        const f = r.testa(alvo) || [];
+        if (f.length) {
+            nota -= r.peso;
+            for (const item of f) falhas.push({ regra: r.id, ...item });
+        }
+    }
+    nota = Math.max(0, nota);
+    const bloqueia = regras.some((r) => r.bloqueia && falhas.some((f) => f.regra === r.id));
+    return { nota, falhas, passou: !bloqueia && nota >= minimo };
+}
+
+/** Slug de arquivo: afirmação curta vira nome seguro. */
+function slug(t) {
+    return String(t || 'entrega').normalize('NFD').replace(/[̀-ͯ]/g, '').toLowerCase()
+        .replace(/[^a-z0-9]+/g, '-').replace(/^-+|-+$/g, '').slice(0, 60) || 'entrega';
+}
+
+/** O caminho do Chrome/Chromium para imprimir PDF, ou null. */
+function acharNavegador(env = process.env, existe = require('fs').existsSync) {
+    const lista = [env.PRIMO_CHROME, '/Applications/Google Chrome.app/Contents/MacOS/Google Chrome',
+        '/Applications/Chromium.app/Contents/MacOS/Chromium', '/usr/bin/google-chrome', '/usr/bin/chromium',
+        '/usr/bin/chromium-browser', 'C:\\Program Files\\Google\\Chrome\\Application\\chrome.exe'];
+    return lista.find((c) => c && existe(c)) || null;
+}
+
+/** HTML → PDF com o Chrome sem cabeça. Devolve { ok, erro }. */
+function htmlParaPdf(htmlPath, pdfPath, { navegador = acharNavegador() } = {}) {
+    if (!navegador) return { ok: false, erro: 'Chrome/Chromium não encontrado (defina PRIMO_CHROME)' };
+    const { spawnSync } = require('child_process');
+    const r = spawnSync(navegador, ['--headless=new', '--disable-gpu', '--no-pdf-header-footer',
+        `--print-to-pdf=${pdfPath}`, 'file://' + htmlPath], { encoding: 'utf8', timeout: 90000 });
+    return require('fs').existsSync(pdfPath) ? { ok: true } : { ok: false, erro: (r.stderr || '').slice(-300) || 'PDF não saiu' };
+}
+
+module.exports = { palavras, hex, luminancia, contraste, conferirBrief, conferirDirecao, conferir, slug, acharNavegador, htmlParaPdf };