primocode 10.5.0 → 10.6.0

package/lib/estudio/diretor.js

@@ -288,6 +288,7 @@ REGRAS QUE SEPARAM UM VÍDEO BOM DE UM GENÉRICO:
 5. RITMO VARIADO. Cenas de durações diferentes e transições diferentes. Tudo em fade parece slide.
 5b. NADA DE GAVETA. Não existe tema pronto, layout pronto nem fundo pronto: é você que decide a cor, a tipografia e a composição DESTE vídeo. Dois vídeos seus sobre assuntos diferentes não podem sair parecidos.
 6. MÍDIA COM PROPÓSITO. Só peça imagem ou logo quando ela PROVA algo. Diga o termo de busca de verdade ("painel solar em telhado residencial", não "imagem legal").
+6b. CADA FRASE PEDE UMA ROTA DE IMAGEM, nesta ordem: número ou citação → nenhuma (a tipografia é a imagem); fala do produto → a tela ou a logo dele; coisa concreta → o vídeo DELA, com a busca no substantivo ("espresso cup", não a frase inteira); ideia abstrata → textura que se move. A imagem entra logo DEPOIS da palavra que a nomeia, nunca antes.
 7. MOVIMENTO. Em cada cena diga em "chaves" o movimento principal — é ele que tira a cara de apresentação parada.
 8. CÂMERA COM PARCIMÔNIA. Movimento de quadro em UMA cena a cada duas ou três ("camera": "nenhuma" nas outras): o que dá ritmo é alternar cena parada e cena que se move. Em cena com foto de fundo, prefira "aproximar" ou "empurrar".
 9. UMA VOZ OU DUAS. Se o pedido fala em dois narradores, duas vozes, diálogo, conversa ou entrevista, escreva como DIÁLOGO: dê nome a cada um em "vozes" (com vozes diferentes) e diga em cada cena quem fala ("falante"). Com uma voz só, deixe "vozes" e "falante" de fora.

package/lib/estudio/falantes.js

@@ -35,22 +35,46 @@ function normalizar(roteiro) {
     return r;
 }
 
