primocode 10.0.0 → 10.0.9

package/lib/estudio/hibrido.js

@@ -0,0 +1,165 @@
+/**
+ * hibrido.js — o cinema com o kit por cima: foto real que não para, e o
+ * motion que parece feito à mão.
+ *
+ *   "Deve funcionar como um mix da versão antiga (o reels da imersão) e a
+ *    última versão — trabalhar juntas, absurdas, coisas que nem parece que
+ *    foi IA que fez." (29/09)
+ *
+ * O que cada lado traz:
+ *   do cinema (cinema.js)  foto e vídeo REAIS ocupando a tela, escurecidos,
+ *                          trocando por baixo do mesmo texto; letra grossa em
+ *                          caixa alta com a palavra da tese no gradiente; o
+ *                          número que conta; a virada que bate no fundo; a
+ *                          marca só no fim.
+ *   do kit (kit/*.jsx)     a câmera que empurra e desliza em toda cena; a
+ *                          etiqueta da fonte que se digita; partículas no
+ *                          número e no fim; o HUD de motion designer; o
+ *                          líquido entre blocos; grão e vinheta.
+ *
+ * Três passos, e nenhum repete o que o cinema já faz:
+ *   traduzir(roteiro)      qualquer roteiro (vox, motion, composição) vira os
+ *                          tipos do cinema; o que o cinema não usa (a fonte, o
+ *                          destaque) fica guardado por parte.
+ *   termosDeBusca(roteiro) o que procurar de b-roll para cada parte.
+ *   enfeitar(plano, …)     o kit por cima do plano que o cinema montou.
+ */
+
+'use strict';
+
+const r2 = (n) => Math.round(n * 100) / 100;
+const k = (t, v, e) => (e ? { t: r2(t), v, e } : { t: r2(t), v });
+const limpo = (x) => String(x || '').replace(/\s+/g, ' ').trim();
+
+/* O b-roll quando a parte não diz o que procurar. Genérico de propósito: é o
+   fundo que se move, não a prova — a prova é o texto e a foto da marca. */
+const BUSCA_PADRAO = ['technology abstract light', 'people working on laptop', 'hands typing keyboard close up',
+    'data center servers', 'city night timelapse', 'team meeting office', 'developer code screen', 'futuristic digital network'];
+
+/** O roteiro de qualquer estilo → o roteiro do cinema. Devolve {roteiro, extras}. */
+function traduzir(roteiro) {
+    const partes = (roteiro && roteiro.partes) || [];
+    const saida = [];
+    const extras = [];
+    // A virada: a parte marcada com climax, ou o último contraste antes do fim.
+    let iClimax = partes.findIndex((p) => p.climax);
+    if (iClimax < 0) {
+        for (let i = partes.length - 2; i > 0; i--) if (partes[i].tipo === 'contraste') { iClimax = i; break; }
+    }
+    partes.forEach((p, i) => {
+        const tipo = p.tipo || 'frase';
+        const marcar = [p.destaque, ...(p.marcar || [])].filter(Boolean);
+        const base = { fala: p.fala, ...(p.mudo ? { mudo: true } : {}), ...(p.falaForte ? { falaForte: p.falaForte } : {}), marcar };
+        let q;
+        // Os tipos que o cinema já conhece passam como estão.
+        if (['frase', 'montagem', 'numeros', 'escada', 'dia', 'depoimento', 'climax', 'final'].includes(tipo)) q = { ...p };
+        else if (i === iClimax) q = { tipo: 'climax', linhas: [p.nao, p.sim].filter(Boolean).map(limpo), ...base };
+        // A abertura é o título, grande; o subtítulo vira a etiqueta digitada (a fonte).
+        else if (tipo === 'abertura') q = { tipo: 'montagem', linhas: [limpo(p.titulo)], ritmo: 0.6, ...base };
+        else if (tipo === 'titulo' || tipo === 'imagem') q = { tipo: 'montagem', linhas: [p.titulo || p.texto, p.sub].filter(Boolean).map(limpo), ...base };
+        else if (tipo === 'numero' || tipo === 'grafico') {
+            // "30% mais rápido": o cinema conta o número e escreve o resto embaixo.
+            q = { tipo: 'numeros', itens: [limpo(`${p.valor || ''} ${p.rotulo || p.titulo || ''}`)], ...base };
+        } else if (tipo === 'passos' || tipo === 'lista') {
+            /* Na escada, o item é o NOME ("Sonnet 4"); a data e o detalhe depois do
+               "·" ou do "—" estão na fala. Cinco itens de cinco palavras eram 7 s
+               de escada pela regra de 0,3 s por palavra. */
+            const itens = (p.itens || []).map((x) => limpo(typeof x === 'string' ? x : (x.titulo || x.texto || '')).split(/\s+[·—–-]\s+/)[0]).filter(Boolean);
+            q = { tipo: 'escada', itens: itens.slice(0, 5), ...(p.titulo ? { final: limpo(p.titulo) } : {}), ...base };
+        } else if (tipo === 'citacao') q = { tipo: 'frase', linhas: [`“${limpo(p.texto)}”`], ...base };
+        else if (tipo === 'contraste') q = { tipo: 'montagem', linhas: [p.nao, p.sim].filter(Boolean).map(limpo), ...base };
+        else if (tipo === 'cta' || tipo === 'logo' || tipo === 'fim') q = { tipo: 'final', linhas: [p.titulo || p.texto, p.link].filter(Boolean).map(limpo), ...base };
+        else q = { tipo: 'montagem', linhas: [p.titulo || p.texto || p.fala].filter(Boolean).map(limpo), ...base };
+        saida.push(q);
+        extras.push({ tipoOriginal: tipo, fonte: tipo === 'abertura' && p.sub ? p.sub : (p.fonte || (tipo === 'citacao' ? p.autor : '')), autor: p.autor || '', busca: p.busca || '' });
+    });
+    return { roteiro: { ...roteiro, partes: saida, estilo: 'hibrido' }, extras };
+}
+
+/** O que procurar de b-roll para cada parte: a busca dela, a do roteiro, ou o padrão. */
+function termosDeBusca(roteiro, extras = []) {
+    const global = [].concat(roteiro.busca || []).filter(Boolean);
+    // Escopo fechado: só os termos da pessoa, nunca o padrão genérico.
+    const fechado = require('./referencias.js').atual().modo === 'fechado';
+    const lista = global.length ? global : fechado ? [] : BUSCA_PADRAO;
+    const termos = new Set();
+    (roteiro.partes || []).forEach((p, i) => {
+        const b = (extras[i] && extras[i].busca) || p.busca;
+        if (b) termos.add(String(b));
+    });
+    for (const t of lista) termos.add(t);
+    return [...termos].slice(0, 8);
+}
+
+/* A câmera de cada cena do cinema: empurra e desliza, alternando o lado. A
+   foto já se move por dentro (os movimentos do cinema); a câmera move o
+   CONJUNTO — é a soma dos dois que dá a profundidade. */
+function camera(d, i, deitado, forte) {
+    const lado = i % 2 ? 1 : -1;
+    const z = forte ? 1.14 : 1.07;
+    const desliza = (deitado ? 26 : 18);
+    return {
+        zoom: [k(0, 1.0), k(Math.max(0.3, d - 0.25), z, 'camera'), k(d, z + 0.04, 'acelera')],
+        x: [k(0, -lado * desliza), k(d, lado * desliza, 'camera')],
+        rotacao: [k(0, -lado * 0.35), k(d, lado * 0.35, 'camera')],
+    };
+}
+
+/** O kit por cima do plano do cinema. Mexe no plano recebido e o devolve. */
+function enfeitar(plano, { extras = [], partes = [], marca = {}, largura, altura } = {}) {
+    if (!plano || !Array.isArray(plano.cenas)) return plano;
+    const W = largura || (plano.formato && plano.formato.largura) || 1920;
+    const H = altura || (plano.formato && plano.formato.altura) || 1080;
+    const deitado = W >= H;
+    const base = Math.min(W, H);
+    const M = Math.round(base * 0.08);
+    const grad = marca.gradiente && marca.gradiente.length >= 2 ? marca.gradiente : ['#2E81ED', '#9567DB'];
+    const ACENTO = (marca.cores && marca.cores.destaque) || grad[1];
+
+    /* As cenas do cinema não são uma por parte: o depoimento com três clipes
+       vira três cenas. O mapa cena → parte sai das partes já traduzidas. */
+    const parteDaCena = [];
+    partes.forEach((p, i) => {
+        const n = p.tipo === 'depoimento' ? Math.max(1, (p.clipes || []).length) : 1;
+        for (let q = 0; q < n; q++) parteDaCena.push(i);
+    });
+    plano.cenas.forEach((cena, c) => {
+        const iParte = parteDaCena[c] != null ? parteDaCena[c] : c;
+        const ex = extras[iParte] || {};
+        const d = cena.duracao || 2;
+        const tipo = ex.tipoOriginal || '';
+        const els = cena.elementos || (cena.elementos = []);
+        const forte = tipo === 'numero' || tipo === 'contraste' || tipo === 'abertura';
+        if (!cena.camera) cena.camera = camera(d, c, deitado, forte);
+
+        // A FONTE que se digita, com a barra do acento: vira prova, não enfeite.
+        if (ex.fonte && d > 1.4) {
+            els.push({ tipo: 'kit', peca: 'fonte', texto: String(ex.fonte).slice(0, 48), t: Math.min(0.9, d * 0.35),
+                x: M, y: Math.round(H - M * (deitado ? 1.1 : 2.6)), tamanho: Math.round(base * 0.016), cor: 'rgba(245,245,247,0.72)', corAcento: ACENTO });
+        }
+        // O NÚMERO estoura em partículas quando assenta.
+        if (tipo === 'numero' || tipo === 'grafico') {
+            els.push({ tipo: 'kit', peca: 'particulas', t: 0.45, x: Math.round(W / 2), y: Math.round(H * 0.42), raio: Math.round(base * 0.34), n: 46,
+                tamanho: Math.max(5, Math.round(base * 0.007)), cores: ['#ffffff', ACENTO, grad[0]] });
+        }
+        // O FIM: a marca entra com um brilho de partículas.
+        if (tipo === 'cta' || tipo === 'logo' || tipo === 'fim') {
+            els.push({ tipo: 'kit', peca: 'particulas', t: 0.2, x: Math.round(W / 2), y: Math.round(H * 0.36), raio: Math.round(base * 0.45), n: 60,
+                tamanho: Math.max(4, Math.round(base * 0.006)), cores: ['#ffffff', ACENTO], forma: 'circulo' });
+        }
+        /* O LÍQUIDO entre blocos: a cada três partes a passagem é a mancha que
+           cobre a tela, não o esmaecer. Mais que isso vira truque. */
+        if (c > 0 && iParte % 3 === 0 && cena.transicao && cena.transicao.tipo !== 'corte' && tipo !== 'cta') {
+            cena.transicao = { tipo: 'liquido', duracao: 0.5, cor: ACENTO };
+        }
+    });
+
+    // O HUD de motion designer: cantos, timecode e a marca.
+    plano.hud = plano.hud || { marca: String(marca.nome || '').toUpperCase().slice(0, 24) || undefined };
+    // O acabamento de filme um pouco mais presente que o do cinema.
+    plano.acabamento = { ...(plano.acabamento || {}), grao: Math.max(0.06, (plano.acabamento || {}).grao || 0), vinheta: Math.max(0.55, (plano.acabamento || {}).vinheta || 0) };
+    plano.estilo = 'hibrido';
+    return plano;
+}
+
+module.exports = { traduzir, termosDeBusca, enfeitar, BUSCA_PADRAO };

