primocode 10.4.7 → 10.6.0

package/lib/estudio/index.js

@@ -66,9 +66,12 @@ const kokoro = require('./kokoro.js');
 const lancamento = require('./lancamento.js');
 const glifos = require('./glifos.js');
 const personagem = require('./personagem.js');
+const mundo = require('./mundo.js');
+const colecao = require('./colecao.js');
 const { escolherEstilo, LEVES } = require('./estilo.js');
 const sonsLeves = require('./sons-leves.js');
 const ende = require('./ende.js');
+const producao = require('./producao.js');
 
 const PY = path.join(__dirname, '..', '..', 'studio');
 
@@ -162,7 +165,7 @@ function semProjeto(id) {
         ok: false,
         error: `não achei o projeto "${id}".`,
         comoResolver: 'liste com estudio_projeto acao:"listar" e use um id de lá — '
-            + 'o id é o nome da pasta (ex: "2026-09-22-anuncio-picpay"), não o título.',
+            + 'o id é o nome da pasta (ex: "anuncio-picpay"), não o título.',
     };
 }
 
@@ -187,6 +190,9 @@ async function ferramentaProjeto(args, ctx = {}) {
             // O caderno é o que faz "mexe naquela parte" funcionar semanas
             // depois: sem ele, reabrir diz o que existe e nunca por quê.
             caderno: projeto.caderno(args.id, { ultimas: 25 }),
+            // A conversa das sessões em que se mexeu neste projeto (AGENTS.md
+            // da pasta dele, lib/agents-md.js): o que foi pedido e decidido.
+            memoria: require('../agents-md.js').ler(p.pasta) || undefined,
             plano: pl ? plano.resumo(pl) : 'ainda não há plano',
             versoes: projeto.versoes(args.id),
             arquivos: listarArquivos(p.pasta),
@@ -518,6 +524,23 @@ async function ferramentaMidia(args) {
         return r;
     }
 
+    /* A BIBLIOTECA (colecao.js, 11/10): o cardápio inteiro, o ícone 3D e a
+       animação pronta. Procurar não usa rede (o índice mora no pacote); com
+       id, baixa para o projeto e devolve o elemento pronto. */
+    if (acao === 'biblioteca' || acao === 'cardapio' || acao === 'cardápio') return colecao.cardapio();
+    if (acao === 'icones3d' || acao === 'icone3d' || acao === 'animacoes' || acao === 'animacao' || acao === 'animação' || acao === 'animações') {
+        const ehAnim = /^anima/.test(acao);
+        if (args.id_item || /^(fluent3d|noto):/.test(String(args.item || args.baixar || ''))) {
+            const pj = p ? projeto.ler(p.id) : null;
+            const fmt = (pj && pj.formato) || {};
+            const r = await colecao.baixar(args.id_item || args.item || args.baixar, { pasta: p ? p.pasta : null, largura: fmt.largura || 1920, altura: fmt.altura || 1080 });
+            if (r.ok && p) projeto.anotar(p.id, 'midia', `biblioteca: ${r.src} (${r.licenca})`);
+            return r;
+        }
+        return ehAnim ? colecao.procurarAnimacoes(args.termo || args.busca || '', { quantas: Number(args.quantas) || 10 })
+            : colecao.procurarIcones3d(args.termo || args.busca || '', { quantas: Number(args.quantas) || 10 });
+    }
+
     if (acao === 'icones' || acao === 'icone') {
         if (args.nome) {
             const r = await assets.icone(args.nome, { pasta: p ? p.pasta : null });
@@ -1051,12 +1074,24 @@ async function prepararDepoimento(p, c) {
         origem: { src: c.src, de: c.de, ate: c.ate, frase: c.frase }, ...(c.fraseDita ? { frase: c.fraseDita } : {}) };
 }
 
+/* O tom de cada estilo, em UMA frase de instrução, em inglês e terminando em
+   dois-pontos, que é a forma que o Gemini TTS entende como instrução e não
+   como fala. Se ainda vazar, o corte de vazamentoNoComeco tira (as palavras
+   ditas antes do roteiro são quase todas daqui). */
+const DIRECAO_DA_VOZ = {
+    gerativo: 'Read aloud in Brazilian Portuguese as a tech reels narrator: full, warm voice close to the mic, energetic and smiling, no long pauses:',
+    fluido: 'Read aloud in Brazilian Portuguese as a premium product video narrator: confident and close, clean sentences that flow into each other, no ad tone:',
+    personagem: 'Read aloud in Brazilian Portuguese as someone really talking on a podcast: natural and close, never like an announcer:',
+    impacto: 'Read aloud in Brazilian Portuguese as an energetic ad announcer: full voice, strong emphasis on the impact words:',
+    padrao: 'Read aloud in Brazilian Portuguese as a lively tech reels narrator: confident, smiling, emphasis on the words that matter:',
+};
+
 /* A narração com cache (a mesma fala, na mesma direção, não é gerada duas vezes). */
 async function narrarComCache(lista, mp3, { voz, direcao } = {}) {
-    /* 'v2' (10/10): as narrações guardadas antes do corte da direção lida em
-       voz alta ("Rápido e contínuo.") ficam para trás — reaproveitar uma delas
-       trazia o vazamento de volta mesmo com o conserto. */
-    const chave = require('crypto').createHash('sha1').update(JSON.stringify(['v2', lista.map((x) => x.texto), voz || '', direcao || ''])).digest('hex').slice(0, 16);
+    /* 'v3' (11/10): as narrações guardadas com a direção antiga (a que tinha
+       "RÁPIDO" e "contínuas") ficam para trás — reaproveitar uma delas trazia o
+       "Rápido e contínuo." de volta mesmo com a direção nova. */
+    const chave = require('crypto').createHash('sha1').update(JSON.stringify(['v3', lista.map((x) => x.texto), voz || '', direcao || ''])).digest('hex').slice(0, 16);
     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')) }; }
@@ -1067,13 +1102,42 @@ async function narrarComCache(lista, mp3, { voz, direcao } = {}) {
     return v;
 }
 
+/* A PRODUÇÃO (producao.js): cada necessidade — voz, trilha, efeitos — pela
+   corrente de provedores dela, com o cache do projeto. `roteiro.provedores`
+   ({ voz: 'kokoro' }) passa um provedor para a frente, e o caderno guarda
+   quem produziu cada coisa. */
+async function produzirNecessidade(p, roteiro, pedido, provedores) {
+    const r = await producao.produzirUma(pedido, provedores, { escolha: ((roteiro && roteiro.provedores) || {})[pedido.tipo], cache: producao.cacheDe(p.pasta) });
+    projeto.anotar(p.id, 'producao', producao.linhaCaderno(r), { necessidade: pedido.tipo, provedor: r.quem || null, cache: !!r.doCache });
+    return r;
+}
+
+/* A voz como provedores, na ordem do kokoro.ordem: o Gemini (com o cache e a
+   direção dele), o Kokoro local e o Edge. A falha de uma passa para a próxima. */
+function provedoresDeVoz(lista, mp3, arq, voz, vozEdge, { soEdge = false, gemini, escolha } = {}) {
+    const todos = {
+        gemini: () => gemini(),
+        kokoro: () => kokoro.narrar(lista, mp3, { voz, uv: acharUv() }),
+        edge: () => {
+            // Ritmo NORMAL: o "citação" (-10%, respiro longo) esticou o vídeo para 125 s.
+            if (!fs.existsSync(arq)) fs.writeFileSync(arq, JSON.stringify(lista.map((x) => ({ ...x, registro: 'normal' }))));
+            return narrarReserva(lista, mp3, arq, voz, vozEdge, { soEdge: true });
+        },
+    };
+    const comResultado = (f) => async () => { const v = await f(); return v && v.ok ? { ...v, arquivo: mp3 } : v; };
+    const ordem = kokoro.ordem(voz, process.env, { soEdge });
+    // A escolhida no roteiro entra mesmo fora da ordem (o produzirUma a põe na frente).
+    if (escolha && todos[escolha] && !ordem.includes(escolha)) ordem.push(escolha);
+    return ordem.map((nome) => ({ nome, gerar: comResultado(todos[nome]) }));
+}
+
 /* 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 }),
+        edge: () => rodarPython('narrar.py', ['roteiro', '--arquivo', arq, '--saida', mp3, '--voz', kokoro.vozNoEdge(voz, vozEdge)], { timeout: 10 * 60000 }),
     });
 }
 
@@ -1181,6 +1245,11 @@ async function prepararRoteiro(p, args) {
         if (!args.estilo && estilo !== 'lancamento') estilo = 'gerativo';
         if (!roteiro.modelo3d) roteiro.modelo3d = variacao3d.modeloDoPedido(pedidoTxt);
     }
+    // O bicho do vídeo 3D não fala com voz de gente (a menos que o pedido peça): sai da narração e fica na cena.
+    if (estilo === 'personagem') {
+        const calados = personagem.calarBichos(roteiro, pedidoTxt);
+        if (calados.length) projeto.anotar(p.id, 'plano', `sem fala (bicho): ${calados.map((c) => `${c.nome} (${c.especie})`).join(', ')} — fica na cena; para falar, peça "${calados[0].especie} falante"`);
+    }
     // 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. */
@@ -1302,35 +1371,38 @@ async function prepararRoteiro(p, args) {
                     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);
-            v = { ok: true, ...JSON.parse(fs.readFileSync(cacheJson, 'utf8')), doCache: true };
-            // Cache sem as palavras (vindo de um plano antigo): transcreve de novo e realinha — sem gastar voz.
-            if (!(v.partes || []).some((pt) => (pt.palavras || []).length)) {
-                try {
-                    const cfg = require('../config').loadConfig();
-                    const tr = await require('../api').requestTranscricao(cfg.server, { token: cfg.token, audio: fs.readFileSync(mp3).toString('base64'), nome: 'voz.mp3', idioma: 'pt' });
-                    if (tr && (tr.palavras || []).length) {
-                        v.partes = alinharPartes(lista, tr.palavras, v.segundos);
-                        fs.writeFileSync(cacheJson, JSON.stringify({ voz: v.voz, segundos: v.segundos, partes: v.partes }));
-                    }
-                } catch { /* fica o alinhamento guardado */ }
+            if (!v.ok) {
+                const arq = path.join(p.pasta, 'midia', `roteiro-${Date.now().toString(36)}.json`);
+                fs.writeFileSync(arq, JSON.stringify(lista.map((x) => ({ ...x, registro: 'normal' }))));
+                v = await narrarReserva(lista, mp3, arq, args.voz || roteiro.voz, 'antonio', { soEdge });
             }
-        } 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: 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 */ }
-            }
-        }
-        if (!v.ok) {
             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 narrarReserva(lista, mp3, arq, args.voz || roteiro.voz, 'antonio', { soEdge });
+            const gemini = async () => {
+                if (fs.existsSync(cacheMp3) && fs.existsSync(cacheJson)) {
+                    fs.copyFileSync(cacheMp3, mp3);
+                    const g = { ok: true, ...JSON.parse(fs.readFileSync(cacheJson, 'utf8')), doCache: true };
+                    // Cache sem as palavras (vindo de um plano antigo): transcreve de novo e realinha — sem gastar voz.
+                    if (!(g.partes || []).some((pt) => (pt.palavras || []).length)) {
+                        try {
+                            const cfg = require('../config').loadConfig();
+                            const tr = await require('../api').requestTranscricao(cfg.server, { token: cfg.token, audio: fs.readFileSync(mp3).toString('base64'), nome: 'voz.mp3', idioma: 'pt' });
+                            if (tr && (tr.palavras || []).length) {
+                                g.partes = alinharPartes(lista, tr.palavras, g.segundos);
+                                fs.writeFileSync(cacheJson, JSON.stringify({ voz: g.voz, segundos: g.segundos, partes: g.partes }));
+                            }
+                        } catch { /* fica o alinhamento guardado */ }
+                    }
+                    return g;
+                }
+                const g = await narrarComGemini(lista, mp3, { voz: args.voz || roteiro.voz, direcao: DIRECAO_CINEMA });
+                if (g.ok) {
+                    try { fs.mkdirSync(cacheDir, { recursive: true }); fs.copyFileSync(mp3, cacheMp3); fs.writeFileSync(cacheJson, JSON.stringify({ voz: g.voz, segundos: g.segundos, partes: g.partes })); } catch { /* sem cache */ }
+                }
+                return g;
+            };
+            v = await produzirNecessidade(p, roteiro, { tipo: 'voz', chave: [lista.map((x) => x.texto), args.voz || roteiro.voz || '', 'cinema-v1', soEdge], destino: mp3 },
+                provedoresDeVoz(lista, mp3, arq, args.voz || roteiro.voz, 'antonio', { soEdge, gemini, escolha: (roteiro.provedores || {}).voz }));
         }
         if (!v.ok) return v;
         /* A DURAÇÃO que o roteiro pede ("60–75 s"): se a voz passa do que cabe,
@@ -1374,25 +1446,32 @@ async function prepararRoteiro(p, args) {
             }
         }
         projeto.anotar(p.id, 'narracao', `${v.segundos}s em ${lista.length} partes, voz ${v.voz}`);
-        const sonsC = await sonsReais(p, video);
-        let trilhaC = null;
+        /* A chave leva o id do projeto e o hash das falas. Só `cinema` fazia um
+           roteiro novo, no mesmo projeto, reaproveitar os efeitos do anterior. */
+        const marcaSfx = require('crypto').createHash('sha1').update(JSON.stringify({ id: p.id || '', falas: partes.map((pt) => cinema.falaDe(pt)) })).digest('hex').slice(0, 16);
+        const sonsC = (await produzirNecessidade(p, roteiro, { tipo: 'sfx', chave: [p.id || '', marcaSfx] },
+            [{ nome: 'openverse', gerar: async () => ({ sons: await sonsReais(p, video) }) }])).sons || {};
         // 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.
         // 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: 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; variedade.marcar('trilha', item.url);