+/* A VOZ PELO GÊNERO (11/10, "os personagens falam com vozes diferentes em
+   cada cena"): o par antigo dava a primeira voz livre a quem falasse
+   primeiro — a Ana saía com a voz do Antonio. Agora o NOME decide o gênero e
+   cada falante ganha uma voz do Gemini só dele, do começo ao fim do vídeo.
+   O que a IA disse (roteiro.vozes, personagens.x.genero) manda. */
+const MASCULINAS = ['Charon', 'Puck', 'Orus', 'Fenrir'];
+const FEMININAS = ['Kore', 'Aoede', 'Leda', 'Zephyr'];
+const ROBO = /\b(ia|ai|assistente|robo|robô|bot|claude|gpt|chatgpt|gemini|primo|primocode|copilot|agente|mascote)\b/i;
+const NOMES_FEMININOS = /^(beatriz|raquel|isabel|carmen|ester|ines|inês|alice|ruth|nicole|lis|luz|rose|ingrid|kelly|jennifer|michelle|rachel|karen|manu|gabi|bel|mel|vitoria|vitória|yasmin|jasmin|carol|isis|ísis|iris|íris|liz|mirian|miriam|ellen|helen|lourdes|mercedes|dolores|socorro|aline|daiane|tais|taís|thais|thaís|lilian|vivian|suellen|jaqueline|simone|rosangela|rosângela|irene|lucimar|nair|jussara|joice|joyce|cris|dani|fer|ju|lu|bia|mãe|mae|vó|vo|avó|avo|tia|dona|senhora|professora|menina|garota|mulher|rainha|princesa|moça|moca)$/;
+const NOMES_MASCULINOS_EM_A = /^(luca|lucca|joshua|nicola|andrea|elias|matias|tobias|jonas|lucas|thomas|tomas|tomás|bruna?x|zuma)$/;
+function generoDe(nome, pedido = {}) {
+    const g = String((pedido && pedido.genero) || '').toLowerCase();
+    if (/^(f|fem|feminin|mulher)/.test(g)) return 'f';
+    if (/^(m|masc|homem)/.test(g)) return 'm';
+    const n = String(nome || '').trim().toLowerCase().split(/\s+/)[0];
+    if (ROBO.test(n)) return 'robo';
+    if (NOMES_FEMININOS.test(n)) return 'f';
+    if (NOMES_MASCULINOS_EM_A.test(n)) return 'm';
+    return /a$/.test(n) ? 'f' : 'm';
+}
+
 /**
  * A voz de cada parte, na ordem. Com falante e voz no mapa, a do mapa; com
- * falante FORA do mapa (o modelo deu nome e esqueceu a voz), a próxima do par
- * que ainda não fala — dois falantes nunca saem com a mesma voz por esquecimento;
- * sem falante, a `padrao` (roteiro.voz).
+ * falante FORA do mapa, uma voz do Gemini do gênero do nome que ainda não
+ * fala neste vídeo; sem falante, a `padrao` (roteiro.voz).
  */
 function vozesDasPartes(partes, roteiro = {}, padrao = '') {
     const mapa = { ...((roteiro && roteiro.vozes) || {}) };
     const ocupadas = new Set(Object.values(mapa).map((v) => String(v).toLowerCase()));
     if (padrao) ocupadas.add(String(padrao).toLowerCase());
+    const pedidos = (roteiro && roteiro.personagens) || {};
+    const livre = (lista, k) => lista.find((v) => !ocupadas.has(v.toLowerCase())) || lista[k % lista.length];
     return (partes || []).map((pt) => {
         const f = nomeFalante(pt && pt.falante);
         if (!f) return padrao || '';
         if (!mapa[f]) {
-            mapa[f] = PAR.find((v) => !ocupadas.has(v)) || PAR[Object.keys(mapa).length % PAR.length];
-            ocupadas.add(mapa[f]);
+            const g = generoDe(f, pedidos[f] || pedidos[Object.keys(pedidos).find((k) => k.toLowerCase() === f)] || {});
+            // O mascote tem a voz mais leve das masculinas (Puck), se estiver livre.
+            mapa[f] = g === 'f' ? livre(FEMININAS, Object.keys(mapa).length) : g === 'robo' && !ocupadas.has('puck') ? 'Puck' : livre(MASCULINAS, Object.keys(mapa).length);
+            ocupadas.add(mapa[f].toLowerCase());
         }
         return mapa[f];
     });
@@ -94,4 +118,4 @@ async function narrarPorFalante(lista, mp3, { narrarUm, juntar }) {
     return { ok: true, voz: [...new Set(feitos.map((x) => x.v.voz).filter(Boolean))].join(' + '), segundos: Math.round(antes * 1000) / 1000, partes, falantes: grupos.length };
 }
 
-module.exports = { normalizar, vozesDasPartes, narrarPorFalante, PAR };
+module.exports = { generoDe, MASCULINAS, FEMININAS, normalizar, vozesDasPartes, narrarPorFalante, PAR };

package/lib/estudio/hibrido.js

@@ -21,6 +21,8 @@
  *   traduzir(roteiro)      qualquer roteiro (vox, motion, composição) vira os
  *                          tipos do cinema; o que o cinema não usa (a fonte, o
  *                          destaque) fica guardado por parte.
+ *   rotaDaParte(parte, …)  qual imagem a frase pede (4 rotas) e em que palavra
+ *                          o corte se ancora (b-roll-finder, Arthur 17/09).
  *   termosDeBusca(roteiro) o que procurar de b-roll para cada parte.
  *   enfeitar(plano, …)     o kit por cima do plano que o cinema montou.
  */
@@ -36,6 +38,65 @@ const limpo = (x) => String(x || '').replace(/\s+/g, ' ').trim();
 const BUSCA_PADRAO = ['technology abstract light', 'people working on laptop', 'hands typing keyboard close up',
     'data center servers', 'city night timelapse', 'team meeting office', 'developer code screen', 'futuristic digital network'];
 
+/* AS 4 ROTAS DO B-ROLL (do b-roll-finder): a frase diz qual imagem pede, e
+   a primeira regra que casa decide. O roteiro manda: `rota` e `busca` na parte.
+     tipografia  número, gráfico, citação      → sem imagem: o texto é a imagem
+     produto     a frase fala da marca/produto → a tela/foto da marca
+     literal     uma coisa concreta ("café")   → o vídeo de banco DELA
+     abstrato    ideia que teria de ser desenhada → textura que se move
+   O termo sai da PALAVRA-ÂNCORA, não da frase inteira; e o clipe troca 0,2 s
+   DEPOIS dela — "atrasado parece intenção, adiantado parece erro". */
+const ROTAS = ['tipografia', 'produto', 'literal', 'abstrato'];
+const ATRASO_ANCORA = require('./edicao.js').DEPOIS_DA_PALAVRA;
+const PRODUTO = /^(app|aplicativ|ferrament|painel|dashboard|plataform|site|terminal|cli|sistema|interface|software|agente)/;
+/* As COISAS que se filmam: substantivo concreto → o termo do banco, em inglês.
+   O ícone da edição (edicao.iconeDe) casa verbo também ("começa" → foguete),
+   bom para emoji, ruim para b-roll literal; aqui só entra o que tem cara. */
+const COISAS = [
+    [['cafe'], 'coffee cup morning'], [['cachorro', 'cao'], 'dog'], [['gato'], 'cat'], [['casa', 'lar'], 'modern house'],
+    [['carro'], 'car driving road'], [['cidade', 'rua'], 'city street people'], [['mar', 'praia', 'oceano'], 'ocean waves'],
+    [['escritorio', 'reuniao'], 'team meeting office'], [['mao', 'maos'], 'hands close up'], [['teclado', 'digit'], 'hands typing keyboard close up'],
+    [['computador', 'notebook', 'laptop'], 'laptop on desk'], [['codigo', 'programa'], 'developer code screen'], [['celular', 'telefone'], 'smartphone in hand'],
+    [['livro', 'aula', 'escola'], 'library books'], [['musica'], 'music concert'], [['pessoa', 'equipe', 'cliente', 'gente'], 'people working together'],
+    [['servidor', 'nuvem'], 'data center servers'], [['dinheiro'], 'money cash'], [['relogio'], 'clock ticking'],
+];
+const coisaDe = (limpo) => { for (const [raizes, termo] of COISAS) if (raizes.some((r) => (r.length <= 3 ? limpo === r : limpo.startsWith(r)))) return termo; return null; };
+const ABSTRATO = ['abstract light texture', 'ink in water slow motion', 'bokeh lights dark background', 'smoke texture dark'];
+
+/** A rota e a âncora de uma parte. `palavras`: [{texto, de, ate}] da voz (ou só o texto). */
+function rotaDaParte(parte, palavras, { marca = null, i = 0 } = {}) {
+    const p = parte || {};
+    const ed = require('./edicao.js');
+    const ws = (palavras && palavras.length ? palavras : String(p.fala || p.texto || p.titulo || '').split(/\s+/).filter(Boolean).map((texto) => ({ texto })));
+    const limpa = (x) => String(x || '').normalize('NFD').replace(/[\u0300-\u036f]/g, '').toLowerCase().replace(/[^a-z0-9]/g, '');
+    const achar = (alvo) => { const a = limpa(String(alvo || '').split(/\s+/)[0]); return a ? ws.find((w) => limpa(w.texto) === a) || null : null; };
+    // A palavra que carrega a frase: a mais longa que não é vazia ("confiança", não "um").
+    const forte = () => ws.reduce((f, w) => (ed.peso(w.texto) && limpa(w.texto).length > (f ? limpa(f.texto).length : 0) ? w : f), null);
+    const tipo = p.tipoOriginal || p.tipo || '';
+    let r;
+    if (ROTAS.includes(p.rota)) r = { rota: p.rota, palavra: null };
+    else if (['numero', 'grafico', 'citacao', 'numeros'].includes(tipo)) r = { rota: 'tipografia', palavra: null };
+    else {
+        const e = ed.rotaDeApoio(ws, { marca });
+        const prod = ws.find((w) => ed.peso(w.texto) && PRODUTO.test(limpa(w.texto)));
+        const coisa = ws.find((w) => ed.peso(w.texto) && coisaDe(limpa(w.texto)));
+        if (e.rota === 'marca' || prod) r = { rota: 'produto', palavra: e.rota === 'marca' ? e.palavra : prod, termo: 'software interface on laptop screen' };
+        else if (e.rota === 'numero') r = { rota: 'tipografia', palavra: e.palavra };
+        else if (coisa) r = { rota: 'literal', palavra: coisa, termo: coisaDe(limpa(coisa.texto)) };
+        else r = { rota: p.busca ? 'literal' : 'abstrato', palavra: forte(), termo: ABSTRATO[i % ABSTRATO.length] };
+    }
+    // A âncora: a do roteiro, a palavra-tese, ou a que a regra achou.
+    r.palavra = achar(p.ancora) || r.palavra || achar(p.destaque) || forte();
+    if (r.rota === 'tipografia') r.termo = null;
+    else if (p.busca) r.termo = String(p.busca);
+    return r;
+}
+
+/** Quando o clipe troca, no tempo da voz: 0,2 s depois da âncora. null sem tempo. */
+function tempoDaAncora(palavra) {
+    return palavra && Number.isFinite(palavra.de) ? r2(palavra.de + ATRASO_ANCORA) : null;
+}
+
 /** O roteiro de qualquer estilo → o roteiro do cinema. Devolve {roteiro, extras}. */
 function traduzir(roteiro) {
     const partes = (roteiro && roteiro.partes) || [];
@@ -71,12 +132,16 @@ function traduzir(roteiro) {
         else if (tipo === 'cta' || tipo === 'logo' || tipo === 'fim') q = { tipo: 'final', linhas: [p.titulo || p.texto, p.link].filter(Boolean).map(limpo), ...base };
         else q = { tipo: 'montagem', linhas: [p.titulo || p.texto || p.fala].filter(Boolean).map(limpo), ...base };
         saida.push(q);
-        extras.push({ tipoOriginal: tipo, fonte: tipo === 'abertura' && p.sub ? p.sub : (p.fonte || (tipo === 'citacao' ? p.autor : '')), autor: p.autor || '', busca: p.busca || '' });
+        extras.push({ tipoOriginal: tipo, fonte: tipo === 'abertura' && p.sub ? p.sub : (p.fonte || (tipo === 'citacao' ? p.autor : '')), autor: p.autor || '', busca: p.busca || '',
+            ...(p.rota ? { rota: p.rota } : {}), ...(p.ancora ? { ancora: p.ancora } : {}) });
     });
     return { roteiro: { ...roteiro, partes: saida, estilo: 'hibrido' }, extras };
 }
 
