primocode 10.0.9 → 10.2.0

package/lib/estudio/index.js

@@ -35,12 +35,16 @@ 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');
 const video = require('./video.js');
+const batida = require('./batida.js');
+const revisor = require('./revisor.js');
 const identidade = require('./identidade.js');
 const slides = require('./slides.js');
 const edicao = require('./edicao.js');
@@ -50,7 +54,9 @@ 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');
@@ -153,9 +159,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',
@@ -199,6 +207,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']) {
@@ -317,6 +347,8 @@ async function ferramentaPlano(args) {
         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. */
@@ -384,7 +416,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.' };
     }
 
@@ -636,7 +668,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;
@@ -682,27 +714,81 @@ 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). */
+/** 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 {
-            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 = {};
+    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);
+    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
@@ -867,11 +953,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). */
@@ -903,7 +1001,7 @@ async function sonsReais(p, video) {
         for (const termo of variedade.termosSfx(nome)) {
             if (sons[nome] !== sint[nome]) break;
             try {
-                const b = await assets.procurarSom(termo, { quantas: 10 });
+                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; }
@@ -939,24 +1037,44 @@ 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();
-    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;
+    /* 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. */
     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 (!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, { 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);
     const modo = (args.modo || roteiro.modo || (p.formato === 'slides' || p.formato === 'arte' ? 'slides' : 'video'));
@@ -987,13 +1105,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()) {
@@ -1044,6 +1162,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, '
@@ -1056,7 +1176,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,
@@ -1171,20 +1291,27 @@ async function prepararRoteiro(p, args) {
                 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)) {
+                    // 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 });
+                        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 b = await assets.procurarImagens(termo, { quantas: 3, orientacao });
-                    for (const item of (b.ok ? b.imagens : []).slice(0, 1)) {
+                    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 });
+                        if (d.ok) { out.push({ src: d.relativo, tipo: 'imagem', cat: cat(termo), alt: termo }); variedade.marcar('broll', item.url); }
                     }
                 } catch { /* sem */ }
                 return out;
@@ -1241,7 +1368,7 @@ async function prepararRoteiro(p, args) {
         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, ritmoLeitura: hib ? 0.55 : 1 });
         if (r.ok && hib) {
-            hibrido.enfeitar(r.plano, { extras: hib.extras, partes, marca: roteiro.marca || {}, largura, altura });
+            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`);
@@ -1263,18 +1390,23 @@ async function prepararRoteiro(p, args) {
                 ? '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.' });
-        if (!v.ok) v = await rodarPython('narrar.py', ['roteiro', '--arquivo', arq, '--saida', mp3, '--voz', String(args.voz || roteiro.voz || 'thalita')], { timeout: 10 * 60000 });
+        // 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). */
-        const ritmo = Math.max(1, Math.min(1.5, Number(roteiro.ritmoVoz || args.ritmoVoz) || 1.12));
+        // 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 });
@@ -1302,9 +1434,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
@@ -1315,9 +1446,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; }
@@ -1326,12 +1458,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); }
@@ -1405,6 +1537,51 @@ async function prepararRoteiro(p, args) {
         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') {
+        /* 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;
+        /* 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`);
+        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`);
@@ -1489,10 +1666,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) {
@@ -1558,7 +1759,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.' : '.'),
     };
 }
 
@@ -1692,7 +1895,7 @@ 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,