primocode 9.8.0-beta.10 → 9.8.0-beta.12

package/README.md

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

package/lib/catalogo.js

@@ -104,7 +104,10 @@ const GRUPOS = [
                 + 'Use os tempos que voltam para a duração das cenas — estimar por número de palavras erra em segundos.' },
 
             { tool: 'estudio_video', escreve: true, faz: 'o que se faz com a gravação do usuário: importar, medir, cortar silêncio, transcrever, recortar a pessoa',
-              args: 'id. acao: importar | medir | silencio | cortar-silencio | quadro | legendas | recortar-pessoa. '
+              args: 'id. acao: editar | importar | medir | silencio | cortar-silencio | quadro | legendas | recortar-pessoa. '
+                + 'editar: FAZ A EDIÇÃO INTEIRA sozinho — corta o silêncio, transcreve palavra por palavra e monta o plano '
+                + '(legenda animada, ícone na hora da palavra, zoom de corte, pop e whoosh). estilo: viral (padrão) | limpo. '
+                + 'Com gravação do usuário, é o PRIMEIRO passo depois de importar; depois só estudio_render. '
                 + 'arquivo: caminho (em "importar", de fora; nas outras, o relativo dentro do projeto). '
                 + 'cortar-silencio: minimoParaCortar (padrão 0.6s), respiro (padrão 0.18s) — os dois existem para o corte não soar robótico. '
                 + 'legendas: devolve os trechos com tempo, para virarem elemento "legenda". '

package/lib/claude-engine.js

@@ -61,6 +61,28 @@ function argsDoModelo() {
     return MODELO_CLAUDE ? ['--model', MODELO_CLAUDE] : [];
 }
 
+/* O Claude Code ENXUTO, como motor. Sem isto cada passo do agente abria o
+ * Claude Code da pessoa inteiro: hooks, plugins, skills, CLAUDE.md dela e as
+ * ferramentas nativas — 36 mil tokens e ~6 s por chamada, e a resposta
+ * chegava com recado de hook pessoal ("context-sync pendente"). Medido em
+ * 25/09: com estes argumentos, a mesma chamada leva 473 tokens e ~3,5 s. Um
+ * pedido de 100 passos pagava aquilo 100 vezes — é a demora de 20 minutos.
+ *
+ * Nada disto tira o que o motor precisa: o protocolo vai inteiro no prompt
+ * (corpoDoProtocolo), e as ferramentas que valem são as do PrimoCode, não as
+ * do Claude Code. */
+const ARGS_ENXUTOS = [
+    '--setting-sources', 'project',
+    '--strict-mcp-config',
+    '--disable-slash-commands',
+    '--tools', '',
+    '--no-session-persistence',
+    '--system-prompt', 'Você é o motor de decisão do PrimoCode. Siga à risca o protocolo que vem na mensagem e responda só com o bloco pedido.',
+];
+function argsDoMotor() {
+    return [...ARGS_ENXUTOS, ...argsDoModelo()];
+}
+
 /**
  * Acha o ÚLTIMO bloco marcado no texto (pode vir ruído de terminal — prompt
  * ANSI, texto solto — antes e depois) e devolve o JSON de dentro dele.
@@ -567,7 +589,7 @@ async function requestActViaHeadless(payload, onEvent) {
         '-p',
         '--output-format', 'json',
         '--dangerously-skip-permissions',
-        ...argsDoModelo(),
+        ...argsDoMotor(),
     ], { encoding: 'utf-8', timeout: 180000, input: prompt, maxBuffer: 32 * 1024 * 1024,
         env: process.env, ...SEM_APARECER });
     const r = JSON.parse(saida);
@@ -577,7 +599,7 @@ async function requestActViaHeadless(payload, onEvent) {
     const pedirCorrecao = (aviso) => {
         const s = execFileSync('claude', [
             '-p', '--output-format', 'json', '--dangerously-skip-permissions',
-            ...argsDoModelo(),
+            ...argsDoMotor(),
         ], {
             encoding: 'utf-8', timeout: 120000, maxBuffer: 32 * 1024 * 1024,
             env: process.env,
@@ -622,7 +644,7 @@ module.exports = {
     // o que veio torto. Reimplementar aquilo no outro motor seria manter dois
     // protocolos que divergem na primeira correção de um deles.
     linhaDoHistorico, nomesDasTools, promptDoProtocolo, promptDeCorrecao,
-    MODELO_CLAUDE, argsDoModelo,
+    MODELO_CLAUDE, argsDoModelo, argsDoMotor,
     SKILL_DIR, SKILL_PATH, garantirSkill,
     temClaudeCode, temOrca, orcaAlcancavel, escolherCaminho,
     garantirEngine, requestAct, emitirDecisao,

package/lib/estudio/edicao.js

@@ -0,0 +1,401 @@
+/**
+ * edicao.js — a gravação da pessoa vira um vídeo editado, SEM o modelo
+ * escrever cena por cena.
+ *
+ *   "Deixe iguais aqueles vídeos que as videomakers editam: aquelas legendas
+ *    maravilhosas que fazem parte do vídeo, alguns ícones aparecendo, cortes
+ *    naturais, mais animações… Quero que até uma batata faça vídeos assim."
+ *   (25/09/2026)
+ *
+ * Com o Claude o vídeo saiu ótimo porque o modelo escreveu, à mão, cada
+ * legenda, cada palavra em destaque e cada zoom. Um modelo grátis não faz
+ * isso. Então a edição mora AQUI, em código: com as palavras e o tempo de
+ * cada uma, `montarEdicao` devolve o plano inteiro —
+ *
+ *   - uma cena por frase, com o corte seco entre elas e o zoom alternando
+ *     (o "punch-in" que dá ritmo a quem fala para a câmera);
+ *   - a legenda palavra por palavra, com a palavra dita em destaque e a
+ *     palavra forte da frase na cor dela;
+ *   - o ícone (emoji colorido) que salta na hora em que a palavra é dita;
+ *   - o letreiro grande da ideia, nas frases sem ícone;
+ *   - o pop e o whoosh nos momentos certos, e a barra de progresso.
+ *
+ * É uma função pura: entra palavra, sai plano. O modelo só escolhe o estilo,
+ * e pode ajustar qualquer cena depois com estudio_plano.
+ */
+
+'use strict';
+
+// ── as palavras que não carregam ideia ───────────────────────────────────
+const VAZIAS = new Set((
+    'a o as os um uma uns umas de do da dos das no na nos nas em por para pra pro com sem que se e '
+    + 'ou mas como mais menos muito muita muitos muitas isso isto esse essa este esta aquele aquela ele ela '
+    + 'eles elas eu voce voces nos meu minha seu sua nosso nossa tem ter ser foi era sao esta estao vai vou '
+    + 'ja ai aqui la entao tambem so quando onde porque pois ate sobre depois antes cada todo toda todos '
+    + 'todas qual quais quem nao sim ne ta tipo coisa coisas gente fazer faz feito pode podem vamos hoje'
+).split(' '));
+
+/* A palavra (sem acento, minúscula, começo dela) → o emoji colorido. Casa
+   pelo começo para "aprender", "aprende" e "aprendizado" caírem no mesmo. Os
+   nomes foram conferidos na coleção fluent-emoji-flat do Iconify (25/09). */
+const ICONES = [
+    [['inteligencia', 'ia', 'robo', 'maquina', 'automac'], 'robot'],
+    [['cerebro', 'pens', 'raciocin', 'aprend', 'mente'], 'brain'],
+    [['ideia', 'criativ', 'inova'], 'light-bulb'],
+    [['dinheiro', 'grana', 'reais', 'lucro', 'vend', 'fatur', 'ganh', 'pagar', 'preco'], 'money-bag'],
+    [['tempo', 'minuto', 'segundo', 'rapid', 'hora'], 'stopwatch'],
+    [['cresc', 'result', 'aument', 'melhor'], 'chart-increasing'],
+    [['cair', 'caiu', 'perd', 'queda', 'pior'], 'chart-decreasing'],
+    [['dados', 'numero', 'grafico', 'estatist', 'parametro'], 'bar-chart'],
+    [['foguete', 'lanc', 'decol', 'comec'], 'rocket'],
+    [['incrivel', 'fogo', 'bomba'], 'fire'],
+    [['certo', 'funcion', 'corret', 'pronto'], 'check-mark-button'],
+    [['errado', 'erro', 'falha', 'proibid'], 'cross-mark'],
+    [['celular', 'telefone', 'aplicativo', 'app'], 'mobile-phone'],
+    [['computador', 'codigo', 'program', 'software', 'site'], 'laptop'],
+    [['internet', 'mundo', 'global'], 'globe-showing-americas'],
+    [['olh', 'ver', 'imagem', 'imagens', 'visual', 'reconhec'], 'eyes'],
+    [['voz', 'som', 'sons', 'audio', 'ouv'], 'speaker-high-volume'],
+    [['texto', 'escrev', 'palavra', 'lista'], 'memo'],
+    [['musica', 'cancao'], 'musical-notes'],
+    [['cachorro', 'cao'], 'dog-face'],
+    [['gato'], 'cat-face'],
+    [['coracao', 'amor', 'ama', 'paixao'], 'red-heart'],
+    [['pessoa', 'cliente', 'usuario', 'equipe', 'publico'], 'busts-in-silhouette'],
+    [['casa', 'lar'], 'house'],
+    [['carro', 'dirig'], 'automobile'],
+    [['livro', 'estud', 'escola', 'ensin', 'aula', 'curso'], 'books'],
+    [['atencao', 'cuidado', 'perigo', 'risco'], 'warning'],
+    [['objeto', 'produto', 'pacote', 'entrega'], 'package'],
+    [['padr', 'peca', 'encaix'], 'puzzle-piece'],
+    [['decid', 'decis', 'escolh', 'duvida', 'pergunta'], 'thinking-face'],
+    [['exemplo', 'procur', 'busca', 'pesquis', 'analis'], 'magnifying-glass-tilted-left'],
+    [['assistente', 'convers', 'chat', 'mensag', 'responde'], 'speech-balloon'],
+    [['recomend', 'filme', 'serie', 'netflix', 'video'], 'clapper-board'],
+    [['tecnolog', 'algoritm', 'sistema', 'ferrament'], 'gear'],
+    [['cotidian', 'rotina', 'semana', 'calendario', 'agenda'], 'calendar'],
+    [['conhecimento', 'formad', 'diploma', 'sabe'], 'graduation-cap'],
+    [['sucesso', 'venc', 'ganhador', 'premio', 'campeao'], 'trophy'],
+    [['forca', 'forte', 'poder', 'energia'], 'flexed-biceps'],
+    [['acordo', 'parceri', 'junt', 'ajud'], 'handshake'],
+    [['compra', 'loja', 'carrinho'], 'shopping-cart'],
+    [['trabalh', 'empresa', 'negocio', 'emprego'], 'briefcase'],
+    [['seguranc', 'senha', 'proteg', 'privad'], 'locked'],
+    [['festa', 'comemor', 'parabens'], 'party-popper'],
+    [['surpre', 'chocad', 'absurd'], 'exploding-head'],
+];
+
+/* O termo de busca da IMAGEM DE APOIO, pelo emoji que a palavra ganhou. Em
+   inglês de propósito: os acervos abertos respondem muito melhor assim. */
+const FOTO = {
+    robot: 'humanoid robot', brain: 'human brain', 'light-bulb': 'light bulb idea', 'money-bag': 'money cash',
+    stopwatch: 'clock time', 'chart-increasing': 'business growth', 'chart-decreasing': 'stock market fall',
+    'bar-chart': 'data analytics', rocket: 'rocket launch', fire: 'fire flames', 'mobile-phone': 'smartphone hand',
+    laptop: 'laptop programming', 'globe-showing-americas': 'earth from space', eyes: 'eye closeup',
+    'speaker-high-volume': 'sound waves', memo: 'writing notebook', 'musical-notes': 'music concert',
+    'dog-face': 'puppy', 'cat-face': 'cat', 'red-heart': 'heart love', 'busts-in-silhouette': 'people crowd',
+    house: 'modern house', automobile: 'car road', books: 'library books', warning: 'warning sign',
+    package: 'objects on table', 'puzzle-piece': 'puzzle pieces', 'thinking-face': 'person thinking',
+    'magnifying-glass-tilted-left': 'magnifying glass', 'speech-balloon': 'smart speaker', 'clapper-board': 'watching tv',
+    gear: 'circuit board', calendar: 'city street people', 'graduation-cap': 'students classroom', trophy: 'trophy',
+    'flexed-biceps': 'strength', handshake: 'handshake', 'shopping-cart': 'shopping', briefcase: 'office work',
+    locked: 'cyber security', 'party-popper': 'party celebration', 'exploding-head': 'surprised face',
+};
+
+function limpa(palavra) {
+    return String(palavra || '').normalize('NFD').replace(/[̀-ͯ]/g, '')
+        .toLowerCase().replace(/[^a-z0-9]/g, '');
+}
+
+/** O emoji desta palavra, ou null. Palavra de 2 letras só casa inteira ("ia"). */
+function iconeDe(palavra) {
+    const w = limpa(palavra);
+    if (!w || VAZIAS.has(w)) return null;
+    for (const [raizes, nome] of ICONES) {
+        for (const r of raizes) {
+            if (r.length <= 3 ? w === r : w.startsWith(r)) return 'fluent-emoji-flat:' + nome;
+        }
+    }
+    return null;
+}
+
+/** Quanto a palavra carrega a ideia da frase. 0 = nada. */
+function peso(palavra) {
+    const w = limpa(palavra);
+    if (!w || VAZIAS.has(w)) return 0;
+    if (/^\d+$/.test(w)) return 20;
+    return w.length + (iconeDe(palavra) ? 6 : 0);
+}
+
+/** O termo de busca da imagem de apoio para esta palavra, ou null. */
+function termoDeApoio(palavra) {
+    const ic = iconeDe(palavra);
+    return ic ? FOTO[ic.split(':')[1]] || null : null;
+}
+
+// Em quais cenas entra imagem de apoio: uma a cada três, a partir da segunda.
+const temApoio = (i) => i % 3 === 2;
+
+function forteDe(g) {
+    let forte = null;
+    for (const p of g) if (peso(p.texto) > (forte ? peso(forte.texto) : 0)) forte = p;
+    return forte;
+}
+
+/** Os termos das imagens de apoio que o plano vai pedir — para baixar antes. */
+function termosDeApoio(palavras) {
+    const lista = (palavras || []).filter((p) => p && p.texto && p.ate > p.de).sort((a, b) => a.de - b.de);
+    const termos = [];
+    frases(lista).forEach((g, i) => {
+        const f = forteDe(g);
+        const t = f && temApoio(i) ? termoDeApoio(f.texto) : null;
+        if (t && !termos.includes(t)) termos.push(t);
+    });
+    return termos;
+}
+
+const fimDeFrase = (texto) => /[.!?…]$/.test(String(texto || '').trim());
+const r2 = (n) => Math.round(n * 100) / 100;
+
+/* As frases: corta no ponto final, na pausa longa ou quando a cena passa do
+   teto. Frase curta demais gruda na próxima — corte a cada meio segundo é
+   epilepsia, não ritmo. */
+function frases(palavras, { teto = 5.5, pausa = 0.5, minimo = 1.4 } = {}) {
+    const grupos = [];
+    let atual = [];
+    palavras.forEach((p, i) => {
+        atual.push(p);
+        const prox = palavras[i + 1];
+        const dur = p.ate - atual[0].de;
+        if (!prox || fimDeFrase(p.texto) || prox.de - p.ate >= pausa || dur >= teto) {
+            grupos.push(atual);
+            atual = [];
+        }
+    });
+    const juntos = [];
+    for (const g of grupos) {
+        const ult = juntos[juntos.length - 1];
+        const durG = g[g.length - 1].ate - g[0].de;
+        if (ult && (durG < minimo || ult[ult.length - 1].ate - ult[0].de < minimo)
+            && g[g.length - 1].ate - ult[0].de <= teto + 1.5) ult.push(...g);
+        else juntos.push([...g]);
+    }
+    return juntos;
+}
+
+/* Os pedaços da legenda: poucas palavras por vez (quem assiste no celular lê
+   em blocos curtos), quebrando na pontuação e na pausa. */
+function blocos(palavras, maximo) {
+    const out = [];
+    let atual = [];
+    palavras.forEach((p, i) => {
+        atual.push(p);
+        const prox = palavras[i + 1];
+        if (!prox || atual.length >= maximo || /[,.!?;:…]$/.test(p.texto) || prox.de - p.ate > 0.3) {
+            out.push(atual);
+            atual = [];
+        }
+    });
+    return out;
+}
+
+// O zoom de cada cena, em rodízio: parado, punch-in, empurrando devagar.
+function camera(i, dur) {
+    const tipo = i % 3;
+    if (tipo === 0) return { zoom: [{ t: 0, v: 1 }, { t: dur, v: 1.04, e: 'linear' }] };
+    if (tipo === 1) return { zoom: [{ t: 0, v: 1.18 }, { t: dur, v: 1.21, e: 'linear' }] };
+    return { zoom: [{ t: 0, v: 1.07 }, { t: dur, v: 1.13, e: 'suave' }] };
+}
+
+const ESTILOS = {
+    viral: { icones: true, letreiro: true, sons: true, barra: true, apoio: true, destaque: '#FFD400', forte: '#00E0A4' },
+    limpo: { icones: false, letreiro: false, sons: false, barra: false, apoio: true, destaque: '#FFFFFF', forte: '#FFD400' },
+};
+
+/**
+ * O plano do vídeo editado.
+ *
+ * @param {object} op
+ * @param {string} op.src         o vídeo (já sem os silêncios), relativo à pasta do projeto
+ * @param {number} op.duracao     a duração dele, em segundos
+ * @param {Array}  op.palavras    [{de, ate, texto}] no tempo DESTE vídeo
+ * @param {number} op.largura     do vídeo de origem
+ * @param {number} op.altura
+ * @param {string} op.estilo      'viral' (padrão) | 'limpo'
+ * @param {object} op.sons        { pop, whoosh } — caminhos na pasta do projeto, opcionais
+ * @param {Set}    op.iconesOk    os nomes de ícone que existem de verdade (sem isso, todos valem)
+ */
+function montarEdicao({ src, duracao, palavras, largura = 1080, altura = 1920, estilo = 'viral', sons = {}, iconesOk = null, imagens = {}, trilha = null }) {
+    const e = ESTILOS[estilo] || ESTILOS.viral;
+    const lista = (palavras || []).filter((p) => p && p.texto && p.ate > p.de).sort((a, b) => a.de - b.de);
+    if (!lista.length) return { ok: false, error: 'a gravação não tem fala transcrita para editar.' };
+
+    const deitado = largura > altura;
+    const base = Math.min(largura, altura);
+    const grupos = frases(lista);
+    const total = duracao || lista[lista.length - 1].ate + 0.3;
+    const cenas = [];
+    const efeitos = [];
+    let lado = 0;
+
+    grupos.forEach((g, i) => {
+        const ini = i === 0 ? 0 : grupos[i - 1][grupos[i - 1].length - 1].ate
+            + (g[0].de - grupos[i - 1][grupos[i - 1].length - 1].ate) / 2;
+        const fim = i === grupos.length - 1 ? total : g[g.length - 1].ate + (grupos[i + 1][0].de - g[g.length - 1].ate) / 2;
+        const dur = r2(Math.max(0.4, fim - ini));
+        const local = (t) => r2(Math.max(0, t - ini));
+
+        // A palavra forte da frase: a que mais carrega a ideia.
+        const forte = forteDe(g);
+
+        const elementos = [{
+            tipo: 'video', src, x: 0, y: 0, largura: '100%', altura: '100%',
+            deOrigem: r2(ini), ateOrigem: r2(ini + dur), volume: 1,
+        }];
+
+        /* A IMAGEM DE APOIO: na hora da palavra forte, a tela vira a imagem do
+           que está sendo dito, com um zoom lento, e a legenda continua por
+           cima. É o "b-roll" das edições de videomaker. */
+        const apoio = forte && e.apoio && temApoio(i) ? imagens[termoDeApoio(forte.texto)] : null;
+        if (apoio) {
+            const de = local(forte.de - 0.1);
+            const vida = Math.min(2.2, dur - de);
+            if (vida > 0.8) {
+                elementos.push({
+                    tipo: 'imagem', src: apoio, x: 0, y: 0, largura: '100%', altura: '100%', ajuste: 'cover',
+                    de, ate: r2(de + vida),
+                    anima: {
+                        escala: [{ t: 0, v: 1.12 }, { t: vida, v: 1.0, e: 'suave' }],
+                        opacidade: [{ t: 0, v: 0 }, { t: 0.12, v: 1 }, { t: vida - 0.15, v: 1 }, { t: vida, v: 0 }],
+                    },
+                });
+                if (e.sons && sons.whoosh) efeitos.push({ t: r2(Math.max(0, ini + de - 0.1)), src: sons.whoosh, volume: 0.55 });
+            }
+        }
+
+        // O ícone salta na hora da palavra; sem ícone, o letreiro da ideia.
+        const icone = forte && e.icones && !apoio ? iconeDe(forte.texto) : null;
+        const temIcone = icone && (!iconesOk || iconesOk.has(icone));
+        const x = lado++ % 2 === 0 ? '78%' : '22%';
+        if (temIcone) {
+            const de = local(forte.de - 0.05);
+            const vida = Math.min(1.8, dur - de);
+            if (vida > 0.5) {
+                elementos.push({
+                    tipo: 'icone', nome: icone, tamanho: Math.round(base * (deitado ? 0.2 : 0.24)),
+                    x, y: deitado ? '30%' : '26%', ancora: 'centro', de, ate: r2(de + vida),
+                    sombra: undefined,
+                    anima: {
+                        escala: [{ t: 0, v: 0 }, { t: 0.2, v: 1.18, e: 'saida' }, { t: 0.34, v: 1, e: 'suave' }],
+                        rotacao: [{ t: 0, v: -14 }, { t: 0.34, v: 0, e: 'saida' }, { t: vida, v: 4, e: 'suave' }],
+                        y: [{ t: 0.34, v: 0 }, { t: vida, v: -14, e: 'suave' }],
+                        opacidade: [{ t: vida - 0.2, v: 1 }, { t: vida, v: 0 }],
+                    },
+                });
+                if (e.sons && sons.pop) efeitos.push({ t: r2(ini + de), src: sons.pop, volume: 0.8 });
+            }
+        } else if (forte && e.letreiro && i % 2 === 0 && peso(forte.texto) >= 7) {
+            const de = local(forte.de);
+            const vida = Math.min(1.6, dur - de);
+            if (vida > 0.5) {
+                elementos.push({
+                    tipo: 'texto', texto: limpaPontuacao(forte.texto).toUpperCase(), fonte: 'Anton',
+                    tamanho: Math.round(base * (deitado ? 0.11 : 0.1)), cor: e.forte, peso: 400,
+                    x, y: deitado ? '28%' : '24%', ancora: 'centro', de, ate: r2(de + vida),
+                    anima: {
+                        escala: [{ t: 0, v: 0.4 }, { t: 0.16, v: 1.12, e: 'saida' }, { t: 0.3, v: 1, e: 'suave' }],
+                        opacidade: [{ t: 0, v: 0 }, { t: 0.1, v: 1 }, { t: vida - 0.18, v: 1 }, { t: vida, v: 0 }],
+                        rotacao: [{ t: 0, v: -6 }, { t: 0.3, v: -3, e: 'saida' }],
+                    },
+                });
+                if (e.sons && sons.pop) efeitos.push({ t: r2(ini + de), src: sons.pop, volume: 0.7 });
+            }
+        }
+
+        // A legenda palavra por palavra.
+        const fala = blocos(g, 3).map((b, j, todos) => ({
+            de: local(b[0].de - 0.04),
+            ate: j < todos.length - 1 ? local(todos[j + 1][0].de - 0.04) : r2(dur),
+            texto: b.map((p) => p.texto).join(' '),
+            palavras: b.map((p) => ({
+                de: local(p.de), ate: local(p.ate), texto: limpaPontuacao(p.texto),
+                ...(p === forte ? { forte: true } : {}),
+            })),
+        }));
+        elementos.push({
+            tipo: 'legenda', x: '50%', y: deitado ? '76%' : '68%', ancora: 'centro', fala,
+            estilo: {
+                fonte: 'Montserrat', peso: 900, tamanho: Math.round(base * (deitado ? 0.078 : 0.072)),
+                destaque: e.destaque, corForte: e.forte, caixa: 'uppercase', largura: '92%',
+            },
+        });
+
+        if (e.barra) {
+            elementos.push({
+                tipo: 'forma', forma: 'retangulo', x: 0, y: 0, altura: Math.max(6, Math.round(base * 0.008)),
+                largura: '100%', cor: e.destaque,
+                anima: { escalaX: [{ t: 0, v: r2(ini / total) }, { t: dur, v: r2((ini + dur) / total), e: 'linear' }] },
+                origem: 'left',
+            });
+        }
+
+        // O whoosh entra no punch-in: é o corte que ele anuncia.
+        if (e.sons && sons.whoosh && i > 0 && i % 3 === 1) efeitos.push({ t: r2(Math.max(0, ini - 0.12)), src: sons.whoosh, volume: 0.6 });
+
+        cenas.push({ duracao: dur, camera: camera(i, dur), elementos, transicao: { tipo: 'corte' } });
+    });
+
+    return {
+        ok: true,
+        plano: {
+            formato: { largura, altura, fps: 30 },
+            fundoGeral: '#000',
+            cenas,
+            ...(efeitos.length || trilha ? { audio: {
+                ...(efeitos.length ? { efeitos } : {}),
+                // A música fica BAIXA: quem fala para a câmera fala o vídeo
+                // inteiro, e a trilha é cama, não disputa.
+                ...(trilha ? { trilha: { src: trilha, volume: 0.07, loop: true } } : {}),
+            } } : {}),
+        },
+        resumo: {
+            cenas: cenas.length,
+            icones: cenas.reduce((n, c) => n + c.elementos.filter((x) => x.tipo === 'icone').length, 0),
+            imagens: cenas.reduce((n, c) => n + c.elementos.filter((x) => x.tipo === 'imagem').length, 0),
+            musica: Boolean(trilha),
+            letreiros: cenas.reduce((n, c) => n + c.elementos.filter((x) => x.tipo === 'texto').length, 0),
+            efeitos: efeitos.length,
+        },
+    };
+}
+
+function limpaPontuacao(t) {
+    return String(t || '').replace(/^[^\p{L}\p{N}]+|[^\p{L}\p{N}%]+$/gu, '');
+}
+
+/* Os dois sons, sintetizados pelo ffmpeg: nada baixado, nada com licença de
+   ninguém. O pop é um tom que cai rápido; o whoosh, um ruído que sobe e some. */
+const SONS = {
+    pop: ['-f', 'lavfi', '-i', "aevalsrc='0.9*sin(2*PI*(1500-7000*t)*t)*exp(-38*t)':s=44100:d=0.14"],
+    whoosh: ['-f', 'lavfi', '-i', 'anoisesrc=d=0.55:c=pink:a=0.6',
+        '-af', 'highpass=f=500,lowpass=f=5000,afade=t=in:st=0:d=0.3:curve=exp,afade=t=out:st=0.3:d=0.25,volume=0.9'],
+};
+
+async function prepararSons(pasta, video) {
+    const fs = require('fs');
+    const path = require('path');
+    const sons = {};
+    for (const [nome, args] of Object.entries(SONS)) {
+        const rel = `midia/sfx-${nome}.mp3`;
+        const cheio = path.join(pasta, rel);
+        if (!fs.existsSync(cheio)) {
+            fs.mkdirSync(path.dirname(cheio), { recursive: true });
+            const r = await video.rodar(video.ffmpeg(), ['-y', ...args, '-q:a', '4', cheio], { timeout: 30000 });
+            if (!r.ok) continue;
+        }
+        sons[nome] = rel;
+    }
+    return sons;
+}
+
+module.exports = { montarEdicao, prepararSons, iconeDe, peso, frases, blocos, termosDeApoio, termoDeApoio, ESTILOS, ICONES, FOTO };

package/lib/estudio/index.js

@@ -40,6 +40,7 @@ const assets = require('./assets.js');
 const video = require('./video.js');
 const identidade = require('./identidade.js');
 const slides = require('./slides.js');
+const edicao = require('./edicao.js');
 
 const PY = path.join(__dirname, '..', '..', 'studio');
 
@@ -399,6 +400,87 @@ async function ferramentaVideo(args, ctx = {}) {
         return transcrever(p, alvo, ctx);
     }
 
+    /* A EDIÇÃO INTEIRA, em código (lib/estudio/edicao.js): corta o silêncio,
+       transcreve palavra por palavra e monta o plano — legenda animada,
+       ícones na hora da palavra, zoom de corte, pop e whoosh. É o caminho
+       para qualquer modelo entregar vídeo de videomaker: ele só chama isto e
+       renderiza. "Até uma batata faz vídeos assim." (25/09/2026) */
+    if (acao === 'editar' || acao === 'edicao' || acao === 'auto') {
+        let fonte = alvo;
+        let cortes = 0;
+        if (args.cortarSilencio !== false) {
+            const saida = path.join(p.pasta, 'midia', `cortado-${Date.now().toString(36)}.mp4`);
+            const c = await video.cortarSilencio(alvo, saida, args);
+            if (c.ok && !c.semCorte) { fonte = saida; cortes = c.cortes || 0; }
+        }
+        /* A VOZ NO VOLUME CERTO. A gravação de celular sai baixa (medido em
+           25/09: -37,6 dB de média no vídeo pronto, e "está sem som"). O
+           loudnorm leva a fala a -15 LUFS, o volume de vídeo de internet; o
+           vídeo em si não é recodificado. */
+        const normal = path.join(p.pasta, 'midia', `voz-normal-${Date.now().toString(36)}.mp4`);
+        const ln = await video.rodar(video.ffmpeg(), ['-y', '-i', fonte, '-c:v', 'copy',
+            '-af', 'loudnorm=I=-15:TP=-1.5:LRA=11', '-c:a', 'aac', '-b:a', '192k', normal], { timeout: 10 * 60000 });
+        if (ln.ok) fonte = normal;
+
+        const m = await video.medir(fonte);
+        if (!m.ok) return m;
+
+        const tr = await transcrever(p, fonte, ctx);
+        if (!tr.ok) return tr;
+        let palavras = tr.palavras || [];
+        // Servidor sem o tempo por palavra: reparte cada trecho pelas palavras
+        // dele. Sai menos preciso, mas a legenda continua animada.
+        if (!palavras.length) palavras = repartirTrechos(tr.trechos || []);
+
+        const candidatos = [...new Set(palavras.map((w) => edicao.iconeDe(w.texto)).filter(Boolean))];
+        const iconesOk = new Set();
+        for (const nome of candidatos) {
+            try { const r = await assets.icone(nome); if (r && (r.ok !== false)) iconesOk.add(nome); } catch { /* fica sem */ }
+        }
+        const sons = await edicao.prepararSons(p.pasta, video);
+
+        // As imagens de apoio: uma por termo, a primeira que baixar.
+        const imagens = {};
+        if ((args.estilo || 'viral') !== 'sem-apoio') {
+            for (const termo of edicao.termosDeApoio(palavras).slice(0, 8)) {
+                try {
+                    const b = await assets.procurarImagens(termo, { quantas: 4 });
+                    for (const item of (b.ok ? b.imagens : [])) {
+                        const d = await assets.baixar(item, { pasta: p.pasta, nome: 'apoio-' + termo });
+                        if (d.ok) { imagens[termo] = d.relativo; break; }
+                    }
+                } catch { /* segue sem esta */ }
+            }
+        }
+
+        // A música de fundo: uma trilha longa, de licença aberta.
+        let trilha = null;
+        if (args.musica !== false) {
+            try {
+                const b = await assets.procurarSom(args.trilha || 'upbeat corporate background', { quantas: 6, duracaoMin: 45 });
+                for (const item of (b.ok ? b.sons : [])) {
+                    const d = await assets.baixar(item, { pasta: p.pasta, nome: 'trilha' });
+                    if (d.ok) { trilha = d.relativo; break; }
+                }
+            } catch { /* segue sem música */ }
+        }
+
+        const montado = edicao.montarEdicao({
+            src: path.relative(p.pasta, fonte).replace(/\\/g, '/'),
+            duracao: m.segundos, palavras, largura: m.largura, altura: m.altura,
+            estilo: args.estilo || 'viral', sons, iconesOk, imagens, trilha,
+        });
+        if (!montado.ok) return montado;
+        const salvo = await ferramentaPlano({ id: args.id, plano: montado.plano, motivo: `edição automática (${args.estilo || 'viral'})` });
+        if (!salvo.ok) return salvo;
+        projeto.anotar(p.id, 'edicao', `${montado.resumo.cenas} cenas, ${montado.resumo.icones} ícones, ${cortes} cortes de silêncio`);
+        return {
+            ok: true, ...montado.resumo, cortesDeSilencio: cortes, duracao: salvo.duracao,
+            proximo: 'estudio_render com este id. Antes, se quiser, ajuste uma cena com estudio_plano cena:N '
+                + '(ex.: trocar um ícone, pôr uma imagem de apoio atrás).',
+        };
+    }
+
     if (acao === 'recortar-pessoa' || acao === 'pessoa') {
         const saida = path.join(p.pasta, 'midia', `pessoa-${Date.now().toString(36)}.webm`);
         const r = await rodarPython('pessoa.py', [
@@ -418,6 +500,23 @@ async function ferramentaVideo(args, ctx = {}) {
     return { ok: false, error: `não conheço a ação "${acao}".` };
 }
 
+/* Sem o tempo de cada palavra, cada trecho é repartido pelas palavras dele,
+   proporcional ao tamanho de cada uma. */
+function repartirTrechos(trechos) {
+    const out = [];
+    for (const t of trechos) {
+        const ws = String(t.texto || '').split(/\s+/).filter(Boolean);
+        const letras = ws.reduce((n, w) => n + w.length, 0) || 1;
+        let cur = t.de;
+        for (const w of ws) {
+            const d = (t.ate - t.de) * (w.length / letras);
+            out.push({ de: cur, ate: cur + d, texto: w });
+            cur += d;
+        }
+    }
+    return out;
+}
+
 /**
  * A transcrição com tempo — é ela que dá legenda sincronizada.
  *
@@ -448,7 +547,7 @@ async function transcrever(p, alvo, ctx) {
         if (!r || r.ok === false) return { ok: false, error: (r && r.erro) || 'a transcrição falhou.' };
         projeto.anotar(p.id, 'transcricao', `${(r.trechos || []).length} trechos`);
         return {
-            ok: true, texto: r.texto, trechos: r.trechos,
+            ok: true, texto: r.texto, trechos: r.trechos, palavras: r.palavras || [],
             comoUsar: 'cada trecho vira uma fala da legenda: {"de":…, "ate":…, "texto":…}. '
                 + 'O estilo da legenda (fonte, cor, peso, posição, animação) é escolha sua — não há padrão.',
         };