primocode 9.8.0-beta.18 → 9.8.0-beta.19

package/README.md

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

package/lib/estudio/assets.js

@@ -311,14 +311,33 @@ async function procurarImagens(termo, { quantas = 8, transparente = false, orien
  * `duracaoMin` existe para separar as duas coisas sem o usuário dizer: um
  * "whoosh" tem menos de dois segundos, uma trilha tem mais de trinta.
  */
+/* A MÚSICA vem da Jamendo (pelo Openverse): música de verdade, moderna, de
+   licença aberta. O Openverse geral devolvia concerto antigo, vento e trilha
+   de terror para "cinematic" (medido em 25/09). Licença "nd" (sem obra
+   derivada) fica de fora da música: pôr a faixa num vídeo editado é derivar. */
+async function procurarMusica(termo, { quantas = 8, duracaoMin = 45 } = {}) {
+    try {
+        const r = await pegar(`https://api.openverse.org/v1/audio/?q=${encodeURIComponent(termo)}&source=jamendo`
+            + `&page_size=${Math.max(quantas * 2, 10)}&license_type=commercial`, { json: true });
+        const sons = (r.results || [])
+            .filter((x) => !/nd/.test(x.license || '') && (!duracaoMin || (x.duration || 0) / 1000 >= duracaoMin))
+            .slice(0, quantas)
+            .map((x) => ({ url: x.url, titulo: x.title || termo, autor: x.creator, licenca: x.license, creditos: x.attribution,
+                fonte: 'jamendo', segundos: x.duration ? Math.round(x.duration / 1000) : null }));
+        if (sons.length) return { ok: true, sons };
+    } catch { /* cai no Openverse geral */ }
+    return procurarSom(termo, { quantas, duracaoMin });
+}
+
 async function procurarSom(termo, { quantas = 8, duracaoMin = 0, duracaoMax = 0 } = {}) {
     try {
         let url = `https://api.openverse.org/v1/audio/?q=${encodeURIComponent(termo)}`
             + `&page_size=${quantas}&license_type=commercial`;
-        if (duracaoMin) url += `&length=${duracaoMin < 30 ? 'short' : 'medium'}`;
+        if (duracaoMin && duracaoMin < 30) url += '&length=short';
         const r = await pegar(url, { json: true });
         const sons = (r.results || [])
             .filter((x) => !duracaoMax || !x.duration || x.duration / 1000 <= duracaoMax)
+            .filter((x) => !duracaoMin || !x.duration || x.duration / 1000 >= duracaoMin)
             .map((x) => ({
                 url: x.url, titulo: x.title || termo, autor: x.creator,
                 licenca: x.license, creditos: x.attribution, fonte: 'openverse',
@@ -392,7 +411,7 @@ async function conferirFonte(familia) {
 module.exports = {
     extensaoPorConteudo,
     pegar, guardar,
-    icone, procurarIcones, iconesDoPlano, COLECOES, procurarVideos,
+    icone, procurarIcones, iconesDoPlano, COLECOES, procurarVideos, procurarMusica,
     procurarImagens, procurarSom, baixar,
     FONTES, conferirFonte,
 };

package/lib/estudio/cinema.js

@@ -0,0 +1,267 @@
+/**
+ * cinema.js — o estilo cinematográfico, premium e humano.
+ *
+ *   "Os efeitos sonoros estão genéricos e sem impacto, a paleta da Paris não
+ *    é laranja, as cenas têm muito texto e não dá de ler antes de trocar, e
+ *    os textos não têm nada a ver com o roteiro." — e veio o roteiro dele:
+ *    "cinematográfico, premium, moderno e humano… poucas palavras por tela…
+ *    fotos nunca estáticas… NÃO usar excesso de efeitos… a abertura não
+ *    mostra o logo." (25/09/2026)
+ *
+ * O contrário do impacto: o texto entra com calma e FICA enquanto é falado
+ * (a voz lê o que está na tela), as fotos se movem sempre (zoom, pan,
+ * lateral), o preto é quase absoluto, o destaque é o gradiente da marca, a
+ * música cresce e silencia antes do clímax, e a marca só aparece no fim.
+ *
+ * Tipos de parte (todos com "fala" opcional; sem ela, a voz lê os textos):
+ *   frase      {linhas}                       preto, linha fina, texto
+ *   montagem   {linhas, ritmo}                fotos rápidas + texto por cima
+ *   numeros    {antes, itens:["3 EDIÇÕES"]}   os números contando
+ *   escada     {itens, final}                 "UMA SALA." "20 CADEIRAS." …
+ *   dia        {num, titulo, linhas}          01 PREPARAR + as três linhas
+ *   depoimento {clipes:[{src,de,ate,frase,nome}]}  o aluno falando
+ *   climax     {linhas}                       montagem acelerada, preto, silêncio
+ *   final      {linhas}                       a logo e a chamada
+ */
+
+'use strict';
+
+const { caber } = require('./composicao.js');
+
+const r2 = (n) => Math.round(n * 100) / 100;
+const tokens = (t) => String(t || '').normalize('NFD').replace(/[̀-ͯ]/g, '').toLowerCase().split(/[^a-z0-9]+/).filter(Boolean);
+
+/** Quanto tempo um texto precisa ficar na tela para ser lido. */
+const leitura = (t) => 0.55 + 0.22 * String(t || '').split(/\s+/).filter(Boolean).length;
+
+/** A fala desta parte (o que a voz diz): a "fala", ou os textos da tela. */
+function falaDe(p) {
+    if (p.fala) return p.fala;
+    if (p.tipo === 'depoimento') return '';
+    const partes = [p.antes, ...(p.linhas || []), ...(p.itens || []), p.num ? `Dia ${p.num}.` : '', p.titulo, p.final];
+    return partes.filter(Boolean).map((x) => String(x).replace(/[·→]/g, ',')).join(' ');
+}
+
+/* Quando cada texto começa, pelo tempo das palavras da voz: procura a
+   primeira palavra do texto a partir de onde parou. */
+function quando(textos, palavras, dur, t0 = 0.25) {
+    const ws = palavras.map((w) => ({ ...w, k: tokens(w.texto)[0] || '' }));
+    let cursor = 0;
+    return textos.map((txt, i) => {
+        const alvo = tokens(txt).find((w) => w.length >= 3) || tokens(txt)[0];
+        let achado = -1;
+        for (let j = cursor; j < ws.length; j++) if (ws[j].k === alvo || (alvo && ws[j].k.startsWith(alvo.slice(0, 5)))) { achado = j; break; }
+        if (achado >= 0) { cursor = achado + 1; return r2(ws[achado].de); }
+        return r2(t0 + (dur - t0) * (i / Math.max(1, textos.length)));
+    });
+}
+
+function montarCinema({ roteiro, largura = 1920, altura = 1080, tempos = [], narracao = null, sons = {}, trilha = null, fotos = [] }) {
+    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';
+    const BRANCO = '#F5F5F7';
+    const DEST = grad[1];
+    const F = { titulo: (marca.fontes && marca.fontes.titulo) || 'Inter', texto: (marca.fontes && marca.fontes.texto) || 'Inter' };
+    const W = largura, H = altura, deitado = W >= H;
+    const M = Math.round(Math.min(W, H) * 0.08), W0 = W - 2 * M;
+    const base = Math.min(W, H);
+    const cenas = [], trechos = [], efeitos = [], volumes = [];
+    let t = 0, fotoI = 0;
+    const foto = () => fotos[fotoI++ % Math.max(1, fotos.length)];
+    const som = (tt, nome, volume = 0.6) => { if (sons[nome]) efeitos.push({ t: r2(Math.max(0, tt)), src: sons[nome], volume }); };
+    const vol = (tt, v) => volumes.push({ t: r2(tt), v });
+
+    // Os movimentos da foto, em rodízio: nunca parada.
+    const movs = [
+        (d) => ({ escala: [{ t: 0, v: 1.02 }, { t: d, v: 1.16, e: 'linear' }] }),
+        (d) => ({ escala: [{ t: 0, v: 1.18 }, { t: d, v: 1.06, e: 'linear' }] }),
+        (d) => ({ escala: [{ t: 0, v: 1.14 }, { t: d, v: 1.14 }], x: [{ t: 0, v: -W * 0.04 }, { t: d, v: W * 0.04, e: 'linear' }] }),
+        (d) => ({ escala: [{ t: 0, v: 1.14 }, { t: d, v: 1.14 }], x: [{ t: 0, v: W * 0.04 }, { t: d, v: -W * 0.04, e: 'linear' }] }),
+    ];
+    let mov = 0;
+    const pFoto = (els, f, de, ate, { veu = 0.5, entrada = 'corte' } = {}) => {
+        if (!f) return;
+        const d = r2(ate - de), v = f.tipo === 'video';
+        els.push({ tipo: v ? 'video' : 'imagem', src: f.src, ...(v ? { volume: 0 } : {}), x: 0, y: 0, largura: '100%', altura: '100%', ajuste: 'cover', foco: 'center 30%', de: r2(de), ate: r2(ate),
+            anima: { ...movs[mov++ % movs.length](d), ...(entrada === 'suave' ? { opacidade: [{ t: 0, v: 0 }, { t: 0.4, v: 1 }] } : {}) } });
+        if (veu > 0) els.push({ tipo: 'forma', forma: 'retangulo', x: 0, y: 0, largura: '100%', altura: '100%', de: r2(de), ate: r2(ate),
+            fundo: { tipo: 'gradiente', cores: [`rgba(7,7,10,${veu * 0.7})`, `rgba(7,7,10,${veu})`, `rgba(7,7,10,${Math.min(0.95, veu + 0.25)})`], angulo: 180 } });
+    };
+    // O texto: entra palavra por palavra no tempo da voz e fica; as palavras marcadas no gradiente.
+    const pTexto = (els, texto, de, ate, { y = null, max = deitado ? H * 0.11 : W * 0.1, linhas = 3, peso = 700, caixa = true, marcar = [], cor = BRANCO, pal = [], alinhar = 'center', x = M, larg = W0 } = {}) => {
+        const txt = caixa ? String(texto).toUpperCase() : String(texto);
+        const fit = caber(txt, { largura: larg * 0.86, linhas, max, fonte: F.titulo });
+        const h = fit.tamanho * 1.08 * fit.linhas;
+        const ws = txt.split(/\s+/);
+        /* Centralizado, a linha entra inteira: palavra por palavra, as que ainda
+           não foram ditas ocupam espaço invisível e o começo da frase aparece
+           torto, puxado para a esquerda. Alinhado à esquerda, palavra por palavra. */
+        const rev = ws.map((_, k) => (alinhar === 'center' ? 0 : r2(Math.max(0, (pal[k] != null ? pal[k] : de + 0.08 * k) - de))));
+        const idx = ws.map((w, k) => (marcar.some((m) => tokens(w)[0] && tokens(m).includes(tokens(w)[0])) ? k : -1)).filter((k) => k >= 0);
+        els.push({ tipo: 'texto', texto: txt, fonte: F.titulo, peso, tamanho: fit.tamanho, cor, entrelinha: 1.08, espacamento: caixa ? 1 : 0,
+            x: Math.round(x), y: Math.round(y == null ? (H - h) / 2 : y), largura: Math.round(larg), alinhamento: alinhar, de: r2(de), ate: r2(ate),
+            revelar: rev, ...(idx.length ? { destaques: idx, corDestaque: DEST } : {}),
+            anima: { opacidade: [{ t: 0, v: 1 }, { t: Math.max(0.01, ate - de - 0.25), v: 1 }, { t: ate - de, v: 0 }], y: [{ t: 0, v: 10 }, { t: ate - de, v: -6, e: 'linear' }] } });
+        return h;
+    };
+    const linhaFina = (els, y, de, larg = W * 0.18) => els.push({ tipo: 'forma', forma: 'retangulo', x: Math.round((W - larg) / 2), y: Math.round(y), largura: Math.round(larg), altura: 2,
+        fundo: { tipo: 'gradiente', cores: [grad[0], grad[1]], angulo: 90 }, origem: 'center', de: r2(de), anima: { escalaX: [{ t: 0, v: 0 }, { t: 0.8, v: 1, e: 'saida' }] } });
+    const pontos = (els, de) => { for (let k = 0; k < 3; k++) els.push({ tipo: 'forma', forma: 'circulo', largura: 6, altura: 6, cor: k === 1 ? DEST : 'rgba(255,255,255,0.4)', x: Math.round(W / 2 - 18 + k * 15), y: Math.round(H - M * 1.2), de: r2(de), anima: { opacidade: [{ t: 0.2 * k, v: 0 }, { t: 0.2 * k + 0.3, v: 1 }] } }); };
+
+    let narrI = 0;
+    partes.forEach((p, i) => {
+        const els = [];
+        const cena = { fundo: { tipo: 'cor', valor: PRETO }, elementos: els, transicao: { tipo: 'corte', duracao: 0 } };
+        const narrada = p.tipo !== 'depoimento';
+        const tp = narrada ? (tempos[narrI++] || null) : null;
+        const off = 0.35;                                         // a voz entra um instante depois do corte
+        const falaDur = tp ? tp.ate - tp.de : 0;
+        const rel = (w) => r2(off + w - (tp ? tp.de : 0));        // tempo da voz → tempo da cena
+        const pals = tp ? tp.palavras || [] : [];
+        let dur;
+
+        if (tp && narracao) trechos.push({ src: narracao, t: r2(t + off), de: r2(tp.de), ate: r2(tp.ate + 0.05), volume: 1 });
+
+        const textosDaParte = p.tipo === 'escada' ? [...(p.itens || []), p.final].filter(Boolean)
+            : p.tipo === 'numeros' ? [p.antes, ...(p.itens || [])].filter(Boolean)
+                : p.tipo === 'dia' ? [p.num, p.titulo, ...(p.linhas || [])].filter(Boolean)
+                    : (p.linhas || []);
+        const somaLeitura = textosDaParte.reduce((n, x) => n + leitura(x), 0);
+        // A cena dura a fala (com um respiro) — e nunca menos que o tempo de ler.
+        dur = r2(Math.max(falaDur + off + 0.45, somaLeitura * 0.8, 2));
+        const inicios = quando(textosDaParte, pals.map((w) => ({ ...w, de: rel(w.de) })), dur, off);
+        /* Cada texto garante o SEU tempo de leitura e empurra o seguinte: sincronia
+           com a voz é bom, ler é obrigatório. Se a leitura pede mais que a fala,
+           a cena cresce (medido: "EDIÇÕES" ficava meio segundo na tela). */
+        for (let k = 1; k < inicios.length; k++) inicios[k] = r2(Math.max(inicios[k], inicios[k - 1] + leitura(textosDaParte[k - 1])));
+        if (inicios.length) dur = r2(Math.max(dur, inicios[inicios.length - 1] + leitura(textosDaParte[inicios.length - 1]) + 0.3));
+        const fimDe = (k) => (k < inicios.length - 1 ? inicios[k + 1] : dur);
+        const palDo = (txt) => { const ws = String(txt).split(/\s+/); const a = pals.findIndex((w) => tokens(w.texto)[0] === tokens(ws[0])[0]); return a < 0 ? [] : ws.map((_, k) => (pals[a + k] ? rel(pals[a + k].de) : null)); };
+
+        if (p.tipo === 'frase') {
+            if (i === 0) { som(t + 0.1, 'teclado', 0.5); vol(t, 0.12); }
+            linhaFina(els, H * 0.5 - base * 0.12, 0.2);
+            textosDaParte.forEach((x, k) => pTexto(els, x, inicios[k], fimDe(k), { caixa: false, peso: 600, max: deitado ? H * 0.1 : W * 0.095, marcar: p.marcar || [], pal: palDo(x) }));
+        } else if (p.tipo === 'montagem' || p.tipo === 'climax') {
+            const rap = p.tipo === 'climax' ? 0.38 : (p.ritmo || 0.75);
+            const fimFotos = p.tipo === 'climax' && textosDaParte.length ? Math.max(1.8, inicios[0] - 0.4) : dur;
+            for (let a = 0; a < fimFotos; a += rap) pFoto(els, foto(), a, Math.min(fimFotos, a + rap), { veu: p.tipo === 'climax' ? 0.15 : 0.5 });
+            if (p.tipo === 'climax') {
+                vol(t, 0.5); vol(t + fimFotos - 0.3, 0.75); vol(t + fimFotos, 0.0); vol(t + dur - 0.2, 0.0);
+                som(t + fimFotos, 'impacto', 0.7);
+            } else { vol(t, 0.28); som(t, 'whoosh', 0.35); }
+            textosDaParte.forEach((x, k) => pTexto(els, x, Math.max(inicios[k], p.tipo === 'climax' ? fimFotos : 0), fimDe(k), { peso: 800, marcar: p.marcar || [], pal: palDo(x) }));
+        } else if (p.tipo === 'numeros') {
+            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.62 });
+            textosDaParte.forEach((x, k) => {
+                const m = String(x).match(/^(\d+)\s+(.*)$/);
+                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.9 }, 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.3, fimDe(k), { y: H * 0.5 + tam * 0.3, max: base * 0.085, peso: 700, cor: DEST });
+            });
+        } else if (p.tipo === 'escada') {
+            vol(t, 0.22);
+            if (sons.sala) trechos.push({ src: sons.sala, t: r2(t), de: 0, ate: dur, volume: 0.25 });
+            // As fotos passam devagar numa janela, à direita (ou em cima, no vertical).
+            const jan = deitado ? { x: W * 0.56, y: M, l: W * 0.44 - M, a: H - 2 * M } : { x: M, y: M, l: W0, a: H * 0.36 };
+            const itens = p.itens || [];
+            const hItem = Math.round(deitado ? H * 0.1 : W * 0.12);
+            const fimItens = p.final ? inicios[itens.length] : dur;
+            for (let a = 0; a < fimItens; a += 1.3) {
+                const f = foto();
+                if (f) els.push({ tipo: f.tipo === 'video' ? 'video' : 'imagem', src: f.src, ...(f.tipo === 'video' ? { volume: 0 } : {}), x: Math.round(jan.x), y: Math.round(jan.y), largura: Math.round(jan.l), altura: Math.round(jan.a), ajuste: 'cover', foco: 'center 30%', raio: 18, de: r2(a), ate: r2(Math.min(fimItens, a + 1.3)),
+                    anima: { ...movs[mov++ % movs.length](1.3), opacidade: [{ t: 0, v: 0 }, { t: 0.3, v: 1 }] } });
+            }
+            itens.forEach((x, k) => {
+                const yy = deitado ? H * 0.5 - (itens.length * hItem * 1.25) / 2 + k * hItem * 1.25 : H * 0.48 + k * hItem * 1.3;
+                pTexto(els, x, inicios[k], fimItens, { y: yy, max: hItem, linhas: 1, alinhar: 'left', larg: deitado ? W * 0.48 : W0, peso: 800, pal: palDo(x) });
+            });
+            if (p.final) pTexto(els, p.final, fimItens, dur, { marcar: p.marcar || [], pal: palDo(p.final) });
+        } else if (p.tipo === 'dia') {
+            vol(t, 0.32);
+            pFoto(els, foto(), 0, dur, { veu: 0.66, entrada: 'suave' });
+            som(t, 'whoosh', 0.3);
+            const tamN = Math.round(deitado ? H * 0.34 : W * 0.42);
+            els.push({ tipo: 'texto', texto: String(p.num), fonte: F.titulo, peso: 800, tamanho: tamN, cor: 'rgba(149,103,219,0.12)', contorno: `${Math.max(3, Math.round(base * 0.004))}px ${DEST}`,
+                x: M, y: Math.round(deitado ? H * 0.12 : H * 0.14), largura: W0, alinhamento: deitado ? 'left' : 'center',
+                anima: { opacidade: [{ t: 0, v: 0 }, { t: 0.6, v: 1 }], x: [{ t: 0, v: -20 }, { t: dur, v: 20, e: 'linear' }] } });
+            const yT = deitado ? H * 0.5 : H * 0.44;
+            const hT = pTexto(els, p.titulo, inicios[1] || 0.4, dur, { y: yT, max: deitado ? H * 0.11 : W * 0.13, linhas: 1, alinhar: deitado ? 'left' : 'center', larg: W0, peso: 800, pal: palDo(p.titulo) });
+            (p.linhas || []).forEach((x, k) => pTexto(els, x, inicios[2 + k] || 0.8 + k * 0.6, dur, { y: yT + hT + H * 0.04 + k * base * 0.085, max: base * 0.06, linhas: 1, caixa: false, peso: 500, cor: 'rgba(245,245,247,0.8)',
+                alinhar: deitado ? 'left' : 'center', larg: W0, pal: palDo(x) }));
+        } else if (p.tipo === 'depoimento') {
+            /* O aluno falando, com a voz dele; a música quase some. CADA depoimento
+               é uma cena: o vídeo conta o tempo do início da cena, e com os três
+               na mesma cena o segundo e o terceiro já tinham passado do fim (preto). */
+            vol(t, 0.06);
+            const clipes = p.clipes || [];
+            clipes.forEach((c, n) => {
+                const d = r2(c.ate - c.de + 0.3);
+                const ce = { fundo: { tipo: 'cor', valor: PRETO }, elementos: [], transicao: { tipo: n === 0 ? 'esmaecer' : 'corte', duracao: n === 0 ? 0.4 : 0 }, duracao: d };
+                const el2 = ce.elementos;
+                if (deitado) {
+                    const wV = Math.round(H * 0.88 * 9 / 16), xV = Math.round(W * 0.08), xT = xV + wV + Math.round(W * 0.05);
+                    el2.push({ tipo: 'video', src: c.src, volume: 0, deOrigem: c.de, ateOrigem: c.ate + 0.3, x: 0, y: 0, largura: '100%', altura: '100%', ajuste: 'cover', anima: { desfoque: [{ t: 0, v: 40 }], brilho: [{ t: 0, v: 0.4 }] } });
+                    el2.push({ tipo: 'video', src: c.src, volume: 1, deOrigem: c.de, ateOrigem: c.ate + 0.3, x: xV, y: Math.round(H * 0.06), largura: wV, altura: Math.round(H * 0.88), ajuste: 'cover', raio: 20, anima: { opacidade: [{ t: 0, v: 0 }, { t: 0.2, v: 1 }] } });
+                    pTexto(el2, `“${c.frase}”`, 0.3, d, { x: xT, larg: W - xT - M, alinhar: 'left', caixa: false, peso: 600, max: H * 0.075, linhas: 5 });
+                    if (c.nome) el2.push({ tipo: 'texto', texto: c.nome.toUpperCase(), fonte: F.texto, peso: 700, tamanho: Math.round(H * 0.03), cor: DEST, espacamento: 3, x: xT, y: Math.round(H * 0.8), de: 0.5 });
+                } else {
+                    el2.push({ tipo: 'video', src: c.src, volume: 1, deOrigem: c.de, ateOrigem: c.ate + 0.3, x: 0, y: 0, largura: '100%', altura: '100%', ajuste: 'cover', foco: 'center 30%' });
+                    el2.push({ tipo: 'forma', forma: 'retangulo', x: 0, y: 0, largura: '100%', altura: '100%', fundo: { tipo: 'gradiente', cores: ['rgba(7,7,10,0)', 'rgba(7,7,10,0.1)', 'rgba(7,7,10,0.85)'], angulo: 180 } });
+                    pTexto(el2, `“${c.frase}”`, 0.3, d, { y: H * 0.68, caixa: false, peso: 600, max: W * 0.075, linhas: 4 });
+                    if (c.nome) el2.push({ tipo: 'texto', texto: c.nome.toUpperCase(), fonte: F.texto, peso: 700, tamanho: Math.round(W * 0.035), cor: DEST, espacamento: 3, x: M, y: Math.round(H * 0.9), largura: W0, alinhamento: 'center', de: 0.5 });
+                }
+                if (n < clipes.length - 1) { cenas.push(ce); t += d; } else { Object.assign(cena, ce); dur = d; }
+            });
+            if (!clipes.length) dur = 1;
+        } else if (p.tipo === 'final') {
+            // A marca, enfim: a logo aparece devagar, as linhas em sequência, a logo some.
+            vol(t, 0.55); vol(t + dur - 1.8, 0.45); vol(t + dur, 0);
+            som(t + 0.05, 'impacto', 0.55);
+            const R = Math.round(Math.max(W, H) * 0.7);
+            els.push({ tipo: 'forma', forma: 'circulo', largura: R, altura: R, x: Math.round(W / 2 - R / 2), y: Math.round(H * 0.42 - R / 2), cor: grad[1], opacidade: 0.18, anima: { desfoque: [{ t: 0, v: Math.round(R * 0.25) }], escala: [{ t: 0, v: 0.8 }, { t: dur, v: 1.15, e: 'suave' }] } });
+            if (marca.logo) {
+                const lh = Math.round(base * (deitado ? 0.13 : 0.1));
+                els.push({ tipo: 'imagem', src: marca.logo, x: Math.round(W / 2 - lh * 1.75), y: Math.round(H * (deitado ? 0.2 : 0.26)), largura: Math.round(lh * 3.5), altura: lh, ajuste: 'contain',
+                    anima: { opacidade: [{ t: 0, v: 0 }, { t: 1.0, v: 1 }, { t: dur - 1.2, v: 1 }, { t: dur, v: 0 }], escala: [{ t: 0, v: 0.94 }, { t: dur, v: 1.02, e: 'linear' }] } });
+            }
+            const y0 = H * (deitado ? 0.44 : 0.42);
+            textosDaParte.forEach((x, k) => pTexto(els, x, inicios[k], k < textosDaParte.length - 1 ? fimDe(k) : dur, { y: y0 + (k % 2) * 0, max: k === textosDaParte.length - 1 ? base * 0.1 : base * 0.08, peso: k === textosDaParte.length - 1 ? 800 : 600,
+                marcar: p.marcar || [], cor: k === textosDaParte.length - 1 ? DEST : BRANCO, pal: palDo(x) }));
+            pontos(els, 0.3);
+            cena.transicao = { tipo: 'esmaecer', duracao: 0.6 };
+        }
+
+        cena.duracao = dur;
+        cenas.push(cena);
+        t += dur;
+    });
+
+    // Os cruzamentos são da cena que entra: a anterior fica no ar até ela entrar.
+    let acum = 0;
+    cenas.forEach((c, k) => {
+        const prox = cenas[k + 1];
+        c.duracao = r2(c.duracao + (prox && prox.transicao.tipo !== 'corte' ? prox.transicao.duracao : 0));
+        acum += c.duracao;
+    });
+    volumes.sort((a, b) => a.t - b.t);
+    return {
+        ok: true,
+        plano: {
+            formato: { largura: W, altura: H, fps: 30 }, fundoGeral: PRETO, cenas,
+            audio: { ...(trilha ? { trilha: { src: trilha, volumes: volumes.length ? volumes : [{ t: 0, v: 0.3 }], loop: true } } : {}), trechos, efeitos },
+            acabamento: { grao: 0.05, vinheta: 0.5, grade: 0.035, passoGrade: Math.round(base / 9) },
+        },
+        resumo: { cenas: cenas.length, estilo: 'cinema', segundos: r2(t) },
+    };
+}
+
+module.exports = { montarCinema, falaDe, quando, leitura };

package/lib/estudio/index.js

@@ -44,6 +44,7 @@ const edicao = require('./edicao.js');
 const composicao = require('./composicao.js');
 const acervoSite = require('./acervo-site.js');
 const impacto = require('./impacto.js');
+const cinema = require('./cinema.js');
 
 const PY = path.join(__dirname, '..', '..', 'studio');
 
@@ -217,8 +218,10 @@ function roteiroValido(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;
-    if (!partes.every((pt) => pt && composicao.TIPOS.includes(pt.tipo))) return null;
-    return Array.isArray(x) ? { partes } : x;
+    const CINEMA = ['frase', 'montagem', 'numeros', 'escada', 'dia', 'depoimento', 'climax', 'final'];
+    if (!partes.every((pt) => pt && (composicao.TIPOS.includes(pt.tipo) || CINEMA.includes(pt.tipo)))) return null;
+    const obj = Array.isArray(x) ? { partes } : x;
+    return partes.some((pt) => CINEMA.includes(pt.tipo)) && !obj.estilo ? { ...obj, estilo: 'cinema' } : obj;
 }
 
 // O último site lido, para o projeto que nasceu DEPOIS da leitura.
@@ -592,7 +595,7 @@ async function ferramentaVideo(args, ctx = {}) {
         let trilha = null;
         if (args.musica !== false) {
             try {
-                const b = await assets.procurarSom(args.trilha || 'upbeat corporate background', { quantas: 6, duracaoMin: 45 });
+                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; }
@@ -734,6 +737,11 @@ async function narrarComGemini(lista, mp3, { voz, direcao } = {}) {
         try { fs.unlinkSync(pcm); } catch { /* fica */ }
         if (!c.ok) return { ok: false, error: 'não consegui converter a voz' };
         const med = await video.medir(mp3);
+        /* A voz CORTADA: o Gemini às vezes devolve metade do roteiro, sem erro
+           (medido em 25/09: 27,5 s de áudio para um texto de ~55 s). Fala
+           normal passa de 11 caracteres por segundo; menos que isso é corte. */
+        const chars = lista.reduce((n, x) => n + x.texto.length, 0);
+        if (med.segundos < chars / 22) return { ok: false, error: `a voz veio cortada (${med.segundos.toFixed(1)} s para ${chars} caracteres)` };
         const tr = await api.requestTranscricao(cfg.server, { token: cfg.token, audio: fs.readFileSync(mp3).toString('base64'), nome: 'voz.mp3', idioma: 'pt' });
         const palavras = (tr && tr.palavras) || [];
         if (!palavras.length) return { ok: false, error: 'sem a transcrição da voz para achar as partes' };
@@ -743,6 +751,33 @@ async function narrarComGemini(lista, mp3, { voz, direcao } = {}) {
     }
 }
 
+/* OS SONS DE VERDADE: gravação real de acervo aberto (teclado, whoosh
+   cinematográfico, impacto grave, som de sala), e o sintetizado só quando a
+   busca falha. "Esses efeitos sonoros estão genéricos e sem impacto."
+   (25/09/2026) */
+async function sonsReais(p, video) {
+    const sint = await edicao.prepararSons(p.pasta, video);
+    const quer = {
+        teclado: ['keyboard typing', 'typing keyboard'],
+        whoosh: ['cinematic whoosh', 'swoosh transition'],
+        impacto: ['cinematic boom impact', 'deep cinematic impact', 'trailer hit'],
+        sala: ['crowd murmur indoor', 'office ambience', 'people talking background'],
+    };
+    const sons = { ...sint };
+    for (const [nome, termos] of Object.entries(quer)) {
+        for (const termo of termos) {
+            try {
+                const b = await assets.procurarSom(termo, { quantas: 5 });
+                const item = (b.ok ? b.sons : []).find((x) => x.url);
+                if (!item) continue;
+                const d = await assets.baixar(item, { pasta: p.pasta, nome: 'sfx-real-' + nome });
+                if (d.ok) { sons[nome] = d.relativo; break; }
+            } catch { /* o próximo termo */ }
+        }
+    }
+    return sons;
+}
+
 const PROPORCOES = { '16:9': [1920, 1080], '9:16': [1080, 1920], '1:1': [1080, 1080], '4:5': [1080, 1350] };
 
 /** O roteiro vira plano: baixa o que falta, narra, e chama o compositor. */
@@ -812,6 +847,71 @@ async function prepararRoteiro(p, args) {
     }
 
     let tempos = [], narracao = null, sons = {}, trilha = null;
+    if (modo === 'video' && estilo === 'cinema') {
+        // Só as partes com voz vão para a narração; o depoimento tem a voz do aluno.
+        const lista = partes.filter((pt) => pt.tipo !== 'depoimento').map((pt) => ({ texto: cinema.falaDe(pt), registro: 'normal' }));
+        const mp3 = path.join(p.pasta, 'midia', `narracao-${Date.now().toString(36)}.mp3`);
+        /* O CACHE DA VOZ: a mesma fala, na mesma voz, não é gerada duas vezes.
+           Refazer o roteiro em outro formato, ou mexer numa cena, não gasta a
+           cota do Gemini — que acaba no meio do dia (medido em 25/09). */
+        const chaveVoz = require('crypto').createHash('sha1').update(JSON.stringify([lista.map((x) => x.texto), args.voz || roteiro.voz || '', 'cinema-v1'])).digest('hex').slice(0, 16);
+        const cacheDir = path.join(os.homedir(), '.primocode', 'studio', 'cache-voz');
+        const cacheMp3 = path.join(cacheDir, chaveVoz + '.mp3'), cacheJson = path.join(cacheDir, chaveVoz + '.json');
+        let v = null;
+        if (fs.existsSync(cacheMp3) && fs.existsSync(cacheJson)) {
+            fs.copyFileSync(cacheMp3, mp3);
+            v = { ok: true, ...JSON.parse(fs.readFileSync(cacheJson, 'utf8')), doCache: true };
+        } else {
+            v = await narrarComGemini(lista, mp3, { voz: args.voz || roteiro.voz,
+                direcao: 'Leia em português do Brasil como narrador de trailer de marca premium: voz grave, confiante e humana, '
+                    + 'ritmo firme, pausas curtas entre as frases, sem arrastar.' });
+            if (v.ok) {
+                try { fs.mkdirSync(cacheDir, { recursive: true }); fs.copyFileSync(mp3, cacheMp3); fs.writeFileSync(cacheJson, JSON.stringify({ voz: v.voz, segundos: v.segundos, partes: v.partes })); } catch { /* sem cache */ }
+            }
+        }
+        if (!v.ok) {
+            const arq = path.join(p.pasta, 'midia', `roteiro-${Date.now().toString(36)}.json`);
+            // Ritmo NORMAL: o "citação" (-10%, respiro longo) esticou o vídeo para 125 s.
+            fs.writeFileSync(arq, JSON.stringify(lista.map((x) => ({ ...x, registro: 'normal' }))));
+            v = await rodarPython('narrar.py', ['roteiro', '--arquivo', arq, '--saida', mp3, '--voz', String(args.voz || roteiro.voz || 'antonio')], { timeout: 10 * 60000 });
+        }
+        if (!v.ok) return v;
+        /* A DURAÇÃO que o roteiro pede ("60–75 s"): se a voz passa do que cabe,
+           ela acelera de leve — até 25%, sem mudar o tom (atempo) — e os tempos
+           de cada parte acompanham. Medido em 25/09: 98 s de voz num vídeo de 70. */
+        const alvo = Number(roteiro.duracao || args.segundos) || 0;
+        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);
+            const cabe = Math.max(15, alvo - depo - 0.7 * lista.length);
+            if (v.segundos > cabe * 1.05) {
+                const k = Math.min(1.25, v.segundos / cabe);
+                const rapido = mp3.replace(/\.mp3$/, '-r.mp3');
+                const c = await video.rodar(video.ffmpeg(), ['-y', '-i', mp3, '-filter:a', `atempo=${k.toFixed(3)}`, rapido], { timeout: 120000 });
+                if (c.ok) {
+                    fs.renameSync(rapido, mp3);
+                    const div = (x) => Math.round((x / k) * 1000) / 1000;
+                    v.partes = v.partes.map((pt) => ({ de: div(pt.de), ate: div(pt.ate), palavras: (pt.palavras || []).map((w) => ({ ...w, de: div(w.de), ate: div(w.ate) })) }));
+                    v.segundos = div(v.segundos);
+                }
+            }
+        }
+        projeto.anotar(p.id, 'narracao', `${v.segundos}s em ${lista.length} partes, voz ${v.voz}`);
+        const sonsC = await sonsReais(p, video);
+        let trilhaC = null;
+        // Vários termos e durações: vídeo sem música foi o que saiu na primeira vez (25/09).
+        for (const [termo, min] of [[roteiro.musica, 60], ['cinematic inspiring', 70], ['inspiring piano cinematic', 60], ['epic cinematic', 60], ['inspiring', 45]]) {
+            if (!termo || trilhaC) continue;
+            try {
+                const b = await assets.procurarMusica(termo, { quantas: 6, duracaoMin: min });
+                for (const item of (b.ok ? b.sons : [])) { const d = await assets.baixar(item, { pasta: p.pasta, nome: 'trilha' }); if (d.ok) { trilhaC = d.relativo; break; } }
+            } catch { /* o próximo termo */ }
+        }
+        const fotosC = acervo.fotos.map((f) => ({ src: f.src, tipo: 'imagem' }));
+        const r = cinema.montarCinema({ roteiro, largura, altura, tempos: v.partes, narracao: path.relative(p.pasta, mp3).replace(/\\/g, '/'),
+            sons: sonsC, trilha: trilhaC, fotos: fotosC });
+        if (r.ok) projeto.anotar(p.id, 'plano', `estilo cinema: ${r.resumo.cenas} cenas, ${r.resumo.segundos}s`);
+        return r;
+    }
     if (modo === 'video') {
         const lista = partes.map((pt, i) => ({ texto: composicao.falaDe(pt), registro: composicao.registroDe(pt, i, partes.length) }));
         const arq = path.join(p.pasta, 'midia', `roteiro-${Date.now().toString(36)}.json`);
@@ -829,7 +929,7 @@ async function prepararRoteiro(p, args) {
         projeto.anotar(p.id, 'narracao', `${v.segundos}s em ${partes.length} partes, voz ${v.voz}`);
         sons = await edicao.prepararSons(p.pasta, video);
         try {
-            const b = await assets.procurarSom(roteiro.musica || args.trilha || (estilo === 'impacto' ? 'epic energetic trailer' : 'inspiring corporate background'), { quantas: 6, duracaoMin: 45 });
+            const b = await assets.procurarMusica(roteiro.musica || args.trilha || (estilo === 'impacto' ? 'epic energetic' : 'inspiring corporate'), { quantas: 6, duracaoMin: 45 });
             for (const item of (b.ok ? b.sons : [])) {
                 const d = await assets.baixar(item, { pasta: p.pasta, nome: 'trilha' });
                 if (d.ok) { trilha = d.relativo; break; }
@@ -972,6 +1072,17 @@ async function ferramentaRender(args, ctx = {}) {
     });
     if (!r.ok) return { ...r, faltaram };
 
+    /* O VOLUME FINAL: a mistura (voz, música, efeitos, depoimento) sai no
+       padrão de Reels e YouTube, -14 LUFS. Medido em 25/09: o vídeo pronto
+       saía com -23,6 dB de média. A imagem não é recodificada. */
+    if (pl.audio && fs.existsSync(saida)) {
+        const tmp = saida.replace(/\.mp4$/, '.norm.mp4');
+        const ln = await video.rodar(video.ffmpeg(), ['-y', '-i', saida, '-c:v', 'copy', '-af', 'loudnorm=I=-14:TP=-1.2:LRA=10',
+            '-c:a', 'aac', '-b:a', '256k', tmp], { timeout: 15 * 60000 });
+        if (ln.ok && fs.existsSync(tmp)) fs.renameSync(tmp, saida);
+        else { try { fs.unlinkSync(tmp); } catch { /* não havia */ } }
+    }
+
     const bytes = fs.existsSync(saida) ? fs.statSync(saida).size : 0;
     projeto.salvar(args.id, { renders: [...(p.renders || []), { quando: new Date().toISOString(), arquivo: saida, bytes }] });
     projeto.anotar(args.id, 'render', `${(bytes / 1048576).toFixed(1)} MB, ${conferida.duracao}s`);
@@ -1088,7 +1199,11 @@ async function ferramentaSite(args) {
                     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);
+                        if (stops.length >= 2) {
+                            marca.gradiente = stops.slice(0, 2);
+                            // A logo manda na identidade: o destaque é a cor dela, não a do CSS.
+                            marca.cores = { ...(marca.cores || {}), destaque: stops[1], apoio: stops[0] };
+                        }
                     }
                 } catch { /* sem gradiente */ }
                 projeto.salvar(args.id, { acervo: { fotos: a.fotos, videos: a.videos, fatos: a.fatos, site: r.url }, marca });

package/lib/estudio/remotion.js

@@ -570,6 +570,12 @@ export const Video = () => {
             + plano.acabamento.luz[0] + ' 0%, transparent 45%), radial-gradient(circle at ' + (50 - 40 * Math.sin(frame / 44)) + '% '
             + (75 - 20 * Math.sin(frame / 33)) + '%, ' + (plano.acabamento.luz[1] || plano.acabamento.luz[0]) + ' 0%, transparent 40%)' }} />
       )}
+      {plano.acabamento && plano.acabamento.grade && (
+        <AbsoluteFill style={{ pointerEvents: 'none', opacity: plano.acabamento.grade,
+          backgroundImage: 'linear-gradient(rgba(255,255,255,0.5) 1px, transparent 1px), linear-gradient(90deg, rgba(255,255,255,0.5) 1px, transparent 1px)',
+          backgroundSize: (plano.acabamento.passoGrade || 120) + 'px ' + (plano.acabamento.passoGrade || 120) + 'px',
+          backgroundPosition: (frame * 0.2) + 'px ' + (frame * 0.1) + 'px' }} />
+      )}
       {plano.acabamento && plano.acabamento.vinheta && (
         <AbsoluteFill style={{ pointerEvents: 'none', background: 'radial-gradient(ellipse at center, transparent 55%, rgba(0,0,0,' + plano.acabamento.vinheta + ') 100%)' }} />
       )}
@@ -588,10 +594,24 @@ export const Video = () => {
       {plano.audio && plano.audio.trilha && (
         <Audio
           src={staticFile(plano.audio.trilha.src || plano.audio.trilha)}
-          volume={plano.audio.trilha.volume ?? 0.18}
+          /* O volume da música pode mudar no tempo ("volumes": [{t, v}]): começa
+             mínima, cresce, abaixa no depoimento e some antes do clímax. */
+          volume={Array.isArray(plano.audio.trilha.volumes)
+            ? (f) => { const tt = f / fps, vs = plano.audio.trilha.volumes;
+                if (tt <= vs[0].t) return vs[0].v;
+                for (let k = 0; k < vs.length - 1; k++) if (tt >= vs[k].t && tt <= vs[k + 1].t) return vs[k].v + (vs[k + 1].v - vs[k].v) * ((tt - vs[k].t) / Math.max(0.001, vs[k + 1].t - vs[k].t));
+                return vs[vs.length - 1].v; }
+            : (plano.audio.trilha.volume ?? 0.18)}
           loop={plano.audio.trilha.loop !== false}
         />
       )}
+      {/* Os TRECHOS: pedaços de áudio no tempo certo — a narração partida entre
+          os depoimentos, o som de ambiente de uma cena. */}
+      {(plano.audio && plano.audio.trechos ? plano.audio.trechos : []).map((a, k) => (
+        <Sequence key={'tr' + k} from={Math.round((a.t || 0) * fps)} durationInFrames={Math.max(1, Math.round(((a.ate ?? 999) - (a.de || 0)) * fps))}>
+          <Audio src={staticFile(a.src)} startFrom={Math.round((a.de || 0) * fps)} volume={a.volume ?? 1} />
+        </Sequence>
+      ))}
       {(plano.audio && plano.audio.efeitos ? plano.audio.efeitos : []).map((e, i) => (
         <Sequence key={'sfx' + i} from={Math.round((e.t || 0) * fps)}>
           <Audio src={staticFile(e.src)} volume={e.volume ?? 0.7} />

package/package.json

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