primocode 10.17.1 → 11.0.0

package/lib/afirmacoes.js

@@ -0,0 +1,56 @@
+/**
+ * afirmacoes.js — o "pronto" que diz ter mudado um arquivo que ninguém mexeu.
+ *
+ * O resumo do finish é o que a pessoa lê. "Atualizei o auth.js e corrigi o teste" com o auth.js intacto é a
+ * mentira que mais custa: ela confia e segue. Aqui: os arquivos que o resumo diz ter criado/editado/corrigido,
+ * conferidos contra o que a tarefa escreveu (tools) ou o que mudou no disco desde que ela começou (um `sed -i`,
+ * um gerador). Puro, menos o stat.
+ */
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+
+const VERBO = /\b(editei|alterei|atualizei|criei|corrigi|consertei|mudei|modifiquei|escrevi|adicionei|removi|refatorei|reescrevi|ajustei|implementei|updated|edited|created|modified|changed|fixed|added|wrote|rewrote|refactored|implemented)\b/i;
+const ARQ = /`?((?:[\w@.-]+\/)*[\w@-][\w@.-]*\.(?:js|mjs|cjs|ts|tsx|jsx|py|md|json|css|scss|html|go|rs|java|rb|php|ya?ml|toml|sh|sql|vue|svelte|txt))`?/gi;
+
+/** Os caminhos que o resumo diz ter mudado: os que aparecem na mesma frase, depois de um verbo de mudança. */
+function alegados(resumo) {
+    const out = new Set();
+    for (const frase of String(resumo || '').split(/(?<=[.!?;])\s+|\n+/)) {
+        const m = VERBO.exec(frase);
+        if (!m) continue;
+        const depois = frase.slice(m.index);
+        let a;
+        ARQ.lastIndex = 0;
+        while ((a = ARQ.exec(depois))) out.add(a[1].replace(/^\.\//, ''));
+    }
+    return [...out];
+}
+
+/** Dos alegados, os que a tarefa não tocou e que não mudaram no disco desde `desde` (ms). */
+function semMudanca(resumo, { tocados = new Set(), pasta = process.cwd(), desde = 0 } = {}) {
+    const nomesTocados = new Set([...tocados].map((p) => path.basename(p)));
+    const relTocados = new Set([...tocados].map((p) => path.relative(pasta, p).split(path.sep).join('/')));
+    return alegados(resumo).filter((a) => {
+        if (relTocados.has(a) || nomesTocados.has(path.basename(a))) return false;
+        try { if (fs.statSync(path.resolve(pasta, a)).mtimeMs >= desde - 1000) return false; } catch { /* não existe: alegou e não há */ }
+        return true;
+    });
+}
+
+/* "os testes passam", "todos os testes passaram", "tests pass", "build passou": a afirmação de prova */
+const DIZ_QUE_PASSOU = /\b((os |todos os )?testes? (passa|passam|passou|passaram|est[aã]o passando|verdes?|ok)|(all )?tests? (pass|passes|passed|passing|are green)|(o )?build (passa|passou|ok)|build (passes|passed))\b/i;
+const NEGA = /\b(n[aã]o|nenhum|sem|not|no|without|couldn't|could not|didn't|did not)\b[^.]{0,40}\b(test|teste|build)/i;
+
+/** O resumo diz que o teste passou, e o registro da tarefa não prova: null se está tudo certo, senão o motivo. */
+function testeSemProva(resumo, testes = []) {
+    const t = String(resumo || '');
+    if (!DIZ_QUE_PASSOU.test(t) || NEGA.test(t)) return null;
+    if (!testes.length) return 'nenhum teste rodou nesta tarefa';
+    const ultimo = testes[testes.length - 1];
+    if (ultimo && ultimo.ok === false) return `o último teste (\`${String(ultimo.comando || '').replace(/ · pelo PrimoCode$/, '')}\`) falhou`;
+    return null;
+}
+
+module.exports = { alegados, semMudanca, testeSemProva };

package/lib/agendar.js

@@ -0,0 +1,124 @@
+/**
+ * agendar.js — o /schedule: um pedido que roda sozinho, em dia e hora marcados.
+ *
+ *   /schedule "toda segunda às 9h" resuma o que mudou na semana
+ *   /schedule                      lista        /schedule off 2   tira o 2
+ *
+ *   entender(frase)          → { ok, dias, hora, minuto, texto } | { ok: false }   (dias: null = todo dia, ou [1..5])
+ *   separar(texto)           → { quando, pedido }     ("frase entre aspas" + o resto)
+ *   criar(dir, quando, pedido, deps) / listar(dir) / remover(dir, n, deps)
+ *
+ * No Mac vira um agente do launchd (~/Library/LaunchAgents) que roda `primocode -p "<pedido>"` na pasta do projeto
+ * e escreve o resultado em .primocode/agendados/<data>.md. Sem ninguém olhando: o modo -p recusa o que precisaria
+ * de um "sim" da pessoa. Em outro sistema o pedido fica salvo e a tela diz que o relógio automático é só do Mac.
+ * Os testes trocam `rodar` (launchctl) e `casa`: nada do sistema muda de verdade.
+ */
+
+'use strict';
+
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+const crypto = require('crypto');
+const { spawnSync } = require('child_process');
+
+const DIAS = { domingo: 0, segunda: 1, terca: 2, terça: 2, quarta: 3, quinta: 4, sexta: 5, sabado: 6, sábado: 6 };
+const NOME_DIA = ['domingo', 'segunda', 'terça', 'quarta', 'quinta', 'sexta', 'sábado'];
+const ARQ = (dir) => path.join(dir, '.primocode', 'agendados.json');
+const PASTA = (dir) => path.join(dir, '.primocode', 'agendados');
+const PREFIXO_LABEL = 'ai.primocode.agendado.';
+
+/** "toda segunda às 9h", "todo dia às 18:30", "dias úteis 8h30", "às 7h" → quando roda. */
+function entender(frase) {
+    const f = String(frase || '').toLowerCase().replace(/-feira/g, '').replace(/\s+/g, ' ').trim();
+    const h = f.match(/(?:\bàs?\b|\bas\b)?\s*(\d{1,2})\s*(?:h|:)\s*(\d{2})?\s*(?:h|horas?)?\s*$/) || f.match(/(?:às?|as)\s+(\d{1,2})\s*$/);
+    if (!h) return { ok: false };
+    const hora = Number(h[1]), minuto = h[2] ? Number(h[2]) : 0;
+    if (hora > 23 || minuto > 59) return { ok: false };
+    const resto = f.slice(0, h.index).replace(/(?:^|\s)(?:às?|as)\s*$/, '').trim();
+    let dias = null, rotulo = 'todo dia';
+    if (/dias? [uú]teis|segunda a sexta/.test(resto)) { dias = [1, 2, 3, 4, 5]; rotulo = 'dias úteis'; }
+    else if (/fim de semana|finais? de semana/.test(resto)) { dias = [6, 0]; rotulo = 'fim de semana'; }
+    else if (/todo dia|todos os dias|diari|^$/.test(resto)) { /* todo dia */ }
+    else {
+        const achados = [...new Set((resto.match(/\b(domingo|segunda|ter[cç]a|quarta|quinta|sexta|s[aá]bado)s?\b/g) || []).map((d) => DIAS[d.replace(/s$/, '')]))];
+        if (!achados.length) return { ok: false };
+        dias = achados; rotulo = 'toda ' + achados.map((d) => NOME_DIA[d]).join(' e ');
+    }
+    return { ok: true, dias, hora, minuto, texto: `${rotulo} às ${hora}h${minuto ? String(minuto).padStart(2, '0') : ''}` };
+}
+
+/** `"frase" pedido` (aspas retas ou curvas) ou, sem aspas, "toda segunda às 9h pedido…". */
+function separar(texto) {
+    const t = String(texto || '').trim();
+    let m = t.match(/^["“'‘]([^"”'’]+)["”'’]\s*(.*)$/s);
+    if (m) return { quando: m[1].trim(), pedido: m[2].trim() };
+    m = t.match(/^((?:todo dia|todos os dias|toda \S+|todas as \S+|dias [uú]teis|fim de semana)?\s*(?:às?|as)\s*\d{1,2}(?:\s*(?:h|:)\s*\d{0,2}\s*h?)?)\s+(.+)$/is);
+    return m ? { quando: m[1].trim(), pedido: m[2].trim() } : { quando: '', pedido: t };
+}
+
+function listar(dir) {
+    try { const j = JSON.parse(fs.readFileSync(ARQ(dir), 'utf8')); return Array.isArray(j) ? j : []; } catch { return []; }
+}
+function gravar(dir, lista) {
+    fs.mkdirSync(path.dirname(ARQ(dir)), { recursive: true });
+    fs.writeFileSync(ARQ(dir), JSON.stringify(lista, null, 2) + '\n');
+}
+
+const labelDe = (dir, id) => `${PREFIXO_LABEL}${crypto.createHash('sha1').update(path.resolve(dir)).digest('hex').slice(0, 8)}.${id}`;
+const plistDe = (casa, label) => path.join(casa, 'Library', 'LaunchAgents', `${label}.plist`);
+const xml = (s) => String(s).replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;');
+const aspas = (s) => `'${String(s).replace(/'/g, `'\\''`)}'`;
+
+/** O script que o relógio roda: lê o pedido de um arquivo (nada de aspas dentro de aspas) e anexa ao .md do dia. */
+function scriptDo(dir, a, { node = process.execPath, bin = path.join(__dirname, '..', 'bin', 'primocode.js') } = {}) {
+    return ['#!/bin/sh', `# /schedule ${a.id}: ${a.quando}`, `cd ${aspas(path.resolve(dir))} || exit 1`, 'mkdir -p .primocode/agendados',
+        'SAIDA=".primocode/agendados/$(date +%Y-%m-%d).md"',
+        `{ printf '\\n## %s — %s\\n\\n' "$(date +%H:%M)" ${aspas(a.pedido.slice(0, 80))}; ${aspas(node)} ${aspas(bin)} -p "$(cat .primocode/agendados/${a.id}.pedido.txt)"; } >> "$SAIDA" 2>&1`, ''].join('\n');
+}
+
+function plistDo(label, script, q) {
+    const horarios = (q.dias || [null]).map((d) => `        <dict>${d === null ? '' : `<key>Weekday</key><integer>${d}</integer>`}<key>Hour</key><integer>${q.hora}</integer><key>Minute</key><integer>${q.minuto}</integer></dict>`).join('\n');
+    return `<?xml version="1.0" encoding="UTF-8"?>\n<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">\n<plist version="1.0"><dict>\n    <key>Label</key><string>${xml(label)}</string>\n    <key>ProgramArguments</key><array><string>/bin/sh</string><string>${xml(script)}</string></array>\n    <key>StartCalendarInterval</key>\n    <array>\n${horarios}\n    </array>\n</dict></plist>\n`;
+}
+
+const lancar = (cmd, args) => { const r = spawnSync(cmd, args, { encoding: 'utf8' }); return { status: r.status, stderr: r.stderr || '' }; };
+
+/** Salva o pedido e, no Mac, liga o relógio. Devolve { ok, item, relogio, erro? }. */
+function criar(dir, quando, pedido, { plataforma = process.platform, casa = os.homedir(), rodar = lancar, uid = process.getuid ? process.getuid() : 501, node, bin } = {}) {
+    const q = entender(quando);
+    if (!q.ok) return { ok: false, erro: 'Não entendi quando. Me diga o dia e a hora, por exemplo: /schedule "toda segunda às 9h" resuma as novidades.' };
+    if (!String(pedido || '').trim()) return { ok: false, erro: 'Faltou o pedido. Exemplo: /schedule "todo dia às 8h" veja se o site está no ar.' };
+    const lista = listar(dir);
+    const id = String(Math.max(0, ...lista.map((x) => Number(x.id) || 0)) + 1);
+    const item = { id, quando: q.texto, pedido: pedido.trim(), dias: q.dias, hora: q.hora, minuto: q.minuto, criado: new Date().toISOString() };
+    fs.mkdirSync(PASTA(dir), { recursive: true });
+    fs.writeFileSync(path.join(PASTA(dir), `${id}.pedido.txt`), item.pedido + '\n');
+    const script = path.join(PASTA(dir), `${id}.sh`);
+    fs.writeFileSync(script, scriptDo(dir, item, { node, bin }), { mode: 0o755 });
+    let relogio = false;
+    if (plataforma === 'darwin') {
+        const label = labelDe(dir, id), plist = plistDe(casa, label);
+        fs.mkdirSync(path.dirname(plist), { recursive: true });
+        fs.writeFileSync(plist, plistDo(label, script, q));
+        const r = rodar('launchctl', ['bootstrap', `gui/${uid}`, plist]);
+        if (r.status !== 0) { try { fs.rmSync(plist); } catch { /* */ } return { ok: false, erro: `O relógio do Mac não aceitou: ${(r.stderr || '').trim().split('\n')[0] || 'erro desconhecido'}` }; }
+        relogio = true;
+    }
+    gravar(dir, [...lista, item]);
+    return { ok: true, item, relogio };
+}
+
+function remover(dir, n, { casa = os.homedir(), rodar = lancar, uid = process.getuid ? process.getuid() : 501 } = {}) {
+    const lista = listar(dir);
+    const i = lista.findIndex((x, k) => x.id === String(n) || String(k + 1) === String(n));
+    if (i < 0) return { ok: false, erro: `Não achei o agendamento ${n}. /schedule mostra a lista.` };
+    const [item] = lista.splice(i, 1);
+    const label = labelDe(dir, item.id);
+    rodar('launchctl', ['bootout', `gui/${uid}/${label}`]);
+    for (const f of [plistDe(casa, label), path.join(PASTA(dir), `${item.id}.sh`), path.join(PASTA(dir), `${item.id}.pedido.txt`)]) { try { fs.rmSync(f); } catch { /* já não existia */ } }
+    gravar(dir, lista);
+    return { ok: true, item };
+}
+
+module.exports = { entender, separar, criar, listar, remover, labelDe, plistDo, scriptDo, NOME_DIA };

