primocode 10.1.0 → 10.3.0-beta.0

package/lib/estudio/biblioteca.js

@@ -113,12 +113,47 @@ const norm = (s) => String(s || '').normalize('NFD').replace(/[̀-ͯ]/g, '').toL
 function acharFonte(nome) { const n = norm(nome); return FONTES.find((f) => norm(f.nome) === n) || null; }
 function acharPaleta(nome) { const n = norm(nome).replace(/\s+/g, '-'); return PALETAS.find((p) => p.nome === n) || null; }
 
-/* O sorteio que pula os recentes. Se a lista inteira já foi usada, vale
-   qualquer uma — nunca fica sem. */
-function sortear(lista, recentes, chave, sorte) {
-    const livres = lista.filter((x) => !recentes.includes(chave(x)));
-    const de = livres.length ? livres : lista;
-    return de[Math.floor(sorte() * de.length) % de.length];
+/* O CASAMENTO DA FONTE COM O ROTEIRO (07/10): "a IA deve escolher fontes e
+   combinações de acordo com assunto, tom, público e ritmo" (Joel). Antes eram
+   dois sorteios independentes. Agora:
+   - o CLIMA do roteiro (o mesmo que escolhe a trilha, variedade.climaDe) diz
+     quanto cada tipo de título serve (0 a 1);
+   - o tipo do título diz que tipo de texto faz par com ele (contraste, não
+     duas fontes que brigam);
+   - a memória penaliza o recente pela distância, não corta: o que serve ao
+     tom ganha do que só é novo (os pontos de variedade.js). */
+const TOM_DO_TITULO = {
+    tecnologia: { display: 1, larga: 0.9, condensada: 0.6, texto: 0.7, serifa: 0.2 },
+    energetico: { condensada: 1, display: 0.9, larga: 0.6, texto: 0.5, serifa: 0.2 },
+    epico: { condensada: 1, serifa: 0.8, display: 0.6, larga: 0.5, texto: 0.3 },
+    calmo: { serifa: 1, texto: 0.9, display: 0.5, condensada: 0.3, larga: 0.2 },
+    alegre: { display: 1, larga: 0.8, texto: 0.6, condensada: 0.4, serifa: 0.4 },
+    emocional: { serifa: 1, texto: 0.7, display: 0.5, condensada: 0.4, larga: 0.2 },
+    misterio: { condensada: 0.9, serifa: 0.9, larga: 0.6, display: 0.5, texto: 0.4 },
+};
+// O par do texto, pelo tipo do título: o contraste que funciona.
+const PAR_DO_TEXTO = {
+    condensada: { texto: 1, mono: 0.8, serifa: 0.6, display: 0.4 },
+    display: { texto: 1, serifa: 0.7, mono: 0.6, display: 0.2 },
+    larga: { mono: 1, texto: 0.9, serifa: 0.4, display: 0.2 },
+    serifa: { texto: 1, mono: 0.7, display: 0.5, serifa: 0.3 },
+    texto: { serifa: 1, mono: 0.9, texto: 0.3, display: 0.5 },
+};
+
+/** O tom do roteiro para a fonte: o clima (variedade.climaDe). Neutro serve tudo igual. */
+function tomDe(roteiro, estilo = '') { return require('./variedade.js').climaDe(roteiro || {}, estilo); }
+
+/* A escolha por pontos: 2 × adequação − recência (1 para o último usado,
+   metade a cada quarto da memória). Entre os quase empatados, sorteia. */
+function escolher(lista, recentes, chave, sorte, adequa = () => 1, lembra = 10) {
+    const meia = Math.max(1, lembra / 4);
+    const pts = lista.map((x) => {
+        const pos = recentes.indexOf(chave(x));
+        return { x, p: 2 * adequa(x) - (pos < 0 ? 0 : Math.pow(0.5, pos / meia)) };
+    });
+    const melhor = Math.max(...pts.map((q) => q.p));
+    const quase = pts.filter((q) => q.p >= melhor - 0.05).map((q) => q.x);
+    return quase[Math.floor(sorte() * quase.length) % quase.length];
 }
 
 /**
@@ -126,7 +161,7 @@ function sortear(lista, recentes, chave, sorte) {
  * trocar nada que a marca já tem. Devolve o que escolheu e de onde veio.
  * memoria: null não lê nem grava o disco (os testes); sorte: () => [0,1).
  */
-function vestir(roteiro, { memoria = ARQ, sorte = Math.random } = {}) {
+function vestir(roteiro, { memoria = ARQ, sorte = Math.random, estilo = '' } = {}) {
     if (!roteiro || typeof roteiro !== 'object') return { mudou: false };
     const marca = roteiro.marca || {};
     const cores = marca.cores || {};
@@ -136,17 +171,22 @@ function vestir(roteiro, { memoria = ARQ, sorte = Math.random } = {}) {
 
     if (!(marca.fontes && marca.fontes.titulo)) {
         // A IA escolheu pelo nome: vale qualquer família do Google Fonts, mesmo fora do cardápio.
-        const titulo = visual.titulo ? String(visual.titulo) : sortear(TITULO, mem.titulo, (f) => f.nome, sorte).nome;
+        const tom = TOM_DO_TITULO[tomDe(roteiro, estilo)] || null;
+        const titulo = visual.titulo ? String(visual.titulo)
+            : escolher(TITULO, mem.titulo, (f) => f.nome, sorte, (f) => (tom ? tom[f.tipo] ?? 0.3 : 1), LEMBRA.titulo).nome;
+        const tipoTitulo = (acharFonte(titulo) || {}).tipo;
+        const par = PAR_DO_TEXTO[tipoTitulo] || null;
         const textoLista = TEXTO.filter((f) => f.nome !== titulo);
-        const texto = visual.texto ? String(visual.texto) : sortear(textoLista, mem.texto, (f) => f.nome, sorte).nome;
+        const texto = visual.texto ? String(visual.texto)
+            : escolher(textoLista, mem.texto, (f) => f.nome, sorte, (f) => (par ? par[f.tipo] ?? 0.2 : 1), LEMBRA.texto).nome;
         marca.fontes = { ...(marca.fontes || {}), titulo, texto };
         mem.titulo = [titulo, ...mem.titulo.filter((x) => x !== titulo)].slice(0, LEMBRA.titulo);
         mem.texto = [texto, ...mem.texto.filter((x) => x !== texto)].slice(0, LEMBRA.texto);
-        Object.assign(escolha, { mudou: true, titulo, texto, fonteDaIA: !!visual.titulo });
+        Object.assign(escolha, { mudou: true, titulo, texto, fonteDaIA: !!visual.titulo, tom: tomDe(roteiro, estilo) });
     }
     // A cor da marca manda: com destaque ou gradiente declarado, a paleta não entra.
     if (!(marca.gradiente && marca.gradiente.length >= 2) && !cores.destaque) {
-        const p = acharPaleta(visual.paleta) || sortear(PALETAS, mem.paleta, (x) => x.base, sorte);
+        const p = acharPaleta(visual.paleta) || escolher(PALETAS, mem.paleta, (x) => x.base, sorte, () => 1, LEMBRA.paleta);
         marca.gradiente = [...p.grad];
         marca.cores = { ...cores, fundo: cores.fundo || p.fundo, destaque: p.grad[1], apoio: p.grad[0] };
         mem.paleta = [p.base, ...mem.paleta.filter((x) => x !== p.base)].slice(0, LEMBRA.paleta);
@@ -171,4 +211,4 @@ function cardapio() {
     };
 }
 
-module.exports = { vestir, cardapio, larguraDe, acharFonte, acharPaleta, FONTES, PALETAS, BASES, TITULO, TEXTO, luz, ARQ };
+module.exports = { vestir, cardapio, tomDe, TOM_DO_TITULO, PAR_DO_TEXTO, larguraDe, acharFonte, acharPaleta, FONTES, PALETAS, BASES, TITULO, TEXTO, luz, ARQ };

package/lib/estudio/decisao.js

@@ -0,0 +1,106 @@
+/**
+ * decisao.js — o que cada frase da edição pede: movimento, recorte, som — ou
+ * nada, e a cena respira.
+ *
+ *   "Não quero simplesmente adicionar efeitos. Quero melhorar a decisão de
+ *    edição. Nem todo momento precisa de movimento, transição ou efeito. Às
+ *    vezes a melhor decisão é deixar a cena respirar." (Joel, 07/10)
+ *
+ * Antes a edição era um rodízio: zoom por `i % 3`, a pessoa recortada em
+ * `i % 4 === 2`, whoosh em `i % 3 === 1`. A frase mais forte do vídeo podia
+ * cair num "parado", e uma frase de ligação ganhava o soco. Aqui:
+ *   1. INTENSIDADE (0 a 1) de cada frase: a palavra mais forte, número,
+ *      exclamação e pergunta, frase curta de efeito, a pausa antes dela (o
+ *      silêncio prepara o golpe), o gancho do começo e o fecho;
+ *   2. MOVIMENTO pela intensidade, com três regras de editor: o golpe é raro
+ *      (no máximo ~1 em 3 frases), depois do golpe vem um respiro, e o mesmo
+ *      movimento não se repete em seguida;
+ *   3. o RECORTE (a pessoa na frente da palavra gigante) vai para as frases
+ *      mais fortes, longe uma da outra; o WHOOSH só anuncia o soco.
+ * Puro: frases entram, decisões saem. `aleatorio` decide os empates.
+ */
+
+'use strict';
+
+const r2 = (n) => Math.round(n * 100) / 100;
+const limpa = (t) => String(t || '').toLowerCase().normalize('NFD').replace(/[̀-ͯ]/g, '').replace(/[^a-z0-9%]/g, '');
+
+/* Os movimentos de câmera (zoom em quadros-chave, no tempo da cena):
+     parado      nada — a cena respira
+     empurra     aproxima devagar (tensão que cresce)
+     soco        entra já fechado e segura (o golpe)
+     recua       abre devagar (alívio, conclusão)
+     reenquadra  fecha num ponto fora do centro (mudança de assunto)  */
+const MOVIMENTOS = {
+    parado: () => ({ zoom: [{ t: 0, v: 1.0 }, { t: 1, v: 1.0 }] }),
+    empurra: (d, k) => ({ zoom: [{ t: 0, v: 1.0 }, { t: d, v: r2(1.04 + 0.06 * k), e: 'linear' }] }),
+    soco: (d, k) => ({ zoom: [{ t: 0, v: r2(1.14 + 0.08 * k) }, { t: d, v: r2(1.17 + 0.08 * k), e: 'linear' }] }),
+    recua: (d, k) => ({ zoom: [{ t: 0, v: r2(1.1 + 0.05 * k) }, { t: d, v: 1.02, e: 'suave' }] }),
+    // O x é em px: 3,5% do lado menor cabe na sobra de um zoom de 1,12.
+    reenquadra: (d, k, lado, base = 1080) => ({ zoom: [{ t: 0, v: r2(1.12 + 0.04 * k) }, { t: d, v: r2(1.15 + 0.04 * k), e: 'suave' }],
+        x: [{ t: 0, v: Math.round((lado ? 1 : -1) * base * 0.03) }, { t: d, v: Math.round((lado ? 1 : -1) * base * 0.035), e: 'suave' }] }),
+};
+
+/** A intensidade de cada frase (lista de palavras {de, ate, texto}), de 0 a 1. */
+function intensidades(grupos, peso = (w) => limpa(w).length) {
+    const n = grupos.length;
+    const brutos = grupos.map((g, i) => {
+        const texto = g.map((p) => p.texto).join(' ');
+        const forte = Math.max(0, ...g.map((p) => peso(p.texto)));
+        let s = Math.min(1, forte / 14) * 0.45;
+        if (/\d/.test(texto)) s += 0.2;
+        if (/!/.test(texto)) s += 0.2;
+        if (/\?/.test(texto)) s += 0.1;
+        if (g.length <= 4) s += 0.15;                                    // frase curta é frase de efeito
+        const pausa = i > 0 ? g[0].de - grupos[i - 1][grupos[i - 1].length - 1].ate : 0;
+        if (pausa > 0.45) s += Math.min(0.2, pausa * 0.25);              // o silêncio prepara o golpe
+        if (i === 0) s += 0.15;                                          // o gancho
+        if (i === n - 1) s += 0.1;                                       // o fecho
+        return s;
+    });
+    const max = Math.max(...brutos, 1e-9), min = Math.min(...brutos);
+    return brutos.map((s) => r2(max - min < 1e-6 ? 0.5 : (s - min) / (max - min)));
+}
+
+/**
+ * As decisões da edição: uma por frase.
+ * @returns {Array<{intensidade:number, movimento:string, recorte:boolean, whoosh:boolean}>}
+ */
+function decidir(grupos, { peso, aleatorio = Math.random, maxRecortes = 3 } = {}) {
+    const ints = intensidades(grupos, peso);
+    const n = ints.length;
+    // O golpe é raro: só as frases do terço de cima (pelo menos 1, no máximo n/3).
+    const ordem = [...ints.keys()].sort((a, b) => ints[b] - ints[a]);
+    const golpes = new Set(ordem.slice(0, Math.max(1, Math.floor(n / 3))).filter((i) => ints[i] >= 0.6 || i === ordem[0]));
+    const out = [];
+    for (let i = 0; i < n; i++) {
+        const ant = out[i - 1];
+        let mov;
+        if (golpes.has(i) && !(ant && ant.movimento === 'soco')) mov = 'soco';
+        else if (ant && ant.movimento === 'soco') mov = 'parado';     // depois do golpe, respira
+        else if (i === n - 1) mov = ints[i] > 0.4 ? 'recua' : 'parado';
+        else {
+            // O resto pelo que a frase pede, sem repetir o anterior.
+            const pede = ints[i] > 0.45 ? ['reenquadra', 'empurra'] : ints[i] > 0.2 ? ['empurra', 'parado', 'reenquadra'] : ['parado', 'empurra'];
+            const opcoes = pede.filter((m) => !ant || m !== ant.movimento);
+            mov = opcoes[Math.floor(aleatorio() * Math.min(2, opcoes.length)) % opcoes.length];
+        }
+        out.push({ intensidade: ints[i], movimento: mov, recorte: false, whoosh: mov === 'soco' && i > 0 });
+    }
+    // O recorte: as frases mais fortes, com pelo menos 3 frases entre um e outro.
+    const escolhidos = [];
+    for (const i of ordem) {
+        if (escolhidos.length >= maxRecortes || ints[i] < 0.5) break;
+        if (i === 0 || escolhidos.some((j) => Math.abs(j - i) < 3)) continue;
+        escolhidos.push(i);
+        out[i].recorte = true;
+    }
+    return out;
+}
+
+/** A câmera da cena para o movimento decidido. `lado` alterna o reenquadramento. */
+function camera(movimento, dur, intensidade = 0.5, lado = 0, base = 1080) {
+    return (MOVIMENTOS[movimento] || MOVIMENTOS.parado)(dur, Math.max(0, Math.min(1, intensidade)), lado, base);
+}
+
+module.exports = { intensidades, decidir, camera, MOVIMENTOS };

package/lib/estudio/diretor.js

@@ -115,9 +115,62 @@ function ritmoPara(segundos) {
         palavrasPorCena: Math.round(media * 2.6) };   // ~155 palavras/minuto de narração
 }
 
+// ── 2b. a estrutura: um cardápio, e a memória do que já saiu ─────────────
+
+/* "o roteiro vicia: todo vídeo começa igual, não escolhe outra estrutura"
+   (Joel, 09/10). A regra 3 do diretor tinha UM arco só — prende em 2
+   segundos, entrega, pede ação — e o produtor nem isso via: todo roteiro
+   saía com a mesma abertura de impacto e o mesmo miolo de lista. Aqui não
+   tem regex escolhendo pelo pedido: o modelo recebe o CARDÁPIO (cada
+   estrutura com o "quando serve" e o jeito de abrir) e o que os últimos
+   vídeos já usaram. Quem escolhe é ele; o código só lembra. */
+const ESTRUTURAS = [
+    { id: 'historia', nome: 'história', quando: 'tem uma pessoa, um caso real ou um antes e depois', abre: 'uma cena concreta: alguém, um lugar, um momento ("Às 6h, a Ana abriu o caixa e…")' },
+    { id: 'problema-solucao', nome: 'problema → solução', quando: 'o assunto resolve uma dor clara', abre: 'a dor dita como quem sente ("Você perde duas horas por semana com…")' },
+    { id: 'lista', nome: 'lista', quando: 'são dicas, razões ou passos que se sustentam sozinhos', abre: 'a promessa com o número ("3 erros que…")' },
+    { id: 'pergunta-resposta', nome: 'pergunta → resposta', quando: 'o público já tem uma dúvida', abre: 'a pergunta, direta, sem a resposta ainda' },
+    { id: 'dialogo', nome: 'diálogo', quando: 'o pedido fala em duas pessoas, duas vozes, conversa ou entrevista', abre: 'a fala de um, e o outro responde' },
+    { id: 'demonstracao', nome: 'demonstração', quando: 'o valor está em VER funcionando', abre: 'o resultado pronto primeiro; depois, como se chega lá' },
+    { id: 'mito-verdade', nome: 'contraste (mito × verdade)', quando: 'existe uma crença comum que está errada', abre: 'o mito, dito como se fosse verdade' },
+    { id: 'dado-surpresa', nome: 'dado que surpreende', quando: 'há um número que muda o jeito de ver o assunto', abre: 'o número sozinho, e a frase que diz por que ele importa' },
+];
+
+const vari = () => require('./variedade.js');   // tardio: a memória mora em ~/.primocode/studio
+const idEstrutura = (x) => String(x || '').toLowerCase().normalize('NFD').replace(/[̀-ͯ]/g, '')
+    .replace(/[^a-z0-9]+/g, '-').replace(/^-|-$/g, '').slice(0, 40);
+
+/** As últimas estruturas e aberturas que saíram em vídeo, mais nova primeiro. */
+function recentes(n = 3) {
+    return { estruturas: vari().usadas('estrutura').slice(0, n), aberturas: vari().usadas('abertura').slice(0, n) };
+}
+
+/** O cardápio em texto, para o prompt — com o que foi usado por último. */
+function cardapioEstruturas({ usadas = recentes() } = {}) {
+    const linhas = ESTRUTURAS.map((e) => `- ${e.id} (${e.nome}): se ${e.quando}. Abre com ${e.abre}.`);
+    if (usadas.estruturas.length) linhas.push(`Usadas recentemente: ${usadas.estruturas.join(', ')} — prefira outra, a menos que o pedido peça essa.`);
+    if (usadas.aberturas.length) linhas.push(`Os últimos vídeos começaram assim: ${usadas.aberturas.map((a) => `"${a}"`).join(' · ')} — não comece do mesmo jeito.`);
+    linhas.push('Nenhuma serve? Invente a estrutura e dê um nome a ela.');
+    return 'CARDÁPIO DE ESTRUTURAS (você escolhe pelo pedido):\n' + linhas.join('\n');
+}
+
+/**
+ * Depois que o roteiro virou plano: guarda a estrutura que o modelo escolheu
+ * e como o vídeo abriu. Aceita o roteiro (partes/fala) ou o plano do diretor
+ * (cenas/narracao). Não julga a escolha — só lembra dela.
+ */
+function registrarEstrutura(r) {
+    const x = r && typeof r === 'object' ? r : {};
+    const estrutura = idEstrutura(x.estrutura) || null;
+    const p0 = (x.partes || x.cenas || [])[0] || {};
+    const abertura = String(p0.fala || p0.narracao || p0.titulo || '').split(/\s+/).filter(Boolean).slice(0, 8).join(' ') || null;
+    if (estrutura) vari().marcar('estrutura', estrutura);
+    if (abertura) vari().marcar('abertura', abertura);
+    return { estrutura, abertura };
+}
+
 // ── 3. o plano ───────────────────────────────────────────────────────────
 
-const CAMPOS_CENA = ['titulo', 'narracao', 'duracao', 'aTela', 'fundo', 'transicao',
+const CAMPOS_CENA = ['titulo', 'falante', 'narracao', 'duracao', 'aTela', 'fundo', 'transicao',
     'elementos', 'midia', 'camera', 'chaves', 'notas'];
 
 /**
@@ -170,6 +223,7 @@ function normalizarPlano(bruto, { segundos } = {}) {
         tom: p.tom || 'neutro',
         publico: p.publico || null,
         promessa: p.promessa || null,          // o que a pessoa leva do vídeo
+        estrutura: idEstrutura(p.estrutura) || null,
         segundos: total,
         voz: vozPara({ tom: p.tom, idioma: p.idioma || 'pt-BR',
             genero: p.voz && p.voz.genero }),
@@ -181,6 +235,9 @@ function normalizarPlano(bruto, { segundos } = {}) {
         midia: limpas.flatMap((c, i) => c.midia.map((m) => ({ cena: i + 1, ...m }))),
         creditos: !!p.creditos,
     };
+    // Duas vozes (falantes.js): o mapa e quem fala cada cena, quando o diretor escreveu diálogo.
+    const { vozes } = require('./falantes.js').normalizar({ vozes: p.vozes, partes: limpas });
+    if (vozes) plano.vozes = vozes;
     return { plano, defeitos, ok: defeitos.length === 0 };
 }
 
@@ -197,6 +254,7 @@ Devolva SÓ um bloco \`\`\`json com este formato, sem texto antes nem depois:
 
 {
   "titulo": "…",
+  "estrutura": "o id que você escolheu no cardápio abaixo (ou o nome da que inventou)",
   "formato": "${formato}",
   "proporcao": "16:9 | 9:16 | 1:1 | 4:5",
   "visual": "a direção de arte em uma ou duas frases: paleta (diga as cores em hex), que ar tem (limpo, denso, luminoso, sujo), que tipografia pede. NÃO existe lista de temas — descreva o que este vídeo tem de próprio.",
@@ -204,9 +262,11 @@ Devolva SÓ um bloco \`\`\`json com este formato, sem texto antes nem depois:
   "publico": "para quem é",
   "promessa": "o que a pessoa leva ao terminar de ver",
   "trilha": { "busca": "termo de busca da música", "humor": "…", "volume": 0.18 },
+  "vozes": { "nome de quem fala": "antonio | thalita | francisca" },
   "cenas": [
     {
       "titulo": "o que aparece grande na tela",
+      "falante": "quem fala esta cena (um nome de vozes) — só quando houver mais de uma voz",
       "narracao": "a frase FALADA, escrita para ser lida em voz alta",
       "duracao": 3.5,
       "aTela": "o que se vê nesta cena, descrito como você descreveria para um motion designer: onde está cada coisa, que tamanho tem, o que domina o quadro",
@@ -223,13 +283,16 @@ Devolva SÓ um bloco \`\`\`json com este formato, sem texto antes nem depois:
 REGRAS QUE SEPARAM UM VÍDEO BOM DE UM GENÉRICO:
 1. NARRAÇÃO É FALA, NÃO LEGENDA. "Vantagens" não é narração. Escreva a frase que a pessoa ouve.
 2. O QUE SE OUVE E O QUE SE VÊ NÃO SE REPETEM. A tela mostra a prova (número, imagem, logo); a voz conta o que ela significa.
-3. ARCO. Primeira cena prende em 2 segundos, o miolo entrega, a última pede uma ação. Sem "Introdução / Desenvolvimento / Conclusão".
+3. ESTRUTURA. Escolha no cardápio do fim a que serve a ESTE pedido; a primeira cena abre do jeito dela e prende em 2 segundos, a última pede uma ação. Sem "Introdução / Desenvolvimento / Conclusão".
 4. NÚMERO É CONCRETO. Nada de "muitos clientes": ou tem o número, ou a frase muda.
 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").
 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".`;
+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.
+
+${cardapioEstruturas()}`;
 };
 
 const REVISAO = (defeitos) => `O plano voltou com defeitos de FORMA. Corrija SÓ o que está listado e devolva o JSON inteiro de novo, no mesmo formato:
@@ -289,9 +352,11 @@ function pauta(plano) {
     linhas.push(`PLANO DE PRODUÇÃO — ${p.titulo}`);
     linhas.push(`formato ${p.formato} · ${p.proporcao} · ${p.segundos}s · tom ${p.tom}`);
     if (p.visual) linhas.push(`visual: ${p.visual}`);
+    if (p.estrutura) linhas.push(`estrutura: ${p.estrutura} (mande em roteiro.estrutura)`);
     if (p.promessa) linhas.push(`promessa: ${p.promessa}`);
     if (p.publico) linhas.push(`público: ${p.publico}`);
     linhas.push(`voz: ${p.voz && p.voz.perfil} · ${p.voz && p.voz.instrucao} · ${p.voz && p.voz.idioma}`);
+    if (p.vozes) linhas.push(`vozes: ${Object.entries(p.vozes).map(([k, v]) => `${k} = ${v}`).join(', ')} (mande em roteiro.vozes, e falante em cada parte)`);
     if (p.trilha) linhas.push(`trilha: ${p.trilha.busca || p.trilha.arquivo} (volume ${p.trilha.volume})`);
     linhas.push('');
     (p.cenas || []).forEach((c, i) => {
@@ -299,7 +364,7 @@ function pauta(plano) {
         if (c.titulo) linhas.push(`  na tela: ${c.titulo}`);
         if (c.aTela) linhas.push(`  composição: ${c.aTela}`);
         if (c.fundo) linhas.push(`  fundo: ${typeof c.fundo === 'string' ? c.fundo : JSON.stringify(c.fundo)}`);
-        linhas.push(`  narração: ${c.narracao}`);
+        linhas.push(`  narração${c.falante ? ` (${c.falante})` : ''}: ${c.narracao}`);
         if (c.camera && c.camera !== 'nenhuma') linhas.push(`  câmera: ${c.camera}`);
         if (c.chaves) linhas.push(`  movimento: ${c.chaves}`);
         (c.midia || []).forEach((m) => linhas.push(
@@ -314,6 +379,7 @@ function pauta(plano) {
 
 module.exports = {
     precisaDeProducao, precisaDeEdicao, vozPara, ritmoPara,
+    ESTRUTURAS, recentes, cardapioEstruturas, registrarEstrutura,
     normalizarPlano, extrairJSON, planejar, pauta,
     DIRETOR, REVISAO,
 };

package/lib/estudio/edicao.js

@@ -26,6 +26,8 @@
 
 'use strict';
 
+const decisao = require('./decisao.js');
+
 // ── as palavras que não carregam ideia ───────────────────────────────────
 const VAZIAS = new Set((
     'a o as os um uma uns umas de do da dos das no na nos nas em por para pra pro com sem que se e '
@@ -88,6 +90,25 @@ const ICONES = [
     [['surpre', 'chocad', 'absurd'], 'exploding-head'],
 ];
 
+/* AS OUTRAS FORMAS DE DIZER O MESMO (07/10): "não quero que o sistema fique
+   repetindo os mesmos ícones". Cada conceito tinha UM emoji — todo vídeo de
+   dinheiro saía com o mesmo saco de dinheiro. O ícone automático continua
+   saindo daqui pelo primeiro nome (o de ICONES); a passada de variedade do
+   vídeo (index.js, variarIcones) troca pelo que os últimos vídeos menos
+   usaram, o mesmo conceito com o mesmo ícone dentro do vídeo. Nomes
+   conferidos no fluent-emoji-flat do Iconify em 07/10. */
+const ALTERNATIVAS = {
+    robot: ['mechanical-arm', 'desktop-computer'], brain: ['thought-balloon', 'light-bulb'], 'light-bulb': ['sparkles', 'glowing-star', 'gem-stone'],
+    'money-bag': ['dollar-banknote', 'coin', 'money-with-wings', 'credit-card'], stopwatch: ['hourglass-not-done', 'alarm-clock', 'mantelpiece-clock', 'watch'],
+    'chart-increasing': ['seedling', 'mountain', 'chequered-flag'], 'bar-chart': ['clipboard', 'hundred-points'], rocket: ['high-voltage', 'airplane'],
+    fire: ['collision', 'high-voltage', 'dizzy'], 'check-mark-button': ['check-mark', 'thumbs-up', 'hundred-points'], 'cross-mark': ['stop-sign', 'no-entry'],
+    laptop: ['desktop-computer', 'keyboard'], 'globe-showing-americas': ['globe-with-meridians', 'satellite-antenna'], 'speaker-high-volume': ['microphone', 'headphone', 'megaphone'],
+    memo: ['pencil', 'open-book', 'clipboard'], books: ['open-book', 'pencil'], 'speech-balloon': ['speaking-head', 'thought-balloon', 'megaphone'],
+    gear: ['hammer-and-wrench', 'toolbox', 'link'], calendar: ['spiral-calendar'], trophy: ['sports-medal', 'crown', 'glowing-star'],
+    'flexed-biceps': ['high-voltage'], handshake: ['people-hugging', 'link'], locked: ['shield', 'key'], briefcase: ['bank', 'classical-building'],
+    'party-popper': ['confetti-ball', 'sparkles'], 'red-heart': ['sparkling-heart'], 'shopping-cart': ['receipt', 'credit-card'], 'clapper-board': ['video-camera', 'camera'],
+};
+
 /* O termo de busca da IMAGEM DE APOIO, pelo emoji que a palavra ganhou. Em
    inglês de propósito: os acervos abertos respondem muito melhor assim. */
 const FOTO = {
@@ -225,14 +246,6 @@ function blocos(palavras, maximo) {
     return out;
 }
 
-// O zoom de cada cena, em rodízio: parado, punch-in, empurrando devagar.
-function camera(i, dur) {
-    const tipo = i % 3;
-    if (tipo === 0) return { zoom: [{ t: 0, v: 1 }, { t: dur, v: 1.04, e: 'linear' }] };
-    if (tipo === 1) return { zoom: [{ t: 0, v: 1.18 }, { t: dur, v: 1.21, e: 'linear' }] };
-    return { zoom: [{ t: 0, v: 1.07 }, { t: dur, v: 1.13, e: 'suave' }] };
-}
-
 const ESTILOS = {
     viral: { icones: true, letreiro: true, sons: true, barra: true, apoio: true, recorte: true, fundoRecorte: ['#1B1F3B', '#3A1C71'], destaque: '#FFD400', forte: '#00E0A4' },
     limpo: { icones: false, letreiro: false, sons: false, barra: false, apoio: true, recorte: false, fundoRecorte: ['#111111', '#333333'], destaque: '#FFFFFF', forte: '#FFD400' },
@@ -251,8 +264,6 @@ const ESTILOS = {
  * @param {object} op.sons        { pop, whoosh } — caminhos na pasta do projeto, opcionais
  * @param {Set}    op.iconesOk    os nomes de ícone que existem de verdade (sem isso, todos valem)
  */
-// Em quais cenas a pessoa é recortada, com a palavra gigante atrás dela.
-const temRecorte = (i) => i % 4 === 2;
 
 function montarEdicao({ src, duracao, palavras, largura = 1080, altura = 1920, estilo = 'viral', sons = {}, iconesOk = null, imagens = {}, trilha = null, recortes = {}, marca = null }) {
     const e = ESTILOS[estilo] || ESTILOS.viral;
@@ -263,6 +274,10 @@ function montarEdicao({ src, duracao, palavras, largura = 1080, altura = 1920, e
     const base = Math.min(largura, altura);
     const grupos = frases(lista);
     const total = duracao || lista[lista.length - 1].ate + 0.3;
+    /* O QUE CADA FRASE PEDE (decisao.js): movimento, recorte e whoosh pela
+       intensidade dela, não pelo rodízio i % 3 — e depois do golpe, respiro. */
+    const decisoes = decisao.decidir(grupos, { peso });
+    let ladoQuadro = 0;
     const cenas = [];
     const efeitos = [];
     const infos = [];   // onde cada cena começa e a palavra forte dela — para o recorte
@@ -283,12 +298,13 @@ function montarEdicao({ src, duracao, palavras, largura = 1080, altura = 1920, e
             deOrigem: r2(ini), ateOrigem: r2(ini + dur), volume: 1,
         }];
 
-        infos.push({ ini: r2(ini), dur, forte: forte ? { de: local(forte.de), texto: forte.texto, peso: peso(forte.texto) } : null });
+        infos.push({ ini: r2(ini), dur, forte: forte ? { de: local(forte.de), texto: forte.texto, peso: peso(forte.texto) } : null,
+            recorte: decisoes[i].recorte, intensidade: decisoes[i].intensidade });
 
         /* A PALAVRA ATRÁS DA PESSOA: o fundo do quarto some, entra a cor da
            marca, a palavra forte aparece enorme e a pessoa, recortada, fica
            na frente dela. É o efeito que mais denuncia edição de videomaker. */
-        const rec = e.recorte && temRecorte(i) ? recortes[i] : null;
+        const rec = e.recorte && decisoes[i].recorte ? recortes[i] : null;
         if (rec && forte) {
             const vida = r2(rec.ate - rec.de);
             const some = [{ t: 0, v: 0 }, { t: 0.1, v: 1 }, { t: vida - 0.12, v: 1 }, { t: vida, v: 0 }];
@@ -403,10 +419,12 @@ function montarEdicao({ src, duracao, palavras, largura = 1080, altura = 1920, e
             });
         }
 
-        // O whoosh entra no punch-in: é o corte que ele anuncia.
-        if (e.sons && sons.whoosh && i > 0 && i % 3 === 1) efeitos.push({ t: r2(Math.max(0, ini - 0.12)), src: sons.whoosh, volume: 0.6 });
+        // O whoosh entra no soco: é o corte que ele anuncia (e só nele).
+        if (e.sons && sons.whoosh && decisoes[i].whoosh) efeitos.push({ t: r2(Math.max(0, ini - 0.12)), src: sons.whoosh, volume: 0.6 });
 
-        cenas.push({ duracao: dur, camera: camera(i, dur), elementos, transicao: { tipo: 'corte' } });
+        const d = decisoes[i];
+        if (d.movimento === 'reenquadra') ladoQuadro = 1 - ladoQuadro;
+        cenas.push({ duracao: dur, camera: decisao.camera(d.movimento, dur, d.intensidade, ladoQuadro, base), elementos, transicao: { tipo: 'corte' }, impacto: d.movimento === 'soco' || undefined });
     });
 
     return {
@@ -473,4 +491,4 @@ async function prepararSons(pasta, video) {
     return sons;
 }
 
-module.exports = { montarEdicao, temRecorte, prepararSons, iconeDe, peso, frases, blocos, termosDeApoio, termoDeApoio, rotaDeApoio, DEPOIS_DA_PALAVRA, ESTILOS, ICONES, FOTO };
+module.exports = { montarEdicao, ALTERNATIVAS, prepararSons, iconeDe, peso, frases, blocos, termosDeApoio, termoDeApoio, rotaDeApoio, DEPOIS_DA_PALAVRA, ESTILOS, ICONES, FOTO };

package/lib/estudio/efeitos.js

@@ -0,0 +1,95 @@
+/**
+ * efeitos.js — o efeito que a IA escreveu num vídeo fica para os próximos.
+ *
+ *   "Quero mais animações, mais efeitos, e que possa criar tudo isso
+ *    também." (Joel, 09/10/2026)
+ *
+ * O `componente` (plano.js) é a válvula: quando nenhuma primitiva alcança, a
+ * IA escreve um arquivo React na pasta do projeto. Só que ele morria com o
+ * projeto — o efeito bonito do vídeo de terça não existia para o de quarta,
+ * e a IA reescrevia do zero (ou pior, nem lembrava que tinha feito).
+ *
+ * Aqui o componente que ficou bom é GUARDADO em ~/.primocode/studio/efeitos/
+ * com nome e descrição, e volta como cardápio: os menos usados primeiro,
+ * pela mesma memória de variedade das trilhas e dos ícones (variedade.js,
+ * tipo 'efeito'). Guardar e reusar são escolhas do modelo; nada entra no
+ * vídeo sozinho.
+ *
+ * Antes de guardar, a fonte é conferida: o efeito vai rodar em OUTROS
+ * projetos, então import relativo (o arquivo vizinho não vai junto),
+ * Math.random/Date.now (cada render sai diferente) e timer (quadro
+ * repetido) são recusados com o motivo.
+ */
+
+'use strict';
+
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+const variedade = require('./variedade.js');
+
+const pasta = () => path.join(os.homedir(), '.primocode', 'studio', 'efeitos');
+const catalogoArq = () => path.join(pasta(), 'catalogo.json');
+const PACOTES = /^(react|react\/jsx-runtime|remotion|@remotion\/[a-z-]+|three|three\/examples\/jsm\/.+|@react-three\/fiber)$/;
+const TETO = 150 * 1024;
+
+function ler() {
+    try { const c = JSON.parse(fs.readFileSync(catalogoArq(), 'utf8')); return Array.isArray(c) ? c : []; } catch { return []; }
+}
+
+/** O que impede este código de rodar em outro projeto. [] = pode guardar. */
+function conferirFonte(codigo) {
+    const falta = [];
+    const sem = String(codigo || '').replace(/\/\*[\s\S]*?\*\//g, '').replace(/\/\/.*$/gm, '');
+    if (!/export\s+(default|function|const)/.test(sem)) falta.push('o arquivo não exporta o componente (export default function …)');
+    for (const m of sem.matchAll(/(?:from\s+|import\s*\(\s*|require\s*\(\s*)['"]([^'"]+)['"]/g)) {
+        if (!PACOTES.test(m[1])) falta.push(`import "${m[1]}": só react, remotion, @remotion/*, three e @react-three/fiber — o arquivo vai sozinho para outro projeto`);
+    }
+    if (/Math\.random|Date\.now/.test(sem)) falta.push('Math.random/Date.now: cada render sairia diferente — use random("semente") do Remotion');
+    if (/setTimeout|setInterval|requestAnimationFrame/.test(sem)) falta.push('timer não existe no render quadro a quadro — anime pelo quadro (useCurrentFrame ou a prop t)');
+    return falta;
+}
+
+/** Guarda o componente do projeto no catálogo, com nome e descrição. */
+function guardar({ pasta: proj, arquivo, nome, descricao, tags = [] } = {}) {
+    const slug = String(nome || '').toLowerCase().normalize('NFD').replace(/[̀-ͯ]/g, '').replace(/[^a-z0-9]+/g, '-').replace(/^-|-$/g, '');
+    if (slug.length < 2) return { ok: false, error: 'dê um nome ao efeito (nome), como "vidro-quebrando".' };
+    if (!String(descricao || '').trim()) return { ok: false, error: 'diga o que o efeito faz (descricao) — é o que você vai ler no cardápio depois.' };
+    if (!proj || !arquivo) return { ok: false, error: 'diga o projeto (id) e o arquivo do componente (arquivo).' };
+    const cheio = path.resolve(proj, arquivo);
+    if (!cheio.startsWith(path.resolve(proj) + path.sep) || !/\.(jsx|js|tsx)$/.test(cheio)) return { ok: false, error: 'o arquivo é um .jsx/.js dentro da pasta do projeto.' };
+    if (!fs.existsSync(cheio)) return { ok: false, error: `o arquivo "${arquivo}" não existe no projeto.` };
+    const codigo = fs.readFileSync(cheio, 'utf8');
+    if (codigo.length > TETO) return { ok: false, error: 'o componente passa de 150 KB — guarde a parte que é o efeito.' };
+    const falta = conferirFonte(codigo);
+    if (falta.length) return { ok: false, error: 'não guardei: ' + falta.join('; ') };
+    fs.mkdirSync(pasta(), { recursive: true });
+    fs.writeFileSync(path.join(pasta(), slug + '.jsx'), codigo);
+    const item = { nome: slug, descricao: String(descricao).trim().slice(0, 300), tags: [].concat(tags || []).map(String).slice(0, 8), guardado: new Date().toISOString().slice(0, 10) };
+    fs.writeFileSync(catalogoArq(), JSON.stringify([item, ...ler().filter((x) => x.nome !== slug)], null, 2));
+    return { ok: true, ...item };
+}
+
+/** O cardápio: os guardados, os menos usados primeiro (memória da variedade). */
+function cardapio({ aleatorio = Math.random } = {}) {
+    const itens = ler().filter((x) => fs.existsSync(path.join(pasta(), x.nome + '.jsx')));
+    return variedade.pontuar(itens, 'efeito', { chave: (x) => x.nome })
+        .map((p) => ({ ...p, pontos: p.pontos + aleatorio() * 0.05 }))
+        .sort((a, b) => b.pontos - a.pontos)
+        .map((p) => ({ nome: p.opcao.nome, descricao: p.opcao.descricao, tags: p.opcao.tags }));
+}
+
+/** Copia o efeito para o projeto e devolve o elemento pronto. Marca o uso. */
+function reusar({ pasta: proj, nome } = {}) {
+    const item = ler().find((x) => x.nome === nome);
+    const de = item && path.join(pasta(), item.nome + '.jsx');
+    if (!item || !fs.existsSync(de)) return { ok: false, error: `não há efeito "${nome}" guardado — veja o cardápio (acao: efeitos).` };
+    if (!proj) return { ok: false, error: 'diga o projeto (id).' };
+    const src = `efeitos/${item.nome}.jsx`;
+    fs.mkdirSync(path.join(proj, 'efeitos'), { recursive: true });
+    fs.copyFileSync(de, path.join(proj, src));
+    variedade.marcar('efeito', item.nome);
+    return { ok: true, src, descricao: item.descricao, elemento: { tipo: 'componente', src, x: 0, y: 0 } };
+}
+
+module.exports = { guardar, cardapio, reusar, conferirFonte, pasta };

package/lib/estudio/estilo.js

@@ -51,13 +51,23 @@ const normal = (e) => {
 /* O RODÍZIO: quando ninguém escolheu ("vários estilos... que não sejam padrão
    da IA", Joel 05/10), o padrão não é sempre o híbrido — gira entre os que
    servem a qualquer roteiro, sem repetir os últimos (memória 'estilo'). */
-const RODIZIO = ['hibrido', 'cinema', 'gerativo', 'impacto', 'fluido'];
+/* Com imagem pedida (08/10): o padrão é o FLUIDO MISTO — motion com a
+   imagem em poucos momentos, cada uma entrando de um jeito. O híbrido e o
+   cinema ("10 mil imagens de banco e a mesma animação") ficam pelo nome. */
+const RODIZIO = ['fluido'];
+/* Sem imagem (o padrão desde 07/10), o rodízio fica nos dois motions que
+   nasceram das referências boas (motions-exemplos/motion-god): o fluido e o
+   gerativo. O impacto (emoji 3D em cada batida, cara de anúncio) saiu do
+   rodízio em 08/10 — "horríveis, nada a ver com as referências" — e fica
+   para quem o pede pelo nome (o agente ou o roteiro). */
+const RODIZIO_SEM_IMAGEM = ['fluido', 'gerativo'];
 
-function estiloDaVez(aleatorio = Math.random) {
-    return variedade.sortear(RODIZIO, 'estilo', { aleatorio }) || 'hibrido';
+function estiloDaVez(aleatorio = Math.random, semImagem = false) {
+    const lista = semImagem ? RODIZIO_SEM_IMAGEM : RODIZIO;
+    return variedade.sortear(lista, 'estilo', { aleatorio }) || lista[0];
 }
 
-function escolherEstilo({ pedido = '', agente = null, roteiro = null, girar = false, aleatorio } = {}) {
+function escolherEstilo({ pedido = '', agente = null, roteiro = null, girar = false, semImagem = false, aleatorio } = {}) {
     const pedidoAgente = normal(agente);
     if (pedidoAgente) return pedidoAgente;
     const doRoteiro = normal(roteiro);
@@ -73,10 +83,11 @@ function escolherEstilo({ pedido = '', agente = null, roteiro = null, girar = fa
     /* Anúncio, reels e o resto: o HÍBRIDO. "Um mix da versão antiga (o reels
        da imersão, no cinema) e da última (o kit) — absurdo, que nem parece
        que foi IA" (29/09). Com `girar`, o padrão roda (RODIZIO). */
-    return girar ? estiloDaVez(aleatorio) : 'hibrido';
+    if (girar) return estiloDaVez(aleatorio, semImagem);
+    return semImagem ? 'gerativo' : 'hibrido';
 }
 
 /** Os estilos que usam os efeitos leves e a trilha do ende.app (os de motion, não os de corte). */
 const LEVES = new Set(['gerativo', 'motion', 'vox', 'marca', 'lancamento', 'fluido']);
 
-module.exports = { escolherEstilo, estiloDaVez, ESTILOS, LEVES, PEDE_MOTION, PEDE_FLUIDO, RODIZIO };
+module.exports = { escolherEstilo, estiloDaVez, ESTILOS, LEVES, PEDE_MOTION, PEDE_FLUIDO, RODIZIO, RODIZIO_SEM_IMAGEM };