primocode 8.40.0 → 8.42.0

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;

package/lib/boas-vindas.js

@@ -16,6 +16,14 @@
  *    pra próxima tela, e aí você seleciona Claude ou GPT — e quando seleciona,
  *    ele dá aquele /gpt ou /claude, e vai funcionar como já funciona hoje."
  *
+ * ── O FLUXO, DO NPM AO PRIMEIRO PEDIDO ───────────────────────────────────
+ *
+ *   npm → `primocode` → login (a página /token do conecta-primo-ai, que é o
+ *   login normal do app com o token do PrimoCode; o site fala com o terminal
+ *   sozinho) → "✅ Autenticado, redirecionando…" → "Como quer prosseguir?",
+ *   com as SETINHAS: API padrão, API própria de outra IA, ou uma IA já
+ *   configurada. Escolheu, está pronto para usar.
+ *
  * ── A ORDEM É O PRODUTO ──────────────────────────────────────────────────
  * Conectar → conferir o plano → escolher o motor. Nesta ordem, e não em
  * outra. A primeira versão disto oferecia o login como UMA OPÇÃO de menu, ao
@@ -43,6 +51,8 @@ const fs = require('fs');
 const os = require('os');
 const path = require('path');
 
+const chavesModulo = require('./chaves.js');
+
 const MARCA = () => path.join(os.homedir(), '.primocode', 'ja-abriu.json');
 
 /** Já escolheu o motor alguma vez? A marca guarda a escolha, não o login. */
