primocode 8.38.0 → 8.39.0

package/app/app.js

@@ -316,12 +316,16 @@
     marcarEscolha("cores", "cor", cor);
   }
 
+  /* A LOGO — a mesma do ícone do sistema e da barra lateral do Conecta. Onde
+     o produto se apresenta vai ela; o mascote em pixel fica para onde ele é
+     personagem. */
   function desenharMarca() {
     if (!window.PrimoMarca) return;
     var t = document.getElementById("marcaTopo");
     var g = document.getElementById("marcaGrande");
-    if (t) t.innerHTML = window.PrimoMarca.svg({ tamanho: 22 });
-    if (g) g.innerHTML = window.PrimoMarca.svg({ tamanho: 82, rotulo: "PrimoCode" });
+    var desenha = window.PrimoMarca.logo || window.PrimoMarca.svg;
+    if (t) t.innerHTML = desenha({ tamanho: 22 });
+    if (g) g.innerHTML = desenha({ tamanho: 82, rotulo: "PrimoCode" });
   }
 
   function quando(iso) {

package/app/primo-marca.js

@@ -1,12 +1,6 @@
 /**
  * primo-marca.js — o mascote do PrimoCode, desenhado em pixel.
  *
- * CÓPIA de conecta-primo-ai/frontend/primo-marca.js. São repositórios
- * diferentes e não há como importar de um para o outro; o que dá para fazer é
- * manter os dois IDÊNTICOS e o teste conferir isso — um mascote que muda num
- * lado e não no outro é a marca do produto se partindo em duas sem ninguém
- * ver.
- *
  * ── POR QUE MATRIZ, E NÃO O PNG ──────────────────────────────────────────
  * O logo veio como imagem. Guardar o PNG funcionaria, mas ele já é pixel art:
  * redesenhá-lo como MATRIZ dá o mesmo desenho nítido em qualquer tamanho —
@@ -103,11 +97,39 @@
       + '" height="' + lado + '"' + acessivel + ">" + partes.join("") + "</svg>";
   }
 
-  /** O mesmo bicho como favicon, sem pedir arquivo ao servidor. */
+  /* A LOGO — a que o dono mandou, e a mesma do ícone do sistema
+     (`app/icone.svg` no PrimoCode): quadrado escuro arredondado, o chevron do
+     prompt e o sublinhado do cursor, em ciano. Onde o produto se apresenta
+     (botão da barra lateral, cabeçalho, favicon) vai ELA; o mascote em pixel
+     acima fica para onde ele é personagem, não marca. Foi por confundir os
+     dois que a barra lateral mostrou o bicho onde devia estar a logo. */
+  var LOGO_FUNDO = "#0a0f16";
+  var LOGO_TRACO = "#22d3ee";
+
+  /**
+   * A logo como SVG.
+   * @param {object} op
+   * @param {number} [op.tamanho]  lado em px
+   * @param {string} [op.rotulo]   texto alternativo; vazio = decorativo
+   */
+  function logo(op) {
+    op = op || {};
+    var lado = op.tamanho || 32;
+    var acessivel = op.rotulo
+      ? ' role="img" aria-label="' + String(op.rotulo).replace(/"/g, "&quot;") + '"'
+      : ' aria-hidden="true"';
+    return '<svg viewBox="0 0 32 32" width="' + lado + '" height="' + lado + '"' + acessivel + ">"
+      + '<rect width="32" height="32" rx="7" fill="' + LOGO_FUNDO + '"/>'
+      + '<path d="M8 10.5 13 16l-5 5.5" fill="none" stroke="' + LOGO_TRACO
+      + '" stroke-width="2.6" stroke-linecap="round" stroke-linejoin="round"/>'
+      + '<path d="M16.5 22H24" fill="none" stroke="' + LOGO_TRACO + '" stroke-width="2.6" stroke-linecap="round"/>'
+      + "</svg>";
+  }
+
+  /** A logo como favicon, sem pedir arquivo ao servidor. */
   function favicon() {
-    var s = svg({ tamanho: 32, fundo: "#0a0f16" });
-    return "data:image/svg+xml," + encodeURIComponent(s);
+    return "data:image/svg+xml," + encodeURIComponent(logo({ tamanho: 32 }));
   }
 
-  raiz.PrimoMarca = { svg: svg, favicon: favicon, MATRIZ: MATRIZ, CORPO: CORPO, DETALHE: DETALHE };
+  raiz.PrimoMarca = { svg: svg, logo: logo, favicon: favicon, MATRIZ: MATRIZ, CORPO: CORPO, DETALHE: DETALHE };
 })(typeof window !== "undefined" ? window : globalThis);

