primocode 10.15.2 → 10.17.0

package/lib/memoria-usuario.js

@@ -0,0 +1,164 @@
+/**
+ * memoria-usuario.js — o PrimoCode lembra de quem a pessoa é.
+ *
+ * A memória que vale entre sessões, do jeito do Claude Code: um fato por
+ * arquivo .md em ~/.primocode/memoria/, e um índice MEMORIA.md com uma linha
+ * por fato. O índice entra no contexto de TODA sessão; o corpo de cada fato
+ * o modelo lê quando precisa (read_file no caminho).
+ *
+ *   ~/.primocode/memoria/MEMORIA.md          - [Título](arquivo.md) — gancho
+ *   ~/.primocode/memoria/<nome-em-kebab>.md  frontmatter (nome, descricao, tipo) + corpo
+ *
+ * Difere do memory-geral.md (uma lista corrida de frases) e do AGENTS.md da
+ * pasta (o resumo da conversa): aqui cada fato tem nome, tipo e pode ser
+ * atualizado ou apagado sem duplicar.
+ *
+ * HOME é injetável, como em lib/estudio/gosto.js: o teste usa uma casa temporária.
+ */
+
+'use strict';
+
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+
+const TIPOS = ['usuario', 'feedback', 'projeto', 'referencia'];
+const LINHAS_DO_INDICE = 200;
+const LIMITE_TEXTO = 8000;
+const INDICE = 'MEMORIA.md';
+
+// Cara de segredo: o fato fica em disco e volta em todo prompt, então chave não entra.
+const SEGREDOS = [
+    /\bsk-[A-Za-z0-9_-]{8,}/,
+    /\bAIza[0-9A-Za-z_-]{10,}/,
+    /\bgh[pousr]_[A-Za-z0-9]{10,}/,
+    /-----BEGIN [A-Z ]*(?:PRIVATE KEY|CERTIFICATE)?-----/,
+    /\bxox[abprs]-[A-Za-z0-9-]{8,}/,
+    /\bAKIA[0-9A-Z]{12,}/,
+    /\b(?:senha|password|passwd|token|api[_-]?key|secret)\s*[:=]\s*\S+/i,
+];
+
+function pasta(home = os.homedir()) { return path.join(home, '.primocode', 'memoria'); }
+function arquivoIndice(home) { return path.join(pasta(home), INDICE); }
+
+/** "Prefere Respostas Curtas!" → "prefere-respostas-curtas". '' se não sobrar nada. */
+function kebab(s) {
+    return String(s || '').normalize('NFD').replace(/[̀-ͯ]/g, '').toLowerCase()
+        .replace(/[^a-z0-9]+/g, '-').replace(/^-+|-+$/g, '').slice(0, 60).replace(/-+$/, '');
+}
+
+function umaLinha(s) { return String(s || '').replace(/\s+/g, ' ').trim(); }
+
+/** O texto parece ter segredo? Devolve true/false. Puro. */
+function temSegredo(...textos) {
+    return textos.some((t) => SEGREDOS.some((re) => re.test(String(t || ''))));
+}
+
+/** "usuario-prefere-curto" → "Usuario prefere curto": o título que aparece no índice. */
+function titulo(nome) {
+    const t = String(nome || '').replace(/-/g, ' ');
+    return t.charAt(0).toUpperCase() + t.slice(1);
+}
+
+function montar({ nome, descricao, tipo, texto }) {
+    return `---\nnome: ${nome}\ndescricao: ${descricao}\ntipo: ${tipo}\n---\n\n${String(texto).trim()}\n`;
+}
+
+/** Lê o frontmatter simples (chave: valor) e o corpo. null se não tem. */
+function analisar(conteudo) {
+    const m = String(conteudo || '').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() };
+}
+
+/** Todas as memórias, em ordem alfabética do arquivo. */
+function listar(home) {
+    let nomes = [];
+    try { nomes = fs.readdirSync(pasta(home)); } catch { return []; }
+    const saida = [];
+    for (const f of nomes.sort()) {
+        if (!f.endsWith('.md') || f === INDICE) continue;
+        let a = null;
+        try { a = analisar(fs.readFileSync(path.join(pasta(home), f), 'utf-8')); } catch { /* ilegível: pula */ }
+        if (!a) continue;
+        saida.push({ nome: a.nome || f.slice(0, -3), descricao: a.descricao || '', tipo: a.tipo || '', arquivo: f, corpo: a.corpo });
+    }
+    return saida;
+}
+
+/** Refaz o MEMORIA.md a partir dos arquivos: o índice nunca desanda do que existe. */
+function reindexar(home) {
+    const linhas = listar(home).map((m) => `- [${titulo(m.nome)}](${m.arquivo}) — ${m.descricao}`);
+    fs.mkdirSync(pasta(home), { recursive: true });
+    fs.writeFileSync(arquivoIndice(home), linhas.length ? linhas.join('\n') + '\n' : '', 'utf-8');
+}
+
+/**
+ * Salva ou atualiza (mesmo nome = mesmo arquivo, sem duplicar).
+ * Devolve { ok, nome, arquivo, criado } ou { ok:false, error }.
+ */
+function salvar({ nome, descricao, tipo, texto } = {}, home) {
+    const slug = kebab(nome);
+    if (!slug) return { ok: false, error: 'Dê um nome curto pra memória (ex.: "prefere-respostas-curtas").' };
+    const desc = umaLinha(descricao);
+    if (!desc) return { ok: false, error: 'Falta a descrição: uma linha dizendo do que se trata.' };
+    const t = String(tipo || '').toLowerCase();
+    if (!TIPOS.includes(t)) return { ok: false, error: `Tipo inválido. Use um destes: ${TIPOS.join(', ')}.` };
+    const corpo = String(texto || '').trim();
+    if (!corpo) return { ok: false, error: 'Falta o texto da memória.' };
+    if (corpo.length > LIMITE_TEXTO) return { ok: false, error: `Texto grande demais (máx. ${LIMITE_TEXTO} letras). Resuma.` };
+    if (temSegredo(nome, desc, corpo)) {
+        return { ok: false, error: 'Isso tem cara de segredo (chave, token ou senha). Não guardo isso na memória. Tire o segredo e tente de novo.' };
+    }
+    const arquivo = `${slug}.md`;
+    const caminho = path.join(pasta(home), arquivo);
+    const criado = !fs.existsSync(caminho);
+    try {
+        fs.mkdirSync(pasta(home), { recursive: true });
+        fs.writeFileSync(caminho, montar({ nome: slug, descricao: desc, tipo: t, texto: corpo }), 'utf-8');
+        reindexar(home);
+    } catch (e) { return { ok: false, error: `Não consegui gravar: ${e.message}` }; }
+    return { ok: true, nome: slug, arquivo, criado };
+}
+
+/** Apaga pelo nome. Devolve { ok } ou { ok:false, error }. */
+function apagar(nome, home) {
+    const slug = kebab(nome);
+    const caminho = path.join(pasta(home), `${slug}.md`);
+    if (!slug || !fs.existsSync(caminho)) return { ok: false, error: `Não achei a memória "${nome}".` };
+    try { fs.unlinkSync(caminho); reindexar(home); } catch (e) { return { ok: false, error: `Não consegui apagar: ${e.message}` }; }
+    return { ok: true, nome: slug };
+}
+
+/** O índice, cortado em `max` linhas (a cabeça fica). '' se não há memória. */
+function carregarIndice(home, max = LINHAS_DO_INDICE) {
+    let t = '';
+    try { t = fs.readFileSync(arquivoIndice(home), 'utf-8'); } catch { return ''; }
+    const linhas = t.split('\n').filter((l) => l.trim());
+    if (linhas.length <= max) return linhas.join('\n');
+    return linhas.slice(0, max).join('\n') + `\n(… cortado: mais ${linhas.length - max} memórias, use /memoria)`;
+}
+
+/** As regras de quando salvar. Entram no contexto junto com o índice. */
+const INSTRUCAO = '[memória]\n'
+    + 'Você tem memória que dura entre sessões, em ~/.primocode/memoria/ (ferramenta `lembrar`: ação salvar ou apagar). '
+    + 'O índice está abaixo; para ler uma memória, read_file no arquivo dela.\n'
+    + '- SALVE quando a pessoa corrige um jeito de trabalhar, diz uma preferência, conta quem é, ou dá um fato de projeto que não está no código. '
+    + 'tipo: usuario (quem é, como trabalha), feedback (correção ou preferência), projeto (fato do projeto), referencia (onde achar algo).\n'
+    + '- NÃO salve o que o código ou o git já mostram, nem o que só vale para esta conversa. Nunca salve chave, token ou senha.\n'
+    + '- ANTES de salvar, confira o índice: se já existe uma que cobre, salve com o MESMO nome para atualizar, em vez de duplicar.';
+
+/** O bloco que entra no contexto da sessão: instrução + índice. */
+/* No servidor (plano grátis) o contexto fixo é curto: o índice entra só com as primeiras `linhas`, e o resto
+   vira o aviso de corte. Com provedor próprio (/api) entra até LINHAS_DO_INDICE. */
+function blocoDoContexto(home, { linhas = LINHAS_DO_INDICE } = {}) {
+    const indice = carregarIndice(home, linhas);
+    return INSTRUCAO + (indice ? `\n\n[MEMORIA.md — o que você já sabe sobre esta pessoa]\n${indice}` : '\n\n(Ainda não há memórias salvas.)');
+}
+
+module.exports = { TIPOS, INDICE, LINHAS_DO_INDICE, pasta, arquivoIndice, kebab, temSegredo, listar, salvar, apagar, reindexar, carregarIndice, blocoDoContexto, INSTRUCAO };

