primocode 10.0.0 → 10.0.9

package/lib/estudio/sons-leves.js

@@ -32,6 +32,14 @@ const EFEITOS = {
     subida: ['-f', 'lavfi', '-i', "aevalsrc='0.28*sin(2*PI*(180+260*t*t)*t)*(t/1.4)':s=44100:d=1.4", '-af', 'afade=t=out:st=1.2:d=0.2'],
     // Toque grave e macio: o que chega e assenta.
     toque: ['-f', 'lavfi', '-i', "aevalsrc='0.7*sin(2*PI*(110-50*t)*t)*exp(-7*t)':s=44100:d=0.6", '-af', 'lowpass=f=900'],
+    /* Os CHEIOS do motion gerativo ("motion é vida: efeito sonoro NA ação",
+       30/09): o whoosh da passagem, o impacto da tese, o riser antes da
+       revelação e o pop da letra que nasce. Ainda sintetizados, ainda limpos. */
+    whoosh: ['-f', 'lavfi', '-i', 'anoisesrc=d=0.75:c=pink:a=0.9', '-af',
+        'bandpass=f=1100:width_type=o:w=2.2,afade=t=in:st=0:d=0.42:curve=exp,afade=t=out:st=0.42:d=0.33:curve=qsin,volume=2.2'],
+    impacto: ['-f', 'lavfi', '-i', "aevalsrc='0.95*sin(2*PI*(62-26*t)*t)*exp(-4.5*t)+0.45*(random(0)*2-1)*exp(-38*t)':s=44100:d=1.1", '-af', 'lowpass=f=2600,volume=1.4'],
+    riser: ['-f', 'lavfi', '-i', "aevalsrc='(0.32*sin(2*PI*(170+620*t*t)*t)+0.22*(random(0)*2-1))*pow(t/1.1,2)':s=44100:d=1.1", '-af', 'highpass=f=260,afade=t=out:st=1.04:d=0.06,volume=1.3'],
+    pop: ['-f', 'lavfi', '-i', "aevalsrc='0.8*sin(2*PI*(980-640*t)*t)*exp(-28*t)*(1-exp(-700*t))':s=44100:d=0.18"],
 };
 
 /**
@@ -59,4 +67,33 @@ function preparar(pasta, { rodar = null } = {}) {
     return sons;
 }
 
-module.exports = { EFEITOS, preparar };
+/**
+ * A família de sons de UM vídeo (gerativo.js sonsDoVideo): cada receita vira
+ * midia/sfx-g<semente>-<nome>.mp3. O que já existe não é refeito.
+ */
+function prepararReceitas(pasta, { receitas = {}, semente = 0 } = {}, { rodar = null } = {}) {
+    const exec = rodar || ((args) => {
+        try { require('child_process').execFileSync('ffmpeg', args, { stdio: 'ignore', timeout: 30000 }); return true; }
+        catch { return false; }
+    });
+    const sons = {};
+    const sufixo = (semente >>> 0).toString(36);
+    for (const [nome, args] of Object.entries(receitas)) {
+        const rel = `midia/sfx-g${sufixo}-${nome}.mp3`;
+        const cheio = path.join(pasta, rel);
+        if (!fs.existsSync(cheio)) {
+            fs.mkdirSync(path.dirname(cheio), { recursive: true });
+            // O limitador no fim: o golpe sintetizado passava de 0 dB e estalava.
+            // "{pasta}" é a pasta do projeto: o som feito da própria trilha lê o arquivo dela.
+            const a = args.map((x) => String(x).split('{pasta}').join(pasta));
+            const fc = a.indexOf('-filter_complex'), i = a.indexOf('-af');
+            if (fc >= 0) a[fc + 1] += ',alimiter=limit=0.8:level=false';
+            else if (i >= 0) a[i + 1] += ',alimiter=limit=0.8:level=false'; else a.push('-af', 'alimiter=limit=0.8:level=false');
+            if (!exec(['-y', '-loglevel', 'error', ...a, '-q:a', '3', cheio])) continue;
+        }
+        sons[nome] = rel;
+    }
+    return sons;
+}
+
+module.exports = { EFEITOS, preparar, prepararReceitas };

package/lib/estudio/variedade.js

