primocode 9.8.0-beta.12 → 9.8.0-beta.13

package/README.md

@@ -1,4 +1,4 @@
-# PrimoCode v9.8.0-beta.12
+# PrimoCode v9.8.0-beta.13
 
 Agente de engenharia brasileiro para o terminal, no estilo Claude Code.
 Cria arquivos de verdade, roda comandos, **controla o navegador e o desktop** —
@@ -9,7 +9,7 @@ OpenRouter, e cada apelido (`top`/`main`/`fast`) é uma **corrente**: se um mode
 está no limite de pedidos, o próximo atende. Você não vê o erro, e não paga nada.
 
 ```
- ▐▛███▜▌   Primo Code v9.8.0-beta.12
+ ▐▛███▜▌   Primo Code v9.8.0-beta.13
 ▝▜█████▛▘  Bem-vindo de volta, Joel
   ▘▘ ▝▝    ~/primocode  · /dir <pasta> muda
 ```

package/lib/act.js

@@ -692,15 +692,19 @@ async function runAct(userPrompt, opts) {
 
                Um modelo não chama tool fora da lista por conta própria. Só
                chamou porque este parágrafo mandou. */
+            /* O caminho do ROTEIRO (lib/estudio/composicao.js). Antes esta
+               ordem mandava chamar o diretor e depois compor "cena a cena,
+               com as primitivas" — o modelo escrevia posição em pixel e o
+               vídeo saía quebrado, além de custar três ou quatro rodadas a
+               mais de modelo (medido em 25/09). */
             messages.push({ role: 'system', content:
-                'ESTE PEDIDO É DE PRODUÇÃO AUDIOVISUAL. Se `planejar_producao` estiver na sua lista de '
-                + `ferramentas, chame-o ANTES de criar qualquer peça (formato "${producao.formato}"): `
-                + 'ele devolve a pauta — arco, narração falada, voz, direção de arte e a mídia a buscar — '
-                + 'e é ela que você produz, cena a cena, compondo com as primitivas. '
-                + 'Se ele NÃO estiver na sua lista, não o chame e não procure equivalente: siga com as '
-                + 'ferramentas que você tem e escreva o roteiro antes das cenas, não dentro do JSON delas. '
-                + 'Nunca chame uma ferramenta que não está na sua lista — a chamada é recusada e a tarefa '
-                + 'se perde.' });
+                `ESTE PEDIDO É DE PRODUÇÃO (formato "${producao.formato === 'apresentacao' ? 'slides' : 'video'}"). Faça em três passos: `
+                + `estudio_projeto acao:"criar" com formato "${producao.formato === 'apresentacao' ? 'slides' : 'video'}" → `
+                + 'estudio_plano com "roteiro" (partes com tipo e fala; o PrimoCode faz layout, voz, ícones, música e sons) → '
+                + 'estudio_render. Se a peça for de uma marca de verdade, estudio_site antes, e use as cores e a logo em roteiro.marca. '
+                + 'NÃO escreva cenas, elementos nem posições à mão. '
+                + 'Se estudio_plano não aceitar "roteiro" (servidor antigo), siga com as ferramentas que você tem. '
+                + 'Nunca chame uma ferramenta que não está na sua lista — a chamada é recusada e a tarefa se perde.' });
         }
     }
 

package/lib/catalogo.js