@@ -67,15 +77,17 @@ function esquecer() {
 
 const MOTORES = [
     { id: 'padrao', titulo: 'Continuar com a API padrão',
-        detalhe: 'A que já vem pronta, incluída no seu plano.' },
-    { id: 'propria', titulo: 'Usar a minha conta (Claude, GPT…)',
-        detalhe: 'O Claude Code ou o Codex que você já usa, na sua assinatura.' },
+        detalhe: 'A que já vem pronta, incluída no seu plano. É só começar.' },
+    { id: 'propria', titulo: 'Usar a API própria de outra IA',
+        detalhe: 'Você cola a sua chave do Claude ou do GPT, e ela é usada nas chamadas.' },
+    { id: 'configurada', titulo: 'Usar uma IA já configurada',
+        detalhe: 'O Claude Code ou o Codex que já está instalado e logado nesta máquina.' },
 ];
 
 const PROVEDORES = [
-    { id: 'claude', titulo: 'Claude', comando: '/claude',
+    { id: 'claude', titulo: 'Claude', comando: '/claude', chave: 'claude',
         detalhe: 'Usa o Claude Code da sua conta, no Opus.' },
-    { id: 'gpt', titulo: 'GPT', comando: '/gpt',
+    { id: 'gpt', titulo: 'GPT', comando: '/gpt', chave: 'codex',
         detalhe: 'Usa o Codex da sua conta, num modelo barato.' },
 ];
 
@@ -90,14 +102,15 @@ function escolher(texto, lista) {
     if (!t) return lista[0].id;
     const n = Number(t);
     if (Number.isInteger(n) && n >= 1 && n <= lista.length) return lista[n - 1].id;
-    for (const e of lista) {
-        if (t === e.id || t === e.titulo.toLowerCase()) return e.id;
-        if (e.id.length >= 3 && t.startsWith(e.id.slice(0, 3))) return e.id;
-    }
+    // Primeiro o que bate INTEIRO. O prefixo vem depois, senão "continuar com
+    // a API padrão" cairia em "configurada" só por começar com "con".
+    for (const e of lista) if (t === e.id || t === e.titulo.toLowerCase()) return e.id;
+    for (const e of lista) if (e.id.length >= 3 && t.startsWith(e.id.slice(0, 3))) return e.id;
     // O jeito como as pessoas falam, e não como a lista se chama.
     if (lista === MOTORES) {
+        if (/j[aá] config|j[aá] instal|j[aá] logad|configurad|instalad|logad/.test(t)) return 'configurada';
         if (/padr|inclu|mesmo|pronta|voc[eê]s|de voc/.test(t)) return 'padrao';
-        if (/minha|meu|pr[oó]pri|conta|chave|assinatura/.test(t)) return 'propria';
+        if (/minha|meu|pr[oó]pri|conta|chave|assinatura|api de outra/.test(t)) return 'propria';
     } else {
         if (/claude|anthropic|opus|sonnet/.test(t)) return 'claude';
         if (/gpt|openai|codex|chatgpt/.test(t)) return 'gpt';
@@ -105,7 +118,19 @@ function escolher(texto, lista) {
     return null;
 }
 
-async function perguntarDaLista({ perguntar, mostrar, cores: c, titulo, ajuda, lista }) {
+/**
+ * A escolha na tela. Com terminal de verdade é a LISTA COM AS SETINHAS — ↑↓
+ * anda, Enter confirma, como no Claude Code: ninguém precisa saber que o item
+ * tem número. `selecionar` vem de quem chamou (o bin, que é dono do teclado);
+ * onde ele não existe — teste, pipe, terminal sem raw mode — cai na lista
+ * numerada de sempre, que responde ao número, ao nome e ao Enter.
+ */
+async function perguntarDaLista({ perguntar, mostrar, cores: c, titulo, ajuda, lista, selecionar }) {
+    if (selecionar) {
+        const escolhido = await selecionar({ titulo, ajuda, lista });
+        if (escolhido && lista.some((e) => e.id === escolhido)) return escolhido;
+        if (escolhido === null) return lista[0].id;   // Esc: fica com a primeira
+    }
     mostrar('');
     mostrar(c.bold(c.brand('  ' + titulo)));
     if (ajuda) mostrar(c.muted('  ' + ajuda));
@@ -142,7 +167,7 @@ async function perguntarDaLista({ perguntar, mostrar, cores: c, titulo, ajuda, l
  * @param {(cmd:string)=>Promise<any>} op.aplicar   executa /claude ou /gpt
  */
 async function rodar({ perguntar, mostrar, cores: c, interativo = true,
-    conectado, conectar, sessao, aplicar } = {}) {
+    conectado, conectar, sessao, aplicar, selecionar, chaves = chavesModulo } = {}) {
 
     /* Sem terminal de verdade (pipe, script, CI) não se pergunta nada — uma
        pergunta onde ninguém pode responder trava o processo para sempre, e
@@ -166,6 +191,12 @@ async function rodar({ perguntar, mostrar, cores: c, interativo = true,
             mostrar(c.muted('  Tente de novo com ') + c.brand('/connect') + c.muted('.'));
             return { liberado: false, motivo: 'sem-login' };
         }
+        /* A MESMA FRASE DOS DOIS LADOS. A página mostra "✅ Autenticado,
+           redirecionando…" e some; quem estava olhando o navegador volta ao
+           terminal e precisa ver que o terminal soube — senão parece que a
+           aprovação ficou no site. */
+        mostrar('');
+        mostrar(c.ok('  ✅ Autenticado, redirecionando…'));
         credencial = conectado ? conectado() : { plano: r.plano };
     }
 
@@ -209,8 +240,9 @@ async function rodar({ perguntar, mostrar, cores: c, interativo = true,
     if (jaEscolheu()) return { liberado: true, motivo: 'ja-escolheu', plano, perguntou: false };
 
     const motor = await perguntarDaLista({
-        perguntar, mostrar, cores: c,
-        titulo: 'Com qual IA você quer trabalhar?',
+        perguntar, mostrar, cores: c, selecionar,
+        titulo: 'Como quer prosseguir?',
+        ajuda: 'Use as setinhas ↑↓ e Enter para confirmar — ou digite o número.',
         lista: MOTORES,
     });
 
@@ -222,21 +254,48 @@ async function rodar({ perguntar, mostrar, cores: c, interativo = true,
         return { liberado: true, motor: 'padrao', plano, perguntou: true };
     }
 
-    // ── 4. qual provedor ─────────────────────────────────────────────────
+    // ── 4. qual IA ───────────────────────────────────────────────────────
+    const propria = motor === 'propria';
     const qual = await perguntarDaLista({
-        perguntar, mostrar, cores: c,
-        titulo: 'Qual conta?',
-        ajuda: 'Ele usa o programa que você já tem instalado e logado.',
+        perguntar, mostrar, cores: c, selecionar,
+        titulo: propria ? 'De qual IA é a sua chave?' : 'Qual IA já configurada?',
+        ajuda: propria
+            ? 'A chave fica só nesta máquina, em ~/.primocode/chaves.json.'
+            : 'Ele usa o programa que você já tem instalado e logado.',
         lista: PROVEDORES,
     });
     const escolhido = PROVEDORES.find((p) => p.id === qual) || PROVEDORES[0];
 
-    marcar({ motor: escolhido.id, plano });
+    /* ── A CHAVE PRÓPRIA ─────────────────────────────────────────────────
+     * Só neste caminho se pede chave. Quem escolheu "já configurada" não tem
+     * chave para colar — a dele está no programa em que já entrou, e pedir
+     * uma ali seria inventar um passo que não existe.
+     *
+     * Chave recusada (colou a do outro provedor, veio truncada) NÃO trava a
+     * abertura: diz o que houve, guarda a escolha do motor e segue. O motor
+     * roda com o login que a pessoa já tem, e `/chave` conserta depois. */
+    if (propria && perguntar) {
+        const p = chaves.PROVEDORES[escolhido.chave] || {};
+        mostrar('');
+        mostrar(c.muted(`  Cole a chave do ${escolhido.titulo}`)
+            + c.dim(p.onde ? ` (pegue em ${p.onde})` : '') + c.muted('.'));
+        mostrar(c.dim('  Enter em branco pula: dá para configurar depois com ')
+            + c.brand('/chave ' + escolhido.chave) + c.dim('.'));
+        const colada = String(await perguntar(c.brand('  ❯ ')) || '').trim();
+        if (colada) {
+            const g = chaves.guardar(escolhido.chave, colada);
+            mostrar(g.ok
+                ? c.ok(`  Chave do ${g.nome} guardada.`) + c.muted(`  ${g.disfarce}`)
+                : c.err(`  ${g.error}`));
+        }
+    }
+
+    marcar({ motor: escolhido.id, origem: motor, plano });
     mostrar('');
     if (aplicar) await aplicar(escolhido.comando);
     mostrar('');
-    return { liberado: true, motor: escolhido.id, comando: escolhido.comando,
-        plano, perguntou: true };
+    return { liberado: true, motor: escolhido.id, origem: motor,
+        comando: escolhido.comando, plano, perguntou: true };
 }
 
 module.exports = {

package/lib/catalogo.js

@@ -89,6 +89,22 @@ const GRUPOS = [
             { tool: 'studio_listar',    escreve: false, faz: 'lista o que já existe no estúdio', args: null },
             { tool: 'studio_midia',     escreve: false, faz: 'manda imagem, música ou vídeo seu para usar nas peças',
               args: 'arquivo (opcional): caminho no projeto — sem ele, lista a galeria. nome (opcional).' },
+            { tool: 'midia_procurar',  escreve: false, faz: 'procura imagem, logo ou música na internet, com licença e crédito',
+              args: 'consulta: o que procurar, específico ("painel solar em telhado residencial", não "imagem legal"). '
+                + 'tipo (opcional): imagem | logo | musica (padrão imagem). quantos (opcional, padrão 6). '
+                + 'Para MÚSICA e EFEITO prefira buscar_audio, que já baixa, manda para o estúdio e devolve o crédito; '
+                + 'para a logo de uma EMPRESA prefira marca_da_empresa, que traz também cor, paleta e fontes do site dela. '
+                + 'orientacao (opcional): paisagem | retrato | quadrado. '
+                + 'Logo vem do Wikimedia Commons (SVG de verdade da marca); foto e música do Openverse (licença aberta); '
+                + 'com PRIMOCODE_GOOGLE_KEY e PRIMOCODE_GOOGLE_CX configurados, entra também a busca de imagens do Google. '
+                + 'Devolve a lista com url, autor e licença — escolha UMA e chame midia_baixar.' },
+            { tool: 'midia_baixar',    escreve: false, faz: 'baixa o que foi encontrado e já deixa disponível para as peças',
+              args: 'url: a url do resultado de midia_procurar. titulo (opcional). semFundo (opcional): true recorta o fundo da imagem. '
+                + 'paraEstudio (opcional, padrão true): também manda para a galeria do estúdio e devolve o "/midia/..." para usar em src e fundo. '
+                + 'A licença fica gravada junto do arquivo; midia_creditos monta a lista para a cena final.' },
+            { tool: 'midia_sem_fundo', escreve: false, faz: 'recorta o fundo de uma imagem que já está na máquina',
+              args: 'arquivo: caminho da imagem. destino (opcional). Usa rembg quando existe; sem ele, só fundo de cor chapada (avisa na resposta).' },
+            { tool: 'midia_creditos',  escreve: false, faz: 'lista os créditos do que foi baixado, prontos para a cena final ou a descrição', args: null },
             { tool: 'remotion_projeto', escreve: true, faz: 'transforma uma peça do estúdio em projeto Remotion (React) na pasta do usuário',
               args: 'id da peça. pasta (opcional): nome da pasta. fps (opcional, padrão 30). renderizar: true só se o npm install já foi feito. '
                 + 'Use SÓ quando o usuário pedir Remotion pelo nome, ou quando precisar de render determinístico, vídeo longo, codec/fps específico ou o projeto em React. '
@@ -164,6 +180,14 @@ const GRUPOS = [
               args: 'pedido: o que o usuário quer, com as palavras dele. pasta (opcional): onde construir — sem ela, uma pasta nova com o nome do pedido. rodadas (opcional, 1 a 4, padrão 2): quantas voltas de correção. '
                 + 'USE quando pedirem um app, um site, uma página ou uma ferramenta INTEIRA, do zero. NÃO use para mexer no que já existe, para um arquivo só, nem para conserto: são seis a oito chamadas de agente, '
                 + 'e gastá-las para trocar a cor de um botão come o dia do usuário. O revisor ABRE a página num navegador invisível e mede — página em branco e erro de JavaScript reprovam sozinhos, o que ele achar volta para o construtor.' },
+            { tool: 'planejar_producao', escreve: false, noLoop: true,
+              faz: 'ativa o DIRETOR: roteiro, narração cena a cena, voz, movimento, mídia a buscar e trilha — a estrutura ANTES de produzir',
+              args: 'pedido: o que o usuário quer, com as palavras dele. segundos (opcional, padrão 30): duração alvo. '
+                + 'formato (opcional): video | apresentacao. contexto (opcional): o que já se sabe (marca, público, dados).\n'
+                + 'USE SEMPRE antes de criar vídeo, reels, teaser, animação ou apresentação com narração — inclusive quando o pedido parecer simples. '
+                + 'Devolve uma PAUTA: produza exatamente o que ela diz (não invente cena, não troque a ordem, não reescreva a narração), '
+                + 'buscando a mídia com midia_procurar + midia_baixar e montando com studio_criar (corte/prisma). '
+                + 'NÃO use para ajustar peça existente nem quando o usuário pediu só o roteiro em texto.' },
             { tool: 'finish',      escreve: false, faz: 'encerra dizendo o que fez', noLoop: true,
               args: 'summary (opcional): uma frase do que foi feito.' },
         ],

package/lib/conta.js

@@ -38,6 +38,26 @@ const CONECTA = process.env.PRIMOCODE_CONTA_SERVER || 'https://conecta-primo-api
 
 const ARQUIVO = path.join(os.homedir(), '.primocode', 'conta.json');
 
+/* ── ONDE O LOGIN ABRE ───────────────────────────────────────────────────
+ *
+ *   "Abre conecta-primo-ai.vercel.app/token do PrimoCode: abre o login normal
+ *    do app, mas com o token do PrimoCode. Aí o site se comunica com o
+ *    terminal."
+ *
+ * A página do token é do SITE, não da API. O servidor devolve a URL dele —
+ * que num ambiente antigo pode apontar para outra origem ou para outro
+ * caminho — e aqui ela é normalizada para o endereço acima, preservando o que
+ * vier na query (é ali que vai o código do pareamento, quando vai).
+ * `PRIMOCODE_SITE` troca a origem para rodar contra uma prévia local. */
+const SITE = (process.env.PRIMOCODE_SITE || 'https://conecta-primo-ai.vercel.app').replace(/\/+$/, '');
+const PAGINA_TOKEN = '/token';
+
+function paginaDeLogin(urlDoServidor) {
+    let query = '';
+    try { query = new URL(urlDoServidor).search; } catch { /* sem url utilizável: só a página */ }
+    return SITE + PAGINA_TOKEN + query;
+}
+
 // Os planos que liberam tudo. A lista é a MESMA do servidor
 // (`PLANOS_COM_PRO`), e quem decide de verdade é ele: isto aqui só evita uma
 // ida à rede para mostrar o selo na abertura.
@@ -201,11 +221,11 @@ async function entrar({ abrir, contar = () => {}, minutos = 5 } = {}) {
     }
 
     let origemDoSite = null;
-    try { origemDoSite = new URL(pedido.url).origin; } catch { /* url estranha: sem CORS para ela */ }
+    try { origemDoSite = new URL(paginaDeLogin(pedido.url)).origin; } catch { /* url estranha: sem CORS para ela */ }
     const local = await servirPareamento(pedido.codigo, origemDoSite);
     const copiado = await area.copiar(pedido.codigo);
 
-    let url = pedido.url;
+    let url = paginaDeLogin(pedido.url);
     if (local.porta) url += (url.includes('?') ? '&' : '?') + 'porta=' + local.porta;
 
     contar({ url, codigo: pedido.codigo, copiado: copiado.ok, porta: local.porta });
@@ -287,4 +307,5 @@ function versao() {
     try { return require('../package.json').version; } catch { return '?'; }
 }
 
-module.exports = { entrar, sair, atual, sessao, dispositivos, servirPareamento, ARQUIVO, CONECTA, PLANOS_PRO, PORTA_PAREAMENTO };
+module.exports = { entrar, sair, atual, sessao, dispositivos, servirPareamento, paginaDeLogin,
+    ARQUIVO, CONECTA, SITE, PAGINA_TOKEN, PLANOS_PRO, PORTA_PAREAMENTO };

package/lib/diretor.js

@@ -0,0 +1,309 @@
+/**
+ * diretor.js — o agente que ESTRUTURA antes de alguém produzir.
+ *
+ *   "Tenha uma IA específica pra roteiro que monta tudo: narração, qual voz,
+ *    roteiro, etc. Ela estrutura tudo antes de mandar pra IA. Funciona assim:
+ *    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."
+ *
+ * ── POR QUE UM PAPEL SEPARADO, E NÃO UM PARÁGRAFO NO PROMPT ──────────────
+ * É o mesmo motivo do pipeline.js: o modelo que está montando as cenas já
+ * gastou a atenção dele em JSON — fonte, cor, duração, layout — e é ali que o
+ * roteiro morre. Vira legenda do que aparece na tela ("Vantagens", "Nossos
+ * serviços"), sem arco, sem narração escrita, sem decisão de voz. O diretor
+ * roda numa conversa PRÓPRIA, sem ver JSON nenhum, e só decide: o que se
+ * conta, em que ordem, em quantos segundos, com que voz, com quais imagens e
+ * qual música. Depois disso o produtor tem pouco a inventar — e inventar é
+ * justamente onde ele erra.
+ *
+ * ── O PLANO É UM CONTRATO, NÃO UM TEXTO BONITO ───────────────────────────
+ * A saída do diretor é JSON com forma conhecida, e este módulo NORMALIZA e
+ * CONFERE o que voltou: duração que fecha, narração em toda cena, keyframes
+ * onde faz sentido, lista de mídia a buscar. Um plano que não fecha volta ao
+ * diretor com o defeito apontado — uma vez. Aceitar "quase certo" aqui custa
+ * um vídeo de 40 segundos que dura 12.
+ *
+ * ── O MOTOR NÃO É GOSTO ──────────────────────────────────────────────────
+ * Estúdio ou Remotion: a escolha tem regra (`motorPara`), porque a resposta
+ * errada aparece tarde — no vídeo de três minutos que engasgou na gravação do
+ * navegador, ou nos cinco minutos de `npm install` para fazer um story de
+ * 15 segundos.
+ */
+
+'use strict';
+
+// ── 1. reconhecer que o pedido é de vídeo ────────────────────────────────
+
+const PEDE_VIDEO = /\b(v[ií]deo|reels?|tiktok|short|shorts|motion|anima[cç][aã]o|anima\b|teaser|trailer|comercial|propaganda|v[ií]nheta|vinheta|abertura|capcut|premiere|after\s*effects|aftereffects)\b/i;
+const PEDE_SLIDE = /\b(slide|slides|deck|apresenta[cç][aã]o|pitch|powerpoint|keynote|prisma)\b/i;
+const SO_TEXTO = /\b(roteiro apenas|s[oó] o roteiro|s[oó] o texto|sem v[ií]deo)\b/i;
+
+/**
+ * O pedido precisa de produção audiovisual? E de que tipo?
+ *
+ * Isto é o gatilho do agente: o CLI pergunta aqui antes de deixar o produtor
+ * começar. Pedir "só o roteiro" NÃO liga a produção — quem pediu texto quer
+ * texto, e devolver um mp4 é ignorar a pessoa.
+ */
+function precisaDeProducao(texto) {
+    const t = String(texto || '');
+    if (!t.trim()) return { producao: false };
+    if (SO_TEXTO.test(t)) return { producao: false, motivo: 'pediu só o texto' };
+    if (PEDE_VIDEO.test(t)) return { producao: true, formato: 'video', motivo: 'o pedido é de vídeo' };
+    if (PEDE_SLIDE.test(t)) return { producao: true, formato: 'apresentacao', motivo: 'o pedido é de apresentação' };
+    return { producao: false };
+}
+
+// ── 2. as decisões que não são do modelo ─────────────────────────────────
+
+/**
+ * Estúdio ou Remotion.
+ *
+ * O estúdio exporta em segundos e não instala nada: é o padrão, e para story,
+ * reels e teaser é a resposta certa. Remotion custa um `npm install` de
+ * minutos e meio giga, e devolve o que o estúdio não tem: quadro a quadro
+ * determinístico, vídeo longo sem risco de engasgo, canal alfa e ProRes.
+ */
+function motorPara({ segundos = 0, pedido = '', alfa = false, fps = 30, entrega } = {}) {
+    const t = String(pedido).toLowerCase();
+    if (/remotion/.test(t)) return { motor: 'remotion', motivo: 'foi pedido pelo nome' };
+    if (/(est[uú]dio|studio|r[aá]pido|agora|j[aá])\b/.test(t) && segundos <= 60) {
+        return { motor: 'estudio', motivo: 'pedido rápido e curto' };
+    }
+    if (alfa || /alfa|transpar[eê]nci|prores|canal alfa/.test(t)) {
+        return { motor: 'remotion', motivo: 'canal alfa e ProRes só existem no Remotion' };
+    }
+    if (entrega === 'cinema' || fps > 30) {
+        return { motor: 'remotion', motivo: 'fps alto pede render determinístico' };
+    }
+    if (segundos > 90) {
+        return { motor: 'remotion', motivo: 'vídeo longo: a gravação do navegador engasga' };
+    }
+    return { motor: 'estudio', motivo: 'curto: sai em segundos, sem instalar nada' };
+}
+
+/**
+ * A voz. Tom e idioma decidem; o nome exato quem resolve é o estúdio, que
+ * sabe o que está instalado — aqui sai a INTENÇÃO, que é o que o diretor
+ * precisa escrever no plano.
+ */
+function vozPara({ tom = 'neutro', idioma = 'pt-BR', genero } = {}) {
+    const t = String(tom).toLowerCase();
+    const perfil = /urgente|energ|hype|an[uú]ncio|venda/.test(t) ? 'energica'
+        : /calm|institucional|corporativ|s[eé]ri/.test(t) ? 'firme'
+            : /doc|narrativ|hist[oó]ria|documental/.test(t) ? 'grave'
+                : /leve|simp[aá]tic|amig|casual/.test(t) ? 'proxima'
+                    : 'neutra';
+    const ritmo = perfil === 'energica' ? 1.08 : perfil === 'grave' ? 0.94 : 1;
+    return { perfil, idioma, genero: genero || 'indiferente', ritmo,
+        instrucao: {
+            energica: 'projeção alta, frases curtas, corte seco entre elas',
+            firme: 'ritmo constante, sem exagero, pausa depois do número',
+            grave: 'grave e pausada, respira entre as frases',
+            proxima: 'como quem conversa, sorriso na voz',
+            neutra: 'clara e neutra, sem cor demais',
+        }[perfil] };
+}
+
+/** Quantas cenas cabem, e de que tamanho, num vídeo desta duração. */
+function ritmoPara(segundos) {
+    const s = Math.max(5, Number(segundos) || 30);
+    const media = s <= 20 ? 2.6 : s <= 45 ? 3.4 : s <= 90 ? 4.2 : 5;
+    return { cenas: Math.max(3, Math.round(s / media)), duracaoMedia: media,
+        palavrasPorCena: Math.round(media * 2.6) };   // ~155 palavras/minuto de narração
+}
+
+// ── 3. o plano ───────────────────────────────────────────────────────────
+
+const CAMPOS_CENA = ['titulo', 'narracao', 'duracao', 'layout', 'fundo', 'transicao',
+    'elementos', 'midia', 'camera', 'chaves', 'notas'];
+
+/**
+ * Normaliza o que o diretor devolveu e aponta o que ficou faltando.
+ *
+ * Não conserta conteúdo — conteúdo é dele. Conserta FORMA: duração que virou
+ * string, cena sem transição, o total que não fecha com o pedido. E lista os
+ * defeitos que só o diretor resolve (cena muda, narração vazia), para voltar
+ * com o apontamento em vez de seguir com o plano torto.
+ */
+function normalizarPlano(bruto, { segundos } = {}) {
+    const p = bruto && typeof bruto === 'object' ? bruto : {};
+    const defeitos = [];
+    const cenas = Array.isArray(p.cenas) ? p.cenas : [];
+    if (!cenas.length) defeitos.push('o plano veio sem cenas');
+
+    const TRANSICOES = ['corte', 'fade', 'deslizar', 'subir', 'zoom', 'limpar', 'persiana', 'flash'];
+    const limpas = cenas.map((c, i) => {
+        const cena = {};
+        for (const k of CAMPOS_CENA) if (c && c[k] !== undefined) cena[k] = c[k];
+        cena.duracao = Math.max(1.2, Math.min(15, Number(cena.duracao) || 3.5));
+        cena.narracao = typeof cena.narracao === 'string' ? cena.narracao.trim() : '';
+        if (!cena.narracao) defeitos.push(`cena ${i + 1} sem narração`);
+        if (!cena.titulo && !cena.elementos) defeitos.push(`cena ${i + 1} sem nada na tela`);
+        // Tudo em fade parece slide, não vídeo — e o diretor esquece disso.
+        if (!TRANSICOES.includes(cena.transicao)) cena.transicao = i === 0 ? 'fade' : TRANSICOES[(i % 6) + 1];
+        cena.midia = Array.isArray(cena.midia) ? cena.midia.filter((m) => m && m.busca) : [];
+        return cena;
+    });
+
+    const total = Math.round(limpas.reduce((s, c) => s + c.duracao, 0) * 10) / 10;
+    const alvo = Number(segundos) || Number(p.segundos) || total;
+    // 20% de folga: o alvo é intenção, não cronômetro. Fora disso o vídeo
+    // entrega outra coisa — 12 segundos onde pediram 40.
+    const fecha = !alvo || Math.abs(total - alvo) <= Math.max(3, alvo * 0.2);
+    if (!fecha) defeitos.push(`a soma das cenas dá ${total}s e o pedido é ${alvo}s`);
+
+    const plano = {
+        titulo: String(p.titulo || '').trim() || 'Sem título',
+        formato: p.formato === 'apresentacao' ? 'apresentacao' : 'video',
+        proporcao: ['16:9', '9:16', '1:1', '4:5'].includes(p.proporcao) ? p.proporcao : '16:9',
+        tema: p.tema || 'meia-noite',
+        tom: p.tom || 'neutro',
+        publico: p.publico || null,
+        promessa: p.promessa || null,          // o que a pessoa leva do vídeo
+        segundos: total,
+        voz: vozPara({ tom: p.tom, idioma: p.idioma || 'pt-BR',
+            genero: p.voz && p.voz.genero }),
+        trilha: p.trilha && (p.trilha.busca || p.trilha.arquivo)
+            ? { busca: p.trilha.busca || null, arquivo: p.trilha.arquivo || null,
+                volume: Number(p.trilha.volume) || 0.18, humor: p.trilha.humor || p.tom || null }
+            : null,
+        cenas: limpas,
+        midia: limpas.flatMap((c, i) => c.midia.map((m) => ({ cena: i + 1, ...m }))),
+        creditos: !!p.creditos,
+    };
+    plano.motor = motorPara({ segundos: total, pedido: p.pedido || '', alfa: !!p.alfa,
+        fps: Number(p.fps) || 30 });
+    return { plano, defeitos, ok: defeitos.length === 0 };
+}
+
+// ── 4. o prompt do diretor ───────────────────────────────────────────────
+
+const DIRETOR = (pedido, { segundos = 30, formato = 'video', contexto = '' } = {}) => {
+    const r = ritmoPara(segundos);
+    return `Você é o DIRETOR de conteúdo. Você NÃO produz nada: você ESTRUTURA, e outra IA produz a partir do que você escrever. Não escreva código, não escreva JSON de cena de ferramenta, não chame ferramenta nenhuma.
+
+PEDIDO: ${pedido}
+${contexto ? `CONTEXTO: ${contexto}\n` : ''}FORMATO: ${formato} · DURAÇÃO ALVO: ${segundos}s · RITMO: ~${r.cenas} cenas de ~${r.duracaoMedia}s (~${r.palavrasPorCena} palavras de narração por cena)
+
+Devolva SÓ um bloco \`\`\`json com este formato, sem texto antes nem depois:
+
+{
+  "titulo": "…",
+  "formato": "${formato}",
+  "proporcao": "16:9 | 9:16 | 1:1 | 4:5",
+  "tema": "meia-noite | claro | papel | neon | brasa | floresta",
+  "tom": "como deve soar (institucional, urgente, documental, leve…)",
+  "publico": "para quem é",
+  "promessa": "o que a pessoa leva ao terminar de ver",
+  "trilha": { "busca": "termo de busca da música", "humor": "…", "volume": 0.18 },
+  "cenas": [
+    {
+      "titulo": "o que aparece grande na tela",
+      "narracao": "a frase FALADA, escrita para ser lida em voz alta",
+      "duracao": 3.5,
+      "layout": "capa | titulo | secao | duas-colunas | numeros | citacao | imagem-direita | centro | livre",
+      "fundo": "malha | aurora | raios | ondas | nevoa | vinheta, uma cor, ou {\\"imagem\\":\\"<da lista midia>\\"}",
+      "transicao": "corte | fade | deslizar | subir | zoom | limpar | persiana | flash",
+      "midia": [ { "busca": "o que procurar", "tipo": "imagem | logo", "papel": "fundo | destaque | selo", "semFundo": false } ],
+      "camera": "aproximar | afastar | pan-direita | pan-esquerda | subir | descer | empurrar | balanco | nenhuma",
+      "chaves": "descreva em uma frase o movimento principal desta cena (o que entra, o que atravessa, o que cresce)",
+      "notas": "o que o produtor precisa saber e não está acima"
+    }
+  ]
+}
+
+REGRAS QUE SEPARAM UM VÍDEO BOM DE UM GENÉRICO:
+1. NARRAÇÃO É FALA, NÃO LEGENDA. "Vantagens" não é narração. Escreva a frase que a pessoa ouve.
+2. O QUE SE OUVE E O QUE SE VÊ NÃO SE REPETEM. A tela mostra a prova (número, imagem, logo); a voz conta o que ela significa.
+3. ARCO. Primeira cena prende em 2 segundos, o miolo entrega, a última pede uma ação. Sem "Introdução / Desenvolvimento / Conclusão".
+4. NÚMERO É CONCRETO. Nada de "muitos clientes": ou tem o número, ou a frase muda.
+5. RITMO VARIADO. Cenas de durações diferentes e transições diferentes. Tudo em fade parece slide.
+6. MÍDIA COM PROPÓSITO. Só peça imagem ou logo quando ela PROVA algo. Diga o termo de busca de verdade ("painel solar em telhado residencial", não "imagem legal").
+7. MOVIMENTO. Em cada cena diga em "chaves" o movimento principal — é ele que tira a cara de apresentação parada.
+8. CÂMERA COM PARCIMÔNIA. Movimento de quadro em UMA cena a cada duas ou três ("camera": "nenhuma" nas outras): o que dá ritmo é alternar cena parada e cena que se move. Em cena com foto de fundo, prefira "aproximar" ou "empurrar".`;
+};
+
+const REVISAO = (defeitos) => `O plano voltou com defeitos de FORMA. Corrija SÓ o que está listado e devolva o JSON inteiro de novo, no mesmo formato:
+
+${defeitos.map((d) => '- ' + d).join('\n')}
+
+Nada de explicação: só o bloco \`\`\`json.`;
+
+/** Tira o JSON do que o modelo escreveu, com ou sem cerca. */
+function extrairJSON(texto) {
+    const t = String(texto || '');
+    const cerca = t.match(/```(?:json)?\s*([\s\S]*?)```/i);
+    const cru = cerca ? cerca[1] : t.slice(t.indexOf('{'), t.lastIndexOf('}') + 1);
+    try { return JSON.parse(cru); } catch { /* tenta limpar vírgula sobrando */ }
+    try { return JSON.parse(String(cru).replace(/,\s*([}\]])/g, '$1')); } catch { return null; }
+}
+
+/**
+ * Roda o diretor: uma conversa própria, o plano de volta, conferido, e uma
+ * segunda chance quando a forma não fecha.
+ *
+ * @param {object} op
+ * @param {string} op.pedido
+ * @param {(prompt:string, papel:string)=>Promise<string>} op.correr  uma conversa NOVA
+ * @param {number} [op.segundos]
+ * @param {(s:string)=>void} [op.mostrar]
+ */
+async function planejar({ pedido, correr, segundos = 30, formato = 'video',
+    contexto = '', mostrar = () => {} } = {}) {
+    if (!pedido) return { ok: false, error: 'Diga o que produzir.' };
+    if (typeof correr !== 'function') return { ok: false, error: 'sem quem rode o diretor' };
+
+    mostrar('diretor — roteiro, narração e voz');
+    let bruto = extrairJSON(await correr(DIRETOR(pedido, { segundos, formato, contexto }), 'diretor'));
+    if (!bruto) return { ok: false, error: 'o diretor não devolveu um plano legível' };
+
+    let { plano, defeitos, ok } = normalizarPlano({ ...bruto, pedido }, { segundos });
+    if (!ok) {
+        mostrar('diretor — corrigindo o plano');
+        const segunda = extrairJSON(await correr(REVISAO(defeitos), 'diretor (revisão)'));
+        if (segunda) {
+            const r2 = normalizarPlano({ ...segunda, pedido }, { segundos });
+            // Fica com o melhor dos dois: a segunda volta só vale se corrigiu.
+            if (r2.defeitos.length <= defeitos.length) ({ plano, defeitos, ok } = r2);
+        }
+    }
+    return { ok: true, plano, defeitos, aprovado: defeitos.length === 0 };
+}
+
+/**
+ * O plano vira a PAUTA do produtor — o texto que a IA de produção recebe no
+ * lugar do pedido cru. Ela não precisa mais decidir o que contar: só montar.
+ */
+function pauta(plano) {
+    const p = plano || {};
+    const linhas = [];
+    linhas.push(`PLANO DE PRODUÇÃO — ${p.titulo}`);
+    linhas.push(`formato ${p.formato} · ${p.proporcao} · ${p.segundos}s · tema ${p.tema} · tom ${p.tom}`);
+    linhas.push(`motor: ${p.motor && p.motor.motor} (${p.motor && p.motor.motivo})`);
+    if (p.promessa) linhas.push(`promessa: ${p.promessa}`);
+    if (p.publico) linhas.push(`público: ${p.publico}`);
+    linhas.push(`voz: ${p.voz && p.voz.perfil} · ${p.voz && p.voz.instrucao} · ${p.voz && p.voz.idioma}`);
+    if (p.trilha) linhas.push(`trilha: ${p.trilha.busca || p.trilha.arquivo} (volume ${p.trilha.volume})`);
+    linhas.push('');
+    (p.cenas || []).forEach((c, i) => {
+        linhas.push(`CENA ${i + 1} — ${c.duracao}s · layout ${c.layout || 'titulo'} · entra em ${c.transicao}`);
+        if (c.titulo) linhas.push(`  na tela: ${c.titulo}`);
+        linhas.push(`  narração: ${c.narracao}`);
+        if (c.camera && c.camera !== 'nenhuma') linhas.push(`  câmera: ${c.camera}`);
+        if (c.chaves) linhas.push(`  movimento: ${c.chaves}`);
+        (c.midia || []).forEach((m) => linhas.push(
+            `  mídia: ${m.tipo || 'imagem'} "${m.busca}" como ${m.papel || 'destaque'}${m.semFundo ? ' (sem fundo)' : ''}`));
+        if (c.notas) linhas.push(`  nota: ${c.notas}`);
+        linhas.push('');
+    });
+    linhas.push('Produza EXATAMENTE este plano. As decisões de conteúdo já foram tomadas:');
+    linhas.push('não invente cena, não troque a ordem, não reescreva a narração.');
+    return linhas.join('\n');
+}
+
+module.exports = {
+    precisaDeProducao, motorPara, vozPara, ritmoPara,
+    normalizarPlano, extrairJSON, planejar, pauta,
+    DIRETOR, REVISAO,
+};

package/lib/tools.js

@@ -15,6 +15,7 @@ const browser = require('./browser');
 const desktop = require('./desktop');
 const referencia = require('./referencia');
 const studio = require('./studio');
+const acervo = require('./acervo');
 const cfg = require('./config');
 
 const IGNORAR = new Set(['node_modules', '.git', 'dist', 'build', '.next', 'coverage', '.cache', 'vendor']);
@@ -580,6 +581,48 @@ async function despachar(name, args, ctx) {
                 return args.arquivo
                     ? studio.midiaEnviar({ arquivo: resolveInProject(args.arquivo, projectDir), nome: args.nome })
                     : studio.midiaListar();
+            /* ── MÍDIA DE VERDADE, VINDA DA INTERNET ──────────────────
+             *
+             * Buscar, baixar, recortar o fundo e já deixar na galeria do
+             * estúdio. O caminho inteiro é uma tool só do ponto de vista do
+             * agente (procurar → baixar), e o `paraEstudio` é o que evita a
+             * volta clássica: baixar num canto do disco e depois descobrir
+             * que a cena precisa de uma URL "/midia/...".
+             *
+             * A licença desce junto e fica gravada ao lado do arquivo. Um
+             * vídeo de cliente com foto CC BY sem crédito é problema do
+             * cliente, e descobrir isso depois de publicar é tarde. */
+            case 'midia_procurar':
+                return acervo.procurar(args.consulta || args.q || '', {
+                    tipo: args.tipo, quantos: args.quantos, orientacao: args.orientacao,
+                    licenca: args.licenca,
+                });
+            case 'midia_baixar': {
+                const r = await acervo.baixar(args.url, { titulo: args.titulo, meta: {
+                    autor: args.autor || null, licenca: args.licenca || null,
+                    fonte: args.fonte || null, pagina: args.pagina || null,
+                } });
+                if (!r.ok) return r;
+                let arquivo = r.arquivo;
+                if (args.semFundo) {
+                    const corte = await acervo.tirarFundo(arquivo);
+                    if (corte.ok) { arquivo = corte.arquivo; r.recorte = corte.metodo; r.avisoRecorte = corte.aviso; }
+                    else r.avisoRecorte = corte.error;
+                }
+                r.arquivo = arquivo;
+                if (args.paraEstudio !== false) {
+                    const g = await studio.midiaEnviar({ arquivo, nome: args.nome });
+                    // O "/midia/..." é o que vai em `src` e em `fundo.imagem`.
+                    if (g && g.ok !== false) r.src = g.url || g.src || null;
+                    else r.avisoGaleria = (g && g.error) || 'não deu para mandar para a galeria';
+                }
+                return r;
+            }
+            case 'midia_sem_fundo':
+                return acervo.tirarFundo(resolveInProject(args.arquivo, projectDir), { destino: args.destino });
+            case 'midia_creditos':
+                return { ok: true, creditos: acervo.creditos() };
+
             case 'studio_analisar': {
                 // Ouvir o vídeo para achar as pausas. A conta acontece num
                 // navegador (é quem sabe decodificar MP4 sem instalar nada) —