primocode 10.5.0 → 10.7.0

package/lib/estudio/index.js

@@ -66,10 +66,14 @@ 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 cenarios = require('./cenarios.js');
+const movimentos = require('./movimentos.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');
 
@@ -163,7 +167,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.',
     };
 }
 
@@ -188,6 +192,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),
@@ -272,6 +279,28 @@ function projetoRecente() {
     return lista[0] || null;
 }
 
+/* Sem id, o projeto é o que acabou de ser criado. Visto em 12/10: o agente
+   criou o projeto, chamou estudio_narrar sem id e o vídeo morreu ali. Só vale
+   para chamada SEM id (id errado continua sendo erro) e para projeto de até
+   30 minutos, como no estudio_plano. */
+function projetoOuRecente(id) {
+    if (id != null && String(id).trim() !== '') return projeto.ler(id);
+    return projetoRecente();
+}
+
+/* roteiro.objetos: [{nome, src}] com o PNG DENTRO da pasta do projeto (o que
+   o estudio_midia baixou ou recortou). Caminho de fora some: o render só
+   enxerga a pasta do projeto, e a IA não escolhe arquivo da máquina. */
+function objetosDoRoteiro(objetos, pasta) {
+    const raiz = path.resolve(pasta);
+    return (Array.isArray(objetos) ? objetos : []).map((o) => {
+        if (!o || typeof o.src !== 'string') return null;
+        const abs = path.resolve(raiz, o.src);
+        if (!abs.startsWith(raiz + path.sep) || !/\.png$/i.test(abs) || !fs.existsSync(abs)) return null;
+        return { nome: o.nome, src: path.relative(raiz, abs).replace(/\\/g, '/') };
+    }).filter(Boolean);
+}
+
 /** O roteiro é utilizável como veio? (objeto ou JSON, com partes de tipo conhecido) */
 function roteiroValido(r) {
     let x = r;
@@ -522,6 +551,19 @@ async function ferramentaMidia(args) {
     /* 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. */
+    /* OS MOVIMENTOS (movimentos.js, 12/10): 100+ entradas, saídas, ênfases e loops com nome. */
+    if (acao === 'movimentos' || acao === 'movimento') {
+        return movimentos.procurar({ termo: args.termo, categoria: args.categoria, limite: Number(args.limite) || 30 });
+    }
+    /* OS CENÁRIOS (cenarios.js, 12/10): os lugares prontos + os que a IA criou
+       e a pessoa deixou guardar. Salvar só com o sim dela (autorizado:true). */
+    if (acao === 'cenarios' || acao === 'cenários') {
+        return { ok: true, prontos: Object.keys(mundo.LUGARES), salvos: cenarios.listar(),
+            comoCriar: 'na cena do estilo personagem: lugar (um pronto como base), ceu [cor de cima, cor do horizonte], chao {tipo, cor, cor2}, parede, luz, acento, hora e elementos. Ficou bom? Pergunte se pode salvar e use acao:"salvar_cenario".' };
+    }
+    if (acao === 'salvar_cenario' || acao === 'salvar_cenário') {
+        return cenarios.salvar({ nome: args.nome, cenario: args.cenario, autorizado: args.autorizado, bases: Object.keys(mundo.LUGARES) });
+    }
     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);
@@ -580,8 +622,9 @@ async function baixarEscolhido(lista, args, p) {
 async function ferramentaNarrar(args) {
     if (args.vozes) return rodarPython('narrar.py', ['vozes'], { timeout: 30000 });
 
-    const p = projeto.ler(args.id);
+    const p = projetoOuRecente(args.id);
     if (!p) return semProjeto(args.id);
+    if (args.id == null || String(args.id).trim() === '') args = { ...args, id: p.id };
     const texto = String(args.texto || '').trim();
     if (!texto) return { ok: false, error: 'não há texto para narrar.' };
 
@@ -611,8 +654,9 @@ async function ferramentaNarrar(args) {
 
 async function ferramentaVideo(args, ctx = {}) {
     const acao = String(args.acao || 'medir').toLowerCase();
-    const p = projeto.ler(args.id);
+    const p = projetoOuRecente(args.id);
     if (!p) return semProjeto(args.id);
+    if (args.id == null || String(args.id).trim() === '') args = { ...args, id: p.id };
 
     const pronto = video.conferir();
     if (!pronto.ok) return pronto;
@@ -1097,13 +1141,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 }),
     });
 }
 
@@ -1211,6 +1284,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. */
@@ -1332,35 +1410,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,
@@ -1404,25 +1485,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
@@ -1469,11 +1557,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) => {
@@ -1483,11 +1572,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 });
@@ -1495,7 +1584,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;
@@ -1554,7 +1643,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`);
@@ -1579,15 +1670,41 @@ async function prepararRoteiro(p, args) {
         /* 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
@@ -1793,8 +1910,23 @@ 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);
+            mundo.adicionarObjetos(r.partitura, objetosDoRoteiro(roteiro.objetos, p.pasta));
+            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') {
@@ -1870,8 +2002,9 @@ async function transcrever(p, alvo, ctx) {
 // ── estudio_render ───────────────────────────────────────────────────────
 
 async function ferramentaRender(args, ctx = {}) {
-    const p = projeto.ler(args.id);
+    const p = projetoOuRecente(args.id);
     if (!p) return semProjeto(args.id);
+    if (args.id == null || String(args.id).trim() === '') args = { ...args, id: p.id };
     const pl = projeto.lerPlano(args.id);
     if (!pl) return { ok: false, error: 'não há plano neste projeto.' };
 
@@ -2117,7 +2250,7 @@ async function ferramentaSite(args) {
 }
 
 module.exports = {
-    vazamentoNoComeco, variarIcones,
+    vazamentoNoComeco, variarIcones, objetosDoRoteiro,
     ferramentaProjeto, ferramentaPlano, ferramentaMidia, ferramentaNarrar,
     ferramentaVideo, ferramentaRender, ferramentaSite,
     projeto, plano, remotion, assets, video, identidade, slides, python, rodarPython, alinharPartes, prepararRoteiro, roteiroValido, juntarVozes,