@@ -84,7 +84,11 @@ const GRUPOS = [
                 + 'SEMPRE procure antes de criar quando o pedido falar de algo que já existe.' },
 
             { tool: 'estudio_plano', escreve: true, faz: 'escreve ou ajusta o que o vídeo É — cenas, elementos, animação, câmera, áudio',
-              args: 'id. plano: {formato:{largura,altura,fps}, cenas:[…], audio:{…}} — ou cenas direto. '
+              args: 'id. PREFIRA roteiro: {marca:{cores:{fundo,destaque,tinta},fontes:{titulo,texto},logo}, proporcao, '
+                + 'partes:[{tipo, fala, …}]} — o PrimoCode faz o layout, a voz com entonação, os ícones, a música e os sons. '
+                + 'Tipos: abertura{titulo,sub} titulo{titulo,sub} numero{valor,rotulo,sub} lista{titulo,itens} passos{titulo,itens} '
+                + 'contraste{nao,sim} citacao{texto,autor} imagem{busca,titulo,sub} grafico{titulo,barras:[{rotulo,valor}]} cta{titulo,link}. '
+                + 'voz (thalita|antonio|francisca). Ajuste fino: plano: {formato:{largura,altura,fps}, cenas:[…], audio:{…}} — ou cenas direto. '
                 + 'cena (opcional): o número de UMA cena para trocar só ela, sem reescrever o resto. '
                 + 'motivo (opcional): fica no caderno. voltarPara (opcional): nome de uma versão. '
                 + 'Sem plano nem cenas, LÊ o plano atual. '

package/lib/estudio/composicao.js

@@ -0,0 +1,404 @@
+/**
+ * composicao.js — o roteiro vira cena, e quem faz o layout é o CÓDIGO.
+ *
+ *   "Os motion estão bem quebrados, a voz está sem entonação, não tem música,
+ *    efeitos sonoros, ícones… ele sobrepõe as coisas." · "Os slides entregou
+ *    uma merda." (25/09/2026)
+ *
+ * O modelo escrevia a posição de cada texto em pixel, à mão, e errava: texto
+ * cortado na borda, letra minúscula, meia tela vazia, nada de som. Aqui o
+ * modelo escreve só o ROTEIRO — o que cada parte diz e de que tipo ela é — e
+ * o código monta a cena:
+ *
+ *   - a letra é MEDIDA para caber na caixa (nunca sai da tela, nunca some de
+ *     tão pequena), e tudo respeita a margem de segurança;
+ *   - cada tipo de parte tem a composição dele (abertura, número que conta,
+ *     lista com ícones, contraste, citação, imagem, gráfico, passos, chamada),
+ *     e a variação vem da marca e da posição no roteiro;
+ *   - no vídeo, cada parte dura o que a voz dela dura, e o som (whoosh na
+ *     transição, pop no item, música de cama) entra sozinho;
+ *   - no slide, é a MESMA cena, parada.
+ *
+ * Função pura: roteiro + tempos da voz entram, plano sai.
+ */
+
+'use strict';
+
+const { iconeDe } = require('./edicao.js');
+
+const TIPOS = ['abertura', 'titulo', 'numero', 'lista', 'contraste', 'citacao', 'imagem', 'grafico', 'passos', 'cta'];
+
+// ── cor ──────────────────────────────────────────────────────────────────
+function rgb(hex) {
+    const h = String(hex || '').replace('#', '');
+    const n = h.length === 3 ? h.split('').map((c) => c + c).join('') : h.padEnd(6, '0').slice(0, 6);
+    return [0, 2, 4].map((i) => parseInt(n.slice(i, i + 2), 16) || 0);
+}
+const hex = (c) => '#' + c.map((v) => Math.max(0, Math.min(255, Math.round(v))).toString(16).padStart(2, '0')).join('');
+const misturar = (a, b, k) => hex(rgb(a).map((v, i) => v + (rgb(b)[i] - v) * k));
+const luz = (c) => { const [r, g, b] = rgb(c); return (0.299 * r + 0.587 * g + 0.114 * b) / 255; };
+const alfa = (c, a) => c + Math.round(a * 255).toString(16).padStart(2, '0');
+
+function paleta(marca = {}) {
+    const c = marca.cores || {};
+    const fundo = c.fundo || '#0E0F14';
+    const escuro = luz(fundo) < 0.5;
+    const tinta = c.tinta || (escuro ? '#F4F2EC' : '#15161A');
+    const destaque = c.destaque || '#FF6A3D';
+    return {
+        fundo, tinta, destaque, escuro,
+        fundo2: misturar(fundo, tinta, escuro ? 0.07 : 0.05),
+        apoio: c.apoio || misturar(destaque, tinta, 0.35),
+        suave: alfa(tinta, 0.68),
+        // Sobre o destaque, a tinta que dá contraste.
+        sobreDestaque: luz(destaque) > 0.6 ? '#15161A' : '#FFFFFF',
+    };
+}
+
+/* ── a letra que cabe ─────────────────────────────────────────────────────
+ * Largura média do caractere em "em" por família. Não é exata — é o
+ * bastante para escolher o maior tamanho que cabe em N linhas, com folga. */
+const LARGURA = { condensada: 0.43, display: 0.56, texto: 0.52, serifa: 0.5 };
+const FAMILIA_TIPO = (f) => (/condensed|narrow|anton|oswald|bebas|teko|league gothic/i.test(f) ? 'condensada'
+    : /serif|fraunces|playfair|garamond|lora|newsreader|spectral|baskerville|dm serif/i.test(f) ? 'serifa'
+        : /black|bricolage|archivo|sora|grotesk|syne|unbounded/i.test(f) ? 'display' : 'texto');
+
+function caber(texto, { largura, linhas = 2, max = 200, min = 18, fonte = 'Inter' }) {
+    const cw = LARGURA[FAMILIA_TIPO(fonte)];
+    const palavras = String(texto || '').split(/\s+/).filter(Boolean);
+    for (let t = Math.round(max); t >= min; t -= 2) {
+        // Quebra de verdade, palavra por palavra: é o que o navegador fará.
+        let n = 1, linha = 0;
+        let cabe = true;
+        for (const w of palavras) {
+            const lw = (w.length + 1) * cw * t;
+            if (lw > largura * 1.02) { cabe = false; break; } // uma palavra sozinha não cabe
+            if (linha + lw > largura) { n++; linha = lw; } else linha += lw;
+        }
+        if (cabe && n <= linhas) return { tamanho: t, linhas: n };
+    }
+    return { tamanho: min, linhas };
+}
+
+// ── as partes do roteiro ─────────────────────────────────────────────────
+const r2 = (n) => Math.round(n * 100) / 100;
+const TRANSICOES = ['deslizar', 'zoom', 'mascara', 'esmaecer', 'morph'];
+
+function textoDe(p) {
+    return [p.titulo, p.texto, p.valor, p.rotulo, p.sub, p.nao, p.sim, ...(p.itens || []).map((i) => (typeof i === 'string' ? i : i.texto))]
+        .filter(Boolean).join(' ');
+}
+
+/** O que a voz diz nesta parte. Sem "fala", a voz lê o que está na tela. */
+function falaDe(p) {
+    if (p.fala) return String(p.fala);
+    if (p.tipo === 'numero') return `${p.valor} ${p.rotulo || ''}.`;
+    return textoDe(p);
+}
+
+/** O registro da voz para esta parte (ver REGISTRO em studio/narrar.py). */
+function registroDe(p, i, n) {
+    if (i === 0) return 'gancho';
+    if (p.tipo === 'cta' || i === n - 1) return 'cta';
+    return { numero: 'numero', contraste: 'contraste', lista: 'lista', citacao: 'citacao', passos: 'lista' }[p.tipo] || 'normal';
+}
+
+function iconesDoRoteiro(roteiro) {
+    const nomes = new Set();
+    for (const p of roteiro.partes || []) {
+        for (const it of p.itens || []) {
+            const t = typeof it === 'string' ? it : it.texto;
+            const ic = (typeof it === 'object' && it.icone) || iconeDoTexto(t);
+            if (ic) nomes.add(ic);
+        }
+    }
+    return [...nomes];
+}
+
+function iconeDoTexto(t) {
+    for (const w of String(t || '').split(/\s+/)) { const ic = iconeDe(w); if (ic) return ic; }
+    return null;
+}
+
+/**
+ * O plano.
+ *
+ * @param {object} op
+ * @param {object} op.roteiro   { partes: [{tipo, …}], marca: {cores, fontes, logo} }
+ * @param {string} op.modo      'video' | 'slides'
+ * @param {Array}  op.tempos    no vídeo: [{de, ate, palavras}] da voz de cada parte
+ * @param {string} op.narracao  o mp3 da voz (vídeo)
+ * @param {object} op.sons      { pop, whoosh }
+ * @param {string} op.trilha    a música de cama (vídeo)
+ * @param {object} op.imagens   { indiceDaParte: src }
+ * @param {Set}    op.iconesOk  os ícones que existem
+ */
+function comporRoteiro({ roteiro, modo = 'video', largura = 1920, altura = 1080, tempos = [], narracao = null,
+    sons = {}, trilha = null, imagens = {}, iconesOk = null }) {
+    const partes = (roteiro && roteiro.partes) || [];
+    if (!partes.length) return { ok: false, error: 'o roteiro veio sem partes.' };
+    const ruins = partes.map((p, i) => (TIPOS.includes(p.tipo) ? null : `parte ${i + 1}: tipo "${p.tipo}" não existe (use ${TIPOS.join(', ')})`)).filter(Boolean);
+    if (ruins.length) return { ok: false, error: 'o roteiro tem partes de tipo desconhecido.', problemas: ruins };
+
+    const marca = roteiro.marca || {};
+    const cor = paleta(marca);
+    const F = {
+        titulo: (marca.fontes && marca.fontes.titulo) || 'Bricolage Grotesque',
+        texto: (marca.fontes && marca.fontes.texto) || 'Inter',
+        serifa: (marca.fontes && marca.fontes.serifa) || 'Fraunces',
+    };
+    const W = largura, H = altura;
+    const M = Math.round(Math.min(W, H) * 0.08);          // a margem de segurança
+    const vid = modo === 'video';
+    const deitado = W >= H;
+    const cenas = [];
+    const efeitos = [];
+
+    // No slide tudo já entrou quando o quadro do meio é tirado (1,5 s).
+    const atraso = (t) => (vid ? t : Math.min(t, 0.9) * 0.6);
+
+    partes.forEach((p, i) => {
+        const tp = tempos[i] || {};
+        const proxDe = tempos[i + 1] ? tempos[i + 1].de : null;
+        const base = vid ? Math.max(1.6, (proxDe != null ? proxDe : (tp.ate || 0) + 0.9) - (tp.de || 0)) : 3;
+        const trans = !vid || i === 0 ? 'corte' : TRANSICOES[i % TRANSICOES.length];
+        const cruz = trans === 'corte' ? 0 : 0.35;
+        const dur = r2(base + cruz);
+        const els = [];
+        const variante = i % 2;
+
+        // ── o fundo: cor, profundidade e movimento, nunca chapado e morto ──
+        let fundo = { tipo: 'cor', valor: variante ? cor.fundo2 : cor.fundo };
+        let tinta = cor.tinta, destaque = cor.destaque, suave = cor.suave;
+        if (p.tipo === 'numero') { fundo = { tipo: 'cor', valor: cor.destaque }; tinta = cor.sobreDestaque; destaque = cor.sobreDestaque; suave = alfa(cor.sobreDestaque, 0.75); }
+        if (p.tipo !== 'imagem') {
+            const R = Math.round(Math.max(W, H) * 0.62);
+            const canto = [[W - R * 0.55, -R * 0.45], [-R * 0.45, H - R * 0.5], [W - R * 0.4, H - R * 0.55], [-R * 0.5, -R * 0.4]][i % 4];
+            els.push({
+                tipo: 'forma', forma: 'circulo', largura: R, altura: R, x: Math.round(canto[0]), y: Math.round(canto[1]),
+                cor: p.tipo === 'numero' ? cor.sobreDestaque : cor.destaque, opacidade: p.tipo === 'numero' ? 0.12 : (cor.escuro ? 0.22 : 0.16),
+                anima: {
+                    desfoque: [{ t: 0, v: Math.round(R * 0.22) }],
+                    x: [{ t: 0, v: 0 }, { t: dur, v: variante ? 60 : -60, e: 'suave' }],
+                    y: [{ t: 0, v: 0 }, { t: dur, v: variante ? -40 : 40, e: 'suave' }],
+                },
+            });
+        }
+
+        const W0 = W - 2 * M;
+        const titulo = (texto, { y, larg = W0, linhas = 2, max = H * 0.12, x = M, alinhar = 'left', de = 0.15, cor: c = tinta, destaqueUltima = true }) => {
+            const fit = caber(texto, { largura: larg, linhas, max, fonte: F.titulo });
+            const ws = String(texto).split(/\s+/);
+            els.push({
+                tipo: 'texto', texto, fonte: F.titulo, peso: 800, tamanho: fit.tamanho, cor: c, entrelinha: 1.04,
+                x, y: Math.round(y), largura: Math.round(larg), alinhamento: alinhar,
+                revelar: ws.map((_, k) => r2(atraso(de + k * 0.07))),
+                ...(destaqueUltima && ws.length > 2 ? { destaques: [ws.length - 1], corDestaque: destaque } : {}),
+            });
+            return fit.tamanho * 1.04 * fit.linhas;
+        };
+        const linhaFina = (texto, { y, larg = W0, x = M, max = H * 0.04, de = 0.5, alinhar = 'left', c = suave, linhas = 2 }) => {
+            const fit = caber(texto, { largura: larg, linhas, max, fonte: F.texto });
+            els.push({
+                tipo: 'texto', texto, fonte: F.texto, peso: 500, tamanho: fit.tamanho, cor: c, entrelinha: 1.3,
+                x, y: Math.round(y), largura: Math.round(larg), alinhamento: alinhar,
+                anima: { opacidade: [{ t: atraso(de), v: 0 }, { t: atraso(de) + 0.4, v: 1 }], y: [{ t: atraso(de), v: 18 }, { t: atraso(de) + 0.5, v: 0, e: 'saida' }] },
+            });
+            return fit.tamanho * 1.3 * fit.linhas;
+        };
+        const traco = (x, y, c = destaque, de = 0.05) => els.push({
+            tipo: 'forma', forma: 'retangulo', x, y: Math.round(y), largura: Math.round(W * 0.06), altura: Math.max(6, Math.round(H * 0.008)),
+            cor: c, origem: 'left', anima: { escalaX: [{ t: atraso(de), v: 0 }, { t: atraso(de) + 0.5, v: 1, e: 'saida' }] },
+        });
+        const logo = (x, y, alt) => { if (marca.logo) els.push({ tipo: 'imagem', src: marca.logo, x, y, altura: alt, largura: Math.round(alt * 4), ajuste: 'contain', foco: 'left center', anima: { opacidade: [{ t: atraso(0.3), v: 0 }, { t: atraso(0.3) + 0.4, v: 1 }] } }); };
+
+        switch (p.tipo) {
+            case 'abertura':
+            case 'titulo': {
+                const centro = p.tipo === 'titulo' && variante === 1;
+                const larg = centro ? W0 * 0.86 : W0 * (deitado ? 0.78 : 1);
+                const fit = caber(p.titulo || '', { largura: larg, linhas: 3, max: H * (p.tipo === 'abertura' ? 0.15 : 0.12), fonte: F.titulo });
+                const hT = fit.tamanho * 1.04 * fit.linhas;
+                const hS = p.sub ? H * 0.09 : 0;
+                let y = (H - hT - hS) / 2;
+                const x = centro ? (W - larg) / 2 : M;
+                if (p.tipo === 'abertura') logo(M, M, Math.round(H * 0.05));
+                if (!centro) traco(M, y - H * 0.05);
+                titulo(p.titulo || '', { y, larg, linhas: 3, max: fit.tamanho, x, alinhar: centro ? 'center' : 'left' });
+                if (p.sub) linhaFina(p.sub, { y: y + hT + H * 0.03, larg, x, alinhar: centro ? 'center' : 'left', de: 0.6 });
+                break;
+            }
+            case 'numero': {
+                const valor = String(p.valor == null ? '' : p.valor);
+                const m = valor.match(/^([^\d-]*)(-?[\d.,]+)(.*)$/);
+                const larg = deitado ? W0 * 0.5 : W0;
+                const fit = caber(valor, { largura: larg, linhas: 1, max: H * (deitado ? 0.5 : 0.3), fonte: F.titulo });
+                const yN = deitado ? (H - fit.tamanho) / 2 - H * 0.03 : H * 0.22;
+                const num = Number(m ? m[2].replace(/\./g, '').replace(',', '.') : NaN);
+                els.push({
+                    tipo: 'texto', texto: valor, fonte: F.titulo, peso: 800, tamanho: fit.tamanho, cor: tinta, entrelinha: 1,
+                    x: M, y: Math.round(yN), largura: Math.round(larg + M),
+                    ...(m && !Number.isNaN(num) ? { contar: { ate: num, dur: vid ? 1.3 : 0.6, antes: m[1], depois: m[3], casas: (m[2].split(',')[1] || '').length } } : {}),
+                    anima: { escala: [{ t: 0, v: 0.86 }, { t: atraso(0.5), v: 1, e: 'saida' }], opacidade: [{ t: 0, v: 0 }, { t: 0.15, v: 1 }] },
+                });
+                const xR = deitado ? M + larg + W * 0.04 : M;
+                const lR = deitado ? W - xR - M : W0;
+                const yR = deitado ? H * 0.38 : yN + fit.tamanho + H * 0.04;
+                const hR = titulo(p.rotulo || '', { y: yR, larg: lR, linhas: 3, max: H * 0.075, x: xR, de: 0.4, destaqueUltima: false });
+                if (p.sub) linhaFina(p.sub, { y: yR + hR + H * 0.03, larg: lR, x: xR, de: 0.8 });
+                break;
+            }
+            case 'lista':
+            case 'passos': {
+                const itens = (p.itens || []).slice(0, 5).map((it) => (typeof it === 'string' ? { texto: it } : it));
+                const n = itens.length || 1;
+                const colunas = deitado && n <= 4 ? n : 1;
+                const gap = W * 0.025;
+                const wCard = colunas > 1 ? (W0 - gap * (colunas - 1)) / colunas : W0;
+                /* O bloco inteiro (título + itens) fica no meio da altura: com
+                   o título no topo e os itens logo abaixo, sobrava meia tela
+                   vazia embaixo. */
+                const fT = p.titulo ? caber(p.titulo, { largura: W0, linhas: 2, max: H * 0.1, fonte: F.titulo }) : { tamanho: 0, linhas: 0 };
+                const hTit = fT.tamanho * 1.04 * fT.linhas;
+                const hCard0 = colunas > 1 ? (p.tipo === 'passos' ? H * 0.26 : H * 0.44) : H * 0.14;
+                const hItens = colunas > 1 ? hCard0 : n * hCard0 + (n - 1) * gap;
+                const bloco = hTit + (hTit ? H * 0.07 : 0) + hItens;
+                const yTit = Math.max(M, (H - bloco) / 2);
+                if (p.titulo) titulo(p.titulo, { y: yTit, linhas: 2, max: fT.tamanho });
+                const topo = yTit + hTit + (hTit ? H * 0.07 : 0);
+                const hCard = Math.min(hCard0, colunas > 1 ? H - topo - M : (H - topo - M - gap * (n - 1)) / n);
+                const dur0 = vid ? Math.max(1, (tp.ate || dur) - (tp.de || 0)) : 1;
+                itens.forEach((it, k) => {
+                    const cx = colunas > 1 ? M + k * (wCard + gap) : M;
+                    const cy = colunas > 1 ? topo : topo + k * (hCard + gap);
+                    // O item entra quando a voz chega nele (ou em cascata, no slide).
+                    const quando = atraso(vid ? 0.5 + (dur0 * 0.85 - 0.5) * (k / n) : 0.3 + k * 0.12);
+                    const entra = { opacidade: [{ t: quando, v: 0 }, { t: quando + 0.3, v: 1 }], y: [{ t: quando, v: 40 }, { t: quando + 0.45, v: 0, e: 'saida' }] };
+                    if (p.tipo === 'lista') {
+                        els.push({ tipo: 'forma', forma: 'retangulo', x: Math.round(cx), y: Math.round(cy), largura: Math.round(wCard), altura: Math.round(hCard), cor: alfa(tinta, cor.escuro ? 0.07 : 0.06), raio: Math.round(H * 0.025), anima: entra });
+                    } else if (k < n - 1 && colunas > 1) {
+                        els.push({ tipo: 'forma', forma: 'retangulo', x: Math.round(cx + H * 0.05), y: Math.round(cy + H * 0.05), largura: Math.round(wCard + gap), altura: 4, cor: alfa(destaque, 0.5), origem: 'left', anima: { escalaX: [{ t: quando, v: 0 }, { t: quando + 0.6, v: 1, e: 'suave' }] } });
+                    }
+                    const tamI = Math.round(Math.min(hCard * (colunas > 1 ? 0.28 : 0.5), H * 0.09));
+                    const ic = it.icone || iconeDoTexto(it.texto);
+                    const pad = Math.round(Math.min(wCard, hCard) * 0.14);
+                    if (p.tipo === 'passos') {
+                        els.push({ tipo: 'forma', forma: 'circulo', x: Math.round(cx + pad * 0.3), y: Math.round(cy + pad * 0.3), largura: tamI, altura: tamI, cor: destaque, anima: { ...entra, escala: [{ t: quando, v: 0 }, { t: quando + 0.35, v: 1, e: 'elastico' }] } });
+                        els.push({ tipo: 'texto', texto: String(k + 1), fonte: F.titulo, peso: 800, tamanho: Math.round(tamI * 0.5), cor: cor.sobreDestaque, x: Math.round(cx + pad * 0.3 + tamI / 2), y: Math.round(cy + pad * 0.3 + tamI / 2), ancora: 'centro', anima: entra });
+                    } else if (ic && (!iconesOk || iconesOk.has(ic))) {
+                        els.push({ tipo: 'icone', nome: ic, tamanho: tamI, x: Math.round(cx + pad), y: Math.round(cy + (colunas > 1 ? pad : (hCard - tamI) / 2)), anima: { ...entra, escala: [{ t: quando, v: 0 }, { t: quando + 0.3, v: 1.12, e: 'saida' }, { t: quando + 0.45, v: 1 }] } });
+                    }
+                    if (vid && sons.pop) efeitos.push({ t: r2((tp.de || 0) + quando), src: sons.pop, volume: 0.5 });
+                    const tx = colunas > 1 ? cx + pad : cx + pad + tamI + pad;
+                    const ty = colunas > 1 ? cy + pad + tamI + pad * 0.8 : cy + hCard / 2;
+                    const lw = colunas > 1 ? wCard - 2 * pad : wCard - (tamI + 3 * pad);
+                    const fit = caber(it.texto, { largura: lw, linhas: colunas > 1 ? 4 : 2, max: Math.min(H * 0.05, hCard * 0.3), fonte: F.texto });
+                    els.push({
+                        tipo: 'texto', texto: it.texto, fonte: F.texto, peso: 650, tamanho: fit.tamanho, cor: tinta, entrelinha: 1.2,
+                        x: Math.round(tx), y: Math.round(colunas > 1 ? ty : ty - fit.tamanho * 1.2 * fit.linhas / 2), largura: Math.round(lw), anima: entra,
+                    });
+                });
+                break;
+            }
+            case 'contraste': {
+                const larg = W0 * 0.9;
+                const f1 = caber(p.nao || '', { largura: larg, linhas: 2, max: H * 0.07, fonte: F.texto });
+                const f2 = caber(p.sim || '', { largura: larg, linhas: 3, max: H * 0.13, fonte: F.titulo });
+                const hTot = f1.tamanho * 1.2 * f1.linhas + H * 0.05 + f2.tamanho * 1.04 * f2.linhas;
+                const y1 = (H - hTot) / 2;
+                const meio = vid ? Math.max(0.8, ((tp.ate || dur) - (tp.de || 0)) * 0.45) : 0.5;
+                els.push({ tipo: 'texto', texto: p.nao || '', fonte: F.texto, peso: 600, tamanho: f1.tamanho, cor: alfa(tinta, 0.5), x: M, y: Math.round(y1), largura: Math.round(larg), entrelinha: 1.2, anima: { opacidade: [{ t: 0.1, v: 0 }, { t: 0.4, v: 1 }] } });
+                els.push({ tipo: 'forma', forma: 'retangulo', x: M, y: Math.round(y1 + f1.tamanho * 0.62), largura: Math.round(Math.min(larg, (p.nao || '').length * f1.tamanho * 0.52)), altura: Math.max(5, Math.round(f1.tamanho * 0.09)), cor: destaque, origem: 'left', anima: { escalaX: [{ t: atraso(meio - 0.3), v: 0 }, { t: atraso(meio), v: 1, e: 'saida' }] } });
+                titulo(p.sim || '', { y: y1 + f1.tamanho * 1.2 * f1.linhas + H * 0.05, larg, linhas: 3, max: f2.tamanho, de: atraso(meio) });
+                if (vid && sons.pop) efeitos.push({ t: r2((tp.de || 0) + meio), src: sons.pop, volume: 0.5 });
+                break;
+            }
+            case 'citacao': {
+                const larg = W0 * 0.84;
+                const fit = caber(p.texto || '', { largura: larg, linhas: 4, max: H * 0.085, fonte: F.serifa });
+                const hT = fit.tamanho * 1.18 * fit.linhas;
+                const y = (H - hT) / 2 + H * 0.04;
+                els.push({ tipo: 'texto', texto: '“', fonte: F.serifa, peso: 700, tamanho: Math.round(H * 0.3), cor: destaque, x: M, y: Math.round(y - H * 0.24), anima: { opacidade: [{ t: 0, v: 0 }, { t: 0.3, v: 1 }], escala: [{ t: 0, v: 0.7 }, { t: 0.5, v: 1, e: 'saida' }] } });
+                const ws = String(p.texto || '').split(/\s+/);
+                els.push({ tipo: 'texto', texto: p.texto || '', fonte: F.serifa, peso: 500, italico: true, tamanho: fit.tamanho, cor: tinta, entrelinha: 1.18, x: Math.round(M + W * 0.04), y: Math.round(y), largura: Math.round(larg), revelar: ws.map((_, k) => r2(atraso(0.2 + k * 0.09))) });
+                if (p.autor) linhaFina('— ' + p.autor, { y: y + hT + H * 0.04, x: Math.round(M + W * 0.04), larg, de: 0.9, c: destaque });
+                break;
+            }
+            case 'imagem': {
+                const src = imagens[i] || p.src;
+                if (src) {
+                    els.push({ tipo: 'imagem', src, x: 0, y: 0, largura: '100%', altura: '100%', ajuste: 'cover', anima: { escala: [{ t: 0, v: 1.12 }, { t: dur, v: 1, e: 'suave' }] } });
+                    els.push({ tipo: 'forma', forma: 'retangulo', x: 0, y: 0, largura: '100%', altura: '100%', fundo: { tipo: 'gradiente', cores: ['rgba(0,0,0,0)', 'rgba(0,0,0,0.25)', 'rgba(0,0,0,0.85)'], angulo: 180 } });
+                }
+                const larg = W0 * 0.8;
+                const fit = caber(p.titulo || '', { largura: larg, linhas: 2, max: H * 0.1, fonte: F.titulo });
+                const hT = fit.tamanho * 1.04 * fit.linhas;
+                const yT = H - M - hT - (p.sub ? H * 0.08 : 0);
+                if (p.titulo) titulo(p.titulo, { y: yT, larg, max: fit.tamanho, cor: '#FFFFFF', de: 0.3 });
+                if (p.sub) linhaFina(p.sub, { y: yT + hT + H * 0.02, larg, c: 'rgba(255,255,255,0.8)', de: 0.7 });
+                break;
+            }
+            case 'grafico': {
+                const barras = (p.barras || []).slice(0, 7);
+                const hT = p.titulo ? titulo(p.titulo, { y: M * 1.1, linhas: 2, max: H * 0.08 }) : 0;
+                const topo = M * 1.1 + hT + H * 0.12;
+                const baseY = H - M - H * 0.08;
+                const hMax = baseY - topo;
+                const maior = Math.max(1, ...barras.map((b) => Number(b.valor) || 0));
+                const gap = W0 * 0.03;
+                const wB = (W0 - gap * (barras.length - 1)) / Math.max(1, barras.length);
+                barras.forEach((b, k) => {
+                    const h = Math.max(6, hMax * (Number(b.valor) || 0) / maior);
+                    const x = M + k * (wB + gap);
+                    const q = atraso(0.4 + k * 0.12);
+                    els.push({ tipo: 'forma', forma: 'retangulo', x: Math.round(x), y: Math.round(baseY - h), largura: Math.round(wB), altura: Math.round(h), cor: k === barras.length - 1 ? destaque : alfa(tinta, 0.25), raio: Math.round(wB * 0.08), origem: 'bottom', anima: { escalaY: [{ t: q, v: 0 }, { t: q + 0.6, v: 1, e: 'saida' }] } });
+                    const fv = Math.round(Math.min(H * 0.05, wB * 0.35));
+                    els.push({ tipo: 'texto', texto: String(b.valor), fonte: F.titulo, peso: 800, tamanho: fv, cor: tinta, x: Math.round(x + wB / 2), y: Math.round(baseY - h - fv * 1.4), ancora: 'centro-x', contar: { ate: Number(b.valor) || 0, dur: 0.8 }, anima: { opacidade: [{ t: q, v: 0 }, { t: q + 0.3, v: 1 }] } });
+                    const fr = caber(b.rotulo || '', { largura: wB, linhas: 2, max: H * 0.03, fonte: F.texto });
+                    els.push({ tipo: 'texto', texto: b.rotulo || '', fonte: F.texto, peso: 500, tamanho: fr.tamanho, cor: suave, x: Math.round(x), y: Math.round(baseY + H * 0.02), largura: Math.round(wB), alinhamento: 'center' });
+                });
+                break;
+            }
+            case 'cta': {
+                const larg = W0 * 0.84;
+                const fit = caber(p.titulo || '', { largura: larg, linhas: 3, max: H * 0.12, fonte: F.titulo });
+                const hT = fit.tamanho * 1.04 * fit.linhas;
+                const temLink = Boolean(p.link || p.sub);
+                const y = (H - hT - (temLink ? H * 0.16 : 0)) / 2;
+                titulo(p.titulo || '', { y, larg, max: fit.tamanho, x: (W - larg) / 2, alinhar: 'center' });
+                if (temLink) {
+                    const txt = p.link || p.sub;
+                    const fl = caber(txt, { largura: larg * 0.7, linhas: 1, max: H * 0.045, fonte: F.texto });
+                    const wP = Math.min(larg, txt.length * fl.tamanho * 0.55 + fl.tamanho * 2.4);
+                    const hP = fl.tamanho * 2.2;
+                    const yP = y + hT + H * 0.06;
+                    const q = atraso(0.8);
+                    const entra = { opacidade: [{ t: q, v: 0 }, { t: q + 0.3, v: 1 }], escala: [{ t: q, v: 0.8 }, { t: q + 0.4, v: 1, e: 'elastico' }] };
+                    els.push({ tipo: 'forma', forma: 'retangulo', x: Math.round((W - wP) / 2), y: Math.round(yP), largura: Math.round(wP), altura: Math.round(hP), cor: destaque, raio: Math.round(hP / 2), anima: entra });
+                    els.push({ tipo: 'texto', texto: txt, fonte: F.texto, peso: 700, tamanho: fl.tamanho, cor: cor.sobreDestaque, x: Math.round(W / 2), y: Math.round(yP + hP / 2), ancora: 'centro', anima: entra });
+                    if (vid && sons.pop) efeitos.push({ t: r2((tp.de || 0) + q), src: sons.pop, volume: 0.55 });
+                }
+                logo(Math.round(W / 2 - H * 0.1), Math.round(H - M - H * 0.05), Math.round(H * 0.05));
+                break;
+            }
+            default: break;
+        }
+
+        const cena = { duracao: dur, fundo, elementos: els, transicao: { tipo: trans, duracao: cruz } };
+        if (vid) cena.camera = { zoom: variante ? [{ t: 0, v: 1.04 }, { t: dur, v: 1, e: 'suave' }] : [{ t: 0, v: 1 }, { t: dur, v: 1.04, e: 'suave' }] };
+        cenas.push(cena);
+        if (vid && i > 0 && sons.whoosh) efeitos.push({ t: r2(Math.max(0, (tp.de || 0) - 0.15)), src: sons.whoosh, volume: 0.4 });
+    });
+
+    const audio = {};
+    if (vid && narracao) audio.narracao = narracao;
+    if (vid && trilha) audio.trilha = { src: trilha, volume: 0.12, loop: true };
+    if (vid && efeitos.length) audio.efeitos = efeitos;
+    return {
+        ok: true,
+        plano: { formato: { largura: W, altura: H, fps: 30 }, fundoGeral: cor.fundo, cenas, ...(Object.keys(audio).length ? { audio } : {}) },
+        resumo: { cenas: cenas.length, efeitos: efeitos.length, musica: Boolean(audio.trilha), voz: Boolean(audio.narracao) },
+    };
+}
+
+module.exports = { comporRoteiro, caber, paleta, falaDe, registroDe, iconesDoRoteiro, TIPOS };

package/lib/estudio/edicao.js

@@ -42,7 +42,7 @@ const ICONES = [
     [['inteligencia', 'ia', 'robo', 'maquina', 'automac'], 'robot'],
     [['cerebro', 'pens', 'raciocin', 'aprend', 'mente'], 'brain'],
     [['ideia', 'criativ', 'inova'], 'light-bulb'],
-    [['dinheiro', 'grana', 'reais', 'lucro', 'vend', 'fatur', 'ganh', 'pagar', 'preco'], 'money-bag'],
+    [['dinheiro', 'grana', 'reais', 'lucro', 'vend', 'fatur', 'ganh', 'pagar', 'preco', 'financ', 'custo', 'econom', 'receita'], 'money-bag'],
     [['tempo', 'minuto', 'segundo', 'rapid', 'hora'], 'stopwatch'],
     [['cresc', 'result', 'aument', 'melhor'], 'chart-increasing'],
     [['cair', 'caiu', 'perd', 'queda', 'pior'], 'chart-decreasing'],
@@ -70,9 +70,9 @@ const ICONES = [
     [['padr', 'peca', 'encaix'], 'puzzle-piece'],
     [['decid', 'decis', 'escolh', 'duvida', 'pergunta'], 'thinking-face'],
     [['exemplo', 'procur', 'busca', 'pesquis', 'analis'], 'magnifying-glass-tilted-left'],
-    [['assistente', 'convers', 'chat', 'mensag', 'responde'], 'speech-balloon'],
+    [['assistente', 'convers', 'chat', 'mensag', 'responde', 'atend', 'suporte', 'whatsapp'], 'speech-balloon'],
     [['recomend', 'filme', 'serie', 'netflix', 'video'], 'clapper-board'],
-    [['tecnolog', 'algoritm', 'sistema', 'ferrament'], 'gear'],
+    [['tecnolog', 'algoritm', 'sistema', 'ferrament', 'operac', 'process', 'automat'], 'gear'],
     [['cotidian', 'rotina', 'semana', 'calendario', 'agenda'], 'calendar'],
     [['conhecimento', 'formad', 'diploma', 'sabe'], 'graduation-cap'],
     [['sucesso', 'venc', 'ganhador', 'premio', 'campeao'], 'trophy'],

package/lib/estudio/index.js

@@ -41,6 +41,7 @@ const video = require('./video.js');
 const identidade = require('./identidade.js');
 const slides = require('./slides.js');
 const edicao = require('./edicao.js');
+const composicao = require('./composicao.js');
 
 const PY = path.join(__dirname, '..', '..', 'studio');
 
@@ -172,12 +173,31 @@ async function ferramentaPlano(args) {
 
     if (args.voltarPara) return projeto.voltarPara(args.id, args.voltarPara);
 
-    if (!args.plano && !args.cenas) {
+    if (!args.plano && !args.cenas && !args.roteiro) {
         const atual = projeto.lerPlano(args.id);
         if (!atual) return { ok: false, error: 'este projeto ainda não tem plano — mande um.' };
         return { ok: true, plano: atual, resumo: plano.resumo(atual) };
     }
 
+    /* O ROTEIRO: o modelo diz o que cada parte é e o que ela diz, e o código
+       faz o resto — layout, voz com entonação, ícones, imagens, música e
+       sons (lib/estudio/composicao.js). É o caminho para qualquer modelo
+       entregar motion e slides que prestam. */
+    if (args.roteiro) {
+        const r = await prepararRoteiro(p, args);
+        if (!r.ok) return r;
+        const conferida = plano.conferir(r.plano, { pasta: p.pasta });
+        if (!conferida.ok) {
+            return { ok: false, error: 'o roteiro virou um plano com problemas (defeito do PrimoCode, não seu).', problemas: conferida.problemas.slice(0, 12) };
+        }
+        projeto.salvarPlano(args.id, r.plano, args.motivo || 'montado do roteiro');
+        projeto.salvar(args.id, { duracao: conferida.duracao });
+        return {
+            ok: true, duracao: conferida.duracao, ...r.resumo, resumo: plano.resumo(r.plano),
+            proximo: 'estudio_render com este id. Para ajustar, mande o roteiro de novo (é rápido) — não edite as cenas à mão.',
+        };
+    }
+
     // Um plano inteiro, ou só as cenas (que é o caso comum).
     let novo = args.plano || { formato: args.formato, cenas: args.cenas, audio: args.audio };
 
@@ -500,6 +520,56 @@ async function ferramentaVideo(args, ctx = {}) {
     return { ok: false, error: `não conheço a ação "${acao}".` };
 }
 
+const PROPORCOES = { '16:9': [1920, 1080], '9:16': [1080, 1920], '1:1': [1080, 1080], '4:5': [1080, 1350] };
+
+/** O roteiro vira plano: baixa o que falta, narra, e chama o compositor. */
+async function prepararRoteiro(p, args) {
+    const roteiro = typeof args.roteiro === 'string' ? JSON.parse(args.roteiro) : args.roteiro;
+    if (Array.isArray(roteiro)) return prepararRoteiro(p, { ...args, roteiro: { partes: roteiro } });
+    const partes = roteiro.partes || [];
+    const modo = (args.modo || roteiro.modo || (p.formato === 'slides' || p.formato === 'arte' ? 'slides' : 'video'));
+    const [largura, altura] = PROPORCOES[roteiro.proporcao || args.proporcao] || (modo === 'slides' ? PROPORCOES['16:9'] : PROPORCOES['16:9']);
+
+    const iconesOk = new Set();
+    for (const nome of composicao.iconesDoRoteiro(roteiro)) {
+        try { const r = await assets.icone(nome); if (r && r.ok) iconesOk.add(nome); } catch { /* sem */ }
+    }
+    const imagens = {};
+    for (const [i, parte] of partes.entries()) {
+        if (parte.tipo !== 'imagem' || parte.src || !parte.busca) continue;
+        try {
+            const b = await assets.procurarImagens(parte.busca, { quantas: 4 });
+            for (const item of (b.ok ? b.imagens : [])) {
+                const d = await assets.baixar(item, { pasta: p.pasta, nome: 'cena-' + (i + 1) });
+                if (d.ok) { imagens[i] = d.relativo; break; }
+            }
+        } catch { /* a cena sai sem a foto, com o título */ }
+    }
+
+    let tempos = [], narracao = null, sons = {}, trilha = null;
+    if (modo === 'video') {
+        const lista = partes.map((pt, i) => ({ texto: composicao.falaDe(pt), registro: composicao.registroDe(pt, i, partes.length) }));
+        const arq = path.join(p.pasta, 'midia', `roteiro-${Date.now().toString(36)}.json`);
+        fs.mkdirSync(path.dirname(arq), { recursive: true });
+        fs.writeFileSync(arq, JSON.stringify(lista));
+        const mp3 = path.join(p.pasta, 'midia', `narracao-${Date.now().toString(36)}.mp3`);
+        const v = await rodarPython('narrar.py', ['roteiro', '--arquivo', arq, '--saida', mp3, '--voz', String(args.voz || roteiro.voz || 'thalita')], { timeout: 10 * 60000 });
+        if (!v.ok) return v;
+        tempos = v.partes;
+        narracao = path.relative(p.pasta, mp3).replace(/\\/g, '/');
+        projeto.anotar(p.id, 'narracao', `${v.segundos}s em ${partes.length} partes, voz ${v.voz}`);
+        sons = await edicao.prepararSons(p.pasta, video);
+        try {
+            const b = await assets.procurarSom(roteiro.musica || args.trilha || 'inspiring corporate background', { quantas: 6, duracaoMin: 45 });
+            for (const item of (b.ok ? b.sons : [])) {
+                const d = await assets.baixar(item, { pasta: p.pasta, nome: 'trilha' });
+                if (d.ok) { trilha = d.relativo; break; }
+            }
+        } catch { /* sem música */ }
+    }
+    return composicao.comporRoteiro({ roteiro, modo, largura, altura, tempos, narracao, sons, trilha, imagens, iconesOk });
+}
+
 /* Sem o tempo de cada palavra, cada trecho é repartido pelas palavras dele,
    proporcional ao tamanho de cada uma. */
 function repartirTrechos(trechos) {

package/lib/estudio/plano.js

@@ -165,7 +165,10 @@ function conferirElemento(caminho, el, pasta, problemas, duracao) {
         }
     }
     conferirCor(`${caminho}.cor`, el.cor, problemas);
-    conferirCor(`${caminho}.fundo`, el.fundo, problemas);
+    // O fundo do elemento é cor, ou o mesmo objeto do fundo da cena (um
+    // gradiente sobre a foto, por exemplo).
+    if (el.fundo && typeof el.fundo === 'object') conferirFundo(`${caminho}.fundo`, el.fundo, pasta, problemas);
+    else conferirCor(`${caminho}.fundo`, el.fundo, problemas);
     conferirAnima(`${caminho}.anima`, el.anima, problemas);
 
     // `de` e `ate` recortam o elemento no tempo DA CENA. Um elemento que

package/lib/estudio/remotion.js

@@ -234,7 +234,39 @@ function Elemento({ el, t, dados }) {
   }
 
   switch (el.tipo) {
-    case 'texto':
+    case 'texto': {
+      /* O NÚMERO QUE CONTA: "contar": {ate: 9, dur: 1.2} faz o texto subir
+         de 0 até o valor, com a curva de saída. Casas decimais e o que vem
+         antes/depois do número (R$, %, mil) ficam como estão. */
+      let conteudo = el.texto;
+      if (el.contar) {
+        const alvo = Number(el.contar.ate) || 0;
+        const dur = el.contar.dur || 1.2;
+        const k = CURVAS.saida(Math.min(1, Math.max(0, tLocal / dur)));
+        const casas = el.contar.casas || 0;
+        const v = (alvo * k).toLocaleString('pt-BR', { minimumFractionDigits: casas, maximumFractionDigits: casas });
+        conteudo = (el.contar.antes || '') + v + (el.contar.depois || '');
+      }
+      /* O TEXTO QUE SE REVELA: "revelar": [t0, t1, …] é o instante (no tempo
+         do elemento) em que cada palavra entra — o da narração. A palavra
+         sobe e aparece; as que ainda não foram ditas esperam invisíveis, e o
+         bloco não muda de tamanho quando elas entram. */
+      if (Array.isArray(el.revelar) && typeof el.texto === 'string') {
+        const palavras = el.texto.split(' ');
+        conteudo = palavras.map((w, i) => {
+          const t0 = el.revelar[Math.min(i, el.revelar.length - 1)] ?? 0;
+          const k = Math.min(1, Math.max(0, (tLocal - t0) / 0.28));
+          const e = CURVAS.saida(k);
+          // O espaço fica FORA do span: é ali que a linha pode quebrar.
+          return (
+            <React.Fragment key={i}>
+              <span style={{ display: 'inline-block', opacity: e, transform: 'translateY(' + (1 - e) * 0.35 + 'em)',
+                color: el.destaques && el.destaques.includes(i) ? (el.corDestaque || el.cor) : undefined }}>{w}</span>
+              {i < palavras.length - 1 ? ' ' : null}
+            </React.Fragment>
+          );
+        });
+      }
       return (
         <div style={{
           ...estilo,
@@ -250,8 +282,13 @@ function Elemento({ el, t, dados }) {
           background: el.gradienteTexto || undefined,
           WebkitBackgroundClip: el.gradienteTexto ? 'text' : undefined,
           WebkitTextFillColor: el.gradienteTexto ? 'transparent' : undefined,
-        }}>{el.texto}</div>
+          fontStyle: el.italico ? 'italic' : undefined,
+          textDecoration: el.riscado ? 'line-through' : undefined,
+          textDecorationThickness: el.riscado ? '0.08em' : undefined,
+          wordBreak: 'normal', overflowWrap: 'break-word',
+        }}>{conteudo}</div>
       );
+    }
 
     case 'forma': {
       const forma = el.forma || 'retangulo';
@@ -260,7 +297,7 @@ function Elemento({ el, t, dados }) {
           ...estilo,
           width: medida(el.largura, '200px'),
           height: forma === 'linha' ? medida(el.espessura, '4px') : medida(el.altura, '200px'),
-          background: el.fundo || el.cor || '#fff',
+          ...(el.fundo && typeof el.fundo === 'object' ? fundoCSS(el.fundo) : { background: el.fundo || el.cor || '#fff' }),
           borderRadius: forma === 'circulo' ? '50%' : medida(a.raio ?? el.raio, '0px'),
           border: el.contorno || undefined,
         }} />
@@ -375,10 +412,11 @@ function Elemento({ el, t, dados }) {
   }
 }
 
-export function Cena({ cena, dados }) {
+export function Cena({ cena, dados, tFixo }) {
   const frame = useCurrentFrame();
   const { fps } = useVideoConfig();
-  const t = frame / fps;
+  // A página parada é a cena num instante só: tFixo manda no tempo.
+  const t = tFixo != null ? tFixo : frame / fps;
 
   const cam = animado(cena.camera, t);
   const camTransform = [
@@ -439,6 +477,21 @@ function Transicao({ tipo, progresso, children }) {
   return <AbsoluteFill style={estilo}>{children}</AbsoluteFill>;
 }
 
+/* AS PÁGINAS: um quadro por cena, cada uma congelada no meio dela. Os
+ * slides saem num render só — antes era um "remotion still" por página, e
+ * cada um empacotava o projeto inteiro de novo (onze páginas, onze
+ * empacotamentos: é a demora de 25 minutos medida em 25/09). */
+export const Paginas = () => {
+  const { fps } = useVideoConfig();
+  const frame = useCurrentFrame();
+  const cena = plano.cenas[Math.min(frame, plano.cenas.length - 1)];
+  return (
+    <AbsoluteFill style={{ backgroundColor: plano.fundoGeral || '#000' }}>
+      <Cena cena={cena} dados={{ fps, icones }} tFixo={cena.duracao / 2} />
+    </AbsoluteFill>
+  );
+};
+
 export const Video = () => {
   const { fps } = useVideoConfig();
   const frame = useCurrentFrame();
@@ -495,7 +548,7 @@ function rootJsx(plano) {
     const f = plano.formato || {};
     return `import React from 'react';
 import { Composition } from 'remotion';
-import { Video } from './Video';
+import { Video, Paginas } from './Video';
 import plano from './plano.json';
 import './fontes.css';
 
@@ -506,14 +559,24 @@ const quadros = Math.max(1, Math.round(
 ));
 
 export const RemotionRoot = () => (
-  <Composition
-    id="Video"
-    component={Video}
-    durationInFrames={quadros}
-    fps={fps}
-    width={${Number(f.largura) || 1920}}
-    height={${Number(f.altura) || 1080}}
-  />
+  <>
+    <Composition
+      id="Video"
+      component={Video}
+      durationInFrames={quadros}
+      fps={fps}
+      width={${Number(f.largura) || 1920}}
+      height={${Number(f.altura) || 1080}}
+    />
+    <Composition
+      id="Paginas"
+      component={Paginas}
+      durationInFrames={plano.cenas.length}
+      fps={fps}
+      width={${Number(f.largura) || 1920}}
+      height={${Number(f.altura) || 1080}}
+    />
+  </>
 );
 `;
 }

package/lib/estudio/slides.js

@@ -48,41 +48,45 @@ const { spawn } = require('child_process');
 function renderizarPaginas({ raiz, destino, plano, aoFalar = () => {} }) {
     return new Promise((resolve) => {
         fs.mkdirSync(destino, { recursive: true });
-        const fps = Number((plano.formato || {}).fps) || 30;
-
-        // Onde começa cada cena, em quadros — a mesma conta do Video.jsx.
-        const inicios = [];
-        let cursor = 0;
-        for (const cena of plano.cenas || []) {
-            const dur = Math.max(1, Math.round(cena.duracao * fps));
-            const t = cena.transicao || {};
-            const cruz = (t.tipo || t) === 'corte' ? 0 : Math.round((t.duracao ?? 0.4) * fps);
-            inicios.push({ de: cursor, dur });
-            cursor += dur - cruz;
-        }
+        for (const f of fs.readdirSync(destino)) if (/\.(jpe?g|png)$/i.test(f)) fs.rmSync(path.join(destino, f));
+        const n = (plano.cenas || []).length;
+        const shell = process.platform === 'win32';
+        const cita = (a) => (shell && /\s/.test(a) ? `"${a}"` : a);
+
+        /* Projeto novo não tem o Remotion instalado: o caminho de slides
+           rodava o npx direto e morria em "could not determine executable". */
+        const passos = fs.existsSync(path.join(raiz, 'node_modules')) ? [] : [['npm', ['install', '--no-audit', '--no-fund']]];
+        // Todas as páginas num render só: a composição "Paginas" tem um quadro por cena.
+        /* O Remotion recusa pasta de sequência com ponto no caminho ("cannot
+           have an extension") — e ~/.primocode tem. A sequência sai numa pasta
+           temporária sem ponto e as páginas são movidas depois. */
+        const tmp = fs.mkdtempSync(path.join(require('os').tmpdir(), 'primo-paginas-'));
+        passos.push(['npx', ['remotion', 'render', 'Paginas', tmp, '--sequence',
+            '--image-format=jpeg', '--jpeg-quality=95', '--log=warn']]);
 
-        const paginas = [];
         const correr = (i) => {
-            if (i >= inicios.length) return resolve({ ok: true, paginas });
-            const { de, dur } = inicios[i];
-            const quadro = de + Math.floor(dur / 2);
-            const arquivo = path.join(destino, `pagina-${String(i + 1).padStart(3, '0')}.jpeg`);
-            aoFalar(`página ${i + 1} de ${inicios.length}`);
-
-            const p = spawn('npx', [
-                'remotion', 'still', 'Video', arquivo,
-                '--frame=' + quadro, '--image-format=jpeg', '--quality=95', '--log=warn',
-            ], { cwd: raiz, shell: process.platform === 'win32' });
-
+            if (i >= passos.length) {
+                // Pelo NÚMERO: em ordem alfabética, element-10 vem antes de element-2.
+                const num = (f) => Number((f.match(/(\d+)\.jpe?g$/i) || [])[1] || 0);
+                const saidas = fs.readdirSync(tmp).filter((f) => /\.jpe?g$/i.test(f)).sort((a, b) => num(a) - num(b));
+                const paginas = saidas.map((f, k) => {
+                    const final = path.join(destino, `pagina-${String(k + 1).padStart(3, '0')}.jpeg`);
+                    fs.copyFileSync(path.join(tmp, f), final);
+                    return final;
+                });
+                try { fs.rmSync(tmp, { recursive: true, force: true }); } catch { /* fica no temporário */ }
+                if (paginas.length !== n) return resolve({ ok: false, error: `saíram ${paginas.length} páginas de ${n}.` });
+                return resolve({ ok: true, paginas });
+            }
+            const [cmd, args] = passos[i];
+            aoFalar(cmd === 'npm' ? 'instalando o Remotion nesta pasta (uma vez só)' : `desenhando ${n} páginas`);
+            const p = spawn(cmd, args.map(cita), { cwd: raiz, shell });
             let erro = '';
-            p.stderr.on('data', (d) => { erro += d.toString().slice(0, 1000); });
-            const relogio = setTimeout(() => { try { p.kill(); } catch {} }, 5 * 60000);
+            p.stderr.on('data', (d) => { erro += d.toString().slice(0, 2000); });
+            const relogio = setTimeout(() => { try { p.kill(); } catch {} }, 15 * 60000);
             p.on('close', (code) => {
                 clearTimeout(relogio);
-                if (code !== 0) {
-                    return resolve({ ok: false, error: `a página ${i + 1} falhou: ${erro.slice(-400).trim()}` });
-                }
-                paginas.push(arquivo);
+                if (code !== 0) return resolve({ ok: false, error: `${cmd} saiu com ${code}: ${erro.slice(-400).trim()}` });
                 correr(i + 1);
             });
             p.on('error', (e) => { clearTimeout(relogio); resolve({ ok: false, error: e.message }); });

package/lib/local/cerebro.json

@@ -1,9 +1,9 @@
 {
- "origem": "primocode-server 8.14.0 8581acd",
+ "origem": "primocode-server 8.15.0 52f6257",
  "SYSTEM_NUCLEO": "Você é o PrimoCode, agente de engenharia da ConectaPrimoAI.\n\nCONVERSA OU TRABALHO: cumprimento, agradecimento, pergunta sobre você ou papo\n(\"oi\", \"o que você faz?\") → responda em texto, 1 ou 2 frases, sem tool nenhuma,\ne não invente tarefa que ninguém pediu. Pedido de criar, alterar, ler, rodar ou\nconsertar → EXECUTE, até o fim, sem conversar no meio.\n\nREGRAS ABSOLUTAS (executando):\n1. NUNCA escreva código na resposta. Código vai SEMPRE dentro de uma tool.\n2. NUNCA pergunte ao usuário. Decida e execute.\n3. NUNCA invente ferramenta, serviço, porta ou API: as suas são EXATAMENTE as\n   desta lista. E nunca diga que algo \"não está rodando\" para se esquivar — o\n   que precisa subir, sobe sozinho quando você chama a tool. Prometer o que\n   você não tem, ou culpar um serviço, é o pior erro possível.\n4. Caminhos RELATIVOS (\"index.html\", \"src/game.js\"). Você já está na pasta do\n   projeto: nunca caminho absoluto, nunca \"../\".\n5. Termine SEMPRE com finish(\"frase curta do que foi feito\").\n6. Resposta em texto: no máximo 1 frase, sem markdown.\n7. NUNCA repita uma chamada que já fez. Reformular a mesma busca traz as mesmas\n   fontes; spec e manual são FIXOS — leu uma vez, está lido. Pesquisou e leu a\n   spec? O passo seguinte é CRIAR com o que já tem.\n\nESCOLHENDO A TOOL: arquivo novo → write_file; mudar parte → edit_file (nunca\nreescreva o arquivo inteiro para trocar poucas linhas); várias mudanças no mesmo\narquivo → multi_edit, numa chamada; não sabe onde está → grep (conteúdo) ou glob\n(nome); arquivo grande → read_file com offset/limit; servidor que fica de pé →\nrun_in_new_terminal.\n\nANTES DE EDITAR, LEIA — SEM EXCEÇÃO: edit_file exige o texto LITERAL do arquivo,\ne você não adivinha indentação. read_file (ou grep) PRIMEIRO, edit_file depois.\n\nQUANDO FALHA: leia o erro e conserte. Se edit_file disser \"trecho não\nencontrado\", ele devolve \"trechosParecidos\" com as linhas reais — copie de lá.\nNUNCA chame finish dizendo que fez algo que falhou: \"não consegui alterar X\nporque Y\" é melhor que um \"pronto!\" falso.\n\nPLANO: tarefa de 3+ passos começa com write_todos e vai atualizando o status (só\nUMA \"in_progress\" por vez). Tarefa curta não precisa.\n\nCOMO VOCÊ FALA ENQUANTO TRABALHA: antes de uma tool que muda o rumo (conserto,\nconversão, desvio), UMA frase em primeira pessoa com o quê e o porquê (\"o vídeo\nveio em .avi, vou converter para mp4\"); resolvido, \"feito, continuando\". Passo\nóbvio não precisa. NUNCA cite limite, cota, token, modelo, provedor, tentativa\nou erro interno: quem lê vê o trabalho, não o encanamento. Contornou uma\nfalha? Conte o contorno.\n\nMEMÓRIA: você recebe memory-geral.md (o usuário) e o memory.md do projeto.\nRespeite as preferências e decisões que estão lá, e não recomece do zero um\nprojeto que já tem arquivos — leia antes de escrever. O memory.md do projeto se\ngrava sozinho. Já o memory-geral.md só guarda o que você mandar com\nremember_general: nome, preferência que vale em qualquer projeto, decisão de\nlongo prazo. Sem essa chamada, nada disso sobrevive para a próxima vez.\n\nPROCESSO: ver o que existe (list_dir/glob) → entender (read_file/grep) → fazer\n(write_file/edit_file) → conferir → finish.",
  "SECOES": {
   "pesquisa": "PEDIDO QUE DEPENDE DE FATO DO MUNDO — PESQUISE PRIMEIRO:\nSe o que o usuário pediu envolve algo real (uma empresa, um produto, uma\npessoa, um mercado, um número, um acontecimento), chame pesquisar_referencia\nANTES de criar qualquer coisa, em qualquer esforço. \"Pesquise sobre a empresa X\ne faça slides\" é UM pedido só: pesquisa e depois cria, sem parar para perguntar\ne sem entregar o deck com dado inventado.\n\nUm deck bonito cheio de número inventado é pior que nenhum deck — o usuário\nleva aquilo para uma reunião. Se depois da pesquisa faltar um dado, escreva na\npeça o que você sabe e deixe o buraco explícito (\"faturamento: não divulgado\"),\nnunca um número plausível de sua cabeça.",
-  "estudio": "O ESTÚDIO — VÍDEO, MOTION, SLIDES E ARTE, FEITOS AQUI:\nCada peça é uma PASTA no computador do usuário, e o arquivo final sai pelo\nRemotion (.mp4 no vídeo, .pdf em slides e arte). Nada de link para abrir num\nsite: no fim, o arquivo abre sozinho para o usuário.\n\nFLUXO:\n1. estudio_projeto acao:\"procurar\" quando o pedido falar de algo que já existe;\n   senão acao:\"criar\" (titulo, pedido, formato: video | slides | arte). Use o\n   id que ele devolve em todas as outras.\n2. Empresa ou marca de verdade no pedido → estudio_site (url ou marca) ANTES de\n   escolher cor e fonte. Inventar a cor de uma marca que existe é erro que sai\n   pronto no vídeo.\n3. Peça com narração ou mais de três cenas → planejar_producao ANTES do plano:\n   o diretor devolve a pauta (arco, fala cena a cena, voz, mídia, trilha).\n4. estudio_midia baixa imagem, ícone, som, trilha e lista fontes — tudo vai\n   para a pasta do projeto; o plano nunca aponta para a internet.\n5. estudio_narrar gera a voz e devolve o tempo MEDIDO de cada fala: as cenas\n   duram o que a fala mede, não o que você estima.\n6. estudio_plano escreve as cenas: elementos (texto, forma, imagem, vídeo,\n   ícone, legenda, componente) com quadros-chave em \"anima\", câmera por cena.\n   Para ajustar depois, mande só a cena que muda (cena: N).\n7. estudio_render vira o arquivo e abre para o usuário. Diga o caminho que ele\n   devolve, em uma linha.\n\nGRAVAÇÃO DO USUÁRIO (\"edita meu vídeo\", um .mp4/.mov dele): estudio_projeto\ncriar → estudio_video acao:\"importar\" → estudio_video acao:\"editar\" (faz a\nedição inteira: cortes, legenda animada, ícones, zoom, sons) → estudio_render.\nNão monte as cenas à mão antes de tentar o \"editar\". Depois, ajuste só a cena\nque o usuário pedir (estudio_plano cena:N). NUNCA escreva .mp4/.mp3 com\nwrite_file e nunca monte vídeo com ffmpeg na mão.\n\nNÃO EXISTE LAYOUT PRONTO NEM TEMA: cada propriedade do vídeo é escolha sua, a\ncada vídeo. Varie a composição entre as cenas, a duração e a transição. Título\nque diz algo (\"Receita triplicou em 18 meses\"), não rótulo (\"Resultados\"). A\nnarração não repete o texto da tela: a tela dá o título, a voz dá o argumento.\n\nSE O USUÁRIO CITAR UM APP (Canva, PowerPoint, CapCut, Premiere…), comece com:\n\"Posso abrir o(a) [app], mas para te entregar com mais qualidade vou usar\nminhas ferramentas.\" — avisa, não pergunta. Se ele insistir, desktop_open_app.\n\nDocumento, planilha e PDF não são do Estúdio: faça o arquivo (.docx, .xlsx,\n.pdf) com código, na pasta do projeto.",
+  "estudio": "O ESTÚDIO — VÍDEO, MOTION, SLIDES E ARTE, FEITOS AQUI:\nCada peça é uma PASTA no computador do usuário, e o arquivo final sai pelo\nRemotion (.mp4 no vídeo, .pdf em slides e arte). Nada de link para abrir num\nsite: no fim, o arquivo abre sozinho para o usuário.\n\nFLUXO (vídeo, motion, slides ou arte feitos do zero):\n1. estudio_projeto acao:\"criar\" (titulo, pedido, formato: video | slides | arte).\n2. Empresa ou marca de verdade → estudio_site ANTES, e use as cores, a fonte\n   e a logo que ele devolve em roteiro.marca.\n3. estudio_plano com ROTEIRO: 6 a 12 partes, cada uma com o tipo certo\n   (abertura, numero, lista, passos, contraste, citacao, imagem, grafico,\n   titulo, cta) e a \"fala\" — a frase dita, que não repete a tela. O PrimoCode\n   faz o layout, a voz com entonação, os ícones, a música e os sons. NÃO\n   escreva cenas nem posições à mão.\n4. estudio_render. Para ajustar, mande o roteiro de novo com a mudança.\n\nGRAVAÇÃO DO USUÁRIO (\"edita meu vídeo\", um .mp4/.mov dele): estudio_projeto\ncriar → estudio_video acao:\"importar\" → estudio_video acao:\"editar\" (faz a\nedição inteira: cortes, legenda animada, ícones, zoom, sons) → estudio_render.\nNão monte as cenas à mão antes de tentar o \"editar\". Depois, ajuste só a cena\nque o usuário pedir (estudio_plano cena:N). NUNCA escreva .mp4/.mp3 com\nwrite_file e nunca monte vídeo com ffmpeg na mão.\n\nO ROTEIRO BOM: a primeira parte prende (abertura ou contraste), o miolo prova\n(numero, grafico, lista, imagem) e a última pede ação (cta). Varie os tipos —\ntrês \"titulo\" seguidos parecem slide parado. Título que diz algo (\"Receita\ntriplicou em 18 meses\"), não rótulo (\"Resultados\"). Número de verdade ou\nnenhum. A fala não repete a tela: a tela dá o título, a voz dá o argumento.\n\nSE O USUÁRIO CITAR UM APP (Canva, PowerPoint, CapCut, Premiere…), comece com:\n\"Posso abrir o(a) [app], mas para te entregar com mais qualidade vou usar\nminhas ferramentas.\" — avisa, não pergunta. Se ele insistir, desktop_open_app.\n\nDocumento, planilha e PDF não são do Estúdio: faça o arquivo (.docx, .xlsx,\n.pdf) com código, na pasta do projeto.",
   "navegador": "CONTROLANDO NAVEGADOR E DESKTOP:\nVocê pode AGIR numa página real e no computador inteiro do usuário — qualquer\nprograma, e a própria área de trabalho:\n- Navegador: browser_open abre a página num Chrome controlado; depois\n  browser_click (por texto/seletor), browser_type, browser_key, browser_read\n  (conferir), browser_screenshot. Use para testar o que você criou, preencher\n  formulários, navegar em sites.\n- No DESKTOP você enxerga por NOMES, não por pixels (você não vê imagens):\n  desktop_windows lista as janelas abertas; desktop_focus traz uma para a\n  frente; desktop_elements lê os botões, campos, menus e ícones dela (nome,\n  tipo e posição); desktop_click_element clica pelo NOME.\n- FLUXO PADRÃO no desktop: desktop_open_app (ou desktop_focus se já está\n  aberto) → desktop_elements → desktop_click_element → desktop_type /\n  desktop_key. Depois de agir, confira: desktop_elements de novo (o estado\n  mudou?) ou desktop_windows.\n- desktop_open_app abre qualquer programa pelo nome (\"chrome\", \"bloco de\n  notas\", \"calculadora\"). A janela leva 1-2s: confirme com desktop_windows.\n- Área de trabalho (Windows): desktop_elements com window \"Program Manager\"\n  lista os ícones; ícone abre com desktop_click_element {double: true}.\n- Atalhos: desktop_key aceita combinações — \"ctrl+c\", \"alt+tab\",\n  \"ctrl+shift+t\", \"Enter\", \"win\" (menu Iniciar).\n- desktop_click/desktop_double_click por coordenada e desktop_screenshot são o\n  último recurso, quando a janela não expõe elementos nomeados.\nPrefira sempre NOMES (texto/seletor no navegador, elemento no desktop) a\ncoordenadas fixas. Confira o resultado antes de dizer que terminou.\n\nPESQUISANDO ANTES DE ESCREVER (qualidade):\nVocê não sabe tudo de cor, e chutar assinatura de API é o erro que mais custa\ncaro. pesquisar_referencia abre documentação oficial, exemplos e respostas\nsobre o assunto e devolve o TEXTO delas para você ler. Use quando:\n- for usar biblioteca/framework/API que você não domina com certeza;\n- a mesma tool falhar duas vezes seguidas (pare de tentar, vá ler);\n- o usuário pedir qualidade, ou a tarefa for grande.\nLeia, entenda o padrão e ESCREVA o seu código. Não cole trecho literal de\nterceiros no projeto do usuário; e confira se a API que a fonte cita existe na\nversão que o projeto usa (veja o package.json).",
   "delegar": "DELEGANDO A ESPECIALISTAS:\nSe a tarefa tem partes independentes, use spawn_agent para cada uma e diga\nQUEM faz em `especialista`: frontend (tela, HTML, CSS) · backend (API, dados\nno servidor, autenticação) · testes (escrever e rodar testes, reproduzir bug)\n· design (identidade visual, paleta, tipografia, ícones) · dados (CSV,\nplanilha, análise) · revisor (lê e aponta defeitos, não conserta) · ambiente\n(instalar dependências, configurar, fazer rodar). Cada um chega com o\nbriefing da profissão. Trabalho grande de código: um por camada (frontend +\nbackend + testes) e um revisor no fim, com o que ele apontou voltando para\nquem escreveu. O subagente trabalha sozinho e devolve só o resultado; escreva\no prompt dele completo — ele NÃO vê esta conversa. Tarefa curta você mesmo\nresolve.",
   "computador": "CONTROLANDO NAVEGADOR E DESKTOP:\nVocê pode AGIR numa página real e no computador inteiro do usuário — qualquer\nprograma, e a própria área de trabalho:\n- Navegador: browser_open abre a página num Chrome controlado; depois\n  browser_click (por texto/seletor), browser_type, browser_key, browser_read\n  (conferir), browser_screenshot. Use para testar o que você criou, preencher\n  formulários, navegar em sites.\n- No DESKTOP você enxerga por NOMES, não por pixels (você não vê imagens):\n  desktop_windows lista as janelas abertas; desktop_focus traz uma para a\n  frente; desktop_elements lê os botões, campos, menus e ícones dela (nome,\n  tipo e posição); desktop_click_element clica pelo NOME.\n- FLUXO PADRÃO no desktop: desktop_open_app (ou desktop_focus se já está\n  aberto) → desktop_elements → desktop_click_element → desktop_type /\n  desktop_key. Depois de agir, confira: desktop_elements de novo (o estado\n  mudou?) ou desktop_windows.\n- desktop_open_app abre qualquer programa pelo nome (\"chrome\", \"bloco de\n  notas\", \"calculadora\"). A janela leva 1-2s: confirme com desktop_windows.\n- Área de trabalho (Windows): desktop_elements com window \"Program Manager\"\n  lista os ícones; ícone abre com desktop_click_element {double: true}.\n- Atalhos: desktop_key aceita combinações — \"ctrl+c\", \"alt+tab\",\n  \"ctrl+shift+t\", \"Enter\", \"win\" (menu Iniciar).\n- desktop_click/desktop_double_click por coordenada e desktop_screenshot são o\n  último recurso, quando a janela não expõe elementos nomeados.\nPrefira sempre NOMES (texto/seletor no navegador, elemento no desktop) a\ncoordenadas fixas. Confira o resultado antes de dizer que terminou.\n\nPESQUISANDO ANTES DE ESCREVER (qualidade):\nVocê não sabe tudo de cor, e chutar assinatura de API é o erro que mais custa\ncaro. pesquisar_referencia abre documentação oficial, exemplos e respostas\nsobre o assunto e devolve o TEXTO delas para você ler. Use quando:\n- for usar biblioteca/framework/API que você não domina com certeza;\n- a mesma tool falhar duas vezes seguidas (pare de tentar, vá ler);\n- o usuário pedir qualidade, ou a tarefa for grande.\nLeia, entenda o padrão e ESCREVA o seu código. Não cole trecho literal de\nterceiros no projeto do usuário; e confira se a API que a fonte cita existe na\nversão que o projeto usa (veja o package.json).",
@@ -543,13 +543,25 @@
    "type": "function",
    "function": {
     "name": "estudio_plano",
-    "description": "Escreve ou ajusta as cenas. Sem plano nem cenas, LE o plano. Elemento: {tipo: texto|forma|imagem|video|icone|legenda|componente, x, y, cor, tamanho, anima: {prop: [{t,v,e}]}}. Cena: camera {zoom,x,y,rotacao}. Nao ha layout pronto nem tema.",
+    "description": "PREFIRA \"roteiro\": voce diz o que cada parte E e o que ela diz, e o PrimoCode faz o layout, a voz com entonacao, os icones, a musica e os sons — video ou slides. roteiro: {marca:{cores:{fundo,destaque,tinta},fontes:{titulo,texto},logo}, proporcao, partes:[{tipo, fala, ...}]}. Tipos: abertura{titulo,sub} titulo{titulo,sub} numero{valor,rotulo,sub} lista{titulo,itens[]} passos{titulo,itens[]} contraste{nao,sim} citacao{texto,autor} imagem{busca,titulo,sub} grafico{titulo,barras[{rotulo,valor}]} cta{titulo,link}. So use plano/cenas para ajuste fino. Sem nada, LE o plano. Elemento: {tipo: texto|forma|imagem|video|icone|legenda|componente, x, y, cor, tamanho, anima: {prop: [{t,v,e}]}}. Cena: camera {zoom,x,y,rotacao}. Nao ha layout pronto nem tema.",
     "parameters": {
      "type": "object",
      "properties": {
       "id": {
        "type": "string"
       },
+      "roteiro": {
+       "type": "object",
+       "description": "{marca, proporcao, partes:[{tipo, fala, ...campos do tipo}]}"
+      },
+      "voz": {
+       "type": "string",
+       "enum": [
+        "thalita",
+        "antonio",
+        "francisca"
+       ]
+      },
       "plano": {
        "type": "object",
        "description": "{formato:{largura,altura,fps}, cenas, audio}"
@@ -1715,13 +1727,25 @@
    "type": "function",
    "function": {
     "name": "estudio_plano",
-    "description": "Escreve ou ajusta as cenas. Sem plano nem cenas, LE o plano. Elemento: {tipo: texto|forma|imagem|video|icone|legenda|componente, x, y, cor, tamanho, anima: {prop: [{t,v,e}]}}. Cena: camera {zoom,x,y,rotacao}. Nao ha layout pronto nem tema.",
+    "description": "PREFIRA \"roteiro\": voce diz o que cada parte E e o que ela diz, e o PrimoCode faz o layout, a voz com entonacao, os icones, a musica e os sons — video ou slides. roteiro: {marca:{cores:{fundo,destaque,tinta},fontes:{titulo,texto},logo}, proporcao, partes:[{tipo, fala, ...}]}. Tipos: abertura{titulo,sub} titulo{titulo,sub} numero{valor,rotulo,sub} lista{titulo,itens[]} passos{titulo,itens[]} contraste{nao,sim} citacao{texto,autor} imagem{busca,titulo,sub} grafico{titulo,barras[{rotulo,valor}]} cta{titulo,link}. So use plano/cenas para ajuste fino. Sem nada, LE o plano. Elemento: {tipo: texto|forma|imagem|video|icone|legenda|componente, x, y, cor, tamanho, anima: {prop: [{t,v,e}]}}. Cena: camera {zoom,x,y,rotacao}. Nao ha layout pronto nem tema.",
     "parameters": {
      "type": "object",
      "properties": {
       "id": {
        "type": "string"
       },
+      "roteiro": {
+       "type": "object",
+       "description": "{marca, proporcao, partes:[{tipo, fala, ...campos do tipo}]}"
+      },
+      "voz": {
+       "type": "string",
+       "enum": [
+        "thalita",
+        "antonio",
+        "francisca"
+       ]
+      },
       "plano": {
        "type": "object",
        "description": "{formato:{largura,altura,fps}, cenas, audio}"

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "primocode",
-  "version": "9.8.0-beta.12",
+  "version": "9.8.0-beta.13",
   "description": "PrimoCode — agente de engenharia com IA e cursor próprio. Requer conta Conecta Primo AI (Premium ou Super). Cria arquivos, roda comandos, controla navegador e desktop: abre apps, clica em botões e ícones pelo nome, digita e usa atalhos.",
   "main": "bin/primocode.js",
   "bin": {
@@ -8,7 +8,7 @@
   },
   "scripts": {
     "start": "node bin/primocode.js",
-    "test": "node test/tools.test.js && node test/ui.test.js && node test/entrada.test.js && node test/transparencia.test.js && node test/permissao.test.js && node test/compatibilidade.test.js && node test/skills.test.js && node test/skills-de-fora.test.js && node test/skills-novas.test.js && node test/comandos.test.js && node test/estudio.test.js && node test/voz.test.js && node test/voz-conversa.test.js && node test/modo.test.js && node test/pasta.test.js && node test/projeto.test.js && node test/nome-projeto.test.js && node test/api-propria.test.js && node test/claude-engine.test.js && node test/codex.test.js && node test/conferir.test.js && node test/catalogo.test.js && node test/desktop.test.js && node test/seta.test.js && node test/effort.test.js && node test/regressao.test.js && node test/memoria-conversa.test.js && node test/repeticao.test.js && node test/autonomia.test.js && node test/desfazer.test.js && node test/desfazer-git.test.js && node test/referencia.test.js && node test/parar.test.js && node test/continuar.test.js && node test/pipeline.test.js && node test/app.test.js && node test/app-janela.test.js && node test/aplicativo.test.js && node test/conta.test.mjs && node test/nuvem.test.js && node test/prazo.test.js && node test/primeira-vez.test.js && node test/janela.test.js && node test/fala.test.js && node test/especialistas.test.js && node test/empurrao.test.js && node test/terminal-novo.test.js && node test/markdown.test.js && node test/coerencia.test.js && node test/contexto.test.js && node test/perigo.test.js && node test/rapidez.test.js && node test/mascotes.test.js && node test/comandos-extra.test.js && node test/offline.test.js && node test/edicao.test.js"
+    "test": "node test/tools.test.js && node test/ui.test.js && node test/entrada.test.js && node test/transparencia.test.js && node test/permissao.test.js && node test/compatibilidade.test.js && node test/skills.test.js && node test/skills-de-fora.test.js && node test/skills-novas.test.js && node test/comandos.test.js && node test/estudio.test.js && node test/voz.test.js && node test/voz-conversa.test.js && node test/modo.test.js && node test/pasta.test.js && node test/projeto.test.js && node test/nome-projeto.test.js && node test/api-propria.test.js && node test/claude-engine.test.js && node test/codex.test.js && node test/conferir.test.js && node test/catalogo.test.js && node test/desktop.test.js && node test/seta.test.js && node test/effort.test.js && node test/regressao.test.js && node test/memoria-conversa.test.js && node test/repeticao.test.js && node test/autonomia.test.js && node test/desfazer.test.js && node test/desfazer-git.test.js && node test/referencia.test.js && node test/parar.test.js && node test/continuar.test.js && node test/pipeline.test.js && node test/app.test.js && node test/app-janela.test.js && node test/aplicativo.test.js && node test/conta.test.mjs && node test/nuvem.test.js && node test/prazo.test.js && node test/primeira-vez.test.js && node test/janela.test.js && node test/fala.test.js && node test/especialistas.test.js && node test/empurrao.test.js && node test/terminal-novo.test.js && node test/markdown.test.js && node test/coerencia.test.js && node test/contexto.test.js && node test/perigo.test.js && node test/rapidez.test.js && node test/mascotes.test.js && node test/comandos-extra.test.js && node test/offline.test.js && node test/edicao.test.js && node test/composicao.test.js"
   },
   "engines": {
     "node": ">=18.17.0"

package/studio/narrar.py

@@ -330,7 +330,8 @@ def comando_roteiro(args):
         roteiro_txt = Path(tmp) / "lista.txt"
         roteiro_txt.write_text("".join(f"file '{w}'\n" for w in lista), encoding="utf-8")
         r = subprocess.run(["ffmpeg", "-y", "-loglevel", "error", "-f", "concat", "-safe", "0",
-                            "-i", str(roteiro_txt), "-c:a", "libmp3lame", "-q:a", "3", str(args.saida)],
+                            "-i", str(roteiro_txt), "-af", "loudnorm=I=-14:TP=-1.5:LRA=9",
+                            "-c:a", "libmp3lame", "-q:a", "3", str(args.saida)],
                            capture_output=True, timeout=180)
         if r.returncode != 0:
             return {"ok": False, "error": (r.stderr or b"").decode("utf-8", "ignore")[-300:]}