primocode 10.0.0 → 10.0.9

package/lib/codex-engine.js

@@ -131,22 +131,40 @@ function recusouOModelo(texto) {
  * `--model` e avisa — cair para o padrão da conta é melhor que a tarefa
  * morrer por causa de um nome que mudou de catálogo.
  */
-function chamarCodex(prompt, { executor, avisar = () => {} } = {}) {
+/* O Codex ASSÍNCRONO, pelo mesmo motivo do claude -p (lib/claude-engine.js):
+   o execFileSync congelava o PrimoCode inteiro — spinner, recado, Esc Esc —
+   enquanto o Codex pensava. O erro mantém stdout/stderr para o diagnóstico. */
+function rodarAssincrono(args, entrada) {
+    const { spawn } = require('child_process');
+    return new Promise((resolve, reject) => {
+        const p = spawn(CODEX, args, { env: process.env, stdio: ['pipe', 'pipe', 'pipe'], windowsHide: true });
+        let out = '', err = '';
+        const relogio = setTimeout(() => { try { p.kill(); } catch {} const e = new Error(`o Codex não respondeu em ${Math.round(TEMPO / 60000)} min`); e.stderr = err; e.stdout = out; reject(e); }, TEMPO);
+        p.stdout.on('data', (d) => { out += d; if (out.length > BUFFER) { try { p.kill(); } catch {} } });
+        p.stderr.on('data', (d) => { err += d; });
+        p.on('error', (e) => { clearTimeout(relogio); reject(e); });
+        p.on('close', (code) => {
+            clearTimeout(relogio);
+            if (code === 0) return resolve(out);
+            const e = new Error(`Command failed: codex (saiu com ${code})`); e.stderr = err; e.stdout = out; reject(e);
+        });
+        p.stdin.end(entrada);
+    });
+}
+
+async function chamarCodex(prompt, { executor, avisar = () => {} } = {}) {
     // A chave própria da pessoa, quando ela configurou uma. Sem configuração
     // o ambiente vai INTACTO — passar a variável vazia apagaria a chave que
     // ela já tem exportada no shell, e o Codex pararia de funcionar por ter
     // sido "configurado".
-    const rodar = executor || ((args, entrada) => execFileSync(CODEX, args, {
-        encoding: 'utf-8', timeout: TEMPO, input: entrada, maxBuffer: BUFFER,
-        env: process.env, ...SEM_APARECER,
-    }));
+    const rodar = executor || rodarAssincrono;
     try {
-        return rodar(argsDoExec(), prompt);
+        return await rodar(argsDoExec(), prompt);
     } catch (e) {
         const detalhe = `${e.message || ''}\n${(e.stderr || '')}\n${(e.stdout || '')}`;
         if (MODELO_CODEX && recusouOModelo(detalhe)) {
             avisar(`o Codex não aceitou o modelo ${MODELO_CODEX} — indo com o padrão da sua conta`);
-            return rodar(argsDoExec({ comModelo: false }), prompt);
+            return await rodar(argsDoExec({ comModelo: false }), prompt);
         }
         throw new Error(primeiraLinhaUtil(detalhe) || e.message);
     }
@@ -185,12 +203,12 @@ async function requestAct(server, payload, onEvent) {
             return;
         }
         const prompt = claude.promptDoProtocolo(payload);
-        const saida = chamarCodex(prompt, { avisar: (m) => onEvent({ aviso: m }) });
+        const saida = await chamarCodex(prompt, { avisar: (m) => onEvent({ aviso: m }) });
 
         // A correção é uma segunda ida ao motor, com o mesmo protocolo e o
         // diagnóstico do que saiu errado. Barata, e evita que um erro de forma
         // do motor vire erro na cara de quem pediu a tarefa.
-        const pedirCorrecao = (aviso) => chamarCodex(claude.promptDeCorrecao(aviso));
+        const pedirCorrecao = (aviso) => chamarCodex(claude.promptDeCorrecao(aviso));   // devolve promessa: quem chama dá await
 
         await claude.emitirDecisao(saida, onEvent, pedirCorrecao, 0,
             claude.nomesDasTools(payload));

package/lib/entrada.js

@@ -43,6 +43,10 @@ const { c, visibleWidth, truncate } = require('./ui.js');
 
 // ── O desenho ────────────────────────────────────────────────────────────
 
+/** A etiqueta de colagem em destaque (fininha, na cor da marca), sem mudar a largura. */
+const RE_ETIQUETA = /\[Colado #\d+ · [^\]]+\]/g;
+function pintarEtiquetas(s) { return String(s).replace(RE_ETIQUETA, (m) => c.brand(m) + '\x1b[38;5;254m'); }
+
 const BORDA = { ne: '╭', no: '╮', se: '╰', so: '╯', h: '─', v: '│' };
 
 /** Preenche até `w` colunas VISÍVEIS (códigos de cor não ocupam coluna). */
@@ -128,6 +132,12 @@ function montar(e) {
 
     const out = [];
     const regua = (bash ? c.warn : c.dim)(BORDA.h.repeat(largura));
+    /* O SPINNER MORA AQUI, na linha logo acima da caixa. Ele escrevia direto
+       no terminal com "\r" a cada 80 ms, sem quebra de linha — e a caixa,
+       que espera a linha fechar para se redesenhar, ficava apagada enquanto
+       ele girasse: o que se digitava não aparecia, e a barra de status
+       sumia ("não consigo digitar enquanto ele trabalha"). */
+    if (e.spinner) out.push(' ' + truncate(e.spinner, largura - 2));
     out.push(regua);
 
     const vazio = !String(e.texto).length;
@@ -137,7 +147,7 @@ function montar(e) {
             : c.dim('┆ ');
         // O "!" some do texto desenhado: quem vê "$ " já sabe que é shell, e
         // mostrar os dois é mostrar a mesma informação duas vezes.
-        let conteudo = c.white(i === 0 && bash ? l.texto.replace(/^\s*!/, '') : l.texto);
+        let conteudo = pintarEtiquetas(c.white(i === 0 && bash ? l.texto.replace(/^\s*!/, '') : l.texto));
         // O fantasma só existe na última linha e só com o cursor no fim dela:
         // desenhado no meio do texto, ele empurraria o que vem depois.
         if (i === linhas.length - 1 && e.fantasma && cursor === String(e.texto).length) {
@@ -326,6 +336,15 @@ class Entrada extends EventEmitter {
 
     prompt() { if (!this.suspenso && this.tty && !this.fechado) this._desenhar(); }
 
+    /** O spinner (lib/ui.js) desenha por aqui quando há caixa: uma linha
+     *  acima dela, redesenhada junto — nunca um "\r" solto por cima. */
+    mostrarSpinner(texto) {
+        const novo = texto || '';
+        if (novo === (this.spinnerTexto || '')) return;
+        this.spinnerTexto = novo;
+        if (this.desenhado && !this._meiaLinha) this._redesenhar();
+    }
+
     /** Escreve texto ACIMA da caixa — é por onde todo o resto do programa fala. */
     escreverAcima(texto) {
         if (!this.desenhado) { this.escreverCru(texto); return; }
@@ -342,7 +361,40 @@ class Entrada extends EventEmitter {
         this._mudou();
     }
 
-    limpar() { this.line = ''; this.cursor = 0; this.menu = null; this._mudou(); }
+    limpar() { this.line = ''; this.cursor = 0; this.menu = null; this.colados = new Map(); this._mudou(); }
+
+    /* COLAR VIRA ETIQUETA, como no Claude Code: texto grande colado (várias
+       linhas, ou mais de 300 caracteres) entra na caixa como
+       "[Colado #1 · 42 linhas]" — a caixa não vira um paredão, dá para
+       escrever o pedido em volta, e no Enter a etiqueta volta a ser o texto
+       inteiro. O que é curto entra como texto mesmo. */
+    colar(texto) {
+        const t = String(texto || '');
+        if (!t) return;
+        const linhas = t.split('\n').length;
+        if (linhas < 3 && t.length <= 300) return this.write(t);
+        if (!this.colados) this.colados = new Map();
+        const n = this.colados.size + 1;
+        const etiqueta = `[Colado #${n} · ${linhas > 1 ? `${linhas} linhas` : `${t.length} caracteres`}]`;
+        this.colados.set(etiqueta, t);
+        this.write(etiqueta);
+    }
+
+    /** A linha com cada etiqueta trocada pelo texto que ela guarda. */
+    expandir(linha) {
+        if (!this.colados || !this.colados.size) return linha;
+        let out = linha;
+        for (const [et, t] of this.colados) out = out.split(et).join(t);
+        return out;
+    }
+
+    /** A etiqueta que termina exatamente no cursor (o backspace apaga ela inteira). */
+    _etiquetaAntes() {
+        if (!this.colados) return null;
+        const antes = this.line.slice(0, this.cursor);
+        for (const et of this.colados.keys()) if (antes.endsWith(et)) return et;
+        return null;
+    }
 
     /**
      * A PRÓXIMA linha é senha: a caixa desenha `•` no lugar das letras, não
@@ -363,6 +415,7 @@ class Entrada extends EventEmitter {
             status: this.op.status ? this.op.status() : [],
             menu: this.menu,
             ocupado: this.ocupado,
+            spinner: this.spinnerTexto || '',
         });
     }
 
@@ -436,11 +489,11 @@ class Entrada extends EventEmitter {
         const seq = (key && key.sequence) || ch || '';
 
         // Colagem entre marcas: tudo que vier até a marca de fim é texto.
-        if (seq.includes('\x1b[200~')) { this.colando = true; }
+        if (seq.includes('\x1b[200~')) { this.colando = true; this.bufColagem = ''; }
         if (this.colando) {
             const limpo = seq.replace('\x1b[200~', '').replace('\x1b[201~', '');
-            if (limpo) this.write(limpo.replace(/\r/g, '\n'));
-            if (seq.includes('\x1b[201~')) this.colando = false;
+            if (limpo) this.bufColagem += limpo.replace(/\r\n?/g, '\n');
+            if (seq.includes('\x1b[201~')) { this.colando = false; this.colar(this.bufColagem); this.bufColagem = ''; }
             return;
         }
 
@@ -478,7 +531,15 @@ class Entrada extends EventEmitter {
                 return;
             }
 
-            case 'backspace':
+            case 'backspace': {
+                const et = this._etiquetaAntes();
+                if (et) {
+                    this.line = this.line.slice(0, this.cursor - et.length) + this.line.slice(this.cursor);
+                    this.cursor -= et.length;
+                    this.colados.delete(et);
+                    return this._mudou();
+                }
+            }
                 if (this.cursor > 0) {
                     this.line = this.line.slice(0, this.cursor - 1) + this.line.slice(this.cursor);
                     this.cursor--;
@@ -585,7 +646,9 @@ class Entrada extends EventEmitter {
 
     _enviar() {
         if (this.menu) return this._escolherDoMenu();
-        const texto = this.line;
+        const visto = this.line;
+        const texto = this.expandir(visto);
+        this.colados = new Map();
         const oculto = this.oculto;
         this.oculto = false;
         this.line = '';
@@ -599,7 +662,8 @@ class Entrada extends EventEmitter {
         this._apagar();
         if (texto.trim() && !oculto) {
             const marca = c.brand('❯ ');
-            this.escreverCru(texto.split('\n').map((l, i) => (i ? '  ' : marca) + c.white(l)).join('\n') + '\n');
+            // Na tela fica a etiqueta (o que se viu ao mandar); quem vai ao agente é o texto inteiro.
+            this.escreverCru(visto.split('\n').map((l, i) => (i ? '  ' : marca) + pintarEtiquetas(c.white(l))).join('\n') + '\n');
             if (this.historico[this.historico.length - 1] !== texto) this.historico.push(texto);
         }
         this._desenhar();
@@ -609,4 +673,4 @@ class Entrada extends EventEmitter {
 
 function criar(op) { return new Entrada(op).iniciar(); }
 
-module.exports = { criar, Entrada, montar, quebrar, encher };
+module.exports = { criar, Entrada, montar, quebrar, encher, pintarEtiquetas };

package/lib/estudio/cinema.js

@@ -34,7 +34,7 @@ const tokens = (t) => String(t || '').normalize('NFD').replace(/[̀-ͯ]/g, '').t
 /** Quanto tempo um texto precisa ficar na tela para ser lido. Nunca menos que
     0,3 s por palavra: a regra de legibilidade do /brag (Arthur, 28/09). */
 const nPalavras = (t) => String(t || '').split(/\s+/).filter(Boolean).length;
-const leitura = (t) => Math.max(0.55 + 0.22 * nPalavras(t), 0.3 * nPalavras(t));
+const leituraCheia = (t) => Math.max(0.55 + 0.22 * nPalavras(t), 0.3 * nPalavras(t));
 
 /** A fala desta parte (o que a voz diz): a "fala", ou os textos da tela. */
 /* A voz lê EXATAMENTE o que está na tela, na ordem da tela ("a narração tem
@@ -94,12 +94,23 @@ function quando(textos, palavras, dur, t0 = 0.25) {
     });
 }
 
-function montarCinema({ roteiro, largura = 1920, altura = 1080, tempos = [], narracao = null, sons = {}, trilha = null, fotos = [], fortes = {} }) {
+function montarCinema({ roteiro, largura = 1920, altura = 1080, tempos = [], narracao = null, sons = {}, trilha = null, fotos = [], fortes = {}, ritmoLeitura = 1 }) {
+    /* O tempo de ler cada texto, escalado: o cinema puro dá o tempo inteiro
+       (1); o híbrido, que tem b-roll trocando por baixo e texto curto, dá
+       pouco mais da metade — senão a cena espera muito depois da voz. */
+    const leitura = (t) => leituraCheia(t) * ritmoLeitura;
     const partes = (roteiro && roteiro.partes) || [];
     if (!partes.length) return { ok: false, error: 'o roteiro veio sem partes.' };
     const marca = roteiro.marca || {};
-    const grad = marca.gradiente && marca.gradiente.length >= 2 ? marca.gradiente : ['#2E81ED', '#9567DB'];
-    const PRETO = (marca.cores && marca.cores.fundo) || '#07070A';
+    /* O destaque é o da MARCA: sem gradiente declarado, a cor de destaque dela
+       vira o gradiente (antes caía no roxo da Paris em toda marca). */
+    const corD = marca.cores && /^#[0-9a-f]{6}$/i.test(marca.cores.destaque || '') ? marca.cores.destaque : null;
+    const grad = marca.gradiente && marca.gradiente.length >= 2 ? marca.gradiente : corD ? [corD, corD] : ['#2E81ED', '#9567DB'];
+    /* O cinema é ESCURO: o texto é branco. Marca de fundo claro (a Anthropic é
+       branca) deixava o texto invisível — o fundo dela só vale se for escuro. */
+    const luz = (h) => { const n = parseInt(String(h).slice(1), 16); return ((n >> 16 & 255) * 0.299 + (n >> 8 & 255) * 0.587 + (n & 255) * 0.114) / 255; };
+    const fundoMarca = marca.cores && /^#[0-9a-f]{6}$/i.test(marca.cores.fundo || '') ? marca.cores.fundo : null;
+    const PRETO = fundoMarca && luz(fundoMarca) < 0.25 ? fundoMarca : '#07070A';
     const BRANCO = '#F5F5F7';
     const DEST = grad[1];
     const F = { titulo: (marca.fontes && marca.fontes.titulo) || 'Inter', texto: (marca.fontes && marca.fontes.texto) || 'Inter' };
@@ -279,12 +290,19 @@ function montarCinema({ roteiro, largura = 1920, altura = 1080, tempos = [], nar
             vol(t, 0.3);
             for (let a = 0; a < dur; a += 1.2) pFoto(els, foto(), a, Math.min(dur, a + 1.2), { veu: 0.45 });
             textosDaParte.forEach((x, k) => {
-                const m = String(x).match(/^(\d+)\s+(.*)$/);
+                /* O valor pode vir com prefixo e unidade: "até 30% mais barato", "+120
+                   marcas", "2,5x mais rápido". O contador sobe só a parte numérica e
+                   mantém o resto em volta (contar.antes / contar.depois). */
+                const mv = String(x).match(/^((?:at[ée]|mais de|\+|-)?\s*)(\d+(?:[.,]\d+)?)(\s?(?:%|x|mil|mi|bi|k|h|s|min)?)\s+(.*)$/i);
+                const m = mv ? [x, mv[2], mv[4]] : null;
                 if (k === 0 && p.antes) { pTexto(els, x, inicios[k], fimDe(k), { max: base * 0.08, peso: 700, pal: palDo(x) }); return; }
                 if (!m) { pTexto(els, x, inicios[k], fimDe(k), { pal: palDo(x) }); return; }
-                const tam = Math.round(deitado ? H * 0.24 : W * 0.3);
-                els.push({ tipo: 'texto', texto: m[1], fonte: F.titulo, peso: 800, tamanho: tam, cor: BRANCO, x: M, y: Math.round(H * 0.5 - tam * 0.75), largura: W0, alinhamento: 'center',
-                    de: inicios[k], ate: fimDe(k), contar: { ate: Number(m[1]), dur: 0.45 }, gradienteTexto: undefined,
+                // O número inteiro numa linha: "ATÉ 30%" em pé quebrava em duas, por cima do rótulo.
+                const larguraNum = String(mv[1] + m[1] + mv[3]).length * 0.8;   // serifa larga: 0,62 ainda quebrava
+                const tam = Math.round(Math.min(deitado ? H * 0.24 : W * 0.3, (W0 * 0.96) / Math.max(1, larguraNum)));
+                const casas = /[.,]/.test(m[1]) ? 1 : 0;
+                els.push({ tipo: 'texto', texto: mv[1] + m[1] + mv[3], fonte: F.titulo, peso: 800, tamanho: tam, cor: BRANCO, x: M, y: Math.round(H * 0.5 - tam * 0.75), largura: W0, alinhamento: 'center',
+                    de: inicios[k], ate: fimDe(k), contar: { ate: Number(m[1].replace(',', '.')), dur: 0.6, casas, antes: mv[1].toUpperCase(), depois: mv[3] }, gradienteTexto: undefined,
                     anima: { opacidade: [{ t: 0, v: 0 }, { t: 0.25, v: 1 }], escala: [{ t: 0, v: 0.92 }, { t: 0.6, v: 1, e: 'saida' }] } });
                 pTexto(els, m[2], inicios[k] + 0.1, fimDe(k), { y: H * 0.5 + tam * 0.3, max: base * 0.085, peso: 700, cor: DEST });
             });
@@ -398,4 +416,4 @@ function montarCinema({ roteiro, largura = 1920, altura = 1080, tempos = [], nar
     };
 }
 
-module.exports = { montarCinema, falaDe, paraFala, quando, leitura };
+module.exports = { montarCinema, falaDe, paraFala, quando, leitura: leituraCheia };

package/lib/estudio/diretor.js

@@ -66,8 +66,20 @@ function precisaDeProducao(texto) {
    editor por linha do tempo (`primocode video`, lib/video/), não o roteiro. */
 const PEDE_EDICAO = /\b(edit[ae]r?|edi[cç][aã]o|cort[ae]r?|legend[ae]r?|tir[ae]r?\s+(o|os)\s+sil[eê]ncios?)\b[\s\S]{0,80}\b(grava[cç][aã]o|meu\s+v[ií]deo|esse\s+v[ií]deo|este\s+v[ií]deo|[\w-]+\.(mp4|mov|mkv|webm|m4v))\b|\b[\w-]+\.(mp4|mov|mkv|webm|m4v)\b[\s\S]{0,80}\b(edit|cort|legend|sil[eê]nci)/i;
 
+/* Os pedidos de EFEITO sobre a gravação (lib/video/ops-fx.js): fundo, camadas,
+   estalo, objeto na mão, legenda na cabeça. Falam da pessoa ("me", "minha
+   mão"), não do arquivo — por isso não casavam com a regra de cima. */
+const PEDE_EFEITO = /\b(tir[ae]r?|remov\w*|troc\w*)\s+(o\s+)?fundo\b|\bsepar\w*\s+em\s+camadas\b|\bestal\w*\s+(o\s+)?dedo\b|\b(logo|objeto)\b[\s\S]{0,40}\bm[aã]os?\b|\bjunt\w*\s+as\s+m[aã]os\b|\blegenda\b[\s\S]{0,40}\b(azul|vermelh|verde|amarel|rosa|roxa|branc|cabe[cç]a|em cima|embaixo)/i;
+
+/* "edite: /Users/…/Fototeca do Photo Booth/…/Filme em 30-09-2026 às 23.56.mov": o caminho
+   do Photo Booth tem mais de 80 caracteres, e o pedido ia para o Estúdio de
+   motion — que tratava a gravação como b-roll (01/10). Verbo de editar + um
+   arquivo de vídeo em qualquer lugar da frase é edição. */
+const EDITA_ARQUIVO = /\b(edit\w*|edi[cç][aã]o|p[oõ]e\s+(ele\s+)?pra\s+editar)\b[\s\S]*\.(mp4|mov|mkv|webm|m4v)\b|\.(mp4|mov|mkv|webm|m4v)\b[\s\S]*\b(edit\w*|edi[cç][aã]o)\b/i;
+
 function precisaDeEdicao(texto) {
-    return PEDE_EDICAO.test(String(texto || ''));
+    const t = String(texto || '');
+    return PEDE_EDICAO.test(t) || PEDE_EFEITO.test(t) || EDITA_ARQUIVO.test(t);
 }
 
 // ── 2. as decisões que não são do modelo ─────────────────────────────────

package/lib/estudio/ende.js

@@ -60,13 +60,18 @@ function lerLista(html) {
     }).filter((f) => f.titulo && f.segundos > 0);
 }
 
-/** A faixa que cobre o vídeo e mais combina com o clima. Nenhuma cobre: null. */
-function escolher(faixas, { clima = 'neutro', segundos = 0 } = {}) {
+/** A faixa que cobre o vídeo e mais combina com o clima. Nenhuma cobre: null.
+ *  Com `semente`, sorteia entre as 5 melhores que não estão em `evitar` e não
+ *  têm voz nas tags — "não repetir a mesma faixa em todo vídeo" (30/09). */
+function escolher(faixas, { clima = 'neutro', segundos = 0, semente = null, evitar = [] } = {}) {
     const palavras = CLIMAS[clima] || CLIMAS.neutro;
     const nota = (f) => f.tags.reduce((n, t) => n + palavras.filter((p) => t.includes(p)).length, 0);
     const cabem = (faixas || []).filter((f) => f.segundos >= segundos);
     if (!cabem.length) return null;
-    return cabem.reduce((a, b) => (nota(b) > nota(a) ? b : a));
+    if (semente == null) return cabem.reduce((a, b) => (nota(b) > nota(a) ? b : a));
+    const semVoz = cabem.filter((f) => !f.tags.some((t) => /vocal|singing|voice|rap\b|song/.test(t)) && !evitar.includes(f.id));
+    const pool = (semVoz.length ? semVoz : cabem).slice().sort((a, b) => nota(b) - nota(a)).slice(0, 5);
+    return pool[Math.abs(Number(semente) | 0) % pool.length];
 }
 
 async function buscarPadrao(url) {
@@ -93,8 +98,14 @@ function provedor({ buscar = buscarPadrao, baixar, pasta = 'midia' } = {}) {
     const salvar = baixar || baixarEm(pasta);
     return {
         nome: 'ende', tipo: 'musica',
-        async gerar({ clima, segundos = 0 } = {}) {
-            const faixa = escolher(lerLista(await buscar(LISTA)), { clima, segundos });
+        async gerar({ clima, segundos = 0, genero = null, semente = null, evitar = [] } = {}) {
+            // O GÊNERO (ende.app/en/genres/<genero>): jazz, lofi, funk, ambient… — escolhido pelo assunto.
+            const url = genero ? 'https://ende.app/en/genres/' + encodeURIComponent(genero) : LISTA;
+            let faixas = [];
+            // A página do gênero falhou: a busca geral (que, sem rede, lança — e a corrente cai no próximo provedor).
+            if (genero) { try { faixas = lerLista(await buscar(url)); } catch { faixas = []; } }
+            if (!faixas.length) faixas = lerLista(await buscar(LISTA));
+            const faixa = escolher(faixas, { clima, segundos, semente, evitar });
             if (!faixa) return null;
             const meta = {
                 fonte: faixa.pagina, titulo: faixa.titulo, autor: 'Sascha Ende',

package/lib/estudio/estilo.js

@@ -1,12 +1,18 @@
 /**
  * estilo.js — qual estilo de vídeo um roteiro vira.
  *
- *   motion      o padrão: um plano contínuo em 3D, o protagonista que se deforma (motion.js)
+ *   gerativo    O MOTION: sem template, a tipografia é o filme, numa linha do tempo
+ *               contínua sorteada do roteiro (gerativo.js). É o que "motion" e
+ *               "animação" pedem, e o que o modo "sem referências" usa.
+ *   motion      o motion antigo: o protagonista 3D que se deforma (motion.js),
+ *               só pelo nome (classico, limpo).
  *   vox         explainer editorial: tinta sobre papel, os oito dispositivos VOX (vox.js)
  *   marca       brand reveal: o brilho, o vetor, a marca cromada, o padrão (lancamento.js)
  *   lancamento  filme de lançamento de produto: cartões, painel, calendário, mural (lancamento.js)
  *   impacto     anúncio: corte a cada batida (impacto.js)
  *   cinema      filme de marca premium com fotos reais (cinema.js)
+ *   hibrido     O PADRÃO do vídeo: o cinema com o kit por cima — foto e vídeo reais
+ *               que não param, e o motion por cima (hibrido.js)
  *   composicao  a composição antiga, uma cena por parte (composicao.js)
  *
  * Quem manda, em ordem: o estilo que o AGENTE pediu; o do roteiro (a menos
@@ -15,9 +21,14 @@
 
 'use strict';
 
-const ESTILOS = ['motion', 'vox', 'marca', 'lancamento', 'impacto', 'cinema', 'composicao'];
+const ESTILOS = ['hibrido', 'gerativo', 'motion', 'vox', 'marca', 'lancamento', 'impacto', 'cinema', 'composicao'];
 // Nomes que o modelo usa para os mesmos estilos.
-const APELIDOS = { limpo: 'motion', explainer: 'vox', editorial: 'vox', brand: 'marca', branding: 'marca', 'brand-reveal': 'marca', launch: 'lancamento', 'lançamento': 'lancamento', produto: 'lancamento' };
+/* "motion" agora é o GERATIVO ("não pode ter template", 29–30/09); o motion
+   antigo segue pelo nome "classico" (e "limpo", o nome mais antigo dele). */
+const APELIDOS = { motion: 'gerativo', generativo: 'gerativo', kinetic: 'gerativo', cinetico: 'gerativo', 'cinético': 'gerativo',
+    tipografico: 'gerativo', 'tipográfico': 'gerativo', animacao: 'gerativo', 'animação': 'gerativo',
+    classico: 'motion', 'clássico': 'motion', 'motion-classico': 'motion', motion3d: 'motion',
+    absurdo: 'hibrido', misto: 'hibrido', mix: 'hibrido', 'híbrido': 'hibrido', limpo: 'motion', explainer: 'vox', editorial: 'vox', brand: 'marca', branding: 'marca', 'brand-reveal': 'marca', launch: 'lancamento', 'lançamento': 'lancamento', produto: 'lancamento' };
 
 const PEDE_MOTION = /\bmotion\b|anima[çc][ãa]o|animad[oa]/i;
 const PEDE_VOX = /\bvox\b|explica|explainer|document[aá]rio|editorial|hist[oó]ria d[aoe]s?\b/i;
@@ -36,16 +47,20 @@ function escolherEstilo({ pedido = '', agente = null, roteiro = null } = {}) {
     const pedidoAgente = normal(agente);
     if (pedidoAgente) return pedidoAgente;
     const doRoteiro = normal(roteiro);
-    if (doRoteiro && !(doRoteiro !== 'motion' && PEDE_MOTION.test(pedido) && !PEDE_VOX.test(pedido))) return doRoteiro;
+    /* Pedir MOTION (ou animação) é pedir o gerativo — antes do vox, da marca e
+       do lançamento, que são leiaute fixo ("não pode ter template", 30/09). */
+    if (doRoteiro && !(doRoteiro !== 'gerativo' && PEDE_MOTION.test(pedido))) return doRoteiro;
+    if (PEDE_MOTION.test(pedido)) return 'gerativo';
     if (PEDE_VOX.test(pedido)) return 'vox';
     if (PEDE_MARCA.test(pedido)) return 'marca';
     if (PEDE_LANCAMENTO.test(pedido)) return 'lancamento';
-    if (PEDE_MOTION.test(pedido)) return 'motion';
-    if (PEDE_IMPACTO.test(pedido)) return 'impacto';
-    return 'motion';
+    /* Anúncio, reels e o resto: o HÍBRIDO. "Um mix da versão antiga (o reels
+       da imersão, no cinema) e da última (o kit) — absurdo, que nem parece
+       que foi IA" (29/09). O impacto segue existindo, se pedido pelo nome. */
+    return 'hibrido';
 }
 
 /** Os estilos que usam os efeitos leves e a trilha do ende.app (os de motion, não os de corte). */
-const LEVES = new Set(['motion', 'vox', 'marca', 'lancamento']);
+const LEVES = new Set(['gerativo', 'motion', 'vox', 'marca', 'lancamento']);
 
 module.exports = { escolherEstilo, ESTILOS, LEVES, PEDE_MOTION };