-                    projeto.anotar(p.id, 'trilha', `"${termo}": ${item.titulo} — ${item.autor || 'Jamendo'} (${item.licenca || 'CC'})`);
-                    break;
+        let trilhaC = (await produzirNecessidade(p, roteiro, { tipo: 'trilha', chave: ['cinema', roteiro.clima || '', roteiro.genero || ''] },
+            [{ nome: 'jamendo', gerar: async () => {
+                for (const termo of [...variedade.termosTrilha(roteiro, 'cinema'), 'instrumental']) {
+                    try {
+                        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; }
+                            variedade.marcar('trilha', item.url);
+                            const credito = `"${termo}": ${item.titulo} — ${item.autor || 'Jamendo'} (${item.licenca || 'CC'})`;
+                            projeto.anotar(p.id, 'trilha', credito);
+                            return { src: d.relativo, credito };
+                        }
+                    } catch { /* o próximo termo */ }
                 }
-            } catch { /* o próximo termo */ }
-        }
+                return null;
+            } }])).src || null;
         /* A MÚSICA mais baixa na origem: a faixa vem masterizada alta e comprimida,
            e mesmo a 30% ela cobria a voz e o depoimento ("a música tá muito
            alta, não dá pra ouvir as pessoas", 25/09). Ela vai a -28 LUFS antes
@@ -1439,11 +1518,12 @@ async function prepararRoteiro(p, args) {
                 try { fs.unlinkSync(path.join(p.pasta, rel)); } catch { /* fica o original */ }
                 return 'midia/' + destino;
             };
