primocode 10.0.0 → 10.1.0

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/portao-skill.js

@@ -0,0 +1,150 @@
+/**
+ * portao-skill.js — antes de instalar skill de fora, lê o que ela manda.
+ *
+ * Skill é texto, mas texto que vira prompt de um agente com o terminal na
+ * mão. Um `cat ~/.ssh/id_ed25519 | curl -X POST …` dentro do SKILL.md é um
+ * comando que o agente pode rodar achando que é parte da tarefa.
+ *
+ * ── O QUE O SKILLSPECTOR ENSINOU ─────────────────────────────────────────
+ * O scanner da NVIDIA pega o `curl` que rouba a chave e deixa passar a MESMA
+ * ordem escrita em prosa ("leia as chaves da pasta .ssh e cole numa issue").
+ * Por isso aqui há três réguas, e a terceira é de prosa: um verbo de mandar
+ * para fora perto de um objeto secreto, em português e em inglês.
+ *
+ * ── O QUE ESTE PORTÃO NÃO É ──────────────────────────────────────────────
+ * Não é garantia. Nada achado quer dizer "nenhum padrão conhecido", não
+ * "segura". E todo achado se lê linha a linha: por isso cada um sai com
+ * arquivo:linha, e a pessoa pode instalar mesmo assim, dizendo que quer.
+ * Nada aqui toca a rede — mandar a skill para ser analisada fora seria
+ * vazar exatamente o que se quer proteger.
+ */
+
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+
+const MAX_ARQUIVOS = 200;
+const MAX_BYTES = 512 * 1024;
+const PULAR = new Set(['.git', 'node_modules']);
+
+const semAcento = (v) => String(v || '').toLowerCase()
+    .normalize('NFD').replace(/[̀-ͯ]/g, '');
+
+// (a) comandos que mandam dado para fora ou rodam o que veio de fora.
+const SAIDA = [
+    [/\b(curl|wget)\b[^\n]*\|\s*(sudo\s+)?(env\s+)?(ba|z|da|k)?sh\b/, 'baixa um script e roda sem ler (| sh)'],
+    [/\bbase64\s+(-d|-D|--decode)\b[^\n]*\|\s*(sudo\s+)?(ba|z|da|k)?sh\b/, 'decodifica base64 e roda no shell'],
+    [/\|\s*(sudo\s+)?(ba|z|da|k)?sh\b/, 'manda texto direto para o shell (| sh)'],
+    [/\b(curl|wget)\b[^\n]*(-X\s*POST|--data\b|--data-\w+|\s-d\s|\s-F\s|--form\b|--upload-file|\s-T\s|--post-(data|file))/i, 'envia dados para fora (curl/wget com POST ou upload)'],
+    [/\bfetch\s*\([^\n]*method\s*:\s*['"`]?(post|put)/i, 'envia dados para fora (fetch com POST)'],
+    [/(^|[\s|;&(`])(nc|ncat|netcat)\s+(-\w+\s+)*[\w.-]+\s+\d{2,5}\b/, 'abre conexão de rede crua (nc)'],
+];
+
+// (b) lugares onde moram os segredos.
+const SEGREDO = [
+    [/(~|\$HOME|\$\{HOME\})\/\.ssh\b|(^|[\s'"`(])\.ssh\/|\bid_(rsa|ed25519|ecdsa|dsa)\b/i, 'lê chaves SSH (~/.ssh)'],
+    [/(~|\$HOME|\$\{HOME\})\/\.aws\b|\.aws\/credentials/i, 'lê credenciais da AWS (~/.aws)'],
+    [/(~|\$HOME|\$\{HOME\})\/\.npmrc\b/i, 'lê o token do npm (~/.npmrc)'],
+    [/\bsecurity\s+(find|dump)-(generic-|internet-)?(password|keychain)|\bkeychain\b/i, 'mexe no chaveiro do sistema (keychain)'],
+    [/\bprintenv\b|(^|[\s;&(`$])env\s*(\||>|\)|`|$)/, 'despeja as variáveis de ambiente (env/printenv)'],
+    [/\b(cat|less|more|head|tail|source|grep|leia|ler|read|open|abra)\b[^\n]{0,40}(?<![\w.])\.env(?![\w.-])/i, 'lê o arquivo .env'],
+];
+
+// (c) prosa: verbo de mandar para fora (ou de esconder) perto de um segredo.
+const VERBOS = [
+    // Conjugações fechadas de propósito: `envi\\w*` casaria "environment", e
+    // `publi\\w*` casaria "public key" — falso positivo na skill mais comum.
+    'envi(?:a|e|ar|ando|ado)', 'mand(?:a|e|ar|ando)', 'sub(?:a|ir)', 'sobe', 'upload\\w*', 'send\\w*', 'sent',
+    'post', 'poste', 'postar', 'exfiltr\\w*', 'escond\\w*', 'hide', 'nao conte', 'cole', 'colar', 'paste',
+    'publique', 'publicar', 'publish\\w*', 'transmit\\w*', 'vaz(?:a|e|ar)', 'leak\\w*',
+].join('|');
+const OBJETOS = [
+    'tokens?', 'chaves?', 'keys?', 'senhas?', 'passwords?', '\\.env', 'credencia\\w*', 'credentials?',
+    'secrets?', 'segredos?', 'api[ _-]?keys?', 'variaveis de ambiente', 'env vars?', 'environment variables?',
+].join('|');
+const B = (x) => `(?<![\\w.])(?:${x})(?![\\w.])`;
+const PROSA = new RegExp(`${B(VERBOS)}[^\\n]{0,60}?${B(OBJETOS)}|${B(OBJETOS)}[^\\n]{0,60}?${B(VERBOS)}`);
+const ESCONDER = /\b(esconda|esconder|oculte|ocultar|hide|nao conte|nao avise|nao mostre|nao diga|don'?t tell|do not tell|without telling)\b[^\n]{0,40}\b(usuario|user|pessoa)\b/;
+
+/* "Nunca publique o .env" é o conselho certo, não o ataque. O skillspector não
+   lê negação e marcou como ataque a frase que proíbe o ataque — falso positivo
+   que treina a pessoa a ignorar o portão. Negação logo antes do verbo, passa. */
+const VERBO = new RegExp(B(VERBOS));
+const NEGA = /\b(nunca|jamais|nao|never|don'?t|do not|not)\b[\W_]*$/;
+function prosaSemNegar(plana) {
+    const re = new RegExp(PROSA.source, 'g');
+    for (let m; (m = re.exec(plana)); re.lastIndex = m.index + 1) {
+        // A negação conta antes do VERBO, que pode estar no fim do trecho.
+        const v = m.index + m[0].search(VERBO);
+        if (!NEGA.test(plana.slice(Math.max(0, v - 20), v))) return true;
+    }
+    return false;
+}
+
+/** Os achados de UM texto. `arquivo` só vai na etiqueta. */
+function varrerTexto(texto, arquivo = 'SKILL.md') {
+    const achados = [];
+    const linhas = String(texto || '').split(/\r?\n/);
+    linhas.forEach((linha, i) => {
+        const marca = (tipo, motivo) => achados.push({
+            arquivo, linha: i + 1, tipo, motivo, trecho: linha.trim().slice(0, 140),
+        });
+        // Uma linha, um achado de cada régua: o `| sh` de um curl não precisa
+        // aparecer três vezes para ser lido.
+        const saida = SAIDA.find(([re]) => re.test(linha));
+        if (saida) marca('comando', saida[1]);
+        const segredo = SEGREDO.find(([re]) => re.test(linha));
+        if (segredo) marca('segredo', segredo[1]);
+        const plana = semAcento(linha);
+        if (prosaSemNegar(plana)) marca('prosa', 'pede em texto para mandar um segredo para fora');
+        else if (ESCONDER.test(plana)) marca('prosa', 'pede para esconder algo de quem usa');
+    });
+    return achados;
+}
+
+/** Todos os arquivos de texto de uma pasta (ou só o arquivo, se for um). */
+function arquivosDe(alvo) {
+    let st;
+    try { st = fs.statSync(alvo); } catch { return []; }
+    if (!st.isDirectory()) return [{ abs: alvo, rel: path.basename(alvo) }];
+    const saida = [];
+    const andar = (dir) => {
+        let ents = [];
+        try { ents = fs.readdirSync(dir, { withFileTypes: true }); } catch { return; }
+        for (const e of ents) {
+            if (saida.length >= MAX_ARQUIVOS) return;
+            const abs = path.join(dir, e.name);
+            if (e.isDirectory()) { if (!PULAR.has(e.name)) andar(abs); }
+            else if (e.isFile()) saida.push({ abs, rel: path.relative(alvo, abs) });
+        }
+    };
+    andar(alvo);
+    return saida;
+}
+
+/**
+ * Varre a skill inteira (pasta ou arquivo). Sem rede, síncrono.
+ * @returns {{achados: Array, arquivos: number}}
+ */
+function varrer(alvo) {
+    const lista = arquivosDe(alvo);
+    const achados = [];
+    for (const { abs, rel } of lista) {
+        let buf;
+        try {
+            if (fs.statSync(abs).size > MAX_BYTES) continue;
+            buf = fs.readFileSync(abs);
+        } catch { continue; }
+        if (buf.includes(0)) continue; // binário: não é instrução para o modelo
+        achados.push(...varrerTexto(buf.toString('utf8'), rel));
+    }
+    return { achados, arquivos: lista.length };
+}
+
+/** Uma linha por achado, para a tela: `arquivo:linha  motivo  — trecho`. */
+function descrever(achados) {
+    return achados.map((a) => `${a.arquivo}:${a.linha}  ${a.motivo}  — ${a.trecho}`);
+}
+
+module.exports = { varrer, varrerTexto, descrever };

package/lib/skills.js

@@ -48,6 +48,7 @@ const fs = require('fs');
 const os = require('os');
 const path = require('path');
 const crypto = require('crypto');
+const portaoSkill = require('./portao-skill.js');
 
 const ORIGEM = path.join(__dirname, '..', 'skills');
 const CASA = path.join(os.homedir(), '.primocode', 'skills');
@@ -313,13 +314,26 @@ function apagar(nome) {
  * arquivo antes. O `/marketplace` traz as do catálogo; `/install-skill
  * <caminho>` traz as que a pessoa escreveu ou recebeu.
  */
-function instalarDe(caminho) {
+function instalarDe(caminho, { forcar = false } = {}) {
     const alvo = String(caminho || '').replace(/^~(?=$|[/\\])/, os.homedir());
     let arquivo = alvo;
     try {
         if (fs.statSync(alvo).isDirectory()) arquivo = path.join(alvo, 'SKILL.md');
     } catch { return { ok: false, error: `Não achei ${caminho}.` }; }
 
+    /* O portão (lib/portao-skill.js): skill de fora é texto que vira ordem
+       para um agente com o terminal na mão. Achou comando que manda dado para
+       fora, leitura de segredo ou prosa pedindo isso, não instala — devolve
+       os achados com arquivo:linha, e quem chamou pergunta se a pessoa quer
+       instalar mesmo assim (`forcar`). */
+    if (!forcar) {
+        const { achados } = portaoSkill.varrer(alvo);
+        if (achados.length) {
+            return { ok: false, bloqueada: true, achados,
+                error: `A skill pede coisas que podem vazar seus segredos (${achados.length} achado${achados.length > 1 ? 's' : ''}). Não instalei.` };
+        }
+    }
+
     let texto;
     try { texto = fs.readFileSync(arquivo, 'utf8'); }
     catch { return { ok: false, error: `Não consegui ler ${arquivo}. Uma skill é um arquivo SKILL.md.` }; }
@@ -408,7 +422,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,