package/bin/primocode.js

@@ -1269,26 +1269,33 @@ async function handleSlash(text) {
                 abrir: (u) => tools.openInBrowser(u),
                 contar: (info) => {
                     sp.stop();
-                    /* O código continua aparecendo — grande, partido em dois,
-                       porque é o que se lê de uma tela e se confere noutra. Mas
-                       agora ele já FOI para a página: o CLI serve o código em
-                       127.0.0.1 e a página pergunta ali; e foi para a área de
-                       transferência, para o "Colar" de um toque onde o
-                       navegador bloqueia o 127.0.0.1 (Safari). Digitar virou a
-                       terceira saída, não a primeira. */
                     const meio = info.codigo.length === 8
                         ? info.codigo.slice(0, 4) + '-' + info.codigo.slice(4) : info.codigo;
                     console.log(c.muted('  Abrindo no navegador:'));
                     console.log('  ' + c.brand(info.url.replace(/[?&]porta=\d+/, '')));
                     console.log('');
-                    console.log('    ' + c.bold(c.brand(meio.split('').join(' '))));
-                    console.log('');
-                    const como = [];
-                    if (info.porta) como.push('a página preenche sozinha');
-                    if (info.copiado) como.push('e o código já está copiado');
-                    console.log(c.dim('  ' + (como.length ? como.join(', ').replace(/^e /, '') + '.'
-                        : 'Digite o código na página.')));
-                    console.log(c.dim('  Esperando você aprovar…'));
+                    if (info.porta) {
+                        /* COM O SERVIDOR LOCAL DE PÉ, NÃO HÁ CÓDIGO PARA LER. A
+                           página pergunta ao 127.0.0.1 desta máquina, recebe o
+                           código e aprova sozinha assim que a pessoa entra com a
+                           conta — "não precisa colocar código, não precisa pra
+                           nada, porque ele já libera". Mostrar as oito letras
+                           grandes aqui era pedir para ler o que ninguém precisa
+                           mais; elas ficam numa linha apagada, só para o caso
+                           de o navegador bloquear o 127.0.0.1 (Safari) e a
+                           página voltar a pedir. */
+                        console.log('  ' + c.white('Entre com a sua conta na página que abriu — o resto é automático.'));
+                        console.log(c.dim(`  Se a página pedir um código: ${meio}${info.copiado ? ' (já copiado)' : ''}.`));
+                    } else {
+                        /* Sem porta local (ocupadas, ou bloqueadas), o código
+                           volta a ser o caminho — grande, partido em dois,
+                           porque é o que se lê de uma tela e se confere noutra. */
+                        console.log('    ' + c.bold(c.brand(meio.split('').join(' '))));
+                        console.log('');
+                        console.log(c.dim('  ' + (info.copiado ? 'O código já está copiado — cole na página.'
+                            : 'Digite o código na página.')));
+                    }
+                    console.log(c.dim('  Esperando o navegador…'));
                 },
             });
             sp.stop();

package/lib/act.js

@@ -19,7 +19,13 @@ const cfg = require('./config');
 const catalogo = require('./catalogo');
 const repeticao = require('./repeticao');
 