+            // banco: true marca o que veio do banco (Pexels): a rota produto prefere a tela da marca (hibrido.ancorar).
             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 });
+                if (jaTem.includes(proxy)) out.push({ src: 'midia/' + proxy, tipo: 'video', cat: cat(termo), alt: termo, banco: true });
                 else try {
                     // Sorteado entre os não usados, com o termo variado (variedade.js, 05/10).
                     const itens = await variedade.buscarSemRepetir(async (t) => {
@@ -1453,11 +1533,11 @@ async function prepararRoteiro(p, args) {
                     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); }
+                        if (l) { out.push({ src: l, tipo: 'video', cat: cat(termo), alt: termo, banco: true }); 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 });
+                if (foto) out.push({ src: 'midia/' + foto, tipo: 'imagem', cat: cat(termo), alt: termo, banco: true });
                 else try {
                     const itens = await variedade.buscarSemRepetir(async (t) => {
                         const b = await assets.procurarImagens(t, { quantas: 8, orientacao });
@@ -1465,7 +1545,7 @@ async function prepararRoteiro(p, args) {
                     }, 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); }
+                        if (d.ok) { out.push({ src: d.relativo, tipo: 'imagem', cat: cat(termo), alt: termo, banco: true }); variedade.marcar('broll', item.url); }
                     }
                 } catch { /* sem */ }
                 return out;
