primocode 10.1.0 → 10.2.0

package/README.md

@@ -1,4 +1,4 @@
-# PrimoCode v10.0.9
+# PrimoCode v10.2.0
 
 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 v10.0.9
+ ▐▛███▜▌   Primo Code v10.2.0
 ▝▜█████▛▘  Bem-vindo de volta, Joel
   ▘▘ ▝▝    ~/primocode  · /dir <pasta> muda
 ```

package/bin/primocode.js

@@ -1088,37 +1088,17 @@ async function enviarPedido(userText) {
         // O Chrome só aparece na tela quando o pedido é de navegador (lib/browser.js, definirVisivel).
         require('../lib/browser.js').definirVisivel(querNavegador(userText));
 
-        /* AS REFERÊNCIAS DO VÍDEO, decididas pela pessoa antes de começar
-           (lib/estudio/referencias.js): web aberta, só o escopo que ela der,
-           ou nenhuma — só motion. No pedido único não há quem responda, e
-           vale o aberto. */
+        /* AS REFERÊNCIAS DO VÍDEO (lib/estudio/referencias.js) saem do próprio
+           pedido. O padrão é SEM IMAGEM, e o menu 1/2/3 saiu: "por padrão, NÃO
+           usar imagens; somente quando o usuário pedir explicitamente" (07/10). */
         const referencias = require('../lib/estudio/referencias.js');
         referencias.limpar();
         const producao = require('../lib/estudio/diretor.js').precisaDeProducao(userText);
         if (producao.producao && producao.formato === 'video') {
-            /* O modo sai do próprio pedido quando ele diz ("só motion", "só do
-               site x.com", "web aberta"). Quando NÃO diz, pergunta antes de
-               começar — "vídeo" às vezes quer dizer só o motion (02/10). No
-               pedido único não há quem responda, e vale o aberto. */
             const r = referencias.inferir(userText);
-            if (!r.explicito && process.stdin.isTTY && !state.semTerminal) {
-                console.log('');
-                console.log('  ' + c.brand('▸') + ' ' + c.bold(c.white('Que vídeo você quer?')));
-                console.log('  ' + c.dim('1') + c.muted(' só motion — animação pura, nenhuma foto nem vídeo de fora'));
-                console.log('  ' + c.dim('2') + c.muted(' motion + web aberta — ele pesquisa e busca imagem e vídeo à vontade'));
-                console.log('  ' + c.dim('3') + c.muted(' motion + escopo fechado — só os sites e termos que você disser'));
-                const dito = String(await ask('  ' + c.brand('❯ ') + c.muted('1, 2 ou 3 '))).trim();
-                // Aqui 1 é o motion (a ordem da pergunta), não o 1 = aberto do entender().
-                const modo = { 1: 'sem', 2: 'aberto', 3: 'fechado' }[(/^\s*([123])\b/.exec(dito) || [])[1]] || referencias.entender(dito) || 'aberto';
-                r.modo = modo;
-                r.escopo = modo === 'fechado'
-                    ? String(await ask('  ' + c.brand('❯ ') + c.muted('quais sites ou termos? (separados por vírgula) '))).trim()
-                    : '';
-                if (modo === 'fechado' && !r.escopo) r.modo = 'aberto';
-            }
-            referencias.definir(r.modo, r.escopo);
-            console.log(c.dim(`  ⎿ referências: ${{ aberto: 'web aberta', fechado: 'só ' + r.escopo, sem: 'nenhuma, só motion' }[r.modo]}`)
-                + (r.modo === 'aberto' ? c.dim(' · diga "só motion" ou "só do site x.com" para mudar') : ''));
+            referencias.definir(r.modo, r.escopo, r.explicito);
+            console.log(c.dim(`  ⎿ imagens: ${{ aberto: 'sim, da web', fechado: 'só de ' + r.escopo, sem: r.explicito ? 'nenhuma, só motion' : 'nenhuma (o padrão)' }[r.modo]}`)
+                + (r.modo === 'sem' && !r.explicito ? c.dim(' · diga "adicione imagens de apoio" para usar') : ''));
         }
 
         // O resumo da rodada anterior é feito em segundo plano logo depois

package/lib/catalogo.js

@@ -90,10 +90,10 @@ const GRUPOS = [
                 + 'partes:[{tipo, fala, …}]} — o PrimoCode faz o layout, a voz com entonação, os ícones, a música e os sons. '
                 + 'Tipos: abertura{titulo,sub} titulo{titulo,sub} numero{valor,rotulo,sub} lista{titulo,itens} passos{titulo,itens} '
                 + 'contraste{nao,sim} citacao{texto,autor} imagem{busca,titulo,sub} grafico{titulo,barras:[{rotulo,valor}]} cta{titulo,link} '
-                + 'logo{titulo} cores{cores:[{nome,hex}]} produto{titulo,texto,destaque,selo,barras}. Em qualquer parte: destaque (a palavra-tese), fonte (a fonte citada). '
+                + 'logo{titulo} cores{cores:[{nome,hex}]} produto{titulo,texto,destaque,selo,barras}. Em qualquer parte: destaque (a palavra-tese), fonte (a fonte citada). O texto da TELA sai da FALA: o título usa palavras que a fala diz, cedo na frase (a tela entra quando a voz diz; palavra que a voz não diz deixa a tela esperando). '
                 + 'visual:{titulo,texto,paleta} (hibrido, cinema, impacto): fonte e cor do cardápio (estudio_midia acao:fontes); sem visual, o PrimoCode sorteia sem repetir os últimos vídeos. '
-                + 'estilo: hibrido (PADRÃO: foto e vídeo reais que não param + o motion por cima; dê busca:"termo em inglês" por parte para o b-roll) | gerativo (= motion: sem template — a tipografia anima nos eixos da fonte numa linha do tempo contínua, composição, fonte, cor e som sorteados do roteiro; é o do modo sem referências e o de quem pede motion/animação; com modelo3d o produto 3D entra numa batida) | classico (o motion 3D antigo) | vox (explainer editorial: tinta sobre papel, câmera que conta a frase) | '
-                + 'marca (brand reveal: brilho, letras em vetor, marca cromada, padrão) | lancamento (produto: cartões, painel, calendário) | fluido (minimalista: uma ideia por batida, a forma de uma vira a próxima, sem corte; paleta noite|breu|lavanda|creme ou tema claro|escuro no roteiro) | impacto | cinema. '
+                + 'estilo (SEM IMAGEM é o padrão: escolha o motion que serve a ESTE roteiro, ou deixe vazio e ele gira entre gerativo, fluido e impacto): hibrido (SÓ quando a pessoa pediu imagem: foto e vídeo reais + o motion por cima; dê busca:"termo em inglês" só nas partes em que a imagem agrega) | gerativo (= motion: sem template — a tipografia anima nos eixos da fonte numa linha do tempo contínua, composição, fonte, cor e som sorteados do roteiro; com modelo3d o produto 3D entra numa batida) | classico (o motion 3D antigo) | vox (explainer editorial: tinta sobre papel, câmera que conta a frase) | '
+                + 'marca (brand reveal: brilho, letras em vetor, marca cromada, padrão) | lancamento (produto: cartões, painel, calendário) | fluido (minimalista: uma ideia por batida, a forma de uma vira a próxima, sem corte; paleta noite|breu|preto|cobalto (escuras) ou lavanda|creme|laranja|branco (claras) — escolha pelo assunto e NÃO repita a do vídeo anterior; vazio, o PrimoCode escolhe) | impacto | cinema. '
                 + 'marca e lancamento aceitam visual:orbe|vetor|estrela|esfera|grade|site|padrao|cromo|cartoes|painel|cores numa parte. marca.nome dá o nome. '
                 + 'voz (thalita|antonio|francisca). Ajuste fino: plano: {formato:{largura,altura,fps}, cenas:[…], audio:{…}} — ou cenas direto. '
                 + 'cena (opcional): o número de UMA cena para trocar só ela, sem reescrever o resto. '

package/lib/estudio/assets.js

@@ -258,6 +258,80 @@ async function pexelsDoServidor(tipo, termo, { quantas, orientacao } = {}) {
     } catch { return null; }
 }
 
+/* ── O ACERVO EDITORIAL (08/10): "as imagens de banco são horríveis… desde
+   que não seja genérica, tipo pessoa sorrindo olhando pro nada" (Joel). Foto
+   de verdade, de arquivo e de museu, em vez de banco de stock:
+     1. Wikimedia Commons — documental (o despertador antigo, a ressonância de
+        1982, a cidade à noite). Só CC0, domínio público e CC BY (sem SA: o
+        SA obrigaria o vídeo a ter a mesma licença), e só foto grande;
+     2. Art Institute of Chicago — o acervo em domínio público (pintura,
+        gravura, fotografia antiga), pela imagem IIIF.
+   O que tem cara de stock ou de assunto pesado sai pelo título. Sem nada
+   que sirva, volta vazio: imagem genérica é pior que nenhuma. */
+const GENERICA = /smil|happy|laugh|business ?(wo)?man|teamwork|handshake|thumbs|stock photo|isolated on white|portrait of (a|an) (young|happy)|selfie|model pos/i;
+const PESADA = /homeless|corpse|dead body|cad[aá]ver|war victim|wounded|blood|nude|naked|execution|lynch|torture|mendig/i;
+const LIVRE = (lic) => /^(cc0|public domain|pd|cc by \d|cc by$|cc-by-\d|attribution)/i.test(String(lic || '').trim()) && !/sa|nc|nd/i.test(String(lic || '').replace(/^public domain/i, ''));
+
+function limparHtml(t) { return String(t || '').replace(/<[^>]+>/g, '').replace(/\s*(title|label)\s+QS:.*$/i, '').replace(/\s+/g, ' ').trim(); }
+
+async function procurarWikimedia(termo, { quantas = 8, minimo = 1200 } = {}) {
+    const url = 'https://commons.wikimedia.org/w/api.php?action=query&format=json&generator=search&gsrnamespace=6'
+        + `&gsrsearch=${encodeURIComponent(termo + ' filetype:bitmap')}&gsrlimit=30&prop=imageinfo`
+        + '&iiprop=url|size|extmetadata&iiurlwidth=1600&iiextmetadatafilter=LicenseShortName|Artist|ImageDescription|ObjectName';
+    const r = await pegar(url, { json: true });
+    const paginas = Object.values((r.query && r.query.pages) || {}).sort((a, b) => (a.index || 0) - (b.index || 0));
+    const out = [];
+    for (const pg of paginas) {
+        const ii = (pg.imageinfo || [])[0];
+        if (!ii || ii.width < minimo || ii.height < minimo * 0.5) continue;
+        const md = ii.extmetadata || {};
+        const lic = (md.LicenseShortName || {}).value || '';
+        const titulo = limparHtml((md.ObjectName || {}).value || pg.title.replace(/^File:/, '').replace(/\.[a-z]+$/i, ''));
+        const desc = limparHtml((md.ImageDescription || {}).value || '');
+        if (!LIVRE(lic) || GENERICA.test(titulo + ' ' + desc) || PESADA.test(titulo + ' ' + desc)) continue;
+        const autor = (limparHtml((md.Artist || {}).value || '').split(/\s+(Author info|Reusing images|Own work)\b/i)[0].slice(0, 80)) || 'Wikimedia Commons';
+        out.push({ url: ii.thumburl || ii.url, titulo, autor, licenca: lic, fonte: 'wikimedia', largura: ii.thumbwidth || ii.width, altura: ii.thumbheight || ii.height,
+            creditos: `${titulo} — ${autor} (${lic}, Wikimedia Commons)`, pagina: ii.descriptionurl });
+        if (out.length >= quantas) break;
+    }
+    return out;
+}
+
+async function procurarArtic(termo, { quantas = 6 } = {}) {
+    const url = `https://api.artic.edu/api/v1/artworks/search?q=${encodeURIComponent(termo)}`
+        + '&query%5Bterm%5D%5Bis_public_domain%5D=true&limit=20&fields=id,title,image_id,artist_title,date_display,thumbnail';
+    const r = await pegar(url, { json: true });
+    return (r.data || []).filter((a) => a.image_id && !PESADA.test(a.title || '')).slice(0, quantas).map((a) => ({
+        url: `https://www.artic.edu/iiif/2/${a.image_id}/full/1686,/0/default.jpg`, titulo: a.title, autor: a.artist_title || 'Art Institute of Chicago',
+        licenca: 'CC0 (domínio público)', fonte: 'artic', largura: (a.thumbnail || {}).width, altura: (a.thumbnail || {}).height,
+        creditos: `${a.title}${a.date_display ? ', ' + a.date_display : ''} — ${a.artist_title || 'autor desconhecido'} (Art Institute of Chicago, CC0)`,
+    }));
+}
+
+/* A BUSCA DE ARQUIVO é curta: o roteiro escreve busca de banco de stock
+   ("tired person at office desk"), e um arquivo de verdade não acha nada
+   com isso. Tenta a busca inteira, depois só as palavras de conteúdo, depois
+   os pares delas do fim para o começo ("alarm clock on nightstand" → "alarm
+   clock"). Pessoa genérica sai da busca: o arquivo responde com a coisa. */
+const VAZIAS_BUSCA = new Set('a an the of on in at with and or to for from by into over under near during while person people man woman someone guy girl young old tired happy sad soft light glowing macro close up closeup shot view cinematic photo image background beautiful modern'.split(' '));
+function buscasMenores(termo) {
+    const ws = String(termo || '').toLowerCase().replace(/[^a-z0-9\s-]/g, ' ').split(/\s+/).filter(Boolean);
+    const conteudo = ws.filter((w) => !VAZIAS_BUSCA.has(w));
+    const pares = [];
+    for (let k = conteudo.length - 2; k >= 0; k--) pares.push(conteudo.slice(k, k + 2).join(' '));
+    return [...new Set([ws.join(' '), conteudo.join(' '), ...pares, ...conteudo.slice().reverse()].filter((x) => x && x.length > 2))];
+}
+
+/** A foto editorial (Wikimedia), da busca inteira à mais curta. Nunca o banco de stock. */
+async function procurarEditorial(termo, { quantas = 8 } = {}) {
+    for (const q of buscasMenores(termo)) {
+        let imagens = [];
+        try { imagens = await procurarWikimedia(q, { quantas }); } catch { continue; }
+        if (imagens.length >= 2) return { ok: true, imagens, busca: q };
+    }
+    return { ok: false, imagens: [] };
+}
+
 /** Procura vídeo de apoio (b-roll). Só Pexels: o Openverse não tem vídeo. */
 async function procurarVideos(termo, { quantas = 5, orientacao = null } = {}) {
     const videos = await pexelsDoServidor('videos', termo, { quantas, orientacao });
@@ -418,6 +492,6 @@ module.exports = {
     extensaoPorConteudo,
     pegar, guardar,
     icone, procurarIcones, iconesDoPlano, COLECOES, procurarVideos, procurarMusica,
-    procurarImagens, procurarSom, urlSom, baixar,
+    procurarImagens, procurarEditorial, procurarWikimedia, procurarArtic, buscasMenores, procurarSom, urlSom, baixar,
     FONTES, conferirFonte,
 };

package/lib/estudio/batida.js

@@ -0,0 +1,184 @@
+/**
+ * batida.js — a música manda no corte: acha a batida da trilha e escolhe de
+ * onde a faixa começa para as batidas caírem em cima dos cortes do vídeo.
+ *
+ *   "A música também deve influenciar a edição: cortes, animações,
+ *    transições e momentos de impacto devem poder ser sincronizados com
+ *    ela." (Joel, 07/10)
+ *
+ * Antes, "cortar no beat" queria dizer cortar 0,08 s antes da primeira
+ * palavra da parte (ritmo.js): a voz mandava, e a música tocava por baixo
+ * sem saber dos cortes. Mexer no corte quebraria a sincronia com a voz,
+ * então aqui quem se move é a MÚSICA — o que um editor faz ao deslizar a
+ * trilha na linha do tempo:
+ *   1. analisar: o ffmpeg decodifica a faixa; a energia vira um envelope de
+ *      ataques; a autocorrelação acha o andamento (60–180 BPM) e a fase;
+ *      os picos mais fortes viram os ACENTOS (a virada, o drop);
+ *   2. alinhar: dos cortes do plano (o corte de impacto pesa mais), procura
+ *      o início da faixa em que mais cortes caem numa batida e o maior
+ *      impacto cai num acento. O plano ganha audio.trilha.inicio.
+ * Puro onde dá: analisarPCM e melhorInicio não tocam o disco.
+ */
+
+'use strict';
+
+const fs = require('fs');
+const { spawn } = require('child_process');
+
+const TAXA = 22050;
+const SALTO = 512;                       // ~23 ms por quadro do envelope
+const r3 = (n) => Math.round(n * 1000) / 1000;
+
+/** O envelope de ataques: quanto a energia SOBE de um quadro para o outro. */
+function envelope(amostras) {
+    const n = Math.floor(amostras.length / SALTO);
+    const energia = new Float64Array(n);
+    for (let i = 0; i < n; i++) {
+        let s = 0;
+        for (let k = i * SALTO; k < (i + 1) * SALTO; k++) s += amostras[k] * amostras[k];
+        energia[i] = Math.log1p(1000 * s / SALTO);
+    }
+    const ataque = new Float64Array(n);
+    for (let i = 1; i < n; i++) ataque[i] = Math.max(0, energia[i] - energia[i - 1]);
+    // Tira a média móvel (1 s): sobra o que se destaca do que está ao redor.
+    const janela = Math.round(TAXA / SALTO);
+    const out = new Float64Array(n);
+    let soma = 0;
+    for (let i = 0; i < n; i++) {
+        soma += ataque[i];
+        if (i >= janela) soma -= ataque[i - janela];
+        out[i] = Math.max(0, ataque[i] - soma / Math.min(i + 1, janela));
+    }
+    return out;
+}
+
+/**
+ * A análise de uma faixa já decodificada (mono, `taxa` Hz).
+ * @returns {{bpm:number, periodo:number, batidas:number[], acentos:number[], confianca:number, segundos:number}}
+ */
+function analisarPCM(amostras, taxa = TAXA) {
+    const seg = amostras.length / taxa;
+    const env = envelope(amostras);
+    const qps = taxa / SALTO;            // quadros do envelope por segundo
+    const vazio = { bpm: 0, periodo: 0, batidas: [], acentos: [], confianca: 0, segundos: r3(seg) };
+    if (env.length < qps * 4) return vazio;
+
+    // O andamento: o atraso (em quadros) que mais se parece consigo mesmo, de 60 a 180 BPM.
+    const media = env.reduce((a, b) => a + b, 0) / env.length;
+    let melhorLag = 0, melhor = 0, total = 0;
+    const lagMin = Math.floor(qps * 60 / 180), lagMax = Math.ceil(qps * 60 / 60);
+    const auto = (lag) => { let s = 0; for (let i = lag; i < env.length; i++) s += (env[i] - media) * (env[i - lag] - media); return s / (env.length - lag); };
+    for (let lag = lagMin; lag <= lagMax; lag++) {
+        const s = auto(lag);
+        // Leve preferência pelo andamento de dança (~120): o dobro e a metade empatam muito.
+        const bpm = 60 * qps / lag;
+        const peso = Math.exp(-0.5 * Math.pow(Math.log2(bpm / 120) / 1.0, 2));
+        if (s * peso > melhor) { melhor = s * peso; melhorLag = lag; }
+        total += Math.max(0, s);
+    }
+    if (!melhorLag || melhor <= 0) return vazio;
+
+    /* O período em fração de quadro: o atraso inteiro (23 ms de grão) acumula
+       erro batida após batida. A parábola nos vizinhos acha o meio; e o
+       período que mais soma ataque numa grade longa decide o resto. */
+    const [y0, y1, y2] = [auto(melhorLag - 1), auto(melhorLag), auto(melhorLag + 1)];
+    let lag = melhorLag + (y0 - 2 * y1 + y2 !== 0 ? 0.5 * (y0 - y2) / (y0 - 2 * y1 + y2) : 0);
+    const somaGrade = (L, f) => { let s = 0; for (let x = f; x < env.length; x += L) s += env[Math.round(x)] || 0; return s; };
+    let fase = 0, maisForte = -1;
+    for (let L = lag - 0.3; L <= lag + 0.3; L += 0.02) {
+        for (let f = 0; f < L; f += 0.5) {
+            const s = somaGrade(L, f);
+            if (s > maisForte) { maisForte = s; fase = f; lag = L; }
+        }
+    }
+    const periodo = lag / qps;
+    // Cada batida se prende ao ataque mais forte a até 2 quadros dela (o músico não é metrônomo).
+    const batidas = [];
+    for (let x = fase; x < env.length; x += lag) {
+        const c = Math.round(x);
+        let i = c;
+        for (let k = Math.max(0, c - 2); k <= Math.min(env.length - 1, c + 2); k++) if (env[k] > env[i]) i = k;
+        batidas.push(r3(i / qps));
+    }
+
+    // Os acentos: os ataques mais fortes (o 5% de cima), a pelo menos 2 s um do outro.
+    const ordem = [...env.keys()].sort((a, b) => env[b] - env[a]);
+    const acentos = [];
+    for (const i of ordem.slice(0, Math.max(4, Math.floor(env.length * 0.05)))) {
+        const t = i / qps;
+        if (acentos.every((a) => Math.abs(a - t) >= 2)) acentos.push(t);
+        if (acentos.length >= 12) break;
+    }
+    /* A confiança: a fração das batidas que caem num ataque de verdade (acima
+       da mediana do envelope). Grade que não casa com a música fica perto de 0,5. */
+    const mediana = [...env].sort((x, y) => x - y)[Math.floor(env.length / 2)];
+    const naBatida = batidas.filter((t) => { const c = Math.round(t * qps); return Math.max(env[c - 1] || 0, env[c] || 0, env[c + 1] || 0) > mediana; }).length;
+    const confianca = batidas.length ? naBatida / batidas.length : 0;
+    return { bpm: Math.round(60 / periodo), periodo: r3(periodo), batidas, acentos: acentos.sort((a, b) => a - b).map(r3), confianca: r3(confianca), segundos: r3(seg) };
+}
+
+/** Decodifica a faixa (até `maximo` s) e analisa. Guarda ao lado: <faixa>.batidas.json. */
+function analisar(arquivo, { maximo = 150, ffmpeg = 'ffmpeg' } = {}) {
+    const cache = arquivo + '.batidas.json';
+    try { return Promise.resolve(JSON.parse(fs.readFileSync(cache, 'utf8'))); } catch { /* analisa */ }
+    return new Promise((resolve) => {
+        const p = spawn(ffmpeg, ['-v', 'error', '-t', String(maximo), '-i', arquivo, '-ac', '1', '-ar', String(TAXA), '-f', 'f32le', '-']);
+        const pedacos = [];
+        p.stdout.on('data', (d) => pedacos.push(d));
+        p.on('error', () => resolve(null));
+        p.on('close', (code) => {
+            if (code !== 0) return resolve(null);
+            const buf = Buffer.concat(pedacos);
+            const amostras = new Float32Array(buf.buffer, buf.byteOffset, Math.floor(buf.length / 4));
+            const a = analisarPCM(amostras, TAXA);
+            try { fs.writeFileSync(cache, JSON.stringify(a)); } catch { /* sem cache */ }
+            resolve(a);
+        });
+    });
+}
+
+const CONFIANCA_MINIMA = 0.7;   // abaixo disso a batida é chute: a faixa entra do começo
+
+const TRANSICOES_FORTES = new Set(['soco', 'flash', 'chicote', 'zoom', 'giro']);
+
+/** Os cortes do plano no tempo do vídeo: [{t, peso}]. Corte de impacto pesa 3; o maior impacto vira `impacto`. */
+function cortesDoPlano(plano) {
+    const cortes = [];
+    let t = 0;
+    for (const [i, cena] of ((plano && plano.cenas) || []).entries()) {
+        if (i > 0) {
+            const tr = cena.transicao && (cena.transicao.tipo || cena.transicao);
+            cortes.push({ t: r3(t), peso: cena.impacto || TRANSICOES_FORTES.has(tr) ? 3 : 1 });
+        }
+        t += Number(cena.duracao) || 0;
+    }
+    return cortes;
+}
+
+/**
+ * De onde a faixa começa (em s) para o máximo de cortes cair numa batida.
+ * Procura em passos de 10 ms, de 0 a `maximo`; empate fica com o início mais
+ * cedo. O corte mais pesado ganha bônus se cair num acento.
+ */
+function melhorInicio(cortes, analise, { maximo = 0, tolerancia = 0.05 } = {}) {
+    const bats = (analise && analise.batidas) || [];
+    if (!cortes.length || bats.length < 4 || (analise.confianca != null && analise.confianca < CONFIANCA_MINIMA)) return { inicio: 0, alinhados: 0, total: cortes.length };
+    const perto = (lista, t) => {
+        let lo = 0, hi = lista.length - 1;
+        while (lo < hi) { const m = (lo + hi) >> 1; if (lista[m] < t) lo = m + 1; else hi = m; }
+        return Math.min(Math.abs(lista[lo] - t), lo > 0 ? Math.abs(lista[lo - 1] - t) : Infinity);
+    };
+    const maior = cortes.reduce((a, b) => (b.peso > a.peso ? b : a), cortes[0]);
+    const acentos = (analise.acentos || []);
+    let melhor = { inicio: 0, pontos: -1 };
+    for (let o = 0; o <= Math.max(0, maximo) + 1e-9; o += 0.01) {
+        let pontos = 0;
+        for (const c of cortes) pontos += c.peso * Math.exp(-0.5 * Math.pow(perto(bats, c.t + o) / tolerancia, 2));
+        if (maior.peso > 1 && acentos.length && perto(acentos, maior.t + o) < 0.1) pontos += 2;
+        if (pontos > melhor.pontos + 1e-6) melhor = { inicio: r3(o), pontos };
+    }
+    const alinhados = cortes.filter((c) => perto(bats, c.t + melhor.inicio) <= tolerancia).length;
+    return { inicio: melhor.inicio, alinhados, total: cortes.length };
+}
+
+module.exports = { analisarPCM, analisar, cortesDoPlano, melhorInicio, TAXA, CONFIANCA_MINIMA };

package/lib/estudio/biblioteca.js

@@ -113,12 +113,47 @@ const norm = (s) => String(s || '').normalize('NFD').replace(/[̀-ͯ]/g, '').toL
 function acharFonte(nome) { const n = norm(nome); return FONTES.find((f) => norm(f.nome) === n) || null; }
 function acharPaleta(nome) { const n = norm(nome).replace(/\s+/g, '-'); return PALETAS.find((p) => p.nome === n) || null; }
 
-/* O sorteio que pula os recentes. Se a lista inteira já foi usada, vale
-   qualquer uma — nunca fica sem. */
-function sortear(lista, recentes, chave, sorte) {
-    const livres = lista.filter((x) => !recentes.includes(chave(x)));
-    const de = livres.length ? livres : lista;
-    return de[Math.floor(sorte() * de.length) % de.length];
+/* O CASAMENTO DA FONTE COM O ROTEIRO (07/10): "a IA deve escolher fontes e
+   combinações de acordo com assunto, tom, público e ritmo" (Joel). Antes eram
+   dois sorteios independentes. Agora:
+   - o CLIMA do roteiro (o mesmo que escolhe a trilha, variedade.climaDe) diz
+     quanto cada tipo de título serve (0 a 1);
+   - o tipo do título diz que tipo de texto faz par com ele (contraste, não
+     duas fontes que brigam);
+   - a memória penaliza o recente pela distância, não corta: o que serve ao
+     tom ganha do que só é novo (os pontos de variedade.js). */
+const TOM_DO_TITULO = {
+    tecnologia: { display: 1, larga: 0.9, condensada: 0.6, texto: 0.7, serifa: 0.2 },
+    energetico: { condensada: 1, display: 0.9, larga: 0.6, texto: 0.5, serifa: 0.2 },
+    epico: { condensada: 1, serifa: 0.8, display: 0.6, larga: 0.5, texto: 0.3 },
+    calmo: { serifa: 1, texto: 0.9, display: 0.5, condensada: 0.3, larga: 0.2 },
+    alegre: { display: 1, larga: 0.8, texto: 0.6, condensada: 0.4, serifa: 0.4 },
+    emocional: { serifa: 1, texto: 0.7, display: 0.5, condensada: 0.4, larga: 0.2 },
+    misterio: { condensada: 0.9, serifa: 0.9, larga: 0.6, display: 0.5, texto: 0.4 },
+};
+// O par do texto, pelo tipo do título: o contraste que funciona.
+const PAR_DO_TEXTO = {
+    condensada: { texto: 1, mono: 0.8, serifa: 0.6, display: 0.4 },
+    display: { texto: 1, serifa: 0.7, mono: 0.6, display: 0.2 },
+    larga: { mono: 1, texto: 0.9, serifa: 0.4, display: 0.2 },
+    serifa: { texto: 1, mono: 0.7, display: 0.5, serifa: 0.3 },
+    texto: { serifa: 1, mono: 0.9, texto: 0.3, display: 0.5 },
+};
+
+/** O tom do roteiro para a fonte: o clima (variedade.climaDe). Neutro serve tudo igual. */
+function tomDe(roteiro, estilo = '') { return require('./variedade.js').climaDe(roteiro || {}, estilo); }
+
+/* A escolha por pontos: 2 × adequação − recência (1 para o último usado,
+   metade a cada quarto da memória). Entre os quase empatados, sorteia. */
+function escolher(lista, recentes, chave, sorte, adequa = () => 1, lembra = 10) {
+    const meia = Math.max(1, lembra / 4);
+    const pts = lista.map((x) => {
+        const pos = recentes.indexOf(chave(x));
+        return { x, p: 2 * adequa(x) - (pos < 0 ? 0 : Math.pow(0.5, pos / meia)) };
+    });
+    const melhor = Math.max(...pts.map((q) => q.p));
+    const quase = pts.filter((q) => q.p >= melhor - 0.05).map((q) => q.x);
+    return quase[Math.floor(sorte() * quase.length) % quase.length];
 }
 
 /**
@@ -126,7 +161,7 @@ function sortear(lista, recentes, chave, sorte) {
  * trocar nada que a marca já tem. Devolve o que escolheu e de onde veio.
  * memoria: null não lê nem grava o disco (os testes); sorte: () => [0,1).
  */
-function vestir(roteiro, { memoria = ARQ, sorte = Math.random } = {}) {
+function vestir(roteiro, { memoria = ARQ, sorte = Math.random, estilo = '' } = {}) {
     if (!roteiro || typeof roteiro !== 'object') return { mudou: false };
     const marca = roteiro.marca || {};
     const cores = marca.cores || {};
@@ -136,17 +171,22 @@ function vestir(roteiro, { memoria = ARQ, sorte = Math.random } = {}) {
 
     if (!(marca.fontes && marca.fontes.titulo)) {
         // A IA escolheu pelo nome: vale qualquer família do Google Fonts, mesmo fora do cardápio.
-        const titulo = visual.titulo ? String(visual.titulo) : sortear(TITULO, mem.titulo, (f) => f.nome, sorte).nome;
+        const tom = TOM_DO_TITULO[tomDe(roteiro, estilo)] || null;
+        const titulo = visual.titulo ? String(visual.titulo)
+            : escolher(TITULO, mem.titulo, (f) => f.nome, sorte, (f) => (tom ? tom[f.tipo] ?? 0.3 : 1), LEMBRA.titulo).nome;
+        const tipoTitulo = (acharFonte(titulo) || {}).tipo;
+        const par = PAR_DO_TEXTO[tipoTitulo] || null;
         const textoLista = TEXTO.filter((f) => f.nome !== titulo);
-        const texto = visual.texto ? String(visual.texto) : sortear(textoLista, mem.texto, (f) => f.nome, sorte).nome;
+        const texto = visual.texto ? String(visual.texto)
+            : escolher(textoLista, mem.texto, (f) => f.nome, sorte, (f) => (par ? par[f.tipo] ?? 0.2 : 1), LEMBRA.texto).nome;
         marca.fontes = { ...(marca.fontes || {}), titulo, texto };
         mem.titulo = [titulo, ...mem.titulo.filter((x) => x !== titulo)].slice(0, LEMBRA.titulo);
         mem.texto = [texto, ...mem.texto.filter((x) => x !== texto)].slice(0, LEMBRA.texto);
-        Object.assign(escolha, { mudou: true, titulo, texto, fonteDaIA: !!visual.titulo });
+        Object.assign(escolha, { mudou: true, titulo, texto, fonteDaIA: !!visual.titulo, tom: tomDe(roteiro, estilo) });
     }
     // A cor da marca manda: com destaque ou gradiente declarado, a paleta não entra.
     if (!(marca.gradiente && marca.gradiente.length >= 2) && !cores.destaque) {
-        const p = acharPaleta(visual.paleta) || sortear(PALETAS, mem.paleta, (x) => x.base, sorte);
+        const p = acharPaleta(visual.paleta) || escolher(PALETAS, mem.paleta, (x) => x.base, sorte, () => 1, LEMBRA.paleta);
         marca.gradiente = [...p.grad];
         marca.cores = { ...cores, fundo: cores.fundo || p.fundo, destaque: p.grad[1], apoio: p.grad[0] };
         mem.paleta = [p.base, ...mem.paleta.filter((x) => x !== p.base)].slice(0, LEMBRA.paleta);
@@ -171,4 +211,4 @@ function cardapio() {
     };
 }
 
-module.exports = { vestir, cardapio, larguraDe, acharFonte, acharPaleta, FONTES, PALETAS, BASES, TITULO, TEXTO, luz, ARQ };
+module.exports = { vestir, cardapio, tomDe, TOM_DO_TITULO, PAR_DO_TEXTO, larguraDe, acharFonte, acharPaleta, FONTES, PALETAS, BASES, TITULO, TEXTO, luz, ARQ };

package/lib/estudio/decisao.js

@@ -0,0 +1,106 @@
+/**
+ * decisao.js — o que cada frase da edição pede: movimento, recorte, som — ou
+ * nada, e a cena respira.
+ *
+ *   "Não quero simplesmente adicionar efeitos. Quero melhorar a decisão de
+ *    edição. Nem todo momento precisa de movimento, transição ou efeito. Às
+ *    vezes a melhor decisão é deixar a cena respirar." (Joel, 07/10)
+ *
+ * Antes a edição era um rodízio: zoom por `i % 3`, a pessoa recortada em
+ * `i % 4 === 2`, whoosh em `i % 3 === 1`. A frase mais forte do vídeo podia
+ * cair num "parado", e uma frase de ligação ganhava o soco. Aqui:
+ *   1. INTENSIDADE (0 a 1) de cada frase: a palavra mais forte, número,
+ *      exclamação e pergunta, frase curta de efeito, a pausa antes dela (o
+ *      silêncio prepara o golpe), o gancho do começo e o fecho;
+ *   2. MOVIMENTO pela intensidade, com três regras de editor: o golpe é raro
+ *      (no máximo ~1 em 3 frases), depois do golpe vem um respiro, e o mesmo
+ *      movimento não se repete em seguida;
+ *   3. o RECORTE (a pessoa na frente da palavra gigante) vai para as frases
+ *      mais fortes, longe uma da outra; o WHOOSH só anuncia o soco.
+ * Puro: frases entram, decisões saem. `aleatorio` decide os empates.
+ */
+
+'use strict';
+
+const r2 = (n) => Math.round(n * 100) / 100;
+const limpa = (t) => String(t || '').toLowerCase().normalize('NFD').replace(/[̀-ͯ]/g, '').replace(/[^a-z0-9%]/g, '');
+
+/* Os movimentos de câmera (zoom em quadros-chave, no tempo da cena):
+     parado      nada — a cena respira
+     empurra     aproxima devagar (tensão que cresce)
+     soco        entra já fechado e segura (o golpe)
+     recua       abre devagar (alívio, conclusão)
+     reenquadra  fecha num ponto fora do centro (mudança de assunto)  */
+const MOVIMENTOS = {
+    parado: () => ({ zoom: [{ t: 0, v: 1.0 }, { t: 1, v: 1.0 }] }),
+    empurra: (d, k) => ({ zoom: [{ t: 0, v: 1.0 }, { t: d, v: r2(1.04 + 0.06 * k), e: 'linear' }] }),
+    soco: (d, k) => ({ zoom: [{ t: 0, v: r2(1.14 + 0.08 * k) }, { t: d, v: r2(1.17 + 0.08 * k), e: 'linear' }] }),
+    recua: (d, k) => ({ zoom: [{ t: 0, v: r2(1.1 + 0.05 * k) }, { t: d, v: 1.02, e: 'suave' }] }),
+    // O x é em px: 3,5% do lado menor cabe na sobra de um zoom de 1,12.
+    reenquadra: (d, k, lado, base = 1080) => ({ zoom: [{ t: 0, v: r2(1.12 + 0.04 * k) }, { t: d, v: r2(1.15 + 0.04 * k), e: 'suave' }],
+        x: [{ t: 0, v: Math.round((lado ? 1 : -1) * base * 0.03) }, { t: d, v: Math.round((lado ? 1 : -1) * base * 0.035), e: 'suave' }] }),
+};
+
+/** A intensidade de cada frase (lista de palavras {de, ate, texto}), de 0 a 1. */
+function intensidades(grupos, peso = (w) => limpa(w).length) {
+    const n = grupos.length;
+    const brutos = grupos.map((g, i) => {
+        const texto = g.map((p) => p.texto).join(' ');
+        const forte = Math.max(0, ...g.map((p) => peso(p.texto)));
+        let s = Math.min(1, forte / 14) * 0.45;
+        if (/\d/.test(texto)) s += 0.2;
+        if (/!/.test(texto)) s += 0.2;
+        if (/\?/.test(texto)) s += 0.1;
+        if (g.length <= 4) s += 0.15;                                    // frase curta é frase de efeito
+        const pausa = i > 0 ? g[0].de - grupos[i - 1][grupos[i - 1].length - 1].ate : 0;
+        if (pausa > 0.45) s += Math.min(0.2, pausa * 0.25);              // o silêncio prepara o golpe
+        if (i === 0) s += 0.15;                                          // o gancho
+        if (i === n - 1) s += 0.1;                                       // o fecho
+        return s;
+    });
+    const max = Math.max(...brutos, 1e-9), min = Math.min(...brutos);
+    return brutos.map((s) => r2(max - min < 1e-6 ? 0.5 : (s - min) / (max - min)));
+}
+
+/**
+ * As decisões da edição: uma por frase.
+ * @returns {Array<{intensidade:number, movimento:string, recorte:boolean, whoosh:boolean}>}
+ */
+function decidir(grupos, { peso, aleatorio = Math.random, maxRecortes = 3 } = {}) {
+    const ints = intensidades(grupos, peso);
+    const n = ints.length;
+    // O golpe é raro: só as frases do terço de cima (pelo menos 1, no máximo n/3).
+    const ordem = [...ints.keys()].sort((a, b) => ints[b] - ints[a]);
+    const golpes = new Set(ordem.slice(0, Math.max(1, Math.floor(n / 3))).filter((i) => ints[i] >= 0.6 || i === ordem[0]));
+    const out = [];
+    for (let i = 0; i < n; i++) {
+        const ant = out[i - 1];
+        let mov;
+        if (golpes.has(i) && !(ant && ant.movimento === 'soco')) mov = 'soco';
+        else if (ant && ant.movimento === 'soco') mov = 'parado';     // depois do golpe, respira
+        else if (i === n - 1) mov = ints[i] > 0.4 ? 'recua' : 'parado';
+        else {
+            // O resto pelo que a frase pede, sem repetir o anterior.
+            const pede = ints[i] > 0.45 ? ['reenquadra', 'empurra'] : ints[i] > 0.2 ? ['empurra', 'parado', 'reenquadra'] : ['parado', 'empurra'];
+            const opcoes = pede.filter((m) => !ant || m !== ant.movimento);
+            mov = opcoes[Math.floor(aleatorio() * Math.min(2, opcoes.length)) % opcoes.length];
+        }
+        out.push({ intensidade: ints[i], movimento: mov, recorte: false, whoosh: mov === 'soco' && i > 0 });
+    }
+    // O recorte: as frases mais fortes, com pelo menos 3 frases entre um e outro.
+    const escolhidos = [];
+    for (const i of ordem) {
+        if (escolhidos.length >= maxRecortes || ints[i] < 0.5) break;
+        if (i === 0 || escolhidos.some((j) => Math.abs(j - i) < 3)) continue;
+        escolhidos.push(i);
+        out[i].recorte = true;
+    }
+    return out;
+}
+
+/** A câmera da cena para o movimento decidido. `lado` alterna o reenquadramento. */
+function camera(movimento, dur, intensidade = 0.5, lado = 0, base = 1080) {
+    return (MOVIMENTOS[movimento] || MOVIMENTOS.parado)(dur, Math.max(0, Math.min(1, intensidade)), lado, base);
+}
+
+module.exports = { intensidades, decidir, camera, MOVIMENTOS };