package/lib/estudio/index.js

@@ -34,6 +34,9 @@ const { spawn } = require('child_process');
 
 const projeto = require('./projeto.js');
 const acervo = require('./acervo.js');
+const hibrido = require('./hibrido.js');
+const referencias = require('./referencias.js');
+const variedade = require('./variedade.js');
 const plano = require('./plano.js');
 const remotion = require('./remotion.js');
 const assets = require('./assets.js');
@@ -46,6 +49,7 @@ const acervoSite = require('./acervo-site.js');
 const impacto = require('./impacto.js');
 const cinema = require('./cinema.js');
 const motion = require('./motion.js');
+const gerativo = require('./gerativo.js');
 const vox = require('./vox.js');
 const lancamento = require('./lancamento.js');
 const glifos = require('./glifos.js');
@@ -306,6 +310,11 @@ async function ferramentaPlano(args) {
        sons (lib/estudio/composicao.js). É o caminho para qualquer modelo
        entregar motion e slides que prestam. */
     if (args.roteiro) {
+        /* O roteiro como a pessoa (ou o modelo) mandou: o híbrido traduz as
+           partes para o cinema no caminho, e o que fica guardado tem de ser o
+           original — senão o próximo ajuste parte do traduzido. */
+        let original = null;
+        try { original = JSON.parse(typeof args.roteiro === 'string' ? args.roteiro : JSON.stringify(args.roteiro)); } catch { original = args.roteiro; }
         const r = await prepararRoteiro(p, args);
         if (!r.ok) return r;
         let conferida = plano.conferir(r.plano, { pasta: p.pasta });
@@ -322,7 +331,7 @@ async function ferramentaPlano(args) {
         }
         projeto.salvarPlano(args.id, r.plano, args.motivo || 'montado do roteiro');
         // O roteiro fica guardado: ajustar uma frase é mandar o roteiro de novo, não reescrever tudo.
-        try { fs.writeFileSync(path.join(p.pasta, 'roteiro.json'), JSON.stringify(args.roteiro, null, 2)); } catch { /* segue */ }
+        try { fs.writeFileSync(path.join(p.pasta, 'roteiro.json'), JSON.stringify(original || args.roteiro, null, 2)); } catch { /* segue */ }
         projeto.salvar(args.id, { duracao: conferida.duracao });
         return {
             ok: true, duracao: conferida.duracao, ...r.resumo, resumo: plano.resumo(r.plano),
@@ -887,21 +896,18 @@ async function temLetra(arquivo) {
    (25/09/2026) */
 async function sonsReais(p, video) {
     const sint = await edicao.prepararSons(p.pasta, video);
-    const quer = {
-        teclado: ['keyboard typing', 'typing keyboard'],
-        whoosh: ['cinematic whoosh', 'swoosh transition'],
-        impacto: ['cinematic boom impact', 'deep cinematic impact', 'trailer hit'],
-        sala: ['crowd murmur indoor', 'office ambience', 'people talking background'],
-    };
+    /* Termo sorteado e resultado sorteado, sem repetir os últimos: o primeiro
+       resultado do termo fixo era o mesmo whoosh em todo vídeo (02/10). */
     const sons = { ...sint };
-    for (const [nome, termos] of Object.entries(quer)) {
-        for (const termo of termos) {
+    for (const nome of ['teclado', 'whoosh', 'impacto', 'sala']) {
+        for (const termo of variedade.termosSfx(nome)) {
+            if (sons[nome] !== sint[nome]) break;
             try {
-                const b = await assets.procurarSom(termo, { quantas: 5 });
-                const item = (b.ok ? b.sons : []).find((x) => x.url);
-                if (!item) continue;
-                const d = await assets.baixar(item, { pasta: p.pasta, nome: 'sfx-real-' + nome });
-                if (d.ok) { sons[nome] = d.relativo; break; }
+                const b = await assets.procurarSom(termo, { quantas: 10 });
+                for (const item of variedade.ordenar(b.ok ? b.sons : [], 'sfx').slice(0, 3)) {
+                    const d = await assets.baixar(item, { pasta: p.pasta, nome: 'sfx-real-' + nome });
+                    if (d.ok) { sons[nome] = d.relativo; variedade.marcar('sfx', item.url); break; }
+                }
             } catch { /* o próximo termo */ }
         }
     }
@@ -932,7 +938,25 @@ async function prepararRoteiro(p, args) {
        lançamento de produto vira LANCAMENTO, anúncio e reels vão para o
        IMPACTO. O que o agente pediu vale mais que tudo. */
     const pedidoTxt = `${p.pedido || ''} ${args.pedido || ''}`;
-    const estilo = escolherEstilo({ pedido: pedidoTxt, agente: args.estilo, roteiro: roteiro.estilo });
+    const ref = referencias.atual();
+    let estilo = escolherEstilo({ pedido: pedidoTxt, agente: args.estilo, roteiro: roteiro.estilo });
+    /* "Sem referências, só motion": o híbrido vive de b-roll de fora, então
+       cai para o motion — sem nada baixado. */
+    const produtoNoPedido = /produto|an[uú]nci|lan[çc]a|headset|fone|celular|t[eê]nis|rel[oó]gio|garrafa|lata|app\b/i.test(pedidoTxt);
+    /* E o motion de agora é o GERATIVO: sem template, produto ou não (o
+       produto em 3D entra numa batida dele, logo abaixo). */
+    if (ref.modo === 'sem' && estilo === 'hibrido') estilo = 'gerativo';
+    void produtoNoPedido;
+    /* "O vídeo deve ter um 3D do fone" (30/09): pedido de 3D vira o gerativo
+       com o produto modelado girando numa batida (kit/tres.jsx) — a menos que
+       o agente tenha escolhido outro estilo pelo nome. */
+    if (/\b3\s?d\b|tridimensional/i.test(pedidoTxt) && (!args.estilo || estilo === 'gerativo' || estilo === 'lancamento')) {
+        // O 3D mora numa batida do gerativo; o lançamento antigo, só pelo nome.
+        if (!args.estilo && estilo !== 'lancamento') estilo = 'gerativo';
+        if (!roteiro.modelo3d) roteiro.modelo3d = /fone|headset|headphone/i.test(pedidoTxt) ? 'fone'
+            : /celular|smartphone|phone/i.test(pedidoTxt) ? 'celular' : /lata|bebida|garrafa/i.test(pedidoTxt) ? 'lata' : 'caixa';
+    }
+    if (ref.modo === 'fechado' && !roteiro.busca && referencias.termos().length) roteiro.busca = referencias.termos();
     // Os estilos de motion usam os efeitos leves e a trilha do ende.app; os de corte, os cheios.
     const ehMotion = LEVES.has(estilo);
     const modo = (args.modo || roteiro.modo || (p.formato === 'slides' || p.formato === 'arte' ? 'slides' : 'video'));
@@ -981,7 +1005,15 @@ async function prepararRoteiro(p, args) {
     }
 
     let tempos = [], narracao = null, sons = {}, trilha = null;
-    if (modo === 'video' && estilo === 'cinema') {
+    /* O HÍBRIDO (hibrido.js) é o cinema com o kit por cima: o roteiro de
+       qualquer estilo vira os tipos do cinema aqui, antes da voz — a voz lê
+       o que o cinema vai mostrar. */
+    let hib = null;
+    if (modo === 'video' && estilo === 'hibrido') {
+        hib = hibrido.traduzir(roteiro);
+        partes.splice(0, partes.length, ...hib.roteiro.partes);
+    }
+    if (modo === 'video' && (estilo === 'cinema' || estilo === 'hibrido')) {
         // Só as partes com voz vão para a narração; o depoimento tem a voz do aluno.
         // Só as partes com voz: o depoimento tem a voz do aluno, e a parte muda não tem voz.
         // A parte com voz forte é narrada à parte: se entrasse aqui também, seria falada duas vezes (e muda uma delas).
@@ -1051,20 +1083,39 @@ async function prepararRoteiro(p, args) {
                 }
             }
         }
+        /* No HÍBRIDO a voz anda um pouco mais rápido por padrão (1,12×, como no
+           vox): o trailer premium do cinema lido pelo Gemini sai no passo de
+           leitura, e o vídeo segue a voz. `roteiro.ritmoVoz` ajusta. */
+        if (hib && ritmoVoz <= 1.01) {
+            const kh = Math.max(1, Math.min(1.5, Number(roteiro.ritmoVoz) || 1.12));
+            const rapido = mp3.replace(/\.mp3$/, '-h.mp3');
+            const c = kh > 1.01 ? await video.rodar(video.ffmpeg(), ['-y', '-i', mp3, '-filter:a', `atempo=${kh.toFixed(3)}`, rapido], { timeout: 120000 }) : { ok: false };
+            if (process.env.PRIMOCODE_TRACO === '1') process.stderr.write(`[traço] voz do híbrido ${kh}× ok=${c.ok} existe=${fs.existsSync(rapido)} ${String(c.erro || '').slice(-120)}\n`);
+            if (c.ok && fs.existsSync(rapido)) {
+                fs.renameSync(rapido, mp3);
+                ritmoVoz = kh;
+                const div = (x) => Math.round((x / kh) * 1000) / 1000;
+                v.partes = v.partes.map((pt) => ({ de: div(pt.de), ate: div(pt.ate), palavras: (pt.palavras || []).map((w) => ({ ...w, de: div(w.de), ate: div(w.ate) })) }));
+                v.segundos = div(v.segundos);
+            }
+        }
         projeto.anotar(p.id, 'narracao', `${v.segundos}s em ${lista.length} partes, voz ${v.voz}`);
         const sonsC = await sonsReais(p, video);
         let trilhaC = null;
         // Vários termos e durações: vídeo sem música foi o que saiu na primeira vez (25/09).
         // E só instrumental: "essa música daria pra deixar só o instrumental?" — a faixa é OUVIDA.
-        for (const [termo, min] of [[roteiro.musica, 60], ['instrumental cinematic inspiring', 70], ['instrumental piano cinematic', 60], ['instrumental epic cinematic', 60], ['instrumental ambient inspiring', 45], ['instrumental', 45]]) {
-            if (!termo || trilhaC) continue;
+        // O termo sai do clima do roteiro (variedade.js), não de uma lista fixa de "cinematic inspiring".
+        for (const termo of [...variedade.termosTrilha(roteiro, 'cinema'), 'instrumental']) {
+            if (trilhaC) break;
             try {
-                const b = await assets.procurarMusica(termo, { quantas: 6, duracaoMin: min });
-                for (const item of (b.ok ? b.sons : [])) {
+                const b = await assets.procurarMusica(termo, { quantas: 10, duracaoMin: 45 });
+                for (const item of variedade.ordenar(b.ok ? b.sons : [], 'trilha').filter((x) => !/vocal|voice|feat|ft\.|remix/i.test(x.titulo || '')).slice(0, 4)) {
                     const d = await assets.baixar(item, { pasta: p.pasta, nome: 'trilha' });
                     if (!d.ok) continue;
                     if (await temLetra(path.join(p.pasta, d.relativo))) { projeto.anotar(p.id, 'midia', `trilha com voz descartada: ${item.titulo}`); continue; }
-                    trilhaC = d.relativo; break;
+                    trilhaC = d.relativo; variedade.marcar('trilha', item.url);
+                    projeto.anotar(p.id, 'trilha', `"${termo}": ${item.titulo} — ${item.autor || 'Jamendo'} (${item.licenca || 'CC'})`);
+                    break;
                 }
             } catch { /* o próximo termo */ }
         }
@@ -1085,7 +1136,69 @@ async function prepararRoteiro(p, args) {
         const MINI = /poster|face \d+|\bthumb/i;
         const fotosC = acervo.fotos.filter((f) => !MINI.test(f.alt || ''))
             .map((f) => ({ src: f.src, tipo: 'imagem', cat: TELA.test(f.alt || '') ? 'tela' : 'pessoas', alt: f.alt }));
-        const rostos = await acharRostos(p, fotosC.map((f) => f.src));
+        /* O B-ROLL do híbrido: o cinema vive de foto que troca por baixo do
+           texto, e o acervo da marca raramente passa de meia dúzia. Vídeo de
+           banco primeiro (o fundo que se move sozinho), foto como reserva —
+           em paralelo, porque são oito buscas. */
+        /* Foto de compartilhamento (og:image) e logo trazem o NOME da marca em
+           letra gigante: como fundo, viravam um "THRO" cortado atrás do texto. */
+        /* E arte de banner (2400×1260 e afins): é o logo da marca desenhado, não
+           uma cena — cortada no vídeo em pé, vira um "✳ Cl" gigante. */
+        const banner = (alt) => { const m = /(\d{3,4})x(\d{3,4})/.exec(alt || ''); return m && Number(m[1]) / Number(m[2]) > 1.7 && altura > largura; };
+        if (hib) for (let q = fotosC.length - 1; q >= 0; q--) if (/open graph|og[:_ -]?image|\blogo|banner|wordmark/i.test(fotosC[q].alt || '') || banner(fotosC[q].alt)) fotosC.splice(q, 1);
+        if (hib && fotosC.length < 14) {
+            const orientacao = largura >= altura ? 'landscape' : 'portrait';
+            const pastaMidia = path.join(p.pasta, 'midia');
+            const jaTem = (() => { try { return fs.readdirSync(pastaMidia); } catch { return []; } })();
+            const cat = (termo) => (/screen|code|data|server|dashboard/i.test(termo) ? 'tela' : 'pessoas');
+            /* A versão LEVE do b-roll: o Pexels entrega 1080×1920 inteiro (até 30
+               MB e 20 s), e o render parava num quadro esperando vários vídeos
+               assim ao mesmo tempo (medido: timeout de 120 s no quadro 184). Cada
+               um vira 8 s, 720 de largura, sem áudio — e fica guardado, para o
+               próximo render não baixar de novo. */
+            const leve = async (rel, destino) => {
+                const alvo = path.join(pastaMidia, destino);
+                const escala = largura >= altura ? 'scale=1280:-2' : 'scale=720:-2';
+                const c = await video.rodar(video.ffmpeg(), ['-y', '-i', path.join(p.pasta, rel), '-t', '8', '-vf', escala + ',fps=30', '-an',
+                    '-c:v', 'libx264', '-preset', 'veryfast', '-crf', '24', '-pix_fmt', 'yuv420p', '-movflags', '+faststart', alvo], { timeout: 180000 });
+                if (!c.ok || !fs.existsSync(alvo)) return null;
+                try { fs.unlinkSync(path.join(p.pasta, rel)); } catch { /* fica o original */ }
+                return 'midia/' + destino;
+            };
+            const achados = await Promise.all(hibrido.termosDeBusca(roteiro, hib.extras).map(async (termo) => {
+                const out = [];
+                const slug = 'broll-' + String(termo).toLowerCase().replace(/[^a-z0-9]+/g, '-').replace(/^-|-$/g, '');
+                const proxy = `${slug}.leve.mp4`;
+                if (jaTem.includes(proxy)) out.push({ src: 'midia/' + proxy, tipo: 'video', cat: cat(termo), alt: termo });
+                else try {
+                    const b = await assets.procurarVideos(termo, { quantas: 3, orientacao });
+                    for (const item of (b.ok ? b.videos : []).filter((v) => !v.duracao || v.duracao >= 4).slice(0, 1)) {
+                        const d = await assets.baixar(item, { pasta: p.pasta, nome: slug });
+                        const l = d.ok ? await leve(d.relativo, proxy) : null;
+                        if (l) out.push({ src: l, tipo: 'video', cat: cat(termo), alt: termo });
+                    }
+                } catch { /* segue com a foto */ }
+                const foto = jaTem.find((f) => f.startsWith(slug + '-') && /\.(jpe?g|png|webp)$/i.test(f));
+                if (foto) out.push({ src: 'midia/' + foto, tipo: 'imagem', cat: cat(termo), alt: termo });
+                else try {
+                    const b = await assets.procurarImagens(termo, { quantas: 3, orientacao });
+                    for (const item of (b.ok ? b.imagens : []).slice(0, 1)) {
+                        const d = await assets.baixar(item, { pasta: p.pasta, nome: slug });
+                        if (d.ok) out.push({ src: d.relativo, tipo: 'imagem', cat: cat(termo), alt: termo });
+                    }
+                } catch { /* sem */ }
+                return out;
+            }));
+            const novos = achados.flat();
+            // Intercalados com as da marca: a foto da marca não pode ficar toda no começo.
+            const marcaF = fotosC.splice(0);
+            for (let q = 0; q < Math.max(marcaF.length, novos.length); q++) {
+                if (novos[q]) fotosC.push(novos[q]);
+                if (marcaF[q]) fotosC.push(marcaF[q]);
+            }
+            projeto.anotar(p.id, 'midia', `b-roll do híbrido: ${novos.filter((f) => f.tipo === 'video').length} vídeos e ${novos.filter((f) => f.tipo === 'imagem').length} fotos`);
+        }
+        const rostos = await acharRostos(p, fotosC.filter((f) => f.tipo !== 'video').map((f) => f.src));
         for (const f of fotosC) if (rostos[f.src]) f.rosto = rostos[f.src];
         // Os depoimentos: cortados na palavra, com a voz no volume certo e fade.
         for (const pt of partes) {
@@ -1126,8 +1239,12 @@ async function prepararRoteiro(p, args) {
             iNarr++;
         }
         const r = cinema.montarCinema({ roteiro, largura, altura, tempos: v.partes, narracao: path.relative(p.pasta, mp3).replace(/\\/g, '/'),
-            sons: sonsC, trilha: trilhaC, fotos: fotosC, fortes });
-        if (r.ok) projeto.anotar(p.id, 'plano', `estilo cinema: ${r.resumo.cenas} cenas, ${r.resumo.segundos}s`);
+            sons: sonsC, trilha: trilhaC, fotos: fotosC, fortes, ritmoLeitura: hib ? 0.55 : 1 });
+        if (r.ok && hib) {
+            hibrido.enfeitar(r.plano, { extras: hib.extras, partes, marca: roteiro.marca || {}, largura, altura });
+            r.resumo.estilo = 'hibrido';
+        }
+        if (r.ok) projeto.anotar(p.id, 'plano', `estilo ${hib ? 'hibrido' : 'cinema'}: ${r.resumo.cenas} cenas, ${r.resumo.segundos}s`);
         return r;
     }
     if (modo === 'video') {
@@ -1137,31 +1254,100 @@ async function prepararRoteiro(p, args) {
         fs.writeFileSync(arq, JSON.stringify(lista));
         const mp3 = path.join(p.pasta, 'midia', `narracao-${Date.now().toString(36)}.mp3`);
         // A voz de gente primeiro (Gemini, pelo servidor); o Edge é a reserva.
-        let v = await narrarComGemini(lista, mp3, { voz: args.voz || roteiro.voz,
-            direcao: estilo === 'impacto' ? 'Leia em português do Brasil como locutor de comercial agressivo e vendedor: energia alta, ritmo rápido, '
-                + 'voz encorpada, ênfase forte nas palavras de impacto, pausas curtas e secas entre as frases, sorrindo na voz.' : undefined });
+        // Com cache: refazer o vídeo (outro estilo, outra proporção) não gasta a cota da voz.
+        let v = await narrarComCache(lista, mp3, { voz: args.voz || roteiro.voz,
+            direcao: estilo === 'gerativo'
+                /* O gerativo pede voz com CORPO ("narração encorpada, extravagante",
+                   30/09): cheia, quente, perto do microfone — e o ritmo segue 1,12×. */
+                /* (A primeira versão pedia "trailer" e "ênfase sustentada": a voz saiu 25% mais lenta, medido em 30/09.) */
+                ? 'Leia em português do Brasil como locutor de reels de tecnologia: RÁPIDO e contínuo, com voz cheia, quente e encorpada, '
+                    + 'bem perto do microfone, muita energia e sorriso na voz. Ataque firme e ênfase curta e forte nas palavras de impacto; '
+                    + 'quase sem pausa entre as frases. Nunca arraste, nunca leia devagar nem solene.'
+                : estilo === 'impacto' ? 'Leia em português do Brasil como locutor de comercial agressivo e vendedor: energia alta, ritmo rápido, '
+                + 'voz encorpada, ênfase forte nas palavras de impacto, pausas curtas e secas entre as frases, sorrindo na voz.'
+                // "A narração tá lenta, deixa mais viva" (29/09): todo estilo fala com energia de reels.
+                : 'Leia em português do Brasil como narrador de reels de tecnologia: vivo, confiante e rápido, sorrindo na voz, '
+                + 'ênfase nas palavras que importam, pausas curtas entre as frases. Nada de leitura lenta ou solene.' });
         if (!v.ok) v = await rodarPython('narrar.py', ['roteiro', '--arquivo', arq, '--saida', mp3, '--voz', String(args.voz || roteiro.voz || 'thalita')], { timeout: 10 * 60000 });
         if (!v.ok) return v;
+        /* O RITMO DA VOZ. Mesmo com a direção, a voz sai no passo de leitura, e
+           o vídeo — que segue a voz palavra por palavra — sai lento junto. O
+           áudio acelera 1,12× (1,3× ficou corrido demais, 29/09; atempo não muda o tom) e cada tempo de palavra
+           acompanha; `roteiro.ritmoVoz` ajusta (1 desliga). */
+        const ritmo = Math.max(1, Math.min(1.5, Number(roteiro.ritmoVoz || args.ritmoVoz) || 1.12));
+        if (ritmo > 1.01) {
+            const rap = mp3.replace(/\.mp3$/, '-r.mp3');
+            const c = await video.rodar(video.ffmpeg(), ['-y', '-i', mp3, '-filter:a', `atempo=${ritmo.toFixed(3)}`, rap], { timeout: 120000 });
+            if (c.ok && fs.existsSync(rap)) {
+                fs.renameSync(rap, mp3);
+                const esc = (x) => (typeof x === 'number' ? Math.round((x / ritmo) * 1000) / 1000 : x);
+                v.segundos = esc(v.segundos);
+                v.partes = (v.partes || []).map((pt) => ({ ...pt, de: esc(pt.de), ate: esc(pt.ate),
+                    palavras: (pt.palavras || []).map((w) => ({ ...w, de: esc(w.de), ate: esc(w.ate) })) }));
+            }
+        }
         tempos = v.partes;
         narracao = path.relative(p.pasta, mp3).replace(/\\/g, '/');
         projeto.anotar(p.id, 'narracao', `${v.segundos}s em ${partes.length} partes, voz ${v.voz}`);
         // O motion usa os efeitos leves; os estilos de corte, os cheios.
-        sons = ehMotion ? sonsLeves.preparar(p.pasta) : await edicao.prepararSons(p.pasta, video);
+        // O gerativo tem a família de sons DELE (sintetizada da semente); os outros motion, os leves.
+        // O gerativo desenha os sons DEPOIS da partitura (um arquivo por evento, da própria trilha).
+        sons = estilo === 'gerativo' ? {}
+            : ehMotion ? sonsLeves.preparar(p.pasta) : await edicao.prepararSons(p.pasta, video);
         // A trilha do motion: ende.app (CC BY 4.0, sem Content ID), clima tecnologia.
         if (ehMotion) {
             try {
                 const segundos = tempos.length ? tempos[tempos.length - 1].ate + 2 : 20;
-                const m = await ende.provedor({ pasta: path.join(p.pasta, 'midia') }).gerar({ clima: roteiro.clima || 'tecnologia', segundos });
+                /* O gerativo escolhe o GÊNERO pelo assunto (jazz para o explainer,
+                   funk para o fone, eletrônica para IA…), sorteia a faixa e não
+                   repete as últimas usadas — nada de "inspiring corporate". */
+                let m = null;
+                const usadasArq = path.join(os.homedir(), '.primocode', 'studio', 'trilhas-usadas.json');
+                let usadas = [];
+                try { usadas = JSON.parse(fs.readFileSync(usadasArq, 'utf8')); } catch { usadas = []; }
+                const mus = estilo === 'gerativo' ? gerativo.musicaDe(roteiro) : null;
+                /* A trilha do gerativo vem do Jamendo (Openverse), pelo GÊNERO do
+                   assunto, instrumental, sorteada e sem repetir as últimas — a
+                   ende.app fica de reserva ("parar de cair sempre na ende", 30/09). */
+                if (mus) {
+                    const BUSCA = { jazz: 'jazz instrumental', 'lofi-chill-beats': 'lofi hip hop instrumental', electronica: 'electronic instrumental', funk: 'funk instrumental',
+                        'dance-club': 'house instrumental', ambient: 'ambient instrumental', acoustic: 'acoustic guitar instrumental', cinematic: 'cinematic instrumental',
+                        classical: 'piano classical instrumental', 'soul-rnb': 'soul instrumental' };
+                    try {
+                        const b = await assets.procurarMusica(BUSCA[roteiro.genero || mus.genero] || ((roteiro.genero || mus.genero) + ' instrumental'), { quantas: 8, duracaoMin: Math.max(45, segundos + 10) });
+                        const opcoes = (b.ok ? b.sons : []).filter((x) => x.url && !usadas.includes(x.url) && !/vocal|voice|feat|ft\.|remix/i.test(x.titulo || ''));
+                        for (let k = 0; k < opcoes.length && !m; k++) {
+                            const item = opcoes[(mus.semente + k) % opcoes.length];
+                            const d = await assets.baixar(item, { pasta: p.pasta, nome: 'trilha-' + (roteiro.genero || mus.genero) });
+                            if (!d.ok) continue;
+                            if (await temLetra(path.join(p.pasta, d.relativo))) { projeto.anotar(p.id, 'midia', `trilha com voz descartada: ${item.titulo}`); continue; }
+                            m = { src: path.join(p.pasta, d.relativo), credito: `Música: ${item.titulo} — ${item.autor || 'Jamendo'} (${item.licenca || 'CC'}, Jamendo)`, id: item.url, segundos: item.segundos };
+                        }
+                    } catch { /* cai na ende.app */ }
+                }
+                if (mus && m) {
+                    try { fs.writeFileSync(usadasArq, JSON.stringify([m.id, ...usadas.filter((x) => x !== m.id)].slice(0, 16))); } catch { /* sem memória */ }
+                    projeto.anotar(p.id, 'trilha', `gênero ${roteiro.genero || mus.genero} (Jamendo)`);
+                } else if (mus) {
+                    m = await ende.provedor({ pasta: path.join(p.pasta, 'midia') }).gerar({ clima: roteiro.clima || 'energetico', segundos, genero: roteiro.genero || mus.genero, semente: mus.semente, evitar: usadas });
+                    const id = m && Number((/ende-(\d+)\.mp3$/.exec(m.src) || [])[1]);
+                    if (id) try { fs.writeFileSync(usadasArq, JSON.stringify([id, ...usadas.filter((x) => x !== id)].slice(0, 16))); } catch { /* sem memória */ }
+                    if (m) projeto.anotar(p.id, 'trilha', `gênero ${roteiro.genero || mus.genero}`);
+                } else m = await ende.provedor({ pasta: path.join(p.pasta, 'midia') }).gerar({ clima: roteiro.clima || 'tecnologia', segundos });
                 if (m) { trilha = path.relative(p.pasta, m.src).replace(/\\/g, '/'); projeto.anotar(p.id, 'trilha', m.credito); }
             } catch { /* cai na busca de sempre */ }
         }
-        if (!trilha) try {
-            const b = await assets.procurarMusica(roteiro.musica || args.trilha || (estilo === 'impacto' ? 'epic energetic' : 'inspiring corporate'), { quantas: 6, duracaoMin: 45 });
-            for (const item of (b.ok ? b.sons : [])) {
-                const d = await assets.baixar(item, { pasta: p.pasta, nome: 'trilha' });
-                if (d.ok) { trilha = d.relativo; break; }
-            }
-        } catch { /* sem música */ }
+        // Termo pelo clima e faixa sorteada sem repetir — o "inspiring corporate" fixo era a mesma música em todo vídeo.
+        for (const termo of [args.trilha, ...variedade.termosTrilha(roteiro, estilo)].filter(Boolean)) {
+            if (trilha) break;
+            try {
+                const b = await assets.procurarMusica(termo, { quantas: 10, duracaoMin: 45 });
+                for (const item of variedade.ordenar(b.ok ? b.sons : [], 'trilha').slice(0, 3)) {
+                    const d = await assets.baixar(item, { pasta: p.pasta, nome: 'trilha' });
+                    if (d.ok) { trilha = d.relativo; variedade.marcar('trilha', item.url); projeto.anotar(p.id, 'trilha', `"${termo}": ${item.titulo}`); break; }
+                }
+            } catch { /* o próximo termo */ }
+        }
     }
     if (estilo === 'impacto' && modo === 'video') {
         // Os emojis das palavras FALADAS também (a batida mostra a fala).
@@ -1197,6 +1383,28 @@ async function prepararRoteiro(p, args) {
         if (r.ok) projeto.anotar(p.id, 'plano', `estilo ${estilo}: ${r.resumo.cenas} cenas, ${r.resumo.segundos}s${precisa ? (g ? ', vetor com os pontos da fonte' : ', vetor sem os pontos (sem a fonte)') : ''}`);
         return r;
     }
+    if (estilo === 'gerativo' && modo === 'video') {
+        /* A música a -18 LUFS (a voz sai a -14): os volumes do plano partem
+           daí — cheia no respiro, uns 9 dB abaixo quando a voz fala. */
+        if (trilha && !/-n18\.mp3$/.test(trilha)) {
+            const norm = path.join(p.pasta, 'midia', path.basename(trilha).replace(/\.[a-z0-9]+$/i, '') + '-n18.mp3');
+            /* A introdução da faixa fica de fora (ela começa morna): corta de 12% em
+               diante, com 0,4 s de entrada, no tamanho do vídeo. */
+            let ini = 0;
+            try { const md = await video.medir(path.join(p.pasta, trilha)); const tot = md.segundos || 0; const quer = (tempos.length ? tempos[tempos.length - 1].ate : 30) + 6; if (tot > quer + 8) ini = Math.min(tot * 0.12, tot - quer - 2); } catch { /* do começo */ }
+            const c = fs.existsSync(norm) ? { ok: true } : await video.rodar(video.ffmpeg(), ['-y', ...(ini > 1 ? ['-ss', ini.toFixed(2)] : []), '-i', path.join(p.pasta, trilha),
+                '-af', 'afade=t=in:st=0:d=0.4,loudnorm=I=-18:TP=-2:LRA=11', '-ar', '44100', norm], { timeout: 5 * 60000 });
+            if (c.ok && fs.existsSync(norm)) trilha = path.relative(p.pasta, norm).replace(/\\/g, '/');
+        }
+        const r = gerativo.montarGerativo({ roteiro, largura, altura, tempos, narracao, sons, trilha });
+        if (r.ok) {
+            const feitos = sonsLeves.prepararReceitas(p.pasta, r.somReceitas);
+            // Som que o ffmpeg não conseguiu fazer sai do plano (o vídeo não espera um arquivo que não existe).
+            r.plano.audio.efeitos = r.plano.audio.efeitos.filter((e) => Object.values(feitos).includes(e.src));
+        }
+        if (r.ok) projeto.anotar(p.id, 'plano', `estilo gerativo: ${r.resumo.batidas} batidas (${r.resumo.composicoes.join(' → ')}), ${r.resumo.segundos}s, semente ${r.resumo.semente}`);
+        return r;
+    }
     if (estilo === 'motion' && modo === 'video') {
         const r = motion.montarMotion({ roteiro, largura, altura, tempos, narracao, sons, trilha, imagens });
         if (r.ok) projeto.anotar(p.id, 'plano', `estilo motion: ${r.resumo.segundos}s contínuos, ${r.resumo.partes} partes, ${r.resumo.fps} fps`);