primocode 10.1.0 → 10.3.0-beta.0

package/lib/estudio/index.js

@@ -38,16 +38,23 @@ const hibrido = require('./hibrido.js');
 const biblioteca = require('./biblioteca.js');
 const referencias = require('./referencias.js');
 const variedade = require('./variedade.js');
+const diretor = require('./diretor.js');
+const falantes = require('./falantes.js');
 const variacao3d = require('./variacao3d.js');
 const plano = require('./plano.js');
 const remotion = require('./remotion.js');
 const assets = require('./assets.js');
 const video = require('./video.js');
+const batida = require('./batida.js');
+const revisor = require('./revisor.js');
+const assinatura = require('./assinatura.js');
 const identidade = require('./identidade.js');
 const slides = require('./slides.js');
 const edicao = require('./edicao.js');
 const composicao = require('./composicao.js');
 const acervoSite = require('./acervo-site.js');
+const printSite = require('./print-site.js');
+const efeitos = require('./efeitos.js');
 const impacto = require('./impacto.js');
 const cinema = require('./cinema.js');
 const motion = require('./motion.js');
@@ -198,6 +205,17 @@ async function ferramentaProjeto(args, ctx = {}) {
         return { ok: true };
     }
 
+    /* O FEEDBACK que vira estilo: "adorei a virada", "texto demais" fica na
+       assinatura da pessoa (assinatura.js), e o próximo vídeo já parte dele.
+       Sem texto, devolve a assinatura (as faixas e as notas). */
+    if (acao === 'assinatura' || acao === 'feedback' || acao === 'gostei') {
+        const nome = args.nome || args.assinatura || 'fluido';
+        if (!args.texto) { const a = assinatura.ler(nome); return a ? { ok: true, assinatura: a } : { ok: false, error: `a assinatura "${nome}" não existe.` }; }
+        const r = assinatura.anotar(nome, args.texto);
+        if (r.ok && args.id) projeto.anotar(args.id, 'assinatura', `feedback gravado na assinatura ${nome}: ${args.texto}`);
+        return r;
+    }
+
     const todos = projeto.listar({ limite: Number(args.limite) || 20 });
     return {
         ok: true,
@@ -260,7 +278,8 @@ function roteiroValido(r) {
     const CINEMA = ['frase', 'montagem', 'numeros', 'escada', 'dia', 'depoimento', 'climax', 'final'];
     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;
+    // Duas vozes: roteiro.vozes e parte.falante, limpos (falantes.js). Sem eles, nada muda.
+    const obj = falantes.normalizar(Array.isArray(x) ? { partes } : x);
     return partes.some((pt) => CINEMA.includes(pt.tipo)) && !obj.estilo ? { ...obj, estilo: 'cinema' } : obj;
 }
 
@@ -363,6 +382,13 @@ async function ferramentaPlano(args) {
         // 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(original || args.roteiro, null, 2)); } catch { /* segue */ }
         projeto.salvar(args.id, { duracao: conferida.duracao });
+        /* A memória da estrutura (diretor.cardapioEstruturas): o próximo roteiro
+           vê o que este usou. Uma vez por projeto — mandar o roteiro de novo
+           para ajustar uma frase não é um vídeo novo. */
+        if (!p.estrutura) {
+            const usada = diretor.registrarEstrutura(original || args.roteiro);
+            projeto.salvar(args.id, { estrutura: usada.estrutura || '-' });
+        }
         return {
             ok: true, duracao: conferida.duracao, ...r.resumo, resumo: plano.resumo(r.plano),
             proximo: 'estudio_render com este id. Para ajustar, mande o roteiro de novo (é rápido) — não edite as cenas à mão.',
@@ -435,6 +461,26 @@ async function ferramentaMidia(args) {
         return { ok: true, src: relativo, metodo: r.metodo, aviso: r.aviso || undefined };
     }
 
+    /* O print de verdade do site (print-site.js), para a peça 3D `printsite`.
+       Só roda quando o modelo pede: o cardápio diz quando vale. */
+    if (acao === 'print') {
+        if (!p) return { ok: false, error: 'para tirar o print é preciso dizer em qual projeto (id).' };
+        const r = await printSite.capturarSite(args.url || args.site || args.termo, { pasta: p.pasta, celular: !!args.celular, inteira: args.inteira !== false });
+        if (r.ok) projeto.anotar(p.id, 'midia', `print de ${r.url} (${r.tela}): ${r.src}`);
+        return r;
+    }
+
+    // O catálogo de efeitos que a IA escreveu (efeitos.js): guardar, listar, reusar.
+    if (acao === 'efeitos') return { ok: true, efeitos: efeitos.cardapio() };
+    if (acao === 'guardar-efeito' || acao === 'usar-efeito') {
+        if (!p) return { ok: false, error: 'diga em qual projeto (id).' };
+        const r = acao === 'guardar-efeito'
+            ? efeitos.guardar({ pasta: p.pasta, arquivo: args.arquivo || args.src, nome: args.nome, descricao: args.descricao, tags: args.tags })
+            : efeitos.reusar({ pasta: p.pasta, nome: args.nome });
+        if (r.ok) projeto.anotar(p.id, 'midia', `${acao === 'guardar-efeito' ? 'guardou' : 'reusou'} o efeito ${r.nome || args.nome}`);
+        return r;
+    }
+
     if (acao === 'logo') {
         if (!p) return { ok: false, error: 'para baixar a logo é preciso dizer em qual projeto (id).' };
         const nome = String(args.marca || args.nome || args.termo || '').trim();
@@ -666,7 +712,7 @@ async function ferramentaVideo(args, ctx = {}) {
         if ((args.estilo || 'viral') === 'viral' && args.recorte !== false) {
             const recortes = {};
             for (const [i, info] of montado.infos.entries()) {
-                if (!edicao.temRecorte(i) || !info.forte || info.forte.peso < 9 || Object.keys(recortes).length >= 3) continue;
+                if (!info.recorte || !info.forte || info.forte.peso < 9 || Object.keys(recortes).length >= 3) continue;
                 const de = Math.max(0, info.forte.de - 0.15);
                 const ate = Math.min(info.dur, de + 2.2);
                 if (ate - de < 1) continue;
@@ -715,6 +761,18 @@ async function ferramentaVideo(args, ctx = {}) {
    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). */
+/** A foto editorial (Wikimedia, museu) que os últimos vídeos não usaram; o crédito fica no caderno. */
+async function baixarEditorial(p, termo) {
+    try {
+        const b = await assets.procurarEditorial(termo, { quantas: 8 });
+        for (const item of variedade.ordenar(b.imagens, 'broll').slice(0, 4)) {
+            const d = await assets.baixar(item, { pasta: p.pasta, nome: 'foto-' + termo });
+            if (d.ok) { variedade.marcar('broll', item.url); projeto.anotar(p.id, 'creditos', item.creditos); return { src: d.relativo, tipo: 'imagem' }; }
+        }
+    } catch { /* sem foto */ }
+    return null;
+}
+
 async function baixarApoio(p, termo, { orientacao = null, video: querVideo = false } = {}) {
     if (querVideo) {
         try {
@@ -749,11 +807,26 @@ async function variarIcones(plano, roteiro) {
     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 */ }
+    for (const nome of variedade.iconesTrocaveis(plano, explicitos)) {
+        /* Primeiro O ÍCONE: o conceito escolhe entre as formas dele
+           (edicao.ALTERNATIVAS) pelos pontos da variedade — o que os últimos
+           vídeos menos usaram. Depois A COLEÇÃO. */
+        const base = nome.split(':')[1];
+        let escolhido = base;
+        const alts = edicao.ALTERNATIVAS[base];
+        if (alts) {
+            const ordem = variedade.ordenar([base, ...alts].map((url) => ({ url })), 'icone-nome').map((x) => x.url);
+            for (const n of ordem) {
+                if (n === base) { escolhido = base; break; }
+                try { const r = await assets.icone('fluent-3d:' + n); if (r && r.ok) { escolhido = n; break; } } catch { /* tenta o próximo */ }
+            }
+            variedade.marcar('icone-nome', escolhido);
+        }
+        let novo = 'fluent-3d:' + escolhido;
+        if (colecao !== 'fluent-3d') {
+            try { const r = await assets.icone(colecao + ':' + escolhido); if (r && r.ok) novo = colecao + ':' + escolhido; } catch { /* fica o 3D */ }
         }
+        if (novo !== nome) troca[nome] = novo;
     }
     const n = variedade.trocarIcones(plano, troca);
     if (n || colecao === 'fluent-3d') variedade.marcar('icones', colecao);
@@ -941,6 +1014,20 @@ function narrarReserva(lista, mp3, arq, voz, vozEdge, { soEdge = false, semKokor
     });
 }
 
+/* DUAS VOZES (falantes.js): os mp3 de cada falante, um depois do outro, num
+   arquivo só — reamostrados, porque o Gemini sai a 24 kHz e o Edge não. A
+   duração de cada um é MEDIDA: é ela que empurra os tempos do grupo seguinte. */
+async function juntarVozes(arquivos, mp3) {
+    const fil = arquivos.map((_, i) => `[${i}:a]aresample=44100,aformat=channel_layouts=mono[a${i}]`).join(';')
+        + ';' + arquivos.map((_, i) => `[a${i}]`).join('') + `concat=n=${arquivos.length}:v=0:a=1[s]`;
+    const c = await video.rodar(video.ffmpeg(), ['-y', ...arquivos.flatMap((a) => ['-i', a]), '-filter_complex', fil, '-map', '[s]',
+        '-c:a', 'libmp3lame', '-q:a', '3', mp3], { timeout: 120000 });
+    if (!c.ok) return { ok: false, error: 'não consegui juntar as vozes' };
+    const duracoes = [];
+    for (const a of arquivos) duracoes.push((await video.medir(a)).segundos);
+    return { ok: true, duracoes };
+}
+
 /* 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). */
@@ -986,6 +1073,14 @@ async function sonsReais(p, video) {
 const PROPORCOES = { '16:9': [1920, 1080], '9:16': [1080, 1920], '1:1': [1080, 1080], '4:5': [1080, 1350] };
 
 /** O roteiro vira plano: baixa o que falta, narra, e chama o compositor. */
+/* A ASSINATURA (assinatura.js): o vídeo é medido e conferido contra as
+   faixas do estilo; o que saiu volta para o agente e fica no caderno. */
+function conferirAssinatura(p, r, nome) {
+    const fora = assinatura.descrever(assinatura.conferir(nome, assinatura.medir(r.partitura, r.plano)).fora);
+    r.resumo.assinatura = { nome, seguiu: !fora.length, fora: fora.length ? fora : undefined };
+    projeto.anotar(p.id, 'assinatura', fora.length ? `fora da assinatura ${nome}: ${fora.join('; ')}` : `seguiu a assinatura ${nome}`);
+}
+
 async function prepararRoteiro(p, args) {
     const roteiro = typeof args.roteiro === 'string' ? JSON.parse(args.roteiro) : args.roteiro;
     if (Array.isArray(roteiro)) return prepararRoteiro(p, { ...args, roteiro: { partes: roteiro } });
@@ -1008,16 +1103,13 @@ async function prepararRoteiro(p, args) {
        IMPACTO. O que o agente pediu vale mais que tudo. */
     const pedidoTxt = `${p.pedido || ''} ${args.pedido || ''}`;
     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;
+    /* Sem imagem é o padrão (07/10): sem o pedido dizer, nada de foto nem
+       vídeo de fora. Ninguém escolheu o estilo? Ele gira (estilo.js) — sem
+       imagem, só entre os que não vivem de foto. O híbrido e o cinema, pedidos
+       pelo nome sem imagem, caem para o gerativo (sem nada baixado). */
+    const semImagem = referencias.semImagem(ref);
+    let estilo = escolherEstilo({ pedido: pedidoTxt, agente: args.estilo, roteiro: roteiro.estilo, girar: true, semImagem });
+    if (semImagem && (estilo === 'hibrido' || estilo === 'cinema')) estilo = 'gerativo';
     /* "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. */
@@ -1040,14 +1132,22 @@ async function prepararRoteiro(p, args) {
         roteiro.semente = p.semente != null ? p.semente : Math.floor(Math.random() * 1e9);
         if (p.semente == null) projeto.salvar(p.id, { semente: roteiro.semente });
     }
+    /* O humor, a paleta, as fontes e o gênero do gerativo, com memória entre
+       vídeos (09/10, "vício em cores, músicas, fontes"): por PROJETO, como a semente. */
+    // O assunto do vídeo é o rótulo da moldura (quando ela sai): o título do projeto.
+    if (estilo === 'gerativo' && !roteiro.titulo && p.titulo) roteiro.titulo = p.titulo;
+    if (estilo === 'gerativo' && !roteiro.escolhasGerativo) {
+        roteiro.escolhasGerativo = p.escolhasGerativo || gerativo.escolherVisual(roteiro);
+        if (!p.escolhasGerativo) projeto.salvar(p.id, { escolhasGerativo: roteiro.escolhasGerativo });
+    }
     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(', '));
+        const v = biblioteca.vestir(roteiro, { estilo });
+        if (v.mudou) projeto.anotar(p.id, 'visual', [v.titulo && `fonte ${v.titulo} + ${v.texto} (tom ${v.tom})`, 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);
@@ -1079,13 +1179,13 @@ async function prepararRoteiro(p, args) {
     const videosMarca = [...(acervo.videos || [])];
     const imagens = {}, fundos = {};
     for (const [i, parte] of partes.entries()) {
-        if (parte.tipo !== 'imagem' || parte.src) continue;
+        if (semImagem || parte.tipo !== 'imagem' || parte.src) continue;
         const texto = `${parte.titulo || ''} ${parte.sub || ''} ${parte.fala || ''} ${parte.busca || ''}`;
         if (modo === 'video' && videosMarca.length && i % 2 === 1) { imagens[i] = { src: videosMarca.shift().src, tipo: 'video' }; continue; }
         const m = melhorFoto(texto) || (parte.busca ? await baixarApoio(p, parte.busca, { orientacao: largura >= altura ? 'landscape' : 'portrait', video: modo === 'video' }) : null);
         if (m) imagens[i] = m;
     }
-    if (acervo.fotos.length) {
+    if (acervo.fotos.length && !semImagem) {
         const comFundo = ['abertura', 'titulo', 'contraste', 'citacao', 'cta', 'passos'];
         let alterna = 0;
         for (const [i, parte] of partes.entries()) {
@@ -1109,7 +1209,13 @@ async function prepararRoteiro(p, args) {
         // 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).
-        const lista = partes.filter((pt) => pt.tipo !== 'depoimento' && cinema.falaDe(pt) !== '' && !pt.falaForte).map((pt) => ({ texto: cinema.falaDe(pt), registro: 'normal' }));
+        const comVoz = partes.filter((pt) => pt.tipo !== 'depoimento' && cinema.falaDe(pt) !== '' && !pt.falaForte);
+        const lista = comVoz.map((pt) => ({ texto: cinema.falaDe(pt), registro: 'normal' }));
+        // Duas vozes: a voz de cada parte pelo falante dela (roteiro.vozes).
+        const vozesL = falantes.vozesDasPartes(comVoz, roteiro, args.voz || roteiro.voz);
+        const variasVozes = new Set(vozesL).size > 1;
+        const DIRECAO_CINEMA = 'Leia em português do Brasil como narrador de trailer de marca premium: voz grave, confiante e humana, '
+            + 'ritmo firme, pausas curtas entre as frases, sem arrastar.';
         const mp3 = path.join(p.pasta, 'midia', `narracao-${Date.now().toString(36)}.mp3`);
         /* O CACHE DA VOZ: a mesma fala, na mesma voz, não é gerada duas vezes.
            Refazer o roteiro em outro formato, ou mexer numa cena, não gasta a
@@ -1120,7 +1226,20 @@ async function prepararRoteiro(p, args) {
         let v = null;
         // motorVoz "edge": a voz do Edge direto, sem esperar a cota do Gemini ("a narração pode manter a do Edge", 25/09).
         const soEdge = String(roteiro.motorVoz || args.motorVoz || '').toLowerCase() === 'edge';
-        if (soEdge) {
+        if (variasVozes) {
+            /* Um grupo por falante, cada um com a sua voz e o seu cache (a chave
+               do narrarComCache leva a voz). Falhou? Fica anotado, e a reserva
+               de baixo narra numa voz só — melhor o vídeo do que nada. */
+            v = await falantes.narrarPorFalante(lista.map((x, i) => ({ ...x, voz: vozesL[i] })), mp3, { juntar: juntarVozes,
+                narrarUm: async (l, m, voz) => {
+                    const g = soEdge ? { ok: false } : await narrarComCache(l, m, { voz, direcao: DIRECAO_CINEMA });
+                    if (g.ok) return g;
+                    const a = m.replace(/\.mp3$/, '.json');
+                    fs.writeFileSync(a, JSON.stringify(l));
+                    return narrarReserva(l, m, a, voz, 'antonio', { soEdge });
+                } });
+            if (!v.ok) projeto.anotar(p.id, 'narracao', `as duas vozes falharam (${v.error}); saiu numa voz só`);
+        } else if (soEdge) {
             v = { ok: false, error: 'edge pedido' };
         } else if (fs.existsSync(cacheMp3) && fs.existsSync(cacheJson)) {
             fs.copyFileSync(cacheMp3, mp3);
@@ -1139,9 +1258,7 @@ async function prepararRoteiro(p, args) {
         } 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, '
-                    + 'ritmo firme, pausas curtas entre as frases, sem arrastar.' });
+            v = await narrarComGemini(lista, mp3, { voz: args.voz || roteiro.voz, direcao: DIRECAO_CINEMA });
             if (v.ok) {
                 try { fs.mkdirSync(cacheDir, { recursive: true }); fs.copyFileSync(mp3, cacheMp3); fs.writeFileSync(cacheJson, JSON.stringify({ voz: v.voz, segundos: v.segundos, partes: v.partes })); } catch { /* sem cache */ }
             }
@@ -1316,12 +1433,14 @@ async function prepararRoteiro(p, args) {
                 // falaForte: true → a voz forte lê o texto da tela.
                 const textoForte = pt.falaForte === true ? cinema.falaDe({ ...pt, fala: undefined }) : pt.falaForte;
                 const soEdgeF = String(roteiro.motorVoz || args.motorVoz || '').toLowerCase() === 'edge';
+                // A voz forte é a de quem fala a parte (duas vozes), não sempre a do narrador.
+                const vozForte = falantes.vozesDasPartes([pt], roteiro, args.voz || roteiro.voz)[0];
                 const vf = soEdgeF ? await (async () => {
                     // No Edge, a ênfase é o registro "contraste": a mesma voz, um pouco mais firme.
                     const arqJ = arqF.replace(/\.mp3$/, '.json');
                     fs.writeFileSync(arqJ, JSON.stringify([{ texto: textoForte, registro: 'contraste' }]));
-                    return rodarPython('narrar.py', ['roteiro', '--arquivo', arqJ, '--saida', arqF, '--voz', String(args.voz || roteiro.voz || 'antonio')], { timeout: 5 * 60000 });
-                })() : await narrarComCache([{ texto: textoForte }], arqF, { voz: args.voz || roteiro.voz,
+                    return rodarPython('narrar.py', ['roteiro', '--arquivo', arqJ, '--saida', arqF, '--voz', String(vozForte || 'antonio')], { timeout: 5 * 60000 });
+                })() : await narrarComCache([{ texto: textoForte }], arqF, { voz: vozForte,
                     // A MESMA voz do narrador, só com um pouco mais de ênfase: "não é mudar a voz, é só um pouco a entonação" (25/09).
                     direcao: pt.entonacao || 'Leia em português do Brasil com a mesma voz e o mesmo ritmo de um narrador de trailer de marca: '
                         + 'confiante e natural, só um pouco mais de ênfase nas palavras principais. Sem dramatizar.' });
@@ -1356,8 +1475,7 @@ async function prepararRoteiro(p, args) {
         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.
         // 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'
+        const 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.) */
@@ -1371,9 +1489,19 @@ async function prepararRoteiro(p, args) {
                 + '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) });
+                + 'ênfase nas palavras que importam, pausas curtas entre as frases. Nada de leitura lenta ou solene.';
+        /* Uma voz por falante (falantes.js). Com uma voz só, um grupo só: é a
+           narração de sempre, com o mesmo cache. */
+        const vozesL = falantes.vozesDasPartes(partes, roteiro, args.voz || roteiro.voz);
+        let v = await falantes.narrarPorFalante(lista.map((x, i) => ({ ...x, voz: vozesL[i] })), mp3, { juntar: juntarVozes,
+            narrarUm: async (l, m, voz) => {
+                const g = await narrarComCache(l, m, { voz, direcao });
+                if (g.ok) return g;
+                // O Kokoro pedido já foi tentado no narrarComCache: a reserva não repete.
+                const a = m === mp3 ? arq : m.replace(/\.mp3$/, '.json');
+                if (a !== arq) fs.writeFileSync(a, JSON.stringify(l));
+                return narrarReserva(l, m, a, voz, 'thalita', { semKokoro: kokoro.querKokoro(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
@@ -1408,9 +1536,8 @@ async function prepararRoteiro(p, args) {
                    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 = []; }
+                // A memória da trilha é a da variedade ('trilha'): antes era um arquivo à parte (trilhas-usadas.json).
+                const usadas = variedade.usadas('trilha');
                 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
@@ -1421,9 +1548,10 @@ async function prepararRoteiro(p, args) {
                         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 || ''));
+                        // Pelos pontos da variedade: a recente e a muito usada vão para o fim, não somem.
+                        const opcoes = variedade.ordenar((b.ok ? b.sons : []).filter((x) => !/vocal|voice|feat|ft\.|remix/i.test(x.titulo || '')), 'trilha');
                         for (let k = 0; k < opcoes.length && !m; k++) {
-                            const item = opcoes[(mus.semente + k) % opcoes.length];
+                            const item = opcoes[k];
                             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; }
@@ -1432,12 +1560,12 @@ async function prepararRoteiro(p, args) {
                     } 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 */ }
+                    variedade.marcar('trilha', m.id);
                     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 (id) variedade.marcar('trilha', id);
                     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); }
@@ -1502,18 +1630,71 @@ async function prepararRoteiro(p, args) {
                 '-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 });
+        /* O herói que o roteiro pediu do Iconify ("mdi:bread-slice"): o desenho é
+           baixado aqui (fica em midia/icones); o que não baixar, a batida fica sem. */
+        const icones = {};
+        for (const pt of partes) {
+            const h = typeof (pt.heroi != null ? pt.heroi : pt.icone) === 'string' ? String(pt.heroi != null ? pt.heroi : pt.icone).trim() : '';
+            if (!/^[a-z0-9-]+:[a-z0-9-]+$/i.test(h) || icones[h]) continue;
+            try { const ic = await assets.icone(h, { pasta: p.pasta }); if (ic && ic.ok) icones[h] = ic.svg; else projeto.anotar(p.id, 'icones', `herói ${h} não baixou: ${(ic && ic.error) || '?'}`); } catch { /* fica sem */ }
+        }
+        const r = gerativo.montarGerativo({ roteiro, largura, altura, tempos, narracao, sons, trilha, icones });
         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}`);
+        if (r.ok) conferirAssinatura(p, r, roteiro.assinatura || 'gerativo');
         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`);
+        /* A CARA de cada vídeo do fluido, por PROJETO (ajustar uma frase não
+           troca): a semente (marcador, jeito das imagens) e a paleta, que a
+           memória de variedade não repete do vídeo anterior (08/10: "sempre o
+           mesmo azul"). A paleta ou o tema pedidos mandam. */
+        if (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 });
+        }
+        /* O modelo também vicia: pedia "noite" em todo vídeo (era a primeira da
+           lista). A paleta dele vale, menos quando é uma das 2 últimas usadas —
+           aí vem a menos usada do mesmo tema (escura ou clara). */
+        if (!p.paletaFluido) {
+            const P = fluido.PALETAS, nomes = Object.keys(P);
+            const pedida = P[String(roteiro.paleta || '').toLowerCase()] ? String(roteiro.paleta).toLowerCase() : null;
+            const recentes = variedade.usadas('paleta-fluido').slice(0, 2);
+            const escuro = pedida ? P[pedida].escuro : /escuro|dark/i.test(roteiro.tema || '') ? true : /claro|light/i.test(roteiro.tema || '') ? false : null;
+            let escolha = pedida && !recentes.includes(pedida) ? pedida : null;
+            if (!escolha) escolha = variedade.sortear(nomes.filter((n) => escuro == null || P[n].escuro === escuro), 'paleta-fluido');
+            else variedade.marcar('paleta-fluido', escolha);
+            if (pedida && escolha !== pedida) projeto.anotar(p.id, 'visual', `paleta ${pedida} pedida, mas foi a de um dos últimos vídeos: ${escolha}`);
+            projeto.salvar(p.id, { paletaFluido: escolha });
+            p.paletaFluido = escolha;
+        }
+        roteiro.paleta = p.paletaFluido;
+        // O trio de fontes, também por projeto e sem repetir os últimos vídeos (09/10, "vício em fontes").
+        if (!p.fontesFluido) { p.fontesFluido = fluido.escolherFontes(roteiro.fontesFluido); projeto.salvar(p.id, { fontesFluido: p.fontesFluido }); }
+        roteiro.fontesFluido = p.fontesFluido;
+        /* As IMAGENS do fluido misto, só com imagem pedida: as partes com
+           "busca", no máximo 1 em 3 e espalhadas (fluido.js decide o jeito). */
+        const fotosFluido = {};
+        if (!semImagem) {
+            const comBusca = partes.map((pt, k) => (pt.busca || pt.src ? k : -1)).filter((k) => k >= 0 && (partes[k].tipo !== 'cta'));
+            const teto = Math.max(1, Math.floor(partes.length / 3));
+            const escolhidas = [];
+            for (const k of comBusca) if (escolhidas.length < teto && !escolhidas.some((j) => Math.abs(j - k) < 2)) escolhidas.push(k);
+            for (const k of escolhidas) {
+                const pt = partes[k];
+                // O acervo EDITORIAL (assets.procurarEditorial), não o banco de stock: sem foto que sirva, a parte fica sem imagem.
+                const m = pt.src ? { src: pt.src } : await baixarEditorial(p, pt.busca);
+                if (m && m.src) fotosFluido[k] = { src: m.src };
+            }
+            if (Object.keys(fotosFluido).length) projeto.anotar(p.id, 'midia', `fluido misto: imagem nas partes ${Object.keys(fotosFluido).map((k) => Number(k) + 1).join(', ')}`);
+        }
+        const r = fluido.montarFluido({ imagens: fotosFluido, roteiro: { ...roteiro, pedido: roteiro.pedido || pedidoTxt }, largura, altura, tempos, narracao, sons, trilha });
+        if (r.ok) projeto.anotar(p.id, 'plano', `estilo fluido: ${r.resumo.batidas} batidas${r.resumo.imagens.length ? ` (imagens: ${r.resumo.imagens.join(', ')})` : ''}, 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`);
+        if (r.ok) conferirAssinatura(p, r, roteiro.assinatura || 'fluido');
         return r;
     }
     if (estilo === 'motion' && modo === 'video') {
@@ -1600,10 +1781,34 @@ async function ferramentaRender(args, ctx = {}) {
             problemas: conferida.problemas.slice(0, 12) };
     }
 
+    /* A REVISÃO (revisor.js): o plano roda; agora, ele está bom? Conserta a
+       receita (transição repetida, câmera sem respiro, som duplicado) e
+       devolve o resto como aviso para quem fez o plano. */
+    const revisao = revisor.revisar(pl, { semImagem: referencias.semImagem() });
+    if (revisao.consertos.length) projeto.anotar(args.id, 'revisao', revisao.consertos.join('; '));
+    if (revisao.avisos.length) projeto.anotar(args.id, 'revisao', 'avisos: ' + revisao.avisos.join('; '));
+
     // Os ícones vêm ANTES do render: um render que busca ícone na internet
     // falha no meio, depois de vinte minutos.
     const { mapa, faltaram } = await assets.iconesDoPlano(pl, p.pasta);
 
+    /* A MÚSICA NO CORTE (batida.js): a faixa começa no ponto em que as
+       batidas caem nos cortes do plano, e o corte de impacto num acento. Só
+       quando ninguém disse o início (audio.trilha.inicio). */
+    const tr = pl.audio && pl.audio.trilha;
+    if (tr && !(typeof tr === 'object' && tr.inicio != null) && !(p.formato === 'slides' || p.formato === 'arte' || args.paginas)) {
+        try {
+            const src = path.join(p.pasta, tr.src || tr);
+            const analise = await batida.analisar(src, { ffmpeg: video.ffmpeg() || 'ffmpeg' });
+            if (analise && analise.batidas.length) {
+                const duracao = (pl.cenas || []).reduce((n, c) => n + (Number(c.duracao) || 0), 0);
+                const r = batida.melhorInicio(batida.cortesDoPlano(pl), analise, { maximo: Math.min(20, analise.segundos - duracao - 0.5) });
+                pl.audio.trilha = { ...(typeof tr === 'object' ? tr : { src: tr }), inicio: r.inicio };
+                projeto.anotar(args.id, 'trilha', `${analise.bpm} BPM; a faixa entra em ${r.inicio}s e ${r.alinhados} de ${r.total} cortes caem na batida`);
+            }
+        } catch { /* sem análise, a faixa entra do começo */ }
+    }
+
     const montado = remotion.montar({ pasta: p.pasta, titulo: p.titulo, plano: pl, icones: mapa });
 
     if (args.somenteProjeto) {
@@ -1669,7 +1874,9 @@ async function ferramentaRender(args, ctx = {}) {
     return {
         ok: true, arquivo: saida, bytes, segundos: conferida.duracao,
         faltaram: faltaram.length ? faltaram : undefined,
-        aviso: 'ABERTO para o usuário assistir. Chame finish dizendo o que foi feito.',
+        revisao: revisao.consertos.length || revisao.avisos.length ? { consertado: revisao.consertos, avisos: revisao.avisos } : undefined,
+        aviso: 'ABERTO para o usuário assistir. Chame finish dizendo o que foi feito'
+            + (revisao.avisos.length ? ' — e cite os avisos da revisão que valem um novo plano.' : '.'),
     };
 }
 
@@ -1803,8 +2010,8 @@ async function ferramentaSite(args) {
     return r;
 }
 
-module.exports = {
+module.exports = { variarIcones,
     ferramentaProjeto, ferramentaPlano, ferramentaMidia, ferramentaNarrar,
     ferramentaVideo, ferramentaRender, ferramentaSite,
-    projeto, plano, remotion, assets, video, identidade, slides, python, rodarPython, alinharPartes, prepararRoteiro,
+    projeto, plano, remotion, assets, video, identidade, slides, python, rodarPython, alinharPartes, prepararRoteiro, roteiroValido, juntarVozes,
 };