primocode 8.40.0 → 8.41.0

package/README.md

@@ -1,15 +1,17 @@
-# PrimoCode v8.1.1
+# PrimoCode v8.41.0
 
 Agente de engenharia brasileiro para o terminal, no estilo Claude Code.
 Cria arquivos de verdade, roda comandos, **controla o navegador e o desktop** —
 e lembra do que fez entre uma sessão e outra.
 
-**Grátis, sem chave de API sua e sem teto de gasto.** Os modelos são os grátis do
-OpenRouter, e cada apelido (`top`/`main`/`fast`) é uma **corrente**: se um modelo
-está no limite de pedidos, o próximo atende. Você não vê o erro, e não paga nada.
+**Sem chave de API sua.** O modelo vem hospedado: você entra com a conta do
+Conecta Primo AI (plano **Premium** ou **Super**) e usa — nada de console de
+provedor, nada de teto de gasto para acompanhar. Quem preferir a própria chave
+do Claude ou do GPT escolhe isso na abertura, com as setinhas, e passa a usar a
+assinatura dele.
 
 ```
- ▐▛███▜▌   Primo Code v8.1.1
+ ▐▛███▜▌   Primo Code v8.41.0
 ▝▜█████▛▘  Bem-vindo de volta, Joel
   ▘▘ ▝▝    ~/primocode  · /dir <pasta> muda
 ```
@@ -31,6 +33,27 @@ veja `/mascot` e `/name`.
 
 Em uma frase: **é o poder de um agente de código no terminal, em português, controlando o seu computador de verdade — sem você precisar configurar chave de API nenhuma.**
 
+## Vídeo e apresentação: o diretor entra antes da produção
+
+Quando o pedido é de vídeo, reels, teaser ou apresentação narrada, o PrimoCode
+não sai montando cena: ele chama primeiro o **diretor** — uma IA que só
+estrutura. Ela devolve o roteiro cena a cena com a **narração escrita para ser
+falada**, a duração, a transição, o movimento de cada cena, a voz (perfil e
+instrução de leitura) e a lista de imagens, logos e música a buscar. Só depois
+disso a produção começa, e ela segue a pauta em vez de inventar.
+
+A mídia é de verdade: foto com licença aberta (Openverse), logo em SVG da marca
+(Wikimedia Commons) e, com chave própria, a busca de imagens do Google pela API
+oficial. Música e efeito sonoro vêm do `buscar_audio`, que baixa e já traz o
+crédito; a identidade de uma empresa — logo, cor, paleta, fontes e frase — o
+`marca_da_empresa` lê do site dela. Tudo o que desce guarda a licença ao lado do
+arquivo, e os créditos saem prontos para a cena final. Recorte de fundo com
+`rembg`, quando instalado.
+
+O motor não é gosto: vídeo curto sai pelo estúdio, em segundos, sem instalar
+nada; vídeo longo, canal alfa, ProRes ou fps alto viram projeto **Remotion** na
+sua pasta — e a resposta sempre diz por que escolheu.
+
 ## Instalação
 
 **macOS / Linux / WSL** — um comando, e ele resolve tudo (inclusive instalar o Node, se faltar):

package/bin/primocode.js

@@ -228,6 +228,69 @@ function sliderEffort(atual) {
     });
 }
 
