primocode 10.0.9 → 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
 ```
@@ -352,7 +352,7 @@ primocode -c                           # continua a última conversa salva (--co
 
 ```json
 {
-  "server": "https://primocode-server.onrender.com",
+  "server": "https://primocode-server-production.up.railway.app",
   "model": "main",
   "token": null
 }
@@ -361,7 +361,7 @@ primocode -c                           # continua a última conversa salva (--co
 Ou por variável de ambiente — elas têm prioridade:
 
 ```bash
-export PRIMOCODE_SERVER="https://primocode-server.onrender.com"
+export PRIMOCODE_SERVER="https://primocode-server-production.up.railway.app"
 export PRIMOCODE_MODEL="main"
 export PRIMOCODE_TOKEN="..."   # só se o servidor exigir
 ```

package/bin/primocode.js

@@ -36,6 +36,7 @@ const skills = require('../lib/skills');
 const checkpoint = require('../lib/checkpoint');
 const comandosLib = require('../lib/comandos');
 const marketplace = require('../lib/marketplace');
+const portaoSkill = require('../lib/portao-skill');
 const vozModo = require('../lib/voz');
 const conta = require('../lib/conta');
 const nuvem = require('../lib/nuvem');
@@ -1003,10 +1004,26 @@ async function instalarSkill() {
     console.log('');
     const caminho = String(await ask('  ' + c.brand('❯ ') + c.white('Caminho do SKILL.md: '))).trim();
     if (!caminho) return;
-    const r = skills.instalarDe(caminho);
+    const r = await instalarComPortao(caminho);
     console.log(r.ok ? c.ok(`  Skill instalada: ${r.nome}`) : c.err(`  ${r.error}`));
 }
 
