primocode 10.2.0 → 10.3.0

package/README.md

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

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). 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. '
+                + '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/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/diretor.js

@@ -115,9 +115,62 @@ function ritmoPara(segundos) {
         palavrasPorCena: Math.round(media * 2.6) };   // ~155 palavras/minuto de narração
 }
 
+// ── 2b. a estrutura: um cardápio, e a memória do que já saiu ─────────────
+
+/* "o roteiro vicia: todo vídeo começa igual, não escolhe outra estrutura"
+   (Joel, 09/10). A regra 3 do diretor tinha UM arco só — prende em 2
+   segundos, entrega, pede ação — e o produtor nem isso via: todo roteiro
+   saía com a mesma abertura de impacto e o mesmo miolo de lista. Aqui não
+   tem regex escolhendo pelo pedido: o modelo recebe o CARDÁPIO (cada
+   estrutura com o "quando serve" e o jeito de abrir) e o que os últimos
+   vídeos já usaram. Quem escolhe é ele; o código só lembra. */
+const ESTRUTURAS = [
+    { id: 'historia', nome: 'história', quando: 'tem uma pessoa, um caso real ou um antes e depois', abre: 'uma cena concreta: alguém, um lugar, um momento ("Às 6h, a Ana abriu o caixa e…")' },
+    { id: 'problema-solucao', nome: 'problema → solução', quando: 'o assunto resolve uma dor clara', abre: 'a dor dita como quem sente ("Você perde duas horas por semana com…")' },
+    { id: 'lista', nome: 'lista', quando: 'são dicas, razões ou passos que se sustentam sozinhos', abre: 'a promessa com o número ("3 erros que…")' },
+    { id: 'pergunta-resposta', nome: 'pergunta → resposta', quando: 'o público já tem uma dúvida', abre: 'a pergunta, direta, sem a resposta ainda' },
+    { id: 'dialogo', nome: 'diálogo', quando: 'o pedido fala em duas pessoas, duas vozes, conversa ou entrevista', abre: 'a fala de um, e o outro responde' },
+    { id: 'demonstracao', nome: 'demonstração', quando: 'o valor está em VER funcionando', abre: 'o resultado pronto primeiro; depois, como se chega lá' },
+    { id: 'mito-verdade', nome: 'contraste (mito × verdade)', quando: 'existe uma crença comum que está errada', abre: 'o mito, dito como se fosse verdade' },
+    { id: 'dado-surpresa', nome: 'dado que surpreende', quando: 'há um número que muda o jeito de ver o assunto', abre: 'o número sozinho, e a frase que diz por que ele importa' },
+];
+
+const vari = () => require('./variedade.js');   // tardio: a memória mora em ~/.primocode/studio
+const idEstrutura = (x) => String(x || '').toLowerCase().normalize('NFD').replace(/[̀-ͯ]/g, '')
+    .replace(/[^a-z0-9]+/g, '-').replace(/^-|-$/g, '').slice(0, 40);
+
+/** As últimas estruturas e aberturas que saíram em vídeo, mais nova primeiro. */
+function recentes(n = 3) {
+    return { estruturas: vari().usadas('estrutura').slice(0, n), aberturas: vari().usadas('abertura').slice(0, n) };
+}
+
+/** O cardápio em texto, para o prompt — com o que foi usado por último. */
+function cardapioEstruturas({ usadas = recentes() } = {}) {
+    const linhas = ESTRUTURAS.map((e) => `- ${e.id} (${e.nome}): se ${e.quando}. Abre com ${e.abre}.`);
+    if (usadas.estruturas.length) linhas.push(`Usadas recentemente: ${usadas.estruturas.join(', ')} — prefira outra, a menos que o pedido peça essa.`);
+    if (usadas.aberturas.length) linhas.push(`Os últimos vídeos começaram assim: ${usadas.aberturas.map((a) => `"${a}"`).join(' · ')} — não comece do mesmo jeito.`);
+    linhas.push('Nenhuma serve? Invente a estrutura e dê um nome a ela.');
+    return 'CARDÁPIO DE ESTRUTURAS (você escolhe pelo pedido):\n' + linhas.join('\n');
+}
+
+/**
+ * Depois que o roteiro virou plano: guarda a estrutura que o modelo escolheu
+ * e como o vídeo abriu. Aceita o roteiro (partes/fala) ou o plano do diretor
+ * (cenas/narracao). Não julga a escolha — só lembra dela.
+ */
+function registrarEstrutura(r) {
+    const x = r && typeof r === 'object' ? r : {};
+    const estrutura = idEstrutura(x.estrutura) || null;
+    const p0 = (x.partes || x.cenas || [])[0] || {};
+    const abertura = String(p0.fala || p0.narracao || p0.titulo || '').split(/\s+/).filter(Boolean).slice(0, 8).join(' ') || null;
+    if (estrutura) vari().marcar('estrutura', estrutura);
+    if (abertura) vari().marcar('abertura', abertura);
+    return { estrutura, abertura };
+}
+
 // ── 3. o plano ───────────────────────────────────────────────────────────
 