@@ -1524,7 +1604,9 @@ 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, hud: roteiro.hud === true, particulas: roteiro.particulas === true });
+            hibrido.enfeitar(r.plano, { extras: hib.extras, partes, marca: roteiro.marca || {}, largura, altura, hud: roteiro.hud === true, particulas: roteiro.particulas === true,
+                // O b-roll de cada frase troca 0,2 s depois da palavra-âncora (hibrido.ancorar).
+                tempos: v.partes, fortes, fotos: fotosC });
             r.resumo.estilo = 'hibrido';
         }
         if (r.ok) projeto.anotar(p.id, 'plano', `estilo ${hib ? 'hibrido' : 'cinema'}: ${r.resumo.cenas} cenas, ${r.resumo.segundos}s`);
@@ -1538,38 +1620,52 @@ 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.
-        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.) */
-                /* Sem a ênfase em caixa alta logo no começo ("rápido" gritado): era
-                   exatamente o trecho que o Gemini lia em voz alta (10/10). */
-                ? 'Leia em português do Brasil como locutor de reels de tecnologia, num ritmo rápido e sem pausas, 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.'
-                // O personagem CONVERSA: voz de gente falando com gente, não de locutor.
-                : estilo === 'personagem' ? 'Fale em português do Brasil como alguém conversando de verdade num podcast: natural, próximo, '
-                    + 'com as pausas e a entonação de quem está pensando junto. Sem voz de locutor, sem leitura.'
-                : 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.';
+        /* A DIREÇÃO DA VOZ. O servidor manda a direção e o texto no MESMO pedido,
+           e o Gemini às vezes lê o começo dela em voz alta: todo vídeo do fluido
+           abria com "Rápido e contínuo." (11/10, "em tudo ela coloca isso, pode
+           ser um negócio de padaria"). Então a direção é curta, descreve só o
+           TOM, e não tem palavra solta que soe como a primeira frase de um
+           roteiro ("rápido", "contínuo", caixa alta). A velocidade não vem
+           daqui: vem do atempo (ritmoVoz) depois da voz pronta. */
+        const direcao = DIRECAO_DA_VOZ[estilo] || DIRECAO_DA_VOZ.padrao;
         /* 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) });
-            } });
+        let v = await produzirNecessidade(p, roteiro, { tipo: 'voz', chave: [lista.map((x) => x.texto), vozesL, direcao], destino: mp3 }, [{
+            nome: ((roteiro.provedores || {}).voz) || 'estudio',
+            gerar: async () => {
+                let reserva = false, gemini = false;
+                const comLista = lista.map((x, i) => ({ ...x, voz: vozesL[i] }));
+                const pelaReserva = async (l, m, voz) => {
+                    // 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));
+                    const rr = await narrarReserva(l, m, a, voz, 'thalita', { semKokoro: kokoro.querKokoro(voz) });
+                    if (rr && rr.ok) reserva = true;
+                    return rr;
+                };
+                let r = await falantes.narrarPorFalante(comLista, mp3, { juntar: juntarVozes,
+                    narrarUm: async (l, m, voz) => {
+                        const g = await narrarComCache(l, m, { voz, direcao });
+                        if (g.ok) { gemini = true; return g; }
+                        return pelaReserva(l, m, voz);
+                    } });
+                /* UMA VOZ SÓ POR VÍDEO (11/10, "os personagens falam com vozes
+                   diferentes em cada cena"): a cota do Gemini acabava no meio, e o
+                   mesmo personagem saía Gemini numa fala e reserva na outra. Se
+                   misturou, o vídeo inteiro é refeito na reserva — pior que o
+                   Gemini, mas cada um com a mesma voz do começo ao fim. */
+                if (r && r.ok && reserva && gemini) {
+                    gemini = false;
+                    r = await falantes.narrarPorFalante(comLista, mp3, { juntar: juntarVozes, narrarUm: pelaReserva });
+                }
+                /* A voz de RESERVA (Kokoro/Edge, quando o Gemini falhou) não vai para o
+                   cache do projeto: guardada, ela voltava em todo refazer do mesmo
+                   texto, mesmo com o Gemini de pé — era a "voz robótica que não sai"
+                   (11/10). Na próxima vez o Gemini é tentado de novo. */
+                return r && r.ok ? { ...r, arquivo: mp3, ...(reserva ? { naoGuardar: true } : {}) } : r;
+            },
+        }]);
         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