@@ -0,0 +1,105 @@
+/**
+ * variedade.js — a trilha e os efeitos dos vídeos de corte (híbrido, cinema,
+ * impacto) sem repetir de um vídeo para o outro.
+ *
+ *   "todos os vídeos é sempre as mesmas músicas, os mesmos efeitos sonoros,
+ *    sempre o mesmo padrão de vídeo" (Joel, 02/10)
+ *
+ * A causa era a mesma nos dois: um termo fixo na busca ("inspiring
+ * corporate", "cinematic whoosh") e o PRIMEIRO resultado baixado. A busca
+ * devolve a mesma lista na mesma ordem, então todo vídeo saía com a mesma
+ * faixa e o mesmo whoosh. Aqui:
+ *   1. o termo sai de um cardápio pelo clima do roteiro, em ordem sorteada;
+ *   2. dos resultados, sorteia — e pula o que os últimos vídeos já usaram;
+ *   3. o que foi usado entra na memória (~/.primocode/studio/<tipo>-usadas.json).
+ */
+
+'use strict';
+
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+
+const PASTA = path.join(os.homedir(), '.primocode', 'studio');
+const MEMORIA = { trilha: 16, sfx: 40 };
+
+function arquivo(tipo) { return path.join(PASTA, `${tipo}-usadas.json`); }
+
+function usadas(tipo) {
+    try { const l = JSON.parse(fs.readFileSync(arquivo(tipo), 'utf8')); return Array.isArray(l) ? l : []; } catch { return []; }
+}
+
+function marcar(tipo, id) {
+    if (!id) return;
+    try {
+        fs.mkdirSync(PASTA, { recursive: true });
+        const l = [id, ...usadas(tipo).filter((x) => x !== id)].slice(0, MEMORIA[tipo] || 20);
+        fs.writeFileSync(arquivo(tipo), JSON.stringify(l));
+    } catch { /* sem memória: só perde a garantia de não repetir */ }
+}
+
+function embaralhar(lista, aleatorio = Math.random) {
+    const a = [...lista];
+    for (let i = a.length - 1; i > 0; i--) {
+        const j = Math.floor(aleatorio() * (i + 1));
+        [a[i], a[j]] = [a[j], a[i]];
+    }
+    return a;
+}
+
+/** Os itens da busca na ordem de tentar: os nunca usados primeiro (sorteados), os usados no fim. */
+function ordenar(itens, tipo, aleatorio = Math.random) {
+    const ja = new Set(usadas(tipo));
+    const validos = (itens || []).filter((x) => x && x.url);
+    return [...embaralhar(validos.filter((x) => !ja.has(x.url)), aleatorio), ...validos.filter((x) => ja.has(x.url))];
+}
+
+// ── a trilha: termos por clima ──────────────────────────────────────────
+const CLIMAS = {
+    tecnologia: ['electronic instrumental', 'synthwave instrumental', 'future bass instrumental', 'downtempo electronic', 'minimal techno instrumental', 'chillwave instrumental'],
+    energetico: ['funk instrumental', 'rock instrumental', 'drum and bass instrumental', 'breakbeat instrumental', 'upbeat indie instrumental', 'house instrumental'],
+    epico: ['epic orchestral', 'trailer instrumental', 'cinematic drums', 'epic hybrid instrumental', 'dramatic strings'],
+    calmo: ['lofi hip hop instrumental', 'ambient instrumental', 'acoustic guitar instrumental', 'piano instrumental', 'jazz instrumental'],
+    alegre: ['ukulele instrumental', 'indie pop instrumental', 'happy acoustic instrumental', 'latin instrumental', 'disco instrumental'],
+    emocional: ['piano emotional instrumental', 'post rock instrumental', 'cinematic strings', 'neo classical instrumental'],
+    misterio: ['dark ambient instrumental', 'trip hop instrumental', 'suspense instrumental', 'noir jazz instrumental'],
+    neutro: ['indie instrumental', 'soul instrumental', 'jazz hop instrumental', 'world instrumental', 'electronic instrumental', 'acoustic instrumental'],
+};
+const SINONIMOS = {
+    tecnologia: /tec|tech|ia\b|ai\b|software|app|digital|futur/, energetico: /energ|agit|rapid|forte|esport|academ/,
+    epico: /epic|epico|grandi|trailer|impact/, calmo: /calm|tranq|suave|relax|chill/, alegre: /aleg|feliz|divert|leve/,
+    emocional: /emoc|emoti|inspir|sentim|historia/, misterio: /mist|sombr|dark|suspen|tens/,
+};
+
+function climaDe(roteiro = {}, estilo = '') {
+    const t = String([roteiro.clima, roteiro.genero, roteiro.tom].filter(Boolean).join(' ')).toLowerCase()
+        .normalize('NFD').replace(/[̀-ͯ]/g, '');
+    for (const [clima, re] of Object.entries(SINONIMOS)) if (re.test(t)) return clima;
+    return estilo === 'impacto' ? 'energetico' : 'neutro';
+}
+
+/**
+ * Os termos para buscar a trilha, em ordem de tentar. O pedido explícito
+ * (roteiro.musica) vem primeiro; depois o clima, sorteado; e por último um
+ * clima vizinho, para nunca sair sem música.
+ */
+function termosTrilha(roteiro = {}, estilo = '', aleatorio = Math.random) {
+    const clima = climaDe(roteiro, estilo);
+    const reserva = clima === 'neutro' ? 'calmo' : 'neutro';
+    return [...new Set([roteiro.musica, ...embaralhar(CLIMAS[clima], aleatorio).slice(0, 3),
+        ...embaralhar(CLIMAS[reserva], aleatorio).slice(0, 2)].filter(Boolean))];
+}
+
+// ── os efeitos: várias formas de pedir o mesmo som ───────────────────────
+const SFX = {
+    teclado: ['keyboard typing', 'typing keyboard', 'mechanical keyboard', 'laptop typing', 'typewriter keys'],
+    whoosh: ['cinematic whoosh', 'swoosh transition', 'air whoosh', 'fast swipe', 'woosh pass by', 'riser whoosh'],
+    impacto: ['cinematic boom impact', 'deep cinematic impact', 'trailer hit', 'bass drop hit', 'punch hit', 'sub boom'],
+    sala: ['crowd murmur indoor', 'office ambience', 'people talking background', 'cafe ambience', 'room tone people'],
+};
+
+function termosSfx(nome, aleatorio = Math.random) {
+    return embaralhar(SFX[nome] || [nome], aleatorio).slice(0, 3);
+}
+
+module.exports = { usadas, marcar, embaralhar, ordenar, climaDe, termosTrilha, termosSfx, CLIMAS, SFX };

package/lib/estudio/vox.js

