primocode 10.13.0 → 10.14.1

package/lib/estudio/effectcraft.js

@@ -0,0 +1,152 @@
+/**
+ * effectcraft.js — o motor After Effects do Estúdio.
+ *
+ * O EffectCraft (github.com/storytold/effectcraft, MIT/Apache-2.0) roda JSX
+ * (ExtendScript) no modelo de objetos do After Effects, sem o After Effects:
+ * `script` monta o projeto (.ecproj), `render` gera o mp4 e `render-frame` um
+ * quadro para a IA conferir. O PrimoCode baixa o binário uma vez, confere o
+ * sha256 e guarda em ~/.primocode/bin/effectcraft-<versão>/.
+ */
+
+'use strict';
+
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+const crypto = require('crypto');
+const { spawnSync } = require('child_process');
+
+const VERSAO = '0.11.1';
+const BASE = 'https://github.com/storytold/effectcraft/releases/download/v' + VERSAO + '/';
+const SHA_MAC = '8eae2e1e9c13e03d1bc2460501a90d43fc570b37e9b386294c0720eb12aad0f0';
+const PASTA_BIN = () => path.join(os.homedir(), '.primocode', 'bin', 'effectcraft-' + VERSAO);
+
+/** O asset da release para esta máquina: { arquivo, sha (null = ler do SHA256SUMS.txt) }. */
+function asset(plataforma = process.platform, arq = process.arch) {
+    if (plataforma === 'darwin') return { arquivo: `effectcraft-cli-${VERSAO}-macos-universal.zip`, sha: SHA_MAC };
+    if (plataforma === 'linux') return { arquivo: `effectcraft-${VERSAO}-linux-${arq === 'arm64' ? 'aarch64' : 'x86_64'}.tar.gz`, sha: null };
+    if (plataforma === 'win32') return { arquivo: `effectcraft-${VERSAO}-windows-${arq === 'arm64' ? 'arm64' : 'x64'}-portable.zip`, sha: null };
+    return null;
+}
+
+function achar(dir, nome) {
+    for (const e of fs.readdirSync(dir, { withFileTypes: true })) {
+        const p = path.join(dir, e.name);
+        if (e.isDirectory()) { const r = achar(p, nome); if (r) return r; }
+        else if (e.name === nome || e.name === nome + '.exe') return p;
+    }
+    return null;
+}
+
+async function baixar(url) {
+    const r = await fetch(url, { redirect: 'follow', signal: AbortSignal.timeout(180000) });
+    if (!r.ok) throw new Error('HTTP ' + r.status + ' em ' + url);
+    return Buffer.from(await r.arrayBuffer());
+}
+
+/** O caminho do executável (baixa se faltar). `{ok, bin}` ou `{ok:false, error}`. */
+async function garantir({ bin } = {}) {
+    const dado = bin || process.env.PRIMOCODE_EFFECTCRAFT_BIN;
+    if (dado) return fs.existsSync(dado) ? { ok: true, bin: dado } : { ok: false, error: 'binário do EffectCraft não existe: ' + dado };
+    const dir = PASTA_BIN();
+    const ja = fs.existsSync(dir) ? achar(dir, 'effectcraft-cli') : null;
+    if (ja) return { ok: true, bin: ja };
+    const a = asset();
+    if (!a) return { ok: false, error: 'o EffectCraft não tem binário para ' + process.platform };
+    try {
+        let sha = a.sha;
+        if (!sha) {
+            const sums = (await baixar(BASE + 'SHA256SUMS.txt')).toString('utf8');
+            const linha = sums.split('\n').find((l) => l.trim().endsWith(a.arquivo));
+            sha = linha && linha.trim().split(/\s+/)[0];
+            if (!sha) return { ok: false, error: 'SHA256SUMS.txt da release não lista ' + a.arquivo };
+        }
+        const buf = await baixar(BASE + a.arquivo);
+        const got = crypto.createHash('sha256').update(buf).digest('hex');
+        if (got !== sha) return { ok: false, error: `sha256 do EffectCraft não confere (esperado ${sha}, veio ${got})` };
+        fs.mkdirSync(dir, { recursive: true });
+        const tmp = path.join(dir, a.arquivo);
+        fs.writeFileSync(tmp, buf);
+        const x = a.arquivo.endsWith('.zip')
+            ? (process.platform === 'win32' ? spawnSync('tar', ['-xf', tmp, '-C', dir]) : spawnSync('unzip', ['-oq', tmp, '-d', dir]))
+            : spawnSync('tar', ['-xzf', tmp, '-C', dir]);
+        fs.rmSync(tmp, { force: true });
+        if (x.status !== 0) return { ok: false, error: 'não consegui extrair o EffectCraft: ' + String(x.stderr || x.error || '').slice(0, 300) };
+        const exe = achar(dir, 'effectcraft-cli');
+        if (!exe) return { ok: false, error: 'o executável effectcraft-cli não estava no pacote' };
+        if (process.platform !== 'win32') fs.chmodSync(exe, 0o755);
+        return { ok: true, bin: exe };
+    } catch (e) {
+        return { ok: false, error: 'não consegui baixar o EffectCraft (sem rede?): ' + (e && e.message || e) };
+    }
+}
+
+function rodar(bin, args, env, timeout) {
+    const r = spawnSync(bin, args, { encoding: 'utf8', env, timeout, maxBuffer: 32 * 1024 * 1024 });
+    const saida = ((r.stdout || '') + (r.stderr || '')).trim();
+    if (r.error) return { ok: false, saida: (r.error.code === 'ETIMEDOUT' ? 'estourou o tempo' : r.error.message) + '\n' + saida };
+    return { ok: r.status === 0, saida };
+}
+
+/**
+ * Roda o JSX, renderiza o mp4 e os quadros de conferência.
+ * `fontes`: [{familia, peso}] baixadas do Google Fonts e passadas em EFFECTCRAFT_FONT_DIRS.
+ * `previa`: rascunho em meia resolução e qualidade draft (segundos, não minutos), para aprovar antes do final.
+ */
+async function renderizar({ pasta, script, comp, fontes = [], audio, conferir = [], bin, timeouts = {}, semVideo = false, previa = false } = {}) {
+    if (!pasta || !script || !comp) return { ok: false, error: 'faltou pasta, script ou comp' };
+    const g = await garantir({ bin });
+    if (!g.ok) return g;
+    const ae = path.join(pasta, 'ae');
+    fs.mkdirSync(ae, { recursive: true });
+    const jsx = path.join(ae, 'cena.jsx');
+    const projeto = path.join(ae, 'projeto.ecproj');
+    fs.writeFileSync(jsx, script);
+
+    const env = { ...process.env };
+    const dirs = [];
+    if (fontes && fontes.length) {
+        const glifos = require('./glifos.js');
+        for (const f of fontes) {
+            try { if (await glifos.baixarFonte(f.familia, f.peso || 400)) dirs.push(glifos.CACHE); } catch { /* sem rede: segue com a fonte do sistema */ }
+        }
+    }
+    if (dirs.length) env.EFFECTCRAFT_FONT_DIRS = [...new Set(dirs)].join(path.delimiter);
+
+    const s = rodar(g.bin, ['script', jsx, '--empty', '--save-as', projeto], env, timeouts.script || 120000);
+    if (!s.ok || !fs.existsSync(projeto)) return { ok: false, error: 'o script JSX falhou:\n' + s.saida.slice(-1500) };
+
+    const bruto = path.join(pasta, audio ? 'video-ae-mudo.mp4' : 'video-ae.mp4');
+    if (semVideo) {   // só a conferência: o script rodou (avisos, auditoria) e os quadros saem; o vídeo fica para a passada final
+        const quadros0 = [];
+        for (const t of conferir || []) {
+            const png = path.join(ae, `quadro-${t}.png`);
+            const q = rodar(g.bin, ['render-frame', '--project', projeto, '--comp', comp, '--time', String(t), '--out', png, '--max-side', '640'], env, timeouts.quadro || 60000);
+            if (q.ok && fs.existsSync(png)) quadros0.push(png);
+        }
+        return { ok: true, video: null, quadros: quadros0, projeto, saida: s.saida, semVideo: true };
+    }
+    const r = rodar(g.bin, ['render', '--project', projeto, '--comp', comp, '--out', bruto, '--format', 'h264', ...(previa ? ['--resolution', 'half', '--quality', 'draft'] : [])], env, timeouts.render || (previa ? 180000 : 600000));
+    if (!r.ok || !fs.existsSync(bruto)) return { ok: false, error: 'o render falhou:\n' + r.saida.slice(-1500) };
+
+    const quadros = [];
+    for (const t of conferir || []) {
+        const png = path.join(ae, `quadro-${t}.png`);
+        const q = rodar(g.bin, ['render-frame', '--project', projeto, '--comp', comp, '--time', String(t), '--out', png, '--max-side', '640'], env, timeouts.quadro || 60000);
+        if (q.ok && fs.existsSync(png)) quadros.push(png);
+    }
+
+    let video = bruto;
+    const aud = audio ? path.resolve(pasta, audio) : null;
+    if (aud && fs.existsSync(aud)) {
+        const final = path.join(pasta, 'video-ae.mp4');
+        const m = rodar('ffmpeg', ['-y', '-i', bruto, '-i', aud, '-c:v', 'copy', '-c:a', 'aac', '-shortest', final], process.env, timeouts.audio || 120000);
+        if (m.ok && fs.existsSync(final)) { video = final; fs.rmSync(bruto, { force: true }); }
+    } else if (audio) {
+        fs.renameSync(bruto, path.join(pasta, 'video-ae.mp4'));
+        video = path.join(pasta, 'video-ae.mp4');
+    }
+    return { ok: true, video, quadros, projeto, saida: s.saida };
+}
+
+module.exports = { VERSAO, asset, garantir, renderizar };