package/lib/nuvem.js

@@ -300,6 +300,27 @@ async function lerConversa(id, { limite = 200 } = {}) {
     } catch (e) { return { ok: false, error: e.message }; }
 }
 
+/**
+ * Apaga uma conversa. O Firestore não apaga a subcoleção junto com o
+ * documento, então as mensagens vão antes, em lotes, e a conversa por último.
+ */
+async function apagarConversa(id) {
+    const s = await abrir();
+    if (!s) return { ok: false, error: 'não conectado' };
+    const base = `${BASE(s.projeto)}/users/${s.uid}/${COLECAO}/${id}`;
+    const auth = { Authorization: `Bearer ${s.idToken}` };
+    try {
+        for (let volta = 0; volta < 50; volta++) {
+            const r = await httpsJson(`${base}/messages?pageSize=300`, 'GET', null, auth);
+            const docs = r.documents || [];
+            if (!docs.length) break;
+            for (const d of docs) await httpsJson(`${FIRESTORE}/v1/${d.name}`, 'DELETE', null, auth);
+        }
+        await httpsJson(base, 'DELETE', null, auth);
+        return { ok: true };
+    } catch (e) { return { ok: false, error: e.message }; }
+}
+
 // ── o gravador da sessão ─────────────────────────────────────────────────
 
 /** Título a partir da primeira frase: uma linha, curta, sem cortar no meio de
@@ -331,7 +352,7 @@ function tituloDe(texto) {
  * terminal e simplesmente não sobe. Derrubar o turno de trabalho de alguém
  * porque o histórico não salvou seria trocar um incômodo por um prejuízo.
  */