-const CAMPOS_CENA = ['titulo', 'narracao', 'duracao', 'aTela', 'fundo', 'transicao',
+const CAMPOS_CENA = ['titulo', 'falante', 'narracao', 'duracao', 'aTela', 'fundo', 'transicao',
     'elementos', 'midia', 'camera', 'chaves', 'notas'];
 
 /**
@@ -170,6 +223,7 @@ function normalizarPlano(bruto, { segundos } = {}) {
         tom: p.tom || 'neutro',
         publico: p.publico || null,
         promessa: p.promessa || null,          // o que a pessoa leva do vídeo
+        estrutura: idEstrutura(p.estrutura) || null,
         segundos: total,
         voz: vozPara({ tom: p.tom, idioma: p.idioma || 'pt-BR',
             genero: p.voz && p.voz.genero }),
@@ -181,6 +235,9 @@ function normalizarPlano(bruto, { segundos } = {}) {
         midia: limpas.flatMap((c, i) => c.midia.map((m) => ({ cena: i + 1, ...m }))),
         creditos: !!p.creditos,
     };
+    // Duas vozes (falantes.js): o mapa e quem fala cada cena, quando o diretor escreveu diálogo.
+    const { vozes } = require('./falantes.js').normalizar({ vozes: p.vozes, partes: limpas });
+    if (vozes) plano.vozes = vozes;
     return { plano, defeitos, ok: defeitos.length === 0 };
 }
 
@@ -197,6 +254,7 @@ Devolva SÓ um bloco \`\`\`json com este formato, sem texto antes nem depois:
 
 {
   "titulo": "…",
+  "estrutura": "o id que você escolheu no cardápio abaixo (ou o nome da que inventou)",
   "formato": "${formato}",
   "proporcao": "16:9 | 9:16 | 1:1 | 4:5",
   "visual": "a direção de arte em uma ou duas frases: paleta (diga as cores em hex), que ar tem (limpo, denso, luminoso, sujo), que tipografia pede. NÃO existe lista de temas — descreva o que este vídeo tem de próprio.",
@@ -204,9 +262,11 @@ Devolva SÓ um bloco \`\`\`json com este formato, sem texto antes nem depois:
   "publico": "para quem é",
   "promessa": "o que a pessoa leva ao terminar de ver",
   "trilha": { "busca": "termo de busca da música", "humor": "…", "volume": 0.18 },
+  "vozes": { "nome de quem fala": "antonio | thalita | francisca" },
   "cenas": [
     {
       "titulo": "o que aparece grande na tela",
+      "falante": "quem fala esta cena (um nome de vozes) — só quando houver mais de uma voz",
       "narracao": "a frase FALADA, escrita para ser lida em voz alta",
       "duracao": 3.5,
       "aTela": "o que se vê nesta cena, descrito como você descreveria para um motion designer: onde está cada coisa, que tamanho tem, o que domina o quadro",
@@ -223,13 +283,16 @@ Devolva SÓ um bloco \`\`\`json com este formato, sem texto antes nem depois:
 REGRAS QUE SEPARAM UM VÍDEO BOM DE UM GENÉRICO:
 1. NARRAÇÃO É FALA, NÃO LEGENDA. "Vantagens" não é narração. Escreva a frase que a pessoa ouve.
 2. O QUE SE OUVE E O QUE SE VÊ NÃO SE REPETEM. A tela mostra a prova (número, imagem, logo); a voz conta o que ela significa.
-3. ARCO. Primeira cena prende em 2 segundos, o miolo entrega, a última pede uma ação. Sem "Introdução / Desenvolvimento / Conclusão".
+3. ESTRUTURA. Escolha no cardápio do fim a que serve a ESTE pedido; a primeira cena abre do jeito dela e prende em 2 segundos, a última pede uma ação. Sem "Introdução / Desenvolvimento / Conclusão".
 4. NÚMERO É CONCRETO. Nada de "muitos clientes": ou tem o número, ou a frase muda.
 5. RITMO VARIADO. Cenas de durações diferentes e transições diferentes. Tudo em fade parece slide.
 5b. NADA DE GAVETA. Não existe tema pronto, layout pronto nem fundo pronto: é você que decide a cor, a tipografia e a composição DESTE vídeo. Dois vídeos seus sobre assuntos diferentes não podem sair parecidos.
 6. MÍDIA COM PROPÓSITO. Só peça imagem ou logo quando ela PROVA algo. Diga o termo de busca de verdade ("painel solar em telhado residencial", não "imagem legal").
 7. MOVIMENTO. Em cada cena diga em "chaves" o movimento principal — é ele que tira a cara de apresentação parada.
-8. CÂMERA COM PARCIMÔNIA. Movimento de quadro em UMA cena a cada duas ou três ("camera": "nenhuma" nas outras): o que dá ritmo é alternar cena parada e cena que se move. Em cena com foto de fundo, prefira "aproximar" ou "empurrar".`;
+8. CÂMERA COM PARCIMÔNIA. Movimento de quadro em UMA cena a cada duas ou três ("camera": "nenhuma" nas outras): o que dá ritmo é alternar cena parada e cena que se move. Em cena com foto de fundo, prefira "aproximar" ou "empurrar".
+9. UMA VOZ OU DUAS. Se o pedido fala em dois narradores, duas vozes, diálogo, conversa ou entrevista, escreva como DIÁLOGO: dê nome a cada um em "vozes" (com vozes diferentes) e diga em cada cena quem fala ("falante"). Com uma voz só, deixe "vozes" e "falante" de fora.
+
+${cardapioEstruturas()}`;
 };
 
 const REVISAO = (defeitos) => `O plano voltou com defeitos de FORMA. Corrija SÓ o que está listado e devolva o JSON inteiro de novo, no mesmo formato:
@@ -289,9 +352,11 @@ function pauta(plano) {
     linhas.push(`PLANO DE PRODUÇÃO — ${p.titulo}`);
     linhas.push(`formato ${p.formato} · ${p.proporcao} · ${p.segundos}s · tom ${p.tom}`);
     if (p.visual) linhas.push(`visual: ${p.visual}`);
+    if (p.estrutura) linhas.push(`estrutura: ${p.estrutura} (mande em roteiro.estrutura)`);
     if (p.promessa) linhas.push(`promessa: ${p.promessa}`);
     if (p.publico) linhas.push(`público: ${p.publico}`);
     linhas.push(`voz: ${p.voz && p.voz.perfil} · ${p.voz && p.voz.instrucao} · ${p.voz && p.voz.idioma}`);
+    if (p.vozes) linhas.push(`vozes: ${Object.entries(p.vozes).map(([k, v]) => `${k} = ${v}`).join(', ')} (mande em roteiro.vozes, e falante em cada parte)`);
     if (p.trilha) linhas.push(`trilha: ${p.trilha.busca || p.trilha.arquivo} (volume ${p.trilha.volume})`);
     linhas.push('');
     (p.cenas || []).forEach((c, i) => {
@@ -299,7 +364,7 @@ function pauta(plano) {
         if (c.titulo) linhas.push(`  na tela: ${c.titulo}`);
         if (c.aTela) linhas.push(`  composição: ${c.aTela}`);
         if (c.fundo) linhas.push(`  fundo: ${typeof c.fundo === 'string' ? c.fundo : JSON.stringify(c.fundo)}`);
-        linhas.push(`  narração: ${c.narracao}`);
+        linhas.push(`  narração${c.falante ? ` (${c.falante})` : ''}: ${c.narracao}`);
         if (c.camera && c.camera !== 'nenhuma') linhas.push(`  câmera: ${c.camera}`);
         if (c.chaves) linhas.push(`  movimento: ${c.chaves}`);
         (c.midia || []).forEach((m) => linhas.push(
@@ -314,6 +379,7 @@ function pauta(plano) {
 
 module.exports = {
     precisaDeProducao, precisaDeEdicao, vozPara, ritmoPara,
+    ESTRUTURAS, recentes, cardapioEstruturas, registrarEstrutura,
     normalizarPlano, extrairJSON, planejar, pauta,
     DIRETOR, REVISAO,
 };

package/lib/estudio/efeitos.js

@@ -0,0 +1,95 @@
+/**
+ * efeitos.js — o efeito que a IA escreveu num vídeo fica para os próximos.
+ *
+ *   "Quero mais animações, mais efeitos, e que possa criar tudo isso
+ *    também." (Joel, 09/10/2026)
+ *
+ * O `componente` (plano.js) é a válvula: quando nenhuma primitiva alcança, a
+ * IA escreve um arquivo React na pasta do projeto. Só que ele morria com o
+ * projeto — o efeito bonito do vídeo de terça não existia para o de quarta,
+ * e a IA reescrevia do zero (ou pior, nem lembrava que tinha feito).
+ *
+ * Aqui o componente que ficou bom é GUARDADO em ~/.primocode/studio/efeitos/
+ * com nome e descrição, e volta como cardápio: os menos usados primeiro,
+ * pela mesma memória de variedade das trilhas e dos ícones (variedade.js,
+ * tipo 'efeito'). Guardar e reusar são escolhas do modelo; nada entra no
+ * vídeo sozinho.
+ *
+ * Antes de guardar, a fonte é conferida: o efeito vai rodar em OUTROS
+ * projetos, então import relativo (o arquivo vizinho não vai junto),
+ * Math.random/Date.now (cada render sai diferente) e timer (quadro
+ * repetido) são recusados com o motivo.
+ */
+
+'use strict';
+
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+const variedade = require('./variedade.js');
+
+const pasta = () => path.join(os.homedir(), '.primocode', 'studio', 'efeitos');
+const catalogoArq = () => path.join(pasta(), 'catalogo.json');
+const PACOTES = /^(react|react\/jsx-runtime|remotion|@remotion\/[a-z-]+|three|three\/examples\/jsm\/.+|@react-three\/fiber)$/;
+const TETO = 150 * 1024;
+
+function ler() {
+    try { const c = JSON.parse(fs.readFileSync(catalogoArq(), 'utf8')); return Array.isArray(c) ? c : []; } catch { return []; }
+}
+
+/** O que impede este código de rodar em outro projeto. [] = pode guardar. */
+function conferirFonte(codigo) {
+    const falta = [];
+    const sem = String(codigo || '').replace(/\/\*[\s\S]*?\*\//g, '').replace(/\/\/.*$/gm, '');
+    if (!/export\s+(default|function|const)/.test(sem)) falta.push('o arquivo não exporta o componente (export default function …)');
+    for (const m of sem.matchAll(/(?:from\s+|import\s*\(\s*|require\s*\(\s*)['"]([^'"]+)['"]/g)) {
+        if (!PACOTES.test(m[1])) falta.push(`import "${m[1]}": só react, remotion, @remotion/*, three e @react-three/fiber — o arquivo vai sozinho para outro projeto`);
+    }
+    if (/Math\.random|Date\.now/.test(sem)) falta.push('Math.random/Date.now: cada render sairia diferente — use random("semente") do Remotion');
+    if (/setTimeout|setInterval|requestAnimationFrame/.test(sem)) falta.push('timer não existe no render quadro a quadro — anime pelo quadro (useCurrentFrame ou a prop t)');
+    return falta;
+}
+
+/** Guarda o componente do projeto no catálogo, com nome e descrição. */
+function guardar({ pasta: proj, arquivo, nome, descricao, tags = [] } = {}) {
+    const slug = String(nome || '').toLowerCase().normalize('NFD').replace(/[̀-ͯ]/g, '').replace(/[^a-z0-9]+/g, '-').replace(/^-|-$/g, '');
+    if (slug.length < 2) return { ok: false, error: 'dê um nome ao efeito (nome), como "vidro-quebrando".' };
+    if (!String(descricao || '').trim()) return { ok: false, error: 'diga o que o efeito faz (descricao) — é o que você vai ler no cardápio depois.' };
+    if (!proj || !arquivo) return { ok: false, error: 'diga o projeto (id) e o arquivo do componente (arquivo).' };
+    const cheio = path.resolve(proj, arquivo);
+    if (!cheio.startsWith(path.resolve(proj) + path.sep) || !/\.(jsx|js|tsx)$/.test(cheio)) return { ok: false, error: 'o arquivo é um .jsx/.js dentro da pasta do projeto.' };
+    if (!fs.existsSync(cheio)) return { ok: false, error: `o arquivo "${arquivo}" não existe no projeto.` };
+    const codigo = fs.readFileSync(cheio, 'utf8');
+    if (codigo.length > TETO) return { ok: false, error: 'o componente passa de 150 KB — guarde a parte que é o efeito.' };
+    const falta = conferirFonte(codigo);
+    if (falta.length) return { ok: false, error: 'não guardei: ' + falta.join('; ') };
+    fs.mkdirSync(pasta(), { recursive: true });
+    fs.writeFileSync(path.join(pasta(), slug + '.jsx'), codigo);
+    const item = { nome: slug, descricao: String(descricao).trim().slice(0, 300), tags: [].concat(tags || []).map(String).slice(0, 8), guardado: new Date().toISOString().slice(0, 10) };
+    fs.writeFileSync(catalogoArq(), JSON.stringify([item, ...ler().filter((x) => x.nome !== slug)], null, 2));
+    return { ok: true, ...item };
+}
+
+/** O cardápio: os guardados, os menos usados primeiro (memória da variedade). */
+function cardapio({ aleatorio = Math.random } = {}) {
+    const itens = ler().filter((x) => fs.existsSync(path.join(pasta(), x.nome + '.jsx')));
+    return variedade.pontuar(itens, 'efeito', { chave: (x) => x.nome })
+        .map((p) => ({ ...p, pontos: p.pontos + aleatorio() * 0.05 }))
+        .sort((a, b) => b.pontos - a.pontos)
+        .map((p) => ({ nome: p.opcao.nome, descricao: p.opcao.descricao, tags: p.opcao.tags }));
+}
+
+/** Copia o efeito para o projeto e devolve o elemento pronto. Marca o uso. */
+function reusar({ pasta: proj, nome } = {}) {
+    const item = ler().find((x) => x.nome === nome);
+    const de = item && path.join(pasta(), item.nome + '.jsx');
+    if (!item || !fs.existsSync(de)) return { ok: false, error: `não há efeito "${nome}" guardado — veja o cardápio (acao: efeitos).` };
+    if (!proj) return { ok: false, error: 'diga o projeto (id).' };
+    const src = `efeitos/${item.nome}.jsx`;
+    fs.mkdirSync(path.join(proj, 'efeitos'), { recursive: true });
+    fs.copyFileSync(de, path.join(proj, src));
+    variedade.marcar('efeito', item.nome);
+    return { ok: true, src, descricao: item.descricao, elemento: { tipo: 'componente', src, x: 0, y: 0 } };
+}
+
+module.exports = { guardar, cardapio, reusar, conferirFonte, pasta };

package/lib/estudio/falantes.js

@@ -0,0 +1,97 @@
+/**
+ * falantes.js — quem fala cada parte do roteiro.
+ *
+ *   "fiz um teste de um vídeo com duas narrações e ele fez de uma narração
+ *    só, uma voz só" (Joel, 09/10)
+ *
+ * O roteiro tinha UMA voz (roteiro.voz) e nenhum lugar para dizer quem fala o
+ * quê: pedir diálogo ou dois narradores não tinha como chegar na narração. O
+ * contrato agora tem dois campos, os dois opcionais:
+ *   roteiro.vozes  = { "ana": "thalita", "bruno": "antonio" }
+ *   parte.falante  = "ana"
+ * Sem eles, nada muda: roteiro.voz segue valendo para tudo. Quem decide se o
+ * vídeo é diálogo é o modelo, pelo pedido; aqui só se lê o que ele escreveu.
+ */
+
+'use strict';
+
+// As vozes do Studio (thalita | antonio | francisca). Para quem ficou sem voz no mapa.
+const PAR = ['antonio', 'thalita', 'francisca'];
+
+const nomeFalante = (x) => (typeof x === 'string' ? x.trim().toLowerCase().slice(0, 40) : '');
+
+/** Limpa vozes e falantes do roteiro (o que não for texto sai). Devolve o mesmo objeto. */
+function normalizar(roteiro) {
+    const r = roteiro && typeof roteiro === 'object' ? roteiro : {};
+    if (r.vozes && typeof r.vozes === 'object' && !Array.isArray(r.vozes)) {
+        const limpo = {};
+        for (const [k, v] of Object.entries(r.vozes)) if (nomeFalante(k) && typeof v === 'string' && v.trim()) limpo[nomeFalante(k)] = v.trim();
+        if (Object.keys(limpo).length) r.vozes = limpo; else delete r.vozes;
+    } else delete r.vozes;
+    for (const pt of Array.isArray(r.partes) ? r.partes : []) {
+        if (!pt || typeof pt !== 'object' || !('falante' in pt)) continue;
+        if (nomeFalante(pt.falante)) pt.falante = nomeFalante(pt.falante); else delete pt.falante;
+    }
+    return r;
+}
+
+/**
+ * A voz de cada parte, na ordem. Com falante e voz no mapa, a do mapa; com
+ * falante FORA do mapa (o modelo deu nome e esqueceu a voz), a próxima do par
+ * que ainda não fala — dois falantes nunca saem com a mesma voz por esquecimento;
+ * sem falante, a `padrao` (roteiro.voz).
+ */
+function vozesDasPartes(partes, roteiro = {}, padrao = '') {
+    const mapa = { ...((roteiro && roteiro.vozes) || {}) };
+    const ocupadas = new Set(Object.values(mapa).map((v) => String(v).toLowerCase()));
+    if (padrao) ocupadas.add(String(padrao).toLowerCase());
+    return (partes || []).map((pt) => {
+        const f = nomeFalante(pt && pt.falante);
+        if (!f) return padrao || '';
+        if (!mapa[f]) {
+            mapa[f] = PAR.find((v) => !ocupadas.has(v)) || PAR[Object.keys(mapa).length % PAR.length];
+            ocupadas.add(mapa[f]);
+        }
+        return mapa[f];
+    });
+}
+
+/**
+ * A narração por falante: as falas seguidas da mesma voz viram um grupo, cada
+ * grupo é narrado na sua voz (narrarUm — a mesma corrente Gemini → Kokoro →
+ * Edge de sempre), e os mp3 são juntados na ordem (juntar). Os tempos de cada
+ * parte andam pela duração dos grupos de antes: o vídeo segue a voz certa.
+ * Uma voz só: um grupo só, e é exatamente a narração de antes.
+ *
+ * @param {Array<{texto:string, voz?:string}>} lista
+ * @param {(lista, mp3, voz) => Promise<{ok, segundos, partes, voz}>} op.narrarUm
+ * @param {(arquivos, mp3) => Promise<{ok, duracoes?:number[]}>} op.juntar
+ */
+async function narrarPorFalante(lista, mp3, { narrarUm, juntar }) {
+    const grupos = [];
+    for (const { voz = '', ...x } of lista) {
+        const g = grupos[grupos.length - 1];
+        if (g && g.voz === voz) g.itens.push(x); else grupos.push({ voz, itens: [x] });
+    }
+    if (grupos.length <= 1) return narrarUm(grupos.length ? grupos[0].itens : [], mp3, grupos.length ? grupos[0].voz : '');
+    const feitos = [];
+    for (const [i, g] of grupos.entries()) {
+        const arq = mp3.replace(/\.mp3$/, '') + `-falante${i + 1}.mp3`;
+        const v = await narrarUm(g.itens, arq, g.voz);
+        if (!v || !v.ok) return { ok: false, error: `a voz ${g.voz || 'padrão'} falhou: ${(v && v.error) || 'sem resposta'}` };
+        feitos.push({ arq, v });
+    }
+    const j = await juntar(feitos.map((x) => x.arq), mp3);
+    if (!j || !j.ok) return { ok: false, error: (j && j.error) || 'não juntei as vozes' };
+    let antes = 0;
+    const partes = [];
+    feitos.forEach(({ v }, i) => {
+        const mais = (t) => Math.round((t + antes) * 1000) / 1000;
+        for (const pt of v.partes || []) partes.push({ ...pt, de: mais(pt.de), ate: mais(pt.ate), palavras: (pt.palavras || []).map((w) => ({ ...w, de: mais(w.de), ate: mais(w.ate) })) });
+        // A duração MEDIDA do arquivo quando quem juntou mediu; senão a que a voz disse.
+        antes += Number((j.duracoes || [])[i]) || Number(v.segundos) || 0;
+    });
+    return { ok: true, voz: [...new Set(feitos.map((x) => x.v.voz).filter(Boolean))].join(' + '), segundos: Math.round(antes * 1000) / 1000, partes, falantes: grupos.length };
+}
+
+module.exports = { normalizar, vozesDasPartes, narrarPorFalante, PAR };