package/lib/estudio/exportar.js

@@ -0,0 +1,181 @@
+'use strict';
+/**
+ * exportar.js — o PACOTE PRA POSTAR do estudio_motion, depois do render.
+ *   exportar({video, pasta, assunto, formatos, cenas, palavras, trilha, sfx, assinatura}) → {ok, dir, arquivos}
+ *   srt(palavras)            → texto .srt (usa os mesmos pedaços da legenda do vídeo)
+ *   postTxt({...})           → gancho + 3 linhas + CTA + 5 hashtags + créditos CC BY
+ *   creditosDe(trilha, sfx)  → linhas de atribuição (só licenças que exigem)
+ *   galeria: registrar / listar / abrir / main(['abrir'|'pasta', n])
+ * Nunca estica: 9:16, 1:1 e 16:9 saem com o fundo desfocado e o vídeo centralizado.
+ */
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+const { spawnSync } = require('child_process');
+
+const DIMS = { '9:16': [1080, 1920], '1:1': [1080, 1080], '16:9': [1920, 1080] };
+const ARQ_GALERIA = () => process.env.PRIMOCODE_VIDEOS || path.join(os.homedir(), '.primocode', 'studio', 'videos.json');
+const PARADAS = new Set('para como uma umas uns com que dos das nos nas por mais sobre entre seu sua isso esse essa este esta pelo pela muito tudo cada sem'.split(' '));
+
+const ff = (args) => spawnSync('ffmpeg', ['-y', '-v', 'error', ...args], { encoding: 'utf8' });
+function sondar(arq) {
+    const r = spawnSync('ffprobe', ['-v', 'error', '-select_streams', 'v:0', '-show_entries', 'stream=width,height:format=duration', '-of', 'json', arq], { encoding: 'utf8' });
+    try { const j = JSON.parse(r.stdout); const s = j.streams[0]; return { w: s.width, h: s.height, dur: parseFloat(j.format.duration) }; } catch { return null; }
+}
+
+// ── legenda .srt ─────────────────────────────────────────────────────────
+const tempoSrt = (s) => {
+    const ms = Math.max(0, Math.round(s * 1000));
+    const p = (n, l = 2) => String(n).padStart(l, '0');
+    return `${p(Math.floor(ms / 3600000))}:${p(Math.floor(ms / 60000) % 60)}:${p(Math.floor(ms / 1000) % 60)},${p(ms % 1000, 3)}`;
+};
+function srt(palavras, { max = 3 } = {}) {
+    if (!Array.isArray(palavras) || !palavras.length) return '';
+    // agrupamento próprio (a legenda do vídeo junta frases inteiras; o .srt das redes quebra em trechos curtos de até `max` palavras)
+    const chunks = [];
+    palavras.forEach((p, i) => {
+        const prev = palavras[i - 1], atual = chunks[chunks.length - 1];
+        if (!atual || !prev || atual.palavras.length >= max || /[.!?;:]$/.test(prev.w) || p.t - prev.t2 > 0.25) chunks.push({ t: p.t, t2: p.t2, palavras: [p] });
+        else { atual.palavras.push(p); atual.t2 = p.t2; }
+    });
+    return chunks.map((c, i) => {
+        const fim = Math.max(c.t2, c.t + 0.4);
+        return `${i + 1}\n${tempoSrt(c.t)} --> ${tempoSrt(fim)}\n${c.palavras.map((p) => String(p.w).replace(/\*/g, '')).join(' ')}\n`;
+    }).join('\n');
+}
+
+// ── os créditos que exigem atribuição (CC BY, BY-SA...) ──────────────────
+function fichaDe(arq) {
+    if (!arq) return null;
+    for (const f of [arq.replace(/\.[a-z0-9]+$/i, '') + '.licenca.json', arq + '.licenca.json']) {
+        try { return JSON.parse(fs.readFileSync(f, 'utf8')); } catch { /* próxima */ }
+    }
+    return null;
+}
+const exigeCredito = (lic) => /^(cc[- ]?by|by)/i.test(String(lic || '').trim()) && !/^(cc0|zero)/i.test(String(lic || ''));
+function creditosDe(trilha, sfx = []) {
+    const out = [];
+    const fichaT = trilha && fichaDe(trilha.arquivo);
+    if (trilha && trilha.creditos && !(fichaT && !exigeCredito(fichaT.licenca) && !/by/i.test(String(trilha.creditos)))) out.push(`Trilha: ${typeof trilha.creditos === 'string' ? trilha.creditos : (trilha.titulo || '') + (trilha.autor ? ' — ' + trilha.autor : '')}`);
+    else if (fichaT && exigeCredito(fichaT.licenca)) out.push(`Trilha: "${fichaT.titulo}"${fichaT.autor ? ' — ' + fichaT.autor : ''} (${String(fichaT.licenca).toUpperCase()}${fichaT.origem ? ', ' + fichaT.origem : ''})`);
+    const vistos = new Set();
+    for (const arq of sfx) {
+        const f = fichaDe(arq);
+        if (!f || !exigeCredito(f.licenca)) continue;
+        const l = `SFX: "${f.titulo}"${f.autor ? ' — ' + f.autor : ''} (${String(f.licenca).toUpperCase()}${f.origem ? ', ' + f.origem : ''})`;
+        if (!vistos.has(l)) { vistos.add(l); out.push(l); }
+    }
+    return out;
+}
+
+// ── o texto do post ──────────────────────────────────────────────────────
+const limpo = (s) => String(s || '').replace(/\*/g, '').replace(/\s+/g, ' ').trim();
+function hashtags(assunto, n = 5) {
+    const norm = (s) => s.normalize('NFD').replace(/[̀-ͯ]/g, '').toLowerCase().replace(/[^a-z0-9]/g, '');
+    const tags = [];
+    for (const w of limpo(assunto).split(/\s+/)) { const t = norm(w); if (t.length >= 4 && !PARADAS.has(t) && !tags.includes(t)) tags.push(t); }
+    for (const t of ['motion', 'video', 'reels', 'design', 'criatividade']) if (!tags.includes(t)) tags.push(t);
+    return tags.slice(0, n).map((t) => '#' + t);
+}
+function postTxt({ assunto, cenas = [], creditos = [] } = {}) {
+    const txt = (c) => limpo(c.titulo || c.texto || c.fala || '');
+    const gancho = cenas.find((c) => c.papel === 'gancho') || cenas[0] || {};
+    const cta = [...cenas].reverse().find((c) => c.papel === 'cta') || null;
+    const meio = cenas.filter((c) => c !== gancho && c !== cta).map(txt).filter(Boolean);
+    const linhas = meio.slice(0, 3);
+    while (linhas.length < 3) linhas.push(['Feito em motion, do roteiro ao corte.', 'Cada cena no tempo da batida.', 'Salve pra rever depois.'][linhas.length]);
+    const chamada = cta ? limpo(cta.botao || cta.titulo || cta.texto) : '';
+    const partes = [txt(gancho) || limpo(assunto), '', ...linhas.map((l) => '• ' + l), '', chamada ? `${chamada} 👇` : 'Curtiu? Salva e manda pra quem precisa.', '', hashtags(assunto).join(' ')];
+    if (creditos.length) partes.push('', 'Créditos:', ...creditos);
+    return partes.join('\n') + '\n';
+}
+
+// ── as versões de formato (fundo desfocado + vídeo centralizado) ─────────
+function recompor(video, saida, [W, H]) {
+    const vf = `split[a][b];[a]scale=${W}:${H}:force_original_aspect_ratio=increase,crop=${W}:${H},boxblur=30:5[bg];[b]scale=${W}:${H}:force_original_aspect_ratio=decrease[fg];[bg][fg]overlay=(W-w)/2:(H-h)/2,setsar=1,format=yuv420p`;
+    const r = ff(['-i', video, '-vf', vf, '-c:v', 'libx264', '-preset', 'veryfast', '-crf', '20', '-c:a', 'copy', '-movflags', '+faststart', saida]);
+    return r.status === 0 && fs.existsSync(saida);
+}
+
+// ── a capa: o quadro de maior contraste, com título (meio de cada cena) ──
+function capa(video, saida, { cenas = [], dur } = {}) {
+    const layout = require('./maquina-layout.js');
+    const total = dur || (sondar(video) || {}).dur || 0;
+    let t = 0;
+    const tempos = cenas.length ? cenas.map((c) => { const x = t + (c.dur || 1) * 0.6; t += c.dur || 1; return x; }) : [0.2, 0.4, 0.6, 0.8].map((k) => k * total);
+    const tmp = fs.mkdtempSync(path.join(os.tmpdir(), 'capa-'));
+    let melhor = null;
+    try {
+        tempos.filter((x) => x < total).forEach((x, i) => {
+            const png = path.join(tmp, `q${i}.png`);
+            if (ff(['-ss', x.toFixed(2), '-i', video, '-frames:v', '1', png]).status !== 0 || !fs.existsSync(png)) return;
+            let m; try { m = layout.medirQuadro(png); } catch { m = null; }
+            if (!m) return;
+            const pontos = m.contraste + Math.min(m.variancia, 60) / 30 - (i === 0 ? 0.3 : 0);   // título legível + algo na tela
+            if (!melhor || pontos > melhor.pontos) melhor = { png, pontos, t: x };
+        });
+        if (!melhor) return null;
+        const r = ff(['-i', melhor.png, '-vf', 'scale=1080:-2', '-q:v', '2', saida]);
+        return r.status === 0 && fs.existsSync(saida) ? { arquivo: saida, t: melhor.t } : null;
+    } finally { fs.rmSync(tmp, { recursive: true, force: true }); }
+}
+
+// ── o pacote ─────────────────────────────────────────────────────────────
+function exportar(o = {}) {
+    const { video, pasta, assunto = '', formatos = [], cenas = [], palavras = [], trilha = null, sfx = [] } = o;
+    if (!video || !fs.existsSync(video)) return { ok: false, error: 'sem vídeo para exportar.' };
+    const dir = path.join(pasta || path.dirname(video), 'entrega');
+    fs.mkdirSync(dir, { recursive: true });
+    const arquivos = [], avisos = [];
+    const final = path.join(dir, 'video.mp4');
+    fs.copyFileSync(video, final); arquivos.push(final);
+    const info = sondar(video);
+    for (const f of [...new Set(formatos || [])]) {
+        if (!DIMS[f]) { avisos.push(`formato desconhecido: ${f}`); continue; }
+        const s = path.join(dir, `video-${f.replace(':', 'x')}.mp4`);
+        if (recompor(video, s, DIMS[f])) arquivos.push(s); else avisos.push(`não consegui gerar o ${f}`);
+    }
+    const legenda = srt(palavras);
+    if (legenda) { const s = path.join(dir, 'legenda.srt'); fs.writeFileSync(s, legenda); arquivos.push(s); }
+    const c = capa(video, path.join(dir, 'capa.jpg'), { cenas, dur: info && info.dur });
+    if (c) arquivos.push(c.arquivo); else avisos.push('a capa não saiu');
+    const creditos = creditosDe(trilha, sfx);
+    const post = path.join(dir, 'post.txt');
+    fs.writeFileSync(post, postTxt({ assunto, cenas, creditos })); arquivos.push(post);
+    return { ok: true, dir, arquivos, creditos, ...(avisos.length ? { avisos } : {}) };
+}
+
+// ── a galeria: ~/.primocode/studio/videos.json ───────────────────────────
+function ler(arq = ARQ_GALERIA()) { try { const j = JSON.parse(fs.readFileSync(arq, 'utf8')); return Array.isArray(j) ? j : []; } catch { return []; } }
+function registrar({ id, assunto, caminho, formato, duracao, assinatura, entrega }, arq = ARQ_GALERIA()) {
+    const l = ler(arq).filter((v) => v.caminho !== caminho);
+    const item = { id: id || path.basename(path.dirname(caminho)), assunto: limpo(assunto), data: new Date().toISOString(), caminho, formato, duracao, assinatura: assinatura || null, entrega: entrega || null };
+    l.push(item);
+    try { fs.mkdirSync(path.dirname(arq), { recursive: true }); fs.writeFileSync(arq, JSON.stringify(l.slice(-200), null, 2)); } catch { /* sem disco: segue */ }
+    return item;
+}
+const listar = (arq) => ler(arq).filter((v) => v.caminho && fs.existsSync(v.caminho)).sort((a, b) => String(b.data).localeCompare(String(a.data)));
+function abrirNoSistema(alvo) {
+    const cmd = process.platform === 'darwin' ? 'open' : process.platform === 'win32' ? 'cmd' : 'xdg-open';
+    const args = process.platform === 'win32' ? ['/c', 'start', '""', alvo] : [alvo];
+    return spawnSync(cmd, args, { stdio: 'ignore' }).status === 0;
+}
+const mmss = (s) => `${Math.floor(s / 60)}:${String(Math.round(s % 60)).padStart(2, '0')}`;
+function formatarLista(l) {
+    if (!l.length) return '  Nenhum vídeo ainda. Peça um ao estúdio de motion.';
+    return ['', ...l.map((v, i) => `  ${String(i + 1).padStart(2)}. ${limpo(v.assunto).slice(0, 44).padEnd(44)} ${String(v.formato || '').padEnd(5)} ${mmss(v.duracao || 0).padStart(5)}  ${String(v.data).slice(0, 10)}`), '', '  primocode videos abrir <n> · primocode videos pasta <n>'].join('\n');
+}
+/** `primocode videos [abrir|pasta <n>]` e /videos. Devolve o texto; `abrir` é injetável nos testes. */
+function main(args = [], { arq, abrir = abrirNoSistema } = {}) {
+    const l = listar(arq);
+    const [acao, n] = args;
+    if (acao === 'abrir' || acao === 'pasta') {
+        const v = l[parseInt(n, 10) - 1];
+        if (!v) return { ok: false, texto: `  Não achei o vídeo ${n || ''}. Veja a lista com: primocode videos` };
+        const alvo = acao === 'abrir' ? v.caminho : (v.entrega || path.dirname(v.caminho));
+        return { ok: abrir(alvo), alvo, texto: `  Abrindo ${alvo}` };
+    }
+    return { ok: true, texto: formatarLista(l) };
+}
+
+module.exports = { exportar, srt, postTxt, creditosDe, hashtags, capa, recompor, registrar, listar, ler, main, formatarLista, DIMS };

