primocode 10.1.0 → 10.3.0-beta.0

package/README.md

@@ -1,4 +1,4 @@
-# PrimoCode v10.0.9
+# PrimoCode v10.3.0-beta.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.3.0-beta.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/act.js

@@ -895,6 +895,11 @@ async function runAct(userPrompt, opts) {
                 + `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) → '
                 + 'estudio_render. Se a peça for de uma marca de verdade, estudio_site antes, e use as cores e a logo em roteiro.marca. '
+                /* "todo vídeo começa igual" (09/10): o cardápio de estruturas e o
+                   que os últimos vídeos usaram. O modelo escolhe; nada aqui força. */
+                + 'ANTES de escrever as partes, escolha a estrutura do roteiro e diga qual em roteiro.estrutura. '
+                + 'SE a pessoa pediu duas vozes, dois narradores ou diálogo: roteiro.vozes {nome: voz} e falante em cada parte.\n'
+                + diretor.cardapioEstruturas() + '\n'
                 + 'NÃO escreva cenas, elementos nem posições à mão. '
                 + 'Se estudio_plano não aceitar "roteiro" (servidor antigo), siga com as ferramentas que você tem. '
                 + 'Nunca chame uma ferramenta que não está na sua lista — a chamada é recusada e a tarefa se perde.' });

package/lib/browser.js

@@ -1296,5 +1296,5 @@ module.exports = {
     scriptDaSeta, verSeta, findChrome,
     open, click, clickText, clickSelector, type, typeInSelector,
     key, screenshot, evaluate, waitFor, wait, scroll, close,
-    inspecionarEscondido, rodarEscondido, abrirEscondido, fecharRevisor, subirRevisor, aquecerRevisor,
+    inspecionarEscondido, rodarEscondido, abrirEscondido, abaEscondida, fecharRevisor, subirRevisor, aquecerRevisor,
 };

package/lib/catalogo.js

@@ -77,7 +77,8 @@ 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 | editar. '
+              args: 'acao: criar | abrir | procurar | listar | anotar | editar | assinatura. '
+                + 'assinatura: quando o usuário diz o que achou de um vídeo ("adorei a virada", "texto demais"), grave com texto (e o id) — o próximo vídeo parte disso; sem texto, lê as faixas e as notas. '
                 + '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). '
@@ -87,24 +88,32 @@ const GRUPOS = [
 
             { tool: 'estudio_plano', escreve: true, faz: 'escreve ou ajusta o que o vídeo É — cenas, elementos, animação, câmera, áudio',
               args: 'id. PREFIRA roteiro: {marca:{cores:{fundo,destaque,tinta},fontes:{titulo,texto},logo}, proporcao, '
-                + 'partes:[{tipo, fala, …}]} — o PrimoCode faz o layout, a voz com entonação, os ícones, a música e os sons. '
+                + 'partes:[{tipo, fala, …}], estrutura} — estrutura é a que VOCÊ escolheu pelo pedido (historia|problema-solucao|lista|pergunta-resposta|dialogo|demonstracao|mito-verdade|dado-surpresa, ou outra com nome); 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; modelo3d fone|celular|notebook|relogio|garrafa|lata|caixa: o objeto gira em 3D numa batida — ponha quando o vídeo é de um produto ou objeto físico; ideia abstrata, história ou explicação: deixe vazio; o vídeo tem UMA identidade (2 chãos, 1 acento, 2 fontes) e o fundo só troca na virada de seção — se o roteiro tem atos, dê secao:"nome curto" nas partes, senão o PrimoCode divide; moldura cantos|completa|false: o quadro fixo do reel (cantos, o assunto no alto, "01 · seção", o tempo) — ponha só se o vídeo pede cara de peça de design; vazio, o PrimoCode alterna com memória e às vezes não põe; heroi em cada parte: o desenho da batida além do texto, tirado do CONTEÚDO — um ícone do Iconify do objeto que a fala cita ("mdi:bread-slice", "mdi:qrcode"; procure com estudio_midia acao:icones), um 3D do kit (raio|relogio|check|balao|escudo|coracao|estrela|sol|play|engrenagem|cadeado|barras|fone|onda|celular|seta|bateria) ou "nenhum" quando a tipografia basta; forma abstrata (explosao|poligono|esfera|toro|truchet|aneis|grade|rastro) só em assunto abstrato ou de tecnologia — numa conversa de padaria, nunca; ambiente limpo|luz|bokeh e acento traco|viagem (o ponto que viaja entre as batidas): vazio, o PrimoCode escolhe com memória e o bokeh quase não sai fora de tecnologia) | 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; fontesFluido aprovado|editorial|revista|carater|tecnico|classico, vazio gira) | 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. '
+                + 'voz (thalita|antonio|francisca). DUAS VOZES (o pedido fala em dois narradores, diálogo, conversa, entrevista): roteiro.vozes {"nome":"antonio","outro":"thalita"} e falante:"nome" em cada parte — cada um sai na sua voz. 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. '
                 + 'motivo (opcional): fica no caderno. voltarPara (opcional): nome de uma versão. '
                 + 'Sem plano nem cenas, LÊ o plano atual. '
                 + 'Cada elemento é {tipo: texto|forma|imagem|video|icone|legenda|componente|kit} com x, y, cor, tamanho e '
                 + '"anima": {propriedade: [{t,v,e}]} — quadros-chave em segundos. A cena tem "camera": {zoom,x,y,rotacao} e '
-                + '"perspectiva" para 3D. NÃO existe layout pronto nem tema — cada propriedade do vídeo é escolha sua, a cada vídeo.' },
+                + '"perspectiva" para 3D. Cena.transicao {tipo,duracao}: corte|esmaecer|deslizar|zoom|giro|mascara|morph|chicote|soco|flash|liquido, '
+                + 'e as 3D virar|cubo|profundidade|inclinar (mexem nas duas cenas) — use 3D se o vídeo pede volume (produto, site, tecnologia); em editorial plano, prefira as planas. '
+                + 'NÃO existe layout pronto nem tema — cada propriedade do vídeo é escolha sua, a cada vídeo.' },
 
             { tool: 'estudio_midia', escreve: true, faz: 'procura e baixa ícone, imagem, música e efeito sonoro da internet, e lista as fontes',
-              args: 'acao: imagem | icones | som | trilha | efeito | fontes. termo. id (para baixar). '
+              args: 'acao: imagem | icones | som | trilha | efeito | fontes | print. termo. id (para baixar). '
+                + 'print: url — tira o print REAL do site e devolve o src e um elemento {tipo:"kit", peca:"printsite"} pronto '
+                + '(o site de verdade numa janela 3D que rola a página; celular: true para a tela do celular; inteira: false só a primeira dobra). '
+                + 'Use SE o pedido trouxer um site e o vídeo for SOBRE ele (lançamento, tour, case); vídeo que só cita a marca não precisa. '
+                + 'efeitos: lista os componentes guardados (os menos usados primeiro). usar-efeito {nome}: copia para o projeto e devolve o elemento — use se um deles servir a ESTE roteiro. '
+                + 'guardar-efeito {arquivo, nome, descricao}: guarda um componente que você escreveu e ficou bom, para os próximos vídeos '
+                + '(o componente: export default de uma função React que recebe {el, t, fps}, num arquivo só, importando só react, remotion, @remotion/*, three). '
                 + 'baixar: o número do item da busca (1 é o primeiro). transparente: true para PNG recortado. '
                 + 'icones: sem "nome", procura; com "nome" ("lucide:zap"), baixa. '
                 + 'Tudo é BAIXADO para a pasta do projeto — o plano nunca aponta para a internet.' },

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/assinatura.js

@@ -0,0 +1,108 @@
+/**
+ * assinatura.js — o estilo como um ARQUIVO com nome e números, que o vídeo
+ * novo é conferido contra e que guarda o que a pessoa disse dos vídeos.
+ *
+ *   Do desmontado do Forseth (rookies-lab, 07/10): o estilo vira um arquivo
+ *   nomeado, e o feedback da pessoa fica gravado nele. O que faltava lá: o
+ *   estilo era prosa, sem número — ninguém conferia se o vídeo seguiu.
+ *
+ * A assinatura de fábrica mora em lib/estudio/assinaturas/<nome>.json: as
+ * faixas medidas do vídeo que o Joel aprovou (08/10). A da pessoa mora em
+ * ~/.primocode/studio/assinaturas/<nome>.json e guarda só o que é dela: as
+ * faixas que ela ajustou e as notas ("adorei a virada", "texto demais").
+ * Lidas juntas: a dela por cima da de fábrica.
+ *
+ *   medir(partitura, plano)   os números do vídeo (os mesmos da assinatura)
+ *   conferir(nome, medidas)   o que saiu da faixa, em uma linha cada
+ *   anotar(nome, texto)       o feedback da pessoa, com a data
+ */
+
+'use strict';
+
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+
+const FABRICA = path.join(__dirname, 'assinaturas');
+const pastaDaPessoa = () => path.join(os.homedir(), '.primocode', 'studio', 'assinaturas');
+const r2 = (n) => Math.round(n * 100) / 100;
+
+function lerJson(arq) { try { return JSON.parse(fs.readFileSync(arq, 'utf8')); } catch { return null; } }
+
+/** A assinatura pelo nome: a de fábrica com a da pessoa por cima. null se não existe nenhuma. */
+function ler(nome) {
+    const n = String(nome || '').toLowerCase().replace(/[^a-z0-9-]/g, '');
+    if (!n) return null;
+    const base = lerJson(path.join(FABRICA, n + '.json'));
+    const dela = lerJson(path.join(pastaDaPessoa(), n + '.json'));
+    if (!base && !dela) return null;
+    const a = { nome: n, faixas: {}, notas: [], ...(base || {}) };
+    if (dela) {
+        for (const [k, v] of Object.entries(dela.faixas || {})) a.faixas[k] = { ...(a.faixas[k] || {}), ...v };
+        a.notas = [...(a.notas || []), ...(dela.notas || [])];
+    }
+    return a;
+}
+
+const mediana = (xs) => { const s = [...xs].sort((a, b) => a - b); return s.length ? (s.length % 2 ? s[(s.length - 1) / 2] : (s[s.length / 2 - 1] + s[s.length / 2]) / 2) : 0; };
+
+/* Uma "frase" na tela: no fluido, b.frases[].palavras; no gerativo, cada
+   linha (b.linhas[], com .palavras ou só .texto). */
+const frasesDe = (b) => [...(b.frases || []), ...(b.linhas || [])]
+    .map((f) => (Array.isArray(f.palavras) ? f.palavras.length : String(f.texto || '').split(/\s+/).filter(Boolean).length));
+
+/** Os números de um vídeo (fluido ou gerativo), da partitura e do plano. */
+function medir(partitura, plano) {
+    const B = (partitura && partitura.batidas) || [];
+    const dur = Number(partitura && partitura.duracao) || 0;
+    if (!B.length || !dur) return null;
+    const palavras = B.flatMap(frasesDe).filter((n) => n > 0);
+    const efeitos = ((plano && plano.audio && plano.audio.efeitos) || []).length;
+    return {
+        batida_mediana_s: r2(mediana(B.map((b) => b.ate - b.de))),
+        palavras_por_frase_max: Math.max(0, ...palavras),
+        palavras_por_frase_mediana: mediana(palavras),
+        // Corte seco: a transição do fluido, ou o fundo do gerativo que troca por corte.
+        cortes_secos: B.filter((b, i) => i > 0 && (b.transicao === 'corte' || b.troca === 'corte')).length,
+        fracao_gigante: r2(B.filter((b) => b.gigante || b.comp === 'gigante').length / B.length),
+        // Virada de fundo: a marcada no fluido, ou o fundo do gerativo que troca (corte, cortina ou inundação).
+        fracao_virada: r2(B.filter((b, i) => b.virada || (i > 0 && b.troca)).length / B.length),
+        efeitos_por_minuto: r2(efeitos / dur * 60),
+    };
+}
+
+/** O que saiu da faixa: [{faixa, valor, min, max, diz}]. Vazio = o vídeo seguiu a assinatura. */
+function conferir(nome, medidas) {
+    const a = ler(nome);
+    if (!a || !medidas) return { assinatura: null, fora: [] };
+    const fora = [];
+    for (const [k, f] of Object.entries(a.faixas || {})) {
+        const v = medidas[k];
+        if (v == null) continue;
+        if ((f.min != null && v < f.min) || (f.max != null && v > f.max)) fora.push({ faixa: k, valor: v, min: f.min, max: f.max, diz: f.diz });
+    }
+    return { assinatura: a.nome, fora };
+}
+
+/** Uma linha por faixa estourada, para o agente e o caderno. */
+function descrever(fora) {
+    return fora.map((x) => `${x.faixa} = ${x.valor} (a assinatura pede ${x.min != null ? x.min : '…'} a ${x.max != null ? x.max : '…'}: ${x.diz || ''})`);
+}
+
+/** O feedback da pessoa fica na assinatura dela, com a data. Devolve quantas notas ela tem. */
+function anotar(nome, texto, quando = new Date()) {
+    const n = String(nome || '').toLowerCase().replace(/[^a-z0-9-]/g, '');
+    const t = String(texto || '').trim();
+    if (!n || !t) return { ok: false, error: 'a assinatura precisa de nome e de texto.' };
+    const arq = path.join(pastaDaPessoa(), n + '.json');
+    const dela = lerJson(arq) || { nome: n, faixas: {}, notas: [] };
+    dela.notas = [...(dela.notas || []), { quando: quando.toISOString().slice(0, 10), texto: t }].slice(-40);
+    try { fs.mkdirSync(pastaDaPessoa(), { recursive: true }); fs.writeFileSync(arq, JSON.stringify(dela, null, 2)); }
+    catch (e) { return { ok: false, error: e.message }; }
+    return { ok: true, assinatura: n, notas: dela.notas.length };
+}
+
+/** As últimas notas, para ir na frente do pedido (o agente lê antes de fazer o próximo vídeo). */
+function notasRecentes(nome, n = 6) { const a = ler(nome); return a ? (a.notas || []).slice(-n) : []; }
+
+module.exports = { ler, medir, conferir, descrever, anotar, notasRecentes, FABRICA };

package/lib/estudio/assinaturas/fluido.json

@@ -0,0 +1,15 @@
+{
+  "nome": "fluido",
+  "estilo": "fluido",
+  "origem": "o vídeo que o Joel aprovou em 08/10/2026 (produtividade-comeca-na-noite-anterior, 35,7 s), medido",
+  "descricao": "Uma ideia por batida, pouco texto, nada de corte seco: a forma de uma batida vira a da próxima. Contraste de escala (palavra gigante) e a virada de fundo nos momentos fortes. O som marca o movimento sem virar ruído.",
+  "faixas": {
+    "batida_mediana_s": { "min": 2.5, "max": 5.5, "medido": 4.0, "diz": "cada batida dura de 3 a 4,5 s" },
+    "palavras_por_frase_max": { "max": 9, "medido": 7, "diz": "no máximo 7 palavras por frase" },
+    "palavras_por_frase_mediana": { "max": 4, "medido": 2, "diz": "o normal é 2 palavras por frase" },
+    "cortes_secos": { "max": 0, "medido": 0, "diz": "zero cortes secos, tudo morfa" },
+    "fracao_gigante": { "min": 0.25, "max": 0.65, "medido": 0.56, "diz": "palavra gigante em perto da metade das batidas" },
+    "fracao_virada": { "min": 0.1, "max": 0.4, "medido": 0.33, "diz": "virada de fundo em ~1 de cada 3 batidas" },
+    "efeitos_por_minuto": { "min": 12, "max": 40, "medido": 26.9, "diz": "uns 27 efeitos sonoros por minuto" }
+  }
+}

package/lib/estudio/assinaturas/gerativo.json

@@ -0,0 +1,15 @@
+{
+  "nome": "gerativo",
+  "estilo": "gerativo",
+  "origem": "o vídeo que o Joel aprovou em 08/10/2026 (teste-e2e-sono, o gerativo do PR #113, 30,3 s), medido",
+  "descricao": "Batida curta e seca, pouco texto por linha, numa identidade só (2 chãos, 1 acento, 2 fontes): o fundo troca na virada de seção, a primeira por corte seco. A palavra gigante entra em ~1 de cada 3 batidas. O som é desenhado da semente e fica mais raro que no fluido.",
+  "faixas": {
+    "batida_mediana_s": { "min": 2, "max": 4.5, "medido": 3.18, "diz": "cada batida dura de 1,7 a 4,5 s, o normal é ~3 s" },
+    "palavras_por_frase_max": { "max": 5, "medido": 3, "diz": "no máximo 3 palavras por linha" },
+    "palavras_por_frase_mediana": { "max": 3, "medido": 2, "diz": "o normal é 1 a 2 palavras por linha" },
+    "cortes_secos": { "min": 1, "medido": 5, "diz": "o fundo troca por corte seco (5 das 9 trocas)" },
+    "fracao_gigante": { "min": 0.15, "max": 0.5, "medido": 0.3, "diz": "palavra gigante em ~1 de cada 3 batidas" },
+    "fracao_virada": { "min": 0, "max": 0.45, "medido": 0.8, "revisto": "09/10/2026: o Joel reprovou o fundo trocando toda batida no vídeo do Pix na padaria (\"do nada preto, do nada branco\"). A faixa saiu de 0,5–1 para 0–0,45; o medido continua o do vídeo de 08/10, que agora fica fora SÓ nesta faixa.", "diz": "o fundo troca só na virada de seção, entre os 2 chãos da identidade (uns 2 a cada 10 batidas)" },
+    "efeitos_por_minuto": { "min": 6, "max": 30, "medido": 15.84, "diz": "uns 16 efeitos sonoros por minuto" }
+  }
+}

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 };