primocode 10.0.0 → 10.1.0

package/lib/estudio/index.js

@@ -34,6 +34,11 @@ const { spawn } = require('child_process');
 
 const projeto = require('./projeto.js');
 const acervo = require('./acervo.js');
+const hibrido = require('./hibrido.js');
+const biblioteca = require('./biblioteca.js');
+const referencias = require('./referencias.js');
+const variedade = require('./variedade.js');
+const variacao3d = require('./variacao3d.js');
 const plano = require('./plano.js');
 const remotion = require('./remotion.js');
 const assets = require('./assets.js');
@@ -46,7 +51,10 @@ 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 fluido = require('./fluido.js');
 const vox = require('./vox.js');
+const kokoro = require('./kokoro.js');
 const lancamento = require('./lancamento.js');
 const glifos = require('./glifos.js');
 const { escolherEstilo, LEVES } = require('./estilo.js');
@@ -149,9 +157,11 @@ function semProjeto(id) {
     };
 }
 
-async function ferramentaProjeto(args) {
+async function ferramentaProjeto(args, ctx = {}) {
     const acao = String(args.acao || 'listar').toLowerCase();
 
+    if (acao === 'editar' || acao === 'editor' || acao === 'studio') return editarNoStudio(args, ctx);
+
     if (acao === 'criar' || acao === 'novo') {
         const r = projeto.criar({
             titulo: args.titulo, pedido: args.pedido || args.titulo, formato: args.formato || 'video',
@@ -195,6 +205,28 @@ async function ferramentaProjeto(args) {
     };
 }
 
+/* EDITAR um vídeo que o Estúdio fez: abre o projeto Remotion dele no
+   Remotion Studio. Sem id, é o projeto mais novo. */
+async function editarNoStudio(args, ctx = {}) {
+    const p = args.id ? projeto.ler(args.id) : projeto.listar({ limite: 1 })[0];
+    if (!p) return semProjeto(args.id);
+    const raiz = path.join(p.pasta, 'remotion');
+    if (!fs.existsSync(path.join(raiz, 'package.json'))) {
+        // Projeto que ainda não virou Remotion: escreve agora, sem renderizar.
+        const m = await ferramentaRender({ id: p.id, somenteProjeto: true }, ctx);
+        if (!m.ok) return m;
+    }
+    const r = remotion.abrirStudio({ raiz, spawnar: ctx.spawnar });
+    if (!r.ok) return { ...r, pasta: raiz };
+    projeto.anotar(p.id, 'editor', 'abriu no Remotion Studio');
+    return {
+        ok: true, id: p.id, pasta: raiz, comando: r.comando,
+        aviso: 'O Remotion Studio está ABRINDO no navegador (geralmente http://localhost:3000). '
+            + `Diga ao usuário onde está o projeto: ${raiz}. Lá ele mexe e renderiza pelo botão Render do Studio. `
+            + 'Cuidado: estudio_render reescreve a pasta src/ a partir do plano e apaga o que ele mudou à mão.',
+    };
+}
+
 function listarArquivos(pasta) {
     const saida = {};
     for (const sub of ['entrada', 'midia', 'saida']) {
@@ -306,8 +338,15 @@ 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;
+        const ic = await variarIcones(r.plano, original);
+        if (ic.trocados) projeto.anotar(p.id, 'icones', `coleção ${ic.colecao}: ${ic.trocados} ícones`);
         let conferida = plano.conferir(r.plano, { pasta: p.pasta });
         /* A rede de segurança: o elemento que não passa sai, e o vídeo segue.
            Um defeito num ícone não pode custar o vídeo inteiro. */
@@ -322,7 +361,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),
@@ -375,7 +414,7 @@ async function ferramentaMidia(args) {
 
     if (acao === 'fontes') {
         if (args.conferir) return assets.conferirFonte(args.conferir);
-        return { ok: true, fontes: assets.FONTES,
+        return { ok: true, fontes: assets.FONTES, biblioteca: biblioteca.cardapio(),
             nota: 'qualquer família do Google Fonts funciona — esta lista é para não repetir sempre as mesmas.' };
     }
 
@@ -673,27 +712,54 @@ async function ferramentaVideo(args, ctx = {}) {
 }
 
 /* A mídia de apoio de um termo: vídeo do Pexels quando pedido e houver,
-   senão a primeira foto que baixar. Devolve {src, tipo} ou null. */
+   senão uma foto. Devolve {src, tipo} ou null. O clipe sai sorteado entre
+   os que os últimos vídeos não usaram (variedade.js), não o primeiro da
+   busca — "o b-roll veio igual nos dois vídeos" (Joel, 05/10). */
 async function baixarApoio(p, termo, { orientacao = null, video: querVideo = false } = {}) {
     if (querVideo) {
         try {
-            const b = await assets.procurarVideos(termo, { quantas: 4, orientacao });
-            for (const item of (b.ok ? b.videos : []).filter((v) => !v.duracao || v.duracao >= 3)) {
+            const itens = await variedade.buscarSemRepetir(async (t) => {
+                const b = await assets.procurarVideos(t, { quantas: 8, orientacao });
+                return (b.ok ? b.videos : []).filter((v) => !v.duracao || v.duracao >= 3);
+            }, termo);
+            for (const item of itens.slice(0, 4)) {
                 const d = await assets.baixar(item, { pasta: p.pasta, nome: 'apoio-' + termo });
-                if (d.ok) return { src: d.relativo, tipo: 'video' };
+                if (d.ok) { variedade.marcar('broll', item.url); return { src: d.relativo, tipo: 'video' }; }
             }
         } catch { /* cai para a foto */ }
     }
     try {
-        const b = await assets.procurarImagens(termo, { quantas: 4, orientacao });
-        for (const item of (b.ok ? b.imagens : [])) {
+        const itens = await variedade.buscarSemRepetir(async (t) => {
+            const b = await assets.procurarImagens(t, { quantas: 8, orientacao });
+            return b.ok ? b.imagens : [];
+        }, termo);
+        for (const item of itens.slice(0, 4)) {
             const d = await assets.baixar(item, { pasta: p.pasta, nome: 'apoio-' + termo });
-            if (d.ok) return { src: d.relativo, tipo: 'imagem' };
+            if (d.ok) { variedade.marcar('broll', item.url); return { src: d.relativo, tipo: 'imagem' }; }
         }
     } catch { /* sem apoio */ }
     return null;
 }
 
+/* Os ícones automáticos trocam de coleção a cada vídeo (Joel, 05/10: "várias
+   opções de ícones... que não sejam padrão da IA"). O ícone que o roteiro
+   pediu pelo nome fica; o que não existe na coleção sorteada fica no 3D. */
+async function variarIcones(plano, roteiro) {
+    const colecao = variedade.colecaoIcones();
+    const explicitos = [];
+    try { JSON.stringify(roteiro || {}, (k, v) => { if (k === 'icone' && typeof v === 'string') explicitos.push(v); return v; }); } catch { /* sem */ }
+    const troca = {};
+    if (colecao !== 'fluent-3d') {
+        for (const nome of variedade.iconesTrocaveis(plano, explicitos)) {
+            const novo = colecao + ':' + nome.split(':')[1];
+            try { const r = await assets.icone(novo); if (r && r.ok) troca[nome] = novo; } catch { /* fica o 3D */ }
+        }
+    }
+    const n = variedade.trocarIcones(plano, troca);
+    if (n || colecao === 'fluent-3d') variedade.marcar('icones', colecao);
+    return { colecao, trocados: n };
+}
+
 /* ── A VOZ DO GEMINI ─────────────────────────────────────────────────────
  * O roteiro inteiro numa chamada só (o plano grátis tem poucos pedidos por
  * minuto), e as partes achadas depois na transcrição do próprio áudio: a
@@ -858,11 +924,23 @@ async function narrarComCache(lista, mp3, { voz, direcao } = {}) {
     const dir = path.join(os.homedir(), '.primocode', 'studio', 'cache-voz');
     const cm = path.join(dir, chave + '.mp3'), cj = path.join(dir, chave + '.json');
     if (fs.existsSync(cm) && fs.existsSync(cj)) { fs.copyFileSync(cm, mp3); return { ok: true, ...JSON.parse(fs.readFileSync(cj, 'utf8')) }; }
+    // A voz local pedida (voz: 'kokoro'): direto nela, sem gastar a cota do Gemini.
+    if (kokoro.querKokoro(voz)) return kokoro.narrar(lista, mp3, { voz, uv: acharUv() });
     const v = await narrarComGemini(lista, mp3, { voz, direcao });
     if (v.ok) { try { fs.mkdirSync(dir, { recursive: true }); fs.copyFileSync(mp3, cm); fs.writeFileSync(cj, JSON.stringify({ voz: v.voz, segundos: v.segundos, partes: v.partes })); } catch { /* sem cache */ } }
     return v;
 }
 
+/* A VOZ DE RESERVA, quando o Gemini falha: o Kokoro (local, sem cota) e
+   depois o Edge. A falha de uma passa para a próxima, nunca derruba. */
+function narrarReserva(lista, mp3, arq, voz, vozEdge, { soEdge = false, semKokoro = false } = {}) {
+    const passos = kokoro.ordem(voz, process.env, { soEdge }).filter((n) => n !== 'gemini' && !(semKokoro && n === 'kokoro'));
+    return kokoro.corrente(passos, {
+        kokoro: () => kokoro.narrar(lista, mp3, { voz, uv: acharUv() }),
+        edge: () => rodarPython('narrar.py', ['roteiro', '--arquivo', arq, '--saida', mp3, '--voz', String(kokoro.querKokoro(voz, {}) ? vozEdge : voz || vozEdge)], { timeout: 10 * 60000 }),
+    });
+}
+
 /* A MÚSICA TEM LETRA? O acervo não diz se a faixa é instrumental, então ela
    é ouvida: 25 s do meio vão para a transcrição, e mais de 6 palavras é voz
    cantada. Sem servidor para ouvir, a faixa passa (melhor música que nenhuma). */
@@ -887,21 +965,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, livre: true });
+                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 +1007,48 @@ 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();
+    /* Ninguém escolheu? O padrão gira (estilo.js, RODIZIO) — menos no "sem
+       referências", que só tem o motion e segue a regra de baixo. */
+    let estilo = escolherEstilo({ pedido: pedidoTxt, agente: args.estilo, roteiro: roteiro.estilo, girar: ref.modo !== 'sem' });
+    /* "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 = variacao3d.modeloDoPedido(pedidoTxt);
+    }
+    // O 3D de cada vídeo: acabamento, câmera, luz e ritmo sorteados sem repetir os últimos.
+    /* Por PROJETO, não por chamada: mandar o roteiro de novo para ajustar uma
+       frase não pode sortear outro 3D nem outro vídeo. Projeto novo, sorteio novo. */
+    if (roteiro.modelo3d && !roteiro.variacao3d) {
+        roteiro.variacao3d = p.variacao3d || variacao3d.escolherVariacao3d();
+        if (!p.variacao3d) projeto.salvar(p.id, { variacao3d: roteiro.variacao3d });
+    }
+    /* A SEMENTE do gerativo saía do texto do roteiro: o mesmo roteiro dava o
+       mesmo vídeo, batida por batida (05/10). Sem semente do roteiro, cada
+       projeto sorteia a sua. */
+    if (estilo === 'gerativo' && roteiro.semente == null) {
+        roteiro.semente = p.semente != null ? p.semente : Math.floor(Math.random() * 1e9);
+        if (p.semente == null) projeto.salvar(p.id, { semente: roteiro.semente });
+    }
+    if (ref.modo === 'fechado' && !roteiro.busca && referencias.termos().length) roteiro.busca = referencias.termos();
+    /* A BIBLIOTECA (biblioteca.js): sem fonte e cor da marca, o híbrido, o
+       cinema e o impacto caíam sempre no Inter e no azul e roxo — "os vídeos
+       todos iguais" (02/10). A marca manda; depois o roteiro.visual da IA;
+       sem nada, o sorteio que pula o que os últimos vídeos usaram. */
+    if (['hibrido', 'cinema', 'impacto'].includes(estilo)) {
+        const v = biblioteca.vestir(roteiro);
+        if (v.mudou) projeto.anotar(p.id, 'visual', [v.titulo && `fonte ${v.titulo} + ${v.texto}`, v.paleta && `paleta ${v.paleta}`].filter(Boolean).join(', '));
+    }
     // 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 +1097,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).
@@ -1012,6 +1136,8 @@ async function prepararRoteiro(p, args) {
                     }
                 } catch { /* fica o alinhamento guardado */ }
             }
+        } else if (kokoro.querKokoro(args.voz || roteiro.voz)) {
+            v = { ok: false, error: 'kokoro pedido' };
         } else {
             v = await narrarComGemini(lista, mp3, { voz: args.voz || roteiro.voz,
                 direcao: 'Leia em português do Brasil como narrador de trailer de marca premium: voz grave, confiante e humana, '
@@ -1024,7 +1150,7 @@ async function prepararRoteiro(p, args) {
             const arq = path.join(p.pasta, 'midia', `roteiro-${Date.now().toString(36)}.json`);
             // Ritmo NORMAL: o "citação" (-10%, respiro longo) esticou o vídeo para 125 s.
             fs.writeFileSync(arq, JSON.stringify(lista.map((x) => ({ ...x, registro: 'normal' }))));
-            v = await rodarPython('narrar.py', ['roteiro', '--arquivo', arq, '--saida', mp3, '--voz', String(args.voz || roteiro.voz || 'antonio')], { timeout: 10 * 60000 });
+            v = await narrarReserva(lista, mp3, arq, args.voz || roteiro.voz, 'antonio', { soEdge });
         }
         if (!v.ok) return v;
         /* A DURAÇÃO que o roteiro pede ("60–75 s"): se a voz passa do que cabe,
@@ -1051,20 +1177,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 +1230,76 @@ 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 {
+                    // Sorteado entre os não usados, com o termo variado (variedade.js, 05/10).
+                    const itens = await variedade.buscarSemRepetir(async (t) => {
+                        const b = await assets.procurarVideos(t, { quantas: 8, orientacao });
+                        return (b.ok ? b.videos : []).filter((v) => !v.duracao || v.duracao >= 4);
+                    }, termo);
+                    for (const item of itens.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 }); variedade.marcar('broll', item.url); }
+                    }
+                } 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 itens = await variedade.buscarSemRepetir(async (t) => {
+                        const b = await assets.procurarImagens(t, { quantas: 8, orientacao });
+                        return b.ok ? b.imagens : [];
+                    }, termo);
+                    for (const item of itens.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 }); variedade.marcar('broll', item.url); }
+                    }
+                } 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 +1340,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, hud: roteiro.hud === true, particulas: roteiro.particulas === true });
+            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 +1355,105 @@ 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 });
-        if (!v.ok) v = await rodarPython('narrar.py', ['roteiro', '--arquivo', arq, '--saida', mp3, '--voz', String(args.voz || roteiro.voz || 'thalita')], { timeout: 10 * 60000 });
+        // 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.'
+                // O fluido é o vídeo de produto: voz limpa e segura, e rápida ("mais rápido", 06/10).
+                : estilo === 'fluido' ? 'Leia em português do Brasil como narrador de vídeo de produto premium: seguro, próximo e RÁPIDO, '
+                    + 'frases limpas e contínuas, quase sem pausa entre elas. Nunca arraste, nunca leia devagar; sem tom de anúncio.'
+                : 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.' });
+        // O Kokoro pedido já foi tentado no narrarComCache: a reserva não repete.
+        if (!v.ok) v = await narrarReserva(lista, mp3, arq, args.voz || roteiro.voz, 'thalita', { semKokoro: kokoro.querKokoro(args.voz || roteiro.voz) });
         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). */
+        // O fluido corre mais ("mais rápido", 06/10): 1,22× por padrão.
+        const ritmo = Math.max(1, Math.min(1.5, Number(roteiro.ritmoVoz || args.ritmoVoz) || (estilo === 'fluido' ? 1.22 : 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 +1489,33 @@ 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 === 'fluido' && modo === 'video') {
+        const r = fluido.montarFluido({ roteiro, largura, altura, tempos, narracao, sons, trilha });
+        if (r.ok) projeto.anotar(p.id, 'plano', `estilo fluido: ${r.resumo.batidas} batidas, paleta ${r.resumo.paleta}, ${r.resumo.segundos}s, batida atrasada no máximo ${r.resumo.atraso}s, palavra atrás da voz no máximo ${r.resumo.sincronia}s`);
+        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`);