primocode 11.0.0 → 11.2.0

package/lib/plugin/estudio/index.js

@@ -0,0 +1,2725 @@
+/**
+ * estudio/index.js — as ferramentas do Studio, do jeito que o agente as vê.
+ *
+ * ── O QUE ESTE ARQUIVO SUBSTITUI ─────────────────────────────────────────
+ * `lib/studio.js`, 887 linhas cuja maior parte era ligar, manter de pé e
+ * conversar por HTTP com um servidor Python que desenhava páginas — e mais o
+ * cuidado de abrir uma aba no navegador da pessoa no momento certo, e de não
+ * abrir três.
+ *
+ * Nada disso existe mais. Cada peça é uma PASTA, cada render é o Remotion, e
+ * a única coisa que abre no fim é o vídeo pronto.
+ *
+ * ── AS SETE FERRAMENTAS, E POR QUE SÃO SETE ──────────────────────────────
+ *   estudio_projeto    abrir, achar, listar, lembrar
+ *   estudio_plano      escrever ou ajustar o que o vídeo é
+ *   estudio_midia      procurar e baixar imagem, som, ícone, fonte
+ *   estudio_narrar     a voz, com os tempos medidos
+ *   estudio_video      o que se faz com a gravação: medir, cortar, legendar
+ *   estudio_render     virar arquivo
+ *   estudio_site       ler a identidade de uma marca a partir do link
+ *
+ * A tentação era uma ferramenta por verbo (criar cena, mover elemento, trocar
+ * cor). Isso multiplicaria o catálogo por dez e, pior, faria o modelo montar
+ * o vídeo por ajustes — que é exatamente como se produz vídeo genérico. O
+ * plano inteiro de uma vez obriga a decidir o vídeo inteiro de uma vez.
+ */
+
+'use strict';
+
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+const { spawn } = require('child_process');
+
+const projeto = require('./projeto.js');
+const acervo = require('./acervo.js');
+const hibrido = require('./hibrido.js');
+const biblioteca = require('./biblioteca.js');
+const referencias = require('./referencias.js');
+const variedade = require('./variedade.js');
+const diretor = require('./diretor.js');
+const falantes = require('./falantes.js');
+const variacao3d = require('./variacao3d.js');
+const plano = require('./plano.js');
+const remotion = require('./remotion.js');
+const assets = require('./assets.js');
+const video = require('./video.js');
+const batida = require('./batida.js');
+const revisor = require('./revisor.js');
+const marcaLib = require('./marca.js');
+const marcaKit = require('../marca-kit.js');
+const conferencia = require('./conferencia.js');
+const margem = require('./margem.js');
+const assinatura = require('./assinatura.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 printSite = require('./print-site.js');
+const efeitos = require('./efeitos.js');
+const impacto = require('./impacto.js');
+const cinema = require('./cinema.js');
+const motion = require('./motion.js');
+const gerativo = require('./gerativo.js');
+const fluido = require('./fluido.js');
+const vox = require('./vox.js');
+const kokoro = require('./kokoro.js');
+const voicestudio = require('./voicestudio.js');
+const lancamento = require('./lancamento.js');
+const glifos = require('./glifos.js');
+const personagem = require('./personagem.js');
+const mundo = require('./mundo.js');
+const cenarios = require('./cenarios.js');
+const estilos = require('./estilos.js');
+const { conferirCena } = require('./cena.js');
+const movimentos = require('./movimentos.js');
+const colecao = require('./colecao.js');
+const { escolherEstilo, LEVES } = require('./estilo.js');
+const sonsLeves = require('./sons-leves.js');
+const semNarracao = require('./sem-narracao.js');
+const camadas = require('./camadas.js');
+const ende = require('./ende.js');
+const producao = require('./producao.js');
+
+const PY = path.join(__dirname, '..', '..', '..', 'studio');
+
+/** Qual python desta máquina. O mesmo problema do Studio antigo, mesma cura. */
+function python() {
+    const { execSync } = require('child_process');
+    const nomes = process.platform === 'win32'
+        ? ['python', 'py', 'python3']
+        : ['python3', 'python', '/opt/homebrew/bin/python3', '/usr/local/bin/python3', '/usr/bin/python3'];
+    for (const n of nomes) {
+        try {
+            const v = execSync(`${n} --version`, { stdio: ['ignore', 'pipe', 'pipe'], timeout: 5000 }).toString();
+            if (/Python 3/.test(v)) return n;
+        } catch { /* próximo */ }
+    }
+    return null;
+}
+
+function rodarPython(script, args, { timeout = 20 * 60000 } = {}) {
+    return new Promise((resolve) => {
+        const py = python();
+        if (!py) {
+            return resolve({ ok: false, error: 'não achei o Python 3 nesta máquina.',
+                comoResolver: 'instale o Python 3 (python.org) e tente de novo' });
+        }
+        const p = spawn(py, [path.join(PY, script), ...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 script não respondeu' }); }
+        });
+        p.on('error', (e) => { clearTimeout(relogio); resolve({ ok: false, error: e.message }); });
+    });
+}
+
+/* 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 ──────────────────────────────────────────────────────
+
+/**
+ * A queixa quando o projeto não aparece — e ela muda conforme o motivo.
+ *
+ * "não achei o projeto 'undefined'" é o que o agente recebia ao chamar a
+ * ferramenta SEM id, e não ensina nada: ele não sabe se inventou o id, se o
+ * projeto sumiu, ou se esqueceu o argumento. Visto em produção — o modelo
+ * chamou `estudio_plano` sem id e ficou repetindo a chamada.
+ */
+function semProjeto(id) {
+    if (id == null || String(id).trim() === '') {
+        return {
+            ok: false,
+            error: 'faltou dizer em qual projeto (id).',
+            comoResolver: 'crie um com estudio_projeto acao:"criar" e use o id que ele devolve, '
+                + 'ou ache o existente com acao:"listar" / acao:"procurar".',
+        };
+    }
+    return {
+        ok: false,
+        error: `não achei o projeto "${id}".`,
+        comoResolver: 'liste com estudio_projeto acao:"listar" e use um id de lá — '
+            + 'o id é o nome da pasta (ex: "anuncio-picpay"), não o título.',
+    };
+}
+
+async function ferramentaProjeto(args, ctx = {}) {
+    const acao = String(args.acao || 'listar').toLowerCase();
+
+    if (acao === 'editar' || acao === 'editor' || acao === 'studio') return editarNoStudio(args, ctx);
+
+    if (acao === 'criar' || acao === 'novo') {
+        const r = projeto.criar({
+            titulo: args.titulo, pedido: args.pedido || args.titulo, formato: args.formato || 'video',
+        });
+        return { ...r, comoUsar: 'agora escreva o plano com estudio_plano, usando este id.' };
+    }
+
+    if (acao === 'abrir' || acao === 'ler') {
+        const p = projeto.ler(args.id);
+        if (!p) return semProjeto(args.id);
+        const pl = projeto.lerPlano(args.id);
+        return {
+            ok: true, projeto: p,
+            // O caderno é o que faz "mexe naquela parte" funcionar semanas
+            // depois: sem ele, reabrir diz o que existe e nunca por quê.
+            caderno: projeto.caderno(args.id, { ultimas: 25 }),
+            // A conversa das sessões em que se mexeu neste projeto (AGENTS.md
+            // da pasta dele, lib/agents-md.js): o que foi pedido e decidido.
+            memoria: require('../../agents-md.js').ler(p.pasta) || undefined,
+            plano: pl ? plano.resumo(pl) : 'ainda não há plano',
+            versoes: projeto.versoes(args.id),
+            arquivos: listarArquivos(p.pasta),
+        };
+    }
+
+    if (acao === 'procurar' || acao === 'achar') {
+        const achados = projeto.procurar(args.texto || args.titulo || '');
+        if (!achados.length) return { ok: true, achados: [], aviso: 'nenhum projeto parecido.' };
+        return {
+            ok: true,
+            achados: achados.map((p) => ({ id: p.id, titulo: p.titulo, criado: p.criado.slice(0, 10), pedido: p.pedido.slice(0, 120) })),
+        };
+    }
+
+    if (acao === 'anotar') {
+        projeto.anotar(args.id, args.tipo || 'nota', args.texto || '');
+        return { ok: true };
+    }
+
+    /* O FEEDBACK que vira estilo: "adorei a virada", "texto demais" fica na
+       assinatura da pessoa (assinatura.js), e o próximo vídeo já parte dele.
+       Sem texto, devolve a assinatura (as faixas e as notas). */
+    if (acao === 'assinatura' || acao === 'feedback' || acao === 'gostei') {
+        const nome = args.nome || args.assinatura || 'fluido';
+        if (!args.texto) { const a = assinatura.ler(nome); return a ? { ok: true, assinatura: a } : { ok: false, error: `a assinatura "${nome}" não existe.` }; }
+        const r = assinatura.anotar(nome, args.texto);
+        if (r.ok && args.id) projeto.anotar(args.id, 'assinatura', `feedback gravado na assinatura ${nome}: ${args.texto}`);
+        return r;
+    }
+
+    const todos = projeto.listar({ limite: Number(args.limite) || 20 });
+    return {
+        ok: true,
+        projetos: todos.map((p) => ({ id: p.id, titulo: p.titulo, criado: p.criado.slice(0, 10), renders: (p.renders || []).length })),
+    };
+}
+
+/* EDITAR um vídeo que o Estúdio fez: abre o projeto Remotion dele no
+   Remotion Studio. Sem id, é o projeto mais novo. */
+async function editarNoStudio(args, ctx = {}) {
+    const p = args.id ? projeto.ler(args.id) : projeto.listar({ limite: 1 })[0];
+    if (!p) return semProjeto(args.id);
+    const raiz = path.join(p.pasta, 'remotion');
+    if (!fs.existsSync(path.join(raiz, 'package.json'))) {
+        // Projeto que ainda não virou Remotion: escreve agora, sem renderizar.
+        const m = await ferramentaRender({ id: p.id, somenteProjeto: true }, ctx);
+        if (!m.ok) return m;
+    }
+    const r = remotion.abrirStudio({ raiz, spawnar: ctx.spawnar });
+    if (!r.ok) return { ...r, pasta: raiz };
+    projeto.anotar(p.id, 'editor', 'abriu no Remotion Studio');
+    return {
+        ok: true, id: p.id, pasta: raiz, comando: r.comando,
+        aviso: 'O Remotion Studio está ABRINDO no navegador (geralmente http://localhost:3000). '
+            + `Diga ao usuário onde está o projeto: ${raiz}. Lá ele mexe e renderiza pelo botão Render do Studio. `
+            + 'Cuidado: estudio_render reescreve a pasta src/ a partir do plano e apaga o que ele mudou à mão.',
+    };
+}
+
+function listarArquivos(pasta) {
+    const saida = {};
+    for (const sub of ['entrada', 'midia', 'saida']) {
+        try {
+            saida[sub] = fs.readdirSync(path.join(pasta, sub))
+                .filter((f) => !f.endsWith('.licenca.json')).slice(0, 40);
+        } catch { saida[sub] = []; }
+    }
+    return saida;
+}
+
+// ── 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;
+}
+
+/* Sem id, o projeto é o que acabou de ser criado. Visto em 12/10: o agente
+   criou o projeto, chamou estudio_narrar sem id e o vídeo morreu ali. Só vale
+   para chamada SEM id (id errado continua sendo erro) e para projeto de até
+   30 minutos, como no estudio_plano. */
+function projetoOuRecente(id) {
+    if (id != null && String(id).trim() !== '') return projeto.ler(id);
+    return projetoRecente();
+}
+
+/* roteiro.objetos: [{nome, src}] com o PNG DENTRO da pasta do projeto (o que
+   o estudio_midia baixou ou recortou). Caminho de fora some: o render só
+   enxerga a pasta do projeto, e a IA não escolhe arquivo da máquina. */
+function objetosDoRoteiro(objetos, pasta) {
+    const raiz = path.resolve(pasta);
+    return (Array.isArray(objetos) ? objetos : []).map((o) => {
+        if (!o || typeof o.src !== 'string') return null;
+        const abs = path.resolve(raiz, o.src);
+        if (!abs.startsWith(raiz + path.sep) || !/\.png$/i.test(abs) || !fs.existsSync(abs)) return null;
+        return { nome: o.nome, src: path.relative(raiz, abs).replace(/\\/g, '/') };
+    }).filter(Boolean);
+}
+
+/** O roteiro é utilizável como veio? (objeto ou JSON, com partes de tipo conhecido) */
+function roteiroValido(r) {
+    let x = r;
+    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'];
+    const NOVOS = ['logo', 'cores', 'produto'];   // vox.js e lancamento.js
+    /* A FALA do personagem (personagem.js) não tem tipo: é {falante, texto}. Sem
+       isto, o roteiro de diálogo caía no roteirista do servidor, que reescrevia
+       tudo com um apresentador só — e as duas vozes sumiam (10/10). */
+    const conversa = (x && !Array.isArray(x) && String(x.estilo || '').toLowerCase() === 'personagem') || partes.some((pt) => pt && typeof pt.falante === 'string' && pt.falante.trim());
+    const fala = (pt) => conversa && !pt.tipo && typeof (pt.texto || pt.fala) === 'string' && String(pt.texto || pt.fala).trim();
+    if (!partes.every((pt) => pt && (composicao.TIPOS.includes(pt.tipo) || CINEMA.includes(pt.tipo) || NOVOS.includes(pt.tipo) || fala(pt)))) return null;
+    // Duas vozes: roteiro.vozes e parte.falante, limpos (falantes.js). Sem eles, nada muda.
+    const obj = falantes.normalizar(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/config').loadConfig();
+    const api = require('../../provider/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 : '',
+        // Pedido de motion nunca vira impacto, nem sendo anúncio.
+        estilo: args.estilo || (escolherEstilo({ pedido }) === 'impacto' ? '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: marcaKit.preencher((args.roteiro && args.roteiro.marca) || p.marca || undefined, { pastas: [p.pasta, process.cwd()] }) } };
+}
+
+async function ferramentaPlano(args) {
+    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 && !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/plugin/estudio/composicao.js). É o caminho para qualquer modelo
+       entregar motion e slides que prestam. */
+    if (args.roteiro) {
+        /* O roteiro como a pessoa (ou o modelo) mandou: o híbrido traduz as
+           partes para o cinema no caminho, e o que fica guardado tem de ser o
+           original — senão o próximo ajuste parte do traduzido. */
+        let original = null;
+        try { original = JSON.parse(typeof args.roteiro === 'string' ? args.roteiro : JSON.stringify(args.roteiro)); } catch { original = args.roteiro; }
+        const r = await prepararRoteiro(p, args);
+        if (!r.ok) return r;
+        /* SEM NARRAÇÃO: o som sobe de papel — um efeito leve em cada corte e em
+           cada entrada marcante, variando (sem-narracao.js, sons-leves.js). */
+        if (args.__semNarracao) {
+            const n = semNarracao.sonorizarPlano(r, { tempos: args.__semNarracao.tempos, cues: args.__semNarracao.cues, sons: sonsLeves.preparar(p.pasta) });
+            if (r.resumo) r.resumo.semNarracao = true;
+            projeto.anotar(p.id, 'plano', `sem narração: ${n} efeitos leves nos cortes, entradas e micros`);
+        } else if (args.__barulhinhos && r.plano) {
+            // Com voz: os micros e os sons pedidos pela cena, baixinho por baixo da fala.
+            const n = semNarracao.sonorizarPlano(r, { tempos: args.__barulhinhos.tempos, cues: args.__barulhinhos.cues, sons: sonsLeves.preparar(p.pasta), comVoz: true });
+            if (n) projeto.anotar(p.id, 'plano', `barulhinhos: ${n} micros por baixo da fala`);
+        }
+        const ic = await variarIcones(r.plano, original);
+        if (ic.trocados) projeto.anotar(p.id, 'icones', `coleção ${ic.colecao}: ${ic.trocados} ícones`);
+        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(original || args.roteiro, null, 2)); } catch { /* segue */ }
+        projeto.salvar(args.id, { duracao: conferida.duracao });
+        /* A memória da estrutura (diretor.cardapioEstruturas): o próximo roteiro
+           vê o que este usou. Uma vez por projeto — mandar o roteiro de novo
+           para ajustar uma frase não é um vídeo novo. */
+        if (!p.estrutura) {
+            const usada = diretor.registrarEstrutura(original || args.roteiro);
+            projeto.salvar(args.id, { estrutura: usada.estrutura || '-' });
+        }
+        const quebradas = args.__cenasQuebradas || [];
+        /* NENHUMA CENA ESCRITA (14/10, a padaria da 10.11.0 saiu toda no
+           gerativo): a regra morava só na skill, e regra escrita não é regra
+           obedecida. O plano volta com o cardápio na mão — a IA ainda decide. */
+        const pts = Array.isArray(original) ? original : (original && original.partes) || [];
+        const nenhuma = pts.length > 1 && !pts.some((pt) => pt && pt.componente) && !quebradas.length;
+        return {
+            ok: true, duracao: conferida.duracao, ...r.resumo, resumo: plano.resumo(r.plano),
+            ...(quebradas.length ? { cenasQuebradas: quebradas } : {}),
+            ...(nenhuma ? { nenhumaCenaEscrita: {
+                aviso: 'Todas as partes caíram no gerativo automático. Para motion de verdade, escreva ao menos uma cena (componente), partindo de um destes efeitos (estudio_midia usar-efeito) se servir, e mande o roteiro de novo. Cada parte pode pedir som: sons:[{t, som}] (pop, mouse, tique, digital, swoosh, sub, ponto1..ponto5). Se o automático é o que você quer, siga para o render.',
+                efeitos: efeitos.cardapio().slice(0, 6),
+            } } : {}),
+            proximo: quebradas.length
+                ? `${quebradas.length} cena(s) sua(s) não compilaram e ficaram no gerativo: conserte o arquivo (o erro está em cenasQuebradas) e mande o roteiro de novo antes do render.`
+                : '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 };
+
+    /* Ajuste de UMA cena, sem reescrever o resto.
+     *
+     * É o caminho de "não gostei da parte do cartão": reescrever o plano
+     * inteiro para mexer numa cena é como o vídeo antigo mudava de cara
+     * sozinho a cada correção. */
+    if (args.cena != null) {
+        const atual = projeto.lerPlano(args.id);
+        if (!atual) return { ok: false, error: 'não há plano para ajustar.' };
+        const i = Number(args.cena) - 1;
+        if (!(i >= 0 && i < atual.cenas.length)) {
+            return { ok: false, error: `a cena ${args.cena} não existe (são ${atual.cenas.length}).` };
+        }
+        atual.cenas[i] = args.plano || args.novaCena || atual.cenas[i];
+        novo = atual;
+    }
+
+    const conferida = plano.conferir(novo, { pasta: p.pasta });
+    if (!conferida.ok) {
+        return {
+            ok: false,
+            error: 'o plano tem problemas que quebrariam o render — conserte e mande de novo.',
+            problemas: conferida.problemas.slice(0, 12),
+        };
+    }
+
+    projeto.salvarPlano(args.id, novo, args.motivo || '');
+    projeto.salvar(args.id, { duracao: conferida.duracao });
+    return {
+        ok: true, duracao: conferida.duracao, resumo: plano.resumo(novo),
+        proximo: 'estudio_render quando estiver pronto.',
+    };
+}
+
+// ── estudio_midia ────────────────────────────────────────────────────────
+
+async function ferramentaMidia(args) {
+    const acao = String(args.acao || 'imagem').toLowerCase();
+    const p = args.id ? projeto.ler(args.id) : null;
+    if (args.id && !p) return semProjeto(args.id);
+
+    if (acao === 'projetos') return require('./projetos.js').procurar({ termo: args.termo, categoria: args.categoria, limite: args.limite });
+    if (acao === 'projeto') return require('./projetos.js').ver(args.nome || args.id_item || args.termo, { c: await require('../../config/limites.js').situacao() });
+
+    if (acao === 'fontes') {
+        if (args.conferir) return assets.conferirFonte(args.conferir);
+        return { ok: true, fontes: assets.FONTES, biblioteca: biblioteca.cardapio(),
+            nota: 'qualquer família do Google Fonts funciona — esta lista é para não repetir sempre as mesmas.' };
+    }
+
+    /* Recortar o fundo. O pedido pede "buscar PNGs na internet, remover fundo
+       e inserir" — e sem isto o agente colava a foto com o retângulo branco
+       dela por cima do fundo da cena, que é o cara-de-recorte que denuncia
+       vídeo feito às pressas. O recorte real é modelo de segmentação (rembg);
+       sem ele na máquina, sobra o corte por cor, que só serve em fundo
+       chapado — e a resposta diz qual dos dois foi usado. */
+    if (acao === 'semfundo' || acao === 'sem-fundo' || acao === 'recortar') {
+        const alvo = args.arquivo || args.src;
+        if (!alvo) return { ok: false, error: 'diga o arquivo (arquivo) da imagem a recortar.' };
+        const cheio = p ? path.resolve(p.pasta, alvo) : path.resolve(alvo);
+        const r = await acervo.tirarFundo(cheio, { cor: args.cor, tolerancia: args.tolerancia });
+        if (!r.ok) return r;
+        const relativo = p ? path.relative(p.pasta, r.arquivo).replace(/\\/g, '/') : r.arquivo;
+        if (p) projeto.anotar(p.id, 'midia', `recortou o fundo de ${alvo} (${r.metodo})`);
+        return { ok: true, src: relativo, metodo: r.metodo, aviso: r.aviso || undefined };
+    }
+
+    /* O print de verdade do site (print-site.js), para a peça 3D `printsite`.
+       Só roda quando o modelo pede: o cardápio diz quando vale. */
+    if (acao === 'print') {
+        if (!p) return { ok: false, error: 'para tirar o print é preciso dizer em qual projeto (id).' };
+        const r = await printSite.capturarSite(args.url || args.site || args.termo, { pasta: p.pasta, celular: !!args.celular, inteira: args.inteira !== false });
+        if (r.ok) projeto.anotar(p.id, 'midia', `print de ${r.url} (${r.tela}): ${r.src}`);
+        return r;
+    }
+
+    /* O ELEMENTO do site, tirado pelo código (print-site.js): a lista das peças
+       (logo, botão, cartão, título…) e uma peça sozinha, com o fundo transparente. */
+    /* A REFERÊNCIA VISUAL que a pessoa manda (13/10: "não usa as referências
+       que mandei" — era o print da landing, arrastado no pedido). O agente não
+       enxerga imagem; aqui ela entra no projeto, as cores saem pelo ffmpeg e,
+       se o projeto ainda não tem marca, viram a marca. Com site, o site manda. */
+    if (acao === 'referencia' || acao === 'referência') {
+        if (!p) return semProjeto(args.id);
+        return importarReferencia(p, String(args.arquivo || args.caminho || args.src || ''));
+    }
+
+    if (acao === 'elementos') return printSite.elementosDoSite(args.url || args.site || args.termo, { celular: !!args.celular });
+    if (acao === 'elemento') {
+        if (!p) return { ok: false, error: 'para tirar o elemento é preciso dizer em qual projeto (id).' };
+        const r = await printSite.capturarElemento(args.url || args.site, { pasta: p.pasta, seletor: args.seletor, texto: args.texto || args.termo,
+            celular: !!args.celular, transparente: args.transparente !== false, margem: args.margem });
+        if (r.ok) projeto.anotar(p.id, 'midia', `elemento de ${r.url} (${args.seletor || args.texto || args.termo}): ${r.src}`);
+        return r;
+    }
+
+    // O catálogo de efeitos que a IA escreveu (efeitos.js): guardar, listar, reusar.
+    if (acao === 'efeitos') return { ok: true, efeitos: efeitos.cardapio(),
+        // A lista de técnicas mora aqui, e não na skill: a skill vai em todo pedido de vídeo e o teto é curto.
+        tecnicas: 'cor (ondas que inundam, paleta que vira na batida) · luz (faixa no título, bloom que respira, feixes, partículas) · física (antecipa, cai com peso, amassa no pouso, rebote; spring com massa, nunca linear) · 3D (perspective + rotateX: entra deitado e levanta, sombra no chão, câmera que orbita) · tipografia (letras que se montam, peso que pulsa, máscara que revela). Vídeo sobre site: tire a peça que conta a história com estudio_site elemento (PNG sem fundo) e anime ELA — peca-impacto-3d é ponto de partida, não molde.' };
+    if (acao === 'guardar-efeito' || acao === 'usar-efeito') {
+        if (!p) return { ok: false, error: 'diga em qual projeto (id).' };
+        const r = acao === 'guardar-efeito'
+            ? efeitos.guardar({ pasta: p.pasta, arquivo: args.arquivo || args.src, nome: args.nome, descricao: args.descricao, tags: args.tags })
+            : efeitos.reusar({ pasta: p.pasta, nome: args.nome });
+        if (r.ok) projeto.anotar(p.id, 'midia', `${acao === 'guardar-efeito' ? 'guardou' : 'reusou'} o efeito ${r.nome || args.nome}`);
+        return r;
+    }
+
+    if (acao === 'logo') {
+        if (!p) return { ok: false, error: 'para baixar a logo é preciso dizer em qual projeto (id).' };
+        const nome = String(args.marca || args.nome || args.termo || '').trim();
+        if (!nome) return { ok: false, error: 'diga a marca (marca).' };
+        let html = '';
+        let site = String(args.site || args.url || '').trim();
+        if (!site) {
+            const achado = await identidade.acharSite(nome);
+            if (achado.ok) site = achado.url;
+        }
+        if (site) {
+            if (!/^https?:\/\//i.test(site)) site = 'https://' + site;
+            html = (await require('../../referencia.js').pegar(site, { timeout: 15000 })) || '';
+        }
+        const r = await identidade.pegarLogo(html, site || 'https://exemplo.invalido', { pasta: p.pasta, nome });
+        if (r.ok) projeto.anotar(p.id, 'midia', `logo de ${nome}: ${r.src} (${r.achadaEm})`);
+        return r;
+    }
+
+    /* A BIBLIOTECA (colecao.js, 11/10): o cardápio inteiro, o ícone 3D e a
+       animação pronta. Procurar não usa rede (o índice mora no pacote); com
+       id, baixa para o projeto e devolve o elemento pronto. */
+    /* OS MOVIMENTOS (movimentos.js, 12/10): 100+ entradas, saídas, ênfases e loops com nome. */
+    if (acao === 'movimentos' || acao === 'movimento') {
+        return movimentos.procurar({ termo: args.termo, categoria: args.categoria, limite: Number(args.limite) || 30 });
+    }
+    /* OS CENÁRIOS (cenarios.js, 12/10): os lugares prontos + os que a IA criou
+       e a pessoa deixou guardar. Salvar só com o sim dela (autorizado:true). */
+    if (acao === 'cenarios' || acao === 'cenários') {
+        return { ok: true, prontos: Object.keys(mundo.LUGARES), salvos: cenarios.listar(),
+            comoCriar: 'na cena do estilo personagem: lugar (um pronto como base), ceu [cor de cima, cor do horizonte], chao {tipo, cor, cor2}, parede, luz, acento, hora e elementos. Ficou bom? Pergunte se pode salvar e use acao:"salvar_cenario".' };
+    }
+    if (acao === 'salvar_cenario' || acao === 'salvar_cenário') {
+        return cenarios.salvar({ nome: args.nome, cenario: args.cenario, autorizado: args.autorizado, bases: Object.keys(mundo.LUGARES) });
+    }
+    /* OS ESTILOS (estilos.js, 14/10): as peças do gerativo como cardápio — a IA
+       monta, mistura e cria; guardar só com o sim da pessoa. */
+    if (acao === 'estilos' || acao === 'estilo') return estilos.cardapio();
+    if (acao === 'salvar_estilo') return estilos.salvar({ nome: args.nome, pecas: args.pecas || args.estilo, descricao: args.descricao, autorizado: args.autorizado });
+    if (acao === 'biblioteca' || acao === 'cardapio' || acao === 'cardápio') return colecao.cardapio();
+    if (acao === 'icones3d' || acao === 'icone3d' || acao === 'animacoes' || acao === 'animacao' || acao === 'animação' || acao === 'animações') {
+        const ehAnim = /^anima/.test(acao);
+        if (args.id_item || /^(fluent3d|noto):/.test(String(args.item || args.baixar || ''))) {
+            const pj = p ? projeto.ler(p.id) : null;
+            const fmt = (pj && pj.formato) || {};
+            const r = await colecao.baixar(args.id_item || args.item || args.baixar, { pasta: p ? p.pasta : null, largura: fmt.largura || 1920, altura: fmt.altura || 1080 });
+            if (r.ok && p) projeto.anotar(p.id, 'midia', `biblioteca: ${r.src} (${r.licenca})`);
+            return r;
+        }
+        return ehAnim ? colecao.procurarAnimacoes(args.termo || args.busca || '', { quantas: Number(args.quantas) || 10 })
+            : colecao.procurarIcones3d(args.termo || args.busca || '', { quantas: Number(args.quantas) || 10 });
+    }
+
+    if (acao === 'icones' || acao === 'icone') {
+        if (args.nome) {
+            const r = await assets.icone(args.nome, { pasta: p ? p.pasta : null });
+            return r.ok ? { ok: true, nome: args.nome, baixado: true } : r;
+        }
+        return assets.procurarIcones(args.termo || args.busca || '');
+    }
+
+    if (acao === 'som' || acao === 'audio' || acao === 'trilha' || acao === 'efeito') {
+        const busca = await assets.procurarSom(args.termo || '', {
+            quantas: Number(args.quantas) || 8,
+            duracaoMin: acao === 'trilha' ? 30 : 0,
+            duracaoMax: acao === 'efeito' ? 6 : 0,
+        });
+        if (!busca.ok || !args.baixar) return busca;
+        return baixarEscolhido(busca.sons, args, p);
+    }
+
+    const busca = await assets.procurarImagens(args.termo || '', {
+        quantas: Number(args.quantas) || 8,
+        transparente: !!args.transparente,
+    });
+    if (!busca.ok || !args.baixar) return busca;
+    return baixarEscolhido(busca.imagens, args, p);
+}
+
+async function baixarEscolhido(lista, args, p) {
+    if (!p) return { ok: false, error: 'para baixar é preciso dizer em qual projeto (id).' };
+    const i = Number(args.baixar) === true ? 0 : Math.max(0, Number(args.baixar) - 1 || 0);
+    const item = lista[i];
+    if (!item) return { ok: false, error: `não há o item ${args.baixar} nessa busca.` };
+    const r = await assets.baixar(item, { pasta: p.pasta, nome: args.nome });
+    if (r.ok) {
+        projeto.anotar(p.id, 'midia', `baixou "${item.titulo}" (${item.licenca || 'sem licença declarada'})`);
+    }
+    return { ...r, creditos: item.creditos || null,
+        comoUsar: r.ok ? `no plano: "src": "${r.relativo}"` : undefined };
+}
+
+// ── estudio_ae ───────────────────────────────────────────────────────────
+
+/** O motor After Effects: roda o JSX do agente na pasta do projeto e devolve o mp4 e os quadros. */
+async function ferramentaAE(args) {
+    const p = args.id ? projeto.ler(args.id) : null;
+    if (!args.id || !p) return semProjeto(args.id);
+    if (!args.script || !args.comp) return { ok: false, error: 'estudio_ae pede script (o JSX) e comp (o nome da composição).' };
+    return require('./cota.js').comCota(() => renderAE(args, p));
+}
+
+async function renderAE(args, p) {
+    const kitM = marcaKit.preencher(null, { pastas: [p.pasta, process.cwd()] });
+    const fontesKit = kitM && kitM.kit ? [kitM.fontes && kitM.fontes.titulo, kitM.fontes && kitM.fontes.texto].filter(Boolean) : [];
+    const r = await require('./effectcraft.js').renderizar({
+        pasta: p.pasta, script: String(args.script), comp: String(args.comp),
+        fontes: [...new Set([...(Array.isArray(args.fontes) ? args.fontes : []), ...fontesKit])], audio: args.audio || undefined,
+        conferir: Array.isArray(args.conferir) ? args.conferir : [],
+    });
+    if (!r.ok) return r;
+    const daMarca = kitM && kitM.kit ? { marca: { nome: kitM.nome, cores: kitM.cores, fontes: kitM.fontes, logo: kitM.logo } } : {};
+    return { ...r, ...daMarca, nota: 'Olhe os quadros (arquivos em ae/) antes de dar por pronto; ajuste o JSX e rode de novo se algo estiver torto.' };
+}
+
+// ── estudio_motion ───────────────────────────────────────────────────────
+
+/** O pacote pra postar (exportar.js) + a galeria; nunca derruba o vídeo. `entrega:false` desliga. */
+function entregar(args, p, r) {
+    const x = r._exportar || {}; delete r._exportar;
+    if (args.entrega === false) return;
+    try {
+        const E = require('./exportar.js');
+        const e = E.exportar({ video: r.video, pasta: p.pasta, assunto: args.assunto, formatos: args.formatos, cenas: x.cenas, palavras: x.palavras, trilha: r.trilha && { ...r.trilha, arquivo: x.trilhaArquivo }, sfx: x.sfx });
+        if (e.ok) {
+            r.entrega = { pasta: e.dir, arquivos: e.arquivos.map((f) => path.basename(f)), creditos: e.creditos, ...(e.avisos ? { avisos: e.avisos } : {}) };
+            E.registrar({ id: p.id, assunto: args.assunto, caminho: r.video, formato: r.formato, duracao: r.duracao, assinatura: r.assinatura, entrega: e.dir });
+        } else r.entrega = { erro: e.error };
+    } catch (err) { r.entrega = { erro: err.message }; }
+}
+
+/** A máquina de motion: assunto + cenas em JSON viram o mp4 (maquina.js), com sons, trilha e voz opcionais. */
+async function ferramentaMotion(args) {
+    const p = args.id ? projeto.ler(args.id) : null;
+    if (!args.id || !p) return semProjeto(args.id);
+    let receita = null;
+    if (args.receita) {
+        const r = require('./projetos.js').ver(args.receita, { c: await require('../../config/limites.js').situacao() });
+        if (!r.ok) return r;
+        // Grátis vê o resumo da receita, não monta a partir dela: diz o porquê em vez de renderizar pela metade.
+        if (r.bloqueado) return { ok: false, error: r.aviso, projeto: r.projeto };
+        receita = r.projeto;
+    }
+    // primeiro motion: aprende o gosto antes de renderizar (a pessoa pode fechar ou pular; o render segue de qualquer jeito)
+    // no terminal abre o navegador; no app (desktop ou Primo.app, -p com PRIMOCODE_APP=1) o app abre a tela pela linha de protocolo
+    try { await require('./gosto.js').antesDoMotion(args); } catch { /* sem tela, segue */ }
+    return require('./cota.js').comCota(() => renderMotion(args, p, receita));
+}
+
+async function renderMotion(args, p, receita) {
+    const narrar = async (texto, mp3, voz) => rodarPython('narrar.py', ['falar', '--texto', texto, '--saida', mp3, '--voz', String(voz || 'francisca')], { timeout: 5 * 60000 });
+    // Kit de marca ativo: cores, fontes e logo entram onde o JSON não disse; o logo vai no CTA (última cena).
+    const kitM = marcaKit.preencher(args.marca, { pastas: [p.pasta, process.cwd()] });
+    if (kitM && kitM.kit) {
+        args = { ...args, marca: kitM };
+        if (kitM.logo && Array.isArray(args.cenas) && args.cenas.length) {
+            args.cenas = args.cenas.map((c, i) => (i === args.cenas.length - 1 && c && !c.logo ? { ...c, logo: kitM.logo } : c));
+        }
+    }
+    // As fotos do pedido: as que a IA passou em `fotos` e as que o terminal achou no texto do pedido (referencias.imagens()).
+    // Antes só o prepararRoteiro (Remotion) as lia: no motion elas viravam "referência" e nenhuma peça aceitava foto.
+    const doPedido = referencias.imagens();
+    const dadas = Array.isArray(args.fotos) ? args.fotos : (args.fotos ? [args.fotos] : []);
+    const todas = [...new Set([...dadas, ...doPedido])];
+    if (todas.length) args = { ...args, fotos: todas, ...(dadas.length ? {} : { fotosImplicitas: true }) };
+    const r = await require('./maquina.js').motion(args, { pasta: p.pasta, receita, deps: { narrar } });
+    if (r.ok) projeto.anotar(p.id, 'motion', `${r.duracao}s, ${r.cenas.length} cenas, ${r.lufs} LUFS`);
+    if (r.ok) entregar(args, p, r);
+    if (!r.ok) return r;
+    const gostoResumo = (() => { try { const G = require('./gosto.js'); return G.resumo(G.ler()); } catch { return ''; } })();
+    return { ...r, ...(gostoResumo ? { gosto: gostoResumo } : {}), nota: 'Abra os quadros (png em ae/) para conferir. Se algo ficou torto, mude o JSON e rode de novo.' };
+}
+
+// ── estudio_criar ────────────────────────────────────────────────────────
+
+/** A porta simples (criar.js): escolhe a receita e chama as ferramentas de cima. `ctx.progresso(pct, etapa)` alimenta o item da tela. */
+async function ferramentaCriar(args, ctx = {}) {
+    return require('./criar.js').criar(args, {
+        projeto,
+        plano: (a) => ferramentaPlano({ ...a, __pasta: ctx.projectDir }),
+        motion: (a) => ferramentaMotion(a),
+        render: (a) => ferramentaRender({ ...a, __pasta: ctx.projectDir }, ctx),
+        progresso: ctx.progresso,
+    });
+}
+
+// ── estudio_editar ───────────────────────────────────────────────────────
+
+/** O editor por comando: reabre o plano da máquina de motion, aplica as mudanças e guarda a versão (editor.js). */
+async function ferramentaEditar(args) {
+    const id = args.id_video || args.id;
+    const p = id ? projeto.ler(id) : null;
+    if (!p) return semProjeto(id);
+    const r = await require('./editor.js').editar(args, { pasta: p.pasta });
+    if (r.ok && r.versao && !args.listar) projeto.anotar(p.id, 'editar', `v${r.versao}: ${(r.feitas || [r.nota || '']).join('; ').slice(0, 120)}`);
+    return r.ok && r.video ? { ...r, nota: r.nota || 'Mostre o vídeo. Se não era isso, mude de novo ou use voltar_para.' } : r;
+}
+
+// ── estudio_narrar ───────────────────────────────────────────────────────
+
+async function ferramentaNarrar(args) {
+    if (args.vozes) return rodarPython('narrar.py', ['vozes'], { timeout: 30000 });
+
+    const p = projetoOuRecente(args.id);
+    if (!p) return semProjeto(args.id);
+    if (args.id == null || String(args.id).trim() === '') args = { ...args, id: p.id };
+    const texto = String(args.texto || '').trim();
+    if (!texto) return { ok: false, error: 'não há texto para narrar.' };
+
+    const saida = path.join(p.pasta, 'midia', `narracao-${Date.now().toString(36)}.mp3`);
+    fs.mkdirSync(path.dirname(saida), { recursive: true });
+
+    const r = await rodarPython('narrar.py', [
+        'falar', '--texto', texto, '--saida', saida,
+        '--voz', String(args.voz || 'antonio'),
+        '--estilo', String(args.estilo || 'normal'),
+        ...(args.ritmo ? ['--ritmo', String(args.ritmo)] : []),
+        ...(args.tom ? ['--tom', String(args.tom)] : []),
+    ], { timeout: 5 * 60000 });
+
+    if (!r.ok) return r;
+    const relativo = path.relative(p.pasta, saida).replace(/\\/g, '/');
+    projeto.anotar(p.id, 'narracao', `${r.segundos}s na voz ${args.voz || 'antonio'}`);
+    return {
+        ...r, relativo,
+        comoUsar: `no plano: "audio": {"narracao": "${relativo}"}. `
+            + 'Os tempos de "falas" são MEDIDOS — use-os para a duração de cada cena e para as legendas, '
+            + 'em vez de estimar por número de palavras.',
+    };
+}
+
+// ── estudio_video ────────────────────────────────────────────────────────
+
+async function ferramentaVideo(args, ctx = {}) {
+    const acao = String(args.acao || 'medir').toLowerCase();
+    const p = projetoOuRecente(args.id);
+    if (!p) return semProjeto(args.id);
+    if (args.id == null || String(args.id).trim() === '') args = { ...args, id: p.id };
+
+    const pronto = video.conferir();
+    if (!pronto.ok) return pronto;
+
+    const dentro = (rel) => {
+        const cheio = path.resolve(p.pasta, String(rel || ''));
+        return cheio.startsWith(path.resolve(p.pasta)) ? cheio : null;
+    };
+
+    if (acao === 'importar') {
+        // O vídeo da pessoa entra na pasta do projeto. Trabalhar a partir de
+        // onde ele está é o caminho para o agente escrever em cima do
+        // original — e o original dela não tem cópia.
+        const de = path.resolve(String(args.arquivo || '').replace(/^~(?=$|[/\\])/, os.homedir()));
+        if (!fs.existsSync(de)) return { ok: false, error: `não achei "${args.arquivo}".` };
+        const para = path.join(p.pasta, 'entrada', path.basename(de));
+        fs.copyFileSync(de, para);
+        const m = await video.medir(para);
+        projeto.anotar(p.id, 'entrada', `importou ${path.basename(de)} (${m.ok ? m.segundos + 's' : '?'})`);
+        return { ok: true, arquivo: path.relative(p.pasta, para).replace(/\\/g, '/'), medida: m };
+    }
+
+    const alvo = dentro(args.arquivo);
+    if (!alvo || !fs.existsSync(alvo)) {
+        return { ok: false, error: `"${args.arquivo}" não está na pasta do projeto. Use acao:"importar" antes.` };
+    }
+
+    if (acao === 'medir') return video.medir(alvo);
+
+    if (acao === 'silencio' || acao === 'pausas') {
+        const s = await video.silencios(alvo, { limiarDb: Number(args.limiarDb) || -40 });
+        if (!s.ok) return s;
+        const m = await video.medir(alvo);
+        return {
+            ok: true, silencios: s.silencios,
+            ficariam: video.trechosQueFicam(m.segundos, s.silencios, args),
+        };
+    }
+
+    if (acao === 'cortar-silencio' || acao === 'cortar') {
+        const saida = path.join(p.pasta, 'midia', `cortado-${Date.now().toString(36)}.mp4`);
+        const r = await video.cortarSilencio(alvo, saida, args);
+        if (r.ok && !r.semCorte) {
+            projeto.anotar(p.id, 'corte', `${r.antes}s → ${r.depois}s, ${r.cortes} cortes`);
+            r.relativo = path.relative(p.pasta, saida).replace(/\\/g, '/');
+        }
+        return r;
+    }
+
+    if (acao === 'quadro') {
+        const saida = path.join(p.pasta, 'midia', `quadro-${Math.round(Number(args.segundo) || 0)}s.png`);
+        const r = await video.quadro(alvo, saida, Number(args.segundo) || 0);
+        if (r.ok) r.relativo = path.relative(p.pasta, saida).replace(/\\/g, '/');
+        return r;
+    }
+
+    if (acao === 'legendas' || acao === 'transcrever') {
+        return transcrever(p, alvo, ctx);
+    }
+
+    /* A EDIÇÃO INTEIRA, em código (lib/plugin/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 (!info.recorte || !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).',
+        };
+    }
+
+    /* O VÍDEO EM CAMADAS (camadas.js, 14/10: "quero uma edição nesse nível"):
+       a pessoa só gravou a fala; a IA passa as batidas (forma do rosto, cena
+       de motion, destaque) e o Estúdio monta o bolo por cima. Sem batidas,
+       devolve uma proposta pela transcrição — a IA aceita ou muda. */
+    if (acao === 'camadas') {
+        const m = await video.medir(alvo);
+        if (!m.ok) return m;
+        // A transcrição fica guardada: a proposta e a montagem não pagam duas vezes.
+        const guardada = path.join(p.pasta, 'midia', `transcricao-${path.basename(alvo).replace(/\.[^.]+$/, '')}.json`);
+        let palavras = Array.isArray(args.palavras) && args.palavras.length ? args.palavras : null;
+        if (palavras) { try { fs.writeFileSync(guardada, JSON.stringify(palavras)); } catch { /* segue sem guardar */ } }
+        if (!palavras && fs.existsSync(guardada)) { try { palavras = JSON.parse(fs.readFileSync(guardada, 'utf8')); } catch { palavras = null; } }
+        if (!palavras) {
+            const tr = await transcrever(p, alvo, ctx);
+            if (!tr.ok) return tr;
+            palavras = (tr.palavras && tr.palavras.length) ? tr.palavras : repartirTrechos(tr.trechos || []);
+            try { fs.writeFileSync(guardada, JSON.stringify(palavras)); } catch { /* segue sem guardar */ }
+        }
+        const batidas = Array.isArray(args.batidas) && args.batidas.length ? args.batidas : null;
+        if (!batidas) {
+            return {
+                ok: true, proposta: camadas.propor(palavras, m.segundos), duracao: m.segundos,
+                comoUsar: 'é uma SUGESTÃO pela transcrição. Decida você: mude as formas, junte ou separe batidas, '
+                    + 'escreva a cena de motion de cada ideia (componentes/x.jsx, recebe {el, t, fps}; el.dados traz largura/altura do espaço livre, '
+                    + 'palavras com t, destaque, cores e fontes; a LEGENDA da fala já está no quadro, então a cena NÃO escreve a fala: desenha a ideia) ou use um efeito de fábrica pelo nome (estudio_midia acao:"efeitos"), '
+                    + 'e chame de novo com batidas:[{de, ate, rosto, cena?, destaque?, canto?, dados?}].',
+            };
+        }
+        // A cena: arquivo da pasta (conferido antes do render) ou efeito de fábrica pelo nome.
+        const problemas = [];
+        const prontas = batidas.map((b, i) => {
+            if (!b || !b.cena) return b;
+            const cena = String(b.cena).trim();
+            if (/[\\/]|\.(jsx|tsx|js)$/i.test(cena)) {
+                const cheio = dentro(cena);
+                if (!cheio || !fs.existsSync(cheio)) { problemas.push(`batidas[${i}]: a cena "${cena}" não está na pasta do projeto.`); return { ...b, cena: null }; }
+                const conf = conferirCena(cheio);
+                if (!conf.ok) { problemas.push(`batidas[${i}]: ${cena} — ${conf.erro}`); return { ...b, cena: null }; }
+                return { ...b, cena };
+            }
+            const r = efeitos.reusar({ pasta: p.pasta, nome: cena });
+            if (!r.ok) { problemas.push(`batidas[${i}]: ${r.error}`); return { ...b, cena: null }; }
+            return { ...b, cena: r.src };
+        });
+        if (problemas.length) return { ok: false, error: 'as cenas têm problema — conserte e mande de novo.', problemas };
+
+        /* A voz no volume de vídeo de internet (-15 LUFS), como na edição
+           automática; o vídeo em si não é recodificado. */
+        let fonte = alvo;
+        if (args.normalizar !== false) {
+            const normal = path.join(p.pasta, 'midia', `voz-normal-${path.basename(alvo).replace(/\.[^.]+$/, '')}.mp4`);
+            if (!fs.existsSync(normal)) {
+                await video.rodar(video.ffmpeg(), ['-y', '-i', alvo, '-c:v', 'copy',
+                    '-af', 'loudnorm=I=-15:TP=-1.5:LRA=11', '-c:a', 'aac', '-b:a', '192k', normal], { timeout: 10 * 60000 });
+            }
+            if (fs.existsSync(normal)) fonte = normal;
+        }
+        const deitado = m.largura > m.altura;
+        const montado = camadas.montar({
+            src: path.relative(p.pasta, fonte).replace(/\\/g, '/'), duracao: m.segundos, palavras, batidas: prontas,
+            largura: deitado ? 1920 : 1080, altura: deitado ? 1080 : 1920, fps: 30,
+            origem: { largura: m.largura, altura: m.altura }, rosto: args.rosto || {}, acento: args.acento,
+            sons: sonsLeves.preparar(p.pasta),
+        });
+        if (!montado.ok) return montado;
+        const salvo = await ferramentaPlano({ id: args.id, plano: montado.plano, motivo: `vídeo em camadas (${montado.resumo.batidas} batidas)` });
+        if (!salvo.ok) return salvo;
+        projeto.anotar(p.id, 'edicao', `camadas: ${montado.resumo.batidas} batidas, ${montado.resumo.cenas} cenas de motion, ${montado.resumo.trocasDeForma} trocas de forma`);
+        return {
+            ok: true, ...montado.resumo, batidas: montado.batidas, duracao: salvo.duracao,
+            proximo: 'estudio_render com este id. Para mudar uma batida, chame camadas de novo com a lista inteira.',
+        };
+    }
+
+    if (acao === 'recortar-pessoa' || acao === 'pessoa') {
+        const saida = path.join(p.pasta, 'midia', `pessoa-${Date.now().toString(36)}.webm`);
+        const r = await rodarPessoa([
+            'recortar', '--entrada', alvo, '--saida', saida,
+            ...(args.suavizar != null ? ['--suavizar', String(args.suavizar)] : []),
+            ...(args.encolher != null ? ['--encolher', String(args.encolher)] : []),
+        ], { timeout: 40 * 60000 });
+        if (r.ok) {
+            r.relativo = path.relative(p.pasta, saida).replace(/\\/g, '/');
+            r.comoUsar = 'é um vídeo com fundo TRANSPARENTE. Ponha-o como elemento de vídeo numa cena '
+                + 'que tenha a imagem de fundo atrás — não precisa juntar os dois num arquivo.';
+            projeto.anotar(p.id, 'pessoa', `recortou ${r.quadros} quadros`);
+        }
+        return r;
+    }
+
+    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 uma foto. Devolve {src, tipo} ou null. O clipe sai sorteado entre
+   os que os últimos vídeos não usaram (variedade.js), não o primeiro da
+   busca — "o b-roll veio igual nos dois vídeos" (Joel, 05/10). */
+/** A foto editorial (Wikimedia, museu) que os últimos vídeos não usaram; o crédito fica no caderno. */
+async function baixarEditorial(p, termo) {
+    try {
+        const b = await assets.procurarEditorial(termo, { quantas: 8 });
+        for (const item of variedade.ordenar(b.imagens, 'broll').slice(0, 4)) {
+            const d = await assets.baixar(item, { pasta: p.pasta, nome: 'foto-' + termo });
+            if (d.ok) { variedade.marcar('broll', item.url); projeto.anotar(p.id, 'creditos', item.creditos); return { src: d.relativo, tipo: 'imagem' }; }
+        }
+    } catch { /* sem foto */ }
+    return null;
+}
+
+async function baixarApoio(p, termo, { orientacao = null, video: querVideo = false } = {}) {
+    if (querVideo) {
+        try {
+            const itens = await variedade.buscarSemRepetir(async (t) => {
+                const b = await assets.procurarVideos(t, { quantas: 8, orientacao });
+                return (b.ok ? b.videos : []).filter((v) => !v.duracao || v.duracao >= 3);
+            }, termo);
+            for (const item of itens.slice(0, 4)) {
+                const d = await assets.baixar(item, { pasta: p.pasta, nome: 'apoio-' + termo });
+                if (d.ok) { variedade.marcar('broll', item.url); return { src: d.relativo, tipo: 'video' }; }
+            }
+        } catch { /* cai para a foto */ }
+    }
+    try {
+        const itens = await variedade.buscarSemRepetir(async (t) => {
+            const b = await assets.procurarImagens(t, { quantas: 8, orientacao });
+            return b.ok ? b.imagens : [];
+        }, termo);
+        for (const item of itens.slice(0, 4)) {
+            const d = await assets.baixar(item, { pasta: p.pasta, nome: 'apoio-' + termo });
+            if (d.ok) { variedade.marcar('broll', item.url); return { src: d.relativo, tipo: 'imagem' }; }
+        }
+    } catch { /* sem apoio */ }
+    return null;
+}
+
+/* Os ícones automáticos trocam de coleção a cada vídeo (Joel, 05/10: "várias
+   opções de ícones... que não sejam padrão da IA"). O ícone que o roteiro
+   pediu pelo nome fica; o que não existe na coleção sorteada fica no 3D. */
+async function variarIcones(plano, roteiro) {
+    const colecao = variedade.colecaoIcones();
+    const explicitos = [];
+    try { JSON.stringify(roteiro || {}, (k, v) => { if (k === 'icone' && typeof v === 'string') explicitos.push(v); return v; }); } catch { /* sem */ }
+    const troca = {};
+    /* VÁRIAS BIBLIOTECAS NO MESMO VÍDEO (13/10: "não uma biblioteca de ícone,
+       mas várias, que vai misturar tudo"). Antes o vídeo sorteava UMA coleção
+       e trocava todos os ícones para ela. Agora cada ícone tenta uma coleção,
+       em rodízio a partir da sorteada; sem o desenho nela, a próxima. */
+    const colecoes = [colecao, ...assets.COLECOES.map((c) => c[0]).filter((c) => c !== colecao)];
+    let vez = 0;
+    for (const nome of variedade.iconesTrocaveis(plano, explicitos)) {
+        /* Primeiro O ÍCONE: o conceito escolhe entre as formas dele
+           (edicao.ALTERNATIVAS) pelos pontos da variedade — o que os últimos
+           vídeos menos usaram. Depois A COLEÇÃO. */
+        const base = nome.split(':')[1];
+        let escolhido = base;
+        const alts = edicao.ALTERNATIVAS[base];
+        if (alts) {
+            const ordem = variedade.ordenar([base, ...alts].map((url) => ({ url })), 'icone-nome').map((x) => x.url);
+            for (const n of ordem) {
+                if (n === base) { escolhido = base; break; }
+                try { const r = await assets.icone('fluent-3d:' + n); if (r && r.ok) { escolhido = n; break; } } catch { /* tenta o próximo */ }
+            }
+            variedade.marcar('icone-nome', escolhido);
+        }
+        let novo = 'fluent-3d:' + escolhido;
+        for (let k = 0; k < colecoes.length; k++) {
+            const c = colecoes[(vez + k) % colecoes.length];
+            if (c === 'fluent-3d') break;
+            try { const r = await assets.icone(c + ':' + escolhido); if (r && r.ok) { novo = c + ':' + escolhido; break; } } catch { /* a próxima */ }
+        }
+        vez++;
+        if (novo !== nome) troca[nome] = novo;
+    }
+    const n = variedade.trocarIcones(plano, troca);
+    if (n || colecao === 'fluent-3d') variedade.marcar('icones', colecao);
+    return { colecao, trocados: n };
+}
+
+/* ── 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 };
+    });
+}
+
+/**
+ * Onde o roteiro COMEÇA na fala transcrita, em segundos — 0 se começa logo.
+ *
+ * Dois jeitos de o Gemini vazar a direção, os dois vistos no vídeo do Joel
+ * (10/10): falar "Rápido e contínuo." ANTES do roteiro, e falar NO LUGAR da
+ * primeira frase ("Rápido e contínuo. Você pergunta…", sem o "IA é pra tirar
+ * dúvida"). Então: acha o primeiro par de palavras seguidas que existe no
+ * roteiro (não só o par do começo), e corta o que veio antes — mas só se o que
+ * veio antes for, na maior parte, palavra da DIREÇÃO. Fala do roteiro que o
+ * transcritor errou não é vazamento e não sai.
+ */
+function vazamentoNoComeco(lista, palavras, direcao = '') {
+    const norm = (t) => String(t || '').toLowerCase().normalize('NFD').replace(/[\u0300-\u036f]/g, '').replace(/[^a-z0-9]+/g, ' ').trim();
+    const roteiro = norm(lista.slice(0, 2).map((x) => x.texto).join(' ')).split(' ').filter(Boolean);
+    if (roteiro.length < 2 || !palavras.length) return 0;
+    const pares = new Set(roteiro.slice(0, -1).map((w, i) => w + ' ' + roteiro[i + 1]));
+    /* 40 palavras, não 14 (13/10): a direção do personagem tem ~20 palavras, e
+       o roteiro só começava depois da janela — o corte desistia e o vídeo saía
+       com "Natural and close. Never like an announcer." na legenda. */
+    const ditas = palavras.slice(0, 40).map((w) => norm(w.texto));
+    let i = 0;
+    while (i < ditas.length - 1 && !pares.has(ditas[i] + ' ' + ditas[i + 1])) i++;
+    if (i === 0 || i >= ditas.length - 1) return 0;
+    const daDirecao = new Set(norm(direcao).split(' ').filter(Boolean));
+    const antes = ditas.slice(0, i).join(' ').split(' ').filter(Boolean);
+    /* A transcrição entorta a direção ("Read aloud in Brazilian Portuguese" vira
+       "Lê a alta em Brasília e Português"): basta 35% das palavras, ou 3, serem dela. */
+    const daDir = antes.filter((w) => daDirecao.has(w)).length;
+    const vazou = !direcao || daDir / antes.length >= 0.35 || daDir >= 3;
+    return vazou ? Math.max(0, palavras[i].de - 0.08) : 0;
+}
+
+async function narrarComGemini(lista, mp3, { voz, direcao } = {}) {
+    /* A narração premium é do Pro em diante (lib/config/limites.js). Sem ela a corrente
+       segue para a voz local (Kokoro/Edge) e o aviso explica o porquê. */
+    const lim = require('../../config/limites.js');
+    const prem = await lim.exigir('narracaoPremium');
+    if (!prem.ok) { lim.avisar(prem.error + ' A narração saiu com a voz local.'); return { ok: false, error: prem.error }; }
+    try {
+        const cfg = require('../../config/config').loadConfig();
+        const api = require('../../provider/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' });
+        let palavras = (tr && tr.palavras) || [];
+        if (!palavras.length) return { ok: false, error: 'sem a transcrição da voz para achar as partes' };
+        let segundos = med.segundos;
+        /* A DIREÇÃO LIDA EM VOZ ALTA. O servidor manda a direção ("leia RÁPIDO e
+           contínuo…") e o texto no mesmo pedido, e o Gemini às vezes fala o
+           começo dela: o vídeo do Joel abria com "Rápido e contínuo." antes do
+           roteiro (10/10). Se o roteiro só começa depois de algumas palavras,
+           o que vem antes é vazamento — e sai do áudio. */
+        const corte = vazamentoNoComeco(lista, palavras, direcao);
+        if (corte > 0.15) {
+            const cortado = mp3.replace(/\.mp3$/, '-c.mp3');
+            const k = await video.rodar(video.ffmpeg(), ['-y', '-ss', corte.toFixed(3), '-i', mp3, '-c:a', 'libmp3lame', '-q:a', '3', cortado], { timeout: 120000 });
+            if (k.ok && fs.existsSync(cortado)) {
+                fs.renameSync(cortado, mp3);
+                palavras = palavras.filter((w) => w.de >= corte - 0.02).map((w) => ({ ...w, de: Math.max(0, w.de - corte), ate: Math.max(0, w.ate - corte) }));
+                segundos = Math.max(0, segundos - corte);
+            }
+        }
+        return { ok: true, voz: `gemini ${r.voz}`, segundos, partes: alinharPartes(lista, palavras, segundos), ...(corte > 0.15 ? { cortouDirecao: corte } : {}) };
+    } catch (e) {
+        return { ok: false, error: e.message };
+    }
+}
+
+/* A VOZ DO VOICESTUDIO (15/10): o app local fala o roteiro inteiro, e o resto
+   é o caminho do Gemini — volume de Reels, a transcrição para achar as partes.
+   Fechado ou falhando, devolve ok:false e a cadeia segue para o Gemini. */
+async function narrarComVoiceStudio(lista, mp3, { voz } = {}) {
+    if (process.env.PRIMOCODE_SEM_VOICESTUDIO) return { ok: false, indisponivel: true, error: 'voicestudio desligado' };
+    try {
+        const texto = lista.map((x) => x.texto).join('\n\n');
+        // A voz do Gemini ("Kore", "Charon") não existe lá: só um perfil do próprio app.
+        const perfil = /^vs:/i.test(String(voz || '')) ? String(voz).slice(3) : undefined;
+        const r = await voicestudio.falar(texto, { voz: perfil });
+        if (!r.ok) return r;
+        const bruto = mp3.replace(/\.mp3$/, '-vs.mp3');
+        fs.writeFileSync(bruto, r.audio);
+        const c = await video.rodar(video.ffmpeg(), ['-y', '-i', bruto, '-af', 'loudnorm=I=-14:TP=-1.5:LRA=9', '-c:a', 'libmp3lame', '-q:a', '3', mp3], { timeout: 120000 });
+        try { fs.unlinkSync(bruto); } catch { /* fica */ }
+        if (!c.ok) return { ok: false, error: 'voicestudio: não consegui converter a voz' };
+        const med = await video.medir(mp3);
+        const chars = lista.reduce((n, x) => n + x.texto.length, 0);
+        if (med.segundos < chars / 22) return { ok: false, error: `voicestudio: a voz veio cortada (${med.segundos.toFixed(1)} s para ${chars} caracteres)` };
+        const cfg = require('../../config/config').loadConfig();
+        const tr = await require('../../provider/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: 'voicestudio: sem a transcrição da voz para achar as partes' };
+        return { ok: true, voz: `voicestudio ${perfil || 'default'}`, segundos: med.segundos, partes: alinharPartes(lista, palavras, med.segundos) };
+    } catch (e) {
+        return { ok: false, error: 'voicestudio: ' + 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/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('../../provider/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 } : {}) };
+}
+
+/* O tom de cada estilo, em UMA frase de instrução, em inglês e terminando em
+   dois-pontos, que é a forma que o Gemini TTS entende como instrução e não
+   como fala. Se ainda vazar, o corte de vazamentoNoComeco tira (as palavras
+   ditas antes do roteiro são quase todas daqui). */
+const DIRECAO_DA_VOZ = {
+    gerativo: 'Read aloud in Brazilian Portuguese as a tech reels narrator: full, warm voice close to the mic, energetic and smiling, no long pauses:',
+    fluido: 'Read aloud in Brazilian Portuguese as a premium product video narrator: confident and close, clean sentences that flow into each other, no ad tone:',
+    personagem: 'Read aloud in Brazilian Portuguese as someone really talking on a podcast: natural and close, never like an announcer:',
+    impacto: 'Read aloud in Brazilian Portuguese as an energetic ad announcer: full voice, strong emphasis on the impact words:',
+    padrao: 'Read aloud in Brazilian Portuguese as a lively tech reels narrator: confident, smiling, emphasis on the words that matter:',
+};
+
+/* A narração com cache (a mesma fala, na mesma direção, não é gerada duas vezes). */
+async function narrarComCache(lista, mp3, { voz, direcao } = {}) {
+    /* 'v3' (11/10): as narrações guardadas com a direção antiga (a que tinha
+       "RÁPIDO" e "contínuas") ficam para trás — reaproveitar uma delas trazia o
+       "Rápido e contínuo." de volta mesmo com a direção nova. */
+    const chave = require('crypto').createHash('sha1').update(JSON.stringify(['v4', 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')) }; }
+    // A voz local pedida (voz: 'kokoro'): direto nela, sem gastar a cota do Gemini.
+    if (kokoro.querKokoro(voz)) return kokoro.narrar(lista, mp3, { voz, uv: acharUv() });
+    // O VoiceStudio local primeiro (15/10); fechado ou falhando, o Gemini.
+    let v = await narrarComVoiceStudio(lista, mp3, { voz });
+    if (!v.ok) 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 PRODUÇÃO (producao.js): cada necessidade — voz, trilha, efeitos — pela
+   corrente de provedores dela, com o cache do projeto. `roteiro.provedores`
+   ({ voz: 'kokoro' }) passa um provedor para a frente, e o caderno guarda
+   quem produziu cada coisa. */
+async function produzirNecessidade(p, roteiro, pedido, provedores) {
+    const r = await producao.produzirUma(pedido, provedores, { escolha: ((roteiro && roteiro.provedores) || {})[pedido.tipo], cache: producao.cacheDe(p.pasta) });
+    projeto.anotar(p.id, 'producao', producao.linhaCaderno(r), { necessidade: pedido.tipo, provedor: r.quem || null, cache: !!r.doCache });
+    return r;
+}
+
+/* A voz como provedores, na ordem do kokoro.ordem: o Gemini (com o cache e a
+   direção dele), o Kokoro local e o Edge. A falha de uma passa para a próxima. */
+function provedoresDeVoz(lista, mp3, arq, voz, vozEdge, { soEdge = false, gemini, escolha } = {}) {
+    const todos = {
+        voicestudio: () => narrarComVoiceStudio(lista, mp3, { voz }),
+        gemini: () => gemini(),
+        kokoro: () => kokoro.narrar(lista, mp3, { voz, uv: acharUv() }),
+        edge: () => {
+            // Ritmo NORMAL: o "citação" (-10%, respiro longo) esticou o vídeo para 125 s.
+            if (!fs.existsSync(arq)) fs.writeFileSync(arq, JSON.stringify(lista.map((x) => ({ ...x, registro: 'normal' }))));
+            return narrarReserva(lista, mp3, arq, voz, vozEdge, { soEdge: true });
+        },
+    };
+    const comResultado = (f) => async () => { const v = await f(); return v && v.ok ? { ...v, arquivo: mp3 } : v; };
+    const ordem = kokoro.ordem(voz, process.env, { soEdge });
+    // A escolhida no roteiro entra mesmo fora da ordem (o produzirUma a põe na frente).
+    if (escolha && todos[escolha] && !ordem.includes(escolha)) ordem.push(escolha);
+    return ordem.map((nome) => ({ nome, gerar: comResultado(todos[nome]) }));
+}
+
+/* A VOZ DE RESERVA, quando o Gemini falha: o Kokoro (local, sem cota) e
+   depois o Edge. A falha de uma passa para a próxima, nunca derruba. */
+function narrarReserva(lista, mp3, arq, voz, vozEdge, { soEdge = false, semKokoro = false } = {}) {
+    const passos = kokoro.ordem(voz, process.env, { soEdge }).filter((n) => n !== 'gemini' && n !== 'voicestudio' && !(semKokoro && n === 'kokoro'));
+    return kokoro.corrente(passos, {
+        kokoro: () => kokoro.narrar(lista, mp3, { voz, uv: acharUv() }),
+        edge: () => rodarPython('narrar.py', ['roteiro', '--arquivo', arq, '--saida', mp3, '--voz', kokoro.vozNoEdge(voz, vozEdge)], { timeout: 10 * 60000 }),
+    });
+}
+
+/* DUAS VOZES (falantes.js): os mp3 de cada falante, um depois do outro, num
+   arquivo só — reamostrados, porque o Gemini sai a 24 kHz e o Edge não. A
+   duração de cada um é MEDIDA: é ela que empurra os tempos do grupo seguinte. */
+async function juntarVozes(arquivos, mp3) {
+    const fil = arquivos.map((_, i) => `[${i}:a]aresample=44100,aformat=channel_layouts=mono[a${i}]`).join(';')
+        + ';' + arquivos.map((_, i) => `[a${i}]`).join('') + `concat=n=${arquivos.length}:v=0:a=1[s]`;
+    const c = await video.rodar(video.ffmpeg(), ['-y', ...arquivos.flatMap((a) => ['-i', a]), '-filter_complex', fil, '-map', '[s]',
+        '-c:a', 'libmp3lame', '-q:a', '3', mp3], { timeout: 120000 });
+    if (!c.ok) return { ok: false, error: 'não consegui juntar as vozes' };
+    const duracoes = [];
+    for (const a of arquivos) duracoes.push((await video.medir(a)).segundos);
+    return { ok: true, duracoes };
+}
+
+/* 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/config').loadConfig();
+        const r = await require('../../provider/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);
+    /* Termo sorteado e resultado sorteado, sem repetir os últimos: o primeiro
+       resultado do termo fixo era o mesmo whoosh em todo vídeo (02/10). */
+    const sons = { ...sint };
+    for (const nome of ['teclado', 'whoosh', 'impacto', 'sala']) {
+        for (const termo of variedade.termosSfx(nome)) {
+            if (sons[nome] !== sint[nome]) break;
+            try {
+                const b = await assets.procurarSom(termo, { quantas: 10, livre: true });
+                for (const item of variedade.ordenar(b.ok ? b.sons : [], 'sfx').slice(0, 3)) {
+                    const d = await assets.baixar(item, { pasta: p.pasta, nome: 'sfx-real-' + nome });
+                    if (d.ok) { sons[nome] = d.relativo; variedade.marcar('sfx', item.url); 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] };
+/* A proporção que o PEDIDO disse (14/10: "vertical 9:16" saiu deitado, porque
+   só valia a proporção que o modelo passasse). A do modelo ainda manda. */
+function proporcaoDoPedido(pedido) {
+    const t = String(pedido || '');
+    if (/\b9\s*[:x×]\s*16\b|\bvertical\b|\breels?\b|\bstor(y|ies)\b|\btik\s?tok\b|\bshorts\b/i.test(t)) return '9:16';
+    if (/\b4\s*[:x×]\s*5\b/.test(t)) return '4:5';
+    if (/\b1\s*[:x×]\s*1\b|\bquadrad[oa]\b/i.test(t)) return '1:1';
+    return null;
+}
+
+/** O roteiro vira plano: baixa o que falta, narra, e chama o compositor. */
+/* A ASSINATURA (assinatura.js): o vídeo é medido e conferido contra as
+   faixas do estilo; o que saiu volta para o agente e fica no caderno. */
+function conferirAssinatura(p, r, nome) {
+    const fora = assinatura.descrever(assinatura.conferir(nome, assinatura.medir(r.partitura, r.plano)).fora);
+    r.resumo.assinatura = { nome, seguiu: !fora.length, fora: fora.length ? fora : undefined };
+    projeto.anotar(p.id, 'assinatura', fora.length ? `fora da assinatura ${nome}: ${fora.join('; ')}` : `seguiu a assinatura ${nome}`);
+}
+
+/* A REFERÊNCIA VISUAL que a pessoa manda (13/10: "não usa as referências
+   que mandei" — era o print da landing, arrastado no pedido). O agente não
+   enxerga imagem; aqui ela entra no projeto, as cores saem pelo ffmpeg e, se o
+   projeto ainda não tem marca, viram a marca. Com site, o site manda. */
+function importarReferencia(p, arquivo) {
+    const orig = String(arquivo || '').trim().replace(/^file:\/\//, '');
+    if (!orig || !fs.existsSync(orig)) return { ok: false, error: 'mande em "arquivo" o caminho da imagem de referência.' };
+    const nome = path.basename(orig).normalize('NFD').replace(/[\u0300-\u036f]/g, '').replace(/[^\w.-]+/g, '-');
+    const destino = path.join(p.pasta, 'midia', 'referencias', nome);
+    fs.mkdirSync(path.dirname(destino), { recursive: true });
+    fs.copyFileSync(orig, destino);
+    const rel = path.relative(p.pasta, destino).replace(/\\/g, '/');
+    const cores = marcaLib.coresDaImagem(destino);
+    const temMarca = !!(p.marca && Object.keys(marcaLib.marcaEmObjeto(p.marca).cores || {}).length);
+    const salvar = { referencias: [...(p.referencias || []).filter((x) => x.src !== rel), { src: rel, cores, de: orig }] };
+    if (!temMarca && cores.length) salvar.marca = { ...(p.marca || {}), ...marcaLib.marcaEmObjeto({ cores }) };
+    projeto.salvar(p.id, salvar);
+    projeto.anotar(p.id, 'referencia', `imagem ${rel}: ${cores.join(' ') || 'sem cor'}${temMarca ? '' : ' (virou a marca)'}`);
+    return {
+        ok: true, src: rel, cores, viraMarca: !temMarca && cores.length > 0,
+        comoUsar: (temMarca ? 'O projeto já tem a marca do site: ela manda nas cores; a referência guia o JEITO (composição, peso, o que aparece). '
+            : 'Estas cores viraram a marca do projeto. ')
+            + 'Se a imagem é print do site ou do produto, o vídeo mostra a tela de verdade (estudio_midia acao:"print" e a peça printsite).',
+    };
+}
+
+async function prepararRoteiro(p, args) {
+    const roteiro = typeof args.roteiro === 'string' ? JSON.parse(args.roteiro) : args.roteiro;
+    // O mesmo args (não uma cópia): o __semNarracao e o __cenasQuebradas voltam para quem chamou.
+    if (Array.isArray(roteiro)) { args.roteiro = { partes: roteiro }; return prepararRoteiro(p, args); }
+    /* 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; }
+    }
+    /* A CENA QUE A IA ESCREVEU (parte.componente): ela escreve na pasta de
+       trabalho, e o Remotion só lê o que está no projeto. O arquivo é copiado
+       para componentes/ do projeto; se não existe, a parte fica no estilo da
+       casa (e o caderno diz por quê), em vez de o render quebrar. */
+    for (const pt of roteiro.partes || []) {
+        if (!pt || typeof pt.componente !== 'string' || !pt.componente.trim()) continue;
+        const pedido = pt.componente.trim();
+        const achado = [path.resolve(p.pasta, pedido), args.__pasta && path.resolve(args.__pasta, pedido), path.isAbsolute(pedido) && pedido]
+            .find((f) => f && fs.existsSync(f) && /\.(jsx|tsx|js)$/i.test(f));
+        if (!achado) { projeto.anotar(p.id, 'plano', `componente ${pedido} não existe: a parte ficou no estilo da casa`); delete pt.componente; continue; }
+        const dentro = path.resolve(p.pasta) + path.sep;
+        if (!achado.startsWith(dentro)) {
+            const destino = path.join(p.pasta, 'componentes', path.basename(achado));
+            fs.mkdirSync(path.dirname(destino), { recursive: true });
+            fs.copyFileSync(achado, destino);
+            pt.componente = path.relative(p.pasta, destino).replace(/\\/g, '/');
+        } else pt.componente = path.relative(p.pasta, achado).replace(/\\/g, '/');
+        // A cena quebrada não derruba o vídeo: sai, a parte fica no gerativo, e o erro volta para a IA (cena.js).
+        const conf = conferirCena(path.join(p.pasta, pt.componente));
+        if (!conf.ok) {
+            (args.__cenasQuebradas = args.__cenasQuebradas || []).push({ componente: pt.componente, erro: conf.erro });
+            projeto.anotar(p.id, 'plano', `componente ${pt.componente} quebrado (${conf.erro}): a parte ficou no gerativo`);
+            delete pt.componente;
+        }
+    }
+    // As imagens do pedido (o terminal guardou em referencias.imagens) entram sozinhas, uma vez por projeto.
+    const jaTem = new Set((p.referencias || []).map((x) => x.de));
+    const novas = referencias.imagens().filter((f) => !jaTem.has(f));
+    for (const f of novas) { try { importarReferencia(p, f); } catch (e) { projeto.anotar(p.id, 'referencia', `não importou ${path.basename(f)}: ${e.message}`); } }
+    if (novas.length) p = projeto.ler(p.id) || p;
+    /* O KIT DE MARCA ativo (lib/plugin/marca-kit.js) vale mais que a marca lida do
+       site: a pessoa criou uma vez e quer em todo vídeo. O roteiro ainda ganha. */
+    const kitM = marcaKit.preencher({}, { pastas: [p.pasta, process.cwd()] });
+    if (kitM.kit) { p = { ...p, marca: kitM }; }
+    if (roteiro.marca) {
+        /* A do roteiro por cima da do site, CAMPO A CAMPO: antes o "cores" em
+           lista do agente apagava o {fundo, destaque} lido do site (13/10). */
+        const site = marcaLib.marcaEmObjeto(p.marca), dele = marcaLib.marcaEmObjeto(roteiro.marca);
+        roteiro.marca = { ...site, ...dele, cores: { ...(site.cores || {}), ...(dele.cores || {}) }, fontes: { ...(site.fontes || {}), ...(dele.fontes || {}) } };
+        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 (estilo.js). O padrão é MOTION (motion.js): um plano contínuo
+       em 3D — "isso sim é motion" (Joel, 28/09). Explicação vira VOX
+       (editorial, tinta sobre papel), marca vira MARCA (brand reveal),
+       lançamento de produto vira LANCAMENTO, anúncio e reels vão para o
+       IMPACTO. O que o agente pediu vale mais que tudo. */
+    const pedidoTxt = `${p.pedido || ''} ${args.pedido || ''}`;
+    const ref = referencias.atual();
+    /* Sem imagem é o padrão (07/10): sem o pedido dizer, nada de foto nem
+       vídeo de fora. Ninguém escolheu o estilo? Ele gira (estilo.js) — sem
+       imagem, só entre os que não vivem de foto. O híbrido e o cinema, pedidos
+       pelo nome sem imagem, caem para o gerativo (sem nada baixado). */
+    const semImagem = referencias.semImagem(ref);
+    let estilo = escolherEstilo({ pedido: pedidoTxt, agente: args.estilo, roteiro: roteiro.estilo, girar: true, semImagem });
+    if (semImagem && (estilo === 'hibrido' || estilo === 'cinema')) estilo = 'gerativo';
+    /* SEM NARRAÇÃO (14/10, "só o motion e os efeitos sonoros, os barulhinhos"):
+       roteiro.semNarracao ou o pedido. O cinema e o híbrido vivem da voz: caem no gerativo. */
+    const semVoz = semNarracao.ativo(roteiro, pedidoTxt);
+    if (semVoz && (estilo === 'hibrido' || estilo === 'cinema')) estilo = 'gerativo';
+    /* "O vídeo deve ter um 3D do fone" (30/09): pedido de 3D vira o gerativo
+       com o produto modelado girando numa batida (kit/tres.jsx) — a menos que
+       o agente tenha escolhido outro estilo pelo nome. */
+    if (/\b3\s?d\b|tridimensional/i.test(pedidoTxt) && estilo !== 'personagem' && (!args.estilo || estilo === 'gerativo' || estilo === 'lancamento')) {
+        // O 3D mora numa batida do gerativo; o lançamento antigo, só pelo nome.
+        if (!args.estilo && estilo !== 'lancamento') estilo = 'gerativo';
+        if (!roteiro.modelo3d) roteiro.modelo3d = variacao3d.modeloDoPedido(pedidoTxt);
+    }
+    // O bicho do vídeo 3D não fala com voz de gente (a menos que o pedido peça): sai da narração e fica na cena.
+    if (estilo === 'personagem') {
+        const calados = personagem.calarBichos(roteiro, pedidoTxt);
+        if (calados.length) projeto.anotar(p.id, 'plano', `sem fala (bicho): ${calados.map((c) => `${c.nome} (${c.especie})`).join(', ')} — fica na cena; para falar, peça "${calados[0].especie} falante"`);
+    }
+    // O 3D de cada vídeo: acabamento, câmera, luz e ritmo sorteados sem repetir os últimos.
+    /* Por PROJETO, não por chamada: mandar o roteiro de novo para ajustar uma
+       frase não pode sortear outro 3D nem outro vídeo. Projeto novo, sorteio novo. */
+    if (roteiro.modelo3d && !roteiro.variacao3d) {
+        roteiro.variacao3d = p.variacao3d || variacao3d.escolherVariacao3d();
+        if (!p.variacao3d) projeto.salvar(p.id, { variacao3d: roteiro.variacao3d });
+    }
+    /* A SEMENTE do gerativo saía do texto do roteiro: o mesmo roteiro dava o
+       mesmo vídeo, batida por batida (05/10). Sem semente do roteiro, cada
+       projeto sorteia a sua. */
+    if (estilo === 'gerativo' && roteiro.semente == null) {
+        roteiro.semente = p.semente != null ? p.semente : Math.floor(Math.random() * 1e9);
+        if (p.semente == null) projeto.salvar(p.id, { semente: roteiro.semente });
+    }
+    /* O humor, a paleta, as fontes e o gênero do gerativo, com memória entre
+       vídeos (09/10, "vício em cores, músicas, fontes"): por PROJETO, como a semente. */
+    // O assunto do vídeo é o rótulo da moldura (quando ela sai): o título do projeto.
+    if (estilo === 'gerativo' && !roteiro.titulo && p.titulo) roteiro.titulo = p.titulo;
+    // O estilo que a IA montou (estilos.js) vence o sorteio e o que o projeto tinha guardado.
+    if (estilo === 'gerativo' && roteiro.estiloVisual && !roteiro.escolhasGerativo) {
+        const r = estilos.montar(roteiro.estiloVisual, roteiro);
+        roteiro.escolhasGerativo = r.escolhas;
+        projeto.salvar(p.id, { escolhasGerativo: r.escolhas });
+        if (r.avisos.length) projeto.anotar(p.id, 'estilo', r.avisos.join(' · '));
+    }
+    if (estilo === 'gerativo' && !roteiro.escolhasGerativo) {
+        roteiro.escolhasGerativo = p.escolhasGerativo || gerativo.escolherVisual(roteiro);
+        if (!p.escolhasGerativo) projeto.salvar(p.id, { escolhasGerativo: roteiro.escolhasGerativo });
+    }
+    /* O ESTILO DA CASA (13/10, o primocode-ele-constroi.mp4 que o Joel aprovou):
+       chão escuro com brilho, frase média, palavra que entra desfocando, Inter
+       e JetBrains Mono. Vale para o vídeo de TECNOLOGIA (o do PrimoCode) quando
+       a IA não montou estilo: em todo vídeo, a padaria saía igual — "animações
+       tudo igual, cores sempre as mesmas, sem ícones" (14/10). */
+    const casa = estilo === 'gerativo' && !roteiro.estiloVisual && (roteiro.escolhasGerativo || {}).humor === 'tecnologia';
+    if (casa && !/\bfontes?\b|tipografia|\bserifa/i.test(pedidoTxt)) {
+        roteiro.marca = { ...(roteiro.marca || {}), fontes: { titulo: 'Inter', texto: 'JetBrains Mono' } };
+    }
+    if (casa) roteiro.casa = true;
+    if (ref.modo === 'fechado' && !roteiro.busca && referencias.termos().length) roteiro.busca = referencias.termos();
+    /* A BIBLIOTECA (biblioteca.js): sem fonte e cor da marca, o híbrido, o
+       cinema e o impacto caíam sempre no Inter e no azul e roxo — "os vídeos
+       todos iguais" (02/10). A marca manda; depois o roteiro.visual da IA;
+       sem nada, o sorteio que pula o que os últimos vídeos usaram. */
+    if (['hibrido', 'cinema', 'impacto'].includes(estilo)) {
+        const v = biblioteca.vestir(roteiro, { estilo });
+        if (v.mudou) projeto.anotar(p.id, 'visual', [v.titulo && `fonte ${v.titulo} + ${v.texto} (tom ${v.tom})`, v.paleta && `paleta ${v.paleta}`].filter(Boolean).join(', '));
+    }
+    // Os estilos de motion usam os efeitos leves e a trilha do ende.app; os de corte, os cheios.
+    const ehMotion = LEVES.has(estilo);
+    const modo = (args.modo || roteiro.modo || (p.formato === 'slides' || p.formato === 'arte' ? 'slides' : 'video'));
+    const [largura, altura] = PROPORCOES[roteiro.proporcao || args.proporcao] || (modo === 'video' && PROPORCOES[proporcaoDoPedido(p.pedido)]) || 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 (semImagem || 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 && !semImagem) {
+        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;
+    /* O HÍBRIDO (hibrido.js) é o cinema com o kit por cima: o roteiro de
+       qualquer estilo vira os tipos do cinema aqui, antes da voz — a voz lê
+       o que o cinema vai mostrar. */
+    let hib = null;
+    if (modo === 'video' && estilo === 'hibrido') {
+        hib = hibrido.traduzir(roteiro);
+        partes.splice(0, partes.length, ...hib.roteiro.partes);
+    }
+    if (modo === 'video' && (estilo === 'cinema' || estilo === 'hibrido')) {
+        // 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 comVoz = partes.filter((pt) => pt.tipo !== 'depoimento' && cinema.falaDe(pt) !== '' && !pt.falaForte);
+        const lista = comVoz.map((pt) => ({ texto: cinema.falaDe(pt), registro: 'normal' }));
+        // Duas vozes: a voz de cada parte pelo falante dela (roteiro.vozes).
+        const vozesL = falantes.vozesDasPartes(comVoz, roteiro, args.voz || roteiro.voz);
+        const variasVozes = new Set(vozesL).size > 1;
+        const DIRECAO_CINEMA = '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.';
+        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 (variasVozes) {
+            /* Um grupo por falante, cada um com a sua voz e o seu cache (a chave
+               do narrarComCache leva a voz). Falhou? Fica anotado, e a reserva
+               de baixo narra numa voz só — melhor o vídeo do que nada. */
+            v = await falantes.narrarPorFalante(lista.map((x, i) => ({ ...x, voz: vozesL[i] })), mp3, { juntar: juntarVozes,
+                narrarUm: async (l, m, voz) => {
+                    const g = soEdge ? { ok: false } : await narrarComCache(l, m, { voz, direcao: DIRECAO_CINEMA });
+                    if (g.ok) return g;
+                    const a = m.replace(/\.mp3$/, '.json');
+                    fs.writeFileSync(a, JSON.stringify(l));
+                    return narrarReserva(l, m, a, voz, 'antonio', { soEdge });
+                } });
+            if (!v.ok) projeto.anotar(p.id, 'narracao', `as duas vozes falharam (${v.error}); saiu numa voz só`);
+            if (!v.ok) {
+                const arq = path.join(p.pasta, 'midia', `roteiro-${Date.now().toString(36)}.json`);
+                fs.writeFileSync(arq, JSON.stringify(lista.map((x) => ({ ...x, registro: 'normal' }))));
+                v = await narrarReserva(lista, mp3, arq, args.voz || roteiro.voz, 'antonio', { soEdge });
+            }
+        } else {
+            const arq = path.join(p.pasta, 'midia', `roteiro-${Date.now().toString(36)}.json`);
+            const gemini = async () => {
+                if (fs.existsSync(cacheMp3) && fs.existsSync(cacheJson)) {
+                    fs.copyFileSync(cacheMp3, mp3);
+                    const g = { ok: true, ...JSON.parse(fs.readFileSync(cacheJson, 'utf8')), doCache: true };
+                    // Cache sem as palavras (vindo de um plano antigo): transcreve de novo e realinha — sem gastar voz.
+                    if (!(g.partes || []).some((pt) => (pt.palavras || []).length)) {
+                        try {
+                            const cfg = require('../../config/config').loadConfig();
+                            const tr = await require('../../provider/api').requestTranscricao(cfg.server, { token: cfg.token, audio: fs.readFileSync(mp3).toString('base64'), nome: 'voz.mp3', idioma: 'pt' });
+                            if (tr && (tr.palavras || []).length) {
+                                g.partes = alinharPartes(lista, tr.palavras, g.segundos);
+                                fs.writeFileSync(cacheJson, JSON.stringify({ voz: g.voz, segundos: g.segundos, partes: g.partes }));
+                            }
+                        } catch { /* fica o alinhamento guardado */ }
+                    }
+                    return g;
+                }
+                const g = await narrarComGemini(lista, mp3, { voz: args.voz || roteiro.voz, direcao: DIRECAO_CINEMA });
+                if (g.ok) {
+                    try { fs.mkdirSync(cacheDir, { recursive: true }); fs.copyFileSync(mp3, cacheMp3); fs.writeFileSync(cacheJson, JSON.stringify({ voz: g.voz, segundos: g.segundos, partes: g.partes })); } catch { /* sem cache */ }
+                }
+                return g;
+            };
+            v = await produzirNecessidade(p, roteiro, { tipo: 'voz', chave: [lista.map((x) => x.texto), args.voz || roteiro.voz || '', 'cinema-v1', soEdge], destino: mp3 },
+                provedoresDeVoz(lista, mp3, arq, args.voz || roteiro.voz, 'antonio', { soEdge, gemini, escolha: (roteiro.provedores || {}).voz }));
+        }
+        if (!v.ok) return v;
+        /* A DURAÇÃO que o roteiro pede ("60–75 s"): se a voz passa do que cabe,
+           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);
+                }
+            }
+        }
+        /* No HÍBRIDO a voz anda um pouco mais rápido por padrão (1,12×, como no
+           vox): o trailer premium do cinema lido pelo Gemini sai no passo de
+           leitura, e o vídeo segue a voz. `roteiro.ritmoVoz` ajusta. */
+        if (hib && ritmoVoz <= 1.01) {
+            const kh = Math.max(1, Math.min(1.5, Number(roteiro.ritmoVoz) || 1.12));
+            const rapido = mp3.replace(/\.mp3$/, '-h.mp3');
+            const c = kh > 1.01 ? await video.rodar(video.ffmpeg(), ['-y', '-i', mp3, '-filter:a', `atempo=${kh.toFixed(3)}`, rapido], { timeout: 120000 }) : { ok: false };
+            if (process.env.PRIMOCODE_TRACO === '1') process.stderr.write(`[traço] voz do híbrido ${kh}× ok=${c.ok} existe=${fs.existsSync(rapido)} ${String(c.erro || '').slice(-120)}\n`);
+            if (c.ok && fs.existsSync(rapido)) {
+                fs.renameSync(rapido, mp3);
+                ritmoVoz = kh;
+                const div = (x) => Math.round((x / kh) * 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}`);
+        /* A chave leva o id do projeto e o hash das falas. Só `cinema` fazia um
+           roteiro novo, no mesmo projeto, reaproveitar os efeitos do anterior. */
+        const marcaSfx = require('crypto').createHash('sha1').update(JSON.stringify({ id: p.id || '', falas: partes.map((pt) => cinema.falaDe(pt)) })).digest('hex').slice(0, 16);
+        const sonsC = (await produzirNecessidade(p, roteiro, { tipo: 'sfx', chave: [p.id || '', marcaSfx] },
+            [{ nome: 'openverse', gerar: async () => ({ sons: await sonsReais(p, video) }) }])).sons || {};
+        // Vários termos e durações: vídeo sem música foi o que saiu na primeira vez (25/09).
+        // E só instrumental: "essa música daria pra deixar só o instrumental?" — a faixa é OUVIDA.
+        // O termo sai do clima do roteiro (variedade.js), não de uma lista fixa de "cinematic inspiring".
+        let trilhaC = (await produzirNecessidade(p, roteiro, { tipo: 'trilha', chave: ['cinema', roteiro.clima || '', roteiro.genero || ''] },
+            [{ nome: 'jamendo', gerar: async () => {
+                for (const termo of [...variedade.termosTrilha(roteiro, 'cinema'), 'instrumental']) {
+                    try {
+                        const b = await assets.procurarMusica(termo, { quantas: 10, duracaoMin: 45 });
+                        for (const item of variedade.ordenar(b.ok ? b.sons : [], 'trilha').filter((x) => !/vocal|voice|feat|ft\.|remix/i.test(x.titulo || '')).slice(0, 4)) {
+                            const d = await assets.baixar(item, { pasta: p.pasta, nome: 'trilha' });
+                            if (!d.ok) continue;
+                            if (await temLetra(path.join(p.pasta, d.relativo))) { projeto.anotar(p.id, 'midia', `trilha com voz descartada: ${item.titulo}`); continue; }
+                            variedade.marcar('trilha', item.url);
+                            const credito = `"${termo}": ${item.titulo} — ${item.autor || 'Jamendo'} (${item.licenca || 'CC'})`;
+                            projeto.anotar(p.id, 'trilha', credito);
+                            return { src: d.relativo, credito };
+                        }
+                    } catch { /* o próximo termo */ }
+                }
+                return null;
+            } }])).src || null;
+        /* A MÚSICA mais baixa na origem: a faixa vem masterizada alta e comprimida,
+           e mesmo a 30% ela cobria a voz e o depoimento ("a música tá muito
+           alta, não dá pra ouvir as pessoas", 25/09). Ela vai a -28 LUFS antes
+           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 }));
+        /* O B-ROLL do híbrido: o cinema vive de foto que troca por baixo do
+           texto, e o acervo da marca raramente passa de meia dúzia. Vídeo de
+           banco primeiro (o fundo que se move sozinho), foto como reserva —
+           em paralelo, porque são oito buscas. */
+        /* Foto de compartilhamento (og:image) e logo trazem o NOME da marca em
+           letra gigante: como fundo, viravam um "THRO" cortado atrás do texto. */
+        /* E arte de banner (2400×1260 e afins): é o logo da marca desenhado, não
+           uma cena — cortada no vídeo em pé, vira um "✳ Cl" gigante. */
+        const banner = (alt) => { const m = /(\d{3,4})x(\d{3,4})/.exec(alt || ''); return m && Number(m[1]) / Number(m[2]) > 1.7 && altura > largura; };
+        if (hib) for (let q = fotosC.length - 1; q >= 0; q--) if (/open graph|og[:_ -]?image|\blogo|banner|wordmark/i.test(fotosC[q].alt || '') || banner(fotosC[q].alt)) fotosC.splice(q, 1);
+        if (hib && fotosC.length < 14) {
+            const orientacao = largura >= altura ? 'landscape' : 'portrait';
+            const pastaMidia = path.join(p.pasta, 'midia');
+            const jaTem = (() => { try { return fs.readdirSync(pastaMidia); } catch { return []; } })();
+            const cat = (termo) => (/screen|code|data|server|dashboard/i.test(termo) ? 'tela' : 'pessoas');
+            /* A versão LEVE do b-roll: o Pexels entrega 1080×1920 inteiro (até 30
+               MB e 20 s), e o render parava num quadro esperando vários vídeos
+               assim ao mesmo tempo (medido: timeout de 120 s no quadro 184). Cada
+               um vira 8 s, 720 de largura, sem áudio — e fica guardado, para o
+               próximo render não baixar de novo. */
+            const leve = async (rel, destino) => {
+                const alvo = path.join(pastaMidia, destino);
+                const escala = largura >= altura ? 'scale=1280:-2' : 'scale=720:-2';
+                const c = await video.rodar(video.ffmpeg(), ['-y', '-i', path.join(p.pasta, rel), '-t', '8', '-vf', escala + ',fps=30', '-an',
+                    '-c:v', 'libx264', '-preset', 'veryfast', '-crf', '24', '-pix_fmt', 'yuv420p', '-movflags', '+faststart', alvo], { timeout: 180000 });
+                if (!c.ok || !fs.existsSync(alvo)) return null;
+                try { fs.unlinkSync(path.join(p.pasta, rel)); } catch { /* fica o original */ }
+                return 'midia/' + destino;
+            };
+            // banco: true marca o que veio do banco (Pexels): a rota produto prefere a tela da marca (hibrido.ancorar).
+            const achados = await Promise.all(hibrido.termosDeBusca(roteiro, hib.extras).map(async (termo) => {
+                const out = [];
+                const slug = 'broll-' + String(termo).toLowerCase().replace(/[^a-z0-9]+/g, '-').replace(/^-|-$/g, '');
+                const proxy = `${slug}.leve.mp4`;
+                if (jaTem.includes(proxy)) out.push({ src: 'midia/' + proxy, tipo: 'video', cat: cat(termo), alt: termo, banco: true });
+                else try {
+                    // Sorteado entre os não usados, com o termo variado (variedade.js, 05/10).
+                    const itens = await variedade.buscarSemRepetir(async (t) => {
+                        const b = await assets.procurarVideos(t, { quantas: 8, orientacao });
+                        return (b.ok ? b.videos : []).filter((v) => !v.duracao || v.duracao >= 4);
+                    }, termo);
+                    for (const item of itens.slice(0, 1)) {
+                        const d = await assets.baixar(item, { pasta: p.pasta, nome: slug });
+                        const l = d.ok ? await leve(d.relativo, proxy) : null;
+                        if (l) { out.push({ src: l, tipo: 'video', cat: cat(termo), alt: termo, banco: true }); variedade.marcar('broll', item.url); }
+                    }
+                } catch { /* segue com a foto */ }
+                const foto = jaTem.find((f) => f.startsWith(slug + '-') && /\.(jpe?g|png|webp)$/i.test(f));
+                if (foto) out.push({ src: 'midia/' + foto, tipo: 'imagem', cat: cat(termo), alt: termo, banco: true });
+                else try {
+                    const itens = await variedade.buscarSemRepetir(async (t) => {
+                        const b = await assets.procurarImagens(t, { quantas: 8, orientacao });
+                        return b.ok ? b.imagens : [];
+                    }, termo);
+                    for (const item of itens.slice(0, 1)) {
+                        const d = await assets.baixar(item, { pasta: p.pasta, nome: slug });
+                        if (d.ok) { out.push({ src: d.relativo, tipo: 'imagem', cat: cat(termo), alt: termo, banco: true }); variedade.marcar('broll', item.url); }
+                    }
+                } catch { /* sem */ }
+                return out;
+            }));
+            const novos = achados.flat();
+            // Intercalados com as da marca: a foto da marca não pode ficar toda no começo.
+            const marcaF = fotosC.splice(0);
+            for (let q = 0; q < Math.max(marcaF.length, novos.length); q++) {
+                if (novos[q]) fotosC.push(novos[q]);
+                if (marcaF[q]) fotosC.push(marcaF[q]);
+            }
+            projeto.anotar(p.id, 'midia', `b-roll do híbrido: ${novos.filter((f) => f.tipo === 'video').length} vídeos e ${novos.filter((f) => f.tipo === 'imagem').length} fotos`);
+        }
+        const rostos = await acharRostos(p, fotosC.filter((f) => f.tipo !== 'video').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';
+                // A voz forte é a de quem fala a parte (duas vozes), não sempre a do narrador.
+                const vozForte = falantes.vozesDasPartes([pt], roteiro, args.voz || roteiro.voz)[0];
+                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(vozForte || 'antonio')], { timeout: 5 * 60000 });
+                })() : await narrarComCache([{ texto: textoForte }], arqF, { voz: vozForte,
+                    // 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, ritmoLeitura: hib ? 0.55 : 1 });
+        if (r.ok && hib) {
+            hibrido.enfeitar(r.plano, { extras: hib.extras, partes, marca: roteiro.marca || {}, largura, altura, hud: roteiro.hud === true, particulas: roteiro.particulas === true,
+                // O b-roll de cada frase troca 0,2 s depois da palavra-âncora (hibrido.ancorar).
+                tempos: v.partes, fortes, fotos: fotosC });
+            r.resumo.estilo = 'hibrido';
+        }
+        if (r.ok) projeto.anotar(p.id, 'plano', `estilo ${hib ? 'hibrido' : 'cinema'}: ${r.resumo.cenas} cenas, ${r.resumo.segundos}s`);
+        return r;
+    }
+    if (modo === 'video' && semVoz) {
+        /* Sem voz, sem tempo medido: cada parte dura o `duracao` dela (ou o que o
+           texto da tela pede), e as palavras são repartidas na parte. Os sons
+           leves entram depois do plano, em cada corte e entrada (sem-narracao.js). */
+        tempos = semNarracao.tempos(partes, { falaDe: composicao.falaDe });
+        args.__semNarracao = { tempos, cues: semNarracao.cuesDe(partes, tempos) };
+        const total = tempos.length ? tempos[tempos.length - 1].ate : 0;
+        projeto.anotar(p.id, 'narracao', `sem narração: ${Math.round(total * 10) / 10}s em ${partes.length} partes, só motion e efeitos sonoros`);
+        sons = estilo === 'gerativo' ? {} : ehMotion ? sonsLeves.preparar(p.pasta) : await edicao.prepararSons(p.pasta, video);
+    }
+    if (modo === 'video' && !semVoz) {
+        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.
+        // Com cache: refazer o vídeo (outro estilo, outra proporção) não gasta a cota da voz.
+        /* A DIREÇÃO DA VOZ. O servidor manda a direção e o texto no MESMO pedido,
+           e o Gemini às vezes lê o começo dela em voz alta: todo vídeo do fluido
+           abria com "Rápido e contínuo." (11/10, "em tudo ela coloca isso, pode
+           ser um negócio de padaria"). Então a direção é curta, descreve só o
+           TOM, e não tem palavra solta que soe como a primeira frase de um
+           roteiro ("rápido", "contínuo", caixa alta). A velocidade não vem
+           daqui: vem do atempo (ritmoVoz) depois da voz pronta. */
+        const direcao = DIRECAO_DA_VOZ[estilo] || DIRECAO_DA_VOZ.padrao;
+        /* Uma voz por falante (falantes.js). Com uma voz só, um grupo só: é a
+           narração de sempre, com o mesmo cache. */
+        const vozesL = falantes.vozesDasPartes(partes, roteiro, args.voz || roteiro.voz);
+        let v = await produzirNecessidade(p, roteiro, { tipo: 'voz', chave: [lista.map((x) => x.texto), vozesL, direcao], destino: mp3 }, [{
+            nome: ((roteiro.provedores || {}).voz) || 'estudio',
+            gerar: async () => {
+                let reserva = false, gemini = false;
+                const comLista = lista.map((x, i) => ({ ...x, voz: vozesL[i] }));
+                const pelaReserva = async (l, m, voz) => {
+                    // O Kokoro pedido já foi tentado no narrarComCache: a reserva não repete.
+                    const a = m === mp3 ? arq : m.replace(/\.mp3$/, '.json');
+                    if (a !== arq) fs.writeFileSync(a, JSON.stringify(l));
+                    const rr = await narrarReserva(l, m, a, voz, 'thalita', { semKokoro: kokoro.querKokoro(voz) });
+                    if (rr && rr.ok) reserva = true;
+                    return rr;
+                };
+                let r = await falantes.narrarPorFalante(comLista, mp3, { juntar: juntarVozes,
+                    narrarUm: async (l, m, voz) => {
+                        const g = await narrarComCache(l, m, { voz, direcao });
+                        if (g.ok) { gemini = true; return g; }
+                        return pelaReserva(l, m, voz);
+                    } });
+                /* UMA VOZ SÓ POR VÍDEO (11/10, "os personagens falam com vozes
+                   diferentes em cada cena"): a cota do Gemini acabava no meio, e o
+                   mesmo personagem saía Gemini numa fala e reserva na outra. Se
+                   misturou, o vídeo inteiro é refeito na reserva — pior que o
+                   Gemini, mas cada um com a mesma voz do começo ao fim. */
+                if (r && r.ok && reserva && gemini) {
+                    gemini = false;
+                    r = await falantes.narrarPorFalante(comLista, mp3, { juntar: juntarVozes, narrarUm: pelaReserva });
+                }
+                /* A voz de RESERVA (Kokoro/Edge, quando o Gemini falhou) não vai para o
+                   cache do projeto: guardada, ela voltava em todo refazer do mesmo
+                   texto, mesmo com o Gemini de pé — era a "voz robótica que não sai"
+                   (11/10). Na próxima vez o Gemini é tentado de novo. */
+                return r && r.ok ? { ...r, arquivo: mp3, ...(reserva ? { naoGuardar: true } : {}) } : r;
+            },
+        }]);
+        if (!v.ok) return v;
+        /* O RITMO DA VOZ. Mesmo com a direção, a voz sai no passo de leitura, e
+           o vídeo — que segue a voz palavra por palavra — sai lento junto. O
+           áudio acelera 1,12× (1,3× ficou corrido demais, 29/09; atempo não muda o tom) e cada tempo de palavra
+           acompanha; `roteiro.ritmoVoz` ajusta (1 desliga). */
+        // O fluido corre mais ("mais rápido", 06/10): 1,22× por padrão.
+        const ritmo = Math.max(1, Math.min(1.5, Number(roteiro.ritmoVoz || args.ritmoVoz) || (estilo === 'fluido' ? 1.22 : estilo === 'personagem' ? 1.06 : 1.12)));
+        if (ritmo > 1.01) {
+            const rap = mp3.replace(/\.mp3$/, '-r.mp3');
+            const c = await video.rodar(video.ffmpeg(), ['-y', '-i', mp3, '-filter:a', `atempo=${ritmo.toFixed(3)}`, rap], { timeout: 120000 });
+            if (c.ok && fs.existsSync(rap)) {
+                fs.renameSync(rap, mp3);
+                const esc = (x) => (typeof x === 'number' ? Math.round((x / ritmo) * 1000) / 1000 : x);
+                v.segundos = esc(v.segundos);
+                v.partes = (v.partes || []).map((pt) => ({ ...pt, de: esc(pt.de), ate: esc(pt.ate),
+                    palavras: (pt.palavras || []).map((w) => ({ ...w, de: esc(w.de), ate: esc(w.ate) })) }));
+            }
+        }
+        tempos = v.partes;
+        args.__barulhinhos = { tempos, cues: semNarracao.cuesDe(partes, tempos) };
+        narracao = path.relative(p.pasta, mp3).replace(/\\/g, '/');
+        projeto.anotar(p.id, 'narracao', `${v.segundos}s em ${partes.length} partes, voz ${v.voz}`);
+        // O motion usa os efeitos leves; os estilos de corte, os cheios.
+        // O gerativo tem a família de sons DELE (sintetizada da semente); os outros motion, os leves.
+        // O gerativo desenha os sons DEPOIS da partitura (um arquivo por evento, da própria trilha).
+        sons = estilo === 'gerativo' ? {}
+            : ehMotion ? sonsLeves.preparar(p.pasta) : await edicao.prepararSons(p.pasta, video);
+    }
+    // A trilha vale com e sem voz: o vídeo sem narração ainda tem música.
+    if (modo === 'video') {
+        // A trilha do motion: ende.app (CC BY 4.0, sem Content ID), clima tecnologia.
+        if (ehMotion) {
+            try {
+                const segundos = tempos.length ? tempos[tempos.length - 1].ate + 2 : 20;
+                /* O gerativo escolhe o GÊNERO pelo assunto (jazz para o explainer,
+                   funk para o fone, eletrônica para IA…), sorteia a faixa e não
+                   repete as últimas usadas — nada de "inspiring corporate". */
+                let m = null;
+                // A memória da trilha é a da variedade ('trilha'): antes era um arquivo à parte (trilhas-usadas.json).
+                const usadas = variedade.usadas('trilha');
+                const mus = estilo === 'gerativo' ? gerativo.musicaDe(roteiro) : null;
+                /* A trilha do gerativo vem do Jamendo (Openverse), pelo GÊNERO do
+                   assunto, instrumental, sorteada e sem repetir as últimas — a
+                   ende.app fica de reserva ("parar de cair sempre na ende", 30/09). */
+                if (mus) {
+                    const BUSCA = { jazz: 'jazz instrumental', 'lofi-chill-beats': 'lofi hip hop instrumental', electronica: 'electronic instrumental', funk: 'funk instrumental',
+                        'dance-club': 'house instrumental', ambient: 'ambient instrumental', acoustic: 'acoustic guitar instrumental', cinematic: 'cinematic instrumental',
+                        classical: 'piano classical instrumental', 'soul-rnb': 'soul instrumental' };
+                    try {
+                        const b = await assets.procurarMusica(BUSCA[roteiro.genero || mus.genero] || ((roteiro.genero || mus.genero) + ' instrumental'), { quantas: 8, duracaoMin: Math.max(45, segundos + 10) });
+                        // Pelos pontos da variedade: a recente e a muito usada vão para o fim, não somem.
+                        const opcoes = variedade.ordenar((b.ok ? b.sons : []).filter((x) => !/vocal|voice|feat|ft\.|remix/i.test(x.titulo || '')), 'trilha');
+                        for (let k = 0; k < opcoes.length && !m; k++) {
+                            const item = opcoes[k];
+                            const d = await assets.baixar(item, { pasta: p.pasta, nome: 'trilha-' + (roteiro.genero || mus.genero) });
+                            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; }
+                            m = { src: path.join(p.pasta, d.relativo), credito: `Música: ${item.titulo} — ${item.autor || 'Jamendo'} (${item.licenca || 'CC'}, Jamendo)`, id: item.url, segundos: item.segundos };
+                        }
+                    } catch { /* cai na ende.app */ }
+                }
+                if (mus && m) {
+                    variedade.marcar('trilha', m.id);
+                    projeto.anotar(p.id, 'trilha', `gênero ${roteiro.genero || mus.genero} (Jamendo)`);
+                } else if (mus) {
+                    m = await ende.provedor({ pasta: path.join(p.pasta, 'midia') }).gerar({ clima: roteiro.clima || 'energetico', segundos, genero: roteiro.genero || mus.genero, semente: mus.semente, evitar: usadas });
+                    const id = m && Number((/ende-(\d+)\.mp3$/.exec(m.src) || [])[1]);
+                    if (id) variedade.marcar('trilha', id);
+                    if (m) projeto.anotar(p.id, 'trilha', `gênero ${roteiro.genero || mus.genero}`);
+                } else m = await ende.provedor({ pasta: path.join(p.pasta, 'midia') }).gerar({ clima: roteiro.clima || 'tecnologia', segundos });
+                if (m) { trilha = path.relative(p.pasta, m.src).replace(/\\/g, '/'); projeto.anotar(p.id, 'trilha', m.credito); }
+            } catch { /* cai na busca de sempre */ }
+        }
+        // Termo pelo clima e faixa sorteada sem repetir — o "inspiring corporate" fixo era a mesma música em todo vídeo.
+        for (const termo of [args.trilha, ...variedade.termosTrilha(roteiro, estilo)].filter(Boolean)) {
+            if (trilha) break;
+            try {
+                const b = await assets.procurarMusica(termo, { quantas: 10, duracaoMin: 45 });
+                for (const item of variedade.ordenar(b.ok ? b.sons : [], 'trilha').slice(0, 3)) {
+                    const d = await assets.baixar(item, { pasta: p.pasta, nome: 'trilha' });
+                    if (d.ok) { trilha = d.relativo; variedade.marcar('trilha', item.url); projeto.anotar(p.id, 'trilha', `"${termo}": ${item.titulo}`); break; }
+                }
+            } catch { /* o próximo termo */ }
+        }
+    }
+    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;
+    }
+    if (estilo === 'vox' && modo === 'video') {
+        const r = vox.montarVox({ roteiro, largura, altura, tempos, narracao, sons, trilha, imagens });
+        if (r.ok) projeto.anotar(p.id, 'plano', `estilo vox: ${r.resumo.cenas} cenas, ${r.resumo.segundos}s`);
+        return r;
+    }
+    if ((estilo === 'marca' || estilo === 'lancamento') && modo === 'video') {
+        /* As letras em vetor (a peça "vetor") pedem os pontos de verdade da
+           fonte: glifos.js lê o .ttf. Sem rede, o vetor desenha o contorno do
+           próprio texto, sem as alças. */
+        const m = roteiro.marca || {};
+        const nome = m.nome || (partes.find((pt) => pt.tipo === 'logo' || pt.tipo === 'abertura') || {}).titulo || '';
+        const precisa = partes.some((pt) => pt.tipo === 'logo' || pt.visual === 'vetor');
+        const g = precisa ? await glifos.palavra((partes.find((pt) => pt.tipo === 'logo') || {}).titulo || nome,
+            { fonte: (m.fontes && m.fontes.titulo) || (estilo === 'marca' ? 'Plus Jakarta Sans' : 'Inter Tight') }) : null;
+        const r = lancamento.montarLancamento({ roteiro, variante: estilo, largura, altura, tempos, narracao, sons, trilha, imagens, glifos: g });
+        if (r.ok) projeto.anotar(p.id, 'plano', `estilo ${estilo}: ${r.resumo.cenas} cenas, ${r.resumo.segundos}s${precisa ? (g ? ', vetor com os pontos da fonte' : ', vetor sem os pontos (sem a fonte)') : ''}`);
+        return r;
+    }
+    if (estilo === 'gerativo' && modo === 'video') {
+        /* A música a -18 LUFS (a voz sai a -14): os volumes do plano partem
+           daí — cheia no respiro, uns 9 dB abaixo quando a voz fala. */
+        if (trilha && !/-n18\.mp3$/.test(trilha)) {
+            const norm = path.join(p.pasta, 'midia', path.basename(trilha).replace(/\.[a-z0-9]+$/i, '') + '-n18.mp3');
+            /* A introdução da faixa fica de fora (ela começa morna): corta de 12% em
+               diante, com 0,4 s de entrada, no tamanho do vídeo. */
+            let ini = 0;
+            try { const md = await video.medir(path.join(p.pasta, trilha)); const tot = md.segundos || 0; const quer = (tempos.length ? tempos[tempos.length - 1].ate : 30) + 6; if (tot > quer + 8) ini = Math.min(tot * 0.12, tot - quer - 2); } catch { /* do começo */ }
+            const c = fs.existsSync(norm) ? { ok: true } : await video.rodar(video.ffmpeg(), ['-y', ...(ini > 1 ? ['-ss', ini.toFixed(2)] : []), '-i', path.join(p.pasta, trilha),
+                '-af', 'afade=t=in:st=0:d=0.4,loudnorm=I=-18:TP=-2:LRA=11', '-ar', '44100', norm], { timeout: 5 * 60000 });
+            if (c.ok && fs.existsSync(norm)) trilha = path.relative(p.pasta, norm).replace(/\\/g, '/');
+        }
+        /* SEM ÍCONE NENHUM (14/10, a padaria: "sem ícones"): o modelo grátis não
+           dá herói, e o gerativo de comida não tem forma abstrata — o vídeo
+           saía só com texto. Na parte em que o modelo não disse nada (nem
+           "nenhum"), o ícone 3D que É a coisa que a fala nomeia ("pão" → bread). */
+        const autoHerois = [];
+        for (const pt of partes) {
+            if (!pt || pt.heroi != null || pt.icone != null) continue;
+            const id = colecao.melhorIcone3d([pt.titulo, pt.destaque, pt.fala, pt.texto].filter(Boolean).join(' '), 80);
+            if (id && !autoHerois.includes(id)) { pt.heroi = id; autoHerois.push(id); }
+        }
+        if (autoHerois.length) projeto.anotar(p.id, 'icones', `sem herói do modelo, a biblioteca achou: ${autoHerois.join(', ')}`);
+        /* O herói que o roteiro pediu do Iconify ("mdi:bread-slice"): o desenho é
+           baixado aqui (fica em midia/icones); o que não baixar, a batida fica sem. */
+        const icones = {};
+        for (const pt of partes) {
+            const h = typeof (pt.heroi != null ? pt.heroi : pt.icone) === 'string' ? String(pt.heroi != null ? pt.heroi : pt.icone).trim() : '';
+            if (/^(fluent3d|noto):/i.test(h) && !icones[h]) {
+                // O herói da biblioteca: o PNG 3D ou o Lottie, baixado para o projeto.
+                try {
+                    const r = await colecao.baixar(h, { pasta: p.pasta, largura, altura });
+                    if (r.ok) icones[h] = /^noto:/i.test(h) ? { lottie: r.src } : { png: r.src };
+                    else projeto.anotar(p.id, 'icones', `herói ${h} não baixou: ${r.error || '?'}`);
+                } catch { /* fica sem */ }
+                continue;
+            }
+            // O ícone do próprio site (estudio_site guardou os <svg> na marca).
+            const doSite = h.match(/^site:(\d+)$/i);
+            if (doSite) { const x = ((roteiro.marca || {}).iconesSite || [])[Number(doSite[1]) - 1]; if (x && x.svg) icones[h] = x.svg; continue; }
+            if (!/^[a-z0-9-]+:[a-z0-9-]+$/i.test(h) || icones[h]) continue;
+            try { const ic = await assets.icone(h, { pasta: p.pasta }); if (ic && ic.ok) icones[h] = ic.svg; else projeto.anotar(p.id, 'icones', `herói ${h} não baixou: ${(ic && ic.error) || '?'}`); } catch { /* fica sem */ }
+        }
+        const r = gerativo.montarGerativo({ roteiro, largura, altura, tempos, narracao, sons, trilha, icones });
+        if (r.ok) {
+            const feitos = sonsLeves.prepararReceitas(p.pasta, r.somReceitas);
+            // Som que o ffmpeg não conseguiu fazer sai do plano (o vídeo não espera um arquivo que não existe).
+            r.plano.audio.efeitos = r.plano.audio.efeitos.filter((e) => Object.values(feitos).includes(e.src));
+        }
+        if (r.ok) projeto.anotar(p.id, 'plano', `estilo gerativo: ${r.resumo.batidas} batidas (${r.resumo.composicoes.join(' → ')}), ${r.resumo.segundos}s, semente ${r.resumo.semente}`);
+        if (r.ok) conferirAssinatura(p, r, roteiro.assinatura || 'gerativo');
+        return r;
+    }
+    if (estilo === 'fluido' && modo === 'video') {
+        /* A CARA de cada vídeo do fluido, por PROJETO (ajustar uma frase não
+           troca): a semente (marcador, jeito das imagens) e a paleta, que a
+           memória de variedade não repete do vídeo anterior (08/10: "sempre o
+           mesmo azul"). A paleta ou o tema pedidos mandam. */
+        if (roteiro.semente == null) {
+            roteiro.semente = p.semente != null ? p.semente : Math.floor(Math.random() * 1e9);
+            if (p.semente == null) projeto.salvar(p.id, { semente: roteiro.semente });
+        }
+        /* O modelo também vicia: pedia "noite" em todo vídeo (era a primeira da
+           lista). A paleta dele vale, menos quando é uma das 2 últimas usadas —
+           aí vem a menos usada do mesmo tema (escura ou clara). */
+        if (!p.paletaFluido) {
+            const P = fluido.PALETAS, nomes = Object.keys(P);
+            const pedida = P[String(roteiro.paleta || '').toLowerCase()] ? String(roteiro.paleta).toLowerCase() : null;
+            const recentes = variedade.usadas('paleta-fluido').slice(0, 2);
+            const escuro = pedida ? P[pedida].escuro : /escuro|dark/i.test(roteiro.tema || '') ? true : /claro|light/i.test(roteiro.tema || '') ? false : null;
+            let escolha = pedida && !recentes.includes(pedida) ? pedida : null;
+            if (!escolha) escolha = variedade.sortear(nomes.filter((n) => escuro == null || P[n].escuro === escuro), 'paleta-fluido');
+            else variedade.marcar('paleta-fluido', escolha);
+            if (pedida && escolha !== pedida) projeto.anotar(p.id, 'visual', `paleta ${pedida} pedida, mas foi a de um dos últimos vídeos: ${escolha}`);
+            projeto.salvar(p.id, { paletaFluido: escolha });
+            p.paletaFluido = escolha;
+        }
+        roteiro.paleta = p.paletaFluido;
+        // O trio de fontes, também por projeto e sem repetir os últimos vídeos (09/10, "vício em fontes").
+        if (!p.fontesFluido) { p.fontesFluido = fluido.escolherFontes(roteiro.fontesFluido); projeto.salvar(p.id, { fontesFluido: p.fontesFluido }); }
+        roteiro.fontesFluido = p.fontesFluido;
+        /* As IMAGENS do fluido misto, só com imagem pedida: as partes com
+           "busca", no máximo 1 em 3 e espalhadas (fluido.js decide o jeito). */
+        const fotosFluido = {};
+        if (!semImagem) {
+            const comBusca = partes.map((pt, k) => (pt.busca || pt.src ? k : -1)).filter((k) => k >= 0 && (partes[k].tipo !== 'cta'));
+            const teto = Math.max(1, Math.floor(partes.length / 3));
+            const escolhidas = [];
+            for (const k of comBusca) if (escolhidas.length < teto && !escolhidas.some((j) => Math.abs(j - k) < 2)) escolhidas.push(k);
+            for (const k of escolhidas) {
+                const pt = partes[k];
+                // O acervo EDITORIAL (assets.procurarEditorial), não o banco de stock: sem foto que sirva, a parte fica sem imagem.
+                const m = pt.src ? { src: pt.src } : await baixarEditorial(p, pt.busca);
+                if (m && m.src) fotosFluido[k] = { src: m.src };
+            }
+            if (Object.keys(fotosFluido).length) projeto.anotar(p.id, 'midia', `fluido misto: imagem nas partes ${Object.keys(fotosFluido).map((k) => Number(k) + 1).join(', ')}`);
+        }
+        const r = fluido.montarFluido({ imagens: fotosFluido, roteiro: { ...roteiro, pedido: roteiro.pedido || pedidoTxt }, largura, altura, tempos, narracao, sons, trilha });
+        if (r.ok) projeto.anotar(p.id, 'plano', `estilo fluido: ${r.resumo.batidas} batidas${r.resumo.imagens.length ? ` (imagens: ${r.resumo.imagens.join(', ')})` : ''}, paleta ${r.resumo.paleta}, ${r.resumo.segundos}s, batida atrasada no máximo ${r.resumo.atraso}s, palavra atrás da voz no máximo ${r.resumo.sincronia}s`);
+        if (r.ok) conferirAssinatura(p, r, roteiro.assinatura || 'fluido');
+        return r;
+    }
+    if (estilo === 'personagem' && modo === 'video') {
+        const r = personagem.montarPersonagem({ roteiro: { ...roteiro, pedido: roteiro.pedido || pedidoTxt, voz: args.voz || roteiro.voz }, largura, altura, tempos, narracao, sons, trilha });
+        if (r.ok) {
+            /* O que não é peça do catálogo vira ícone 3D da biblioteca, em blocos
+               (kit/mundo.jsx): "uma pizza que fala", "um violão na praia". Sem
+               ícone, a peça sai da cena (e a coisa que fala vira o mascote). */
+            const achados = {};
+            for (const nome of mundo.iconesPendentes(r.partitura)) {
+                const id = colecao.melhorIcone3d(nome, 40);
+                if (!id) continue;
+                const b = await colecao.baixar(id, { pasta: p.pasta, largura, altura }).catch(() => null);
+                if (b && b.ok) achados[nome] = b.src;
+            }
+            mundo.aplicarIcones(r.partitura, achados);
+            mundo.adicionarObjetos(r.partitura, objetosDoRoteiro(roteiro.objetos, p.pasta));
+            const icones = Object.keys(achados);
+            projeto.anotar(p.id, 'plano', `estilo personagem: ${r.resumo.elenco.join(' e ')}${r.resumo.figurantes.length ? ` (+ ${r.resumo.figurantes.join(', ')})` : ''} em ${r.resumo.lugares.join(' → ')}, ${r.resumo.planos} planos, ${r.resumo.segundos}s${icones.length ? `; em blocos: ${icones.join(', ')}` : ''}`);
+        }
+        return r;
+    }
+    if (estilo === 'motion' && modo === 'video') {
+        const r = motion.montarMotion({ roteiro, largura, altura, tempos, narracao, sons, trilha, imagens });
+        if (r.ok) projeto.anotar(p.id, 'plano', `estilo motion: ${r.resumo.segundos}s contínuos, ${r.resumo.partes} partes, ${r.resumo.fps} fps`);
+        return r;
+    }
+    /* A composição (e os slides) só conhece os tipos antigos: as partes novas
+       viram a mais parecida delas, e o roteiro do vídeo serve à página. */
+    const PARECIDA = { logo: 'abertura', cores: 'lista', produto: 'titulo' };
+    const paraComposicao = { ...roteiro, partes: partes.map((pt) => (PARECIDA[pt.tipo]
+        ? { ...pt, tipo: PARECIDA[pt.tipo], itens: pt.itens || (pt.cores || []).map((c) => (typeof c === 'string' ? c : c.nome)) }
+        : pt)) };
+    return composicao.comporRoteiro({ roteiro: paraComposicao, 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.
+ *
+ * Quem tem a chave é o servidor, e é assim de propósito (a API vem com o
+ * produto). O áudio vai pequeno: mono, 16 kHz, 32 kbps.
+ */
+async function transcrever(p, alvo, ctx) {
+    const mp3 = path.join(p.pasta, 'midia', `audio-${Date.now().toString(36)}.mp3`);
+    const ex = await video.extrairAudio(alvo, mp3);
+    if (!ex.ok) return ex;
+
+    if (!ctx.api || !ctx.server) {
+        return { ok: false, error: 'a transcrição precisa do servidor, e ele não foi passado para a ferramenta.' };
+    }
+    if (ex.bytes > 20 * 1024 * 1024) {
+        return { ok: false, error: `o áudio ficou com ${(ex.bytes / 1048576).toFixed(1)} MB, acima do teto de 20 MB. `
+            + 'Transcreva em pedaços: recorte o vídeo antes.' };
+    }
+
+    try {
+        const r = await ctx.api.requestTranscricao(ctx.server, {
+            token: ctx.token,
+            audio: fs.readFileSync(mp3).toString('base64'),
+            nome: path.basename(mp3),
+            idioma: 'pt',
+        });
+        try { fs.unlinkSync(mp3); } catch { /* fica, não faz mal */ }
+        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, 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.',
+        };
+    } catch (e) {
+        return { ok: false, error: `a transcrição falhou: ${e.message}` };
+    }
+}
+
+// ── estudio_render ───────────────────────────────────────────────────────
+
+/* O SEGUNDO MOTOR: HYPERFRAMES (heygen-com/hyperframes, Apache-2.0, 13/10:
+   "trabalhar com o Remotion, mas também com o Hyperframes"). A IA escreve a
+   composição em HTML (index.html com data-start/data-duration e GSAP, CSS ou
+   three.js) numa pasta dela; aqui a pasta vai para o projeto, ganha a midia/
+   do projeto (voz, trilha, sons do Estúdio), e o CLI renderiza num Chrome
+   escondido — sem telemetria (HYPERFRAMES_NO_TELEMETRY). Depois, o mesmo do
+   Remotion: volume de Reels, a conferência e o vídeo aberto. */
+const HYPERFRAMES = 'hyperframes@0.8.154';
+async function renderHyperframes(p, args, ctx = {}) {
+    const pedido = String(args.html || args.composicao || 'hyperframes').trim();
+    const origem = [path.resolve(p.pasta, pedido), args.__pasta && path.resolve(args.__pasta, pedido), path.isAbsolute(pedido) && pedido]
+        .find((d) => d && fs.existsSync(path.join(d, 'index.html')));
+    if (!origem) return { ok: false, error: `não achei ${pedido}/index.html — escreva a composição do Hyperframes numa pasta com index.html e passe html:"<pasta>".` };
+    const destino = path.join(p.pasta, 'hyperframes');
+    if (path.resolve(origem) !== path.resolve(destino)) {
+        fs.rmSync(destino, { recursive: true, force: true });
+        fs.cpSync(origem, destino, { recursive: true });
+    }
+    const midia = path.join(destino, 'midia');
+    if (!fs.existsSync(midia) && fs.existsSync(path.join(p.pasta, 'midia'))) fs.symlinkSync(path.join(p.pasta, 'midia'), midia);
+    const saida = path.join(p.pasta, 'saida', `${projeto.apelidar(p.titulo)}.mp4`);
+    fs.mkdirSync(path.dirname(saida), { recursive: true });
+    (ctx.aoFalar || (() => {}))('renderizando no Hyperframes');
+    const npx = process.platform === 'win32' ? 'npx.cmd' : 'npx';
+    const r = await new Promise((resolve) => {
+        const { spawn } = require('child_process');
+        const proc = spawn(npx, ['--yes', HYPERFRAMES, 'render', destino, '-o', saida, '--quiet'], { env: { ...process.env, HYPERFRAMES_NO_TELEMETRY: '1', DO_NOT_TRACK: '1' } });
+        let erro = '';
+        proc.stderr.on('data', (d) => { erro += d; });
+        proc.stdout.on('data', (d) => { erro += d; });
+        const relogio = setTimeout(() => { try { proc.kill(); } catch { /* já saiu */ } }, (Number(args.minutos) || 20) * 60000);
+        proc.on('close', (code) => { clearTimeout(relogio); resolve({ ok: code === 0 && fs.existsSync(saida), erro }); });
+        proc.on('error', (e) => { clearTimeout(relogio); resolve({ ok: false, erro: e.message }); });
+    });
+    if (!r.ok) return { ok: false, error: `o Hyperframes não renderizou: ${r.erro.slice(-400)}`, comoResolver: 'precisa de Node 22+ e do ffmpeg; rode `npx hyperframes doctor` na pasta.' };
+    const med = await video.medir(saida);
+    if (med.ok && med.temAudio) {
+        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.statSync(saida).size;
+    projeto.salvar(p.id, { renders: [...(p.renders || []), { quando: new Date().toISOString(), arquivo: saida, bytes, motor: 'hyperframes' }] });
+    projeto.anotar(p.id, 'render', `hyperframes: ${(bytes / 1048576).toFixed(1)} MB, ${(med.segundos || 0).toFixed(1)}s`);
+    const conf = await conferencia.conferir(saida, { duracao: med.segundos || 0 });
+    if (conf.ok && conf.avisos.length) projeto.anotar(p.id, 'conferencia', conf.avisos.join('; '));
+    if (ctx.abrir) { try { ctx.abrir(saida); } catch { /* o caminho está na resposta */ } }
+    return { ok: true, motor: 'hyperframes', arquivo: saida, bytes, segundos: med.segundos,
+        conferencia: conf.ok ? { som: conf.som, parados: conf.parados, avisos: conf.avisos, olho: conf.olho } : undefined,
+        aviso: 'ABERTO para o usuário assistir. Chame finish dizendo o que foi feito' + (conf.ok && conf.avisos.length ? ' — e cite os avisos da conferência.' : '.') };
+}
+
+async function ferramentaRender(args, ctx = {}) {
+    const p = projetoOuRecente(args.id);
+    if (!p) return semProjeto(args.id);
+    if (args.id == null || String(args.id).trim() === '') args = { ...args, id: p.id };
+    if (String(args.motor || '').toLowerCase() === 'hyperframes' || args.html) return renderHyperframes(p, args, ctx);
+    const pl = projeto.lerPlano(args.id);
+    if (!pl) return { ok: false, error: 'não há plano neste projeto.' };
+
+    const conferida = plano.conferir(pl, { pasta: p.pasta });
+    if (!conferida.ok) {
+        return { ok: false, error: 'o plano tem problemas — conserte antes de renderizar.',
+            problemas: conferida.problemas.slice(0, 12) };
+    }
+
+    /* A REVISÃO (revisor.js): o plano roda; agora, ele está bom? Conserta a
+       receita (transição repetida, câmera sem respiro, som duplicado) e
+       devolve o resto como aviso para quem fez o plano. */
+    const revisao = revisor.revisar(pl, { semImagem: referencias.semImagem() });
+    if (revisao.consertos.length) projeto.anotar(args.id, 'revisao', revisao.consertos.join('; '));
+    if (revisao.avisos.length) projeto.anotar(args.id, 'revisao', 'avisos: ' + revisao.avisos.join('; '));
+
+    /* A ÁREA SEGURA E O RESPIRO (margem.js): nada a menos de 6%/7% da borda,
+       nada colado em nada. É conta, não pedido: o elemento que o modelo pôs
+       encostado entra, o texto largo encolhe, o colado se afasta. */
+    const guarda = margem.guardarPlano(pl);
+    if (guarda.consertos.length) projeto.anotar(args.id, 'margem', guarda.consertos.slice(0, 12).join('; '));
+
+    // Os ícones vêm ANTES do render: um render que busca ícone na internet
+    // falha no meio, depois de vinte minutos.
+    const { mapa, faltaram } = await assets.iconesDoPlano(pl, p.pasta);
+
+    /* A MÚSICA NO CORTE (batida.js): a faixa começa no ponto em que as
+       batidas caem nos cortes do plano, e o corte de impacto num acento. Só
+       quando ninguém disse o início (audio.trilha.inicio). */
+    const tr = pl.audio && pl.audio.trilha;
+    if (tr && !(typeof tr === 'object' && tr.inicio != null) && !(p.formato === 'slides' || p.formato === 'arte' || args.paginas)) {
+        try {
+            const src = path.join(p.pasta, tr.src || tr);
+            const analise = await batida.analisar(src, { ffmpeg: video.ffmpeg() || 'ffmpeg' });
+            if (analise && analise.batidas.length) {
+                const duracao = (pl.cenas || []).reduce((n, c) => n + (Number(c.duracao) || 0), 0);
+                const r = batida.melhorInicio(batida.cortesDoPlano(pl), analise, { maximo: Math.min(20, analise.segundos - duracao - 0.5) });
+                pl.audio.trilha = { ...(typeof tr === 'object' ? tr : { src: tr }), inicio: r.inicio };
+                projeto.anotar(args.id, 'trilha', `${analise.bpm} BPM; a faixa entra em ${r.inicio}s e ${r.alinhados} de ${r.total} cortes caem na batida`);
+            }
+        } catch { /* sem análise, a faixa entra do começo */ }
+    }
+
+    const montado = remotion.montar({ pasta: p.pasta, titulo: p.titulo, plano: pl, icones: mapa });
+
+    if (args.somenteProjeto) {
+        return { ok: true, projeto: montado.raiz, faltaram,
+            aviso: 'o projeto Remotion está escrito, mas nada foi renderizado.' };
+    }
+
+    /* SLIDES E ARTE são o mesmo plano, parados no tempo: cada cena vira uma
+       página. O Studio antigo tinha seis ferramentas com seis formatos de
+       documento; cinco delas eram "coisas posicionadas num retângulo", que é
+       o que uma cena já é. */
+    const parado = p.formato === 'slides' || p.formato === 'arte' || args.paginas;
+    if (parado) {
+        const pasta = path.join(p.pasta, 'saida', 'paginas');
+        const r = await slides.renderizarPaginas({
+            raiz: montado.raiz, destino: pasta, plano: pl, aoFalar: ctx.aoFalar || (() => {}),
+        });
+        if (!r.ok) return { ...r, faltaram };
+
+        const pdf = path.join(p.pasta, 'saida', `${projeto.apelidar(p.titulo)}.pdf`);
+        const junto = slides.montarPDF(r.paginas, pdf);
+        if (!junto.ok) return { ...junto, imagens: r.paginas };
+
+        projeto.salvar(args.id, { renders: [...(p.renders || []), { quando: new Date().toISOString(), arquivo: pdf, bytes: junto.bytes }] });
+        projeto.anotar(args.id, 'render', `${junto.paginas} páginas em PDF`);
+        if (ctx.abrir) { try { ctx.abrir(pdf); } catch { /* o caminho está na resposta */ } }
+        return {
+            ok: true, arquivo: pdf, paginas: junto.paginas, bytes: junto.bytes,
+            imagens: r.paginas,
+            faltaram: faltaram.length ? faltaram : undefined,
+            aviso: 'ABERTO para o usuário ver. Chame finish dizendo o que foi feito.',
+        };
+    }
+
+    const saida = path.join(p.pasta, 'saida', `${projeto.apelidar(p.titulo)}.mp4`);
+    const falar = ctx.aoFalar || (() => {});
+    const r = await remotion.renderizar({
+        raiz: montado.raiz, saida,
+        minutos: Number(args.minutos) || 30,
+        aoFalar: falar,
+    });
+    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`);
+
+    /* A CONFERÊNCIA (conferencia.js): o arquivo que saiu, medido. Som fora do
+       alvo e imagem parada viram aviso; quem decide se refaz é o agente. */
+    const conf = fs.existsSync(saida) ? await conferencia.conferir(saida, { duracao: conferida.duracao }) : { ok: false };
+    const avisosDoArquivo = conf.ok ? conf.avisos : [];
+    if (avisosDoArquivo.length) projeto.anotar(args.id, 'conferencia', avisosDoArquivo.join('; '));
+
+    // O vídeo pronto abre. É a única coisa que abre — a interface morreu, e
+    // o que a pessoa pediu foi o vídeo.
+    if (ctx.abrir) { try { ctx.abrir(saida); } catch { /* o caminho está na resposta */ } }
+
+    return {
+        ok: true, arquivo: saida, bytes, segundos: conferida.duracao,
+        faltaram: faltaram.length ? faltaram : undefined,
+        revisao: revisao.consertos.length || revisao.avisos.length ? { consertado: revisao.consertos, avisos: revisao.avisos } : undefined,
+        conferencia: conf.ok ? { som: conf.som, parados: conf.parados, avisos: conf.avisos, olho: conf.olho } : undefined,
+        aviso: 'ABERTO para o usuário assistir. Chame finish dizendo o que foi feito'
+            + (revisao.avisos.length || avisosDoArquivo.length ? ' — e cite os avisos da revisão e da conferência que valem um novo plano.' : '.'),
+    };
+}
+
+// ── 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();
+
+    /* Só o NOME da empresa também serve: "faz um vídeo para a Paris Group"
+       não traz link nenhum, e sem este caminho o agente inventaria as cores
+       da marca — erro que aparece pronto no vídeo entregue. */
+    if (!alvo && (args.marca || args.nome || args.empresa)) {
+        const achado = await identidade.acharSite(args.marca || args.nome || args.empresa);
+        if (!achado.ok) return achado;
+        alvo = achado.url;
+    }
+    if (!alvo) return { ok: false, error: 'mande a url do site, ou o nome da empresa em "marca".' };
+    // "tailwindcss.com" é endereço para gente e não é URL para o `new URL`.
+    // Sem isto, o domínio sem esquema voltava "não é um endereço" — e quem
+    // digita o domínio pelado é justamente quem já sabe qual é o site.
+    if (!/^https?:\/\//i.test(alvo)) alvo = 'https://' + alvo;
+
+    const r = await identidade.analisar(alvo);
+    if (r.ok) r.achadoPor = args.url || args.site ? 'url dada' : 'nome da empresa';
+
+    /* A LOGO. Cor e fonte saem do CSS; a logo não — ela mora num <img> do
+       cabeçalho, num apple-touch-icon ou no og:image. Sem baixar aqui, o
+       agente montava a peça de marca com o nome em texto e o usuário
+       perguntava por que a logo dele não apareceu.
+
+       Só baixa quando há projeto: arquivo de mídia solto no disco, fora de
+       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) {
+            /* O nome que o USUÁRIO disse vem primeiro. `r.marca` sai do
+               <title>, e título de página é frase: o nubank.com.br devolve
+               "Nu | About us", de onde sobra "about" — que não identifica
+               marca nenhuma e faz o desempate premiar a imagem errada. */
+            const daMarca = args.marca || args.nome || args.empresa || r.marca || r.titulo || 'marca';
+            r.logo = await identidade.pegarLogo(html, r.url, { pasta: p.pasta, nome: daMarca });
+            if (r.logo.ok) projeto.anotar(args.id, 'midia', `logo de ${r.marca || r.url}: ${r.logo.src} (${r.logo.achadaEm})`);
+        }
+    }
+
+    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/plugin/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 */ }
+                /* Os ícones do próprio site (os <svg> dos cartões): viram "site:N" no roteiro. */
+                const icSite = marcaLib.iconesDoSite(html);
+                if (icSite.length) { marca.iconesSite = icSite; r.icones = icSite.map((x, i) => `site:${i + 1}${x.nome ? ' (' + x.nome + ')' : ''}`); }
+                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 (objeto: {cores: {fundo, destaque, tinta}, fontes: {titulo, texto}}).'
+                    + (r.icones ? ' Os ícones do site estão em "icones": ponha icone:"site:N" na parte em que o assunto dele aparece.' : '');
+            } catch (e) {
+                r.acervo = { erro: e.message };
+            }
+        }
+    }
+    return r;
+}
+
+module.exports = { proporcaoDoPedido,
+    vazamentoNoComeco, variarIcones, objetosDoRoteiro,
+    ferramentaProjeto, ferramentaPlano, ferramentaMidia, ferramentaAE, ferramentaMotion, ferramentaEditar, ferramentaNarrar, ferramentaCriar,
+    ferramentaVideo, ferramentaRender, ferramentaSite,
+    projeto, plano, remotion, assets, video, identidade, slides, python, rodarPython, alinharPartes, prepararRoteiro, roteiroValido, juntarVozes,
+};