-const MAX_ITERATIONS = 15;
+// 40, não 15: com o freio de repetição (repeticao.js) e o de rodada parada,
+// volta a mais não é volta em círculo — é trabalho. Quinze acabavam no meio
+// de um vídeo de dez cenas com pesquisa, e a pessoa lia "gastei as voltas".
+const MAX_ITERATIONS = Number(process.env.PRIMOCODE_MAX_VOLTAS || 40);
+// Quantas vezes o agente é EMPURRADO quando para no meio para narrar
+// ("agora vou criar o arquivo…") em vez de fazer. Ver `pareceParadaNoMeio`.
+const MAX_EMPURROES = 3;
 // Voltas seguidas sem executar nada antes de desistir.
 const MAX_RODADAS_PARADAS = 3;
 const MAX_PROFUNDIDADE = 2; // principal + 1 nível de subagente
@@ -182,6 +188,20 @@ function logResult(kind, result, profundidade) {
             }
             return;
         }
+        case 'buscar_audio': {
+            console.log(p + c.muted(`${result.tipo === 'efeito' ? 'efeito' : 'música'}: `) + c.white(`${result.titulo}`)
+                + c.muted(` — ${result.autor || 'autor desconhecido'}${result.duracao ? ` · ${result.duracao}s` : ''} · ${result.licenca}`));
+            console.log(p + c.dim(`${result.url}`));
+            return;
+        }
+        case 'marca_da_empresa': {
+            const cores = (result.cores && result.cores.paleta || []).slice(0, 4).join(' ');
+            console.log(p + c.white(result.nome || '') + c.muted(` · ${result.site || ''}`));
+            console.log(p + c.dim(`cor ${(result.cores && result.cores.principal) || '—'}${cores ? ` · paleta ${cores}` : ''}`
+                + `${(result.fontes || []).length ? ` · fonte ${result.fontes[0]}` : ''}`
+                + `${result.logo ? ` · logo ${result.logo.formato} (${result.logo.fonte})` : ' · sem logo'}`));
+            return;
+        }
         case 'desktop_windows': {
             console.log(p + c.muted(`${result.total} janela${result.total === 1 ? '' : 's'}`));
             for (const j of (result.janelas || []).slice(0, 5)) console.log(p + c.dim(`${j.app ? j.app + ' · ' : ''}${j.titulo}`.slice(0, 120)));
@@ -338,6 +358,39 @@ async function pausar(ms, subagent) {
     if (sp) sp.stop();
 }
 
+/**
+ * O modelo devolveu TEXTO, sem tool e sem finish. Isso é resposta — ou é o
+ * agente parando no meio para narrar o que ia fazer?
+ *
+ * Reclamação do dono: "ele tá parando sem concluir, ele deve continuar até o
+ * fim". Medido: o modelo escreve "Agora vou criar o vídeo com as cenas…" e
+ * para, porque texto sem tool encerra a rodada. Quem lê vê uma promessa no
+ * lugar da entrega. Três sinais dizem que foi parada, não resposta:
+ *
+ *   1. Há um plano (write_todos) com item por fazer — ele mesmo disse que
+ *      não acabou.
+ *   2. O texto é INTENÇÃO: começa ou termina anunciando o próximo passo
+ *      ("vou", "em seguida", "próximo passo", dois-pontos no fim, reticências).
+ *   3. É curto. Uma resposta de verdade a "explique este erro" tem corpo; um
+ *      "vou abrir o arquivo agora" não tem.
+ *
+ * Pergunta ao usuário NÃO conta como parada: o prompt proíbe perguntar, mas
+ * se o modelo perguntou, empurrá-lo faria ele decidir sozinho o que talvez
+ * não devesse — e o texto de conversa ("oi, sou o PrimoCode") também não é
+ * parada. Só intenção declarada e plano aberto.
+ */
+const INTENCAO = /(^|[.!\n]\s*)(agora\s+)?(vou|irei|deixa eu|deixe-me|preciso (agora )?(de )?(criar|ler|abrir|rodar|ver|conferir|pesquisar|mandar|fazer|gerar|escrever|ajustar)|primeiro (vou|eu)|em seguida|pr[óo]ximo passo|a seguir,?\s+(vou|eu)|vamos (criar|ler|abrir|rodar|ver|conferir|come[çc]ar|fazer|gerar|escrever))\b/i;
+function pareceParadaNoMeio(texto, { todosPendentes = 0, rodouTool = false } = {}) {
+    const t = String(texto || '').trim();
+    if (!t) return false;
+    if (todosPendentes > 0) return true;
+    if (t.length > 700) return false;                       // resposta com corpo
+    if (/\?\s*$/.test(t)) return false;                      // perguntou: não é parada
+    if (INTENCAO.test(t)) return true;
+    if (rodouTool && /[:…]\s*$|\.\.\.\s*$/.test(t)) return true;   // "Criando as cenas:" e nada depois
+    return false;
+}
+
 function motivoDaParada({ voltas, voltasEmFalso, falhasPendentes, travou }) {
     if (falhasPendentes.length) {
         return `Parei sem concluir. A última falha foi: ${falhasPendentes[falhasPendentes.length - 1].texto}`;
@@ -391,6 +444,13 @@ async function runAct(userPrompt, opts) {
     // assim que "crie um vídeo para a tostudy" morreu sem entregar nada.
     let pesquisasSecas = 0;
     let rodadasParadas = 0;
+    // Para o `pareceParadaNoMeio`: alguma tool já rodou nesta tarefa, e o
+    // último plano que o modelo escreveu (write_todos) — desta tarefa, não da
+    // sessão: um plano velho de um pedido interrompido não pode empurrar o
+    // pedido seguinte.
+    let rodouTool = false;
+    let todosDaTarefa = [];
+    let empurroes = 0;
 
     const messages = [];
     if (!subagent) {
@@ -579,6 +639,29 @@ async function runAct(userPrompt, opts) {
                 iteration--;
                 continue;
             }
+            // PAROU NO MEIO? Texto de intenção ("agora vou criar…") ou plano
+            // com item aberto não é entrega. Em vez de encerrar, a tarefa é
+            // devolvida: "isso foi uma promessa — faça". Três empurrões; se
+            // depois disso ele insistir em só falar, a resposta é dele.
+            const pendentes = todosDaTarefa.filter((t) => t.status !== 'completed').length;
+            if (finalText && empurroes < MAX_EMPURROES && !PARAR
+                && pareceParadaNoMeio(finalText, { todosPendentes: pendentes, rodouTool })) {
+                empurroes++;
+                if (!subagent) {
+                    if (fluxo) fluxo.fechar();
+                    else fala.pensamento(finalText, profundidade);
+                }
+                messages.push({ role: 'assistant', content: finalText });
+                messages.push({
+                    role: 'user',
+                    content: 'Isso foi uma intenção, não uma entrega: você parou no meio. Não narre o próximo '
+                        + 'passo — CHAME a tool agora e siga até o fim'
+                        + (pendentes ? `, o seu plano ainda tem ${pendentes} item(ns) por fazer` : '')
+                        + '. Só pare quando tudo estiver feito, com finish("o que foi feito").',
+                });
+                finalText = '';
+                continue;
+            }
             if (!subagent) {
                 if (fluxo) fluxo.fechar();
                 else fala.resposta(finalText);
@@ -711,9 +794,11 @@ async function runAct(userPrompt, opts) {
             }
 
             algoRodou = true;
+            rodouTool = true;
             fala.acao(tc.name, tc.arguments, profundidade);
             const result = await tools.execute(tc.name, tc.arguments, { projectDir: pastaAtual });
             logResult(tc.name, result, profundidade);
+            if (tc.name === 'write_todos' && result && Array.isArray(result.todos)) todosDaTarefa = result.todos;
 
             // Uma escrita bem-sucedida limpa a dívida — mas só a do MESMO
             // arquivo. Escrever algo sem relação (ou um run_shell qualquer)
@@ -910,4 +995,4 @@ async function rodarPipeline(args, ctx) {
 }
 
 module.exports = { runAct, interromper, compactar, motivoDaParada, ehTetoDeToken, ehTransitorio, esperaDoErro,
-    anotacaoDoQueJaFoi, encolherParaContinuar, MAX_ITERATIONS };
+    anotacaoDoQueJaFoi, encolherParaContinuar, pareceParadaNoMeio, MAX_ITERATIONS, MAX_EMPURROES };

package/lib/audio-livre.js

@@ -0,0 +1,172 @@
+/**
+ * audio-livre.js — música e efeitos sonoros da internet, com licença.
+ *
+ * Pedido do dono: "selecione músicas da internet, efeitos sonoros". O que
+ * existia era a trilha SINTETIZADA (quatro osciladores e um ruído) e o
+ * arquivo do próprio usuário. Faltava o meio: uma faixa de verdade, tocada
+ * por gente, que ele não precise ter no disco.
+ *
+ * ── DE ONDE VEM ──────────────────────────────────────────────────────────
+ * Da API do Openverse (openverse.org, mantida pela WordPress Foundation):
+ * ela indexa áudio com licença Creative Commons de fontes abertas — música
+ * do Jamendo, efeitos do Freesound, arquivos da Wikimedia — e devolve, para
+ * cada faixa, a URL do arquivo, a licença e o crédito pronto. Sem chave, sem
+ * conta. Não é YouTube nem Spotify: aqui a licença permite usar, e o crédito
+ * vai junto para a peça não sair devendo.
+ *
+ * ── O QUE ELA DEVOLVE ────────────────────────────────────────────────────
+ * O arquivo já BAIXADO para a pasta do projeto e ENVIADO ao estúdio: a URL
+ * "/midia/…" que entra direto em `trilha.src` ou em `som: {arquivo}`, mais o
+ * crédito ("Título — Autor, CC BY 4.0"). A licença decide o que o agente
+ * tem de fazer: BY pede o crédito na peça; CC0/PDM não pede nada. Licença
+ * NC (não comercial) não entra por padrão — a peça pode ser um anúncio.
+ *
+ * Zero dependências: o `pegar` do referencia.js, em modo binário.
+ */
+
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const referencia = require('./referencia.js');
+
+const API = 'https://api.openverse.org/v1/audio/';
+
+// Licenças que permitem uso comercial sem pedir nada além do crédito.
+const LIVRES = new Set(['by', 'by-sa', 'cc0', 'pdm']);
+const NOME_LICENCA = {
+    by: 'CC BY', 'by-sa': 'CC BY-SA', 'by-nc': 'CC BY-NC', 'by-nd': 'CC BY-ND',
+    'by-nc-sa': 'CC BY-NC-SA', 'by-nc-nd': 'CC BY-NC-ND', cc0: 'CC0', pdm: 'Domínio público',
+};
+
+function slug(t) {
+    return String(t || '').normalize('NFD').replace(/[̀-ͯ]/g, '')
+        .toLowerCase().replace(/[^a-z0-9]+/g, '-').replace(/^-+|-+$/g, '').slice(0, 48) || 'audio';
+}
+
+function credito(f) {
+    const lic = NOME_LICENCA[f.license] || String(f.license || '').toUpperCase();
+    const versao = f.license_version && !/cc0|pdm/.test(f.license) ? ' ' + f.license_version : '';
+    return `${f.title || 'Sem título'} — ${f.creator || 'autor desconhecido'} (${lic}${versao}, via ${f.provider || 'Openverse'})`;
+}
+
+/**
+ * Pergunta ao Openverse. `tipo` "musica" restringe à categoria music; "efeito"
+ * pede coisa curta (até ~12 s). `dur` em segundos aproxima a duração desejada
+ * da trilha — uma faixa de 4 min para um reels de 30 s é desperdício, mas
+ * uma de 20 s para um vídeo de 60 s acaba antes; a nota pesa isso.
+ */
+async function procurar({ consulta, tipo = 'musica', dur = 0, comercial = true, pagina = 1 }) {
+    const q = new URLSearchParams({ q: consulta, page_size: '20', page: String(pagina) });
+    if (tipo === 'musica') q.set('category', 'music');
+    if (comercial) q.set('license_type', 'commercial');
+    const bruto = await referencia.pegar(`${API}?${q}`, { timeout: 12000 });
+    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);
+    const alvoMs = tipo === 'efeito' ? 2500 : (dur ? dur * 1000 : 90000);
+    const notas = itens.map((f) => {
+        let n = 0;
+        const d = Number(f.duration) || 0;
+        if (tipo === 'efeito') {
+            if (d > 15000) n -= 50;                            // não é efeito, é faixa
+            else n += 20 - Math.abs(d - alvoMs) / 500;
+        } else {
+            if (d && d < alvoMs * 0.6) n -= 20;                // acaba antes do vídeo
+            n -= Math.abs(d - alvoMs) / 20000;                 // perto da duração pedida
+            if (f.category === 'music') n += 5;
+        }
+        if (/cc0|pdm/.test(f.license)) n += 3;                 // sem crédito obrigatório
+        if (/mp3/i.test(f.filetype || '') || /\.mp3(\?|$)/i.test(f.url)) n += 4;   // toca em qualquer lugar
+        // As palavras da consulta no título/tags contam.
+        const alvo = `${f.title} ${(f.tags || []).map((t) => t.name).join(' ')} ${(f.genres || []).join(' ')}`.toLowerCase();
+        for (const p of consulta.toLowerCase().split(/\s+/)) if (p.length > 2 && alvo.includes(p)) n += 3;
+        return { f, n };
+    }).sort((a, b) => b.n - a.n);
+    return {
+        ok: true,
+        total: j.result_count || itens.length,
+        itens: notas.map(({ f }) => ({
+            id: f.id, titulo: f.title, autor: f.creator, licenca: f.license, licencaUrl: f.license_url,
+            duracao: f.duration ? Math.round(f.duration / 1000) : null, url: f.url, pagina: f.foreign_landing_url,
+            provedor: f.provider, tipoArquivo: f.filetype || null, generos: f.genres || [], credito: credito(f),
+        })),
+    };
+}
+
+/** Baixa a faixa para <projeto>/midia/ e manda ao estúdio. */
+async function trazer(item, { projectDir, studio }) {
+    const bytes = await referencia.pegar(item.url, { timeout: 45000, binario: true });
+    if (!bytes || bytes.length < 2000) return { ok: false, error: `não consegui baixar "${item.titulo}" de ${item.provedor}` };
+    // A extensão pelo conteúdo, não pela URL: o Jamendo entrega mp3 numa URL
+    // sem extensão ("?trackid=…&format=mp32").
+    const cab = bytes.subarray(0, 12);
+    const ext = cab.subarray(0, 3).toString() === 'ID3' || (cab[0] === 0xff && (cab[1] & 0xe0) === 0xe0) ? '.mp3'
+        : cab.subarray(0, 4).toString() === 'RIFF' ? '.wav'
+            : cab.subarray(0, 4).toString() === 'OggS' ? '.ogg'
+                : cab.subarray(0, 4).toString() === 'fLaC' ? '.flac'
+                    : (item.tipoArquivo ? '.' + item.tipoArquivo.replace(/^\./, '') : '.mp3');
+    const pasta = path.join(projectDir || process.cwd(), 'midia');
+    fs.mkdirSync(pasta, { recursive: true });
+    const nome = `${slug(item.titulo)}-${String(item.id || '').slice(0, 6)}${ext}`;
+    const caminho = path.join(pasta, nome);
+    fs.writeFileSync(caminho, bytes);
+    // FLAC/OGG do Freesound: o navegador toca, mas o MP4 exportado quer AAC —
+    // o estúdio cuida disso na exportação; aqui só entregamos o arquivo.
+    const envio = await studio.midiaEnviar({ arquivo: caminho, nome });
+    if (!envio || envio.ok === false) return { ok: false, error: (envio && envio.error) || 'o estúdio não aceitou o arquivo', arquivoLocal: caminho };
+    return { ok: true, url: envio.url, arquivoLocal: path.relative(projectDir || process.cwd(), caminho), bytes: bytes.length };
+}
+
+/**
+ * A tool: procura, escolhe a melhor, baixa e devolve a URL pronta — e as
+ * alternativas, para o agente trocar sem pesquisar de novo.
+ */
+async function buscarAudio(args, { projectDir, studio }) {
+    const consulta = String(args.consulta || args.query || '').trim();
+    if (!consulta) return { ok: false, error: 'Diga o que procurar: o clima da música ("upbeat corporate", "piano calmo") ou o efeito ("whoosh", "ding", "click").' };
+    const tipo = /^(efeito|som|sfx|sound)/i.test(String(args.tipo || '')) ? 'efeito' : 'musica';
+    const dur = Number(args.duracao) || 0;
+    const busca = await procurar({ consulta, tipo, dur, comercial: args.comercial !== false });
+    if (!busca.ok) return busca;
+    if (!busca.itens.length) {
+        return {
+            ok: false,
+            error: `Nenhuma faixa livre para "${consulta}".`,
+            comoCorrigir: tipo === 'efeito'
+                ? 'Use um som SINTETIZADO do estúdio, que não precisa de arquivo: som: "whoosh" | "impacto" | "click" | "pop" | "ding" | "subida" | "tique" | "brilho".'
+                : 'Tente a consulta em inglês e mais genérica ("upbeat electronic", "calm piano", "epic cinematic"), ou use a trilha GERADA: "trilha": {"tipo":"gerada","estilo":"pulso"}.',
+        };
+    }
+    // Baixa a melhor; se ela falhar, a próxima. Três tentativas.
+    let trazido = null;
+    let escolhida = null;
+    for (const item of busca.itens.slice(0, 3)) {
+        trazido = await trazer(item, { projectDir, studio });
+        if (trazido.ok) { escolhida = item; break; }
+    }
+    if (!trazido || !trazido.ok) return { ok: false, error: (trazido && trazido.error) || 'não consegui baixar nenhuma faixa', alternativas: busca.itens.slice(0, 5) };
+    const precisaCredito = !/cc0|pdm/.test(escolhida.licenca);
+    return {
+        ok: true,
+        tipo,
+        url: trazido.url,
+        titulo: escolhida.titulo,
+        autor: escolhida.autor,
+        duracao: escolhida.duracao,
+        licenca: NOME_LICENCA[escolhida.licenca] || escolhida.licenca,
+        licencaUrl: escolhida.licencaUrl,
+        credito: escolhida.credito,
+        pagina: escolhida.pagina,
+        arquivoLocal: trazido.arquivoLocal,
+        comoUsar: tipo === 'efeito'
+            ? `No elemento ou na cena: "som": {"arquivo": "${trazido.url}", "volume": 0.8}.`
+            : `No documento: "trilha": {"tipo":"arquivo","src":"${trazido.url}","volume":0.55,"repetir":true}.`
+              + (precisaCredito ? ` A licença pede CRÉDITO: ponha "${escolhida.credito}" na assinatura ou numa legenda da última cena.` : ' Licença sem exigência de crédito.'),
+        alternativas: busca.itens.filter((i) => i.id !== escolhida.id).slice(0, 4)
+            .map((i) => ({ titulo: i.titulo, autor: i.autor, duracao: i.duracao, licenca: i.licenca, id: i.id })),
+    };
+}
+
+module.exports = { buscarAudio, procurar, trazer, credito, LIVRES, NOME_LICENCA };

package/lib/boas-vindas.js

@@ -157,13 +157,13 @@ async function rodar({ perguntar, mostrar, cores: c, interativo = true,
         mostrar('');
         mostrar(c.bold(c.brand('  Bem-vindo ao PrimoCode.')));
         mostrar(c.muted('  Primeiro, entre na sua conta do Conecta Primo AI.'));
-        mostrar(c.dim('  Vou abrir o navegador; é só confirmar por lá.'));
+        mostrar(c.dim('  Vou abrir o navegador; é só entrar com a conta por lá — o resto é automático.'));
         mostrar('');
         const r = await conectar();
         if (!r || r.ok === false) {
             mostrar('');
             mostrar(c.err('  Não deu para conectar' + (r && r.error ? `: ${r.error}` : '.')));
-            mostrar(c.muted('  Tente de novo com ') + c.brand('/conectar') + c.muted('.'));
+            mostrar(c.muted('  Tente de novo com ') + c.brand('/connect') + c.muted('.'));
             return { liberado: false, motivo: 'sem-login' };
         }
         credencial = conectado ? conectado() : { plano: r.plano };
@@ -181,7 +181,7 @@ async function rodar({ perguntar, mostrar, cores: c, interativo = true,
     } else if (!s || !s.ok) {
         mostrar('');
         mostrar(c.err('  Não consegui confirmar sua conta' + (s && s.error ? `: ${s.error}` : '.')));
-        mostrar(c.muted('  Entre de novo com ') + c.brand('/conectar') + c.muted('.'));
+        mostrar(c.muted('  Entre de novo com ') + c.brand('/connect') + c.muted('.'));
         return { liberado: false, motivo: 'sessao-invalida' };
     }
 
@@ -195,7 +195,7 @@ async function rodar({ perguntar, mostrar, cores: c, interativo = true,
         mostrar('');
         mostrar(c.dim('  Assine em ') + c.brand('conecta-primo-ai.vercel.app')
             + c.dim(' e rode ') + c.brand('primo') + c.dim(' de novo.'));
-        mostrar(c.dim('  Já assinou? ') + c.brand('/conectar')
+        mostrar(c.dim('  Já assinou? ') + c.brand('/connect')
             + c.dim(' atualiza o plano nesta máquina.'));
         mostrar('');
         return { liberado: false, motivo: 'sem-plano', plano };

package/lib/catalogo.js

@@ -143,6 +143,13 @@ const GRUPOS = [
               args: 'todos: lista de {content: a tarefa curta no imperativo, status: pending|in_progress|completed}. Reescreve a lista inteira a cada chamada; só uma "in_progress" por vez.' },
             { tool: 'pesquisar_referencia', escreve: false, faz: 'lê docs e exemplos antes de escrever — sobe a qualidade',
               args: 'consulta: o que pesquisar, de preferência em inglês. paginas (opcional, número, padrão 3, máximo 5).' },
+            // Baixa o arquivo para <projeto>/midia/ — por isso `escreve: true`.
+            { tool: 'buscar_audio', escreve: true, faz: 'acha música ou efeito sonoro livre na internet (Creative Commons), baixa e manda para o estúdio, com o crédito',
+              args: 'consulta: o clima ou o som, em inglês ("upbeat corporate", "calm piano", "whoosh", "ding"). tipo (opcional): "musica" (padrão) ou "efeito". '
+                + 'duracao (opcional, segundos): quanto o vídeo dura, para a faixa combinar. Devolve url para trilha.src ou som.arquivo, e o crédito a pôr na peça quando a licença pedir.' },
+            { tool: 'marca_da_empresa', escreve: true, faz: 'puxa do site da empresa a logo, a cor principal, a paleta, as fontes e a frase — pronto para `marca` no estúdio',
+              args: 'nome: a empresa como o usuário falou. site (opcional): o endereço, se souber — sem ele, o site é descoberto. '
+                + 'Devolve marca:{cor, logo} para colar no documento, mais cores.paleta, fontes e frase. Chame ANTES de criar uma peça de marca.' },
             // Vai para memory-geral.md, FORA da pasta do projeto — por isso não
             // é write_file/edit_file (a sandbox de resolveInProject bloqueia
             // qualquer caminho fora do projeto, e é assim mesmo que tem que