primocode 9.8.0-beta.9 → 9.8.0

package/lib/estudio/index.js

@@ -40,6 +40,11 @@ const assets = require('./assets.js');
 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 acervoSite = require('./acervo-site.js');
+const impacto = require('./impacto.js');
+const cinema = require('./cinema.js');
 
 const PY = path.join(__dirname, '..', '..', 'studio');
 
@@ -79,6 +84,37 @@ function rodarPython(script, args, { timeout = 20 * 60000 } = {}) {
     });
 }
 
+/* O RECORTE DA PESSOA precisa do MediaPipe, e o MediaPipe só existe até o
+   Python 3.12 — no Python 3.14 do Homebrew ele nem instala (medido em
+   25/09: o recorte nunca tinha rodado nesta máquina). Com o `uv`, o script
+   roda num Python 3.12 isolado, baixado uma vez; sem ele, tenta o Python da
+   máquina, como antes. */
+function acharUv() {
+    const { execFileSync } = require('child_process');
+    for (const c of ['uv', path.join(os.homedir(), '.local', 'bin', 'uv'), '/opt/homebrew/bin/uv', '/usr/local/bin/uv']) {
+        try { execFileSync(c, ['--version'], { stdio: 'ignore', timeout: 5000 }); return c; } catch { /* próximo */ }
+    }
+    return null;
+}
+function rodarPessoa(args, { timeout = 40 * 60000 } = {}) {
+    const uv = acharUv();
+    if (!uv) return rodarPython('pessoa.py', args, { timeout });
+    return new Promise((resolve) => {
+        const p = spawn(uv, ['run', '--quiet', '--python', '3.12', '--with', 'mediapipe<0.10.22',
+            '--with', 'opencv-python', '--with', 'numpy', 'python', path.join(PY, 'pessoa.py'), ...args]);
+        let saida = '', erro = '';
+        p.stdout.on('data', (d) => { saida += d.toString(); });
+        p.stderr.on('data', (d) => { erro += d.toString(); });
+        const relogio = setTimeout(() => { try { p.kill(); } catch {} }, timeout);
+        p.on('close', () => {
+            clearTimeout(relogio);
+            try { resolve(JSON.parse(saida.trim().split('\n').pop())); }
+            catch { resolve({ ok: false, error: (erro || saida).slice(-400).trim() || 'o recorte não respondeu' }); }
+        });
+        p.on('error', (e) => { clearTimeout(relogio); resolve({ ok: false, error: e.message }); });
+    });
+}
+
 // ── estudio_projeto ──────────────────────────────────────────────────────
 
 /**
@@ -165,18 +201,125 @@ function listarArquivos(pasta) {
 
 // ── estudio_plano ────────────────────────────────────────────────────────
 
+/* O projeto de AGORA, quando o modelo esquece o id: o criado há menos de
+   30 minutos. Medido com o modelo grátis em 25/09: ele chamou estudio_plano
+   sem id logo depois de criar o projeto, e a tarefa morreu ali. */
+function projetoRecente() {
+    const agora = Date.now();
+    const lista = projeto.listar({ limite: 8 })
+        .filter((x) => x.criado && agora - new Date(x.criado).getTime() < 30 * 60000)
+        .sort((a, b) => new Date(b.criado) - new Date(a.criado));
+    return lista[0] || null;
+}
+
+/** O roteiro é utilizável como veio? (objeto ou JSON, com partes de tipo conhecido) */
+function roteiroValido(r) {
+    let x = r;
+    if (typeof x === 'string') { try { x = JSON.parse(x); } catch { return null; } }
+    const partes = Array.isArray(x) ? x : x && x.partes;
+    if (!Array.isArray(partes) || partes.length < 2) return null;
+    const CINEMA = ['frase', 'montagem', 'numeros', 'escada', 'dia', 'depoimento', 'climax', 'final'];
+    if (!partes.every((pt) => pt && (composicao.TIPOS.includes(pt.tipo) || CINEMA.includes(pt.tipo)))) return null;
+    const obj = Array.isArray(x) ? { partes } : x;
+    return partes.some((pt) => CINEMA.includes(pt.tipo)) && !obj.estilo ? { ...obj, estilo: 'cinema' } : obj;
+}
+
+// O último site lido, para o projeto que nasceu DEPOIS da leitura.
+let ultimoSite = null;
+
+async function garantirAcervo(p) {
+    if (p.acervo && (p.acervo.fotos || []).length) return p;
+    if (!ultimoSite || Date.now() - ultimoSite.quando > 60 * 60000) return p;
+    try {
+        const a = await acervoSite.colher({ url: ultimoSite.url, pedido: p.pedido || '', pasta: p.pasta, htmlInicial: ultimoSite.html,
+            buscar: identidade.buscar, baixar: assets.baixar });
+        projeto.salvar(p.id, { acervo: { fotos: a.fotos, videos: a.videos, fatos: a.fatos, site: ultimoSite.url }, ...(p.marca ? {} : { marca: ultimoSite.marca }) });
+        projeto.anotar(p.id, 'midia', `acervo do site: ${a.fotos.length} fotos, ${a.videos.length} vídeos`);
+    } catch { /* segue sem acervo */ }
+    return projeto.ler(p.id);
+}
+
+/* O ROTEIRISTA do servidor: quando o modelo não manda um roteiro que preste
+   (nenhum, ou texto corrido), o pedido e os fatos da marca viram o roteiro
+   numa chamada só, com uma tarefa só. */
+async function roteiroDoServidor(p, args) {
+    const cfg = require('../config').loadConfig();
+    const api = require('../api');
+    const pedido = [p.pedido, args.pedido].filter(Boolean).join(' — ');
+    const seg = Number(args.segundos) || Number((pedido.match(/(\d{2,3})\s*(s\b|seg)/i) || [])[1]) || 30;
+    const acervo = p.acervo || {};
+    const r = await api.request(cfg.server, '/api/roteiro', {
+        pedido, segundos: seg,
+        fatos: (acervo.fatos || []).map((f) => f.texto).join('\n\n').slice(0, 5000),
+        fotos: (acervo.fotos || []).length ? `${acervo.fotos.length} fotos reais` : '',
+        site: acervo.site ? new URL(acervo.site).hostname.replace(/^www\./, '') : '',
+        rascunho: typeof args.roteiro === 'string' ? args.roteiro : '',
+        estilo: args.estilo || (/an[uú]nci|reels?|divulg|promo|lan[çc]a|vend|campanha|convite|inscri/i.test(pedido) ? 'impacto' : undefined),
+    }, cfg.token);
+    if (!r || !r.ok) return { ok: false, error: (r && r.erro) || 'o roteirista não respondeu.' };
+    return { ok: true, roteiro: { ...r.roteiro, marca: (args.roteiro && args.roteiro.marca) || p.marca || undefined } };
+}
+
 async function ferramentaPlano(args) {
-    const p = projeto.ler(args.id);
+    let p = projeto.ler(args.id);
+    // Só quando o id FALTOU: id errado continua sendo erro, para não escrever no projeto errado.
+    if (!p && (args.id == null || String(args.id).trim() === '') && (args.roteiro || args.plano || args.cenas)) {
+        const recente = projetoRecente();
+        if (recente) { args = { ...args, id: recente.id }; p = recente; }
+    }
     if (!p) return semProjeto(args.id);
 
+    /* Roteiro que não serve (texto corrido, JSON quebrado, tipo inventado) ou
+       nenhum, num projeto ainda sem plano: o roteirista escreve. */
+    const valido = args.roteiro ? roteiroValido(args.roteiro) : null;
+    if (!args.plano && !args.cenas && !args.voltarPara && !valido && (args.roteiro || !projeto.lerPlano(args.id))) {
+        p = await garantirAcervo(p);
+        const escrito = await roteiroDoServidor(p, args);
+        if (!escrito.ok) return escrito;
+        args = { ...args, roteiro: escrito.roteiro };
+        projeto.anotar(p.id, 'plano', `roteiro escrito pelo roteirista: ${escrito.roteiro.partes.length} partes`);
+    } else if (valido) {
+        args = { ...args, roteiro: valido };
+        p = await garantirAcervo(p);
+    }
+
     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;
+        let conferida = plano.conferir(r.plano, { pasta: p.pasta });
+        /* A rede de segurança: o elemento que não passa sai, e o vídeo segue.
+           Um defeito num ícone não pode custar o vídeo inteiro. */
+        if (!conferida.ok) {
+            projeto.anotar(p.id, 'defeito', `plano do roteiro reprovou: ${conferida.problemas.slice(0, 4).map((x) => x.onde + ' ' + x.oque).join(' | ')}`);
+            const ruins = new Set(conferida.problemas.map((x) => (String(x.onde).match(/^cenas\[(\d+)\]\.elementos\[(\d+)\]/) || []).slice(1, 3).join(':')).filter((k) => k.includes(':')));
+            r.plano.cenas.forEach((c, i) => { c.elementos = c.elementos.filter((_, j) => !ruins.has(`${i}:${j}`)); });
+            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');
+        // O roteiro fica guardado: ajustar uma frase é mandar o roteiro de novo, não reescrever tudo.
+        try { fs.writeFileSync(path.join(p.pasta, 'roteiro.json'), JSON.stringify(args.roteiro, null, 2)); } catch { /* segue */ }
+        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 };
 
@@ -399,9 +542,110 @@ async function ferramentaVideo(args, ctx = {}) {
         return transcrever(p, alvo, ctx);
     }
 
+    /* A EDIÇÃO INTEIRA, em código (lib/estudio/edicao.js): corta o silêncio,
+       transcreve palavra por palavra e monta o plano — legenda animada,
+       ícones na hora da palavra, zoom de corte, pop e whoosh. É o caminho
+       para qualquer modelo entregar vídeo de videomaker: ele só chama isto e
+       renderiza. "Até uma batata faz vídeos assim." (25/09/2026) */
+    if (acao === 'editar' || acao === 'edicao' || acao === 'auto') {
+        let fonte = alvo;
+        let cortes = 0;
+        if (args.cortarSilencio !== false) {
+            const saida = path.join(p.pasta, 'midia', `cortado-${Date.now().toString(36)}.mp4`);
+            const c = await video.cortarSilencio(alvo, saida, args);
+            if (c.ok && !c.semCorte) { fonte = saida; cortes = c.cortes || 0; }
+        }
+        /* A VOZ NO VOLUME CERTO. A gravação de celular sai baixa (medido em
+           25/09: -37,6 dB de média no vídeo pronto, e "está sem som"). O
+           loudnorm leva a fala a -15 LUFS, o volume de vídeo de internet; o
+           vídeo em si não é recodificado. */
+        const normal = path.join(p.pasta, 'midia', `voz-normal-${Date.now().toString(36)}.mp4`);
+        const ln = await video.rodar(video.ffmpeg(), ['-y', '-i', fonte, '-c:v', 'copy',
+            '-af', 'loudnorm=I=-15:TP=-1.5:LRA=11', '-c:a', 'aac', '-b:a', '192k', normal], { timeout: 10 * 60000 });
+        if (ln.ok) fonte = normal;
+
+        const m = await video.medir(fonte);
+        if (!m.ok) return m;
+
+        const tr = await transcrever(p, fonte, ctx);
+        if (!tr.ok) return tr;
+        let palavras = tr.palavras || [];
+        // Servidor sem o tempo por palavra: reparte cada trecho pelas palavras
+        // dele. Sai menos preciso, mas a legenda continua animada.
+        if (!palavras.length) palavras = repartirTrechos(tr.trechos || []);
+
+        const candidatos = [...new Set(palavras.map((w) => edicao.iconeDe(w.texto)).filter(Boolean))];
+        const iconesOk = new Set();
+        for (const nome of candidatos) {
+            try { const r = await assets.icone(nome); if (r && (r.ok !== false)) iconesOk.add(nome); } catch { /* fica sem */ }
+        }
+        const sons = await edicao.prepararSons(p.pasta, video);
+
+        // As imagens de apoio: uma por termo, a primeira que baixar.
+        const imagens = {};
+        if ((args.estilo || 'viral') !== 'sem-apoio') {
+            const orientacao = m.largura >= m.altura ? 'landscape' : 'portrait';
+            for (const termo of edicao.termosDeApoio(palavras).slice(0, 8)) {
+                imagens[termo] = await baixarApoio(p, termo, { orientacao, video: true });
+                if (!imagens[termo]) delete imagens[termo];
+            }
+        }
+
+        // A música de fundo: uma trilha longa, de licença aberta.
+        let trilha = null;
+        if (args.musica !== false) {
+            try {
+                const b = await assets.procurarMusica(args.trilha || 'upbeat corporate', { 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 { /* segue sem música */ }
+        }
+
+        const base = {
+            src: path.relative(p.pasta, fonte).replace(/\\/g, '/'),
+            duracao: m.segundos, palavras, largura: m.largura, altura: m.altura,
+            estilo: args.estilo || 'viral', sons, iconesOk, imagens, trilha,
+        };
+        let montado = edicao.montarEdicao(base);
+        if (!montado.ok) return montado;
+
+        /* A segunda passada: nas frases escolhidas, a pessoa recortada na
+           frente da palavra gigante. Só os trechos que entram são recortados
+           (2 s cada), não o vídeo inteiro — recortar 52 s levaria minutos. */
+        if ((args.estilo || 'viral') === 'viral' && args.recorte !== false) {
+            const recortes = {};
+            for (const [i, info] of montado.infos.entries()) {
+                if (!edicao.temRecorte(i) || !info.forte || info.forte.peso < 9 || Object.keys(recortes).length >= 3) continue;
+                const de = Math.max(0, info.forte.de - 0.15);
+                const ate = Math.min(info.dur, de + 2.2);
+                if (ate - de < 1) continue;
+                const seg = path.join(p.pasta, 'midia', `seg-${i + 1}-${Date.now().toString(36)}.mp4`);
+                const corte = await video.rodar(video.ffmpeg(), ['-y', '-ss', String(info.ini + de), '-t', String(ate - de), '-i', fonte,
+                    '-vf', `scale=${Math.min(1280, m.largura)}:-2`, '-an', '-c:v', 'libx264', '-preset', 'veryfast', seg], { timeout: 120000 });
+                if (!corte.ok) continue;
+                const saida = path.join(p.pasta, 'midia', `pessoa-${i + 1}-${Date.now().toString(36)}.webm`);
+                const r = await rodarPessoa(['recortar', '--entrada', seg, '--saida', saida], { timeout: 10 * 60000 });
+                try { fs.unlinkSync(seg); } catch { /* fica */ }
+                if (!r.ok) break;   // sem MediaPipe, nenhum recorte vai dar: não tenta os outros
+                recortes[i] = { src: path.relative(p.pasta, saida).replace(/\\/g, '/'), de: Math.round(de * 100) / 100, ate: Math.round(ate * 100) / 100 };
+            }
+            if (Object.keys(recortes).length) montado = edicao.montarEdicao({ ...base, recortes });
+        }
+        const salvo = await ferramentaPlano({ id: args.id, plano: montado.plano, motivo: `edição automática (${args.estilo || 'viral'})` });
+        if (!salvo.ok) return salvo;
+        projeto.anotar(p.id, 'edicao', `${montado.resumo.cenas} cenas, ${montado.resumo.icones} ícones, ${cortes} cortes de silêncio`);
+        return {
+            ok: true, ...montado.resumo, cortesDeSilencio: cortes, duracao: salvo.duracao,
+            proximo: 'estudio_render com este id. Antes, se quiser, ajuste uma cena com estudio_plano cena:N '
+                + '(ex.: trocar um ícone, pôr uma imagem de apoio atrás).',
+        };
+    }
+
     if (acao === 'recortar-pessoa' || acao === 'pessoa') {
         const saida = path.join(p.pasta, 'midia', `pessoa-${Date.now().toString(36)}.webm`);
-        const r = await rodarPython('pessoa.py', [
+        const r = await rodarPessoa([
             'recortar', '--entrada', alvo, '--saida', saida,
             ...(args.suavizar != null ? ['--suavizar', String(args.suavizar)] : []),
             ...(args.encolher != null ? ['--encolher', String(args.encolher)] : []),
@@ -418,6 +662,520 @@ async function ferramentaVideo(args, ctx = {}) {
     return { ok: false, error: `não conheço a ação "${acao}".` };
 }
 
+/* A mídia de apoio de um termo: vídeo do Pexels quando pedido e houver,
+   senão a primeira foto que baixar. Devolve {src, tipo} ou null. */
+async function baixarApoio(p, termo, { orientacao = null, video: querVideo = false } = {}) {
+    if (querVideo) {
+        try {
+            const b = await assets.procurarVideos(termo, { quantas: 4, orientacao });
+            for (const item of (b.ok ? b.videos : []).filter((v) => !v.duracao || v.duracao >= 3)) {
+                const d = await assets.baixar(item, { pasta: p.pasta, nome: 'apoio-' + termo });
+                if (d.ok) return { src: d.relativo, tipo: 'video' };
+            }
+        } catch { /* cai para a foto */ }
+    }
+    try {
+        const b = await assets.procurarImagens(termo, { quantas: 4, orientacao });
+        for (const item of (b.ok ? b.imagens : [])) {
+            const d = await assets.baixar(item, { pasta: p.pasta, nome: 'apoio-' + termo });
+            if (d.ok) return { src: d.relativo, tipo: 'imagem' };
+        }
+    } catch { /* sem apoio */ }
+    return null;
+}
+
+/* ── A VOZ DO GEMINI ─────────────────────────────────────────────────────
+ * O roteiro inteiro numa chamada só (o plano grátis tem poucos pedidos por
+ * minuto), e as partes achadas depois na transcrição do próprio áudio: a
+ * primeira palavra de cada parte, procurada em ordem. Sem achar, o tempo é
+ * repartido pelo tamanho do texto de cada parte. */
+const VOZ_GEMINI = { thalita: 'Kore', francisca: 'Aoede', antonio: 'Charon', feminina: 'Kore', masculina: 'Charon' };
+const tokens = (t) => String(t || '').normalize('NFD').replace(/[̀-ͯ]/g, '').toLowerCase().split(/[^a-z0-9]+/).filter(Boolean);
+
+function alinharPartes(lista, palavras, total) {
+    const ws = palavras.map((w) => ({ ...w, k: tokens(w.texto)[0] || '' }));
+    const chars = lista.map((x) => x.texto.length);
+    const soma = chars.reduce((a, b) => a + b, 0) || 1;
+    const inicios = [0];
+    let cursor = 0, acum = 0;
+    for (let i = 1; i < lista.length; i++) {
+        acum += chars[i - 1];
+        const esperado = Math.round(ws.length * acum / soma);
+        /* As DUAS primeiras palavras da parte, seguidas: achar só pela primeira
+           palavra longa deixava o "E" de "E sair com algo" no fim da fala
+           anterior, e ele soava duas vezes (medido em 25/09, aos 38 s). */
+        const tk = tokens(lista[i].texto);
+        let achado = -1;
+        for (let j = Math.max(cursor + 1, esperado - 14); j < Math.min(ws.length, esperado + 14); j++) {
+            if (ws[j].k === tk[0] && (!tk[1] || (ws[j + 1] && ws[j + 1].k === tk[1]))) { achado = j; break; }
+        }
+        if (achado < 0) {
+            const alvo = tk.find((w) => w.length >= 3) || tk[0];
+            for (let j = Math.max(cursor + 1, esperado - 12); j < Math.min(ws.length, esperado + 12); j++) {
+                if (ws[j].k === alvo) { achado = j; break; }
+            }
+            // A palavra curta que vem antes da achada ("e", "a", "o") é desta parte, não da anterior.
+            while (achado > cursor + 1 && ws[achado - 1].k.length <= 2 && tk.slice(0, 3).includes(ws[achado - 1].k)) achado--;
+        }
+        const idx = achado > cursor ? achado : Math.max(cursor + 1, Math.min(ws.length - 1, esperado));
+        inicios.push(idx);
+        cursor = idx;
+    }
+    return lista.map((_, i) => {
+        const a = ws[inicios[i]], b = ws[(inicios[i + 1] || ws.length) - 1];
+        // As palavras da parte vão junto: o estilo impacto corta no tempo delas.
+        const palavras = ws.slice(inicios[i], inicios[i + 1] || ws.length).map(({ de, ate, texto }) => ({ de, ate, texto }));
+        return { de: i === 0 ? 0 : (a ? a.de : 0), ate: b ? b.ate : total, palavras };
+    });
+}
+
+async function narrarComGemini(lista, mp3, { voz, direcao } = {}) {
+    try {
+        const cfg = require('../config').loadConfig();
+        const api = require('../api');
+        /* A cota grátis da voz é por MINUTO e pequena: "quota" é esperar e
+           tentar de novo, não desistir para a voz de reserva (medido em 25/09:
+           a mesma chamada passava meio minuto depois). */
+        let r = null;
+        for (let tentativa = 0; tentativa < 4; tentativa++) {
+            try {
+                r = await api.request(cfg.server, '/api/voz', {
+                    texto: lista.map((x) => x.texto).join('\n\n'),
+                    voz: VOZ_GEMINI[String(voz || '').toLowerCase()] || voz || 'Charon',
+                    ...(direcao ? { direcao } : {}),
+                }, cfg.token);
+            } catch (e) { r = { ok: false, erro: e.message }; }
+            if (r && r.ok) break;
+            if (!/quota|rate|429|exhaust/i.test(String(r && r.erro))) break;
+            await new Promise((ok) => setTimeout(ok, 30000));
+        }
+        if (!r || !r.ok) return { ok: false, error: (r && r.erro) || 'sem voz no servidor' };
+        const pcm = mp3.replace(/\.mp3$/, '.pcm');
+        fs.writeFileSync(pcm, Buffer.from(r.audio, 'base64'));
+        const taxa = (String(r.formato).match(/rate=(\d+)/) || [])[1] || '24000';
+        const c = await video.rodar(video.ffmpeg(), ['-y', '-f', 's16le', '-ar', taxa, '-ac', '1', '-i', pcm,
+            '-af', 'loudnorm=I=-14:TP=-1.5:LRA=9', '-c:a', 'libmp3lame', '-q:a', '3', mp3], { timeout: 120000 });
+        try { fs.unlinkSync(pcm); } catch { /* fica */ }
+        if (!c.ok) return { ok: false, error: 'não consegui converter a voz' };
+        const med = await video.medir(mp3);
+        /* A voz CORTADA: o Gemini às vezes devolve metade do roteiro, sem erro
+           (medido em 25/09: 27,5 s de áudio para um texto de ~55 s). Fala
+           normal passa de 11 caracteres por segundo; menos que isso é corte. */
+        const chars = lista.reduce((n, x) => n + x.texto.length, 0);
+        if (med.segundos < chars / 22) return { ok: false, error: `a voz veio cortada (${med.segundos.toFixed(1)} s para ${chars} caracteres)` };
+        const tr = await api.requestTranscricao(cfg.server, { token: cfg.token, audio: fs.readFileSync(mp3).toString('base64'), nome: 'voz.mp3', idioma: 'pt' });
+        const palavras = (tr && tr.palavras) || [];
+        if (!palavras.length) return { ok: false, error: 'sem a transcrição da voz para achar as partes' };
+        return { ok: true, voz: `gemini ${r.voz}`, segundos: med.segundos, partes: alinharPartes(lista, palavras, med.segundos) };
+    } catch (e) {
+        return { ok: false, error: e.message };
+    }
+}
+
+/* Onde estão os rostos em cada foto (studio/rostos.py, pelo uv). Guardado no
+   projeto: a mesma foto não é analisada duas vezes. */
+async function acharRostos(p, srcs) {
+    const guardado = (p.acervo && p.acervo.rostos) || {};
+    const falta = srcs.filter((s0) => !(s0 in guardado));
+    if (falta.length) {
+        const uv = acharUv();
+        const r = await new Promise((resolve) => {
+            const args = ['run', '--quiet', '--python', '3.12', '--with', 'mediapipe<0.10.22', '--with', 'opencv-python', '--with', 'numpy', 'python', path.join(PY, 'rostos.py'), ...falta.map((x) => path.join(p.pasta, x))];
+            const pr = uv ? spawn(uv, args) : spawn(python() || 'python3', [path.join(PY, 'rostos.py'), ...falta.map((x) => path.join(p.pasta, x))]);
+            let out = '';
+            pr.stdout.on('data', (d) => { out += d; });
+            pr.on('close', () => { try { resolve(JSON.parse(out.trim().split('\n').pop())); } catch { resolve({ ok: false }); } });
+            pr.on('error', () => resolve({ ok: false }));
+        });
+        if (r && r.ok) {
+            for (const [cheio, info] of Object.entries(r.fotos || {})) guardado[path.relative(p.pasta, cheio).replace(/\\/g, '/')] = info;
+            for (const x of falta) if (!(x in guardado)) guardado[x] = null;
+            projeto.salvar(p.id, { acervo: { ...(projeto.ler(p.id).acervo || {}), rostos: guardado } });
+        }
+    }
+    return guardado;
+}
+
+/* O DEPOIMENTO cortado na PALAVRA, não no trecho: começa na primeira palavra
+   da frase e termina logo depois da última, com fade, a voz normalizada e um
+   respiro no fim. "Fica sempre um 'é', um 'e' das pessoas… a música muito
+   alta e não dá pra ouvir as pessoas" (25/09). */
+async function prepararDepoimento(p, c) {
+    const origem = path.join(p.pasta, c.src);
+    if (!fs.existsSync(origem) || c.pronto) return {};
+    let de = c.de, ate = c.ate;
+    try {
+        const cfg = require('../config').loadConfig();
+        const amostra = path.join(p.pasta, 'midia', `depo-amostra-${Date.now().toString(36)}.mp3`);
+        await video.rodar(video.ffmpeg(), ['-y', '-ss', String(Math.max(0, c.de - 1.5)), '-t', String(c.ate - c.de + 3), '-i', origem, '-ac', '1', '-ar', '16000', '-b:a', '32k', amostra], { timeout: 60000 });
+        const tr = await require('../api').requestTranscricao(cfg.server, { token: cfg.token, audio: fs.readFileSync(amostra).toString('base64'), nome: 'd.mp3', idioma: 'pt' });
+        try { fs.unlinkSync(amostra); } catch { /* fica */ }
+        const base0 = Math.max(0, c.de - 1.5);
+        const ws = ((tr && tr.palavras) || []).map((w) => ({ ...w, de: w.de + base0, ate: w.ate + base0 }));
+        /* Só a FRASE de efeito: começa na primeira palavra dela e termina na
+           última. "Fala a frase que tem que falar e continua antes de trocar"
+           (25/09): o resto da conversa não tem nada a ver com o vídeo. */
+        const alvo = tokens(c.frase || '');
+        const k0 = (w) => tokens(w.texto)[0] || '';
+        const iniW = ws.find((w) => w.de >= c.de - 1.2 && alvo.length && k0(w) === alvo[0])
+            || ws.find((w) => w.de >= c.de - 0.6 && alvo.includes(k0(w)));
+        const ultimo = alvo[alvo.length - 1];
+        const fimW = [...ws].reverse().find((w) => w.ate <= c.ate + 1.5 && (!iniW || w.de > iniW.de) && k0(w) === ultimo);
+        if (iniW) de = Math.max(0, iniW.de - 0.08);
+        if (fimW) ate = fimW.ate;
+        else { const fimWs = ws.filter((w) => w.ate <= c.ate + 0.3); if (fimWs.length) ate = fimWs[fimWs.length - 1].ate; }
+        // A frase na tela é o que a pessoa FALA no trecho — palavra por palavra.
+        const ditas = ws.filter((w) => w.de >= de - 0.05 && w.ate <= ate + 0.05).map((w) => w.texto).join(' ').trim();
+        /* Se a frase do roteiro bate com o que foi dito (a transcrição erra
+           detalhe: "eu conseguir" no lugar de "eu consegui"), fica a do roteiro. */
+        const tA = tokens(c.frase || ''), tD = tokens(ditas);
+        const bate = tA.length && tA.filter((w) => tD.includes(w)).length / tA.length >= 0.7;
+        if (!bate && ditas.split(/\s+/).length >= 3) c.fraseDita = ditas.replace(/^./, (x) => x.toUpperCase()).replace(/[,;]$/, '.');
+    } catch { /* fica o trecho pedido */ }
+    const dur = ate - de + 0.45;   // um respiro curto depois da última palavra
+    const saida = path.join(p.pasta, 'midia', `depo-${path.basename(c.src, path.extname(c.src))}-${Math.round(de)}.mp4`);
+    const r = await video.rodar(video.ffmpeg(), ['-y', '-ss', String(de), '-t', String(dur), '-i', origem,
+        '-af', `loudnorm=I=-14:TP=-1.5:LRA=9,afade=t=in:d=0.1,afade=t=out:st=${Math.max(0, dur - 0.4).toFixed(2)}:d=0.4`,
+        '-c:v', 'libx264', '-preset', 'veryfast', '-crf', '18', '-c:a', 'aac', '-b:a', '192k', saida], { timeout: 5 * 60000 });
+    if (!r.ok) return {};
+    return { src: path.relative(p.pasta, saida).replace(/\\/g, '/'), de: 0, ate: Math.round((dur - 0.3) * 100) / 100, pronto: true,
+        origem: { src: c.src, de: c.de, ate: c.ate, frase: c.frase }, ...(c.fraseDita ? { frase: c.fraseDita } : {}) };
+}
+
+/* A narração com cache (a mesma fala, na mesma direção, não é gerada duas vezes). */
+async function narrarComCache(lista, mp3, { voz, direcao } = {}) {
+    const chave = require('crypto').createHash('sha1').update(JSON.stringify([lista.map((x) => x.texto), voz || '', direcao || ''])).digest('hex').slice(0, 16);
+    const dir = path.join(os.homedir(), '.primocode', 'studio', 'cache-voz');
+    const cm = path.join(dir, chave + '.mp3'), cj = path.join(dir, chave + '.json');
+    if (fs.existsSync(cm) && fs.existsSync(cj)) { fs.copyFileSync(cm, mp3); return { ok: true, ...JSON.parse(fs.readFileSync(cj, 'utf8')) }; }
+    const v = await narrarComGemini(lista, mp3, { voz, direcao });
+    if (v.ok) { try { fs.mkdirSync(dir, { recursive: true }); fs.copyFileSync(mp3, cm); fs.writeFileSync(cj, JSON.stringify({ voz: v.voz, segundos: v.segundos, partes: v.partes })); } catch { /* sem cache */ } }
+    return v;
+}
+
+/* A MÚSICA TEM LETRA? O acervo não diz se a faixa é instrumental, então ela
+   é ouvida: 25 s do meio vão para a transcrição, e mais de 6 palavras é voz
+   cantada. Sem servidor para ouvir, a faixa passa (melhor música que nenhuma). */
+async function temLetra(arquivo) {
+    try {
+        const m = await video.medir(arquivo);
+        const ini = Math.max(0, (m.segundos || 60) * 0.35);
+        const amostra = arquivo.replace(/\.[a-z0-9]+$/i, '') + '.amostra.mp3';
+        const c = await video.rodar(video.ffmpeg(), ['-y', '-ss', String(ini), '-t', '25', '-i', arquivo, '-ac', '1', '-ar', '16000', '-b:a', '32k', amostra], { timeout: 60000 });
+        if (!c.ok) return false;
+        const cfg = require('../config').loadConfig();
+        const r = await require('../api').requestTranscricao(cfg.server, { token: cfg.token, audio: fs.readFileSync(amostra).toString('base64'), nome: 'musica.mp3', idioma: 'en' });
+        try { fs.unlinkSync(amostra); } catch { /* fica */ }
+        const palavras = (r && r.palavras ? r.palavras.length : String((r && r.texto) || '').split(/\s+/).filter(Boolean).length);
+        return palavras > 6;
+    } catch { return false; }
+}
+
+/* OS SONS DE VERDADE: gravação real de acervo aberto (teclado, whoosh
+   cinematográfico, impacto grave, som de sala), e o sintetizado só quando a
+   busca falha. "Esses efeitos sonoros estão genéricos e sem impacto."
+   (25/09/2026) */
+async function sonsReais(p, video) {
+    const sint = await edicao.prepararSons(p.pasta, video);
+    const quer = {
+        teclado: ['keyboard typing', 'typing keyboard'],
+        whoosh: ['cinematic whoosh', 'swoosh transition'],
+        impacto: ['cinematic boom impact', 'deep cinematic impact', 'trailer hit'],
+        sala: ['crowd murmur indoor', 'office ambience', 'people talking background'],
+    };
+    const sons = { ...sint };
+    for (const [nome, termos] of Object.entries(quer)) {
+        for (const termo of termos) {
+            try {
+                const b = await assets.procurarSom(termo, { quantas: 5 });
+                const item = (b.ok ? b.sons : []).find((x) => x.url);
+                if (!item) continue;
+                const d = await assets.baixar(item, { pasta: p.pasta, nome: 'sfx-real-' + nome });
+                if (d.ok) { sons[nome] = d.relativo; break; }
+            } catch { /* o próximo termo */ }
+        }
+    }
+    return sons;
+}
+
+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 } });
+    /* O que o modelo manda e o disco não tem vira problema de render: um
+       "src" que é endereço da internet vira busca, e um arquivo que não
+       existe na pasta sai. A logo da marca vale só se estiver lá. */
+    const existe = (rel) => rel && !/^https?:/i.test(rel) && fs.existsSync(path.resolve(p.pasta, rel));
+    for (const pt of roteiro.partes || []) {
+        if (pt.src && !existe(pt.src)) { if (!pt.busca && /^https?:/i.test(pt.src)) pt.busca = pt.titulo || ''; delete pt.src; }
+    }
+    if (roteiro.marca) {
+        roteiro.marca = { ...(p.marca || {}), ...roteiro.marca };
+        if (roteiro.marca.logo && !existe(roteiro.marca.logo)) roteiro.marca.logo = (p.marca && existe(p.marca.logo)) ? p.marca.logo : undefined;
+    } else if (p.marca) roteiro.marca = p.marca;
+    const partes = roteiro.partes || [];
+    /* O ESTILO: "impacto" (anúncio, corte a cada batida) ou "limpo" (uma cena
+       por parte). Pedido de anúncio, reels, divulgação ou venda já vem em
+       impacto — é o que se espera de uma peça dessas em 2026. */
+    const estilo = args.estilo || roteiro.estilo
+        || (/an[uú]nci|reels?|divulg|promo|lan[çc]a|vend|campanha|convite|inscri/i.test(`${p.pedido || ''} ${args.pedido || ''}`) ? 'impacto' : 'limpo');
+    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 */ }
+    }
+    /* O ACERVO DA MARCA (guardado pelo estudio_site): as fotos reais entram
+       nas partes de imagem e de FUNDO nas cenas de texto; os vídeos, nas
+       partes de imagem do vídeo. A foto escolhida é a que mais combina, pela
+       descrição, com o que a parte diz. Sem acervo, vale a busca (Pexels). */
+    const acervo = (p.acervo && (p.acervo.fotos || []).length) ? p.acervo : { fotos: [], videos: [] };
+    const usadas = new Set();
+    const palavrasDe = (t) => new Set(String(t || '').normalize('NFD').replace(/[\u0300-\u036f]/g, '').toLowerCase().split(/[^a-z0-9]+/).filter((w) => w.length >= 4));
+    const melhorFoto = (texto) => {
+        const quer = palavrasDe(texto);
+        let melhor = null, pontos = -1;
+        for (const f of acervo.fotos) {
+            if (usadas.has(f.src)) continue;
+            const n = [...palavrasDe(f.alt)].filter((w) => quer.has(w)).length;
+            if (n > pontos) { melhor = f; pontos = n; }
+        }
+        if (melhor) usadas.add(melhor.src);
+        return melhor ? { src: melhor.src, tipo: 'imagem' } : null;
+    };
+    const videosMarca = [...(acervo.videos || [])];
+    const imagens = {}, fundos = {};
+    for (const [i, parte] of partes.entries()) {
+        if (parte.tipo !== 'imagem' || parte.src) continue;
+        const texto = `${parte.titulo || ''} ${parte.sub || ''} ${parte.fala || ''} ${parte.busca || ''}`;
+        if (modo === 'video' && videosMarca.length && i % 2 === 1) { imagens[i] = { src: videosMarca.shift().src, tipo: 'video' }; continue; }
+        const m = melhorFoto(texto) || (parte.busca ? await baixarApoio(p, parte.busca, { orientacao: largura >= altura ? 'landscape' : 'portrait', video: modo === 'video' }) : null);
+        if (m) imagens[i] = m;
+    }
+    if (acervo.fotos.length) {
+        const comFundo = ['abertura', 'titulo', 'contraste', 'citacao', 'cta', 'passos'];
+        let alterna = 0;
+        for (const [i, parte] of partes.entries()) {
+            if (!comFundo.includes(parte.tipo)) continue;
+            if (i !== 0 && alterna++ % 2 === 1) continue;   // uma sim, uma não: o respiro também é ritmo
+            const m = melhorFoto(`${parte.titulo || ''} ${parte.sim || ''} ${parte.fala || ''}`);
+            if (m) fundos[i] = m;
+        }
+    }
+
+    let tempos = [], narracao = null, sons = {}, trilha = null;
+    if (modo === 'video' && estilo === 'cinema') {
+        // Só as partes com voz vão para a narração; o depoimento tem a voz do aluno.
+        // Só as partes com voz: o depoimento tem a voz do aluno, e a parte muda não tem voz.
+        // A parte com voz forte é narrada à parte: se entrasse aqui também, seria falada duas vezes (e muda uma delas).
+        const lista = partes.filter((pt) => pt.tipo !== 'depoimento' && cinema.falaDe(pt) !== '' && !pt.falaForte).map((pt) => ({ texto: cinema.falaDe(pt), registro: 'normal' }));
+        const mp3 = path.join(p.pasta, 'midia', `narracao-${Date.now().toString(36)}.mp3`);
+        /* O CACHE DA VOZ: a mesma fala, na mesma voz, não é gerada duas vezes.
+           Refazer o roteiro em outro formato, ou mexer numa cena, não gasta a
+           cota do Gemini — que acaba no meio do dia (medido em 25/09). */
+        const chaveVoz = require('crypto').createHash('sha1').update(JSON.stringify([lista.map((x) => x.texto), args.voz || roteiro.voz || '', 'cinema-v1'])).digest('hex').slice(0, 16);
+        const cacheDir = path.join(os.homedir(), '.primocode', 'studio', 'cache-voz');
+        const cacheMp3 = path.join(cacheDir, chaveVoz + '.mp3'), cacheJson = path.join(cacheDir, chaveVoz + '.json');
+        let v = null;
+        // motorVoz "edge": a voz do Edge direto, sem esperar a cota do Gemini ("a narração pode manter a do Edge", 25/09).
+        const soEdge = String(roteiro.motorVoz || args.motorVoz || '').toLowerCase() === 'edge';
+        if (soEdge) {
+            v = { ok: false, error: 'edge pedido' };
+        } else if (fs.existsSync(cacheMp3) && fs.existsSync(cacheJson)) {
+            fs.copyFileSync(cacheMp3, mp3);
+            v = { ok: true, ...JSON.parse(fs.readFileSync(cacheJson, 'utf8')), doCache: true };
+            // Cache sem as palavras (vindo de um plano antigo): transcreve de novo e realinha — sem gastar voz.
+            if (!(v.partes || []).some((pt) => (pt.palavras || []).length)) {
+                try {
+                    const cfg = require('../config').loadConfig();
+                    const tr = await require('../api').requestTranscricao(cfg.server, { token: cfg.token, audio: fs.readFileSync(mp3).toString('base64'), nome: 'voz.mp3', idioma: 'pt' });
+                    if (tr && (tr.palavras || []).length) {
+                        v.partes = alinharPartes(lista, tr.palavras, v.segundos);
+                        fs.writeFileSync(cacheJson, JSON.stringify({ voz: v.voz, segundos: v.segundos, partes: v.partes }));
+                    }
+                } catch { /* fica o alinhamento guardado */ }
+            }
+        } else {
+            v = await narrarComGemini(lista, mp3, { voz: args.voz || roteiro.voz,
+                direcao: 'Leia em português do Brasil como narrador de trailer de marca premium: voz grave, confiante e humana, '
+                    + 'ritmo firme, pausas curtas entre as frases, sem arrastar.' });
+            if (v.ok) {
+                try { fs.mkdirSync(cacheDir, { recursive: true }); fs.copyFileSync(mp3, cacheMp3); fs.writeFileSync(cacheJson, JSON.stringify({ voz: v.voz, segundos: v.segundos, partes: v.partes })); } catch { /* sem cache */ }
+            }
+        }
+        if (!v.ok) {
+            const arq = path.join(p.pasta, 'midia', `roteiro-${Date.now().toString(36)}.json`);
+            // Ritmo NORMAL: o "citação" (-10%, respiro longo) esticou o vídeo para 125 s.
+            fs.writeFileSync(arq, JSON.stringify(lista.map((x) => ({ ...x, registro: 'normal' }))));
+            v = await rodarPython('narrar.py', ['roteiro', '--arquivo', arq, '--saida', mp3, '--voz', String(args.voz || roteiro.voz || 'antonio')], { timeout: 10 * 60000 });
+        }
+        if (!v.ok) return v;
+        /* A DURAÇÃO que o roteiro pede ("60–75 s"): se a voz passa do que cabe,
+           ela acelera de leve — até 25%, sem mudar o tom (atempo) — e os tempos
+           de cada parte acompanham. Medido em 25/09: 98 s de voz num vídeo de 70. */
+        const alvo = Number(roteiro.duracao || args.segundos) || 0;
+        let ritmoVoz = 1;
+        if (alvo) {
+            const depo = partes.filter((pt) => pt.tipo === 'depoimento').reduce((n, pt) => n + (pt.clipes || []).reduce((m, c) => m + (c.ate - c.de + 0.3), 0), 0);
+            // A voz forte (narrada à parte) e as partes mudas também ocupam o tempo.
+            const forteEst = partes.filter((pt) => pt.falaForte).reduce((n, pt) => n + cinema.falaDe({ ...pt, fala: undefined }).length / 13 + 1.9, 0);
+            const mudas = partes.filter((pt) => pt.tipo !== 'depoimento' && cinema.falaDe(pt) === '').length * 4;
+            const cabe = Math.max(15, alvo - depo - forteEst - mudas - 0.45 * lista.length);
+            if (v.segundos > cabe * 1.05) {
+                const k = Math.min(1.25, v.segundos / cabe);
+                ritmoVoz = k;
+                const rapido = mp3.replace(/\.mp3$/, '-r.mp3');
+                const c = await video.rodar(video.ffmpeg(), ['-y', '-i', mp3, '-filter:a', `atempo=${k.toFixed(3)}`, rapido], { timeout: 120000 });
+                if (c.ok) {
+                    fs.renameSync(rapido, mp3);
+                    const div = (x) => Math.round((x / k) * 1000) / 1000;
+                    v.partes = v.partes.map((pt) => ({ de: div(pt.de), ate: div(pt.ate), palavras: (pt.palavras || []).map((w) => ({ ...w, de: div(w.de), ate: div(w.ate) })) }));
+                    v.segundos = div(v.segundos);
+                }
+            }
+        }
+        projeto.anotar(p.id, 'narracao', `${v.segundos}s em ${lista.length} partes, voz ${v.voz}`);
+        const sonsC = await sonsReais(p, video);
+        let trilhaC = null;
+        // Vários termos e durações: vídeo sem música foi o que saiu na primeira vez (25/09).
+        // E só instrumental: "essa música daria pra deixar só o instrumental?" — a faixa é OUVIDA.
+        for (const [termo, min] of [[roteiro.musica, 60], ['instrumental cinematic inspiring', 70], ['instrumental piano cinematic', 60], ['instrumental epic cinematic', 60], ['instrumental ambient inspiring', 45], ['instrumental', 45]]) {
+            if (!termo || trilhaC) continue;
+            try {
+                const b = await assets.procurarMusica(termo, { quantas: 6, duracaoMin: min });
+                for (const item of (b.ok ? b.sons : [])) {
+                    const d = await assets.baixar(item, { pasta: p.pasta, nome: 'trilha' });
+                    if (!d.ok) continue;
+                    if (await temLetra(path.join(p.pasta, d.relativo))) { projeto.anotar(p.id, 'midia', `trilha com voz descartada: ${item.titulo}`); continue; }
+                    trilhaC = d.relativo; break;
+                }
+            } catch { /* o próximo termo */ }
+        }
+        /* A MÚSICA mais baixa na origem: a faixa vem masterizada alta e comprimida,
+           e mesmo a 30% ela cobria a voz e o depoimento ("a música tá muito
+           alta, não dá pra ouvir as pessoas", 25/09). Ela vai a -28 LUFS antes
+           da mistura; os volumes do plano partem daí. */
+        if (trilhaC) {
+            const norm = path.join(p.pasta, 'midia', 'trilha-baixa-' + path.basename(trilhaC).replace(/\.[a-z0-9]+$/i, '.mp3'));
+            const c = await video.rodar(video.ffmpeg(), ['-y', '-i', path.join(p.pasta, trilhaC), '-af', 'loudnorm=I=-28:TP=-6:LRA=11', '-ar', '44100', norm], { timeout: 5 * 60000 });
+            if (c.ok) trilhaC = path.relative(p.pasta, norm).replace(/\\/g, '/');
+        }
+        /* AS FOTOS, separadas e enquadradas. "Uma sala, 20 cadeiras" com foto de
+           dashboard "não tem nada a ver" (25/09): foto de gente e print de tela
+           são coisas diferentes, e a miniatura de depoimento fica de fora. E
+           onde estão os rostos, para o recorte vertical não cortar ninguém. */
+        const TELA = /dashboard|pauta|kpi|tend[eê]ncias|landing|review|tela|screen|painel|relat[oó]rio/i;
+        const MINI = /poster|face \d+|\bthumb/i;
+        const fotosC = acervo.fotos.filter((f) => !MINI.test(f.alt || ''))
+            .map((f) => ({ src: f.src, tipo: 'imagem', cat: TELA.test(f.alt || '') ? 'tela' : 'pessoas', alt: f.alt }));
+        const rostos = await acharRostos(p, fotosC.map((f) => f.src));
+        for (const f of fotosC) if (rostos[f.src]) f.rosto = rostos[f.src];
+        // Os depoimentos: cortados na palavra, com a voz no volume certo e fade.
+        for (const pt of partes) {
+            if (pt.tipo !== 'depoimento') continue;
+            for (const c of pt.clipes || []) Object.assign(c, await prepararDepoimento(p, c));
+        }
+        // A voz FORTE: a parte com "falaForte" é narrada à parte, com a direção dela.
+        const fortes = {};
+        let iNarr = 0;
+        for (const [i, pt] of partes.entries()) {
+            if (pt.tipo === 'depoimento' || cinema.falaDe(pt) === '') continue;
+            if (pt.falaForte) {
+                const arqF = path.join(p.pasta, 'midia', `voz-forte-${i + 1}-${Date.now().toString(36)}.mp3`);
+                // falaForte: true → a voz forte lê o texto da tela.
+                const textoForte = pt.falaForte === true ? cinema.falaDe({ ...pt, fala: undefined }) : pt.falaForte;
+                const soEdgeF = String(roteiro.motorVoz || args.motorVoz || '').toLowerCase() === 'edge';
+                const vf = soEdgeF ? await (async () => {
+                    // No Edge, a ênfase é o registro "contraste": a mesma voz, um pouco mais firme.
+                    const arqJ = arqF.replace(/\.mp3$/, '.json');
+                    fs.writeFileSync(arqJ, JSON.stringify([{ texto: textoForte, registro: 'contraste' }]));
+                    return rodarPython('narrar.py', ['roteiro', '--arquivo', arqJ, '--saida', arqF, '--voz', String(args.voz || roteiro.voz || 'antonio')], { timeout: 5 * 60000 });
+                })() : await narrarComCache([{ texto: textoForte }], arqF, { voz: args.voz || roteiro.voz,
+                    // A MESMA voz do narrador, só com um pouco mais de ênfase: "não é mudar a voz, é só um pouco a entonação" (25/09).
+                    direcao: pt.entonacao || 'Leia em português do Brasil com a mesma voz e o mesmo ritmo de um narrador de trailer de marca: '
+                        + 'confiante e natural, só um pouco mais de ênfase nas palavras principais. Sem dramatizar.' });
+                // A voz forte no mesmo ritmo da narração (se ela foi acelerada, esta também).
+                if (vf.ok && ritmoVoz > 1.01) {
+                    const rap = arqF.replace(/\.mp3$/, '-r.mp3');
+                    const c = await video.rodar(video.ffmpeg(), ['-y', '-i', arqF, '-filter:a', `atempo=${ritmoVoz.toFixed(3)}`, rap], { timeout: 120000 });
+                    if (c.ok) {
+                        fs.renameSync(rap, arqF);
+                        vf.segundos = vf.segundos / ritmoVoz;
+                        if (vf.partes && vf.partes[0]) vf.partes[0].palavras = (vf.partes[0].palavras || []).map((w) => ({ ...w, de: w.de / ritmoVoz, ate: w.ate / ritmoVoz }));
+                    }
+                }
+                if (vf.ok) fortes[i] = { src: path.relative(p.pasta, arqF).replace(/\\/g, '/'), segundos: vf.segundos, palavras: (vf.partes[0] || {}).palavras || [] };
+            }
+            iNarr++;
+        }
+        const r = cinema.montarCinema({ roteiro, largura, altura, tempos: v.partes, narracao: path.relative(p.pasta, mp3).replace(/\\/g, '/'),
+            sons: sonsC, trilha: trilhaC, fotos: fotosC, fortes });
+        if (r.ok) projeto.anotar(p.id, 'plano', `estilo cinema: ${r.resumo.cenas} cenas, ${r.resumo.segundos}s`);
+        return r;
+    }
+    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`);
+        // A voz de gente primeiro (Gemini, pelo servidor); o Edge é a reserva.
+        let v = await narrarComGemini(lista, mp3, { voz: args.voz || roteiro.voz,
+            direcao: estilo === 'impacto' ? 'Leia em português do Brasil como locutor de comercial agressivo e vendedor: energia alta, ritmo rápido, '
+                + 'voz encorpada, ênfase forte nas palavras de impacto, pausas curtas e secas entre as frases, sorrindo na voz.' : undefined });
+        if (!v.ok) 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.procurarMusica(roteiro.musica || args.trilha || (estilo === 'impacto' ? 'epic energetic' : 'inspiring corporate'), { 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 */ }
+    }
+    if (estilo === 'impacto' && modo === 'video') {
+        // Os emojis das palavras FALADAS também (a batida mostra a fala).
+        const faladas = tempos.flatMap((t) => (t.palavras || []).map((w) => w.texto));
+        for (const nome of new Set(faladas.map((w) => edicao.iconeDe(w)).filter(Boolean))) {
+            if (iconesOk.has(nome)) continue;
+            try { const r = await assets.icone(nome); if (r && r.ok) iconesOk.add(nome); } catch { /* sem */ }
+        }
+        const fotos = [
+            ...acervo.fotos.map((f) => ({ src: f.src, tipo: 'imagem' })),
+            ...(acervo.videos || []).map((v) => ({ src: v.src, tipo: 'video' })),
+            ...Object.values(imagens),
+        ];
+        const r = impacto.montarImpacto({ roteiro, largura, altura, tempos, narracao, sons, trilha, fotos, iconesOk });
+        if (r.ok) projeto.anotar(p.id, 'plano', `estilo impacto: ${r.resumo.cenas} batidas`);
+        return r;
+    }
+    return composicao.comporRoteiro({ roteiro, modo, largura, altura, tempos, narracao, sons, trilha, imagens, iconesOk, fundos });
+}
+
+/* Sem o tempo de cada palavra, cada trecho é repartido pelas palavras dele,
+   proporcional ao tamanho de cada uma. */
+function repartirTrechos(trechos) {
+    const out = [];
+    for (const t of trechos) {
+        const ws = String(t.texto || '').split(/\s+/).filter(Boolean);
+        const letras = ws.reduce((n, w) => n + w.length, 0) || 1;
+        let cur = t.de;
+        for (const w of ws) {
+            const d = (t.ate - t.de) * (w.length / letras);
+            out.push({ de: cur, ate: cur + d, texto: w });
+            cur += d;
+        }
+    }
+    return out;
+}
+
 /**
  * A transcrição com tempo — é ela que dá legenda sincronizada.
  *
@@ -448,7 +1206,7 @@ async function transcrever(p, alvo, ctx) {
         if (!r || r.ok === false) return { ok: false, error: (r && r.erro) || 'a transcrição falhou.' };
         projeto.anotar(p.id, 'transcricao', `${(r.trechos || []).length} trechos`);
         return {
-            ok: true, texto: r.texto, trechos: r.trechos,
+            ok: true, texto: r.texto, trechos: r.trechos, palavras: r.palavras || [],
             comoUsar: 'cada trecho vira uma fala da legenda: {"de":…, "ate":…, "texto":…}. '
                 + 'O estilo da legenda (fonte, cor, peso, posição, animação) é escolha sua — não há padrão.',
         };
@@ -518,6 +1276,17 @@ async function ferramentaRender(args, ctx = {}) {
     });
     if (!r.ok) return { ...r, faltaram };
 
+    /* O VOLUME FINAL: a mistura (voz, música, efeitos, depoimento) sai no
+       padrão de Reels e YouTube, -14 LUFS. Medido em 25/09: o vídeo pronto
+       saía com -23,6 dB de média. A imagem não é recodificada. */
+    if (pl.audio && fs.existsSync(saida)) {
+        const tmp = saida.replace(/\.mp4$/, '.norm.mp4');
+        const ln = await video.rodar(video.ffmpeg(), ['-y', '-i', saida, '-c:v', 'copy', '-af', 'loudnorm=I=-14:TP=-1.2:LRA=10',
+            '-c:a', 'aac', '-b:a', '256k', tmp], { timeout: 15 * 60000 });
+        if (ln.ok && fs.existsSync(tmp)) fs.renameSync(tmp, saida);
+        else { try { fs.unlinkSync(tmp); } catch { /* não havia */ } }
+    }
+
     const bytes = fs.existsSync(saida) ? fs.statSync(saida).size : 0;
     projeto.salvar(args.id, { renders: [...(p.renders || []), { quando: new Date().toISOString(), arquivo: saida, bytes }] });
     projeto.anotar(args.id, 'render', `${(bytes / 1048576).toFixed(1)} MB, ${conferida.duracao}s`);
@@ -535,6 +1304,36 @@ async function ferramentaRender(args, ctx = {}) {
 
 // ── estudio_site ─────────────────────────────────────────────────────────
 
+/* A PALETA INTEIRA do site, não só a primeira cor. O fundo é o neutro
+   escuro que o site mais usa (#121218 na Paris Group); o destaque é a cor da
+   marca que mais aparece sobre ele (o laranja, não o azul escuro que some); o
+   apoio é a seguinte. A fonte serifada, quando existe, vai para citação. */
+function paletaDoSite(r) {
+    const hexRgb = (h) => { const n = parseInt(String(h).slice(1).padEnd(6, '0').slice(0, 6), 16); return [n >> 16, (n >> 8) & 255, n & 255]; };
+    const luz = (h) => { const [a, b, c] = hexRgb(h); return (0.299 * a + 0.587 * b + 0.114 * c) / 255; };
+    const sat = (h) => { const v = hexRgb(h); return (Math.max(...v) - Math.min(...v)) / 255; };
+    const neutras = ((r.cores && (r.cores.neutras || r.cores.fundo)) || []).map((x) => x.cor || x).filter((c) => /^#/.test(c));
+    const fundo = neutras.find((c) => luz(c) < 0.15 && luz(c) > 0.02) || neutras.find((c) => luz(c) < 0.2) || undefined;
+    const base = fundo || '#121218';
+    const marca = ((r.cores && r.cores.marca) || []).map((x) => x.cor).filter(Boolean);
+    const nota = (c) => sat(c) * 1.2 + Math.abs(luz(c) - luz(base));
+    const ordenadas = [...marca].sort((a, b) => nota(b) - nota(a));
+    const destaque = ordenadas[0];
+    // O apoio é OUTRA cor, de outro matiz: dois laranjas não fazem paleta.
+    const matiz = (h) => { const [a, b, c] = hexRgb(h).map((v) => v / 255); const mx = Math.max(a, b, c), mn = Math.min(a, b, c), d = mx - mn;
+        if (!d) return 0; const x = mx === a ? ((b - c) / d) % 6 : mx === b ? (c - a) / d + 2 : (a - b) / d + 4; return (x * 60 + 360) % 360; };
+    const longe = (a, b) => { const d = Math.abs(matiz(a) - matiz(b)); return Math.min(d, 360 - d) > 60; };
+    const apoio = ordenadas.find((c) => c !== destaque && longe(c, destaque) && sat(c) > 0.3) || ordenadas[1];
+    const fontes = ((r.fontes && r.fontes.declaradas) || []).map((x) => x.fonte).filter((f) => !/mono|menlo|courier|system|arial|helvetica/i.test(f));
+    return {
+        cores: { ...(fundo ? { fundo } : {}), ...(destaque ? { destaque } : {}), ...(apoio ? { apoio } : {}) },
+        fontes: {
+            ...(fontes[0] ? { titulo: fontes.find((f) => !/serif/i.test(f) || /sans/i.test(f)) || fontes[0], texto: fontes.find((f) => !/serif/i.test(f) || /sans/i.test(f)) || fontes[0] } : {}),
+            ...(fontes.find((f) => /serif/i.test(f) && !/sans/i.test(f)) ? { serifa: fontes.find((f) => /serif/i.test(f) && !/sans/i.test(f)) } : {}),
+        },
+    };
+}
+
 async function ferramentaSite(args) {
     let alvo = String(args.url || args.site || '').trim();
 
@@ -564,6 +1363,10 @@ async function ferramentaSite(args) {
        uma pasta de projeto, é lixo que ninguém recolhe. */
     const html = r.html;
     delete r.html;                          // o HTML cru não vai para o modelo
+    if (r.ok) {
+        const marcaLida = paletaDoSite(r);
+        ultimoSite = { url: r.url, html, quando: Date.now(), marca: marcaLida };
+    }
     if (r.ok && args.id && args.logo !== false) {
         const p = projeto.ler(args.id);
         if (p) {
@@ -580,11 +1383,57 @@ async function ferramentaSite(args) {
     if (r.ok && args.id) {
         projeto.anotar(args.id, 'referencia', `leu ${r.url}: ${(r.cores.marca[0] || {}).cor || 'sem cor'} · ${(r.fontes.declaradas[0] || {}).fonte || 'sem fonte'}`);
     }
+
+    /* O ACERVO DA MARCA: as fotos e os vídeos reais do site, e o texto das
+       páginas que combinam com o pedido (lib/estudio/acervo-site.js). As
+       fotos ficam guardadas no projeto e o roteiro as usa sozinho; os fatos
+       voltam para o modelo escrever o roteiro com dado de verdade. */
+    if (r.ok && args.id && args.acervo !== false) {
+        const p = projeto.ler(args.id);
+        if (p) {
+            try {
+                const a = await acervoSite.colher({
+                    url: r.url, pedido: args.pedido || p.pedido || '', pasta: p.pasta, htmlInicial: html,
+                    buscar: identidade.buscar, baixar: assets.baixar,
+                });
+                const marca = { ...ultimoSite.marca, ...(r.logo && r.logo.ok ? { logo: r.logo.src } : {}) };
+                /* O GRADIENTE da marca sai da própria logo, quando ela é SVG com
+                   gradiente (a da Paris Group vai de #2E81ED a #9567DB). */
+                try {
+                    if (marca.logo && /\.svg$/i.test(marca.logo)) {
+                        const svg = fs.readFileSync(path.join(p.pasta, marca.logo), 'utf8');
+                        const stops = [...new Set((svg.match(/stop-color=["'](#[0-9a-f]{3,6})["']/gi) || []).map((x) => x.match(/#[0-9a-f]{3,6}/i)[0].toUpperCase()))];
+                        if (stops.length >= 2) {
+                            marca.gradiente = stops.slice(0, 2);
+                            // A logo manda na identidade: o destaque é a cor dela, não a do CSS.
+                            marca.cores = { ...(marca.cores || {}), destaque: stops[1], apoio: stops[0] };
+                        }
+                    }
+                } catch { /* sem gradiente */ }
+                projeto.salvar(args.id, { acervo: { fotos: a.fotos, videos: a.videos, fatos: a.fatos, site: r.url }, marca });
+                projeto.anotar(args.id, 'midia', `acervo do site: ${a.fotos.length} fotos, ${a.videos.length} vídeos, ${a.paginas.length} páginas lidas`);
+                let orcamento = 4200;
+                r.fatos = a.fatos.map((f) => {
+                    const texto = f.texto.slice(0, Math.max(0, Math.min(1400, orcamento)));
+                    orcamento -= texto.length;
+                    return { pagina: f.pagina, texto };
+                }).filter((f) => f.texto);
+                r.acervo = { fotos: a.fotos.length, videos: a.videos.length,
+                    exemplos: a.fotos.slice(0, 6).map((f) => f.alt).filter(Boolean) };
+                r.comoUsar = 'Escreva o roteiro com os FATOS acima (datas, local, números, frases da marca) — nada '
+                    + 'inventado. As fotos e os vídeos reais da marca entram SOZINHOS no vídeo: não precisa pôr '
+                    + '"busca" nas partes de imagem (use tipo "imagem" com só o título). Use as cores, a fonte e '
+                    + 'a logo em roteiro.marca.';
+            } catch (e) {
+                r.acervo = { erro: e.message };
+            }
+        }
+    }
     return r;
 }
 
 module.exports = {
     ferramentaProjeto, ferramentaPlano, ferramentaMidia, ferramentaNarrar,
     ferramentaVideo, ferramentaRender, ferramentaSite,
-    projeto, plano, remotion, assets, video, identidade, slides, python, rodarPython,
+    projeto, plano, remotion, assets, video, identidade, slides, python, rodarPython, alinharPartes,
 };