primocode 10.17.1 → 10.19.0

package/lib/editor-pro.js

@@ -383,14 +383,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 +450,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 +516,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 +538,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 +546,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 +570,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 +615,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,11 +637,20 @@ 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 || 'limpo';
+    // 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));
@@ -547,7 +658,8 @@ function aplicarPlano(cfg, plano, { fala, duracao, broll = [] }) {
         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 +669,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 +754,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 +785,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 +809,19 @@ 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('montando a edição com os sons…', () => build(E, P.proj, ['completo']));
         }
         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, 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 +856,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, 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 +882,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?, 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 +923,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,
 };

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.js

@@ -0,0 +1,67 @@
+/**
+ * entregaveis.js — o arquivo que o pedido manda gravar tem que existir no fim (26/10).
+ *
+ * Visto num `primocode -p` de verdade: "grave o PLANO.md" e o agente disse
+ * "pronto!" com o PLANO.md sem existir. Quem nunca programou acredita no
+ * "pronto" e só descobre depois.
+ *
+ * `pedidos(texto)` acha os arquivos que o pedido manda CRIAR ou ESCREVER (o
+ * nome vem depois de um verbo de escrever: grave, escreva, crie, salve…). O
+ * que vem depois de um verbo de ler ("leia o README.md", "com base no X.md")
+ * não conta: esse já existe, ou não é o agente que faz. `faltando` diz quais
+ * ainda não estão no disco. Sem modelo, sem rede.
+ */
+
+'use strict';
+
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+
+const EXTENSOES = 'md|txt|html?|css|js|mjs|cjs|ts|tsx|jsx|json|py|rb|go|rs|java|sh|ya?ml|toml|csv|sql|xml|svg|php|vue|svelte|ini';
+const ARQUIVO = new RegExp(`^[\\w.~/-]*[\\w-]\\.(?:${EXTENSOES})$`, 'i');
+const ESCREVER = /^(grav[ea]r?|grava|escrev[ae]r?|escreve|cri[ea]r?|cria|ger[ea]r?|gera|salv[ea]r?|salva|fa[çc]a|fazer|faz|mont[ea]r?|monta|write|create|save|generate|make|produce)$/i;
+// Depois destes, o arquivo citado é de LER (ou de editar, que é outra trava).
+const OUTRO = /^(lei?a|ler|l[êe]|abr[ae]|abrir|olh[ae]|olhar|vej?a|ver|use|usar|usando|base|partir|segu[ei]ndo|conforme|edit[ae]r?|mud[ae]r?|alter[ae]r?|apag[ae]r?|remov[ae]r?|read|open|use|using|based|from|edit|update|delete|remove|following)$/i;
+
+/** Os arquivos que o pedido manda criar ou escrever, na ordem, sem repetir. */
+function pedidos(texto) {
+    const achados = [];
+    const frases = String(texto || '').replace(/```[\s\S]*?```/g, ' ').split(/[.!?;\n]+(?=\s|$)/);
+    for (const frase of frases) {
+        let escrevendo = false;
+        for (const cru of frase.split(/\s+/)) {
+            const palavra = cru.replace(/^[("'`[]+|[)"'`\],:]+$/g, '');
+            if (!palavra) continue;
+            if (ESCREVER.test(palavra)) { escrevendo = true; continue; }
+            if (OUTRO.test(palavra)) { escrevendo = false; continue; }
+            if (escrevendo && ARQUIVO.test(palavra) && !/^https?:/i.test(palavra) && !achados.includes(palavra)) achados.push(palavra);
+        }
+    }
+    return achados;
+}
+
+/**
+ * Dos arquivos pedidos, os que não existem. Vale achar na pasta do projeto, ou
+ * um arquivo com o mesmo nome que a tarefa escreveu (ele pôs em docs/PLANO.md).
+ */
+function faltando(texto, pasta, escritos = []) {
+    const mesmoNome = new Set([...escritos].filter((f) => { try { return fs.existsSync(f); } catch { return false; } })
+        .map((f) => path.basename(f).toLowerCase()));
+    return pedidos(texto).filter((nome) => {
+        const caminho = nome.startsWith('~') ? path.join(os.homedir(), nome.slice(1)) : path.resolve(pasta || '.', nome);
+        if (fs.existsSync(caminho)) return false;
+        return !mesmoNome.has(path.basename(nome).toLowerCase());
+    });
+}
+
+/** O recado pro agente, ou null quando não falta nada. */
+function recado(falta) {
+    if (!falta.length) return null;
+    const lista = falta.join(', ');
+    return falta.length === 1
+        ? `o arquivo ${lista} ainda não existe. O pedido manda gravar esse arquivo: crie ele agora (write_file) e finalize de novo. Se não der, diga em uma frase por quê.`
+        : `os arquivos ${lista} ainda não existem. O pedido manda gravar esses arquivos: crie eles agora (write_file) e finalize de novo. Se não der, diga em uma frase por quê.`;
+}
+
+module.exports = { pedidos, faltando, recado };

package/lib/escopo.js

@@ -0,0 +1,68 @@
+/**
+ * escopo.js — "pedi pra mexer no login.js e ele mexeu em mais três": o aviso, e o "/desfazer fora".
+ *
+ *   citados(pedido)                          → ['login.js', …]          (os arquivos que o pedido nomeia; puro)
+ *   foraDoPedido(pedido, mudou, projectDir)  → [{ caminho, rel, acao }]  (o que o pedido mudou sem ser citado; puro)
+ *   texto(citados, fora)                     → as linhas pro terminal    (puro)
+ *   nota(pedido)                             → o aviso que vai junto do pedido pro agente, ou ''  (puro)
+ *
+ * Fórum do Cursor, maio a agosto de 2026: um pedido de um arquivo mexe em 18 (forum.cursor.com/t/165633 e /161320), e a
+ * única saída que a equipe deles dá é "liste os arquivos permitidos no pedido". Aqui, quando o pedido nomeia arquivo, o
+ * PrimoCode compara com o que o checkpoint do pedido viu mudar (lib/checkpoint.js) e diz o que ficou de fora — sem
+ * modelo. Pedido que não nomeia arquivo nenhum não gera aviso: "melhora o site" pode mexer em tudo.
+ */
+
+'use strict';
+
+const path = require('path');
+
+const EXT = 'html?|css|scss|jsx?|tsx?|mjs|cjs|json|py|rb|go|rs|php|vue|svelte|md|txt|svg|ya?ml|toml|sql|sh';
+const RE = new RegExp(`(?:^|[\\s"'\`(@])((?:\\.{0,2}/)?[\\w\\-./]*\\w\\.(?:${EXT}))(?=$|[\\s"'\`),.;:!?])`, 'gi');
+// o que muda sozinho junto (lockfile) ou é do próprio PrimoCode: nunca conta como "fora"
+const DE_FORA_NUNCA = /(^|\/)(package-lock\.json|yarn\.lock|pnpm-lock\.yaml|PRIMO\.md|memory\.md)$/;
+
+function citados(pedido) {
+    const out = [];
+    for (const m of String(pedido || '').matchAll(RE)) {
+        const c = m[1].replace(/^\.\//, '').toLowerCase();
+        if (/^https?:|^www\./.test(c) || out.includes(c)) continue;
+        out.push(c);
+    }
+    return out;
+}
+
+function foraDoPedido(pedido, mudou, projectDir) {
+    const lista = citados(pedido);
+    if (!lista.length) return [];
+    const bate = (rel) => {
+        const r = rel.toLowerCase();
+        return lista.some((c) => r === c || r.endsWith('/' + c) || (!c.includes('/') && path.basename(r) === c));
+    };
+    return (mudou || [])
+        .map((m) => ({ ...m, rel: path.relative(projectDir, m.caminho).split(path.sep).join('/') }))
+        .filter((m) => m.rel && !m.rel.startsWith('..') && !DE_FORA_NUNCA.test(m.rel) && !bate(m.rel));
+}
+
+const VERBO = { criado: 'criei', mudou: 'mudei', apagado: 'apaguei' };
+
+function texto(lista, fora) {
+    if (!fora.length) return [];
+    const pediu = lista.length === 1 ? lista[0] : lista.slice(0, -1).join(', ') + ' e ' + lista[lista.length - 1];
+    const linhas = [`Você pediu pra mexer em ${pediu}. Eu também mexi em ${fora.length === 1 ? 'outro arquivo' : fora.length + ' outros'}:`];
+    for (const f of fora.slice(0, 8)) linhas.push(`  ${VERBO[f.acao] || 'mudei'} ${f.rel}`);
+    if (fora.length > 8) linhas.push(`  e mais ${fora.length - 8}`);
+    linhas.push(`Se não era pra mexer, /undo fora volta só ${fora.length === 1 ? 'ele' : 'esses'}. O que você pediu fica.`);
+    return linhas;
+}
+
+/** Antes, e não só depois: o agente fica sabendo do escopo junto do pedido. Não proíbe (às vezes o conserto do
+    login.js precisa mesmo do util.js), pede que ele diga o porquê — e o aviso do fim continua de pé. */
+function nota(pedido) {
+    const lista = citados(pedido);
+    if (!lista.length) return '';
+    const quais = lista.slice(0, 6).join(', ');
+    return `\n\nESCOPO: o pedido citou ${quais}. Mexa só ${lista.length === 1 ? 'nele' : 'neles'}. `
+        + 'Se precisar mudar outro arquivo, mude só o necessário e diga na resposta qual e por quê.';
+}
+
+module.exports = { citados, foraDoPedido, texto, nota };

package/lib/especialistas.js

@@ -64,7 +64,7 @@ const ESPECIALISTAS = {
     ambiente: {
         faz: 'instalar dependências, configurar e fazer rodar',
         sinais: /\b(instal\w*|depend[êe]ncias?|npm|pnpm|yarn|pip|uv|brew|apt(-get)?|winget|ffmpeg|configur\w*|ambiente|setup|rodar o projeto|node_modules|docker|venv)\b/gi,
-        briefing: `Você é o especialista em AMBIENTE — dependências, instalação e execução. Descubra o que a máquina tem (node --version, python3 --version, qual gerenciador: npm/pnpm/yarn, pip/uv, brew/apt/winget) antes de mandar instalar; use o gerenciador que o projeto já usa (o lockfile diz). Instale só o que a tarefa pede, com a versão fixada no manifesto (package.json, requirements.txt), nunca global sem motivo. Comando que demora ou fica de pé vai em run_in_new_terminal; o resto em run_shell, lendo a saída inteira — "warning" não é erro, "ERR!" é. Falta algo no sistema (ffmpeg, git, python)? Instale pelo gerenciador do sistema e confira com --version. PROVE: o comando de rodar funcionando, e um LEIA.md com instalar e rodar que qualquer um siga.`,
+        briefing: `Você é o especialista em AMBIENTE — dependências, instalação e execução. Descubra o que a máquina tem (node --version, python3 --version, qual gerenciador: npm/pnpm/yarn, pip/uv, brew/apt/winget) antes de mandar instalar; use o gerenciador que o projeto já usa (o lockfile diz). Instale só o que a tarefa pede, com a versão fixada no manifesto (package.json, requirements.txt), nunca global sem motivo. Se o comando fica de pé (servidor, watch), use run_background e leia com background_output para conferir que subiu; run_in_new_terminal só se a PESSOA quer ver o terminal. O resto em run_shell, lendo a saída inteira — "warning" não é erro, "ERR!" é. Falta algo no sistema (ffmpeg, git, python)? Instale pelo gerenciador do sistema e confira com --version. PROVE: o comando de rodar funcionando, e um LEIA.md com instalar e rodar que qualquer um siga.`,
     },
 };
 

package/lib/estudio/conferencia.js

@@ -18,13 +18,22 @@
  *            imagem dá 6,5 s a 8,3 s ("torrado" parado, a pílula vazia, e
  *            para quando "café" entra), e os vídeos 3D não dão nada.
  *
- * Só mede e avisa. Não conserta nada: quem decide se refaz é o agente.
- * As duas leituras (lerSom, lerParados) são puras e testáveis sem vídeo.
+ *   olho     8 quadros espaçados lidos pelo Vision do macOS (visao.js), em todo caminho (AE, Remotion, Hyperframes):
+ *            texto colado na borda, sobre rosto, encavalado (conferencia-visual) e o contraste de cada texto contra o
+ *            fundo atrás dele, 3:1 no mínimo (regras-motion). Sem o Vision, o olho fica de fora e nada quebra.
+ *
+ * Só mede e avisa (agora também olha). Não conserta nada: quem decide se refaz é o agente.
+ * As leituras (lerSom, lerParados) e o julgamento do olho são puros e testáveis sem vídeo.
  */
 
 'use strict';
 
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
 const video = require('./video.js');
+const conferenciaVisual = require('./conferencia-visual.js');
+const regras = require('./regras-motion.js');
 
 const ALVO = { lufs: -14, folgaLufs: 2, picoMax: -1, paradoMin: 2 };
 const r1 = (n) => Math.round(n * 10) / 10;
@@ -79,8 +88,53 @@ function julgar({ som, parados = [] }, alvo = ALVO) {
     return avisos;
 }
 
-/** Mede o arquivo numa passada só do ffmpeg e devolve medidas e avisos. */
-async function conferir(arquivo, { duracao = 0 } = {}) {
+/** Tira `quadros` quadros do vídeo e lê no Vision. `visao` injetável (null = sem olho). Nunca falha: sem olho devolve {olho:'sem'}. */
+async function olhar(arquivo, { duracao = 0, visao, quadros = 8, pasta } = {}) {
+    let V = visao;
+    if (V === undefined) { try { V = require('./visao.js'); } catch { V = null; } }
+    if (!V || !V.disponivel() || !(duracao > 0)) return { olho: 'sem', problemas: [] };
+    const tmp = pasta || fs.mkdtempSync(path.join(os.tmpdir(), 'olho-'));
+    try {
+        const segundos = [], arquivos = [];
+        for (let i = 0; i < quadros; i++) {
+            const s = (i + 0.5) * duracao / quadros, png = path.join(tmp, `q${i}.png`);
+            const q = await video.quadro(arquivo, png, s);
+            if (q.ok) { segundos.push(s); arquivos.push(png); }
+        }
+        const r = arquivos.length ? V.ler(arquivos) : null;
+        if (!r || !r.ok) return { olho: 'sem', problemas: [] };
+        const problemas = [];
+        for (const q of r.quadros) {
+            const i = arquivos.indexOf(q.arquivo);
+            if (i < 0) continue;
+            const seg = r1(segundos[i]);
+            const achados = conferenciaVisual.julgarLeitura(q, i).map((p) => ({ ...p, segundo: seg }));
+            achados.push(...regras.julgarContraste(q, pixels(q.arquivo, 540), { cena: i, segundo: seg }));
+            problemas.push(...achados);
+        }
+        return { olho: 'vision', problemas };
+    } finally {
+        if (!pasta) { try { fs.rmSync(tmp, { recursive: true, force: true }); } catch { /* o sistema limpa */ } }
+    }
+}
+
+// carregado na hora: maquina-layout puxa mais coisa, e a medida de som não precisa dele
+function pixels(png, largura) { return require('./maquina-layout.js').pixels(png, largura); }
+
+/** Os problemas do olho viram avisos com o segundo; o mesmo texto e tipo só aparece uma vez (no 1º segundo). */
+function avisosDoOlho(problemas) {
+    const vistos = new Set(), avisos = [];
+    for (const p of problemas) {
+        const chave = `${p.tipo}|${(p.texto.match(/"([^"]*)"/) || [, p.texto])[1]}`;
+        if (vistos.has(chave)) continue;
+        vistos.add(chave);
+        avisos.push(`aos ${String(p.segundo).replace('.', ',')} s: ${p.texto}`);
+    }
+    return avisos;
+}
+
+/** Mede o arquivo numa passada só do ffmpeg, olha os quadros e devolve medidas e avisos. */
+async function conferir(arquivo, { duracao = 0, olho = true, visao } = {}) {
     const c = video.conferir();
     if (!c.ok) return c;
     const r = await video.rodar(video.ffmpeg(), [
@@ -92,7 +146,18 @@ async function conferir(arquivo, { duracao = 0 } = {}) {
     if (!r.ok) return { ok: false, error: `a conferência não leu o vídeo: ${r.erro.slice(-200)}` };
     const som = lerSom(r.erro);
     const parados = lerParados(r.erro, duracao);
-    return { ok: true, som, parados, avisos: julgar({ som, parados }) };
+    const visto = olho ? await olhar(arquivo, { duracao, visao }) : { olho: 'sem', problemas: [] };
+    return { ok: true, som, parados, avisos: [...julgar({ som, parados }), ...avisosDoOlho(visto.problemas)], olho: visto };
+}
+
+/* O que a PESSOA vê no terminal depois do render: os avisos só iam pro modelo, e quem olhava a tela
+   achava que o vídeo tinha saído limpo. Até `max` linhas, o resto vira "e mais N". Pura. */
+function linhasPraPessoa(conf, max = 4) {
+    const av = (conf && Array.isArray(conf.avisos) ? conf.avisos : []).filter(Boolean);
+    if (!av.length) return [];
+    const out = ['a conferência do vídeo pronto achou:', ...av.slice(0, max).map((a) => '· ' + a)];
+    if (av.length > max) out.push(`· e mais ${av.length - max}`);
+    return out;
 }
 
-module.exports = { ALVO, lerSom, lerParados, julgar, conferir };
+module.exports = { ALVO, lerSom, lerParados, julgar, olhar, avisosDoOlho, conferir, linhasPraPessoa };