+/* Instala passando pelo portão (lib/portao-skill.js). Achou algo: mostra cada
+   achado com arquivo:linha e faz a mesma pergunta do que não tem volta
+   (autorizarControle) — Enter sozinho é NÃO. */
+async function instalarComPortao(caminho) {
+    const r = skills.instalarDe(caminho);
+    if (!r.bloqueada) return r;
+    console.log('');
+    console.log('  ' + c.err(r.error));
+    for (const linha of portaoSkill.descrever(r.achados).slice(0, 20)) console.log('    ' + c.warn(linha));
+    if (r.achados.length > 20) console.log(c.dim(`    … e mais ${r.achados.length - 20}`));
+    console.log('  ' + c.dim('Leia cada linha: o portão acha padrão, não intenção.'));
+    const resposta = await autorizarControle(`instalar a skill de ${caminho} mesmo assim`, { tipo: 'perigo' });
+    if (resposta !== 'agora' && resposta !== 'sessao') return { ok: false, error: 'Skill não instalada.' };
+    return skills.instalarDe(caminho, { forcar: true });
+}
+
 async function sendPrompt(userText) {
     /* O portão do plano. Sem ele o bloqueio da abertura seria só um texto na
        tela: a pessoa leria "você não tem acesso" e mandaria a primeira coisa
@@ -1071,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
@@ -2218,7 +2215,7 @@ async function handleSlash(text) {
                 console.log(c.dim('  Ou abra o ') + c.brand('/marketplace') + c.dim(' e escolha "New Skill" para escrever uma.'));
                 break;
             }
-            const r = skills.instalarDe(rest);
+            const r = await instalarComPortao(rest);
             if (!r.ok) { console.log(c.err(`  ${r.error}`)); break; }
             console.log(c.ok(`  Skill instalada: ${r.nome}`) + c.muted(`  (${shortPath(r.caminho)})`));
             console.log(c.dim('  Já está ligada. /skills mostra todas.'));

package/lib/act.js

@@ -849,10 +849,13 @@ async function runAct(userPrompt, opts) {
      * um diretor dentro do diretor é uma volta a mais para o mesmo lugar. */
     if (!subagent && profundidade === 0) {
         const diretor = require('./estudio/diretor.js');
+        // Vídeo que o Estúdio fez se edita no Remotion Studio, não no editor por linha do tempo.
+        const EDITAR_DO_ESTUDIO = 'SE ELA QUER EDITAR UM VÍDEO QUE O ESTÚDIO FEZ (não uma gravação dela): '
+            + 'estudio_projeto acao:"editar" com o id do projeto abre o Remotion Studio no navegador; diga a pasta a ela e pare.\n';
         const producao = diretor.precisaDeProducao(pedido);
         if (diretor.precisaDeEdicao(pedido)) {
             // A gravação da pessoa: o editor por linha do tempo (lib/video/), pelo run_shell.
-            messages.push({ role: 'system', content: 'PARA EDITAR A GRAVAÇÃO DA PESSOA use o editor por linha do tempo via run_shell: '
+            messages.push({ role: 'system', content: EDITAR_DO_ESTUDIO + 'PARA EDITAR A GRAVAÇÃO DA PESSOA use o editor por linha do tempo via run_shell: '
                 + 'SE A PESSOA SÓ DISSE "edite esse vídeo" (sem dizer o quê), O VÍDEO É O PEDIDO: `primocode video import --json \'{"path":"<arquivo>"}\'`, '
                 + 'depois `primocode video auto --json \'{}\'` (lê o que ela FALA na gravação e aplica cada efeito no momento em que diz), inspect, export e abra o mp4. '
                 + 'Senão: '
@@ -887,7 +890,7 @@ async function runAct(userPrompt, opts) {
                resposta é o modelo. Então isto é o caminho SE for produzir, e não
                mais uma ordem de produzir. */
             messages.push({ role: 'system', content:
-                'VOCÊ DECIDE o que entregar, pelo que a pessoa pediu: se ela quer só o roteiro, a ideia, um texto ou uma resposta, ESCREVA isso e pare — não produza vídeo. '
+                EDITAR_DO_ESTUDIO + 'VOCÊ DECIDE o que entregar, pelo que a pessoa pediu: se ela quer só o roteiro, a ideia, um texto ou uma resposta, ESCREVA isso e pare — não produza vídeo. '
                 + `SE ela quer a peça pronta (formato "${producao.formato === 'apresentacao' ? 'slides' : 'video'}"), faça em três passos: `
                 + `estudio_projeto acao:"criar" com formato "${producao.formato === 'apresentacao' ? 'slides' : 'video'}" → `
                 + 'estudio_plano com "roteiro" (partes com tipo e fala; o PrimoCode faz layout, voz, ícones, música e sons) → '

package/lib/catalogo.js

@@ -77,7 +77,9 @@ const GRUPOS = [
         resumo: 'vídeo, motion, slides e arte — a IA faz, e no fim abre o resultado pronto',
         itens: [
             { tool: 'estudio_projeto', escreve: true, faz: 'abre, acha e lista os projetos do estúdio — cada peça é uma pasta que não some',
-              args: 'acao: criar | abrir | procurar | listar | anotar. '
+              args: 'acao: criar | abrir | procurar | listar | anotar | editar. '
+                + 'editar: id (sem id, o mais novo) — quando o usuário quer EDITAR um vídeo que o Estúdio fez, '
+                + 'abre o projeto no Remotion Studio (o editor, no navegador) e devolve a pasta. '
                 + 'criar: titulo, pedido, formato (video|slides|arte). '
                 + 'abrir: id — devolve o plano, o CADERNO (o que foi decidido e por quê) e os arquivos. '
                 + 'procurar: texto — acha pelo que o usuário lembra ("aquele do PicPay"), inclusive por detalhe do meio do processo. '
@@ -88,9 +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). '
-                + '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) | impacto | cinema. '
+                + '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 (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/config.js

@@ -273,6 +273,14 @@ function podarMemoriaGeral() {
     } catch {}
 }
 
+/* O servidor saiu do Render pro Railway da Paris Group (05/10). Quem gravou o
+   endereço antigo no config.json vai pro novo: o Render vai ser desligado. */
+const SERVIDOR = 'https://primocode-server-production.up.railway.app';
+const SERVIDOR_ANTIGO = /^https?:\/\/primocode-server\.onrender\.com\/?$/;
+function servidor(escolhido) {
+    return !escolhido || SERVIDOR_ANTIGO.test(String(escolhido).trim()) ? SERVIDOR : escolhido;
+}
+
 function loadConfig() {
     ensureStructure();
     let file = {};
@@ -280,7 +288,7 @@ function loadConfig() {
         if (fs.existsSync(CONFIG_FILE)) file = JSON.parse(fs.readFileSync(CONFIG_FILE, 'utf8'));
     } catch { file = {}; }
     return {
-        server: process.env.PRIMOCODE_SERVER || file.server || 'https://primocode-server.onrender.com',
+        server: servidor(process.env.PRIMOCODE_SERVER || file.server),
         model: process.env.PRIMOCODE_MODEL || file.model || 'main',
         // Esforço, estilo Claude Code (/effort). É o que o usuário escolhe; o
         // modelo é derivado dele. Guardado para durar entre sessões.
@@ -363,7 +371,7 @@ function esquecerProjeto() {
 module.exports = {
     tokensDoAssunto, GENERICAS,
     lembrarProjeto, projetoLembrado, esquecerProjeto, PROJETO_ATIVO_FILE,
-    loadConfig, saveConfig, appendHistory,
+    loadConfig, saveConfig, appendHistory, servidor, SERVIDOR,
     CONFIG_DIR, CONFIG_FILE, HISTORY_FILE, ROOT_DIR, GENERAL_MEMORY,
     ensureStructure, slugify, stripAccents,
     createProjectDir, getProjectDir, listProjects, findSimilarProject,

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 });
@@ -329,12 +403,18 @@ async function procurarMusica(termo, { quantas = 8, duracaoMin = 45 } = {}) {
     return procurarSom(termo, { quantas, duracaoMin });
 }
 
-async function procurarSom(termo, { quantas = 8, duracaoMin = 0, duracaoMax = 0 } = {}) {
+/* `livre`: só domínio público (CC0 e PDM). O efeito sonoro entra no vídeo sem
+   crédito, então não pode ser CC-BY, que o "commercial" deixa passar. */
+function urlSom(termo, { quantas = 8, duracaoMin = 0, livre = false } = {}) {
+    let url = `https://api.openverse.org/v1/audio/?q=${encodeURIComponent(termo)}`
+        + `&page_size=${quantas}` + (livre ? '&license=cc0,pdm' : '&license_type=commercial');
+    if (duracaoMin && duracaoMin < 30) url += '&length=short';
+    return url;
+}
+
+async function procurarSom(termo, { quantas = 8, duracaoMin = 0, duracaoMax = 0, livre = false } = {}) {
     try {
-        let url = `https://api.openverse.org/v1/audio/?q=${encodeURIComponent(termo)}`
-            + `&page_size=${quantas}&license_type=commercial`;
-        if (duracaoMin && duracaoMin < 30) url += '&length=short';
-        const r = await pegar(url, { json: true });
+        const r = await pegar(urlSom(termo, { quantas, duracaoMin, livre }), { json: true });
         const sons = (r.results || [])
             .filter((x) => !duracaoMax || !x.duration || x.duration / 1000 <= duracaoMax)
             .filter((x) => !duracaoMin || !x.duration || x.duration / 1000 >= duracaoMin)
@@ -412,6 +492,6 @@ module.exports = {
     extensaoPorConteudo,
     pegar, guardar,
     icone, procurarIcones, iconesDoPlano, COLECOES, procurarVideos, procurarMusica,
-    procurarImagens, procurarSom, 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 };