primocode 9.10.0 → 10.0.9

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,11 @@ 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');
+const { escolherEstilo, LEVES } = require('./estilo.js');
 const sonsLeves = require('./sons-leves.js');
 const ende = require('./ende.js');
 
@@ -222,7 +230,8 @@ function roteiroValido(r) {
     const partes = Array.isArray(x) ? x : x && x.partes;
     if (!Array.isArray(partes) || partes.length < 2) return null;
     const CINEMA = ['frase', 'montagem', 'numeros', 'escada', 'dia', 'depoimento', 'climax', 'final'];
-    if (!partes.every((pt) => pt && (composicao.TIPOS.includes(pt.tipo) || CINEMA.includes(pt.tipo)))) return null;
+    const NOVOS = ['logo', 'cores', 'produto'];   // vox.js e lancamento.js
+    if (!partes.every((pt) => pt && (composicao.TIPOS.includes(pt.tipo) || CINEMA.includes(pt.tipo) || NOVOS.includes(pt.tipo)))) return null;
     const obj = Array.isArray(x) ? { partes } : x;
     return partes.some((pt) => CINEMA.includes(pt.tipo)) && !obj.estilo ? { ...obj, estilo: 'cinema' } : obj;
 }
@@ -245,7 +254,6 @@ async function garantirAcervo(p) {
 /* O ROTEIRISTA do servidor: quando o modelo não manda um roteiro que preste
    (nenhum, ou texto corrido), o pedido e os fatos da marca viram o roteiro
    numa chamada só, com uma tarefa só. */
-const PEDE_MOTION = /\bmotion\b|anima[çc][ãa]o|animad[oa]/i;
 
 async function roteiroDoServidor(p, args) {
     const cfg = require('../config').loadConfig();
@@ -260,7 +268,7 @@ async function roteiroDoServidor(p, args) {
         site: acervo.site ? new URL(acervo.site).hostname.replace(/^www\./, '') : '',
         rascunho: typeof args.roteiro === 'string' ? args.roteiro : '',
         // Pedido de motion nunca vira impacto, nem sendo anúncio.
-        estilo: args.estilo || (!PEDE_MOTION.test(pedido) && /an[uú]nci|reels?|divulg|promo|lan[çc]a|vend|campanha|convite|inscri/i.test(pedido) ? 'impacto' : undefined),
+        estilo: args.estilo || (escolherEstilo({ pedido }) === 'impacto' ? 'impacto' : undefined),
     }, cfg.token);
     if (!r || !r.ok) return { ok: false, error: (r && r.erro) || 'o roteirista não respondeu.' };
     return { ok: true, roteiro: { ...r.roteiro, marca: (args.roteiro && args.roteiro.marca) || p.marca || undefined } };
@@ -302,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 });
@@ -318,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),
@@ -883,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 */ }
         }
     }
@@ -922,20 +932,33 @@ async function prepararRoteiro(p, args) {
         if (roteiro.marca.logo && !existe(roteiro.marca.logo)) roteiro.marca.logo = (p.marca && existe(p.marca.logo)) ? p.marca.logo : undefined;
     } else if (p.marca) roteiro.marca = p.marca;
     const partes = roteiro.partes || [];
-    /* O ESTILO. O padrão é MOTION (motion.js): um plano contínuo em 3D, com
-       um protagonista que se deforma de parte em parte — "isso sim é motion"
-       (Joel, 28/09). "limpo" era o nome antigo do padrão e vira motion
-       também. Anúncio, reels e venda vão para o "impacto" (corte a cada
-       batida), a menos que o pedido diga motion ou animação. A composição
-       antiga, uma cena por parte, só com estilo: "composicao". */
+    /* O ESTILO (estilo.js). O padrão é MOTION (motion.js): um plano contínuo
+       em 3D — "isso sim é motion" (Joel, 28/09). Explicação vira VOX
+       (editorial, tinta sobre papel), marca vira MARCA (brand reveal),
+       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 || ''}`;
-    // O estilo que o AGENTE pediu vale; o que o roteirista pôs no roteiro não
-    // passa por cima de um pedido de motion.
-    const pedido0 = args.estilo || (PEDE_MOTION.test(pedidoTxt) ? null : roteiro.estilo);
-    const estilo = pedido0 === 'limpo' ? 'motion' : (pedido0
-        || (PEDE_MOTION.test(pedidoTxt) ? 'motion'
-            : /an[uú]nci|reels?|divulg|promo|lan[çc]a|vend|campanha|convite|inscri/i.test(pedidoTxt) ? 'impacto' : 'motion'));
-    const ehMotion = estilo === 'motion';
+    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'));
     const [largura, altura] = PROPORCOES[roteiro.proporcao || args.proporcao] || (modo === 'slides' ? PROPORCOES['16:9'] : PROPORCOES['16:9']);
 
@@ -982,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).
@@ -1052,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 */ }
         }
@@ -1086,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) {
@@ -1127,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') {
@@ -1138,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).
@@ -1180,12 +1365,58 @@ async function prepararRoteiro(p, args) {
         if (r.ok) projeto.anotar(p.id, 'plano', `estilo impacto: ${r.resumo.cenas} batidas`);
         return r;
     }
-    if (ehMotion && modo === 'video') {
+    if (estilo === 'vox' && modo === 'video') {
+        const r = vox.montarVox({ roteiro, largura, altura, tempos, narracao, sons, trilha, imagens });
+        if (r.ok) projeto.anotar(p.id, 'plano', `estilo vox: ${r.resumo.cenas} cenas, ${r.resumo.segundos}s`);
+        return r;
+    }
+    if ((estilo === 'marca' || estilo === 'lancamento') && modo === 'video') {
+        /* As letras em vetor (a peça "vetor") pedem os pontos de verdade da
+           fonte: glifos.js lê o .ttf. Sem rede, o vetor desenha o contorno do
+           próprio texto, sem as alças. */
+        const m = roteiro.marca || {};
+        const nome = m.nome || (partes.find((pt) => pt.tipo === 'logo' || pt.tipo === 'abertura') || {}).titulo || '';
+        const precisa = partes.some((pt) => pt.tipo === 'logo' || pt.visual === 'vetor');
+        const g = precisa ? await glifos.palavra((partes.find((pt) => pt.tipo === 'logo') || {}).titulo || nome,
+            { fonte: (m.fontes && m.fontes.titulo) || (estilo === 'marca' ? 'Plus Jakarta Sans' : 'Inter Tight') }) : null;
+        const r = lancamento.montarLancamento({ roteiro, variante: estilo, largura, altura, tempos, narracao, sons, trilha, imagens, glifos: g });
+        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`);
         return r;
     }
-    return composicao.comporRoteiro({ roteiro, modo, largura, altura, tempos, narracao, sons, trilha, imagens, iconesOk, fundos });
+    /* A composição (e os slides) só conhece os tipos antigos: as partes novas
+       viram a mais parecida delas, e o roteiro do vídeo serve à página. */
+    const PARECIDA = { logo: 'abertura', cores: 'lista', produto: 'titulo' };
+    const paraComposicao = { ...roteiro, partes: partes.map((pt) => (PARECIDA[pt.tipo]
+        ? { ...pt, tipo: PARECIDA[pt.tipo], itens: pt.itens || (pt.cores || []).map((c) => (typeof c === 'string' ? c : c.nome)) }
+        : pt)) };
+    return composicao.comporRoteiro({ roteiro: paraComposicao, modo, largura, altura, tempos, narracao, sons, trilha, imagens, iconesOk, fundos });
 }
 
 /* Sem o tempo de cada palavra, cada trecho é repartido pelas palavras dele,