@@ -91,7 +91,11 @@ function montarVox({ roteiro, largura = 1920, altura = 1080, tempos = [], narrac
     const partes = (roteiro && roteiro.partes) || [];
     if (!partes.length) return { ok: false, error: 'o roteiro veio sem partes.' };
     const W = largura, H = altura, deitado = W >= H;
-    const b = Math.min(W, H) / 1080;
+    /* Deitado, o quadro tem 1920 de largura e o mesmo 1080 de altura do em
+       pé: com a escala do lado menor, tudo saía do tamanho do vertical,
+       miúdo e solto num canvas vazio ("deixar os elementos mais organizados",
+       29/09). No 16:9 a tipografia cresce 30%. */
+    const b = (Math.min(W, H) / 1080) * (deitado ? 1.3 : 1);
     const M = Math.round(Math.min(W, H) * 0.075);
     const TOPO = Math.round(H * (deitado ? 0.17 : 0.2));          // a banda intocada
 
@@ -115,7 +119,8 @@ function montarVox({ roteiro, largura = 1920, altura = 1080, tempos = [], narrac
     const leitura = (p) => 1.6 + 0.3 * String([p.titulo, p.sub, p.valor, p.rotulo, p.nao, p.sim, ...itensDe(p)].filter(Boolean).join(' ')).split(/\s+/).length;
     const { ini, dur, total, temVoz } = tempoDasPartes(partes, tempos, { semVoz: leitura });
     const efeitos = [];
-    const som = (t, nome, volume) => { if (sons[nome]) efeitos.push({ t: r2(Math.max(0, t)), src: sons[nome], volume }); };
+    // Efeito que não se ouve é efeito que não existe: 1,6× o volume antigo.
+    const som = (t, nome, volume) => { if (sons[nome]) efeitos.push({ t: r2(Math.max(0, t)), src: sons[nome], volume: Math.min(0.65, volume * 1.6) }); };
 
     // ── as quatro profundidades, e o que mora em cada uma ──────────────
     const CAMADAS = [{ p: 0.12, desfoque: 2.2 }, { p: 0.4, desfoque: 0.9 }, { p: 0.55, desfoque: 0, sujeito: true }, { p: 1.25, desfoque: 3.4 }];
@@ -133,10 +138,16 @@ function montarVox({ roteiro, largura = 1920, altura = 1080, tempos = [], narrac
             return { zoom: [k(0, 3.4), k(Math.min(1.8, d * 0.55), 1.0, 'camera'), k(fimLento, 1.03, 'camera'), k(d, 1.06, 'acelera')],
                 x: [k(0, 0), k(d, lado * 10 * b, 'camera')] };
         }
-        const z1 = modo === 'climax' ? 1.14 : 1.045;
-        return { zoom: [k(0, 1.0), k(fimLento, z1, 'camera'), k(d, z1 + 0.035, 'acelera')],
-            x: [k(0, -lado * 14 * b), k(d, lado * 14 * b, 'camera')],
-            rotacao: [k(0, -lado * 0.3), k(d, lado * 0.3, 'camera')] };
+        /* "Mais movimento" (29/09): a câmera contida do guia VOX (4,5% de
+           zoom, 14 px) lia como tela parada. Deitado ela empurra 12% (22% no
+           clímax) e desliza 34 px; em pé, menos, porque a âncora ocupa a
+           largura toda. */
+        const z1 = modo === 'climax' ? (deitado ? 1.22 : 1.16) : (deitado ? 1.12 : 1.08);
+        const desliza = (deitado ? 34 : 22) * b;   // mais que isso leva a âncora até a borda
+        return { zoom: [k(0, 1.0), k(fimLento, z1, 'camera'), k(d, z1 + 0.05, 'acelera')],
+            x: [k(0, -lado * desliza), k(d, lado * desliza, 'camera')],
+            y: [k(0, lado * desliza * 0.35), k(d, -lado * desliza * 0.35, 'camera')],
+            rotacao: [k(0, -lado * 0.7), k(d, lado * 0.7, 'camera')] };
     };
 
     /* O CORTE NO BEAT dentro da parte longa: passou de 5 s, a câmera pula de
@@ -221,8 +232,10 @@ function montarVox({ roteiro, largura = 1920, altura = 1080, tempos = [], narrac
                 const maior = itens.reduce((a, x) => ((x.termo + (x.def ? ' — ' + x.def : '')).length > a.length ? x.termo + (x.def ? ' — ' + x.def : '') : a), '');
                 // Uma linha por item quando cabe grande; senão, duas.
                 const umaLinha = caber(maior, { largura: larguraAncora * (deitado ? 1.05 : 1), linhas: 1, max: (tipo === 'contraste' ? 170 : itens.length > 3 ? 80 : 96) * b, min: 30 * b, fonte: F.titulo });
-                const tam = umaLinha.tamanho >= 58 * b || tipo === 'contraste' ? umaLinha.tamanho
-                    : caber(maior, { largura: larguraAncora * (deitado ? 1.05 : 1), linhas: 2, max: 80 * b, min: 30 * b, fonte: F.titulo }).tamanho;
+                // O contraste com frase longa saía numa linha só, miúdo no meio do
+                // quadro (29/09). Não coube grande em uma? Vai em duas, maior.
+                const tam = umaLinha.tamanho >= (tipo === 'contraste' ? 72 : 58) * b ? umaLinha.tamanho
+                    : caber(maior, { largura: larguraAncora * (deitado ? 1.05 : 1), linhas: 2, max: (tipo === 'contraste' ? 120 : 80) * b, min: 30 * b, fonte: F.titulo }).tamanho;
                 const ts = g(itens.map((x) => (tipo === 'passos' ? x.def : x.termo)), { t0: titulo && tipo !== 'contraste' ? 0.6 : 0.3 });
                 itens.forEach((x, j) => { x.t = ts[j]; });
                 const linhasEst = itens.reduce((n, x) => n + Math.ceil(((x.termo + (x.def ? ' — ' + x.def : '')).length * tam * 0.56) / larguraAncora), 0);
@@ -354,6 +367,22 @@ function montarVox({ roteiro, largura = 1920, altura = 1080, tempos = [], narrac
         }
 
         const cam = corteInterno(camera(d, modo, i), d, tp, t0);
+        /* CADA ELEMENTO RESPIRA: além da câmera, cada peça flutua um pouco na
+           direção dela (alternando) e cresce 3% — em profundidades diferentes
+           isso vira parallax. O que já tem animação própria de posição,
+           escala ou rotação fica como está. */
+        els.forEach((el, j) => {
+            if (!el || el.peca === 'papel') return;
+            const a = el.anima || {};
+            const sinal = (i + j) % 2 ? 1 : -1;
+            const amp = (deitado ? 14 : 10) * b * (1 + (j % 3) * 0.4);
+            el.anima = {
+                ...a,
+                ...(a.y ? {} : { y: [k(0, sinal * amp), k(d, -sinal * amp, 'camera')] }),
+                ...(a.escala ? {} : { escala: [k(0, 1), k(d, 1.03, 'camera')] }),
+                ...(a.rotacao ? {} : { rotacao: [k(0, -sinal * 0.4), k(d, sinal * 0.4, 'camera')] }),
+            };
+        });
         return {
             duracao: d,
             fundo: escuro ? ESCURO : PAPEL,

package/lib/mcp.js

@@ -0,0 +1,156 @@
+/**
+ * mcp.js — os servidores MCP ao alcance do agente, sem mudar o servidor.
+ *
+ *   "Coloca MCP, coloca coisas pra otimizar ele." (30/09)
+ *
+ * Quem declara as ferramentas ao modelo é o servidor do PrimoCode, que este
+ * cliente não muda. Então o MCP entra como o editor de vídeo entrou: um
+ * subcomando que se descreve (`primocode mcp list`, `primocode mcp call`), e
+ * o agente chama pelo run_shell. A lista curta dos servidores e das tools vai
+ * no contexto — guardada em cache, para não subir servidor a cada pedido.
+ *
+ * A configuração é a mesma do Claude Code, para quem já tem uma:
+ *   ~/.primocode/mcp.json   e   <pasta do projeto>/.mcp.json
+ *   { "mcpServers": { "nome": { "command": "npx", "args": [...], "env": {...} } } }
+ *
+ * O cliente é o mínimo do protocolo por stdio: JSON-RPC 2.0, uma mensagem por
+ * linha — initialize, notifications/initialized, tools/list, tools/call.
+ */
+
+'use strict';
+
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+const { spawn } = require('child_process');
+
+const CASA = path.join(os.homedir(), '.primocode');
+const CONFIG = path.join(CASA, 'mcp.json');
+const CACHE = path.join(CASA, 'mcp-cache.json');
+
+function lerJson(arq) { try { return JSON.parse(fs.readFileSync(arq, 'utf8')); } catch { return null; } }
+
+/* O PADRÃO: o Context7, a documentação ATUAL de qualquer biblioteca. É o
+   que mais melhora a programação de um modelo grátis — ele para de chutar a
+   API de memória. Só sobe quando o agente chama; PRIMOCODE_SEM_MCP=1 tira. */
+const PADRAO = { context7: { command: 'npx', args: ['-y', '@upstash/context7-mcp@latest'] } };
+
+/** Os servidores configurados: o padrão, o do usuário e o do projeto (o do projeto vence). */
+function servidores(pasta = process.cwd()) {
+    const out = process.env.PRIMOCODE_SEM_MCP === '1' ? {} : { ...PADRAO };
+    for (const arq of [CONFIG, path.join(pasta, '.mcp.json')]) {
+        const j = lerJson(arq);
+        for (const [nome, s] of Object.entries((j && j.mcpServers) || {})) if (s && s.command) out[nome] = s;
+    }
+    return out;
+}
+
+/** Abre um servidor, faz o aperto de mão e devolve {pedir, fechar}. */
+function conectar(def, { tetoMs = 60000 } = {}) {
+    return new Promise((resolve, reject) => {
+        const p = spawn(def.command, def.args || [], { env: { ...process.env, ...(def.env || {}) }, stdio: ['pipe', 'pipe', 'pipe'] });
+        let buf = '', id = 0;
+        const espera = new Map();
+        const relogio = setTimeout(() => { try { p.kill(); } catch {} reject(new Error('o servidor MCP não respondeu')); }, tetoMs);
+        p.on('error', (e) => { clearTimeout(relogio); reject(e); });
+        p.stdout.on('data', (d) => {
+            buf += d.toString();
+            let i;
+            while ((i = buf.indexOf('\n')) >= 0) {
+                const linha = buf.slice(0, i).trim(); buf = buf.slice(i + 1);
+                if (!linha) continue;
+                let m; try { m = JSON.parse(linha); } catch { continue; }
+                if (m.id != null && espera.has(m.id)) { const w = espera.get(m.id); espera.delete(m.id); m.error ? w.rej(new Error(m.error.message || 'erro do MCP')) : w.res(m.result); }
+            }
+        });
+        const pedir = (method, params = {}) => new Promise((res, rej) => {
+            const meu = ++id;
+            espera.set(meu, { res, rej });
+            p.stdin.write(JSON.stringify({ jsonrpc: '2.0', id: meu, method, params }) + '\n');
+        });
+        const avisar = (method, params = {}) => p.stdin.write(JSON.stringify({ jsonrpc: '2.0', method, params }) + '\n');
+        pedir('initialize', { protocolVersion: '2025-06-18', capabilities: {}, clientInfo: { name: 'primocode', version: '10' } })
+            .then(() => { avisar('notifications/initialized'); clearTimeout(relogio); resolve({ pedir, fechar: () => { try { p.kill(); } catch {} } }); })
+            .catch((e) => { clearTimeout(relogio); try { p.kill(); } catch {} reject(e); });
+    });
+}
+
+async function listar(pasta) {
+    const lista = servidores(pasta);
+    const out = {};
+    await Promise.all(Object.entries(lista).map(async ([nome, def]) => {
+        try {
+            const c = await conectar(def);
+            const r = await c.pedir('tools/list');
+            c.fechar();
+            out[nome] = (r.tools || []).map((t) => ({ nome: t.name, descricao: String(t.description || '').split(/\n|\. /)[0].slice(0, 120), args: Object.keys((t.inputSchema && t.inputSchema.properties) || {}) }));
+        } catch (e) { out[nome] = { erro: e.message }; }
+    }));
+    try { fs.mkdirSync(CASA, { recursive: true }); fs.writeFileSync(CACHE, JSON.stringify({ quando: Date.now(), servidores: out }, null, 2)); } catch { /* sem cache */ }
+    return out;
+}
+
+async function chamar(servidor, tool, args = {}, pasta) {
+    const def = servidores(pasta)[servidor];
+    if (!def) throw new Error(`não há servidor MCP "${servidor}" — veja primocode mcp list`);
+    const c = await conectar(def);
+    try {
+        const r = await c.pedir('tools/call', { name: tool, arguments: args });
+        return r;
+    } finally { c.fechar(); }
+}
+
+/** A linha do contexto: só se houver servidor configurado, a partir do cache. */
+function dica(pasta) {
+    const lista = Object.keys(servidores(pasta));
+    if (!lista.length) return '';
+    const c = lerJson(CACHE);
+    const det = lista.map((n) => {
+        const tools = c && c.servidores && Array.isArray(c.servidores[n]) ? c.servidores[n].map((t) => t.nome).slice(0, 8).join(', ') : '';
+        return tools ? `${n} (${tools})` : n;
+    }).join(' · ');
+    return `[mcp] Servidores MCP disponíveis: ${det}. Use pelo run_shell: primocode mcp call <servidor> <tool> --json '{...}'`
+        + (c ? '' : ' (rode primocode mcp list para ver as tools).');
+}
+
+/** `primocode mcp …` */
+async function main(argv) {
+    const [op, ...resto] = argv;
+    const json = (() => { const i = resto.indexOf('--json'); try { return i >= 0 ? JSON.parse(resto[i + 1] || '{}') : {}; } catch { return null; } })();
+    try {
+        if (!op || op === 'help') {
+            console.log('primocode mcp list                         — servidores e tools (de ~/.primocode/mcp.json e .mcp.json)');
+            console.log("primocode mcp call <servidor> <tool> --json '{...}'  — chama uma tool; sai o resultado em JSON");
+            console.log('primocode mcp add <nome> -- <comando> [args…]  — guarda um servidor em ~/.primocode/mcp.json');
+            return 0;
+        }
+        if (op === 'list') { console.log(JSON.stringify(await listar(process.cwd()))); return 0; }
+        if (op === 'call') {
+            if (json === null) { console.log(JSON.stringify({ ok: false, error: '--json inválido' })); return 1; }
+            const r = await chamar(resto[0], resto[1], json, process.cwd());
+            const texto = (r.content || []).map((x) => (x.type === 'text' ? x.text : `[${x.type}]`)).join('\n');
+            console.log(JSON.stringify({ ok: !r.isError, resultado: texto.slice(0, 20000) }));
+            return r.isError ? 1 : 0;
+        }
+        if (op === 'add') {
+            const i = resto.indexOf('--');
+            const nome = resto[0];
+            const cmd = i >= 0 ? resto.slice(i + 1) : resto.slice(1);
+            if (!nome || !cmd.length) { console.log('uso: primocode mcp add <nome> -- <comando> [args…]'); return 1; }
+            const j = lerJson(CONFIG) || { mcpServers: {} };
+            j.mcpServers = j.mcpServers || {};
+            j.mcpServers[nome] = { command: cmd[0], args: cmd.slice(1) };
+            fs.mkdirSync(CASA, { recursive: true });
+            fs.writeFileSync(CONFIG, JSON.stringify(j, null, 2));
+            console.log(JSON.stringify({ ok: true, servidor: nome }));
+            return 0;
+        }
+        console.log(JSON.stringify({ ok: false, error: `operação desconhecida: ${op}` }));
+        return 1;
+    } catch (e) {
+        console.log(JSON.stringify({ ok: false, error: e.message }));
+        return 1;
+    }
+}
+
+module.exports = { servidores, conectar, listar, chamar, dica, main };

package/lib/personas.js

@@ -0,0 +1,67 @@
+/**
+ * personas.js — a equipe que trabalha calada por trás de cada pedido.
+ *
+ *   "Coloca personas que fiquem trabalhando ocultamente, e que seja surreal."
+ *   (30/09)
+ *
+ * Não são subagentes: cada subagente é mais uma ida ao modelo, e o plano
+ * grátis conta idas. A persona é o OLHAR de um especialista entrando no
+ * contexto do mesmo pedido — curta, e só a que o pedido pede. O agente faz o
+ * trabalho com o padrão de quem faria aquilo de profissão.
+ *
+ *   escolher(pedido) → [{ nome, olhar }]   no máximo duas
+ *   bloco(pedido)    → o texto que entra no contexto, ou ''
+ */
+
+'use strict';
+
+const EQUIPE = [
+    {
+        nome: 'engenheira sênior', curto: 'código pequeno e certo, siga o padrão da casa, rode o que prova', quando: /\b(c[oó]digo|api|bug|erro|teste|fun[cç][aã]o|refator|backend|servidor|banco|typescript|javascript|python|node|react|next|deploy|build)\b/i,
+        olhar: 'Antes de escrever, olhe o que já existe e siga o padrão da casa. Mudança pequena e certa vence reescrita. '
+            + 'Trate o erro de verdade (entrada vazia, rede caída), sem try/catch que engole tudo. Rode o teste ou o comando que prova. '
+            + 'Biblioteca que você não domina: consulte a doc atual com primocode mcp call context7 query-docs antes de chutar a API.',
+    },
+    {
+        nome: 'designer de produto', curto: 'identidade própria, um acento, hierarquia, funciona em 390px', quando: /\b(site|p[aá]gina|landing|app|tela|interface|layout|dashboard|formul[aá]rio|loja)\b/i,
+        olhar: 'Nada de cara de template: uma tipografia com caráter (não Inter/Roboto por padrão), uma paleta tirada do assunto com UM acento, '
+            + 'hierarquia clara, espaço para respirar, estados de foco e de vazio, e funciona em 390px. Texto real do negócio, nunca lorem ipsum.',
+    },
+    {
+        nome: 'diretor de motion', curto: 'o áudio comanda o quadro, uma ação por vez, respiro', quando: /\b(v[ií]deo|motion|anima[cç][aã]o|reels?|an[uú]ncio|vinheta|trailer)\b/i,
+        olhar: 'O áudio comanda o quadro: cada elemento entra na palavra que o pede. Uma ação dominante por vez, um acento só, '
+            + 'respiro de 30–40% do quadro. Roteiro curto e falado, com uma palavra-tese por parte.',
+    },
+    {
+        nome: 'redatora', curto: 'frase curta, verbo forte, uma ideia por frase', quando: /\b(texto|copy|legenda|post|e-?mail|roteiro|t[ií]tulo|descri[cç][aã]o|artigo)\b/i,
+        olhar: 'Frase curta, verbo forte, uma ideia por frase. Fale com quem vai ler, no português de gente. Corte adjetivo que não carrega fato.',
+    },
+    {
+        /* Só quando a pessoa pede para MEXER no computador ("abre o YouTube",
+           "clica em…"). "Pesquisa sobre X" não é isso: era o que abria o Chrome
+           do nada, mostrava o mouse e parava (01/10). */
+        nome: 'operador', curto: 'só quando pedirem para mexer no computador; termine o que pediram', quando: /\b(abr[ae]|abrir|clica|clique|digita|navega)\b[\s\S]{0,40}\b(chrome|youtube|safari|firefox|spotify|whatsapp|navegador|site|aba|app|aplicativo|janela)\b|\b(mouse|teclado)\b/i,
+        olhar: 'A pessoa pediu para mexer no computador: faça à vista (browser_open, browser_read, clique pelas refs @e3) e TERMINE o que ela pediu — '
+            + 'abrir a janela não é a tarefa. Diga em uma linha o que fez.',
+    },
+];
+
+function escolher(pedido) {
+    const t = String(pedido || '');
+    return EQUIPE.filter((p) => p.quando.test(t)).slice(0, 2);
+}
+
+/* A IA ESCOLHE (01/10). Antes entravam só as que a regex casava — e a regex
+   errava para os dois lados (a "pesquisa" que chamava o operador). Agora a
+   equipe inteira vai, curta, e o modelo adota quem a tarefa pede; as que a
+   regex casou vêm primeiro, com o olhar inteiro, como sugestão — não ordem. */
+function bloco(pedido) {
+    const t = String(pedido || '').trim();
+    if (!t || /^(oi|ol[aá]|e a[ií]|bom dia|boa tarde|boa noite|valeu|obrigad\w*|tudo bem)\b[\s\S]{0,20}$/i.test(t)) return '';
+    const sugeridas = escolher(t);
+    const linhas = sugeridas.map((p) => `- ${p.nome} (provável): ${p.olhar}`);
+    for (const p of EQUIPE) if (!sugeridas.includes(p)) linhas.push(`- ${p.nome}: ${p.curto}`);
+    return '[equipe] Adote o olhar de quem esta tarefa pede (no máximo dois; nenhum, se for conversa):\n' + linhas.join('\n');
+}
+
+module.exports = { escolher, bloco, EQUIPE };

package/lib/skills.js

@@ -408,7 +408,43 @@ function montar(texto, op = {}) {
     return { texto: cabeca + texto, skills: escolhidas };
 }
 
+/**
+ * O CARDÁPIO: a IA escolhe (01/10). "Tem que ser a IA que vai decidir o que
+ * ela vai fazer." Antes a skill entrava INTEIRA por contagem de palavra — e
+ * "faz um roteiro de vídeo" trazia "Motion de primeira", que mandava animar.
+ * Agora entra uma linha por skill (as que casam com o pedido primeiro, até
+ * 12), e o modelo carrega a que servir com `primocode skill <nome>` — como a
+ * ferramenta Skill do Claude Code. Custa uma ida a mais só quando a skill é
+ * usada, e as linhas custam menos que um corpo inteiro.
+ */
+function cardapio(texto, { todas = null, max = 12 } = {}) {
+    const lista = (todas || listar()).filter((s) => s.ligada && s.corpo);
+    if (!lista.length) return { texto, sugeridas: [] };
+    const comNota = lista.map((s) => ({ s, pontos: pontuar(s, texto) }))
+        .sort((a, b) => b.pontos - a.pontos || a.s.nome.localeCompare(b.s.nome));
+    const linhas = comNota.slice(0, max).map(({ s, pontos }) =>
+        `- ${s.nome}${pontos ? ' (pode servir)' : ''} — ${String(s.descricao || s.titulo).replace(/\s+/g, ' ').slice(0, 90)}`);
+    const cabeca = '[skills] Você decide se usa alguma. Se uma é do tipo desta tarefa, CARREGUE antes de começar '
+        + '(run_shell: primocode skill <nome>; várias na mesma resposta). Se nenhuma serve, ignore.\n'
+        + linhas.join('\n') + '\n\nPEDIDO:\n';
+    return { texto: cabeca + texto, sugeridas: comNota.filter((x) => x.pontos > 0).map((x) => x.s) };
+}
+
+/** `primocode skill <nome>` | `primocode skill list` — o corpo da skill, para o agente carregar. */
+function main(argv) {
+    const [nome] = argv;
+    if (!nome || nome === 'list' || nome === 'help') {
+        for (const s of listar().filter((x) => x.ligada)) console.log(`${s.nome} — ${s.descricao || s.titulo}`);
+        return 0;
+    }
+    const s = ler(apelidar(nome)) || listar().find((x) => x.nome.startsWith(String(nome).toLowerCase()));
+    if (!s) { console.log(`não há skill "${nome}" — veja primocode skill list`); return 1; }
+    console.log(`# ${s.titulo}\n\n${s.corpo}`);
+    return 0;
+}
+
 module.exports = {
+    cardapio, main,
     impressao,
     CASA, ORIGEM, MAX_CARACTERES,
     separar, listar, ler, criar, ligar, apagar, instalarDe, apelidar,

package/lib/tools.js

@@ -402,6 +402,13 @@ function readFile({ path: rawPath, offset, limit }, projectDir) {
         };
     }
 
+    /* Arquivo pequeno vem INTEIRO, mesmo pedido aos pedaços: o modelo lia um
+       app.js de 393 linhas de 50 em 50, cada pedaço uma ida ao servidor
+       (teste da loja, 01/10). Inteiro, uma vez, custa menos. */
+    if (todas.length <= 400 && bruto.length <= 40000) {
+        return { ok: true, content: todas.map((l, i) => `${i + 1}\t${l}`).join('\n'), linhas: todas.length, bytes: bruto.length,
+            inteiro: true, dica: 'arquivo pequeno: veio inteiro, com o número das linhas — não precisa ler de novo' };
+    }
     const inicio = Math.max(0, (offset || 1) - 1);
     const fim = Math.min(todas.length, inicio + (limit || 200));
     const recorte = todas.slice(inicio, fim).map((l, i) => `${inicio + i + 1}\t${l}`).join('\n');
@@ -560,6 +567,14 @@ async function despachar(name, args, ctx) {
                 const alvo = /^https?:\/\//i.test(args.target || '')
                     ? args.target
                     : resolveInProject(args.target, projectDir);
+                /* Site da web abre À VISTA no Chrome controlado (o cursor vai na
+                   barra e digita). Arquivo do projeto continua no navegador padrão. */
+                if (/^https?:/i.test(alvo) && process.env.PRIMOCODE_BROWSER_HEADLESS !== '1' && require('./cursor').disponivel()) {
+                    try {
+                        const r = await browser.abrirVisivel(alvo);
+                        if (r && r.ok !== false) return { ok: true, opener: 'chrome à vista', url: r.url, pagina: await browser.retrato(40), comoUsar: snapshot.COMO_USAR };
+                    } catch { /* cai no navegador padrão */ }
+                }
                 return openInBrowser(alvo);
             }
             case 'multi_edit':
@@ -570,11 +585,14 @@ async function despachar(name, args, ctx) {
             // Pesquisa de referência: abre documentação e exemplos sobre o
             // pedido e devolve o TEXTO para o modelo aprender antes de
             // escrever. Aparece no terminal, com as fontes — nada oculto.
-            case 'pesquisar_referencia':
-                return referencia.pesquisar({
+            case 'pesquisar_referencia': {
+                const r = await referencia.pesquisar({
                     consulta: args.consulta || args.query || '',
                     paginas: Math.max(1, Math.min(5, Number(args.paginas) || 3)),
                 });
+                // Escopo fechado ("só do site x.com"): o buscador devolve o mundo; aqui só passa o site.
+                return require('./estudio/referencias.js').filtrar(r);
+            }
 
             // memory-geral.md fica FORA da pasta do projeto — write_file/edit_file
             // não alcançam por design (resolveInProject bloqueia ../ de propósito).
@@ -595,7 +613,8 @@ async function despachar(name, args, ctx) {
                 const alvo = /^https?:\/\//i.test(args.url || '')
                     ? args.url
                     : 'file://' + resolveInProject(args.url, projectDir);
-                const r = await browser.open(alvo);
+                // Endereço da web abre À VISTA: o cursor vai na barra e digita (browser.abrirVisivel).
+                const r = /^https?:/i.test(alvo) ? await browser.abrirVisivel(alvo) : await browser.open(alvo);
                 return r && r.ok !== false ? { ...r, pagina: await browser.retrato(40), comoUsar: snapshot.COMO_USAR } : r;
             }
             case 'browser_click': {

package/lib/ui.js

@@ -310,11 +310,11 @@ const TIPS = [
 ];
 
 const NEWS = [
-    'Digite enquanto ele trabalha: o recado entra na tarefa depois do passo atual',
-    'Mais rápido: não relê o que escreveu, e a espera aparece com os segundos',
-    'primocode video help — o editor de vídeo que o agente opera sozinho',
-    'Motion novo: vox, marca e lancamento · /voice: fale, e ele responde em voz',
-    'Esc Esc a qualquer momento para o agente no meio do trabalho',
+    'A IA decide o caminho: skills e equipe num cardápio, ela escolhe o que usa',
+    'Até 8 agentes em paralelo, cada um volta com uma entrega — e passa a vez',
+    'Edite falando no vídeo: primocode video auto aplica o que você diz, na hora',
+    'Colou texto grande? Vira etiqueta [Colado #1 · N linhas] na caixa',
+    'Escopo fechado de verdade: "só do site x.com" filtra a pesquisa',
 ];
 
 // ── Cabeçalho ────────────────────────────────────────────────────────────
@@ -419,6 +419,21 @@ class Spinner {
         // Fora de um terminal (pipe, CI) a animação só sujaria a saída.
         if (!process.stdout.isTTY) return this;
         this.desde = Date.now();
+        /* Com a caixa de digitar no ar, o spinner desenha DENTRO dela (ver
+           mostrarSpinner em lib/entrada.js): escrever "\r" por cima apagava
+           a caixa e a barra de status enquanto ele girava. */
+        const caixa = Spinner.caixa;
+        if (caixa && caixa.mostrarSpinner && caixa.desenhado !== undefined) {
+            this.naCaixa = caixa;
+            this.timer = setInterval(() => {
+                if (this.textos.length > 1) this.text = this.textos[Math.floor((Date.now() - this.desde) / 4000) % this.textos.length];
+                const seg = Math.floor((Date.now() - this.desde) / 1000);
+                const extra = (seg >= 3 ? ` · ${seg}s` : '') + (this.detalhe ? ` · ${this.detalhe}` : '');
+                caixa.mostrarSpinner(`${c.muted(this.frames[this.i])} ${c.muted(this.text)}${c.dim(extra)}`);
+                this.i = (this.i + 1) % this.frames.length;
+            }, 120);
+            return this;
+        }
         this.timer = setInterval(() => {
             // Com mais de uma frase, troca a cada 4s. A frase nova pode ser mais
             // curta que a anterior: o resto da linha velha ficaria na tela, então
@@ -439,10 +454,29 @@ class Spinner {
         return this;
     }
     stop() {
+        if (this.naCaixa) {
+            if (this.timer) { clearInterval(this.timer); this.timer = null; }
+            this.naCaixa.mostrarSpinner('');
+            this.naCaixa = null;
+            return;
+        }
         if (this.timer) { clearInterval(this.timer); this.timer = null; process.stdout.write(`\r${' '.repeat(Math.max(80, this.largura + 4))}\r`); }
     }
 }
 
+/* O TÍTULO DO TERMINAL: é por ele que o Orca (e qualquer terminal com abas)
+   sabe que este painel é um agente e se está trabalhando. O Orca lê o glifo
+   de spinner em braile como "trabalhando" e o nome como identidade — então
+   "⠋ PrimoCode — tarefa" enquanto trabalha, "PrimoCode" parado. Vai pelo
+   canal cru da caixa: pelo stdout embrulhado, um escape sem quebra de linha
+   deixaria a caixa apagada (o mesmo defeito do spinner). */
+function titulo(texto) {
+    if (!process.stdout.isTTY || process.env.PRIMOCODE_SEM_TITULO === '1') return;
+    const limpo = String(texto || '').replace(/[\x00-\x1f\x7f]/g, ' ').slice(0, 80);
+    const escrever = Spinner.caixa && Spinner.caixa.escreverCru ? Spinner.caixa.escreverCru : (s) => process.stdout.write(s);
+    try { escrever(`\x1b]0;${limpo}\x07`); } catch { /* terminal fechado */ }
+}
+
 // O rótulo de cada tool na tela — o que a pessoa lê no lugar do nome interno.
 const ROTULOS = {
         read_file:'Read', write_file:'Write', edit_file:'Edit', multi_edit:'MultiEdit',
@@ -616,4 +650,5 @@ function friendlyError(raw) {
 }
 
 
-module.exports = { c, mascot, MASCOTES, resolverMascote, mascoteInfo, galeriaMascotes, reacao, welcomeBox, Spinner, PENSANDO, actionHeader, friendlyError, visibleWidth, stripAnsi, truncate, padRight };
+module.exports = {
+    titulo, c, mascot, MASCOTES, resolverMascote, mascoteInfo, galeriaMascotes, reacao, welcomeBox, Spinner, PENSANDO, actionHeader, friendlyError, visibleWidth, stripAnsi, truncate, padRight };