@@ -1703,6 +1799,15 @@ async function prepararRoteiro(p, args) {
         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 (/^(fluent3d|noto):/i.test(h) && !icones[h]) {
+                // O herói da biblioteca: o PNG 3D ou o Lottie, baixado para o projeto.
+                try {
+                    const r = await colecao.baixar(h, { pasta: p.pasta, largura, altura });
+                    if (r.ok) icones[h] = /^noto:/i.test(h) ? { lottie: r.src } : { png: r.src };
+                    else projeto.anotar(p.id, 'icones', `herói ${h} não baixou: ${r.error || '?'}`);
+                } catch { /* fica sem */ }
+                continue;
+            }
             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 */ }
         }
@@ -1766,8 +1871,22 @@ async function prepararRoteiro(p, args) {
         return r;
     }
     if (estilo === 'personagem' && modo === 'video') {
-        const r = personagem.montarPersonagem({ roteiro, largura, altura, tempos, narracao, sons, trilha });
-        if (r.ok) projeto.anotar(p.id, 'plano', `estilo personagem: ${r.resumo.elenco.join(' e ')} no set ${r.resumo.cenario}, ${r.resumo.planos} planos, ${r.resumo.segundos}s`);
+        const r = personagem.montarPersonagem({ roteiro: { ...roteiro, pedido: roteiro.pedido || pedidoTxt }, largura, altura, tempos, narracao, sons, trilha });
+        if (r.ok) {
+            /* O que não é peça do catálogo vira ícone 3D da biblioteca, em blocos
+               (kit/mundo.jsx): "uma pizza que fala", "um violão na praia". Sem
+               ícone, a peça sai da cena (e a coisa que fala vira o mascote). */
+            const achados = {};
+            for (const nome of mundo.iconesPendentes(r.partitura)) {
+                const id = colecao.melhorIcone3d(nome, 40);
+                if (!id) continue;
+                const b = await colecao.baixar(id, { pasta: p.pasta, largura, altura }).catch(() => null);
+                if (b && b.ok) achados[nome] = b.src;
+            }
+            mundo.aplicarIcones(r.partitura, achados);
+            const icones = Object.keys(achados);
+            projeto.anotar(p.id, 'plano', `estilo personagem: ${r.resumo.elenco.join(' e ')}${r.resumo.figurantes.length ? ` (+ ${r.resumo.figurantes.join(', ')})` : ''} em ${r.resumo.lugares.join(' → ')}, ${r.resumo.planos} planos, ${r.resumo.segundos}s${icones.length ? `; em blocos: ${icones.join(', ')}` : ''}`);
+        }
         return r;
     }
     if (estilo === 'motion' && modo === 'video') {

package/lib/estudio/kit/animacao.jsx

@@ -0,0 +1,41 @@
+/* kit/animacao.jsx — a animação pronta (Lottie) da biblioteca, quadro a quadro.
+ *
+ * {"tipo":"kit","peca":"animacao","src":"midia/animacoes/1f525.json","x":…,"y":…,"largura":…,"altura":…,
+ *  "loop":true,"velocidade":1}
+ *
+ * O Lottie é vetor: sai nítido em qualquer tamanho. Ele NÃO toca sozinho
+ * (o relógio do navegador faria cada render sair diferente): a cada quadro o
+ * tempo do elemento vira o quadro da animação (goToAndStop). Os arquivos vêm
+ * de colecao.js (o Noto Emoji animado do Google, CC BY 4.0). */
+import React, { useEffect, useRef, useState } from 'react';
+import { staticFile, delayRender, continueRender } from 'remotion';
+import lottie from 'lottie-web';
+
+export function Animacao({ el, t }) {
+  const caixa = useRef(null);
+  const [anim, setAnim] = useState(null);
+  const [espera] = useState(() => delayRender('animação ' + el.src));
+  useEffect(() => {
+    let vivo = true;
+    let a = null;
+    fetch(/^https?:/.test(el.src) ? el.src : staticFile(el.src))
+      .then((r) => r.json())
+      .then((dados) => {
+        if (!vivo || !caixa.current) return;
+        a = lottie.loadAnimation({ container: caixa.current, renderer: 'svg', loop: false, autoplay: false, animationData: dados,
+          rendererSettings: { preserveAspectRatio: 'xMidYMid meet' } });
+        a.addEventListener('DOMLoaded', () => { setAnim(a); continueRender(espera); });
+      })
+      .catch(() => continueRender(espera));
+    return () => { vivo = false; if (a) a.destroy(); };
+  }, [el.src]);
+  if (anim) {
+    const total = Math.max(1, anim.totalFrames - 1);
+    const q = Math.max(0, t) * (anim.frameRate || 30) * (el.velocidade || 1);
+    anim.goToAndStop(el.loop === false ? Math.min(q, total) : q % total, true);
+  }
+  const w = el.largura || 300, h = el.altura || w;
+  return <div ref={caixa} style={{ position: 'absolute', left: el.x || 0, top: el.y || 0, width: w, height: h }} />;
+}
+
+export const ANIMACAO = { animacao: Animacao };

package/lib/estudio/kit/gerativo.jsx

@@ -12,7 +12,8 @@
  * quadro as fontes carregam e cada linha é MEDIDA no navegador (delayRender):
  * o que não cabe encolhe, e o acento sabe onde fica cada palavra. */
 import React, { useState, useEffect, useMemo } from 'react';
-import { delayRender, continueRender } from 'remotion';
+import { delayRender, continueRender, Img, staticFile } from 'remotion';
+import { Animacao } from './animacao';
 import { SNAPPY, CURVAS_KIT, acaso, suave, alfa, mistura } from './base';
 import { Produto3D, Icone3D, Heroi3D } from './tres';
 
@@ -1075,6 +1076,25 @@ export function Gerativo({ el, t, fps }) {
                 const [px, py] = achou;
                 /* O ÍCONE PLANO (09/10): o do Iconify que o roteiro pediu (o pão, o QR
                    code), na cor do acento da identidade — entra em mola e flutua de leve. */
+                /* O ÍCONE DA BIBLIOTECA (11/10): o 3D renderizado do Fluent (png) ou a
+                   animação pronta do Noto (lottie). Entra em mola, gira de leve no
+                   eixo Y e flutua, com a sombra no chão que dá peso de objeto. */
+                if (ic.png || ic.lottie) {
+                  const k = MOLA(t - ic.t), dt = t - ic.t, sai = c01((t - (x.ate - 0.25)) / 0.25);
+                  const fl = Math.sin(dt * 1.4) * 0.025 * tam, giro = Math.sin(dt * 0.9) * 10;
+                  return (
+                    <div style={{ position: 'absolute', left: Math.round(px), top: Math.round(py), width: tam, height: tam, opacity: c01(k * 1.4) * (1 - sai),
+                      transform: 'translateZ(140px) scale(' + (0.5 + 0.5 * k).toFixed(4) + ')', transformOrigin: '50% 70%' }}>
+                      <div style={{ position: 'absolute', left: '18%', right: '18%', bottom: '-4%', height: '9%', borderRadius: '50%', background: 'rgba(0,0,0,0.28)',
+                        filter: 'blur(' + (tam * 0.03).toFixed(1) + 'px)', transform: 'scale(' + (1 - fl / tam * 2).toFixed(3) + ')' }} />
+                      <div style={{ position: 'absolute', inset: 0, transform: 'translateY(' + fl.toFixed(1) + 'px) perspective(800px) rotateY(' + giro.toFixed(2) + 'deg) rotate(' + ((1 - k) * -10).toFixed(2) + 'deg)' }}>
+                        {ic.png
+                          ? <Img src={staticFile(ic.png)} style={{ width: '100%', height: '100%', objectFit: 'contain' }} />
+                          : <Animacao el={{ src: ic.lottie, x: 0, y: 0, largura: tam, altura: tam, loop: true }} t={Math.max(0, dt)} />}
+                      </div>
+                    </div>
+                  );
+                }
                 if (ic.svg) {
                   const k = MOLA(t - ic.t), fl = Math.sin((t - ic.t) * 1.3) * 0.012 * tam, sai = c01((t - (x.ate - 0.25)) / 0.25);
                   return <div style={{ position: 'absolute', left: Math.round(px), top: Math.round(py + fl), width: tam, height: tam, color: ic.cor, opacity: c01(k * 1.4) * (1 - sai),

package/lib/estudio/kit/index.jsx

@@ -10,6 +10,8 @@ import { TRES } from './tres';
 import { GERATIVO } from './gerativo';
 import { FLUIDO } from './fluido';
 import { PERSONAGEM } from './personagem';
+import { VOXEL } from './voxel';
+import { ANIMACAO } from './animacao';
 
-export const KIT = { ...VOX, ...MARCA, ...TRES, ...GERATIVO, ...FLUIDO, ...PERSONAGEM, papel: Papel };
+export const KIT = { ...VOX, ...MARCA, ...TRES, ...GERATIVO, ...FLUIDO, ...PERSONAGEM, ...VOXEL, ...ANIMACAO, papel: Papel };
 export { Filtros, Acabamento, Hud, CURVAS_KIT, bolhaCaminho } from './base';