-/** O que procurar de b-roll para cada parte: a busca dela, a do roteiro, ou o padrão. */
+/* A parte com o que o roteiro original disse dela (o tipo, a busca, a rota). */
+const comExtras = (p, ex) => ({ ...p, ...(ex ? { tipoOriginal: ex.tipoOriginal, busca: ex.busca || p.busca, rota: ex.rota || p.rota, ancora: ex.ancora || p.ancora } : {}) });
+
+/** O que procurar de b-roll para cada parte: o termo da rota dela, a busca do roteiro, ou o padrão. */
 function termosDeBusca(roteiro, extras = []) {
     const global = [].concat(roteiro.busca || []).filter(Boolean);
     // Escopo fechado: só os termos da pessoa, nunca o padrão genérico.
@@ -84,11 +149,20 @@ function termosDeBusca(roteiro, extras = []) {
     const lista = global.length ? global : fechado ? [] : BUSCA_PADRAO;
     const termos = new Set();
     (roteiro.partes || []).forEach((p, i) => {
-        const b = (extras[i] && extras[i].busca) || p.busca;
-        if (b) termos.add(String(b));
+        const q = comExtras(p, extras[i]);
+        const r = rotaDaParte(q, null, { marca: roteiro.marca && roteiro.marca.nome, i });
+        /* Escopo fechado: só a busca que o roteiro deu à parte. O termo da rota sai
+           do dicionário (textura, tela de app, e o literal: "cachorro" → "dog") e
+           furava o escopo da pessoa (revisão do #99). */
+        if (r.termo && (!fechado || q.busca)) termos.add(r.termo);
     });
-    for (const t of lista) termos.add(t);
-    return [...termos].slice(0, 8);
+    /* O corte em 8 guarda lugar para a busca global do roteiro (no fechado, é o
+       escopo da pessoa): as frases vinham antes e a empurravam para fora
+       (revisão do #99). O padrão genérico é só enchimento, esse pode cair. */
+    const fixos = global.slice(0, 8);
+    const frases = [...termos].filter((t) => !fixos.includes(t)).slice(0, 8 - fixos.length);
+    const resto = global.length ? [] : lista.filter((t) => !termos.has(t));
+    return [...frases, ...fixos, ...resto].slice(0, 8);
 }
 
 /* A câmera de cada cena do cinema: empurra e desliza, alternando o lado. A
@@ -109,7 +183,7 @@ function camera(d, i, deitado, forte) {
 /* SEM CARA DE IA (05/10): o HUD (cantos, timecode, fps, rótulos nas bordas)
    e as partículas eram exatamente a lista do "ruim" que o Joel juntou. Agora
    só entram quando o roteiro pede: roteiro.hud === true, roteiro.particulas === true. */
-function enfeitar(plano, { extras = [], partes = [], marca = {}, largura, altura, hud = false, particulas = false } = {}) {
+function enfeitar(plano, { extras = [], partes = [], marca = {}, largura, altura, hud = false, particulas = false, tempos = null, fortes = {}, fotos = [] } = {}) {
     if (!plano || !Array.isArray(plano.cenas)) return plano;
     const W = largura || (plano.formato && plano.formato.largura) || 1920;
     const H = altura || (plano.formato && plano.formato.altura) || 1080;
@@ -126,6 +200,7 @@ function enfeitar(plano, { extras = [], partes = [], marca = {}, largura, altura
         const n = p.tipo === 'depoimento' ? Math.max(1, (p.clipes || []).length) : 1;
         for (let q = 0; q < n; q++) parteDaCena.push(i);
     });
+    if (tempos) ancorar(plano, { extras, partes, marca, tempos, fortes, fotos, parteDaCena });
     plano.cenas.forEach((cena, c) => {
         const iParte = parteDaCena[c] != null ? parteDaCena[c] : c;
         const ex = extras[iParte] || {};
@@ -166,4 +241,65 @@ function enfeitar(plano, { extras = [], partes = [], marca = {}, largura, altura
     return plano;
 }
 
-module.exports = { traduzir, termosDeBusca, enfeitar, BUSCA_PADRAO };
+/* O B-ROLL NA PALAVRA: a cena de montagem (ou de frase) troca para o clipe da
+   rota dela 0,2 s depois da âncora — antes, segue a montagem do cinema. Rota
+   tipografia tira as fotos: o número já é a imagem. O tempo da cena é o do
+   cinema: a voz entra 0,2 s depois do corte (off). */
+function ancorar(plano, { extras, partes, marca, tempos, fortes, fotos, parteDaCena }) {
+    const cinema = require('./cinema.js');
+    const off = 0.2;
+    let narrI = 0;
+    const tempoDe = partes.map((p, i) => (p.tipo !== 'depoimento' && cinema.falaDe(p) !== '' && !(p.falaForte && fortes[i]) ? tempos[narrI++] || null : null));
+    const ehFoto = (e) => (e.tipo === 'imagem' || e.tipo === 'video' || (e.tipo === 'forma' && e.fundo && e.fundo.tipo === 'gradiente')) && e.largura === '100%';
+    const plan = [], vez = [];
+    plano.cenas.forEach((cena, c) => {
+        const i = parteDaCena[c] != null ? parteDaCena[c] : c;
+        const p = partes[i], tp = tempoDe[i];
+        if (!p || !['montagem', 'frase', 'numeros'].includes(p.tipo) || (parteDaCena.indexOf(i) !== c)) return;
+        const r = rotaDaParte(comExtras(p, extras[i]), tp && tp.palavras, { marca: marca.nome, i });
+        plan.push({ parte: i, rota: r.rota, ancora: r.palavra ? r.palavra.texto : null, termo: r.termo || null });
+        /* Produto: a tela DA MARCA (o print do acervo) antes do vídeo de banco. Antes
+           a regra perguntava se o alt não era termo de busca, mas o conjunto tinha o
+           alt de todas as fotos: nunca casava, e o painel ficava de fora (revisão do #99). */
+        const f = r.rota === 'tipografia' ? null : r.rota === 'produto' ? fotos.find((x) => x.cat === 'tela' && !x.banco) || fotos.find((x) => x.alt === r.termo)
+            : fotos.find((x) => x.alt === r.termo && x.tipo === 'video') || fotos.find((x) => x.alt === r.termo);
+        const ta = tp ? tempoDaAncora(r.palavra) : null;
+        const de = ta == null ? null : r2(off + ta - tp.de);
+        vez.push({ cena, r, f: f && de != null && (cena.duracao || 2) - de >= 0.8 ? f : null, de });   // sem 0,8 s para ver, fica a montagem
+    });
+    /* O clipe de uma frase não aparece ANTES da palavra dela (nem na montagem
+       de outra cena): quem vê o café antes de ouvir "café" sente o erro. */
+    const reservado = new Set(vez.filter((x) => x.f).map((x) => x.f.src));
+    const livres = fotos.filter((x) => !reservado.has(x.src));
+    let n = 0;
+    for (const { cena, r, f, de } of vez) {
+        let els = cena.elementos || [];
+        if (r.rota === 'tipografia') { cena.elementos = els.filter((e) => !ehFoto(e)); continue; }
+        for (const e of els) if ((e.tipo === 'imagem' || e.tipo === 'video') && reservado.has(e.src) && livres.length) {
+            const g = livres[n++ % livres.length];
+            Object.assign(e, { tipo: g.tipo === 'video' ? 'video' : 'imagem', src: g.src, ...(g.tipo === 'video' ? { volume: 0 } : {}) });
+        }
+        if (!f) continue;
+        const d = cena.duracao || 2;
+        els = els.filter((e) => !(ehFoto(e) && e.de >= de));
+        for (const e of els) if (ehFoto(e) && (e.ate == null || e.ate > de)) e.ate = de;
+        // Um resto de foto de um instante vira um piscar: a foto de antes cobre o buraco.
+        for (const e of els.filter((x) => ehFoto(x) && x.ate - (x.de || 0) < 0.25)) {
+            for (const x of els) if (x !== e && ehFoto(x) && x.ate === e.de && x.tipo === e.tipo) x.ate = e.ate;
+            els = els.filter((x) => x !== e);
+        }
+        const v = f.tipo === 'video';
+        const vida = r2(d - de);
+        const novo = [{ tipo: v ? 'video' : 'imagem', src: f.src, ...(v ? { volume: 0 } : {}), x: 0, y: 0, largura: '100%', altura: '100%', ajuste: 'cover', de, ate: r2(d), broll: r.rota,
+            anima: { escala: [{ t: 0, v: 1.12 }, { t: vida, v: 1.02, e: 'linear' }] } },
+        { tipo: 'forma', forma: 'retangulo', x: 0, y: 0, largura: '100%', altura: '100%', de, ate: r2(d),
+            fundo: { tipo: 'gradiente', cores: ['rgba(7,7,10,0.35)', 'rgba(7,7,10,0.5)', 'rgba(7,7,10,0.75)'], angulo: 180 } }];
+        const k = els.findIndex((e) => e.tipo === 'texto' || e.tipo === 'kit');
+        els.splice(k < 0 ? els.length : k, 0, ...novo);
+        cena.elementos = els;
+    }
+    plano.broll = plan;
+    return plan;
+}
+
+module.exports = { traduzir, termosDeBusca, enfeitar, rotaDaParte, tempoDaAncora, ancorar, ROTAS, ATRASO_ANCORA, BUSCA_PADRAO };

package/lib/estudio/index.js

@@ -66,10 +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');
 
@@ -163,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.',
     };
 }
 
@@ -188,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),
@@ -1097,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 }),
     });
 }
 
@@ -1211,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. */
@@ -1332,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,
@@ -1404,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
@@ -1469,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) => {
@@ -1483,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 });
@@ -1495,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;
@@ -1554,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`);
@@ -1579,15 +1631,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 +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') {