package/lib/estudio/index.js

@@ -48,6 +48,7 @@ const video = require('./video.js');
 const batida = require('./batida.js');
 const revisor = require('./revisor.js');
 const marcaLib = require('./marca.js');
+const marcaKit = require('../marca-kit.js');
 const conferencia = require('./conferencia.js');
 const margem = require('./margem.js');
 const assinatura = require('./assinatura.js');
@@ -362,7 +363,7 @@ async function roteiroDoServidor(p, args) {
         estilo: args.estilo || (escolherEstilo({ pedido }) === 'impacto' ? 'impacto' : undefined),
     }, cfg.token);
     if (!r || !r.ok) return { ok: false, error: (r && r.erro) || 'o roteirista não respondeu.' };
-    return { ok: true, roteiro: { ...r.roteiro, marca: (args.roteiro && args.roteiro.marca) || p.marca || undefined } };
+    return { ok: true, roteiro: { ...r.roteiro, marca: marcaKit.preencher((args.roteiro && args.roteiro.marca) || p.marca || undefined, { pastas: [p.pasta, process.cwd()] }) } };
 }
 
 async function ferramentaPlano(args) {
@@ -506,6 +507,9 @@ async function ferramentaMidia(args) {
     const p = args.id ? projeto.ler(args.id) : null;
     if (args.id && !p) return semProjeto(args.id);
 
+    if (acao === 'projetos') return require('./projetos.js').procurar({ termo: args.termo, categoria: args.categoria, limite: args.limite });
+    if (acao === 'projeto') return require('./projetos.js').ver(args.nome || args.id_item || args.termo, { c: await require('../limites.js').situacao() });
+
     if (acao === 'fontes') {
         if (args.conferir) return assets.conferirFonte(args.conferir);
         return { ok: true, fontes: assets.FONTES, biblioteca: biblioteca.cardapio(),
@@ -663,6 +667,88 @@ async function baixarEscolhido(lista, args, p) {
         comoUsar: r.ok ? `no plano: "src": "${r.relativo}"` : undefined };
 }
 
+// ── estudio_ae ───────────────────────────────────────────────────────────
+
+/** O motor After Effects: roda o JSX do agente na pasta do projeto e devolve o mp4 e os quadros. */
+async function ferramentaAE(args) {
+    const p = args.id ? projeto.ler(args.id) : null;
+    if (!args.id || !p) return semProjeto(args.id);
+    if (!args.script || !args.comp) return { ok: false, error: 'estudio_ae pede script (o JSX) e comp (o nome da composição).' };
+    return require('./cota.js').comCota(() => renderAE(args, p));
+}
+
+async function renderAE(args, p) {
+    const kitM = marcaKit.preencher(null, { pastas: [p.pasta, process.cwd()] });
+    const fontesKit = kitM && kitM.kit ? [kitM.fontes && kitM.fontes.titulo, kitM.fontes && kitM.fontes.texto].filter(Boolean) : [];
+    const r = await require('./effectcraft.js').renderizar({
+        pasta: p.pasta, script: String(args.script), comp: String(args.comp),
+        fontes: [...new Set([...(Array.isArray(args.fontes) ? args.fontes : []), ...fontesKit])], audio: args.audio || undefined,
+        conferir: Array.isArray(args.conferir) ? args.conferir : [],
+    });
+    if (!r.ok) return r;
+    const daMarca = kitM && kitM.kit ? { marca: { nome: kitM.nome, cores: kitM.cores, fontes: kitM.fontes, logo: kitM.logo } } : {};
+    return { ...r, ...daMarca, nota: 'Olhe os quadros (arquivos em ae/) antes de dar por pronto; ajuste o JSX e rode de novo se algo estiver torto.' };
+}
+
+// ── estudio_motion ───────────────────────────────────────────────────────
+
+/** O pacote pra postar (exportar.js) + a galeria; nunca derruba o vídeo. `entrega:false` desliga. */
+function entregar(args, p, r) {
+    const x = r._exportar || {}; delete r._exportar;
+    if (args.entrega === false) return;
+    try {
+        const E = require('./exportar.js');
+        const e = E.exportar({ video: r.video, pasta: p.pasta, assunto: args.assunto, formatos: args.formatos, cenas: x.cenas, palavras: x.palavras, trilha: r.trilha && { ...r.trilha, arquivo: x.trilhaArquivo }, sfx: x.sfx });
+        if (e.ok) {
+            r.entrega = { pasta: e.dir, arquivos: e.arquivos.map((f) => path.basename(f)), creditos: e.creditos, ...(e.avisos ? { avisos: e.avisos } : {}) };
+            E.registrar({ id: p.id, assunto: args.assunto, caminho: r.video, formato: r.formato, duracao: r.duracao, assinatura: r.assinatura, entrega: e.dir });
+        } else r.entrega = { erro: e.error };
+    } catch (err) { r.entrega = { erro: err.message }; }
+}
+
+/** A máquina de motion: assunto + cenas em JSON viram o mp4 (maquina.js), com sons, trilha e voz opcionais. */
+async function ferramentaMotion(args) {
+    const p = args.id ? projeto.ler(args.id) : null;
+    if (!args.id || !p) return semProjeto(args.id);
+    let receita = null;
+    if (args.receita) {
+        const r = require('./projetos.js').ver(args.receita, { c: await require('../limites.js').situacao() });
+        if (!r.ok) return r;
+        // Grátis vê o resumo da receita, não monta a partir dela: diz o porquê em vez de renderizar pela metade.
+        if (r.bloqueado) return { ok: false, error: r.aviso, projeto: r.projeto };
+        receita = r.projeto;
+    }
+    return require('./cota.js').comCota(() => renderMotion(args, p, receita));
+}
+
+async function renderMotion(args, p, receita) {
+    const narrar = async (texto, mp3, voz) => rodarPython('narrar.py', ['falar', '--texto', texto, '--saida', mp3, '--voz', String(voz || 'francisca')], { timeout: 5 * 60000 });
+    // Kit de marca ativo: cores, fontes e logo entram onde o JSON não disse; o logo vai no CTA (última cena).
+    const kitM = marcaKit.preencher(args.marca, { pastas: [p.pasta, process.cwd()] });
+    if (kitM && kitM.kit) {
+        args = { ...args, marca: kitM };
+        if (kitM.logo && Array.isArray(args.cenas) && args.cenas.length) {
+            args.cenas = args.cenas.map((c, i) => (i === args.cenas.length - 1 && c && !c.logo ? { ...c, logo: kitM.logo } : c));
+        }
+    }
+    const r = await require('./maquina.js').motion(args, { pasta: p.pasta, receita, deps: { narrar } });
+    if (r.ok) projeto.anotar(p.id, 'motion', `${r.duracao}s, ${r.cenas.length} cenas, ${r.lufs} LUFS`);
+    if (r.ok) entregar(args, p, r);
+    return r.ok ? { ...r, nota: 'Abra os quadros (png em ae/) para conferir. Se algo ficou torto, mude o JSON e rode de novo.' } : r;
+}
+
+// ── estudio_editar ───────────────────────────────────────────────────────
+
+/** O editor por comando: reabre o plano da máquina de motion, aplica as mudanças e guarda a versão (editor.js). */
+async function ferramentaEditar(args) {
+    const id = args.id_video || args.id;
+    const p = id ? projeto.ler(id) : null;
+    if (!p) return semProjeto(id);
+    const r = await require('./editor.js').editar(args, { pasta: p.pasta });
+    if (r.ok && r.versao && !args.listar) projeto.anotar(p.id, 'editar', `v${r.versao}: ${(r.feitas || [r.nota || '']).join('; ').slice(0, 120)}`);
+    return r.ok && r.video ? { ...r, nota: r.nota || 'Mostre o vídeo. Se não era isso, mude de novo ou use voltar_para.' } : r;
+}
+
 // ── estudio_narrar ───────────────────────────────────────────────────────
 
 async function ferramentaNarrar(args) {
@@ -1120,6 +1206,11 @@ function vazamentoNoComeco(lista, palavras, direcao = '') {
 }
 
 async function narrarComGemini(lista, mp3, { voz, direcao } = {}) {
+    /* A narração premium é do Pro em diante (lib/limites.js). Sem ela a corrente
+       segue para a voz local (Kokoro/Edge) e o aviso explica o porquê. */
+    const lim = require('../limites.js');
+    const prem = await lim.exigir('narracaoPremium');
+    if (!prem.ok) { lim.avisar(prem.error + ' A narração saiu com a voz local.'); return { ok: false, error: prem.error }; }
     try {
         const cfg = require('../config').loadConfig();
         const api = require('../api');
@@ -1490,6 +1581,10 @@ async function prepararRoteiro(p, args) {
     const novas = referencias.imagens().filter((f) => !jaTem.has(f));
     for (const f of novas) { try { importarReferencia(p, f); } catch (e) { projeto.anotar(p.id, 'referencia', `não importou ${path.basename(f)}: ${e.message}`); } }
     if (novas.length) p = projeto.ler(p.id) || p;
+    /* O KIT DE MARCA ativo (lib/marca-kit.js) vale mais que a marca lida do
+       site: a pessoa criou uma vez e quer em todo vídeo. O roteiro ainda ganha. */
+    const kitM = marcaKit.preencher({}, { pastas: [p.pasta, process.cwd()] });
+    if (kitM.kit) { p = { ...p, marca: kitM }; }
     if (roteiro.marca) {
         /* A do roteiro por cima da do site, CAMPO A CAMPO: antes o "cores" em
            lista do agente apagava o {fundo, destaque} lido do site (13/10). */
@@ -2600,7 +2695,7 @@ async function ferramentaSite(args) {
 
 module.exports = { proporcaoDoPedido,
     vazamentoNoComeco, variarIcones, objetosDoRoteiro,
-    ferramentaProjeto, ferramentaPlano, ferramentaMidia, ferramentaNarrar,
+    ferramentaProjeto, ferramentaPlano, ferramentaMidia, ferramentaAE, ferramentaMotion, ferramentaEditar, ferramentaNarrar,
     ferramentaVideo, ferramentaRender, ferramentaSite,
     projeto, plano, remotion, assets, video, identidade, slides, python, rodarPython, alinharPartes, prepararRoteiro, roteiroValido, juntarVozes,
 };