primocode 9.10.0 → 10.0.9

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/pipeline.js

@@ -217,8 +217,8 @@ Duas regras que valem mais que o resto:
 
 Responda com a especificação e mais nada.`;
 
-const CONSTRUTOR_1 = (spec, pasta) => `Você é o CONSTRUTOR 1, e o seu trabalho é
-o PROTÓTIPO que FUNCIONA.
+const CONSTRUTOR_1 = (spec, pasta) => `Você é o CONSTRUTOR, e o seu trabalho é
+o PRODUTO que FUNCIONA — de primeira, sem protótipo para alguém refazer depois.
 
 Construa na pasta: ${pasta}
 
@@ -243,39 +243,35 @@ Regras:
   digitar não mostra nada.
 · Não deixe função pela metade nem "TODO". O que não der para fazer, não
   prometa na tela.
+· Com TELA: hierarquia de tamanhos, espaço para respirar, estados de foco e de
+  toque, mensagem que diz o que fazer quando o campo está vazio, e nada de
+  rolagem horizontal em 390px. Uma paleta, mantida.
+· RÁPIDO: escreva cada arquivo UMA vez, inteiro, e vários na mesma rodada. O
+  resultado do write_file é a verdade — não releia o que acabou de escrever.
 
 Escreva os arquivos e diga em uma linha o que ficou pronto.`;
 
-const CONSTRUTOR_2 = (spec, pasta, relato) => `Você é o CONSTRUTOR 2, e o seu
-trabalho é virar o protótipo em PRODUTO.
+const CONSTRUTOR_2 = (spec, pasta, relato) => `Você é o CORRETOR. O produto já
+está construído na pasta ${pasta}, e alguém ABRIU e achou problema.
 
-A pasta é: ${pasta}
-LEIA os arquivos que já estão lá antes de mexer. Não recomece do zero: o que
-está funcionando fica.
-
-Especificação:
+O que foi pedido (resumo):
 
 """
 ${spec}
 """
 
-${relato ? `O revisor testou o que existe e achou isto:\n\n"""\n${relato}\n"""\n\n` : ''}\
-O que você faz:
+O que está errado:
 
-· CONSERTA o que o revisor apontou. Isso vem primeiro; nada de recurso novo com
-  erro aberto.
-· COMPLETA o que a especificação pede e o protótipo não faz.
-· REDESENHA: hierarquia de tamanhos, espaço para respirar, estados de foco e de
-  toque, e o que aparece quando não há dados. Escolha uma paleta e mantenha.
-· CUIDA DO ERRO: campo vazio, valor impossível, lista vazia. Cada um com uma
-  mensagem que diz o que fazer, não "erro".
-· RESPONSIVO de verdade: nada de rolagem horizontal em 390px de largura.
+"""
+${relato || '(sem relato)'}
+"""
 
-As três últimas valem para o que TEM TELA. Se isto roda no terminal, o
-equivalente é: mensagem de uso quando faltar argumento, saída legível, e código
-de saída diferente de zero quando der errado.
+· Conserte SÓ o que está apontado. Nada de recurso novo, nada de recomeçar.
+· Leia apenas o arquivo citado no erro — não a pasta inteira — e troque o trecho
+  com edit_file. Reescrever o arquivo inteiro só se ele estiver vazio ou em
+  branco.
+· Não releia o arquivo depois de editar: o resultado do edit_file é a verdade.
 
-Não escreva "pronto" sem ter aberto os arquivos e mudado o que precisa.
 Diga em uma linha o que mudou.`;
 
 const REVISOR = (spec, pasta, arquivos, relato) => `Você é o REVISADOR, e você
@@ -327,11 +323,12 @@ const APROVOU = /^\s*APROVAD[OA]\b/im;
  * @param {(prompt:string,rotulo:string)=>Promise<string>} op.correr  roda um agente
  * @param {(linha:string)=>void} op.mostrar   escreve na tela do usuário
  * @param {(alvo:string)=>any} [op.abrir]     abre no navegador da pessoa