-function gravador() {
+function gravador({ batizar } = {}) {
     let id = null;
     let titulo = null;
     let contagem = 0;
@@ -360,6 +381,7 @@ function gravador() {
                 const s = await abrir();
                 if (!s) return;                     // sem conta: fica só no local
                 if (!titulo) titulo = tituloDe(pergunta);
+                const nova = !id;                   // só a primeira troca de uma conversa nova ganha título da IA
                 if (!id) {
                     const r = await salvarConversa({ titulo });
                     if (!r.ok) { ultimoErro = r.error; return; }
@@ -375,6 +397,15 @@ function gravador() {
                 // celular. Sem esta volta, a conversa de hoje aparece embaixo
                 // das de semana passada.
                 await salvarConversa({ id, titulo, mensagens: contagem });
+                if (nova && batizar) {
+                    // O título da IA entra depois, num PATCH à parte: se falhar, fica o de antes, sem erro.
+                    let t = null;
+                    try { t = await batizar(pergunta, resposta); } catch { /* fica o título de antes */ }
+                    if (t && t !== titulo) {
+                        const r = await salvarConversa({ id, titulo: t, mensagens: contagem });
+                        if (r.ok) titulo = t;
+                    }
+                }
             });
         },
 
@@ -388,7 +419,7 @@ module.exports = {
     cifrar, decifrar, cifrarJson, decifrarJson,
     gravador, tituloDe,
     abrir, esquecer,
-    salvarConversa, salvarMensagem, listarConversas, lerConversa,
+    salvarConversa, salvarMensagem, listarConversas, lerConversa, apagarConversa,
     COLECAO, VERSAO_CIFRA, ITERACOES, TAM_IV,
     // A tradução para o formato do Firestore sai daqui porque é ela que decide
     // o que vira `stringValue` em claro e o que vira `mapValue` cifrado.

package/lib/passagem.js

@@ -0,0 +1,50 @@
+/**
+ * passagem.js — quando o agente PARA sem terminar, ele passa o bastão.
+ *
+ * Visto no SystemOneHarness (harnessrouter, Apache-2.0; só a ideia, código
+ * nosso): ao encerrar sem confiança, o agente grava o estado e o que falta
+ * para quem assumir — em vez de só dizer "parei". Aqui, "quem assume" é a
+ * próxima conversa ("continua"), que lê o memory.md da pasta.
+ *
+ * Antes, a memória guardava `Pedido` + os 500 primeiros caracteres do motivo
+ * ("Usei as 40 voltas…"). A conversa seguinte sabia QUE parou, mas não o que
+ * já existia no disco, o que falhou, nem por onde recomeçar — e relia a pasta
+ * às cegas (ou reescrevia um arquivo que já estava pronto).
+ *
+ * Puro: recebe o registro do pedido (lib/registro.js) e devolve o texto.
+ */
+
+'use strict';
+
+const lista = (xs, n = 12) => {
+    const v = (xs || []).filter(Boolean);
+    return v.length ? v.slice(0, n).join(', ') + (v.length > n ? ` (+${v.length - n})` : '') : '';
+};
+
+/**
+ * @param {{pedido: string, motivo: string, registro?: object, falhasPendentes?: Array<{texto: string}>}} dados
+ * @returns {string} bloco curto, em português, para o memory.md
+ */
+function montar({ pedido, motivo, registro, falhasPendentes = [] }) {
+    const reg = registro || {};
+    const L = [`**Pedido (NÃO concluído):** ${String(pedido || '').replace(/\s+/g, ' ').trim().slice(0, 300)}`,
+        `**Por que parei:** ${String(motivo || 'sem explicação').replace(/\s+/g, ' ').trim().slice(0, 300)}`];
+    const criados = lista(reg.criados), alterados = lista(reg.alterados);
+    if (criados) L.push(`**Já existe no disco (criei):** ${criados}`);
+    if (alterados) L.push(`**Já mudei:** ${alterados}`);
+    const testes = (reg.testes || []).slice(-3).map((t) => `${t.comando}: ${t.ok ? 'passou' : 'FALHOU'}`);
+    if (testes.length) L.push(`**Últimos testes:** ${testes.join(' | ')}`);
+    const falhas = [
+        ...(reg.falhas || []).slice(-3).map((f) => `${f.acao}${f.alvo ? ' ' + f.alvo : ''}: ${f.motivo}`),
+        ...falhasPendentes.slice(-2).map((f) => f.texto),
+    ].map((x) => String(x).replace(/\s+/g, ' ').slice(0, 160));
+    const unicas = [...new Set(falhas)];
+    if (unicas.length) L.push(`**O que falhou:** ${unicas.join(' | ')}`);
+    const arquivosFeitos = !!(criados || alterados);
+    L.push(arquivosFeitos
+        ? '**Ao retomar:** NÃO recomece do zero nem reescreva o que já existe — leia os arquivos acima, confira o que falta contra o pedido e continue de onde parou.'
+        : '**Ao retomar:** nada foi gravado ainda — comece pelo pedido, mas por um caminho diferente do que travou.');
+    return L.join('\n');
+}
+
+module.exports = { montar };

package/lib/perigo.js

@@ -25,6 +25,7 @@
 
 const os = require('os');
 const path = require('path');
+const protecao = require('./protecao');
 
 const MODOS = ['auto', 'perguntar', 'livre', 'plano'];
 const COMANDOS = new Set(['run_shell', 'run_in_new_terminal']);
@@ -122,7 +123,7 @@ function analisarTrecho(palavras, estado) {
     if (cmd === 'sudo' || cmd === 'doas') return 'usa sudo: mexe como administrador no computador inteiro';
     if (cmd === 'cd') { estado.cwd = path.resolve(estado.cwd, expandir(alvos[0] || os.homedir())); return null; }
     if ((cmd === 'sh' || cmd === 'bash' || cmd === 'zsh') && args[0] === '-c' && args[1]) {
-        return analisarComando(args[1], estado.cwd, estado.projeto);
+        return analisarComando(args[1], estado.cwd, estado.projeto, estado.baixados);
     }
     if (cmd === 'rm' || cmd === 'rmdir' || cmd === 'trash') {
         const recursivo = cmd === 'rmdir' || tem(/^-[a-zA-Z]*[rR]|^--recursive$/);
@@ -141,6 +142,7 @@ function analisarTrecho(palavras, estado) {
     }
     if (cmd === 'git') {
         const sub = alvos[0];
+        if (sub === 'add') { const r = protecao.gitAddLevaSegredo(alvos, flags, estado.cwd); if (r) return r; }
         if (sub === 'push' && (tem(/^--force$|^-[a-zA-Z]*f/) || alvos.some((a) => /^\+/.test(a)))) {
             return 'git push --force: reescreve o histórico no GitHub, e o que estava lá some';
         }
@@ -188,7 +190,7 @@ function mexeNoLivro(palavras, cwd) {
     return p.slice(1).some((x) => !/^-/.test(x) && noLivro(x.split(/>>?/)[0]));
 }
 
-function analisarComando(comando, cwd, projeto) {
+function analisarComando(comando, cwd, projeto, baixados = null) {
     const s = String(comando || '');
     // Baixar e rodar na hora: o que roda é o que o site mandar naquele segundo.
     if (/\b(curl|wget)\b[^;&]*\|\s*(sudo\s+)?(env\s+)?(ba|z|da|k)?sh\b/.test(s)) {
@@ -196,11 +198,16 @@ function analisarComando(comando, cwd, projeto) {
     }
     // O mesmo que mcp_conectar, pela porta dos fundos: não pula o portão.
     if (/\bprimocode\s+mcp\s+(conectar|connect|add)\b/.test(s)) return 'instala e roda um servidor MCP de terceiros';
-    const estado = { cwd, projeto, pulandoFlags: false };
+    const estado = { cwd, projeto, pulandoFlags: false, baixados };
     for (const t of trechos(s)) {
         if (mexeNoLivro(t.palavras, estado.cwd)) return 'mexe no livro de ações do PrimoCode (~/.primocode/registro), o registro do que o agente fez';
         const r = analisarTrecho(t.palavras, estado);
         if (r) return r;
+        const prot = protecao.shellEscreveEmProtegido(t.palavras);
+        if (prot) return prot;
+        const baix = protecao.rodaBaixado(t.palavras, estado.cwd, baixados);
+        if (baix) return baix;
+        if (baixados) protecao.baixadosPor(t.palavras).forEach((x) => baixados.add(path.resolve(estado.cwd, x)));
     }
     return null;
 }
@@ -209,13 +216,13 @@ function analisarComando(comando, cwd, projeto) {
  * Esta ação é perigosa?
  * @returns {{perigoso: boolean, motivo: string}}
  */
-function classificar(nome, args, { projectDir } = {}) {
+function classificar(nome, args, { projectDir, baixados = null } = {}) {
     const a = args || {};
     const projeto = path.resolve(projectDir || process.cwd());
-    let motivo = null;
+    let motivo = null, fora = false;
     if (COMANDOS.has(nome)) {
         const cwd = a.cwd ? path.resolve(projeto, expandir(a.cwd)) : projeto;
-        motivo = analisarComando(a.command, cwd, projeto);
+        motivo = analisarComando(a.command, cwd, projeto, baixados);
     } else if (nome === 'mcp_conectar') {
         /* Instala e roda código de terceiro (npx/uvx/docker) com as chaves do
            usuário: sempre pergunta, como o curl | sh. O motivo leva o comando,
@@ -227,9 +234,10 @@ function classificar(nome, args, { projectDir } = {}) {
         const rel = path.relative(projeto, alvo);
         if (rel.startsWith('..') || path.isAbsolute(rel) || /^[a-zA-Z]:[\\/]/.test(String(a.path))) {
             motivo = `mexe num arquivo fora da pasta do projeto (${a.path})`;
-        }
+            fora = true;
+        } else motivo = protecao.motivoDoArquivo(rel);
     }
-    return { perigoso: !!motivo, motivo: motivo || '' };
+    return { perigoso: !!motivo, motivo: motivo || '', fora };
 }
 
 /* Comando que só olha: todo trecho começa por uma palavra de leitura, sem
@@ -250,7 +258,7 @@ function somenteLeitura(comando) {
     });
 }
 
-function novo() { return { liberados: new Set(), negados: new Set() }; }
+function novo() { return { liberados: new Set(), negados: new Set(), baixados: new Set() }; }
 
 /* Uma pergunta por vez. Subagentes rodam em paralelo (Promise.all) e dois
    pedidos ao mesmo tempo no mesmo terminal se atropelariam. */
@@ -274,7 +282,7 @@ async function portao(estado, { modo, nome, args, projectDir, subagent = false,
         }
         return { ok: true };
     }
-    const { perigoso, motivo: motivoPerigo } = classificar(nome, args, { projectDir });
+    const { perigoso, motivo: motivoPerigo, fora } = classificar(nome, args, { projectDir, baixados: estado.baixados });
     const tipo = perigoso ? 'perigo' : (m === 'perguntar' && (COMANDOS.has(nome) || nome === 'mcp_usar')) ? 'comando'
         : (m === 'perguntar' && ESCRITAS.has(nome)) ? 'arquivo' : null;
     if (!tipo) return { ok: true };
@@ -287,7 +295,7 @@ async function portao(estado, { modo, nome, args, projectDir, subagent = false,
 
     // Escrever fora da pasta o tools.js já recusa sozinho: perguntar seria
     // pedir um "sim" que não serve para nada.
-    if (perigoso && ESCRITAS.has(nome)) {
+    if (perigoso && fora && ESCRITAS.has(nome)) {
         return recusa(`Recusado: ${motivo}. O PrimoCode só escreve dentro da pasta do projeto — use /dir se a pessoa quiser trabalhar em outra pasta.`);
     }
     if (subagent) {

package/lib/protecao.js

@@ -0,0 +1,134 @@
+/**
+ * protecao.js — três portas que o perigo.js não tinha, vistas no OpenWorker
+ * (andrewyng, MIT) e no repo de skills do Instagram (sergebulaev, MIT).
+ * Reescritas do nosso jeito: nenhum código copiado, só a ideia.
+ *
+ *  1. AUTOPROTEÇÃO. O agente não reescreve, calado, o arquivo que manda nele
+ *     (AGENTS.md, CLAUDE.md, .primocode/hooks.json…). Quem escreve ali muda o
+ *     comportamento de TODAS as próximas sessões, e a pessoa nem vê.
+ *  2. ARQUIVO QUE EXECUTA DEPOIS. `.git/hooks`, `.github/workflows`,
+ *     `.vscode/tasks.json`: o texto que entra ali roda mais tarde, fora desta
+ *     conversa e fora da vista da pessoa.
+ *  3. SEGREDO NO GIT. Uma chave real vazou num repo público porque o `.env`
+ *     foi parar num commit. `git add .env` (ou `git add -A` com um `.env` que
+ *     o .gitignore não cobre) agora pergunta.
+ *  4. PROCEDÊNCIA. Rodar um arquivo que o próprio agente baixou nesta sessão
+ *     (`curl -o x.sh … && bash x.sh`) sempre pergunta: é o `curl | sh` com um
+ *     passo no meio.
+ *
+ * Puro quase todo: o único I/O é ler o .gitignore e ver se o .env existe.
+ */
+
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+
+const norm = (p) => String(p || '').replace(/\\/g, '/').replace(/^\.\//, '');
+
+/** Esse caminho (relativo ao projeto) muda o agente ou roda depois? → motivo, ou null. */
+function motivoDoArquivo(rel) {
+    const p = norm(rel);
+    const nome = path.posix.basename(p);
+    if (/^(agents|claude|gemini)\.md$/i.test(nome) || nome === '.cursorrules' || /(^|\/)\.github\/copilot-instructions\.md$/.test(p)
+        || /(^|\/)\.(claude|cursor)\/(rules|commands|agents|settings(\.local)?\.json|hooks)/.test(p)
+        || /(^|\/)\.primocode\/(hooks\.json|comandos\/)/.test(p)) {
+        return `mexe num arquivo de regras do agente (${nome}): o que entra ali vale para todas as próximas sessões`;
+    }
+    if (/(^|\/)\.git\/hooks\//.test(p)) return `escreve num gancho do git (${nome}): roda sozinho em todo commit`;
+    if (/(^|\/)\.github\/workflows\//.test(p)) return `escreve num fluxo do GitHub Actions (${nome}): roda nos servidores, com as chaves do repositório`;
+    if (/(^|\/)\.vscode\/tasks\.json$/.test(p)) return 'escreve em .vscode/tasks.json: o editor roda isso quando a pasta é aberta';
+    if (/(^|\/)\.husky\//.test(p)) return `escreve num gancho do husky (${nome}): roda sozinho em todo commit`;
+    return null;
+}
+
+/** Palavra de comando que aponta para arquivo protegido? Tira o `>`/`>>` do começo. */
+function arquivoNaPalavra(w) {
+    const s = String(w).replace(/^\d?>>?/, '');
+    return s ? motivoDoArquivo(s) : null;
+}
+
+const ESCREVEM = new Set(['tee', 'cp', 'mv', 'ln', 'install', 'touch', 'truncate', 'rm', 'rsync', 'dd']);
+/** Um trecho de shell (já em palavras) escreve num arquivo protegido? */
+function shellEscreveEmProtegido(palavras) {
+    if (!palavras.length) return null;
+    const cmd = path.basename(palavras[0]);
+    const redirecionou = palavras.some((w, i) => /^\d?>>?$/.test(w) ? !!(palavras[i + 1] && motivoDoArquivo(palavras[i + 1])) : /^\d?>>?./.test(w) && !!arquivoNaPalavra(w));
+    const sedI = cmd === 'sed' && palavras.some((w) => /^-[a-zA-Z]*i/.test(w) || w === '--in-place');
+    if (!redirecionou && !sedI && !ESCREVEM.has(cmd)) return null;
+    for (let i = 0; i < palavras.length; i++) {
+        const w = palavras[i];
+        const alvo = /^\d?>>?$/.test(w) ? palavras[i + 1] : w;
+        const m = alvo && (/^\d?>>?./.test(alvo) ? arquivoNaPalavra(alvo) : (i > 0 || /^\d?>>?$/.test(w)) ? motivoDoArquivo(alvo) : null);
+        if (m) return m;
+    }
+    return null;
+}
+
+/* ── segredo no git ─────────────────────────────────────────────────── */
+
+const MODELO = /\.(example|sample|template|dist|defaults?)$/i;
+function nomeDeSegredo(alvo) {
+    const nome = path.posix.basename(norm(alvo));
+    if (MODELO.test(nome)) return false;
+    return /^\.env(\.[\w-]+)?$/i.test(nome) || /^id_(rsa|ed25519|ecdsa|dsa)$/.test(nome) || /\.(pem|p12|pfx|key)$/i.test(nome)
+        || /^(credentials?|service-account.*|secrets?)\.(json|ya?ml)$/i.test(nome) || nome === '.npmrc' || nome === '.netrc';
+}
+
+function envFicaDeFora(projeto) {
+    try {
+        const gi = fs.readFileSync(path.join(projeto, '.gitignore'), 'utf8').split('\n').map((l) => l.trim());
+        return gi.some((l) => /^\/?\.env(\*|\.\*)?\/?$/.test(l) || l === '*.env');
+    } catch { return false; }
+}
+
+/** `git add …` leva um segredo? `alvos` já sem as flags. */
+function gitAddLevaSegredo(alvos, flags, projeto) {
+    const lista = alvos.slice(1);
+    const duro = lista.find(nomeDeSegredo);
+    if (duro) return `git add ${duro}: um arquivo de segredo no commit vira chave vazada no GitHub`;
+    const tudo = lista.some((a) => a === '.' || a === '*' || a === ':/') || flags.some((f) => /^(-A|--all|-a)$/.test(f));
+    if (tudo && projeto) {
+        const temEnv = ['.env', '.env.local', '.env.production'].some((n) => { try { return fs.existsSync(path.join(projeto, n)); } catch { return false; } });
+        if (temEnv && !envFicaDeFora(projeto)) return 'git add de tudo, com um .env na pasta que o .gitignore não cobre: a chave iria junto no commit';
+    }
+    return null;
+}
+
+/* ── procedência: o que o agente baixou ─────────────────────────────── */
+
+/** Arquivos que um trecho de shell baixa (curl -o/-O, wget -O/padrão). */
+function baixadosPor(palavras) {
+    const cmd = path.basename(palavras[0] || '');
+    const urls = palavras.filter((w) => /^https?:\/\//i.test(w));
+    const saida = [];
+    if (cmd === 'curl') {
+        for (let i = 1; i < palavras.length; i++) {
+            const w = palavras[i];
+            if ((w === '-o' || w === '--output') && palavras[i + 1]) saida.push(palavras[i + 1]);
+            else if (/^-[a-zA-Z]*O$/.test(w) || w === '--remote-name') urls.forEach((u) => saida.push(path.posix.basename(u.split(/[?#]/)[0])));
+            else if (/^-o./.test(w)) saida.push(w.slice(2));
+        }
+    } else if (cmd === 'wget') {
+        const o = palavras.findIndex((w) => w === '-O' || w === '--output-document');
+        if (o > 0 && palavras[o + 1]) saida.push(palavras[o + 1]);
+        else urls.forEach((u) => saida.push(path.posix.basename(u.split(/[?#]/)[0]) || 'index.html'));
+    }
+    return saida.filter((x) => x && x !== '-');
+}
+
+const INTERPRETES = new Set(['sh', 'bash', 'zsh', 'dash', 'node', 'python', 'python3', 'ruby', 'perl', 'source', '.', 'deno', 'bun', 'npx', 'tsx']);
+/** O trecho roda um arquivo que foi baixado? `baixados` = Set de caminhos absolutos. */
+function rodaBaixado(palavras, cwd, baixados) {
+    if (!baixados || !baixados.size || !palavras.length) return null;
+    const abs = (x) => path.resolve(cwd, String(x));
+    const cmd = palavras[0];
+    let alvo = null;
+    if (INTERPRETES.has(path.basename(cmd))) alvo = palavras.slice(1).find((w) => !/^-/.test(w));
+    else if (/^\.{0,2}\//.test(cmd) || cmd.includes('/')) alvo = cmd;
+    else if (baixados.has(abs(cmd))) alvo = cmd;
+    if (alvo && baixados.has(abs(alvo))) return `roda um arquivo que o próprio agente baixou nesta sessão (${path.basename(alvo)}) sem a pessoa ter lido`;
+    return null;
+}
+
+module.exports = { motivoDoArquivo, shellEscreveEmProtegido, nomeDeSegredo, gitAddLevaSegredo, envFicaDeFora, baixadosPor, rodaBaixado };

package/lib/repeticao.js

@@ -100,7 +100,7 @@ function consultaDe(nome, args) {
  * ficam fora da época. */
 const OBSERVAM = new Set(['read_file', 'list_dir', 'glob', 'grep', 'browser_read', 'browser_screenshot',
     'desktop_screenshot', 'desktop_size', 'desktop_windows', 'desktop_elements']);
-const NAO_MUDAM = new Set(['write_todos', 'remember_general', 'pesquisar_referencia', ...REFERENCIAS]);
+const NAO_MUDAM = new Set(['write_todos', 'remember_general', 'lembrar', 'pesquisar_referencia', ...REFERENCIAS]);
 const SHELL_SO_LEITURA = /^\s*(ls|cat|head|tail|pwd|echo|grep|rg|find|wc|tree|stat|file|which|type|du|df|env|printenv|date|git\s+(status|log|diff|show|branch|remote))\b[^;&|>]*$/;
 
 function comandoDe(args) {