primocode 8.42.2 → 9.1.0

package/lib/estudio/index.js

@@ -0,0 +1,565 @@
+/**
+ * estudio/index.js — as ferramentas do Studio, do jeito que o agente as vê.
+ *
+ * ── O QUE ESTE ARQUIVO SUBSTITUI ─────────────────────────────────────────
+ * `lib/studio.js`, 887 linhas cuja maior parte era ligar, manter de pé e
+ * conversar por HTTP com um servidor Python que desenhava páginas — e mais o
+ * cuidado de abrir uma aba no navegador da pessoa no momento certo, e de não
+ * abrir três.
+ *
+ * Nada disso existe mais. Cada peça é uma PASTA, cada render é o Remotion, e
+ * a única coisa que abre no fim é o vídeo pronto.
+ *
+ * ── AS SETE FERRAMENTAS, E POR QUE SÃO SETE ──────────────────────────────
+ *   estudio_projeto    abrir, achar, listar, lembrar
+ *   estudio_plano      escrever ou ajustar o que o vídeo é
+ *   estudio_midia      procurar e baixar imagem, som, ícone, fonte
+ *   estudio_narrar     a voz, com os tempos medidos
+ *   estudio_video      o que se faz com a gravação: medir, cortar, legendar
+ *   estudio_render     virar arquivo
+ *   estudio_site       ler a identidade de uma marca a partir do link
+ *
+ * A tentação era uma ferramenta por verbo (criar cena, mover elemento, trocar
+ * cor). Isso multiplicaria o catálogo por dez e, pior, faria o modelo montar
+ * o vídeo por ajustes — que é exatamente como se produz vídeo genérico. O
+ * plano inteiro de uma vez obriga a decidir o vídeo inteiro de uma vez.
+ */
+
+'use strict';
+
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+const { spawn } = require('child_process');
+
+const projeto = require('./projeto.js');
+const acervo = require('../acervo.js');
+const plano = require('./plano.js');
+const remotion = require('./remotion.js');
+const assets = require('./assets.js');
+const video = require('./video.js');
+const identidade = require('./identidade.js');
+const slides = require('./slides.js');
+
+const PY = path.join(__dirname, '..', '..', 'studio');
+
+/** Qual python desta máquina. O mesmo problema do Studio antigo, mesma cura. */
+function python() {
+    const { execSync } = require('child_process');
+    const nomes = process.platform === 'win32'
+        ? ['python', 'py', 'python3']
+        : ['python3', 'python', '/opt/homebrew/bin/python3', '/usr/local/bin/python3', '/usr/bin/python3'];
+    for (const n of nomes) {
+        try {
+            const v = execSync(`${n} --version`, { stdio: ['ignore', 'pipe', 'pipe'], timeout: 5000 }).toString();
+            if (/Python 3/.test(v)) return n;
+        } catch { /* próximo */ }
+    }
+    return null;
+}
+
+function rodarPython(script, args, { timeout = 20 * 60000 } = {}) {
+    return new Promise((resolve) => {
+        const py = python();
+        if (!py) {
+            return resolve({ ok: false, error: 'não achei o Python 3 nesta máquina.',
+                comoResolver: 'instale o Python 3 (python.org) e tente de novo' });
+        }
+        const p = spawn(py, [path.join(PY, script), ...args]);
+        let saida = '', erro = '';
+        p.stdout.on('data', (d) => { saida += d.toString(); });
+        p.stderr.on('data', (d) => { erro += d.toString(); });
+        const relogio = setTimeout(() => { try { p.kill(); } catch {} }, timeout);
+        p.on('close', () => {
+            clearTimeout(relogio);
+            try { resolve(JSON.parse(saida.trim().split('\n').pop())); }
+            catch { resolve({ ok: false, error: (erro || saida).slice(-400).trim() || 'o script não respondeu' }); }
+        });
+        p.on('error', (e) => { clearTimeout(relogio); resolve({ ok: false, error: e.message }); });
+    });
+}
+
+// ── estudio_projeto ──────────────────────────────────────────────────────
+
+async function ferramentaProjeto(args) {
+    const acao = String(args.acao || 'listar').toLowerCase();
+
+    if (acao === 'criar' || acao === 'novo') {
+        const r = projeto.criar({
+            titulo: args.titulo, pedido: args.pedido || args.titulo, formato: args.formato || 'video',
+        });
+        return { ...r, comoUsar: 'agora escreva o plano com estudio_plano, usando este id.' };
+    }
+
+    if (acao === 'abrir' || acao === 'ler') {
+        const p = projeto.ler(args.id);
+        if (!p) return { ok: false, error: `não achei o projeto "${args.id}". Use acao:"procurar".` };
+        const pl = projeto.lerPlano(args.id);
+        return {
+            ok: true, projeto: p,
+            // O caderno é o que faz "mexe naquela parte" funcionar semanas
+            // depois: sem ele, reabrir diz o que existe e nunca por quê.
+            caderno: projeto.caderno(args.id, { ultimas: 25 }),
+            plano: pl ? plano.resumo(pl) : 'ainda não há plano',
+            versoes: projeto.versoes(args.id),
+            arquivos: listarArquivos(p.pasta),
+        };
+    }
+
+    if (acao === 'procurar' || acao === 'achar') {
+        const achados = projeto.procurar(args.texto || args.titulo || '');
+        if (!achados.length) return { ok: true, achados: [], aviso: 'nenhum projeto parecido.' };
+        return {
+            ok: true,
+            achados: achados.map((p) => ({ id: p.id, titulo: p.titulo, criado: p.criado.slice(0, 10), pedido: p.pedido.slice(0, 120) })),
+        };
+    }
+
+    if (acao === 'anotar') {
+        projeto.anotar(args.id, args.tipo || 'nota', args.texto || '');
+        return { ok: true };
+    }
+
+    const todos = projeto.listar({ limite: Number(args.limite) || 20 });
+    return {
+        ok: true,
+        projetos: todos.map((p) => ({ id: p.id, titulo: p.titulo, criado: p.criado.slice(0, 10), renders: (p.renders || []).length })),
+    };
+}
+
+function listarArquivos(pasta) {
+    const saida = {};
+    for (const sub of ['entrada', 'midia', 'saida']) {
+        try {
+            saida[sub] = fs.readdirSync(path.join(pasta, sub))
+                .filter((f) => !f.endsWith('.licenca.json')).slice(0, 40);
+        } catch { saida[sub] = []; }
+    }
+    return saida;
+}
+
+// ── estudio_plano ────────────────────────────────────────────────────────
+
+async function ferramentaPlano(args) {
+    const p = projeto.ler(args.id);
+    if (!p) return { ok: false, error: `não achei o projeto "${args.id}".` };
+
+    if (args.voltarPara) return projeto.voltarPara(args.id, args.voltarPara);
+
+    if (!args.plano && !args.cenas) {
+        const atual = projeto.lerPlano(args.id);
+        if (!atual) return { ok: false, error: 'este projeto ainda não tem plano — mande um.' };
+        return { ok: true, plano: atual, resumo: plano.resumo(atual) };
+    }
+
+    // Um plano inteiro, ou só as cenas (que é o caso comum).
+    let novo = args.plano || { formato: args.formato, cenas: args.cenas, audio: args.audio };
+
+    /* Ajuste de UMA cena, sem reescrever o resto.
+     *
+     * É o caminho de "não gostei da parte do cartão": reescrever o plano
+     * inteiro para mexer numa cena é como o vídeo antigo mudava de cara
+     * sozinho a cada correção. */
+    if (args.cena != null) {
+        const atual = projeto.lerPlano(args.id);
+        if (!atual) return { ok: false, error: 'não há plano para ajustar.' };
+        const i = Number(args.cena) - 1;
+        if (!(i >= 0 && i < atual.cenas.length)) {
+            return { ok: false, error: `a cena ${args.cena} não existe (são ${atual.cenas.length}).` };
+        }
+        atual.cenas[i] = args.plano || args.novaCena || atual.cenas[i];
+        novo = atual;
+    }
+
+    const conferida = plano.conferir(novo, { pasta: p.pasta });
+    if (!conferida.ok) {
+        return {
+            ok: false,
+            error: 'o plano tem problemas que quebrariam o render — conserte e mande de novo.',
+            problemas: conferida.problemas.slice(0, 12),
+        };
+    }
+
+    projeto.salvarPlano(args.id, novo, args.motivo || '');
+    projeto.salvar(args.id, { duracao: conferida.duracao });
+    return {
+        ok: true, duracao: conferida.duracao, resumo: plano.resumo(novo),
+        proximo: 'estudio_render quando estiver pronto.',
+    };
+}
+
+// ── estudio_midia ────────────────────────────────────────────────────────
+
+async function ferramentaMidia(args) {
+    const acao = String(args.acao || 'imagem').toLowerCase();
+    const p = args.id ? projeto.ler(args.id) : null;
+    if (args.id && !p) return { ok: false, error: `não achei o projeto "${args.id}".` };
+
+    if (acao === 'fontes') {
+        if (args.conferir) return assets.conferirFonte(args.conferir);
+        return { ok: true, fontes: assets.FONTES,
+            nota: 'qualquer família do Google Fonts funciona — esta lista é para não repetir sempre as mesmas.' };
+    }
+
+    /* Recortar o fundo. O pedido pede "buscar PNGs na internet, remover fundo
+       e inserir" — e sem isto o agente colava a foto com o retângulo branco
+       dela por cima do fundo da cena, que é o cara-de-recorte que denuncia
+       vídeo feito às pressas. O recorte real é modelo de segmentação (rembg);
+       sem ele na máquina, sobra o corte por cor, que só serve em fundo
+       chapado — e a resposta diz qual dos dois foi usado. */
+    if (acao === 'semfundo' || acao === 'sem-fundo' || acao === 'recortar') {
+        const alvo = args.arquivo || args.src;
+        if (!alvo) return { ok: false, error: 'diga o arquivo (arquivo) da imagem a recortar.' };
+        const cheio = p ? path.resolve(p.pasta, alvo) : path.resolve(alvo);
+        const r = await acervo.tirarFundo(cheio, { cor: args.cor, tolerancia: args.tolerancia });
+        if (!r.ok) return r;
+        const relativo = p ? path.relative(p.pasta, r.arquivo).replace(/\\/g, '/') : r.arquivo;
+        if (p) projeto.anotar(p.id, 'midia', `recortou o fundo de ${alvo} (${r.metodo})`);
+        return { ok: true, src: relativo, metodo: r.metodo, aviso: r.aviso || undefined };
+    }
+
+    if (acao === 'logo') {
+        if (!p) return { ok: false, error: 'para baixar a logo é preciso dizer em qual projeto (id).' };
+        const nome = String(args.marca || args.nome || args.termo || '').trim();
+        if (!nome) return { ok: false, error: 'diga a marca (marca).' };
+        let html = '';
+        let site = String(args.site || args.url || '').trim();
+        if (!site) {
+            const achado = await identidade.acharSite(nome);
+            if (achado.ok) site = achado.url;
+        }
+        if (site) {
+            if (!/^https?:\/\//i.test(site)) site = 'https://' + site;
+            html = (await require('../referencia.js').pegar(site, { timeout: 15000 })) || '';
+        }
+        const r = await identidade.pegarLogo(html, site || 'https://exemplo.invalido', { pasta: p.pasta, nome });
+        if (r.ok) projeto.anotar(p.id, 'midia', `logo de ${nome}: ${r.src} (${r.achadaEm})`);
+        return r;
+    }
+
+    if (acao === 'icones' || acao === 'icone') {
+        if (args.nome) {
+            const r = await assets.icone(args.nome, { pasta: p ? p.pasta : null });
+            return r.ok ? { ok: true, nome: args.nome, baixado: true } : r;
+        }
+        return assets.procurarIcones(args.termo || args.busca || '');
+    }
+
+    if (acao === 'som' || acao === 'audio' || acao === 'trilha' || acao === 'efeito') {
+        const busca = await assets.procurarSom(args.termo || '', {
+            quantas: Number(args.quantas) || 8,
+            duracaoMin: acao === 'trilha' ? 30 : 0,
+            duracaoMax: acao === 'efeito' ? 6 : 0,
+        });
+        if (!busca.ok || !args.baixar) return busca;
+        return baixarEscolhido(busca.sons, args, p);
+    }
+
+    const busca = await assets.procurarImagens(args.termo || '', {
+        quantas: Number(args.quantas) || 8,
+        transparente: !!args.transparente,
+    });
+    if (!busca.ok || !args.baixar) return busca;
+    return baixarEscolhido(busca.imagens, args, p);
+}
+
+async function baixarEscolhido(lista, args, p) {
+    if (!p) return { ok: false, error: 'para baixar é preciso dizer em qual projeto (id).' };
+    const i = Number(args.baixar) === true ? 0 : Math.max(0, Number(args.baixar) - 1 || 0);
+    const item = lista[i];
+    if (!item) return { ok: false, error: `não há o item ${args.baixar} nessa busca.` };
+    const r = await assets.baixar(item, { pasta: p.pasta, nome: args.nome });
+    if (r.ok) {
+        projeto.anotar(p.id, 'midia', `baixou "${item.titulo}" (${item.licenca || 'sem licença declarada'})`);
+    }
+    return { ...r, creditos: item.creditos || null,
+        comoUsar: r.ok ? `no plano: "src": "${r.relativo}"` : undefined };
+}
+
+// ── estudio_narrar ───────────────────────────────────────────────────────
+
+async function ferramentaNarrar(args) {
+    if (args.vozes) return rodarPython('narrar.py', ['vozes'], { timeout: 30000 });
+
+    const p = projeto.ler(args.id);
+    if (!p) return { ok: false, error: `não achei o projeto "${args.id}".` };
+    const texto = String(args.texto || '').trim();
+    if (!texto) return { ok: false, error: 'não há texto para narrar.' };
+
+    const saida = path.join(p.pasta, 'midia', `narracao-${Date.now().toString(36)}.mp3`);
+    fs.mkdirSync(path.dirname(saida), { recursive: true });
+
+    const r = await rodarPython('narrar.py', [
+        'falar', '--texto', texto, '--saida', saida,
+        '--voz', String(args.voz || 'antonio'),
+        '--estilo', String(args.estilo || 'normal'),
+        ...(args.ritmo ? ['--ritmo', String(args.ritmo)] : []),
+        ...(args.tom ? ['--tom', String(args.tom)] : []),
+    ], { timeout: 5 * 60000 });
+
+    if (!r.ok) return r;
+    const relativo = path.relative(p.pasta, saida).replace(/\\/g, '/');
+    projeto.anotar(p.id, 'narracao', `${r.segundos}s na voz ${args.voz || 'antonio'}`);
+    return {
+        ...r, relativo,
+        comoUsar: `no plano: "audio": {"narracao": "${relativo}"}. `
+            + 'Os tempos de "falas" são MEDIDOS — use-os para a duração de cada cena e para as legendas, '
+            + 'em vez de estimar por número de palavras.',
+    };
+}
+
+// ── estudio_video ────────────────────────────────────────────────────────
+
+async function ferramentaVideo(args, ctx = {}) {
+    const acao = String(args.acao || 'medir').toLowerCase();
+    const p = projeto.ler(args.id);
+    if (!p) return { ok: false, error: `não achei o projeto "${args.id}".` };
+
+    const pronto = video.conferir();
+    if (!pronto.ok) return pronto;
+
+    const dentro = (rel) => {
+        const cheio = path.resolve(p.pasta, String(rel || ''));
+        return cheio.startsWith(path.resolve(p.pasta)) ? cheio : null;
+    };
+
+    if (acao === 'importar') {
+        // O vídeo da pessoa entra na pasta do projeto. Trabalhar a partir de
+        // onde ele está é o caminho para o agente escrever em cima do
+        // original — e o original dela não tem cópia.
+        const de = path.resolve(String(args.arquivo || '').replace(/^~(?=$|[/\\])/, os.homedir()));
+        if (!fs.existsSync(de)) return { ok: false, error: `não achei "${args.arquivo}".` };
+        const para = path.join(p.pasta, 'entrada', path.basename(de));
+        fs.copyFileSync(de, para);
+        const m = await video.medir(para);
+        projeto.anotar(p.id, 'entrada', `importou ${path.basename(de)} (${m.ok ? m.segundos + 's' : '?'})`);
+        return { ok: true, arquivo: path.relative(p.pasta, para).replace(/\\/g, '/'), medida: m };
+    }
+
+    const alvo = dentro(args.arquivo);
+    if (!alvo || !fs.existsSync(alvo)) {
+        return { ok: false, error: `"${args.arquivo}" não está na pasta do projeto. Use acao:"importar" antes.` };
+    }
+
+    if (acao === 'medir') return video.medir(alvo);
+
+    if (acao === 'silencio' || acao === 'pausas') {
+        const s = await video.silencios(alvo, { limiarDb: Number(args.limiarDb) || -40 });
+        if (!s.ok) return s;
+        const m = await video.medir(alvo);
+        return {
+            ok: true, silencios: s.silencios,
+            ficariam: video.trechosQueFicam(m.segundos, s.silencios, args),
+        };
+    }
+
+    if (acao === 'cortar-silencio' || acao === 'cortar') {
+        const saida = path.join(p.pasta, 'midia', `cortado-${Date.now().toString(36)}.mp4`);
+        const r = await video.cortarSilencio(alvo, saida, args);
+        if (r.ok && !r.semCorte) {
+            projeto.anotar(p.id, 'corte', `${r.antes}s → ${r.depois}s, ${r.cortes} cortes`);
+            r.relativo = path.relative(p.pasta, saida).replace(/\\/g, '/');
+        }
+        return r;
+    }
+
+    if (acao === 'quadro') {
+        const saida = path.join(p.pasta, 'midia', `quadro-${Math.round(Number(args.segundo) || 0)}s.png`);
+        const r = await video.quadro(alvo, saida, Number(args.segundo) || 0);
+        if (r.ok) r.relativo = path.relative(p.pasta, saida).replace(/\\/g, '/');
+        return r;
+    }
+
+    if (acao === 'legendas' || acao === 'transcrever') {
+        return transcrever(p, alvo, ctx);
+    }
+
+    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', [
+            'recortar', '--entrada', alvo, '--saida', saida,
+            ...(args.suavizar != null ? ['--suavizar', String(args.suavizar)] : []),
+            ...(args.encolher != null ? ['--encolher', String(args.encolher)] : []),
+        ], { timeout: 40 * 60000 });
+        if (r.ok) {
+            r.relativo = path.relative(p.pasta, saida).replace(/\\/g, '/');
+            r.comoUsar = 'é um vídeo com fundo TRANSPARENTE. Ponha-o como elemento de vídeo numa cena '
+                + 'que tenha a imagem de fundo atrás — não precisa juntar os dois num arquivo.';
+            projeto.anotar(p.id, 'pessoa', `recortou ${r.quadros} quadros`);
+        }
+        return r;
+    }
+
+    return { ok: false, error: `não conheço a ação "${acao}".` };
+}
+
+/**
+ * A transcrição com tempo — é ela que dá legenda sincronizada.
+ *
+ * Quem tem a chave é o servidor, e é assim de propósito (a API vem com o
+ * produto). O áudio vai pequeno: mono, 16 kHz, 32 kbps.
+ */
+async function transcrever(p, alvo, ctx) {
+    const mp3 = path.join(p.pasta, 'midia', `audio-${Date.now().toString(36)}.mp3`);
+    const ex = await video.extrairAudio(alvo, mp3);
+    if (!ex.ok) return ex;
+
+    if (!ctx.api || !ctx.server) {
+        return { ok: false, error: 'a transcrição precisa do servidor, e ele não foi passado para a ferramenta.' };
+    }
+    if (ex.bytes > 20 * 1024 * 1024) {
+        return { ok: false, error: `o áudio ficou com ${(ex.bytes / 1048576).toFixed(1)} MB, acima do teto de 20 MB. `
+            + 'Transcreva em pedaços: recorte o vídeo antes.' };
+    }
+
+    try {
+        const r = await ctx.api.requestTranscricao(ctx.server, {
+            token: ctx.token,
+            audio: fs.readFileSync(mp3).toString('base64'),
+            nome: path.basename(mp3),
+            idioma: 'pt',
+        });
+        try { fs.unlinkSync(mp3); } catch { /* fica, não faz mal */ }
+        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,
+            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.',
+        };
+    } catch (e) {
+        return { ok: false, error: `a transcrição falhou: ${e.message}` };
+    }
+}
+
+// ── estudio_render ───────────────────────────────────────────────────────
+
+async function ferramentaRender(args, ctx = {}) {
+    const p = projeto.ler(args.id);
+    if (!p) return { ok: false, error: `não achei o projeto "${args.id}".` };
+    const pl = projeto.lerPlano(args.id);
+    if (!pl) return { ok: false, error: 'não há plano neste projeto.' };
+
+    const conferida = plano.conferir(pl, { pasta: p.pasta });
+    if (!conferida.ok) {
+        return { ok: false, error: 'o plano tem problemas — conserte antes de renderizar.',
+            problemas: conferida.problemas.slice(0, 12) };
+    }
+
+    // Os ícones vêm ANTES do render: um render que busca ícone na internet
+    // falha no meio, depois de vinte minutos.
+    const { mapa, faltaram } = await assets.iconesDoPlano(pl, p.pasta);
+
+    const montado = remotion.montar({ pasta: p.pasta, titulo: p.titulo, plano: pl, icones: mapa });
+
+    if (args.somenteProjeto) {
+        return { ok: true, projeto: montado.raiz, faltaram,
+            aviso: 'o projeto Remotion está escrito, mas nada foi renderizado.' };
+    }
+
+    /* SLIDES E ARTE são o mesmo plano, parados no tempo: cada cena vira uma
+       página. O Studio antigo tinha seis ferramentas com seis formatos de
+       documento; cinco delas eram "coisas posicionadas num retângulo", que é
+       o que uma cena já é. */
+    const parado = p.formato === 'slides' || p.formato === 'arte' || args.paginas;
+    if (parado) {
+        const pasta = path.join(p.pasta, 'saida', 'paginas');
+        const r = await slides.renderizarPaginas({
+            raiz: montado.raiz, destino: pasta, plano: pl, aoFalar: ctx.aoFalar || (() => {}),
+        });
+        if (!r.ok) return { ...r, faltaram };
+
+        const pdf = path.join(p.pasta, 'saida', `${projeto.apelidar(p.titulo)}.pdf`);
+        const junto = slides.montarPDF(r.paginas, pdf);
+        if (!junto.ok) return { ...junto, imagens: r.paginas };
+
+        projeto.salvar(args.id, { renders: [...(p.renders || []), { quando: new Date().toISOString(), arquivo: pdf, bytes: junto.bytes }] });
+        projeto.anotar(args.id, 'render', `${junto.paginas} páginas em PDF`);
+        if (ctx.abrir) { try { ctx.abrir(pdf); } catch { /* o caminho está na resposta */ } }
+        return {
+            ok: true, arquivo: pdf, paginas: junto.paginas, bytes: junto.bytes,
+            imagens: r.paginas,
+            faltaram: faltaram.length ? faltaram : undefined,
+            aviso: 'ABERTO para o usuário ver. Chame finish dizendo o que foi feito.',
+        };
+    }
+
+    const saida = path.join(p.pasta, 'saida', `${projeto.apelidar(p.titulo)}.mp4`);
+    const falar = ctx.aoFalar || (() => {});
+    const r = await remotion.renderizar({
+        raiz: montado.raiz, saida,
+        minutos: Number(args.minutos) || 30,
+        aoFalar: falar,
+    });
+    if (!r.ok) return { ...r, faltaram };
+
+    const bytes = fs.existsSync(saida) ? fs.statSync(saida).size : 0;
+    projeto.salvar(args.id, { renders: [...(p.renders || []), { quando: new Date().toISOString(), arquivo: saida, bytes }] });
+    projeto.anotar(args.id, 'render', `${(bytes / 1048576).toFixed(1)} MB, ${conferida.duracao}s`);
+
+    // O vídeo pronto abre. É a única coisa que abre — a interface morreu, e
+    // o que a pessoa pediu foi o vídeo.
+    if (ctx.abrir) { try { ctx.abrir(saida); } catch { /* o caminho está na resposta */ } }
+
+    return {
+        ok: true, arquivo: saida, bytes, segundos: conferida.duracao,
+        faltaram: faltaram.length ? faltaram : undefined,
+        aviso: 'ABERTO para o usuário assistir. Chame finish dizendo o que foi feito.',
+    };
+}
+
+// ── estudio_site ─────────────────────────────────────────────────────────
+
+async function ferramentaSite(args) {
+    let alvo = String(args.url || args.site || '').trim();
+
+    /* Só o NOME da empresa também serve: "faz um vídeo para a Paris Group"
+       não traz link nenhum, e sem este caminho o agente inventaria as cores
+       da marca — erro que aparece pronto no vídeo entregue. */
+    if (!alvo && (args.marca || args.nome || args.empresa)) {
+        const achado = await identidade.acharSite(args.marca || args.nome || args.empresa);
+        if (!achado.ok) return achado;
+        alvo = achado.url;
+    }
+    if (!alvo) return { ok: false, error: 'mande a url do site, ou o nome da empresa em "marca".' };
+    // "tailwindcss.com" é endereço para gente e não é URL para o `new URL`.
+    // Sem isto, o domínio sem esquema voltava "não é um endereço" — e quem
+    // digita o domínio pelado é justamente quem já sabe qual é o site.
+    if (!/^https?:\/\//i.test(alvo)) alvo = 'https://' + alvo;
+
+    const r = await identidade.analisar(alvo);
+    if (r.ok) r.achadoPor = args.url || args.site ? 'url dada' : 'nome da empresa';
+
+    /* A LOGO. Cor e fonte saem do CSS; a logo não — ela mora num <img> do
+       cabeçalho, num apple-touch-icon ou no og:image. Sem baixar aqui, o
+       agente montava a peça de marca com o nome em texto e o usuário
+       perguntava por que a logo dele não apareceu.
+
+       Só baixa quando há projeto: arquivo de mídia solto no disco, fora de
+       uma pasta de projeto, é lixo que ninguém recolhe. */
+    const html = r.html;
+    delete r.html;                          // o HTML cru não vai para o modelo
+    if (r.ok && args.id && args.logo !== false) {
+        const p = projeto.ler(args.id);
+        if (p) {
+            /* O nome que o USUÁRIO disse vem primeiro. `r.marca` sai do
+               <title>, e título de página é frase: o nubank.com.br devolve
+               "Nu | About us", de onde sobra "about" — que não identifica
+               marca nenhuma e faz o desempate premiar a imagem errada. */
+            const daMarca = args.marca || args.nome || args.empresa || r.marca || r.titulo || 'marca';
+            r.logo = await identidade.pegarLogo(html, r.url, { pasta: p.pasta, nome: daMarca });
+            if (r.logo.ok) projeto.anotar(args.id, 'midia', `logo de ${r.marca || r.url}: ${r.logo.src} (${r.logo.achadaEm})`);
+        }
+    }
+
+    if (r.ok && args.id) {
+        projeto.anotar(args.id, 'referencia', `leu ${r.url}: ${(r.cores.marca[0] || {}).cor || 'sem cor'} · ${(r.fontes.declaradas[0] || {}).fonte || 'sem fonte'}`);
+    }
+    return r;
+}
+
+module.exports = {
+    ferramentaProjeto, ferramentaPlano, ferramentaMidia, ferramentaNarrar,
+    ferramentaVideo, ferramentaRender, ferramentaSite,
+    projeto, plano, remotion, assets, video, identidade, slides, python, rodarPython,
+};