+/* ── A LISTA COM AS SETINHAS ─────────────────────────────────────────────
+ *
+ *   "O usuário seleciona usando as setinhas, igual você."
+ *
+ * ↑↓ anda, Enter confirma, Esc fica com o primeiro item. O número também
+ * funciona — quem já sabe qual quer não precisa navegar até lá.
+ *
+ * Devolve `undefined` quando não há terminal de verdade: aí quem chamou cai
+ * na lista numerada, que funciona em pipe e em CI. `null` é outra coisa —
+ * é Esc, que É uma resposta ("tanto faz, a primeira").
+ */
+function menuSetas({ titulo, ajuda, lista }) {
+    return new Promise((resolve) => {
+        if (!process.stdin.isTTY || !process.stdout.isTTY) return resolve(undefined);
+        let idx = 0;
+        const linhas = () => {
+            const fora = [''];
+            fora.push(c.bold(c.brand('  ' + titulo)));
+            if (ajuda) fora.push(c.muted('  ' + ajuda));
+            fora.push('');
+            lista.forEach((e, i) => {
+                const aqui = i === idx;
+                fora.push((aqui ? c.brand('  ❯ ') : '    ') + (aqui ? c.bold(c.white(e.titulo)) : c.muted(e.titulo)));
+                fora.push('      ' + c.dim(e.detalhe || ''));
+            });
+            fora.push('');
+            return fora;
+        };
+        const ALTURA = linhas().length;
+
+        const pintar = (primeira) => {
+            if (!primeira) process.stdout.write(`\x1b[${ALTURA}A\r`);
+            process.stdout.write(linhas().map((l) => '\x1b[2K' + l).join('\n') + '\n');
+        };
+
+        const encerrar = (valor) => {
+            process.stdin.removeListener('keypress', aoTeclar);
+            sliderAtivo = false;
+            try { process.stdout.write('\x1b[?25h'); } catch {}
+            resolve(valor);
+        };
+        const aoTeclar = (ch, key) => {
+            if (!key) return;
+            if (key.name === 'down' || key.name === 'j' || (key.name === 'tab' && !key.shift)) {
+                idx = (idx + 1) % lista.length; return pintar(false);
+            }
+            if (key.name === 'up' || key.name === 'k' || (key.name === 'tab' && key.shift)) {
+                idx = (idx - 1 + lista.length) % lista.length; return pintar(false);
+            }
+            if (/^[1-9]$/.test(ch || '') && Number(ch) <= lista.length) {
+                idx = Number(ch) - 1; return pintar(false);
+            }
+            if (key.name === 'return' || key.name === 'enter') return encerrar(lista[idx].id);
+            if (key.name === 'escape' || (key.ctrl && key.name === 'c')) return encerrar(null);
+        };
+
+        sliderAtivo = true;   // enquanto está no ar, o resto do teclado se cala
+        try { process.stdout.write('\x1b[?25l'); } catch {}
+        pintar(true);
+        process.stdin.on('keypress', aoTeclar);
+    });
+}
+
 function aplicarEffort(nome) {
     const nivel = effort.nivelDe(nome);
     state.config.effort = nivel.nome;
@@ -1652,6 +1715,10 @@ async function main() {
     }
 
     rl.on('line', (line) => {
+        // A lista de setinhas (e o slider do /effort) são donos do teclado
+        // enquanto estão no ar: o Enter que confirma a escolha não é uma
+        // linha para a fila, e sem isto ele vira um pedido em branco.
+        if (sliderAtivo) return;
         if (pendingAsk) { const resolve = pendingAsk; pendingAsk = null; resolve(line); return; }
         // Abertura correndo: guarda em vez de mandar ao agente.
         if (segurando) { adiantadas.push(line); return; }
@@ -1687,6 +1754,29 @@ async function main() {
         interativo: !!(process.stdin.isTTY && process.stdout.isTTY),
         conectado: () => conta.atual(),
         conectar: () => handleSlash('/connect').then(() => conta.atual()),
+        /* A ESCOLHA, COM AS SETINHAS — E O QUE FOI DIGITADO ANTES DELA.
+         *
+         * A lista só aparece depois de o plano voltar do servidor, e quem
+         * colou "3⏎1⏎/version" já respondeu antes de ver. Esse texto está em
+         * `adiantadas`; se a lista ignorasse, a resposta se perderia e o
+         * menu ficaria esperando um teclado que já falou. Então: primeiro o
+         * que foi adiantado (se casar com algum item), depois as setinhas. O
+         * que não casa fica na fila — é comando, não resposta. */
+        selecionar: ({ titulo, ajuda, lista }) => {
+            while (adiantadas.length) {
+                const dito = String(adiantadas[0] || '').trim();
+                if (!dito) { adiantadas.shift(); continue; }
+                const qual = boasVindas.escolher(dito, lista);
+                if (!qual) break;                       // isso é comando, não escolha
+                adiantadas.shift();
+                const item = lista.find((e) => e.id === qual);
+                console.log('');
+                console.log(c.bold(c.brand('  ' + titulo)));
+                console.log(c.brand('  ❯ ') + c.white(item ? item.titulo : qual));
+                return Promise.resolve(qual);
+            }
+            return menuSetas({ titulo, ajuda, lista });
+        },
         sessao: () => conta.sessao(),
         aplicar: (cmd) => handleSlash(cmd),
     }).then((r) => {

package/lib/acervo.js

@@ -0,0 +1,391 @@
+/**
+ * acervo.js — de onde vêm as imagens, os logos e a música.
+ *
+ *   "Pesquise e use imagens e logos do Google, baixe imagens, corte fundo, use
+ *    músicas da internet."
+ *
+ * ── POR QUE ISTO NÃO É "BAIXAR DO GOOGLE" E PRONTO ───────────────────────
+ * Porque o Google Imagens não é uma API: raspar a página dele é contra os
+ * termos, quebra sem aviso e devolve a MINIATURA, que num vídeo 1920×1080
+ * aparece como um borrão. O que existe de verdade são três caminhos, e este
+ * módulo usa os três, nesta ordem:
+ *
+ *   1. OPENVERSE — busca de imagem E de áudio com licença aberta, sem chave.
+ *      É o padrão: funciona na máquina de todo mundo, no primeiro minuto.
+ *   2. WIKIMEDIA COMMONS — é onde MORAM os logos das marcas, em SVG e PNG
+ *      grandes. Uma busca de logo que não passa por aqui devolve fan art.
+ *   3. GOOGLE CUSTOM SEARCH — a busca do Google DE VERDADE, pela API oficial,
+ *      quando a pessoa tem chave (`PRIMOCODE_GOOGLE_KEY` + `PRIMOCODE_GOOGLE_CX`).
+ *      Cobre o que os dois primeiros não têm.
+ *
+ * ── A LICENÇA ANDA JUNTO DO ARQUIVO ──────────────────────────────────────
+ * Todo download grava um `.json` ao lado com fonte, autor e licença. Não é
+ * burocracia: um vídeo de cliente com uma foto "CC BY" sem crédito é um
+ * problema jurídico do cliente, e descobrir isso depois de publicar é tarde.
+ * `creditos()` monta a lista pronta para a cena final ou a descrição.
+ *
+ * ── O QUE NÃO ENTRA AQUI ─────────────────────────────────────────────────
+ * Nada é baixado para dentro do pacote npm nem fica de dependência. O acervo
+ * mora em `~/.primocode/acervo`, com cache por URL: a mesma foto pedida duas
+ * vezes desce uma vez só.
+ */
+
+'use strict';
+
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+const https = require('https');
+const http = require('http');
+const { spawn, spawnSync } = require('child_process');
+
+const PASTA = () => path.join(os.homedir(), '.primocode', 'acervo');
+const TETO_BYTES = 25 * 1024 * 1024;     // 25 MB: foto grande cabe, filme não
+const TIPOS_OK = /^(image\/(jpeg|png|webp|gif|svg\+xml)|audio\/(mpeg|mp4|ogg|wav|flac)|video\/mp4)/;
+
+// ── a rede, sem dependência ──────────────────────────────────────────────
+
+function buscarJSON(url, { timeout = 15000, cabecalhos = {} } = {}) {
+    return new Promise((resolve, reject) => {
+        const req = https.get(url, {
+            timeout,
+            headers: { 'User-Agent': agente(), Accept: 'application/json', ...cabecalhos },
+        }, (res) => {
+            if (res.statusCode >= 300 && res.statusCode < 400 && res.headers.location) {
+                res.resume();
+                return resolve(buscarJSON(new URL(res.headers.location, url).href, { timeout, cabecalhos }));
+            }
+            let txt = '';
+            res.setEncoding('utf8');
+            res.on('data', (d) => { txt += d; });
+            res.on('end', () => {
+                if (res.statusCode >= 400) return reject(new Error(`${res.statusCode} em ${new URL(url).host}`));
+                try { resolve(JSON.parse(txt)); } catch { reject(new Error('resposta que não é JSON')); }
+            });
+        });
+        req.on('timeout', () => req.destroy(new Error('o servidor demorou demais')));
+        req.on('error', reject);
+    });
+}
+
+/* O User-Agent é EXIGIDO pela Wikimedia — sem ele a API responde 403, e o
+   erro não diz isso. Vai com o nome do programa e a versão, que é o que a
+   política deles pede. */
+function agente() {
+    let v = '?';
+    try { v = require('../package.json').version; } catch { /* sem package: tanto faz */ }
+    return `PrimoCode/${v} (https://github.com/parisgroup-ai/primocode)`;
+}
+
+// ── as buscas ────────────────────────────────────────────────────────────
+
+/**
+ * Imagens com licença aberta, do Openverse. Sem chave, sem cadastro.
+ * `licenca: 'comercial'` (padrão) só traz o que pode ir em vídeo de cliente.
+ */
+async function openverseImagens(consulta, { quantos = 8, licenca = 'comercial', orientacao } = {}) {
+    const q = new URLSearchParams({ q: consulta, page_size: String(Math.min(20, quantos * 2)) });
+    if (licenca === 'comercial') q.set('license_type', 'commercial');
+    if (orientacao) q.set('aspect_ratio', orientacao === 'retrato' ? 'tall'
+        : orientacao === 'quadrado' ? 'square' : 'wide');
+    const r = await buscarJSON('https://api.openverse.org/v1/images/?' + q.toString());
+    return (r.results || []).slice(0, quantos).map((i) => ({
+        fonte: 'openverse', titulo: i.title || consulta, url: i.url, pagina: i.foreign_landing_url,
+        autor: i.creator || null, licenca: [i.license, i.license_version].filter(Boolean).join(' ').toUpperCase(),
+        largura: i.width || null, altura: i.height || null, tipo: i.filetype || null,
+    }));
+}
+
+/** Música e efeitos, do mesmo Openverse — é ele quem indexa ccMixter e Jamendo. */
+async function openverseAudio(consulta, { quantos = 6, licenca = 'comercial', segundosMin = 20 } = {}) {
+    const q = new URLSearchParams({ q: consulta, page_size: String(Math.min(20, quantos * 3)) });
+    if (licenca === 'comercial') q.set('license_type', 'commercial');
+    const r = await buscarJSON('https://api.openverse.org/v1/audio/?' + q.toString());
+    return (r.results || [])
+        .filter((a) => !segundosMin || !a.duration || a.duration / 1000 >= segundosMin)
+        .slice(0, quantos)
+        .map((a) => ({
+            fonte: 'openverse', titulo: a.title || consulta,
+            url: a.url || (a.alt_files && a.alt_files[0] && a.alt_files[0].url),
+            pagina: a.foreign_landing_url, autor: a.creator || null,
+            licenca: [a.license, a.license_version].filter(Boolean).join(' ').toUpperCase(),
+            segundos: a.duration ? Math.round(a.duration / 1000) : null,
+            genero: (a.genres || []).join(', ') || null,
+        }))
+        .filter((a) => a.url);
+}
+
+/**
+ * Logos, no lugar onde eles moram de verdade: o Wikimedia Commons.
+ *
+ * A busca vai atrás de "<marca> logo" no espaço de arquivos e devolve a URL
+ * do ORIGINAL — normalmente SVG, que é o que se quer num vídeo: escala sem
+ * borrar. Procurar logo numa busca de fotos devolve fan art e camiseta.
+ */
+async function wikimediaLogos(marca, { quantos = 6 } = {}) {
+    const q = new URLSearchParams({
+        action: 'query', format: 'json', origin: '*', generator: 'search',
+        gsrsearch: `${marca} logo`, gsrnamespace: '6', gsrlimit: String(Math.min(20, quantos * 2)),
+        prop: 'imageinfo', iiprop: 'url|size|extmetadata', iiurlwidth: '1024',
+    });
+    const r = await buscarJSON('https://commons.wikimedia.org/w/api.php?' + q.toString());
+    const paginas = r && r.query && r.query.pages ? Object.values(r.query.pages) : [];
+    return paginas
+        .map((p) => {
+            const info = (p.imageinfo || [])[0] || {};
+            const meta = info.extmetadata || {};
+            return {
+                fonte: 'wikimedia', titulo: p.title || marca,
+                url: info.url, pagina: info.descriptionurl,
+                autor: limpar(meta.Artist && meta.Artist.value) || null,
+                licenca: (meta.LicenseShortName && meta.LicenseShortName.value) || 'ver a página',
+                largura: info.width || null, altura: info.height || null,
+                vetor: /\.svg$/i.test(info.url || ''),
+            };
+        })
+        .filter((i) => i.url && /\.(svg|png|jpe?g|webp)$/i.test(i.url))
+        .sort((a, b) => Number(b.vetor) - Number(a.vetor))     // SVG primeiro
+        .slice(0, quantos);
+}
+
+function limpar(html) {
+    return html ? String(html).replace(/<[^>]*>/g, '').replace(/\s+/g, ' ').trim() : null;
+}
+
+/**
+ * A busca do Google DE VERDADE — pela API oficial, com a chave da pessoa.
+ * Sem chave, devolve lista vazia e quem chamou segue com os outros caminhos:
+ * não é erro, é um caminho que esta máquina não tem.
+ */
+async function googleImagens(consulta, { quantos = 8, chave, cx, tipo } = {}) {
+    const key = chave || process.env.PRIMOCODE_GOOGLE_KEY;
+    const eng = cx || process.env.PRIMOCODE_GOOGLE_CX;
+    if (!key || !eng) return [];
+    const q = new URLSearchParams({
+        key, cx: eng, q: consulta, searchType: 'image', num: String(Math.min(10, quantos)),
+        safe: 'active', imgSize: 'xlarge',
+    });
+    if (tipo === 'logo') { q.set('imgType', 'clipart'); q.set('imgSize', 'large'); }
+    const r = await buscarJSON('https://www.googleapis.com/customsearch/v1?' + q.toString());
+    return (r.items || []).map((i) => ({
+        fonte: 'google', titulo: i.title, url: i.link,
+        pagina: (i.image && i.image.contextLink) || i.link,
+        autor: i.displayLink || null, licenca: 'confira na página de origem',
+        largura: i.image && i.image.width, altura: i.image && i.image.height,
+    }));
+}
+
+/**
+ * A busca que o agente chama: tenta os caminhos na ordem certa para o que
+ * está sendo procurado, e junta.
+ *
+ * Logo pede Wikimedia primeiro; foto pede Openverse. O Google entra sempre
+ * que houver chave — é ele que cobre o que falta.
+ */
+async function procurar(consulta, { tipo = 'imagem', quantos = 8, licenca = 'comercial', orientacao } = {}) {
+    const achados = [];
+    const tentar = async (fn) => {
+        try { achados.push(...(await fn())); } catch (e) { falhas.push(e.message); }
+    };
+    const falhas = [];
+
+    if (tipo === 'musica' || tipo === 'audio') {
+        await tentar(() => openverseAudio(consulta, { quantos, licenca }));
+    } else if (tipo === 'logo') {
+        await tentar(() => wikimediaLogos(consulta, { quantos }));
+        await tentar(() => googleImagens(consulta + ' logo', { quantos, tipo: 'logo' }));
+        if (!achados.length) await tentar(() => openverseImagens(consulta + ' logo', { quantos, licenca }));
+    } else {
+        await tentar(() => openverseImagens(consulta, { quantos, licenca, orientacao }));
+        await tentar(() => googleImagens(consulta, { quantos }));
+    }
+
+    const vistos = new Set();
+    const lista = achados.filter((a) => a.url && !vistos.has(a.url) && vistos.add(a.url));
+    return { ok: lista.length > 0, tipo, consulta, achados: lista.slice(0, quantos),
+        falhas: lista.length ? [] : falhas };
+}
+
+// ── baixar ───────────────────────────────────────────────────────────────
+
+function nomeDe(url, titulo) {
+    let ext = '';
+    try { ext = path.extname(new URL(url).pathname).slice(0, 6); } catch { /* url estranha */ }
+    const base = String(titulo || 'arquivo').toLowerCase()
+        .normalize('NFD').replace(/[̀-ͯ]/g, '')
+        .replace(/[^a-z0-9]+/g, '-').replace(/^-+|-+$/g, '').slice(0, 48) || 'arquivo';
+    const marca = hash(url);
+    return `${base}-${marca}${ext || ''}`;
+}
+
+function hash(texto) {
+    // Um identificador curto e estável por URL. Não é segurança — é cache.
+    let h = 0;
+    for (let i = 0; i < texto.length; i++) { h = (h * 31 + texto.charCodeAt(i)) | 0; }
+    return Math.abs(h).toString(36).slice(0, 7);
+}
+
+/**
+ * Baixa e guarda, com a licença ao lado. Mesma URL duas vezes: baixa uma.
+ *
+ * Recusa o que não é mídia (uma página de erro em HTML chega com 200 e
+ * viraria um "jpg" que não abre) e o que passa do teto.
+ */
+function baixar(url, { titulo, meta = {}, pasta = PASTA(), teto = TETO_BYTES } = {}) {
+    return new Promise((resolve) => {
+        let destino;
+        try { destino = path.join(pasta, nomeDe(url, titulo)); }
+        catch { return resolve({ ok: false, error: 'url inválida' }); }
+
+        if (fs.existsSync(destino) && fs.statSync(destino).size > 0) {
+            return resolve({ ok: true, arquivo: destino, cache: true, ...lerFicha(destino) });
+        }
+        fs.mkdirSync(pasta, { recursive: true });
+
+        const puxar = (alvo, saltos = 0) => {
+            let u;
+            try { u = new URL(alvo); } catch { return resolve({ ok: false, error: 'url inválida' }); }
+            const lib = u.protocol === 'https:' ? https : http;
+            const req = lib.get(u, { timeout: 30000, headers: { 'User-Agent': agente() } }, (res) => {
+                if (res.statusCode >= 300 && res.statusCode < 400 && res.headers.location) {
+                    res.resume();
+                    if (saltos > 4) return resolve({ ok: false, error: 'redirecionamento sem fim' });
+                    return puxar(new URL(res.headers.location, alvo).href, saltos + 1);
+                }
+                if (res.statusCode !== 200) {
+                    res.resume();
+                    return resolve({ ok: false, error: `o servidor respondeu ${res.statusCode}` });
+                }
+                const tipo = String(res.headers['content-type'] || '').split(';')[0];
+                if (tipo && !TIPOS_OK.test(tipo)) {
+                    res.resume();
+                    return resolve({ ok: false, error: `isso não é mídia (${tipo})` });
+                }
+                const tamanho = Number(res.headers['content-length'] || 0);
+                if (tamanho && tamanho > teto) {
+                    res.resume();
+                    return resolve({ ok: false, error: `arquivo grande demais (${Math.round(tamanho / 1e6)} MB)` });
+                }
+                let escritos = 0;
+                const saida = fs.createWriteStream(destino);
+                res.on('data', (p) => {
+                    escritos += p.length;
+                    if (escritos > teto) {
+                        req.destroy();
+                        saida.destroy();
+                        try { fs.rmSync(destino, { force: true }); } catch {}
+                        resolve({ ok: false, error: 'arquivo grande demais' });
+                    }
+                });
+                res.pipe(saida);
+                saida.on('finish', () => {
+                    const ficha = { url, titulo: titulo || null, baixado: new Date().toISOString(), ...meta };
+                    try { fs.writeFileSync(destino + '.json', JSON.stringify(ficha, null, 2), 'utf8'); } catch {}
+                    resolve({ ok: true, arquivo: destino, bytes: escritos, cache: false, ficha });
+                });
+                saida.on('error', (e) => resolve({ ok: false, error: e.message }));
+            });
+            req.on('timeout', () => req.destroy(new Error('demorou demais')));
+            req.on('error', (e) => resolve({ ok: false, error: e.message }));
+        };
+        puxar(url);
+    });
+}
+
+function lerFicha(arquivo) {
+    try { return { ficha: JSON.parse(fs.readFileSync(arquivo + '.json', 'utf8')) }; }
+    catch { return { ficha: null }; }
+}
+
+/** A lista de créditos do que foi usado — pronta para a cena final. */
+function creditos(arquivos = null, pasta = PASTA()) {
+    let fichas = [];
+    try {
+        const alvos = arquivos || fs.readdirSync(pasta)
+            .filter((f) => f.endsWith('.json'))
+            .map((f) => path.join(pasta, f.replace(/\.json$/, '')));
+        fichas = alvos.map((a) => lerFicha(a).ficha).filter(Boolean);
+    } catch { /* sem acervo ainda */ }
+    return fichas.map((f) => ({
+        titulo: f.titulo, autor: f.autor || null, licenca: f.licenca || null,
+        fonte: f.fonte || null, pagina: f.pagina || f.url,
+        linha: [f.titulo, f.autor && `por ${f.autor}`, f.licenca, f.fonte]
+            .filter(Boolean).join(' · '),
+    }));
+}
+
+// ── tirar o fundo ────────────────────────────────────────────────────────
+
+/**
+ * Qual ferramenta desta máquina sabe recortar. A decisão fica separada do
+ * processo para poder ser testada sem recortar nada.
+ */
+function comoTirarFundo({ temRembg, temBackgroundRemover, temPython, temFfmpeg } = {}) {
+    if (temRembg) return 'rembg';
+    if (temBackgroundRemover) return 'backgroundremover';
+    if (temPython) return 'python-rembg';
+    if (temFfmpeg) return 'ffmpeg-chroma';       // só resolve fundo de cor chapada
+    return null;
+}
+
+function existe(cmd) {
+    try { return spawnSync(cmd, ['--help'], { stdio: 'ignore', timeout: 8000 }).status != null; }
+    catch { return false; }
+}
+
+/**
+ * Recorta o fundo, com o que houver instalado.
+ *
+ * O caminho bom é o `rembg` (modelo U²-Net), que resolve pessoa, produto e
+ * logo com sombra. O `ffmpeg -colorkey` é o último recurso e só serve para
+ * fundo de UMA cor chapada — dizer que ele "tira o fundo" de uma foto
+ * qualquer seria mentira, e por isso o resultado vem com `metodo` na
+ * resposta: quem chamou mostra o que foi feito.
+ */
+async function tirarFundo(arquivo, { destino, cor = '0x00FF00', tolerancia = 0.3 } = {}) {
+    if (!fs.existsSync(arquivo)) return { ok: false, error: 'esse arquivo não existe' };
+    const saida = destino || arquivo.replace(/\.[^.]+$/, '') + '-sem-fundo.png';
+    const metodo = comoTirarFundo({
+        temRembg: existe('rembg'),
+        temBackgroundRemover: existe('backgroundremover'),
+        // `import rembg` só sai 0 quando o pacote ESTÁ lá — é a pergunta
+        // certa: ter python não é ter recortador.
+        temPython: (() => {
+            try { return spawnSync('python3', ['-c', 'import rembg'], { stdio: 'ignore', timeout: 20000 }).status === 0; }
+            catch { return false; }
+        })(),
+        temFfmpeg: existe('ffmpeg'),
+    });
+    if (!metodo) {
+        return { ok: false, error: 'nada nesta máquina sabe recortar fundo',
+            comoResolver: 'instale com: pip install rembg  (ou pipx install rembg)' };
+    }
+
+    const rodar = (cmd, args) => new Promise((ok) => {
+        const p = spawn(cmd, args, { stdio: 'ignore' });
+        p.on('error', () => ok(false));
+        p.on('close', (cod) => ok(cod === 0));
+    });
+
+    let deu = false;
+    if (metodo === 'rembg') deu = await rodar('rembg', ['i', arquivo, saida]);
+    else if (metodo === 'backgroundremover') deu = await rodar('backgroundremover', ['-i', arquivo, '-o', saida]);
+    else if (metodo === 'python-rembg') {
+        deu = await rodar('python3', ['-c',
+            'import sys;from rembg import remove;open(sys.argv[2],"wb").write(remove(open(sys.argv[1],"rb").read()))',
+            arquivo, saida]);
+    } else {
+        deu = await rodar('ffmpeg', ['-y', '-i', arquivo, '-vf',
+            `colorkey=${cor}:${tolerancia}:0.1`, '-c:a', 'copy', saida]);
+    }
+
+    if (!deu || !fs.existsSync(saida)) return { ok: false, error: `o recorte falhou (${metodo})`, metodo };
+    return { ok: true, arquivo: saida, metodo,
+        aviso: metodo === 'ffmpeg-chroma'
+            ? 'recorte por cor: só funciona bem em fundo de uma cor só' : null };
+}
+
+module.exports = {
+    procurar, openverseImagens, openverseAudio, wikimediaLogos, googleImagens,
+    baixar, creditos, tirarFundo, comoTirarFundo, nomeDe, PASTA,
+};

package/lib/act.js

@@ -760,6 +760,22 @@ async function runAct(userPrompt, opts) {
                 continue;
             }
 
+            /* O DIRETOR mora aqui pelo mesmo motivo do pipeline: ele roda
+               um AGENTE, e quem sabe rodar agente é este arquivo. É a peça
+               que o dono pediu — "a IA identifica que precisa criar vídeo,
+               ativa o agente, esse agente faz a estrutura e manda pra IA, e
+               depois ela só faz o vídeo". */
+            if (tc.name === 'planejar_producao') {
+                algoRodou = true;
+                fala.acao(tc.name, tc.arguments, profundidade);
+                const r = await rodarDiretor(tc.arguments || {}, {
+                    server, model, token, projectDir: pastaAtual, projectName, profundidade, motor,
+                });
+                logResult(tc.name, r, profundidade);
+                messages.push({ role: 'tool', tool_call_id: tc.id, content: JSON.stringify(r) });
+                continue;
+            }
+
             // Repetiu a mesma chamada? Não executa de novo. Rodar outra vez
             // gastaria a cota para devolver exatamente o mesmo texto, e é
             // esse texto que convence o modelo a repetir mais uma vez. Sem
@@ -994,5 +1010,60 @@ async function rodarPipeline(args, ctx) {
     });
 }
 
+/* ══ O DIRETOR ═════════════════════════════════════════════════════════════
+ *
+ *   "Tenha uma IA específica pra roteiro que monta tudo — narração, qual voz,
+ *    roteiro. Ela estrutura tudo antes de mandar pra IA."
+ *
+ * As regras, o prompt e a conferência do plano moram em `diretor.js`. Aqui é
+ * a costura: uma conversa NOVA para o diretor (ele não vê a do usuário nem a
+ * do produtor — é isso que faz o roteiro parar de virar legenda do slide) e a
+ * pauta de volta, que é o que o produtor recebe no lugar do pedido cru.
+ */
+async function rodarDiretor(args, ctx) {
+    const { server, model, token, projectDir, projectName, profundidade, motor } = ctx;
+    const diretor = require('./diretor.js');
+
+    const correr = async (prompt, rotulo) => {
+        if (PARAR) return '';
+        fala.agente('Diretor', rotulo, profundidade);
+        const r = await runAct(prompt, {
+            server, model, token, projectDir, projectName,
+            history: [], profundidade: profundidade + 1, subagent: true, motor,
+        });
+        return (r && r.assistantMessage && r.assistantMessage.content) || '';
+    };
+
+    const r = await diretor.planejar({
+        pedido: args.pedido || args.prompt || '',
+        segundos: Number(args.segundos) || 30,
+        formato: args.formato === 'apresentacao' ? 'apresentacao' : 'video',
+        contexto: args.contexto || '',
+        correr,
+        mostrar: (linha) => console.log(fala.resultado(profundidade) + c.muted(linha)),
+    });
+    if (!r.ok) return r;
+
+    return {
+        ok: true,
+        motor: r.plano.motor,
+        voz: r.plano.voz,
+        midia: r.plano.midia,
+        trilha: r.plano.trilha,
+        pauta: diretor.pauta(r.plano),
+        plano: r.plano,
+        ressalvas: r.defeitos,
+        aviso: 'A ESTRUTURA ESTÁ PRONTA. Agora só PRODUZA: busque a mídia listada com '
+            + 'midia_procurar + midia_baixar (use o "src" que volta em fundo.imagem e em src); '
+            + 'a TRILHA vem do buscar_audio (já baixa e credita) e a identidade de uma empresa, do marca_da_empresa. '
+            + `e monte com studio_criar (${r.plano.formato === 'apresentacao' ? 'prisma' : 'corte'}) `
+            + 'seguindo a pauta cena a cena. Não invente cena, não troque a ordem, não reescreva a narração. '
+            + (r.plano.motor.motor === 'remotion'
+                ? 'Depois de criar, gere o projeto Remotion com remotion_projeto: '
+                    + r.plano.motor.motivo + '.'
+                : 'O motor é o estúdio: ' + r.plano.motor.motivo + '.'),
+    };
+}
+
 module.exports = { runAct, interromper, compactar, motivoDaParada, ehTetoDeToken, ehTransitorio, esperaDoErro,
     anotacaoDoQueJaFoi, encolherParaContinuar, pareceParadaNoMeio, MAX_ITERATIONS, MAX_EMPURROES };

package/lib/audio-livre.js

@@ -64,7 +64,12 @@ async function procurar({ consulta, tipo = 'musica', dur = 0, comercial = true,
     if (!bruto) return { ok: false, error: 'o Openverse não respondeu (rede?)' };
     let j;
     try { j = JSON.parse(bruto); } catch { return { ok: false, error: 'resposta ilegível do Openverse' }; }
-    const itens = (j.results || []).filter((f) => f.url && LIVRES.has(String(f.license || '').toLowerCase()) || !comercial);
+    // `f.url &&` PRECISA valer sempre: sem o parêntese, `&&` liga mais forte
+    // que `||` e `comercial: false` deixava passar item sem url (o download
+    // falhava três vezes e a tool dizia "não consegui baixar") E, pior, faixa
+    // NC dentro de peça comercial — o que a lista LIVRES existe para impedir.
+    const itens = (j.results || []).filter((f) => f.url
+        && (LIVRES.has(String(f.license || '').toLowerCase()) || !comercial));
     const alvoMs = tipo === 'efeito' ? 2500 : (dur ? dur * 1000 : 90000);
     const notas = itens.map((f) => {
         let n = 0;