primocode 10.13.0 → 10.14.0

package/lib/estudio/maquina.js

@@ -0,0 +1,516 @@
+/**
+ * maquina.js — a máquina de motion: o assunto entra, o vídeo de motion sai, com assinatura própria.
+ *
+ * O modelo (mesmo o grátis) preenche um JSON declarativo; o DIRETOR (maquina-diretor.js) completa o que faltar:
+ * metáfora do assunto, primitivas de cena (38), transições (15), câmera (8), tipografia (8), ritmo, com semente por
+ * vídeo e conferência contra as últimas assinaturas. O kit (kit-ae/*.jsx) faz o trabalho fino no EffectCraft.
+ *
+ *   estudio_motion → elementos reais (3D/GIF/logo) → direção → [voz + whisper: o tempo de cada palavra]
+ *     → [trilha + batidas: cortes na batida] → JSX → render → conferência (folha de contato, quadro vazio,
+ *     texto fora, contraste; falhou → corrige e refaz até 2×) → SFX reais CC0 por ação → mix −14 LUFS.
+ */
+
+'use strict';
+
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+const { spawnSync } = require('child_process');
+
+const KIT = path.join(__dirname, 'kit-ae');
+const FORMATOS = { '9:16': [1080, 1920], '1:1': [1080, 1080], '16:9': [1920, 1080] };
+const diretor = require('./maquina-diretor.js');
+const TIPOS = diretor.TIPOS;                 // as 38 primitivas de cena
+const TROCAS = diretor.TRANSICOES;           // as 15 transições
+const LUFS_ALVO = -14;
+
+// ── cor ──────────────────────────────────────────────────────────────────
+
+function rgb(h) {
+    let s = String(h || '').replace('#', '');
+    if (s.length === 3) s = s.split('').map((c) => c + c).join('');
+    if (!/^[0-9a-f]{6}$/i.test(s)) return null;
+    return [0, 2, 4].map((i) => parseInt(s.substr(i, 2), 16));
+}
+const hex = (c) => '#' + c.map((v) => Math.max(0, Math.min(255, Math.round(v))).toString(16).padStart(2, '0')).join('');
+function luminancia(h) {
+    const c = (rgb(h) || [0, 0, 0]).map((v) => { v /= 255; return v <= 0.03928 ? v / 12.92 : Math.pow((v + 0.055) / 1.055, 2.4); });
+    return 0.2126 * c[0] + 0.7152 * c[1] + 0.0722 * c[2];
+}
+function contraste(a, b) {
+    const x = luminancia(a), y = luminancia(b);
+    return (Math.max(x, y) + 0.05) / (Math.min(x, y) + 0.05);
+}
+function misturar(a, b, p) {
+    const x = rgb(a) || [0, 0, 0], y = rgb(b) || [255, 255, 255];
+    return hex(x.map((v, i) => v + (y[i] - v) * p));
+}
+/** A cor da lista que mais contrasta com `fundo`. */
+const melhorCor = (fundo, lista) => lista.slice().sort((p, q) => contraste(q, fundo) - contraste(p, fundo))[0];
+
+
+
+// ── paletas: nada de roxo-azul genérico ──────────────────────────────────
+
+const CHAVES = {
+    forno: /p[aã]o|padaria|caf[eé]|comida|restaurante|doce|bolo|lanche|confeit|pizza|hamb|sorvete|cozinha|a[cç]a[ií]/i,
+    rose: /cl[ií]nica|est[eé]tica|beleza|sal[aã]o|cabelo|unha|spa|pele|sa[uú]de|m[eé]dic|dent|cliente|sumid/i,
+    grafite: /app|saas|software|c[oó]digo|program|tecnolog|ia\b|intelig|primocode|sistema|plataforma|dados|site|digital|startup/i,
+    floresta: /finan|dinheiro|invest|agro|natur|sustent|verde|jardim|planta|energia|banco|cr[eé]dito|imobili/i,
+    petroleo: /curso|aula|educa|escola|ensino|consult|advoc|direito|mentoria|treinamento|palestra|livro/i,
+    coral: /moda|roupa|fitness|academia|esporte|treino|loja|vestid|sapato|brech[oó]|corrida|dan[cç]a/i,
+};
+const PALETAS = Object.keys(diretor.PALETAS).map((nome) => ({ nome, chaves: CHAVES[nome] || null, ...diretor.PALETAS[nome] }));
+const hashTexto = diretor.hashTexto;
+function paletaDoAssunto(assunto) {
+    const a = String(assunto || '');
+    const achou = PALETAS.find((p) => p.chaves && p.chaves.test(a));
+    return achou || PALETAS[hashTexto(a) % PALETAS.length];
+}
+
+/** As 3 variações da paleta: normal, fundo profundo e fundo de destaque, sempre com contraste de leitura. */
+function variacoes(base) {
+    const fundo = base.fundo, tinta = base.tinta, dest = base.destaque;
+    const claroBg = luminancia(fundo) >= luminancia(tinta) ? fundo : tinta;
+    const escuroBg = claroBg === fundo ? tinta : fundo;
+    const fix = (bg, fg, ac) => {
+        if (contraste(fg, bg) < 4.5) fg = melhorCor(bg, ['#FFFFFF', '#111111']);
+        if (contraste(ac, bg) < 3) ac = melhorCor(bg, [dest, fg, tinta, fundo]);
+        const mudo = misturar(bg, fg, 0.66);
+        return { bg, fg, ac, mudo: contraste(mudo, bg) >= 3 ? mudo : fg, card: misturar(bg, fg, 0.1), brilho: misturar(bg, ac, 0.32) };
+    };
+    return {
+        normal: fix(fundo, tinta, dest),
+        fundo: fix(escuroBg, claroBg, dest),
+        destaque: (() => { const fg = melhorCor(dest, [claroBg, escuroBg]), ac = melhorCor(dest, [escuroBg, claroBg]); return fix(dest, contraste(fg, dest) >= 3 ? fg : melhorCor(dest, ['#FFFFFF', '#111111']), contraste(ac, dest) >= 3 ? ac : melhorCor(dest, ['#FFFFFF', '#111111'])); })(),
+    };
+}
+
+// ── entrada → plano ──────────────────────────────────────────────────────
+
+const limpa = (s, max) => String(s == null ? '' : s).replace(/[\r\n]+/g, ' ').replace(/\s+/g, ' ').trim().slice(0, max);
+const marcarChave = diretor.marcarChave;
+
+function formatoDe(arg, ficha) {
+    const bruto = String(arg || (ficha && ficha.formato) || '9:16');
+    if (FORMATOS[bruto]) return bruto;
+    if (/16\s*[:x×]\s*9|1920\s*[x×]\s*1080/.test(bruto)) return '16:9';
+    if (/9\s*[:x×]\s*16|1080\s*[x×]\s*1920/.test(bruto)) return '9:16';
+    if (/1\s*:\s*1|quadrad|1080\s*[x×]\s*1080/.test(bruto)) return '1:1';
+    return '9:16';
+}
+function duracaoDaFicha(ficha) {
+    const m = ficha && String(ficha.duracao || '').match(/(\d+(?:[.,]\d+)?)\s*s/);
+    return m ? Number(m[1].replace(',', '.')) : null;
+}
+
+/** Os papéis padrão (compatível com o roteiro antigo): quando o modelo não manda cenas, o diretor sorteia os papéis. */
+function roteiroPadrao(assunto, { duracao = 15 } = {}) {
+    return diretor.dirigir({ assunto, duracao }, { historico: [], semente: hashTexto(assunto) }).cenas;
+}
+function normalizarCena(c, i) {
+    c = c && typeof c === 'object' ? c : { titulo: String(c || '') };
+    const tipo = diretor.PRIMITIVAS[diretor.normTipo(c.tipo)] ? diretor.normTipo(c.tipo) : (i === 0 ? 'gancho' : 'citacao');
+    return diretor.completar(c, tipo, { assunto: c.titulo || '', meta: diretor.METAFORAS.geral, proxima: null });
+}
+
+const maxDur = (tipo) => (tipo === 'celular' || tipo === 'prompt' ? 5 : 4.2);
+
+/**
+ * Do pedido ao PLANO que o kit entende (sem rede nem disco; o histórico de assinaturas vem por `opc.historico`).
+ * `args`: {assunto, formato, marca:{cores,fontes}, cenas:[{papel, tipo, fala, titulo, itens…}], transicoes, camera, tipografia,
+ *          metafora, ritmo, semente, receita, duracao}. `opc`: {receita, historico, semente, elementos}.
+ */
+function plano(args = {}, opc = {}) {
+    const receita = opc.receita || null;
+    const ficha = receita && receita.ficha;
+    const formato = formatoDe(args.formato, ficha);
+    const [w, h] = FORMATOS[formato];
+    const alvo = Math.max(6, Math.min(60, Number(args.duracao) || duracaoDaFicha(ficha) || 15));
+    const elementos = opc.elementos || [];
+    const dir = diretor.dirigir({ ...args, duracao: alvo }, { historico: opc.historico || [], semente: opc.semente != null ? opc.semente : null, temElemento: opc.elementos ? opc.elementos.length > 0 : true });
+    const cenas = dir.cenas;
+
+    // o ritmo: sem pedido de duração por cena, ajusta ao alvo (cada cena entre 1,4 e 4,2 s)
+    const soma = cenas.reduce((s, c) => s + c.dur, 0);
+    if (!args.cenas || args.duracao) {
+        const k = alvo / soma;
+        cenas.forEach((c) => { c.dur = Math.round(Math.max(1.4, Math.min(maxDur(c.tipo), c.dur * k)) * 10) / 10; });
+    }
+
+    // paleta: a da marca ou a sorteada pela metáfora; 3 variações em ciclo, sem repetir o fundo em fila
+    const m = args.marca || {};
+    const cores = m.cores || {};
+    const base = dir.paleta && diretor.PALETAS[dir.paleta] ? diretor.PALETAS[dir.paleta] : paletaDoAssunto(args.assunto);
+    const paleta = {
+        fundo: rgb(cores.fundo) ? cores.fundo : base.fundo,
+        tinta: rgb(cores.tinta) ? cores.tinta : base.tinta,
+        destaque: rgb(cores.destaque) ? cores.destaque : base.destaque,
+    };
+    const v = variacoes(paleta);
+    // o ciclo de fundos: o fundo da marca domina; o de destaque e o invertido entram de contraponto (nunca iguais em fila)
+    const N = v.normal, D = v.destaque, F = v.fundo;
+    const ciclos = luminancia(paleta.fundo) > 0.5 ? [[N, D, N, F], [N, F, N, D], [N, D, F, N]] : [[N, D, F, N], [N, F, D, N], [N, N, D, F]];
+    const ordem = ciclos[dir.ordemPal % 3];
+    cenas.forEach((c, i) => {
+        let p = ordem[i % ordem.length];
+        if (i > 0 && p.bg === cenas[i - 1].pal.bg) p = p === N ? D : N;
+        if (i === cenas.length - 1 && cenas.length > 3) p = i > 0 && cenas[i - 1].pal.bg === F.bg ? (cenas[i - 1].pal.bg !== N.bg ? N : D) : F;   // o CTA fecha no fundo invertido, a não ser que a cena anterior já o use
+        c.pal = { ...p };
+    });
+    cenas.forEach((c, i) => { if (cenas[i + 1]) c.proxBg = cenas[i + 1].pal.bg; });
+
+    const tip = diretor.TIPOGRAFIAS[dir.tipografia];
+    const f = m.fontes || {};
+    const fontes = { titulo: limpa(f.titulo, 40) || tip.fontes.titulo, texto: limpa(f.texto, 40) || tip.fontes.texto, destaque: limpa(f.destaque, 40) || tip.fontes.destaque };
+    const tipo = { nome: dir.tipografia, entrada: tip.entrada, realce: tip.realce, caixa: tip.caixa || null, passo: tip.passo, tracking: tip.tracking == null ? 0 : tip.tracking, entreLinhas: tip.entreLinhas || null };
+    // tudo entra nos primeiros ~35% da cena: a cena é montada em tempo nominal e tocada f vezes mais rápido (f ≥ 1, até 2,2)
+    cenas.forEach((c) => { const e = (diretor.PRIMITIVAS[c.tipo] || {}).entra || 2; c.f = Math.round(Math.max(1, Math.min(2.2, e / (0.36 * c.dur))) * 100) / 100; c.elemento = !!(diretor.PRIMITIVAS[c.tipo] || {}).elemento; });
+    const duracao = Math.round(cenas.reduce((s, c) => s + c.dur, 0) * 100) / 100;
+    cenas.forEach((c, i) => { c.inicio = Math.round(cenas.slice(0, i).reduce((s, x) => s + x.dur, 0) * 1000) / 1000; });
+    return { w, h, fps: 30, formato, fontes, tipo, paleta, trocas: dir.trocas, cenas, ajuste: 1, receita: receita ? receita.id : null, duracao,
+        camera: dir.camera, elementos, bpm: 0, voz: null, legenda: null, direcao: dir.assinatura, semente: dir.semente, variacoes: v };
+}
+
+/** A voz manda: cada cena começa na 1ª palavra da fala dela e dura até a próxima. `voz` = resultado de falarEMedir. */
+function aplicarVoz(pl, voz, { legenda = true } = {}) {
+    const vozCenas = voz.cenas;
+    pl.cenas.forEach((c, i) => {
+        const vc = vozCenas[i];
+        c.inicio = Math.round(vc.inicio * 1000) / 1000;
+        const fim = i < pl.cenas.length - 1 ? vozCenas[i + 1].inicio : voz.dur + 0.7;
+        c.dur = Math.round(Math.max(1.5, Math.min(7.5, fim - vc.inicio)) * 100) / 100;
+        c.f = 1;   // com voz, o elemento entra no início da palavra que o cita: o tempo é o da fala, sem acelerar
+    });
+    // contíguas: a cena seguinte começa onde a anterior termina
+    for (let i = 1; i < pl.cenas.length; i++) pl.cenas[i].inicio = Math.round((pl.cenas[i - 1].inicio + pl.cenas[i - 1].dur) * 1000) / 1000;
+    pl.duracao = Math.round((pl.cenas[pl.cenas.length - 1].inicio + pl.cenas[pl.cenas.length - 1].dur) * 100) / 100;
+    pl.voz = { palavras: voz.palavras.map((p) => ({ w: p.w, n: p.n, t: p.t, t2: p.t2, cena: p.cena })), dur: voz.dur, motor: voz.motor };
+    if (legenda) {
+        let chunks = require('./maquina-voz.js').legendaChunks(voz.palavras, { max: 12, maxCar: 64 });
+        // a legenda some quando o título da cena já diz a mesma coisa (≥ 70% das palavras do trecho estão no título)
+        const norm = (x) => String(x || '').toLowerCase().normalize('NFD').replace(/[̀-ͯ]/g, '').replace(/[^a-z0-9]/g, '');
+        chunks = chunks.filter((ch) => {
+            const tit = new Set(String(((pl.cenas[ch.cena] && pl.cenas[ch.cena].titulo) || '') + ' ' + ((pl.cenas[ch.cena] && pl.cenas[ch.cena].botao) || '')).replace(/\*/g, '').split(/\s+/).map(norm).filter(Boolean));
+            if (!tit.size) return true;
+            const ws = ch.palavras.map((x) => norm(x.w)).filter(Boolean);
+            return ws.filter((x) => tit.has(x)).length / Math.max(1, ws.length) < 0.6;
+        });
+        const v = pl.variacoes || {};
+        pl.legenda = { chunks, fonte: pl.fontes.texto, fonteDestaque: pl.fontes.destaque, tamanho: pl.h > pl.w ? 50 : 44, corDestaque: legendaCor(pl), y: pl.h > pl.w ? 0.78 : 0.9 };
+    }
+    return pl;
+}
+/** A cor da palavra-chave na legenda (sobre a faixa preta): o destaque se tem contraste, senão amarelo. */
+function legendaCor(pl) {
+    const ac = pl.paleta.destaque;
+    return contraste(ac, '#000000') >= 4.5 ? ac : (contraste(pl.paleta.tinta, '#000000') >= 4.5 ? pl.paleta.tinta : '#FFD54A');
+}
+
+/** Puxa os cortes para a batida mais próxima (até 0,28 s), sem deixar cena com menos de 1,4 s nem mexer no total. */
+function ajustarCortes(pl, batidas, { tolerancia = 0.28 } = {}) {
+    const bs = (batidas || []).filter((b) => isFinite(b));
+    if (!bs.length || pl.voz) return 0;
+    const n = pl.cenas.length, ini = pl.cenas.map((c) => c.inicio), total = pl.duracao;
+    let mexeu = 0;
+    for (let k = 1; k < n; k++) {
+        let melhor = null;
+        for (const b of bs) if (melhor == null || Math.abs(b - ini[k]) < Math.abs(melhor - ini[k])) melhor = b;
+        if (melhor == null || Math.abs(melhor - ini[k]) > tolerancia) continue;
+        const min = ini[k - 1] + 1.4, max = total - (n - k) * 1.4;
+        const novo = Math.max(min, Math.min(max, melhor));
+        if (Math.abs(novo - melhor) < 0.001) { ini[k] = novo; mexeu++; }
+    }
+    pl.cenas.forEach((c, i) => { c.inicio = Math.round(ini[i] * 1000) / 1000; c.dur = Math.round(((i < n - 1 ? ini[i + 1] : total) - ini[i]) * 1000) / 1000; });
+    return mexeu;
+}
+
+const lerKit = (n) => fs.readFileSync(path.join(KIT, n), 'utf8');
+/** O JSX completo: o kit, as primitivas, as cenas e a chamada `montar(PLANO)`. */
+function script(pl) {
+    return lerKit('base.jsx') + '\n' + lerKit('primitivas.jsx') + '\n' + lerKit('cenas.jsx') + '\nmontar(' + JSON.stringify(pl) + ');\n';
+}
+/** Os tempos medidos de cada cena (início de cada uma e o instante de conferir). */
+function tempos(pl) {
+    return pl.cenas.map((c) => {
+        const t = c.inicio != null ? c.inicio : 0;
+        return { inicio: t, fim: t + c.dur, conferir: Math.round((t + Math.min(c.dur - 0.1, c.dur * 0.78 + 0.05)) * 100) / 100 };
+    });
+}
+
+// ── áudio (a mixagem e as medidas moram em maquina-som.js) ────────────────
+
+function sondar(arq) {
+    const r = spawnSync('ffprobe', ['-v', 'error', '-show_entries', 'format=duration', '-of', 'default=nw=1:nk=1', arq], { encoding: 'utf8' });
+    const d = parseFloat(String(r.stdout || '').trim());
+    return isNaN(d) ? null : d;
+}
+const medirLufs = (arq) => require('./maquina-som.js').medirLufs(arq);
+const mixar = (o) => require('./maquina-som.js').mixar(o);
+
+/** Os eventos "SOM {json}" que o kit escreveu no stdout do script. */
+function lerSons(saida) {
+    const r = [];
+    for (const l of String(saida || '').split('\n')) {
+        const m = l.match(/^SOM (\{.*\})\s*$/);
+        if (m) { try { const e = JSON.parse(m[1]); if (e && e.tipo && isFinite(e.t)) r.push(e); } catch { /* linha ruim */ } }
+    }
+    return r.sort((a, b) => a.t - b.t);
+}
+
+/**
+ * Só os eventos-chave soam (Joel, 18/10: "muito efeito sonoro, sujo" e "muito explosivo"): troca (whoosh/swish curto), pouso do
+ * herói (1 pop por cena), clique, número/caixa/sino e a digitação (até 3 por cena). No máximo 1 evento a cada 0,6 s. Um único impacto
+ * SUAVE no vídeo inteiro, na virada principal (o corte do meio). Sem sub-drop, sem riser, sem glitch.
+ */
+function filtrarSons(eventos, pl) {
+    const cortes = pl.cenas.slice(1).map((c) => c.inicio);
+    const meio = cortes.length ? cortes[Math.floor(cortes.length / 2)] : null;
+    const daTroca = (t) => cortes.findIndex((c) => t >= c - 0.75 && t <= c + 0.3);
+    const cenaDe = (t) => { let k = 0; pl.cenas.forEach((c, i) => { if (t >= c.inicio - 0.01) k = i; }); return k; };
+    const cand = [];
+    const porCena = {};
+    const conta = (cena, tipo) => { const k = cena + ':' + tipo; porCena[k] = (porCena[k] || 0) + 1; return porCena[k]; };
+    for (const e of eventos) {
+        const g = e.ganho == null ? 1 : e.ganho;
+        const k = daTroca(e.t), cena = cenaDe(e.t);
+        let prio = 0, tipo = e.tipo, gan = g;
+        if (['troca', 'sobe', 'impacto', 'sub', 'glitch'].includes(e.tipo) && k >= 0) {
+            if (e.tipo === 'troca') { prio = 90; gan = Math.min(g, 0.8); }
+            else if (e.tipo === 'impacto' && meio != null && Math.abs(cortes[k] - meio) < 0.01) { prio = 95; tipo = 'impacto'; gan = 0.7; }
+        } else if (e.tipo === 'clique') prio = 80;
+        else if (e.tipo === 'impacto' && cena === pl.cenas.length - 1 && e.t > pl.cenas[cena].inicio + 0.5 && !eventos.some((x) => x.tipo === 'impacto' && meio != null && Math.abs(daTroca(x.t) >= 0 ? cortes[daTroca(x.t)] - meio : 9) < 0.01)) prio = 70;
+        else if (['caixa', 'sino', 'notif'].includes(e.tipo)) prio = conta(cena, e.tipo) <= 2 ? 70 : 0;
+        else if (e.tipo === 'brilho') prio = g >= 0.6 && conta(cena, 'brilho') <= 1 ? 60 : 0;
+        else if (e.tipo === 'pop') prio = conta(cena, 'pop') === 1 ? 55 : 0;     // o pouso do herói
+        else if (e.tipo === 'digita') prio = conta(cena, 'digita') <= 3 ? 45 : 0;
+        else if (['papel', 'tap', 'toque'].includes(e.tipo)) prio = conta(cena, e.tipo) <= 1 ? 40 : 0;
+        if (prio > 0) cand.push({ ...e, tipo, ganho: gan, prio, troca: k >= 0 && ['troca', 'impacto'].includes(e.tipo) ? k : -1 });
+    }
+    // no máximo 1 impacto suave no vídeo
+    let impactos = 0;
+    const lista = cand.filter((e) => (e.tipo === 'impacto' ? (++impactos <= 1) : true));
+    // espaçamento mínimo de 0,6 s entre eventos de grupos diferentes (a troca e o seu impacto contam como um grupo só)
+    lista.sort((a, b) => b.prio - a.prio || a.t - b.t);
+    const aceitos = [];
+    for (const e of lista) {
+        const choca = aceitos.some((x) => Math.abs(x.t - e.t) < 0.6 && !(e.troca >= 0 && x.troca === e.troca));
+        if (!choca) aceitos.push(e);
+    }
+    return aceitos.sort((a, b) => a.t - b.t).map(({ prio, troca, ...r }) => r);
+}
+const lerAvisos = (saida) => String(saida || '').split('\n').filter((l) => /^AVISO /.test(l)).map((l) => l.slice(6));
+const lerEntradas = (saida) => String(saida || '').split('\n').filter((l) => /^ENTRADA \{/.test(l)).map((l) => { try { return JSON.parse(l.slice(8)); } catch { return null; } }).filter(Boolean);
+const lerElementos = (saida) => { const m = String(saida || '').match(/^ELEMENTOS (\d+)/m); return m ? Number(m[1]) : null; };
+
+/** A variância de luminância do quadro (0 = tela lisa). */
+const variancia = (png) => { const m = require('./maquina-layout.js').medirQuadro(png); return m ? m.variancia : null; };
+const LIMIAR_VAZIO = 12;
+
+// ── a máquina ────────────────────────────────────────────────────────────
+
+/** Procura e baixa uma trilha; null se a busca não funcionar. */
+async function acharTrilha(pasta, busca) {
+    try {
+        const assets = require('./assets.js');
+        const termos = [busca, 'upbeat instrumental', 'corporate background'].filter(Boolean);
+        for (const t of termos) {
+            const r = await assets.procurarMusica(t, { quantas: 6, duracaoMin: 25 });
+            const lista = (r && r.sons) || [];
+            for (const item of lista.slice(0, 3)) {
+                const b = await assets.baixar(item, { pasta, nome: 'trilha-motion', sub: 'midia' });
+                if (b.ok) return { arquivo: b.arquivo, creditos: b.creditos || item.creditos || null, titulo: item.titulo };
+            }
+        }
+    } catch { /* sem rede */ }
+    return null;
+}
+
+/** As fontes para o render: o peso que a família tem (as de peso único vão em 400). */
+const SO_400 = new Set(['Anton', 'Archivo Black', 'Instrument Serif', 'Bebas Neue', 'Caveat']);
+function fontesDoPlano(pl) {
+    const f = pl.fontes, it = pl.tipo && pl.tipo.realce === 'italico';
+    const so = (fam) => SO_400.has(fam);
+    return [
+        { familia: f.titulo, peso: so(f.titulo) ? 400 : 800 },
+        { familia: f.texto, peso: so(f.texto) ? 400 : 700 },
+        { familia: f.destaque, peso: it ? (so(f.destaque) ? '400i' : '700i') : (so(f.destaque) ? 400 : 700) },
+    ];
+}
+
+/** Reparte uma narração única entre as cenas que não trazem `fala` (frases em ordem, em grupos contíguos). */
+function repartirFala(texto, cenas) {
+    const frases = String(texto || '').replace(/\s+/g, ' ').match(/[^.!?]+[.!?]*/g) || [];
+    const limpas = frases.map((s) => s.trim()).filter(Boolean);
+    if (!limpas.length) return;
+    const n = cenas.length;
+    cenas.forEach((c, i) => {
+        const de = Math.floor(i * limpas.length / n), ate = Math.floor((i + 1) * limpas.length / n);
+        c.fala = limpas.slice(de, Math.max(ate, de + (i === n - 1 && de >= limpas.length ? 0 : 0))).join(' ') || c.fala || '';
+    });
+}
+
+/**
+ * estudio_motion: do pedido ao mp4 com som.
+ * `deps` (injetáveis; testes e servidor): renderizar, narrar(texto, mp3, voz), whisper(mp3), elementos(opts), trilha(pasta, busca),
+ *   batidas(arquivo), sfxIndice, semRede, historico (array) e arquivoHistorico (caminho).
+ * Devolve {ok, video, quadros, folha, duracao, lufs, cenas, conferencia, avisos, trilha, assinatura, elementos}.
+ */
+async function motion(args = {}, { pasta, receita = null, deps = {} } = {}) {
+    if (!pasta) return { ok: false, error: 'faltou a pasta do projeto.' };
+    if (!args.assunto && !(Array.isArray(args.cenas) && args.cenas.length)) return { ok: false, error: 'estudio_motion pede o assunto (ou as cenas).' };
+    fs.mkdirSync(pasta, { recursive: true });
+    const renderizar = deps.renderizar || require('./effectcraft.js').renderizar;
+    const layout = require('./maquina-layout.js');
+    const semRede = !!(deps.semRede || args.semRede);
+    const arqHist = deps.arquivoHistorico || diretor.arquivoHistorico();
+    const historico = deps.historico || diretor.lerHistorico(arqHist);
+    const assunto = limpa(args.assunto || (args.cenas[0] && (args.cenas[0].titulo || args.cenas[0].texto)) || '', 160);
+
+    // 1. os elementos reais do assunto
+    const meta = diretor.achar(assunto + ' ' + (args.metafora || ''));
+    const pedidos = Array.isArray(args.elementos) ? args.elementos : (args.elementos ? [args.elementos] : []);
+    const reunir = deps.elementos || require('./maquina-elementos.js').reunir;
+    const el = await reunir({ assunto, pedidos, meta, pasta, rede: !semRede, logos: args.logos, site: args.site, minimo: 3, max: 6 });
+    const elementos = (el && el.elementos) || [];
+
+    // 2. a direção (primitivas, transições, câmera, tipografia, paleta) com semente e conferência de assinatura
+    let pl = plano({ ...args, assunto }, { receita, historico, elementos });
+    const avisosDeMotor = [];
+    if (elementos.length < 3) avisosDeMotor.push(`só ${elementos.length} elemento(s) real(is) do assunto (o pedido é ≥ 3)`);
+
+    // 3. a narração (opcional) manda no tempo
+    let voz = null;
+    const quer = args.voz || pl.cenas.some((c) => c.fala);
+    if (args.voz && quer) {
+        const textoVoz = typeof args.voz === 'string' ? args.voz : (args.voz.texto || '');
+        if (textoVoz && !pl.cenas.some((c) => c.fala)) repartirFala(textoVoz, pl.cenas);
+        pl.cenas.forEach((c) => { if (!c.fala) c.fala = String(c.titulo || c.texto || '').replace(/\*/g, ''); });
+        const mv = require('./maquina-voz.js');
+        const r = await mv.falarEMedir({ falas: pl.cenas.map((c) => c.fala), pasta, voz: typeof args.voz === 'object' ? args.voz.voz : undefined, narrar: deps.narrar, whisper: deps.whisper });
+        if (r.ok) { voz = r; aplicarVoz(pl, r, { legenda: args.legenda !== false }); }
+        else avisosDeMotor.push('a narração não saiu: ' + r.error);
+    }
+
+    // 4. a trilha: energia alta (BPM ≥ 110, batida firme), fora da lista negra, com o drop no corte mais pesado; sem faixa boa, sem música
+    let trilha = null, analise = null, semMusica = null, trilhaInicio = 0;
+    if (args.trilha !== false && args.trilha !== 0) {
+        const T = require('./maquina-trilha.js');
+        const arquivoPessoa = typeof args.trilha === 'string' && fs.existsSync(args.trilha) ? args.trilha : null;
+        const busca = typeof args.trilha === 'string' && !arquivoPessoa && args.trilha !== 'true' ? args.trilha : null;
+        let r;
+        if (deps.trilha) {   // injetada (testes): o contrato antigo {arquivo,...} + deps.batidas
+            const t0 = await deps.trilha(pasta, busca);
+            r = t0 && t0.arquivo ? { ...t0, ...(deps.batidas ? await deps.batidas(t0.arquivo) : {}) } : { semMusica: true, motivo: 'sem trilha' };
+        } else r = await T.escolher({ chave: meta.chave, busca, arquivo: arquivoPessoa, pasta, rede: !semRede });
+        if (r && r.arquivo) {
+            trilha = r;
+            const cortes = pl.cenas.slice(1).map((c, i) => ({ t: c.inicio, peso: ['tremor', 'corte', 'chicote', 'zoom'].includes(pl.trocas[i]) ? 3 : 1 }));
+            const meio = cortes[Math.floor(cortes.length / 2)]; if (meio) meio.peso = 5;   // o drop cai no corte do meio (a virada)
+            if (r.batidas && r.batidas.length > 3 && r.confianca >= 0.7) {
+                trilhaInicio = T.inicioNoDrop(cortes, r, pl.duracao).inicio || 0;
+                const vb = r.batidas.map((b) => b - trilhaInicio).filter((b) => b >= 0);
+                analise = { bpm: r.bpm, batidas: vb, confianca: r.confianca, acentos: (r.acentos || []).map((a) => a - trilhaInicio).filter((a) => a >= 0) };
+                pl.bpm = r.bpm; pl.batidaFase = vb.length ? vb[0] % (60 / r.bpm) : 0;
+                if (!voz) analise.cortesNaBatida = ajustarCortes(pl, vb);
+            }
+        } else if (r && r.semMusica) { semMusica = r.motivo; avisosDeMotor.push('sem música: ' + r.motivo); }
+    }
+
+    // 5. conferência → corrige → confere de novo (o script e os quadros, sem renderizar o vídeo); só no fim vem o render de verdade.
+    //    O relatório conta as violações de cada tipo na 1ª passada ("antes") e na última ("depois").
+    let r = null, conferencia = null;
+    const historicoDeTentativas = [], passadas = [];
+    const classificar = (avisos, auditorias, entradas, vazios, baixo, tardias) => {
+        const cnt = { foraDaArea: 0, colisao: 0, poucoEspaco: 0, textoPequeno: 0, heroiPequeno: 0, entradaTardia: tardias.length, quadroVazio: vazios.length, contrasteBaixo: baixo.filter((b) => b.contraste < 3).length, quadrosForaDaArea: 0, quadrosComColisao: 0 };
+        for (const a of avisos) {
+            if (/fora da área segura/.test(a)) cnt.foraDaArea++;
+            else if (/colisão|se sobrepõem/.test(a)) cnt.colisao++;
+            else if (/pouco espaço/.test(a)) cnt.poucoEspaco++;
+            else if (/texto principal pequeno/.test(a)) cnt.textoPequeno++;
+            else if (/herói pequeno/.test(a)) cnt.heroiPequeno++;
+        }
+        for (const x of auditorias) { cnt.quadrosForaDaArea += x.foraDaArea || 0; cnt.quadrosComColisao += x.colisoes || 0; }
+        return cnt;
+    };
+    const lerAudit = (saida) => String(saida || '').split('\n').filter((l) => /^AUDIT \{/.test(l)).map((l) => { try { return JSON.parse(l.slice(6)); } catch { return null; } }).filter(Boolean);
+    const tm0 = tempos(pl);
+    for (let tentativa = 1; tentativa <= 5; tentativa++) {
+        const tm = tempos(pl);
+        // quadros: 1 por cena (no instante de ler) + 2 em cada troca (+0,08 s e +0,22 s) para pegar borda de comp aparecendo e borrão
+        const trTempos = []; pl.cenas.slice(1).forEach((c) => trTempos.push(Math.round((c.inicio + 0.08) * 100) / 100, Math.round((c.inicio + 0.22) * 100) / 100));
+        r = await renderizar({ pasta, script: script(pl), comp: 'MAIN', fontes: fontesDoPlano(pl), conferir: tm.map((x) => x.conferir).concat(trTempos), semVideo: true, previa: !!args.previa });
+        if (!r.ok) return r;
+        const avisos = lerAvisos(r.saida);
+        const nReais = lerElementos(r.saida);
+        const entradas = lerEntradas(r.saida);
+        const auditorias = lerAudit(r.saida);
+        // a regra dos 30–40%: nada novo entra depois de 40% da cena (com voz, vale a palavra: até 60%)
+        const lim = voz ? 0.6 : 0.4;
+        const tardias = entradas.filter((x) => x.max / (x.f || 1) > lim * x.dur + 0.02).map((x) => ({ cena: x.cena, entrou: Math.round(x.max / (x.f || 1) * 100) / 100, dur: x.dur, f: x.f }));
+        const nCenas = pl.cenas.length, quadrosCena = (r.quadros || []).slice(0, nCenas), quadrosTroca = (r.quadros || []).slice(nCenas);
+        const c = layout.conferir(quadrosCena);
+        const vazios = c.vazios;
+        // as checagens de pixel: borda da comp aparecendo, retângulo sólido preto/branco fora da paleta, borrão ilegível nas trocas
+        const pxChecks = { bordaDaComp: [], solidoForaDaPaleta: [], borrao: [] };
+        const nitidezCena = [];
+        quadrosCena.forEach((q, i) => { const px = layout.lerPixels(q); if (!px) return; nitidezCena.push(layout.nitidez(px)); const fb = layout.faixaDeBorda(px); if (fb) pxChecks.bordaDaComp.push({ cena: i, ...fb }); const pc = pl.cenas[i].pal; const so = layout.solidosForaDaPaleta(px, [pc.bg, pc.fg, pc.ac, pc.mudo, pc.card]); if (so >= 0.025) pxChecks.solidoForaDaPaleta.push({ cena: i, fracao: Math.round(so * 1000) / 1000 }); });
+        const nitMed = nitidezCena.slice().sort((a, b) => a - b)[Math.floor(nitidezCena.length / 2)] || 0;
+        quadrosTroca.forEach((q, k) => { const px = layout.lerPixels(q); if (!px) return; const cutIdx = Math.floor(k / 2) + 1; const nt = layout.nitidez(px); if (nitMed > 0 && layout.varLum(px) > 400 && nt < nitMed * 0.01) pxChecks.borrao.push({ cena: cutIdx, nitidez: nt, referencia: nitMed }); });
+        const graves = c.baixoContraste.filter((b) => b.contraste < 3);
+        const contagem = classificar(avisos, auditorias, entradas, vazios, c.baixoContraste, tardias);
+        contagem.bordaDaComp = pxChecks.bordaDaComp.length; contagem.solidoForaDaPaleta = pxChecks.solidoForaDaPaleta.length; contagem.borrao = pxChecks.borrao.length;
+        passadas.push({ passada: tentativa, ...contagem });
+        conferencia = { tentativas: tentativa, quadros: (r.quadros || []).length, pixels: pxChecks, vazios, baixoContraste: c.baixoContraste, bordas: c.bordas, avisos, auditoria: auditorias, elementosNaCena: nReais, entradas: entradas.map((x) => ({ cena: x.cena, entrou: Math.round(x.max / (x.f || 1) * 100) / 100, dur: x.dur, f: x.f })), entradaTardia: tardias, ok: !vazios.length && !graves.length && !avisos.length && !tardias.length && !pxChecks.bordaDaComp.length && !pxChecks.solidoForaDaPaleta.length && !pxChecks.borrao.length };
+        if (conferencia.ok || tentativa === 5) break;
+        const mudou = layout.corrigir(pl, { avisos, vazios, baixoContraste: c.baixoContraste, bordas: [], tardias, pixels: pxChecks }, { tentativa, paletaFundo: pl.variacoes && pl.variacoes.fundo });
+        historicoDeTentativas.push({ tentativa, mudou });
+        if (!mudou.length) break;
+    }
+    conferencia.correcoes = historicoDeTentativas;
+    conferencia.relatorio = { antes: passadas[0], depois: passadas[passadas.length - 1], passadas };
+    try { fs.writeFileSync(path.join(pasta, 'ae', 'conferencia.json'), JSON.stringify(conferencia.relatorio, null, 2)); } catch { /* sem relatório em disco */ }
+    // a passada de verdade: o render do vídeo com o plano já corrigido
+    r = await renderizar({ pasta, script: script(pl), comp: 'MAIN', fontes: fontesDoPlano(pl), conferir: tm0.map((x) => x.conferir), previa: !!args.previa });
+    if (!r.ok) return r;
+
+    // 6. o som: SFX reais CC0 escolhidos por ação e assunto, nos tempos, com a batida e a voz
+    const eventosBrutos = lerSons(r.saida);
+    const eventos = filtrarSons(eventosBrutos, pl);
+    const som = require('./maquina-som.js');
+    const final = path.join(pasta, 'video-motion.mp4');
+    let mix = { ok: false, semAudio: true, video: r.video }, sons = [], sfxReais = 0;
+    if (!args.previa) try {   // prévia: sem mix final pesado
+        let indice = deps.sfxIndice || null;
+        if (!indice) indice = await som.prepararBiblioteca({ assunto, acoes: [...new Set(eventos.map((e) => e.tipo))], rede: !semRede });
+        const base = eventos.map((e) => (voz ? { ...e, ganho: (e.ganho == null ? 1 : e.ganho) * 0.8 } : e));
+        sons = som.escolherSons(base, { assunto, indice, semente: pl.semente || 1 });
+        if (analise && analise.confianca >= 0.7) sons = som.encaixarNaBatida(sons, analise.batidas);
+        sfxReais = sons.filter((s) => s.arquivo).length;
+        mix = som.mixar({ pasta, mudo: r.video, saida: final, sons, trilha: trilha && trilha.arquivo, trilhaInicio, voz: voz && voz.mp3, duracao: pl.duracao });
+    } catch (e) { mix = { ok: false, error: e.message, video: r.video }; }
+    const video = mix.ok ? mix.video : r.video;
+    if (args.saida && fs.existsSync(video)) { try { fs.mkdirSync(path.dirname(args.saida), { recursive: true }); fs.copyFileSync(video, args.saida); } catch { /* sem cópia */ } }
+
+    // 7. a folha de contato e a assinatura (gravada no histórico: o próximo vídeo foge dela)
+    const dur = sondar(video) || pl.duracao;
+    const folha = layout.folhaDeContato(video, path.join(pasta, 'ae', 'folha-de-contato.png'), dur);
+    const assinatura = { ...pl.direcao, arquivo: path.basename(pasta), elementos: elementos.map((e) => e.nome), voz: !!voz };
+    if (!deps.historico && args.registrar !== false && !args.previa) diretor.registrar(assinatura, arqHist);
+    // o editor (editor.js) guarda o plano e a versão: é o que `estudio_editar` reabre
+    let sv = {};
+    try { sv = require('./editor.js').salvarSpec(pasta, { pl, args, trilha: trilha && { arquivo: trilha.arquivo, inicio: trilhaInicio }, voz: voz && { mp3: voz.mp3 }, video, previa: !!args.previa }) || {}; } catch { /* sem versão */ }
+    return {
+        ok: true, video: sv.video || video, versao: sv.versao, previa: !!args.previa, quadros: r.quadros || [], folha, duracao: dur,
+        lufs: mix.ok ? mix.lufs : null, formato: pl.formato, cenas: pl.cenas.map((c) => ({ tipo: c.tipo, dur: c.dur, papel: c.papel, camera: c.camera })),
+        trocas: pl.trocas, tipografia: pl.tipo.nome, camera: pl.camera, paleta: pl.direcao.paleta,
+        sons: eventos.length, sonsBrutos: eventosBrutos.length, sfxReais, mix: mix.mix || null, trilha: trilha ? { titulo: trilha.titulo, autor: trilha.autor, creditos: trilha.creditos, bpm: trilha.bpm, nota: trilha.nota, lufs: trilha.lufs, inicio: trilhaInicio, cortesNaBatida: analise && analise.cortesNaBatida, pessoa: !!trilha.pessoa } : null, semMusica,
+        voz: !!voz, vozMotor: voz && voz.motor, vozMedida: voz && voz.medido, conferencia, receita: pl.receita, projeto: r.projeto, assinatura,
+        elementos: elementos.map((e) => ({ nome: e.nome, tipo: e.tipo, licenca: e.licenca })), creditos: (el && el.creditos) || [],
+        avisos: avisosDeMotor,
+        _exportar: { palavras: voz ? voz.palavras : [], sfx: sons.filter((x) => x.arquivo).map((x) => x.arquivo), cenas: pl.cenas.map((c) => ({ papel: c.papel, titulo: c.titulo, texto: c.texto, fala: c.fala, botao: c.botao, dur: c.dur })), trilhaArquivo: trilha && trilha.arquivo },
+        ...(mix.ok || args.previa ? {} : { aviso: 'o vídeo saiu sem a mixagem de áudio: ' + (mix.error || 'sem sons') }),
+    };
+}
+
+module.exports = { filtrarSons, FORMATOS, TIPOS, TROCAS, PALETAS, plano, aplicarVoz, ajustarCortes, roteiroPadrao, normalizarCena, paletaDoAssunto, variacoes, contraste, script, tempos, lerSons, lerAvisos, lerElementos, lerEntradas, mixar, variancia, medirLufs, motion, marcarChave, fontesDoPlano, repartirFala, LIMIAR_VAZIO };

package/lib/estudio/projetos.js

@@ -0,0 +1,60 @@
+/**
+ * projetos.js — receitas de projetos completos que a IA consulta antes de montar.
+ *
+ * Cada receita (dados/projetos/*.json) diz para quem serve, a ficha técnica,
+ * as etapas e um prompt com {{CAMPOS}}. O conteúdo é original do PrimoCode e
+ * descreve o que as ferramentas do Estúdio já fazem.
+ */
+
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+
+const PASTA = path.join(__dirname, 'dados', 'projetos');
+const CATEGORIAS = ['narrado', 'produto', 'saas', 'sound', 'elementos', 'ae'];
+
+const sem = (s) => String(s || '').normalize('NFD').replace(/[̀-ͯ]/g, '').toLowerCase();
+
+let cache = null;
+function todos() {
+    if (!cache) {
+        cache = fs.readdirSync(PASTA).filter((f) => f.endsWith('.json')).sort()
+            .map((f) => JSON.parse(fs.readFileSync(path.join(PASTA, f), 'utf8')));
+    }
+    return cache;
+}
+
+/** Busca sem acento em título, resumo, estilo e indicado; sem termo, lista tudo. */
+function procurar({ termo, categoria, limite = 10 } = {}) {
+    const cat = categoria ? sem(categoria) : '';
+    const palavras = sem(termo).split(/\s+/).filter(Boolean);
+    const achados = todos().filter((p) => {
+        if (cat && p.categoria !== cat) return false;
+        const palheiro = sem([p.titulo, p.resumo, (p.estilo || []).join(' '), p.indicado].join(' '));
+        return palavras.every((w) => palheiro.includes(w));
+    })
+        // Com 68 receitas, a ordem importa: a palavra no título vale mais que no resumo.
+        .map((p) => ({ p, nota: palavras.filter((w) => sem(p.titulo).includes(w)).length }))
+        .sort((a, b) => b.nota - a.nota)
+        .map((x) => x.p)
+        .slice(0, Math.max(1, Number(limite) || 10));
+    return {
+        ok: true, quantos: achados.length, categorias: CATEGORIAS,
+        projetos: achados.map((p) => ({ id: p.id, titulo: p.titulo, categoria: p.categoria, resumo: p.resumo, estilo: p.estilo, motor: p.ficha.motor })),
+        nota: 'estudio_midia acao:"projeto" nome:"<id>" traz a receita inteira.',
+    };
+}
+
+/** A receita inteira, pelo id (ou, na falta, o melhor palpite do texto). */
+function ver(id) {
+    const q = sem(id).trim();
+    if (!q) return { ok: false, error: 'diga o id da receita (acao:"projetos" lista).' };
+    const p = todos().find((x) => x.id === q) || procurar({ termo: q, limite: 1 }).projetos.map((x) => todos().find((y) => y.id === x.id))[0];
+    if (!p) return { ok: false, error: `não há receita "${id}".`, ids: todos().map((x) => x.id) };
+    // Os scripts do After Effects ficam em disco: a resposta leva o caminho, e o agente lê só o que precisar.
+    if (p.scripts_ae) p.scripts_ae = { ...p.scripts_ae, caminho: path.join(__dirname, 'dados', 'projetos-ae', p.id.replace(/^clube-/, '')) };
+    return { ok: true, projeto: p };
+}
+
+module.exports = { procurar, ver, CATEGORIAS };

package/lib/headless.js

@@ -0,0 +1,71 @@
+/**
+ * headless.js — `primocode -p "pedido"`: sem tela, para script e CI.
+ *
+ *   primocode -p "arruma o teste"                 texto no stdout
+ *   primocode -p "..." --output-format json       um JSON no fim: {type, is_error, result, duration_ms}
+ *   git diff | primocode -p "revisa isso"         o stdin entra no pedido
+ *   primocode -p "..." --permission-mode plan     só lê (ver lib/perigo.js)
+ *
+ * Mesma ideia do `claude -p` e do `codex exec` (flags documentadas deles; o
+ * código é nosso). O pedido passa pelo MESMO caminho do digitado (sendPrompt).
+ * Código de saída: 0 ok, 1 erro.
+ */
+'use strict';
+
+const { stripAnsi } = require('./ui');
+
+const FORMATOS = ['text', 'json'];
+
+/** Tira -p/--print, --output-format e --permission-mode dos argumentos. */
+function analisar(argv) {
+    const r = { ativo: false, formato: 'text', permissao: null, resto: [], erro: null };
+    for (let i = 0; i < argv.length; i++) {
+        const a = argv[i];
+        const [chave, valor] = a.startsWith('--') && a.includes('=') ? [a.slice(0, a.indexOf('=')), a.slice(a.indexOf('=') + 1)] : [a, null];
+        if (a === '-p' || a === '--print') r.ativo = true;
+        else if (chave === '--output-format') {
+            const v = valor !== null ? valor : argv[++i];
+            if (!FORMATOS.includes(v)) r.erro = `--output-format aceita ${FORMATOS.join(' ou ')}`;
+            else r.formato = v;
+        } else if (chave === '--permission-mode') r.permissao = valor !== null ? valor : argv[++i];
+        else r.resto.push(a);
+    }
+    return r;
+}
+
+/** O pedido: os argumentos soltos, mais o stdin (que vem depois, como contexto). */
+function montarPedido(palavras, stdin) {
+    const pedido = palavras.join(' ').trim();
+    const extra = String(stdin || '').trim();
+    if (pedido && extra) return `${pedido}\n\n${extra}`;
+    return pedido || extra;
+}
+
+function lerStdin() {
+    if (process.stdin.isTTY) return Promise.resolve('');
+    return new Promise((resolve) => {
+        let s = '';
+        process.stdin.setEncoding('utf8');
+        process.stdin.on('data', (d) => { s += d; });
+        process.stdin.on('end', () => resolve(s));
+        process.stdin.on('error', () => resolve(s));
+    });
+}
+
+/** Roda `fn` guardando tudo o que ela escreve. `calar` esconde da tela. */
+async function capturar(fn, { calar = false } = {}) {
+    const log = console.log;
+    const escrever = process.stdout.write.bind(process.stdout);
+    let texto = '';
+    const pega = (s) => { texto += stripAnsi(s); };
+    console.log = (...a) => { pega(a.join(' ') + '\n'); if (!calar) log(...a); };
+    process.stdout.write = (s, ...resto) => { pega(typeof s === 'string' ? s : Buffer.from(s).toString()); return calar ? true : escrever(s, ...resto); };
+    try { await fn(); } finally { console.log = log; process.stdout.write = escrever; }
+    return texto.replace(/\n{3,}/g, '\n\n').trim();
+}
+
+function resultadoJson({ texto, erro, inicio, permissao }) {
+    return JSON.stringify({ type: 'result', is_error: !!erro, result: erro ? String(erro) : texto, duration_ms: Date.now() - inicio, permission_mode: permissao || 'auto' });
+}
+
+module.exports = { analisar, montarPedido, lerStdin, capturar, resultadoJson, FORMATOS };