package/lib/agentes/index.js

@@ -0,0 +1,146 @@
+'use strict';
+/**
+ * lib/agentes — Mastermind + Geral (sempre ligados) e 90+ especialistas (sob demanda).
+ * Divulgação progressiva: o núcleo é curto; o índice e as receitas só entram quando o modelo busca.
+ * Formato: docs/rebuild/agentes-arquitetura.md
+ */
+const fs = require('fs');
+const path = require('path');
+
+const RAIZ = path.join(__dirname, '..', '..', 'agentes');
+
+const semAcento = (s) => String(s || '').toLowerCase().normalize('NFD').replace(/[̀-ͯ]/g, '');
+const palavras = (s) => semAcento(s).split(/[^a-z0-9+#.]+/).filter((w) => w.length > 1);
+
+function frontmatter(texto) {
+    const m = String(texto).match(/^---\n([\s\S]*?)\n---\n?([\s\S]*)$/);
+    if (!m) return null;
+    const meta = {};
+    for (const l of m[1].split('\n')) {
+        const i = l.indexOf(':');
+        if (i > 0) meta[l.slice(0, i).trim()] = l.slice(i + 1).trim();
+    }
+    return { meta, corpo: m[2].trim() };
+}
+
+let CACHE = null;
+function carregar(raiz = RAIZ) {
+    if (CACHE && raiz === RAIZ) return CACHE;
+    const mapa = new Map();
+    // 1) índice: uma linha por agente. id|Nome|area|quando_usar|palavras
+    const idx = path.join(raiz, 'indice.md');
+    if (fs.existsSync(idx)) {
+        for (const l of fs.readFileSync(idx, 'utf8').split('\n')) {
+            if (!l || l.startsWith('#') || !l.includes('|')) continue;
+            const [id, nome, area, quando, chaves = ''] = l.split('|').map((s) => s.trim());
+            if (id) mapa.set(id, { id, nome, area, quando_usar: quando, palavras: chaves, briefing: null });
+        }
+    }
+    // 2) arquivos completos sobrescrevem a linha do índice
+    for (const f of fs.existsSync(raiz) ? fs.readdirSync(raiz) : []) {
+        if (!f.endsWith('.md') || f === 'indice.md') continue;
+        const p = frontmatter(fs.readFileSync(path.join(raiz, f), 'utf8'));
+        if (!p || !p.meta.id) throw new Error(`agente inválido: ${f}`);
+        mapa.set(p.meta.id, { ...p.meta, briefing: p.corpo });
+    }
+    if (raiz === RAIZ) CACHE = mapa;
+    return mapa;
+}
+
+/** Briefing de um agente; os só-índice ganham um briefing genérico honesto, ancorado na área. */
+function briefing(a) {
+    if (a.briefing) return a.briefing;
+    return `Você é o especialista em ${a.nome} (${a.area}): ${a.quando_usar}. Leia o que já existe e siga o padrão dele; faça a menor mudança que resolve; `
+        + 'não invente API, flag ou fato que você não conferiu. Pronto só com prova: rode o comando/teste ou abra o resultado e cite a saída.';
+}
+
+function porId(id) {
+    const n = semAcento(id).trim();
+    const m = carregar();
+    if (m.has(n)) return m.get(n);
+    return null;
+}
+
+/** Os N agentes que melhor casam com a consulta (pontos por palavra em palavras > nome/id > quando_usar > area). */
+function buscar(consulta, n = 5) {
+    const q = [...new Set(palavras(consulta))];
+    const lista = [];
+    for (const a of carregar().values()) {
+        const chaves = new Set(palavras(a.palavras));
+        const nome = new Set(palavras(`${a.id} ${a.nome}`));
+        const quando = new Set(palavras(a.quando_usar));
+        const area = new Set(palavras(a.area));
+        let pts = 0;
+        for (const w of q) {
+            if (chaves.has(w)) pts += 3;
+            if (nome.has(w)) pts += 3;
+            if (quando.has(w)) pts += 1;
+            if (area.has(w)) pts += 1;
+        }
+        if (pts > 0) lista.push({ a, pts });
+    }
+    lista.sort((x, y) => y.pts - x.pts || x.a.id.localeCompare(y.a.id));
+    return lista.slice(0, n).map((x) => x.a);
+}
+
+function linha(a) { return `${a.id} — ${a.nome} (${a.area}): ${a.quando_usar}`; }
+
+/** A ferramenta agentes_buscar: lista curta; `ver` traz o briefing completo de um. */
+function ferramentaBuscar({ consulta, ver }) {
+    if (ver) {
+        const a = porId(ver);
+        return a ? { ok: true, id: a.id, briefing: briefing(a) } : { ok: false, error: `sem agente "${ver}"; use agentes_buscar com uma consulta` };
+    }
+    if (!consulta) return { ok: true, total: carregar().size, areas: [...new Set([...carregar().values()].map((a) => a.area))] };
+    const achados = buscar(consulta, 6);
+    return { ok: true, total: carregar().size, resultados: achados.map(linha), dica: 'Chame spawn_agent com especialista="id" (ou "id1,id2" para dois olhares na mesma tarefa).' };
+}
+
+// ── capacidades do Geral ────────────────────────────────────────────────
+let CAPS = null;
+function capacidades() {
+    if (CAPS) return CAPS;
+    const dir = path.join(RAIZ, 'geral', 'capacidades');
+    CAPS = [];
+    for (const f of fs.existsSync(dir) ? fs.readdirSync(dir).sort() : []) {
+        if (!f.endsWith('.json')) continue;
+        const g = JSON.parse(fs.readFileSync(path.join(dir, f), 'utf8'));
+        for (const it of g.itens) CAPS.push({ ...it, grupo: g.grupo });
+    }
+    return CAPS;
+}
+function gruposDeCapacidades() {
+    const o = {};
+    for (const c of capacidades()) o[c.grupo] = (o[c.grupo] || 0) + 1;
+    return o;
+}
+function ferramentaCapacidade({ consulta, grupo }) {
+    if (!consulta && !grupo) return { ok: true, total: capacidades().length, grupos: gruposDeCapacidades() };
+    const q = [...new Set(palavras(consulta))];
+    const pts = capacidades().filter((c) => !grupo || c.grupo === grupo).map((c) => {
+        const alvo = new Set(palavras(`${c.nome} ${c.quando || ''} ${c.id}`));
+        return { c, p: q.reduce((s, w) => s + (alvo.has(w) ? 2 : 0) + (semAcento(c.receita).includes(w) ? 1 : 0), q.length ? 0 : 1) };
+    }).filter((x) => x.p > 0).sort((a, b) => b.p - a.p).slice(0, 5);
+    return { ok: true, resultados: pts.map(({ c }) => ({ id: c.id, grupo: c.grupo, nome: c.nome, receita: c.receita, prova: c.prova })) };
+}
+
+// ── delegação ───────────────────────────────────────────────────────────
+/** "react" ou "react,seguranca": até 3 olhares na mesma tarefa. Devolve [] se nenhum id existe. */
+function resolver(nomes) {
+    const ids = String(nomes || '').split(/[,+;]/).map((s) => s.trim()).filter(Boolean).slice(0, 3);
+    return ids.map(porId).filter(Boolean);
+}
+function montarTarefa(agentes, tarefa) {
+    if (!agentes.length) return String(tarefa || '');
+    const cab = agentes.map((a) => briefing(a)).join('\n\n');
+    const nota = agentes.length > 1 ? `\n\n(Você acumula ${agentes.length} olhares: ${agentes.map((a) => a.nome).join(' + ')}. Faça a tarefa uma vez, passando por cada checagem.)` : '';
+    return `${cab}${nota}\n\nSUA TAREFA:\n${tarefa}`;
+}
+function rotulo(agentes) { return agentes.length ? `Agente·${agentes.map((a) => a.id).join('+')}` : 'Agente'; }
+
+/** O que o Mastermind faz com o que voltou de N especialistas (vai no resultado do lote). */
+const REVISAO_DO_LOTE = '[mastermind] Entregas acima: confira cada "como provar", cruze os contratos entre partes (nomes, rotas, formatos) e mande de volta só o que falhou.';
+
+function nucleo() { return require('./nucleo.js').NUCLEO; }
+
+module.exports = { carregar, buscar, porId, briefing, ferramentaBuscar, ferramentaCapacidade, capacidades, gruposDeCapacidades, resolver, montarTarefa, rotulo, nucleo, REVISAO_DO_LOTE, frontmatter, RAIZ };

package/lib/agentes/nucleo.js

@@ -0,0 +1,18 @@
+'use strict';
+/* O núcleo sempre ligado: Mastermind + Geral. Teto de ~1.5k tokens (test/agentes.test.js mede). */
+const NUCLEO = `[mastermind]
+Pense como um engenheiro sênior, mesmo sendo um modelo pequeno:
+1. ENTENDA: diga em uma linha o que será entregue e como saberá que ficou pronto. Pedido ambíguo e barato de adivinhar: assuma, escreva a suposição, siga. Só pergunte se errar custa caro.
+2. PLANEJE o menor caminho que prova o resultado. Pedido pequeno: faça direto. Grande: write_todos com 3 a 7 passos.
+3. OLHE antes de mexer: leia o que existe e siga o padrão da casa. Não invente API, arquivo, flag ou fato: confira (grep, ler, rodar) ou diga que não conferiu.
+4. FAÇA uma mudança por vez, a menor que resolve. Ações independentes vão juntas na mesma resposta.
+5. PROVE: rode o teste/comando ou abra o resultado e cite a saída. "Deve funcionar" não é prova. Falhou: leia o erro inteiro, mude a hipótese (nunca repita o mesmo comando), no máximo 3 tentativas e depois diga o bloqueio.
+6. PARE quando a prova passou. Sem extras, sem refatorar o que não foi pedido, sem reler o que acabou de escrever.
+7. FINALIZE com finish: o que mudou, a prova, o que ficou de fora.
+
+[delegar]
+Parte que pede ofício (linguagem, framework, segurança, design, banco...) ou 2+ partes independentes: agentes_buscar("o que preciso") acha o especialista; spawn_agent especialista="id" (ou "id1,id2" para dois olhares). Vários spawn_agent na mesma resposta rodam em paralelo. O prompt é completo: o subagente não vê esta conversa. Quando voltarem, VOCÊ revisa: confira o "como provar" de cada um, cruze contratos entre as partes, devolva só o que falhou. Edição pequena de um arquivo: faça você.
+
+[geral]
+Você é o agente que faz de tudo: código, pesquisa, texto, shell, git, depuração, dados, arquivos. Há um catálogo de receitas (capacidade_buscar("tarefa"), sem argumento lista os grupos): git, shell, depuração, código, pesquisa, escrita, dados, arquivos, web/API, segurança. Antes de improvisar tarefa conhecida (rebase, bisect, regex, curl com auth, migração), busque a receita: ela traz o passo e a prova. Segredo nunca vai no chat nem no commit. Ação destrutiva ou irreversível: diga o que vai acontecer e peça o sim.`;
+module.exports = { NUCLEO };

package/lib/backup-banco.js

@@ -0,0 +1,121 @@
+/**
+ * backup-banco.js — a cópia do banco que o PrimoCode faz sozinho antes de apagar dado.
+ *
+ *   achar(projectDir)              → ['app.db', …]                 (arquivos SQLite do projeto, de verdade: confere o cabeçalho)
+ *   fazer(projectDir, agora?)      → { pasta, criado, arquivos } | null   (copia pra .primocode/backup/AAAA-MM-DD_HHMMSS/)
+ *   listar(projectDir)             → [backup], o mais novo primeiro
+ *   pendentes(projectDir)          → [backup] que ainda não foram restaurados
+ *   desde(projectDir, iso)         → os pendentes feitos a partir de `iso` (os do pedido que o /undo volta)
+ *   restaurar(projectDir, backup)  → [{ arquivo, acao }]            (copia de volta e marca como restaurado)
+ *
+ * O portão (lib/perigo.js) pergunta antes de DROP, TRUNCATE, DELETE sem WHERE e afins, e o checkpoint do /undo só vê a
+ * pasta: um banco que o .gitignore esconde não voltava. Aqui, quando a pessoa deixa o comando rodar, o arquivo de
+ * banco vai pra uma pasta de cópias ANTES, e o /undo devolve. Sem comando novo: quem nunca programou não precisa saber.
+ * Só SQLite (arquivo na pasta): Postgres e Supabase moram fora do computador e a cópia não alcança.
+ */
+
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+
+const EXT = /\.(db|sqlite3?|db3)$/i;
+const PULAR = new Set(['node_modules', '.git', '.primocode', '.venv', 'venv', '__pycache__', '.next', 'dist', 'build']);
+const COMPANHEIROS = ['-wal', '-shm', '-journal'];
+const MAX_PROFUNDIDADE = 6;
+const MAX_BYTES = 500 * 1024 * 1024;   // mais que isso, copiar a cada comando travaria o terminal
+const GUARDAR = 5;                     // quantas cópias ficam; as mais velhas saem
+
+const pastaDe = (projectDir) => path.join(projectDir, '.primocode', 'backup');
+
+function ehSqlite(arquivo) {
+    try {
+        const fd = fs.openSync(arquivo, 'r');
+        try { const b = Buffer.alloc(16); fs.readSync(fd, b, 0, 16, 0); return b.toString('latin1') === 'SQLite format 3\0'; }
+        finally { fs.closeSync(fd); }
+    } catch { return false; }
+}
+
+function achar(projectDir) {
+    const raiz = path.resolve(projectDir), achados = [];
+    const andar = (dir, fundo) => {
+        let itens = [];
+        try { itens = fs.readdirSync(dir, { withFileTypes: true }); } catch { return; }
+        for (const d of itens) {
+            const abs = path.join(dir, d.name);
+            if (d.isDirectory()) { if (fundo < MAX_PROFUNDIDADE && !PULAR.has(d.name)) andar(abs, fundo + 1); }
+            else if (d.isFile() && EXT.test(d.name) && ehSqlite(abs)) achados.push(path.relative(raiz, abs));
+        }
+    };
+    andar(raiz, 0);
+    return achados.sort();
+}
+
+function manifestDe(pasta) {
+    try { return { pasta, ...JSON.parse(fs.readFileSync(path.join(pasta, 'manifest.json'), 'utf8')) }; } catch { return null; }
+}
+
+function listar(projectDir) {
+    let nomes = [];
+    try { nomes = fs.readdirSync(pastaDe(projectDir)); } catch { return []; }
+    return nomes.sort().reverse().map((n) => manifestDe(path.join(pastaDe(projectDir), n))).filter(Boolean);
+}
+
+const doisDigitos = (n) => String(n).padStart(2, '0');
+function rotuloDaData(d) {
+    return `${d.getFullYear()}-${doisDigitos(d.getMonth() + 1)}-${doisDigitos(d.getDate())}_${doisDigitos(d.getHours())}${doisDigitos(d.getMinutes())}${doisDigitos(d.getSeconds())}`;
+}
+
+function fazer(projectDir, agora = new Date()) {
+    const raiz = path.resolve(projectDir);
+    const bancos = achar(raiz);
+    if (!bancos.length) return null;
+    const tamanho = bancos.reduce((s, b) => { try { return s + fs.statSync(path.join(raiz, b)).size; } catch { return s; } }, 0);
+    if (tamanho > MAX_BYTES) return null;
+    let pasta = path.join(pastaDe(raiz), rotuloDaData(agora)), n = 1;
+    while (fs.existsSync(pasta)) pasta = path.join(pastaDe(raiz), `${rotuloDaData(agora)}-${++n}`);
+    const copiados = [];
+    for (const b of bancos) {
+        for (const sufixo of ['', ...COMPANHEIROS]) {
+            const de = path.join(raiz, b + sufixo);
+            if (!fs.existsSync(de)) continue;
+            const para = path.join(pasta, b + sufixo);
+            fs.mkdirSync(path.dirname(para), { recursive: true });
+            fs.copyFileSync(de, para);
+            if (!sufixo) copiados.push(b);
+        }
+    }
+    const manifest = { criado: agora.toISOString(), arquivos: copiados, restaurado: false };
+    fs.writeFileSync(path.join(pasta, 'manifest.json'), JSON.stringify(manifest, null, 2));
+    for (const velho of listar(raiz).slice(GUARDAR)) fs.rmSync(velho.pasta, { recursive: true, force: true });
+    return { pasta, ...manifest };
+}
+
+const pendentes = (projectDir) => listar(projectDir).filter((b) => !b.restaurado);
+
+function desde(projectDir, iso) {
+    const t = new Date(iso).getTime();
+    return pendentes(projectDir).filter((b) => new Date(b.criado).getTime() >= t - 1000);
+}
+
+function restaurar(projectDir, backup) {
+    const raiz = path.resolve(projectDir), feitos = [];
+    for (const b of backup.arquivos) {
+        for (const sufixo of ['', ...COMPANHEIROS]) {
+            const de = path.join(backup.pasta, b + sufixo), para = path.join(raiz, b + sufixo);
+            try {
+                if (fs.existsSync(de)) { fs.mkdirSync(path.dirname(para), { recursive: true }); fs.copyFileSync(de, para); if (!sufixo) feitos.push({ arquivo: b, acao: 'voltou' }); }
+                else if (sufixo && fs.existsSync(para)) fs.rmSync(para);   // o -wal de hoje não combina com o banco de ontem
+            } catch (e) { if (!sufixo) feitos.push({ arquivo: b, acao: 'falhou', erro: e.message }); }
+        }
+    }
+    // marca este e tudo o que veio depois: o que se restaurou é de antes deles, não sobra nada pra voltar
+    const t = new Date(backup.criado).getTime();
+    for (const b of pendentes(raiz)) {
+        if (new Date(b.criado).getTime() < t) continue;
+        try { fs.writeFileSync(path.join(b.pasta, 'manifest.json'), JSON.stringify({ criado: b.criado, arquivos: b.arquivos, restaurado: true }, null, 2)); } catch { /* sem marca, só oferece de novo */ }
+    }
+    return feitos;
+}
+
+module.exports = { achar, fazer, listar, pendentes, desde, restaurar, pastaDe };

package/lib/boas-vindas.js

@@ -116,7 +116,7 @@ async function rodar({ perguntar, mostrar, cores: c, interativo = true,
         mostrar(c.err('  Sua conta ainda não tem um plano.'));
         mostrar(c.muted('  O PrimoCode é por assinatura, a partir de ') + c.brand('R$ 69,90/mês') + c.muted('.'));
         mostrar('');
-        mostrar(c.dim('  Veja os planos e assine: ') + c.brand('/planos'));
+        mostrar(c.dim('  Veja os planos e assine: ') + c.brand('/account plans'));
         mostrar(c.dim('  Já assinou? ') + c.brand('/account')
             + c.dim(' atualiza o plano nesta máquina.'));
         mostrar('');
@@ -127,7 +127,7 @@ async function rodar({ perguntar, mostrar, cores: c, interativo = true,
        Estar logado é o estado NORMAL do produto — anunciar isso toda vez é
        ruído, e ruído no primeiro instante empurra para baixo o que importa,
        que é a caixa de digitar. O selo do plano continua existindo onde quem
-       procura vai olhar (/account, /status); a abertura só diz alguma coisa
+       procura vai olhar (/account, /doctor status); a abertura só diz alguma coisa
        quando há algo a resolver. */
 
     /* Não há etapa 3. O que vinha aqui era a escolha do provedor de IA, e
@@ -143,7 +143,8 @@ async function rodar({ perguntar, mostrar, cores: c, interativo = true,
        a pessoa e o cursor. */
     if (primeira) {
         mostrar('');
-        mostrar(c.muted('  Tudo pronto. Pode pedir a primeira coisa.'));
+        mostrar(c.muted('  Tudo pronto. Pode pedir qualquer coisa, escrevendo normal, como numa conversa.'));
+        mostrar(c.muted('  Nunca programou? Digite ') + c.brand('/new') + c.muted(' e crie seu primeiro app com 3 perguntas.'));
     }
     mostrar('');
     return { liberado: true, plano, primeira, perguntou: false };

package/lib/catalogo.js

@@ -41,9 +41,15 @@ const GRUPOS = [
         resumo: 'rodar comando na sua máquina',
         itens: [
             { tool: 'run_shell',           escreve: false, faz: 'roda comando e devolve a saída',
-              args: 'command. timeout_ms (opcional, número, padrão 60000).' },
-            { tool: 'run_in_new_terminal', escreve: false, faz: 'abre outro terminal para o que fica de pé (servidor, watch)',
+              args: 'command. timeout_ms (opcional, número, padrão 60000). em_segundo_plano (opcional, true): roda solto, devolve um id e avisa quando terminar.' },
+            { tool: 'run_in_new_terminal', escreve: false, faz: 'abre outro terminal quando a PESSOA quer ver o servidor ou o watch rodando',
               args: 'command. cwd (opcional): pasta onde rodar.' },
+            { tool: 'run_background',      escreve: false, faz: 'se o comando fica de pé (servidor, watch), roda em segundo plano e deixa você ler a saída depois',
+              args: 'command. Devolve um id; confira que subiu com background_output.' },
+            { tool: 'background_output',   escreve: false, faz: 'lê a saída de uma tarefa em segundo plano (só o que é novo desde a última leitura)',
+              args: 'id. desde (opcional, número): o "ate" da leitura anterior.' },
+            { tool: 'stop_background',     escreve: false, faz: 'para uma tarefa em segundo plano',
+              args: 'id.' },
         ],
     },
     {
@@ -248,6 +254,16 @@ const GRUPOS = [
         itens: [
             { tool: 'write_todos', escreve: false, faz: 'monta o plano e vai marcando o que terminou',
               args: 'todos: lista de {content: a tarefa curta no imperativo, status: pending|in_progress|completed}. Reescreve a lista inteira a cada chamada; só uma "in_progress" por vez.' },
+            { tool: 'perguntar', escreve: false, faz: 'pergunta ao usuário com 2 a 4 opções — só quando está bloqueado',
+              args: 'pergunta. opcoes: lista de 2 a 4 textos curtos (a recomendada primeiro). texto_livre (opcional, padrão true).' },
+            { tool: 'buscar_web', escreve: false, faz: 'busca na internet e devolve links com trecho',
+              args: 'consulta: poucas palavras. limite (opcional, número, padrão 6).' },
+            { tool: 'ler_url', escreve: false, faz: 'abre um link e devolve o texto da página em markdown',
+              args: 'url: link completo. max_chars (opcional), desde (opcional, número: continua uma leitura cortada).' },
+            { tool: 'agentes_buscar', escreve: false, faz: 'acha o especialista certo no catálogo de 100+ agentes (ou traz o briefing de um)',
+              args: 'consulta: o que você precisa, em poucas palavras. ver (opcional): id de um agente para ler o briefing completo. Sem argumentos: lista as áreas.' },
+            { tool: 'capacidade_buscar', escreve: false, faz: 'acha uma receita pronta (git, shell, depuração, código, pesquisa, escrita, dados, arquivos, web, segurança)',
+              args: 'consulta: a tarefa. grupo (opcional): limita a um grupo. Sem argumentos: lista os grupos.' },
             { tool: 'pesquisar_referencia', escreve: false, faz: 'lê docs e exemplos antes de escrever — sobe a qualidade',
               args: 'consulta: o que pesquisar, de preferência em inglês. paginas (opcional, número, padrão 3, máximo 5).' },
             // Vai para memory-geral.md, FORA da pasta do projeto — por isso não
@@ -266,7 +282,7 @@ const GRUPOS = [
                 + 'Para só LER lá não precisa trocar: read_file/list_dir com o caminho absoluto, glob/grep com padrão absoluto.' },
             // Estas duas o loop do agente atende (lib/act.js), não o tools.execute.
             { tool: 'spawn_agent', escreve: false, faz: 'chama um subagente especialista para uma parte da tarefa', noLoop: true,
-              args: 'description: 3 a 5 palavras, aparece na tela do usuário. prompt: instrução completa e autossuficiente — o subagente não vê esta conversa. especialista (opcional): frontend, backend, testes, design, dados, revisor ou ambiente — cada um chega com o briefing da profissão (lib/especialistas.js); sem ele, a tarefa sugere.' },
+              args: 'description: 3 a 5 palavras, aparece na tela do usuário. prompt: instrução completa e autossuficiente — o subagente não vê esta conversa. especialista (opcional): id de agentes_buscar (frontend, backend, testes, react, sql, seguranca…) ou dois separados por vírgula — cada um chega com o briefing da profissão (lib/especialistas.js); sem ele, a tarefa sugere.' },
             { tool: 'construir_app', escreve: true, noLoop: true,
               faz: 'constrói um app ou site inteiro com quatro papéis: engenheiro de prompt → protótipo → MVP → revisor que testa escondido, em laço até passar',
               args: 'pedido: o que o usuário quer, com as palavras dele. pasta (opcional): onde construir — sem ela, uma pasta nova com o nome do pedido. rodadas (opcional, 1 a 4, padrão 2): quantas voltas de correção. '
@@ -303,7 +319,7 @@ const SHELL_QUE_CRIA = /\b(mkdir|touch|git\s+clone|npm\s+(init|create)|npx\s+(cr
 
 function criaProjeto(tool, args) {
     if (CRIAM_PROJETO.has(tool)) return true;
-    if (tool === 'run_shell' || tool === 'run_in_new_terminal') {
+    if (tool === 'run_shell' || tool === 'run_in_new_terminal' || tool === 'run_background') {
         return SHELL_QUE_CRIA.test(String((args && (args.command || args.comando)) || ''));
     }
     return false;

package/lib/chave-exposta.js

@@ -0,0 +1,61 @@
+/**
+ * chave-exposta.js — a chave que ficou escrita no código do app, antes do "pronto".
+ *
+ *   procurar(arquivos, { raiz }) → [{ arquivo, linha, tipo }]     (lê só os arquivos que a tarefa mexeu)
+ *   tipoDaLinha(texto)           → nome do tipo, ou null          (puro)
+ *
+ * Quem nunca programou cola a chave da OpenAI ou do Stripe direto no script.js, e o site publicado entrega a chave
+ * pra qualquer visitante (aibuilderclub.com, "vibe coding for non-technical founders" [VERIFICAR]). O .env é o lugar
+ * certo e não conta. A chave do Firebase (AIza…) fica de fora de propósito: ela é pública por natureza, vive no front.
+ */
+
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+
+const TIPOS = [
+    ['chave da OpenAI ou parecida', /\bsk-(?:proj-|live-|test-)?[A-Za-z0-9_-]{20,}/],
+    ['chave secreta do Stripe', /\b(?:rk|sk)_live_[A-Za-z0-9]{16,}/],
+    ['token do GitHub', /\bgh[pousr]_[A-Za-z0-9]{20,}/],
+    ['chave da AWS', /\bAKIA[0-9A-Z]{16}\b/],
+    ['token do Slack', /\bxox[abprs]-[A-Za-z0-9-]{10,}/],
+    // o bloco inteiro, do BEGIN ao END: só o cabeçalho deixava o corpo da chave no /exportar (achado da revisão)
+    ['chave privada', /-----BEGIN [A-Z ]*PRIVATE KEY-----[\s\S]*?(?:-----END [A-Z ]*PRIVATE KEY-----|$)/],
+    // senha/segredo com VALOR literal longo entre aspas: `token = getToken()` não é segredo
+    // o nome pode vir dentro de outro (DB_PASSWORD, JWT_SECRET, clientSecret, OPENAI_API_KEY) e entre aspas no JSON
+    // ("password": "…"); o \b do começo deixava passar os nomes mais comuns (achado da revisão)
+    ['senha ou segredo escrito no código', /(?:senha|password|passwd|secret|api[_-]?key|token)\w*["']?\s*[:=]\s*["'](?!AIza)[^"'\s]{16,}["']/i],
+];
+const FORA = /(^|\/)\.env(\.|$)|(^|\/)(node_modules|\.git)\//;   // o .env é o lugar certo
+
+function tipoDaLinha(texto) {
+    for (const [nome, re] of TIPOS) if (re.test(String(texto || ''))) return nome;
+    return null;
+}
+
+function procurar(arquivos, { raiz = process.cwd() } = {}) {
+    const achados = [];
+    for (const abs of new Set(arquivos || [])) {
+        const rel = path.relative(raiz, abs) || abs;
+        if (FORA.test(rel)) continue;
+        let texto;
+        try { if (fs.statSync(abs).size > 1024 * 1024) continue; texto = fs.readFileSync(abs, 'utf8'); } catch { continue; }
+        texto.split('\n').some((l, i) => {
+            const tipo = tipoDaLinha(l);
+            if (tipo) achados.push({ arquivo: rel, linha: i + 1, tipo });
+            return achados.length >= 5;
+        });
+        if (achados.length >= 5) break;
+    }
+    return achados;
+}
+
+/** O que a pessoa e o modelo leem. Puro. */
+function relato(achados) {
+    if (!achados || !achados.length) return '';
+    const onde = achados.slice(0, 3).map((a) => `${a.arquivo} (linha ${a.linha}: ${a.tipo})`).join('; ');
+    return `ficou uma chave escrita no código: ${onde}. Quem abrir o site ou o app consegue ler e usar essa chave.`;
+}
+
+module.exports = { procurar, tipoDaLinha, relato, TIPOS };