- * @param {number} [op.rodadas]               voltas de correção (padrão 2)
+ * @param {number} [op.rodadas]               conferências, contando a primeira (padrão 3)
  */
 async function construir(op) {
     const { pedido, pasta, correr, mostrar = () => {}, abrir } = op;
-    const rodadasMax = Math.max(1, Math.min(4, op.rodadas == null ? 2 : op.rodadas));
+    // Quantas CONFERÊNCIAS (a primeira + os consertos). 3 = até dois consertos.
+    const rodadasMax = Math.max(1, Math.min(4, op.rodadas == null ? 3 : op.rodadas));
     if (!pedido) return { ok: false, error: 'Diga o que construir.' };
     if (!pasta) return { ok: false, error: 'Diga em que pasta construir.' };
     fs.mkdirSync(pasta, { recursive: true });
@@ -345,45 +342,47 @@ async function construir(op) {
             return { ok: false, error: 'O engenheiro de prompt não devolveu especificação. Faça você mesmo.' };
         }
 
-        mostrar('construtor 1 — protótipo');
-        await correr(CONSTRUTOR_1(spec, pasta), 'construtor 1');
-        etapas.push({ papel: 'construtor 1', arquivos: listar(pasta).length });
-
+        mostrar('construtor');
+        await correr(CONSTRUTOR_1(spec, pasta), 'construtor');
+        etapas.push({ papel: 'construtor', arquivos: listar(pasta).length });
+
+        /* ── CONFERIR: a máquina primeiro, o modelo só quando ela não sabe ──
+         * Antes eram quatro agentes no mínimo: engenheiro, protótipo, um
+         * construtor 2 que RELIA tudo para refazer como MVP, e um revisor que
+         * relia de novo para opinar. Era o "escreve dois arquivos e fica o dia
+         * lendo o que fez". Agora: a página abriu limpa no Chrome escondido?
+         * Está pronta — a medida é fato, e opinião por cima dela só custava.
+         * Abriu com erro? O corretor recebe o erro e troca o trecho. O revisor
+         * de modelo só entra quando não há página para medir (um app de
+         * terminal), porque aí "não sei" precisa de alguém que leia. */
         let relato = null;
         let aprovado = false;
         let ultimoRevisor = '';
 
         for (let volta = 1; volta <= rodadasMax; volta++) {
-            mostrar(`construtor 2 — ${volta === 1 ? 'MVP' : `correção ${volta - 1}`}`);
-            await correr(CONSTRUTOR_2(spec, pasta, relato), `construtor 2 (${volta})`);
-
-            mostrar('revisador — testando escondido');
+            mostrar(volta === 1 ? 'conferindo — abrindo a página escondido' : `conferindo o conserto ${volta - 1}`);
             const medida = await medirNoNavegador(pasta);
-            const arquivos = listar(pasta);
-            ultimoRevisor = await correr(
-                REVISOR(spec, pasta, arquivos, medida.relato), `revisador (${volta})`);
-
-            etapas.push({ papel: `revisador ${volta}`, testou: medida.testou,
-                limpo: medida.limpo, veredito: (ultimoRevisor || '').split('\n')[0] });
-
-            /* O veredito do modelo NÃO passa por cima do que a máquina mediu.
-               Página em branco ou erro de JavaScript é reprovação, e um
-               "APROVADO" escrito em cima disso é o revisor lendo o que ele
-               queria que estivesse lá — que é exatamente o defeito que separar
-               os papéis existe para evitar.
-
-               Mas o VETO precisa de MEDIDA: quando não deu para abrir nada —
-               porque o projeto não é uma página, ou porque não há navegador
-               nesta máquina — o que a máquina tem a dizer é "não sei", e "não
-               sei" não reprova. Sem esta distinção, um app de linha de comando
-               nunca seria aprovado: gastaria as voltas todas e terminaria
-               dizendo que não está pronto, sobre um trabalho que está. */
-            aprovado = APROVOU.test(ultimoRevisor || '') && !(medida.testou && !medida.limpo);
+            let veredito;
+            if (medida.testou) {
+                aprovado = medida.limpo;
+                veredito = medida.limpo ? 'APROVADO pela medida' : 'REPROVADO pela medida';
+                relato = medida.limpo ? null : medida.relato;
+            } else {
+                mostrar('revisador — lendo o que foi feito');
+                ultimoRevisor = await correr(
+                    REVISOR(spec, pasta, listar(pasta), medida.relato), `revisador (${volta})`);
+                aprovado = APROVOU.test(ultimoRevisor || '');
+                veredito = (ultimoRevisor || '').split('\n')[0];
+                relato = aprovado ? null : ultimoRevisor;
+            }
+            etapas.push({ papel: `conferência ${volta}`, testou: medida.testou, limpo: medida.limpo, veredito });
             if (aprovado) { mostrar('aprovado'); break; }
-
-            relato = medida.limpo ? ultimoRevisor : `${medida.relato}\n\n${ultimoRevisor || ''}`;
-            if (volta < rodadasMax) mostrar('reprovado — voltando para o construtor');
+            if (volta === rodadasMax) break;
+            if (!ultimoRevisor) ultimoRevisor = relato || '';
+            mostrar(`corretor — consertando (${volta})`);
+            await correr(CONSTRUTOR_2(spec, pasta, relato), `corretor (${volta})`);
         }
+        if (!ultimoRevisor && relato) ultimoRevisor = relato;
 
         const entrada = acharEntrada(pasta);
         let abriu = false;

package/lib/repeticao.js

@@ -62,7 +62,9 @@ function palavras(texto) {
 /** Quanto duas buscas se sobrepõem, de 0 a 1. */
 function semelhanca(a, b) {
     const A = palavras(a), B = palavras(b);
-    if (!A.size || !B.size) return A.size === B.size ? 1 : 0;
+    // Sem palavra que conte dos dois lados ("go" e "js"): só é a mesma busca
+    // se o texto for o mesmo.
+    if (!A.size || !B.size) return normalizar(a).trim() === normalizar(b).trim() ? 1 : 0;
     let juntos = 0;
     for (const p of A) if (B.has(p)) juntos++;
     return juntos / (A.size + B.size - juntos);

package/lib/skills.js

@@ -80,7 +80,13 @@ function separar(texto) {
 }
 
 function lerEstado() {
-    try { return JSON.parse(fs.readFileSync(ESTADO, 'utf8')); } catch { return { desligadas: [] }; }
+    let e;
+    try { e = JSON.parse(fs.readFileSync(ESTADO, 'utf8')); } catch { e = null; }
+    // Um estado.json válido sem `desligadas` (um `{}`) derrubava /skills,
+    // /marketplace e a entrada das skills em todo pedido.
+    if (!e || typeof e !== 'object') e = {};
+    if (!Array.isArray(e.desligadas)) e.desligadas = [];
+    return e;
 }
 
 function salvarEstado(estado) {
@@ -200,7 +206,7 @@ function ler(nome) {
         quando: String(cabecalho.quando || '').split(',').map((s) => s.trim().toLowerCase()).filter(Boolean),
         autor: cabecalho.autor || '',
         corpo,
-        ligada: !estado.desligadas.includes(nome),
+        ligada: !(Array.isArray(estado.desligadas) && estado.desligadas.includes(nome)),
         doProduto: fs.existsSync(path.join(ORIGEM, nome, 'SKILL.md')),
         caminho: arquivo,
     };
@@ -402,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/snapshot.js

@@ -0,0 +1,111 @@
+/**
+ * snapshot.js — a página como o agente precisa dela: o que dá para clicar e
+ * digitar, cada coisa com uma REF curta.
+ *
+ *   @e1 [link] "Preços" → /precos
+ *   @e2 [textbox] "E-mail" (seu@email.com)
+ *   @e3 [button] "Entrar"
+ *
+ * Antes o agente lia o innerText da página (6.000 caracteres de texto corrido,
+ * sem dizer o que é botão) e chutava um seletor CSS — `input[name="q"]` no
+ * Google, que é `textarea`. Errava, lia de novo, chutava de novo. Com a ref,
+ * clicar é `browser_click selector:"@e3"`: sem CSS, sem chute. A ideia é a do
+ * agent-browser da Vercel e do Playwright MCP (árvore de acessibilidade com
+ * refs); o código é nosso, roda no mesmo CDP que o PrimoCode já usa e não pede
+ * instalar nada.
+ *
+ * A ref mora no próprio elemento (data-primo-ref). Navegou ou a página se
+ * redesenhou, a ref some — e o erro diz para ler de novo, em vez de clicar no
+ * lugar errado.
+ */
+
+'use strict';
+
+const ATRIBUTO = 'data-primo-ref';
+
+/** O script que roda DENTRO da página e devolve { titulo, url, linhas, total }. */
+function scriptDoRetrato(max = 80) {
+    return `(function(){
+  var MAX = ${Number(max) || 80};
+  var ATR = ${JSON.stringify(ATRIBUTO)};
+  var velhos = document.querySelectorAll('[' + ATR + ']');
+  for (var i = 0; i < velhos.length; i++) velhos[i].removeAttribute(ATR);
+  function visivel(el) {
+    var r = el.getBoundingClientRect();
+    if (r.width < 2 || r.height < 2) return false;
+    var s = getComputedStyle(el);
+    return s.visibility !== 'hidden' && s.display !== 'none' && Number(s.opacity) > 0.05;
+  }
+  function limpo(t, n) { return String(t || '').replace(/\\s+/g, ' ').trim().slice(0, n || 60); }
+  function papel(el) {
+    var r = el.getAttribute('role');
+    if (r) return r;
+    var tag = el.tagName.toLowerCase();
+    if (tag === 'a') return 'link';
+    if (tag === 'button' || tag === 'summary') return 'button';
+    if (tag === 'select') return 'select';
+    if (tag === 'textarea') return 'textbox';
+    if (tag === 'input') {
+      var t = (el.type || 'text').toLowerCase();
+      if (t === 'checkbox' || t === 'radio') return t;
+      if (t === 'submit' || t === 'button' || t === 'reset') return 'button';
+      return 'textbox';
+    }
+    if (el.isContentEditable) return 'textbox';
+    return 'button';
+  }
+  function nome(el) {
+    var n = el.getAttribute('aria-label') || el.getAttribute('title') || '';
+    if (!n && el.id) { var l = document.querySelector('label[for="' + el.id + '"]'); if (l) n = l.innerText; }
+    if (!n && el.closest && el.closest('label')) n = el.closest('label').innerText;
+    // O innerText de um select são TODAS as opções — o nome dele é o rótulo.
+    if (!n && el.tagName !== 'SELECT') n = el.innerText || el.value || el.getAttribute('alt') || '';
+    if (!n) { var img = el.querySelector && el.querySelector('img[alt]'); if (img) n = img.alt; }
+    return limpo(n);
+  }
+  var SEL = 'a[href],button,input:not([type=hidden]),textarea,select,summary,[contenteditable=""],[contenteditable=true],'
+    + '[role=button],[role=link],[role=checkbox],[role=radio],[role=tab],[role=menuitem],[role=option],[role=textbox],'
+    + '[role=combobox],[role=switch],[role=searchbox],[onclick],h1,h2,h3';
+  var linhas = [], n = 0, total = 0;
+  var todos = document.querySelectorAll(SEL);
+  for (var j = 0; j < todos.length; j++) {
+    var el = todos[j];
+    if (!visivel(el)) continue;
+    var tag = el.tagName.toLowerCase();
+    if (/^h[1-3]$/.test(tag)) { var h = limpo(el.innerText, 80); if (h) linhas.push('#'.repeat(Number(tag[1])) + ' ' + h); continue; }
+    total++;
+    if (n >= MAX) continue;
+    n++;
+    var ref = 'e' + n;
+    el.setAttribute(ATR, ref);
+    var p = papel(el), txt = nome(el), extra = '';
+    if (p === 'link') { var href = el.getAttribute('href') || ''; if (href && href.indexOf('javascript:') !== 0) extra = ' → ' + href.slice(0, 60); }
+    if (p === 'textbox' && el.placeholder && el.placeholder !== txt) extra = ' (' + limpo(el.placeholder, 40) + ')';
+    if ((p === 'textbox' || p === 'select') && el.value) extra += ' = "' + limpo(el.value, 40) + '"';
+    if ((p === 'checkbox' || p === 'radio') && el.checked) extra += ' [marcado]';
+    if (el.disabled) extra += ' [desativado]';
+    linhas.push('@' + ref + ' [' + p + '] "' + txt + '"' + extra);
+  }
+  return { titulo: document.title, url: location.href, linhas: linhas, total: total };
+})()`;
+}
+
+/** Texto do retrato, pronto para o modelo. */
+function formatar(r, max = 80) {
+    if (!r) return '';
+    const cab = `${r.titulo || '(sem título)'} — ${r.url || ''}`;
+    const mais = r.total > max ? `\n… e mais ${r.total - max} elementos (role a página e leia de novo)` : '';
+    return `${cab}\n${(r.linhas || []).join('\n')}${mais}`;
+}
+
+/** "@e3" ou "e3" → o seletor CSS da ref; qualquer outra coisa passa igual. */
+function seletorDaRef(s) {
+    const m = /^@?(e\d+)$/.exec(String(s || '').trim());
+    return m ? `[${ATRIBUTO}="${m[1]}"]` : s;
+}
+function ehRef(s) { return /^@?e\d+$/.test(String(s || '').trim()); }
+
+const COMO_USAR = 'Para agir, use a ref como selector: browser_click selector:"@e3", '
+    + 'browser_type selector:"@e2" text:"…". A ref vale até a página mudar; depois de navegar, leia de novo.';
+
+module.exports = { scriptDoRetrato, formatar, seletorDaRef, ehRef, COMO_USAR, ATRIBUTO };