primocode 9.8.0-beta.2 → 9.8.0-beta.3

package/lib/act.js

@@ -21,7 +21,9 @@ const repeticao = require('./repeticao');
 const diff = require('./diff');
 const registro = require('./registro');
 const permissao = require('./permissao');
+const perigo = require('./perigo');
 const skills = require('./skills');
+const checkpoint = require('./checkpoint');
 
 // 40, não 15: com o freio de repetição (repeticao.js) e o de rodada parada,
 // volta a mais não é volta em círculo — é trabalho. Quinze acabavam no meio
@@ -475,6 +477,11 @@ function mapaDoProjeto(dir, limite = 80) {
 
 function buildMemoryContext(projectDir, projectName) {
     const parts = [];
+    // As instruções vêm primeiro: são regra de quem manda no projeto, e a
+    // memória é o que o agente anotou. Entram aqui (e não no bin) para valer
+    // igual no terminal, no modo voz e em cada passo de um plano.
+    const instrucoes = require('./mencoes.js').instrucoesDoProjeto(projectDir);
+    if (instrucoes) parts.push(instrucoes);
     const geral = cfg.readGeneralMemory();
     if (geral.trim()) parts.push(`[memory-geral.md]\n${geral}`);
     const projeto = cfg.readProjectMemory(projectDir);
@@ -493,6 +500,10 @@ async function runAct(userPrompt, opts) {
            quem sabe lembrar é a SESSÃO — um subagente não pode começar do
            zero e pedir de novo o que já foi autorizado. */
         autorizar = null, controle = null,
+        /* O modo do /permissoes (auto · perguntar · livre). Vem da config pela
+           CLI e desce para os subagentes pelo ctx: eles recusam o perigoso,
+           mas só sabem que é "livre" se alguém disser. */
+        permissoes = 'auto',
         /* O cliente HTTP, injetável. NÃO é mais um comutador de motor — o
            PrimoCode tem um motor só, o do servidor, e não há provedor para o
            usuário escolher. Continua um parâmetro porque é por aqui que o
@@ -962,7 +973,7 @@ async function runAct(userPrompt, opts) {
             fala.paralelo(juntos.length, profundidade);
             const rs = await Promise.all(juntos.map((tc) =>
                 runSubagent(tc.arguments || {}, {
-                    server, model, token, projectDir: pastaAtual, projectName, profundidade, motor,
+                    server, model, token, projectDir: pastaAtual, projectName, profundidade, motor, permissoes,
                 }).catch((e) => `Subagente falhou: ${e && e.message}`)));
             juntos.forEach((tc, i) => resultadosSpawn.set(tc.id, rs[i]));
         }
@@ -1005,7 +1016,7 @@ async function runAct(userPrompt, opts) {
                 const r = resultadosSpawn.has(tc.id)
                     ? resultadosSpawn.get(tc.id)
                     : await runSubagent(tc.arguments || {}, {
-                        server, model, token, projectDir: pastaAtual, projectName, profundidade, motor,
+                        server, model, token, projectDir: pastaAtual, projectName, profundidade, motor, permissoes,
                     });
                 repeticao.executou(jaChamado, tc.name, tc.arguments);
                 messages.push({ role: 'tool', tool_call_id: tc.id, content: r });
@@ -1018,7 +1029,7 @@ async function runAct(userPrompt, opts) {
                 algoRodou = true;
                 fala.acao(tc.name, tc.arguments, profundidade);
                 const r = await rodarDiretor(tc.arguments || {}, {
-                    server, model, token, projectDir: pastaAtual, projectName, profundidade, motor,
+                    server, model, token, projectDir: pastaAtual, projectName, profundidade, motor, permissoes,
                 });
                 logResult(tc.name, r, profundidade);
                 messages.push({ role: 'tool', tool_call_id: tc.id, content: JSON.stringify(r) });
@@ -1036,7 +1047,7 @@ async function runAct(userPrompt, opts) {
                 garantirPasta();
                 fala.acao(tc.name, tc.arguments, profundidade);
                 const r = await rodarPipeline(tc.arguments || {}, {
-                    server, model, token, projectDir: pastaAtual, projectName, profundidade, motor, livro, autorizar, controle: portaoControle,
+                    server, model, token, projectDir: pastaAtual, projectName, profundidade, motor, permissoes, livro, autorizar, controle: portaoControle,
                 });
                 logResult(tc.name, r, profundidade);
                 repeticao.executou(jaChamado, tc.name, tc.arguments);
@@ -1087,9 +1098,30 @@ async function runAct(userPrompt, opts) {
                 }
             }
 
+            /* O PORTÃO do que não tem volta (lib/perigo.js). No mesmo lugar do
+               portão do desktop e pelo mesmo motivo: antes, não depois. A
+               resposta mora no mesmo objeto da sessão — quem lembra é ela. */
+            if (!portaoControle.perigo) portaoControle.perigo = perigo.novo();
+            const risco = await perigo.portao(portaoControle.perigo, {
+                modo: permissoes, nome: tc.name, args: tc.arguments,
+                projectDir: pastaAtual, subagent, perguntar: autorizar,
+            });
+            if (!risco.ok) {
+                fala.acao(tc.name, tc.arguments, profundidade);
+                console.log(fala.resultado(profundidade) + c.warn(`não autorizado — ${risco.motivo}`));
+                registro.anotar(livro, tc.name, tc.arguments, { ok: false, error: risco.error });
+                messages.push({ role: 'tool', tool_call_id: tc.id, content: JSON.stringify({ ok: false, error: risco.error }) });
+                continue;
+            }
+
             algoRodou = true;
             rodouTool = true;
             fala.acao(tc.name, tc.arguments, profundidade);
+            /* Antes de mexer no arquivo, guarda o original — é o que o /desfazer
+               devolve. Caminho inválido não é problema nosso: a tool recusa. */
+            if (checkpoint.MUDAM_ARQUIVO.has(tc.name)) {
+                try { checkpoint.antesDeMudar(tools.resolveInProject(tc.arguments && tc.arguments.path, pastaAtual), pastaAtual); } catch {}
+            }
             const result = await tools.execute(tc.name, tc.arguments, { projectDir: pastaAtual });
             logResult(tc.name, result, profundidade);
             repeticao.executou(jaChamado, tc.name, tc.arguments);
@@ -1232,7 +1264,7 @@ async function runAct(userPrompt, opts) {
 }
 
 async function runSubagent(args, ctx) {
-    const { server, model, token, projectDir, projectName, profundidade, motor } = ctx;
+    const { server, model, token, projectDir, projectName, profundidade, motor, permissoes } = ctx;
     const descricao = args.description || 'sub-tarefa';
 
     if (profundidade + 1 >= MAX_PROFUNDIDADE) {
@@ -1251,6 +1283,7 @@ async function runSubagent(args, ctx) {
         profundidade: profundidade + 1,
         subagent: true,
         motor,
+        permissoes,
         autorizar: ctx.autorizar,
         controle: ctx.controle,   // o mesmo objeto: a resposta vale para todos
     });
@@ -1294,7 +1327,7 @@ async function runSubagent(args, ctx) {
  * inventar — e inventar é onde ele erra.
  */
 async function rodarDiretor(args, ctx) {
-    const { server, model, token, projectDir, projectName, profundidade, motor } = ctx;
+    const { server, model, token, projectDir, projectName, profundidade, motor, permissoes } = ctx;
     if (profundidade > 0) {
         return { ok: false, error: 'Recusado: o diretor não roda dentro de um subagente. '
             + 'Produza com o plano que você já recebeu.' };
@@ -1305,7 +1338,7 @@ async function rodarDiretor(args, ctx) {
         fala.agente('Diretor', rotulo, profundidade);
         const r = await runAct(prompt, {
             server, model, token, projectDir, projectName,
-            history: [], profundidade: profundidade + 1, subagent: true, motor,
+            history: [], profundidade: profundidade + 1, subagent: true, motor, permissoes,
         });
         return (r && r.assistantMessage && r.assistantMessage.content) || '';
     };
@@ -1338,7 +1371,7 @@ async function rodarDiretor(args, ctx) {
 }
 
 async function rodarPipeline(args, ctx) {
-    const { server, model, token, projectDir, projectName, profundidade, motor } = ctx;
+    const { server, model, token, projectDir, projectName, profundidade, motor, permissoes } = ctx;
     if (profundidade > 0) {
         return { ok: false, error: 'Recusado: o pipeline não roda dentro de um subagente — '
             + 'os papéis dele já são subagentes. Faça a parte que te cabe.' };
@@ -1361,7 +1394,7 @@ async function rodarPipeline(args, ctx) {
         fala.agente('Agente', rotulo, profundidade);
         const r = await runAct(prompt, {
             server, model, token, projectDir: pasta, projectName,
-            history: [], profundidade: profundidade + 1, subagent: true, motor,
+            history: [], profundidade: profundidade + 1, subagent: true, motor, permissoes,
         });
         return (r && r.assistantMessage && r.assistantMessage.content) || '';
     };
@@ -1376,5 +1409,5 @@ async function rodarPipeline(args, ctx) {
     });
 }
 
-module.exports = { runAct, interromper, compactar, motivoDaParada, pareceParadaNoMeio, ehTetoDeToken, ehTransitorio, esperaDoErro,
+module.exports = { runAct, buildMemoryContext, interromper, compactar, motivoDaParada, pareceParadaNoMeio, ehTetoDeToken, ehTransitorio, esperaDoErro,
     anotacaoDoQueJaFoi, encolherParaContinuar, MAX_ITERATIONS };

package/lib/checkpoint.js

@@ -0,0 +1,134 @@
+/**
+ * checkpoint.js — toda mudança do agente num arquivo tem volta.
+ *
+ * Quem usa o PrimoCode quase nunca sabe git. Uma edição ruim ("ele apagou
+ * metade do meu site") não pode ser o fim da história: antes de o agente
+ * escrever, editar ou apagar um arquivo, guardamos o conteúdo ORIGINAL dele,
+ * uma vez por pedido. O `/desfazer` devolve tudo como estava.
+ *
+ * Por que o checkpoint é do PEDIDO e não do passo: um pedido vira vários
+ * runAct (passos do plano, continuações, subagentes). Para a pessoa, "desfaz"
+ * quer dizer "desfaz o que eu pedi", não "desfaz o terceiro passo interno".
+ * Por isso o CLI chama `iniciar(pedido)` antes do laço de passos, e o loop do
+ * agente só avisa `antesDeMudar(arquivo, pasta)` — o estado fica aqui, no
+ * módulo, e o subagente (mesmo processo) cai no mesmo checkpoint.
+ *
+ * Onde fica: ~/.primocode/checkpoints/<projeto>-<hash>/<id>/
+ *   manifest.json   o pedido, a hora e cada arquivo (existia ou não)
+ *   0, 1, 2…        a cópia original de cada arquivo que existia
+ * Só os últimos MAXIMO por projeto: é rede de segurança, não arquivo morto.
+ */
+
+'use strict';
+
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+const crypto = require('crypto');
+
+const MAXIMO = 20;
+/** As tools de arquivo que mudam o disco. run_shell fica de fora: não dá para
+    saber, antes de rodar, que arquivos um comando vai tocar. */
+const MUDAM_ARQUIVO = new Set(['write_file', 'edit_file', 'multi_edit']);
+
+let atual = null;   // o pedido em andamento: { pedido, dir, manifest }
+
+/* os.homedir() lido na hora, não no require: o teste troca o HOME. */
+function raiz() { return path.join(os.homedir(), '.primocode', 'checkpoints'); }
+
+/** Uma pasta por projeto: o nome para a pessoa reconhecer, o hash para dois
+    projetos "site" em lugares diferentes não se misturarem. */
+function pastaDoProjeto(projectDir) {
+    const abs = path.resolve(projectDir);
+    const nome = path.basename(abs).replace(/[^\w.-]+/g, '-').slice(0, 40) || 'raiz';
+    const hash = crypto.createHash('sha1').update(abs).digest('hex').slice(0, 8);
+    return path.join(raiz(), `${nome}-${hash}`);
+}
+
+/** Começa o checkpoint de um pedido. Nada vai ao disco ainda: pedido que não
+    mexe em arquivo (uma pergunta, uma pesquisa) não deixa checkpoint vazio. */
+function iniciar(pedido) {
+    atual = { pedido: String(pedido || '').replace(/\s+/g, ' ').trim(), dir: null, manifest: null };
+}
+
+function encerrar() { atual = null; }
+
+function gravarManifest() {
+    fs.writeFileSync(path.join(atual.dir, 'manifest.json'), JSON.stringify(atual.manifest, null, 2));
+}
+
+/** Chamado pelo loop ANTES de uma tool de arquivo rodar. Guarda o original só
+    na primeira vez que o arquivo é tocado no pedido — a segunda edição do
+    mesmo arquivo não pode sobrescrever o original com a versão já editada. */
+function antesDeMudar(caminhoAbs, projectDir) {
+    if (!atual || !caminhoAbs) return;
+    try {
+        if (!atual.dir) {
+            const base = pastaDoProjeto(projectDir);
+            fs.mkdirSync(base, { recursive: true });
+            // Sempre maior que o anterior: a ordem dos ids É a ordem dos pedidos.
+            const ultimo = fs.readdirSync(base).filter((n) => /^\d+$/.test(n)).reduce((m, n) => Math.max(m, Number(n)), 0);
+            const id = String(Math.max(Date.now(), ultimo + 1));
+            atual.dir = path.join(base, id);
+            fs.mkdirSync(atual.dir);
+            atual.manifest = { pedido: atual.pedido, quando: new Date().toISOString(),
+                projectDir: path.resolve(projectDir), arquivos: [] };
+            podar(base);
+        }
+        const abs = path.resolve(caminhoAbs);
+        if (atual.manifest.arquivos.some((a) => a.caminho === abs)) return;
+        const existia = fs.existsSync(abs) && fs.statSync(abs).isFile();
+        const item = { caminho: abs, existia };
+        if (existia) {
+            item.copia = String(atual.manifest.arquivos.length);
+            fs.copyFileSync(abs, path.join(atual.dir, item.copia));
+        }
+        atual.manifest.arquivos.push(item);
+        gravarManifest();
+    } catch { /* checkpoint nunca derruba o trabalho do agente */ }
+}
+
+function podar(base) {
+    const ids = fs.readdirSync(base).filter((n) => /^\d+$/.test(n)).sort((a, b) => Number(b) - Number(a));
+    for (const velho of ids.slice(MAXIMO)) fs.rmSync(path.join(base, velho), { recursive: true, force: true });
+}
+
+/** Os checkpoints do projeto, o mais novo primeiro. */
+function lista(projectDir) {
+    const base = pastaDoProjeto(projectDir);
+    let ids = [];
+    try { ids = fs.readdirSync(base).filter((n) => /^\d+$/.test(n)); } catch { return []; }
+    return ids.sort((a, b) => Number(b) - Number(a)).map((id) => {
+        try {
+            const m = JSON.parse(fs.readFileSync(path.join(base, id, 'manifest.json'), 'utf8'));
+            return { id, dir: path.join(base, id), ...m };
+        } catch { return null; }
+    }).filter(Boolean);
+}
+
+/** Desfaz os N pedidos mais recentes, do mais novo para o mais velho — assim,
+    se dois pedidos mexeram no mesmo arquivo, o que sobra é o original do mais
+    antigo. Cada checkpoint desfeito é apagado: o próximo /desfazer volta mais
+    um pedido, em vez de repetir o mesmo. */
+function desfazer(projectDir, n = 1) {
+    const feitos = [];
+    for (const cp of lista(projectDir).slice(0, Math.max(1, n))) {
+        for (const a of cp.arquivos) {
+            try {
+                if (a.existia) {
+                    fs.mkdirSync(path.dirname(a.caminho), { recursive: true });
+                    fs.copyFileSync(path.join(cp.dir, a.copia), a.caminho);
+                    feitos.push({ caminho: a.caminho, acao: 'restaurado' });
+                } else {
+                    fs.rmSync(a.caminho, { force: true });
+                    feitos.push({ caminho: a.caminho, acao: 'apagado' });
+                }
+            } catch (e) { feitos.push({ caminho: a.caminho, acao: 'falhou', erro: e.message }); }
+        }
+        fs.rmSync(cp.dir, { recursive: true, force: true });
+        if (atual && atual.dir === cp.dir) atual = null;
+    }
+    return feitos;
+}
+
+module.exports = { MAXIMO, MUDAM_ARQUIVO, iniciar, encerrar, antesDeMudar, lista, desfazer, pastaDoProjeto };

package/lib/comandos.js

@@ -0,0 +1,104 @@
+/**
+ * comandos.js — o pedido que a pessoa repete vira um comando dela.
+ *
+ * Quem pede "revisa o projeto e me explica os bugs sem jargão" toda semana
+ * não deveria digitar isso toda semana. Um arquivo `revisar.md` com o pedido
+ * dentro vira `/revisar`, e `/revisar o login` troca `$ARGUMENTOS` por
+ * "o login". É o mesmo desenho dos comandos do Claude Code.
+ *
+ * ── POR QUE NÃO É UMA SKILL ──────────────────────────────────────────────
+ * Skill entra sozinha quando o pedido casa com o `quando:` dela. Comando só
+ * entra quando a pessoa chama pelo nome. Um é conhecimento de fundo, o outro
+ * é um atalho de digitação — e misturar os dois faria um atalho disparar
+ * sem ninguém ter pedido.
+ *
+ * ── ONDE MORAM, E QUEM GANHA ─────────────────────────────────────────────
+ *   1. `comandos/` do pacote       — os três que vêm de fábrica ("primocode")
+ *   2. `~/.primocode/comandos/`    — os da pessoa, em qualquer projeto ("global")
+ *   3. `<projeto>/.primocode/comandos/` — os daquele projeto ("projeto")
+ * O mais perto do trabalho ganha: o do projeto sabe coisas do projeto que o
+ * global não sabe. E o de fábrica perde para qualquer um, para a pessoa poder
+ * reescrever o `/revisar` do jeito dela sem mexer no pacote.
+ */
+
+'use strict';
+
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+const { separar } = require('./skills.js');
+
+const PASTA_DO_PACOTE = path.join(__dirname, '..', 'comandos');
+// O nome vira `/nome` na caixa de digitar: sem espaço, sem acento estranho,
+// sem barra — senão o comando existe no disco e não há como digitá-lo.
+const NOME_VALIDO = /^[a-z0-9][a-z0-9_-]*$/;
+
+/** Um arquivo .md → { nome, descricao, corpo, arquivo }. */
+function ler(arquivo) {
+    const { cabecalho, corpo } = separar(fs.readFileSync(arquivo, 'utf-8'));
+    return {
+        nome: path.basename(arquivo, '.md').toLowerCase(),
+        descricao: cabecalho.descricao || cabecalho.description || '',
+        corpo,
+        arquivo,
+    };
+}
+
+function daPasta(pasta, origem) {
+    let nomes = [];
+    try { nomes = fs.readdirSync(pasta); } catch { return []; }   // pasta que não existe é lista vazia
+    const fora = [];
+    for (const n of nomes.filter((x) => x.endsWith('.md')).sort()) {
+        try {
+            const c = ler(path.join(pasta, n));
+            if (NOME_VALIDO.test(c.nome) && c.corpo) fora.push({ ...c, origem });
+        } catch { /* um arquivo ilegível não derruba os outros */ }
+    }
+    return fora;
+}
+
+/** A lista final, um por nome, já com a precedência aplicada. */
+function carregar({ projectDir, home = os.homedir(), pastaDoPacote = PASTA_DO_PACOTE } = {}) {
+    const porNome = new Map();
+    // Em ordem crescente de prioridade: quem vem depois sobrescreve.
+    const camadas = [
+        [pastaDoPacote, 'primocode'],
+        [path.join(home, '.primocode', 'comandos'), 'global'],
+    ];
+    if (projectDir) camadas.push([path.join(projectDir, '.primocode', 'comandos'), 'projeto']);
+    for (const [pasta, origem] of camadas) {
+        for (const c of daPasta(pasta, origem)) porNome.set(c.nome, c);
+    }
+    return [...porNome.values()].sort((a, b) => a.nome.localeCompare(b.nome));
+}
+
+/** O prompt que vai ao agente. */
+function expandir(comando, argumentos) {
+    const args = String(argumentos || '').trim();
+    const corpo = comando.corpo;
+    if (corpo.includes('$ARGUMENTOS')) return corpo.split('$ARGUMENTOS').join(args).trim();
+    // Sem a marca, o que foi digitado não pode sumir: vai no fim.
+    return args ? `${corpo}\n\n${args}` : corpo;
+}
+
+/** Cria ~/.primocode/comandos/<nome>.md com um esqueleto. Devolve o caminho. */
+function criar(nome, { home = os.homedir() } = {}) {
+    const n = String(nome || '').trim().toLowerCase().replace(/^\//, '');
+    if (!NOME_VALIDO.test(n)) return { ok: false, error: 'Nome só com letras minúsculas, números, - e _.' };
+    const pasta = path.join(home, '.primocode', 'comandos');
+    const arquivo = path.join(pasta, n + '.md');
+    if (fs.existsSync(arquivo)) return { ok: false, error: `Já existe: ${arquivo}`, arquivo };
+    fs.mkdirSync(pasta, { recursive: true });
+    fs.writeFileSync(arquivo, [
+        '---',
+        `descricao: o que o /${n} faz, numa linha`,
+        '---',
+        'Escreva aqui o pedido, do jeito que você digitaria.',
+        '',
+        'O que vier depois do comando entra no lugar desta palavra: $ARGUMENTOS',
+        '',
+    ].join('\n'));
+    return { ok: true, arquivo };
+}
+
+module.exports = { PASTA_DO_PACOTE, NOME_VALIDO, ler, carregar, expandir, criar };

package/lib/config.js

@@ -129,15 +129,25 @@ function listProjects() {
     } catch { return []; }
 }
 
+/* Palavras que dizem o TIPO da coisa, não QUAL coisa. "landing da barbearia"
+   e "landing-nova" (de outra empresa) dividiam "landing", e o pedido novo caía
+   dentro do projeto antigo — medido em 24/09: a landing da Navalha de Ouro foi
+   escrita em landing-nova/. Só o assunto conta como parecido. */
+const GENERICAS = new Set(['landing', 'lading', 'page', 'pagina', 'site', 'app', 'aplicativo', 'projeto',
+    'novo', 'nova', 'sistema', 'web', 'html', 'teste', 'versao', 'final', 'the', 'para', 'pra']);
+function tokensDoAssunto(nome) {
+    return slugify(nome).split('-').filter((t) => t.length > 2 && !GENERICAS.has(t) && !/^v?\d+$/.test(t));
+}
+
 // Projeto parecido com o que o usuário pediu? Compara os pedaços do slug.
 // "jogo-de-carro" vs "jogo-carro-2d" -> compartilham jogo+carro -> 0.5
 function findSimilarProject(projectName, minScore = 0.4) {
-    const wanted = new Set(slugify(projectName).split('-').filter((t) => t.length > 2));
+    const wanted = new Set(tokensDoAssunto(projectName));
     if (!wanted.size) return null;
 
     let best = null;
     for (const existing of listProjects()) {
-        const tokens = new Set(existing.split('-').filter((t) => t.length > 2));
+        const tokens = new Set(tokensDoAssunto(existing));
         if (!tokens.size) continue;
         let shared = 0;
         for (const t of wanted) if (tokens.has(t)) shared++;
@@ -288,6 +298,9 @@ function loadConfig() {
         theme: file.theme || 'primo',
         // Modo escolhido dura entre sessões: quem liga o auto quer o auto amanhã.
         mode: process.env.PRIMOCODE_MODE || file.mode || 'auto',
+        // O /permissoes: quando ele pergunta antes de agir. Dura entre sessões
+        // pelo mesmo motivo do modo — quem escolheu "perguntar" quer amanhã também.
+        permissoes: file.permissoes || 'auto',
         rootDir: ROOT_DIR,
         _file: file,
     };
@@ -297,8 +310,8 @@ function saveConfig(partial) {
     ensureDir(CONFIG_DIR);
     const cur = (() => { try { return JSON.parse(fs.readFileSync(CONFIG_FILE, 'utf8')); } catch { return {}; } })();
     // Só persiste o que faz sentido guardar — nada de campos derivados.
-    const { server, model, effort, token, autoApply, currentProject, userName, mascot, theme, mode } = { ...cur, ...partial };
-    const next = { server, model, effort, token, autoApply, currentProject, userName, mascot, theme, mode };
+    const { server, model, effort, token, autoApply, currentProject, userName, mascot, theme, mode, permissoes } = { ...cur, ...partial };
+    const next = { server, model, effort, token, autoApply, currentProject, userName, mascot, theme, mode, permissoes };
     fs.writeFileSync(CONFIG_FILE, JSON.stringify(next, null, 2), 'utf8');
     return next;
 }
@@ -338,6 +351,7 @@ function esquecerProjeto() {
 }
 
 module.exports = {
+    tokensDoAssunto, GENERICAS,
     lembrarProjeto, projetoLembrado, esquecerProjeto, PROJETO_ATIVO_FILE,
     loadConfig, saveConfig, appendHistory,
     CONFIG_DIR, CONFIG_FILE, HISTORY_FILE, ROOT_DIR, GENERAL_MEMORY,

package/lib/kits.js

@@ -0,0 +1,81 @@
+/**
+ * kits.js — o modelo grátis começa de uma página pronta, e não do zero.
+ *
+ *   "A IA free fez essa página, ficou boa, mas quero que ela seja mais
+ *    rápida." · "Como chegar nesse nível com os modelos free? Nem terminou,
+ *    demora 10 anos." (24/09/2026)
+ *
+ * ── A CONTA ──────────────────────────────────────────────────────────────
+ * Uma landing boa são ~30 KB de HTML+CSS+JS — uns 9 mil tokens de SAÍDA. No
+ * plano grátis (6 mil tokens por minuto, entrada e saída juntas) isso não
+ * cabe numa resposta: o servidor manda "uma tool por vez", e a página sai em
+ * pedaços, com espera a cada minuto. E o modelo fraco, desenhando do zero,
+ * erra justamente o que dá o nível: tipografia, espaço, animação.
+ *
+ * Com o kit, o design já está resolvido (a landing que o Claude fez, com o
+ * conteúdo trocado por marcadores). O agente só TROCA texto e três cores com
+ * edit_file: ~1–2 mil tokens de saída em vez de 9 mil. Mais rápido E melhor,
+ * pela mesma razão — o trabalho difícil já foi feito uma vez, por quem faz
+ * bem.
+ *
+ * Só entra em pasta NOVA (ou vazia): num projeto que já tem página, copiar
+ * um kit por cima seria apagar o trabalho da pessoa.
+ */
+
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+
+const PASTA_KITS = path.join(__dirname, '..', 'kits');
+
+/* O pedido de landing. Estreito de propósito: "crie um app de tarefas" não é
+   landing, e um kit errado é pior que kit nenhum. */
+const RE_LANDING = /\b(landing|lading|p[áa]gina (de vendas|de captura|inicial|institucional|de apresenta[çc][ãa]o|pr[ao]|do meu|da minha|da empresa|do neg[óo]cio)|site (institucional|da empresa|do meu|da minha|pr[ao] (minha|meu|a|o))|one ?page|home ?page)\b/i;
+// Pedido que não quer a cara do kit: nada de puxar o kit por cima disso.
+const RE_SEM_KIT = /\b(do zero|sem modelo|sem template|sem kit|react|next(\.?js)?|vue|svelte|angular|tailwind|wordpress)\b/i;
+
+const KITS = {
+    landing: {
+        nome: 'landing',
+        arquivos: ['index.html', 'style.css', 'script.js'],
+        instrucao: 'A PASTA JÁ TEM UMA LANDING PRONTA (index.html, style.css, script.js), com design profissional, '
+            + 'animações e responsiva. NÃO reescreva os arquivos com write_file: é lento e piora o design. '
+            + 'ADAPTE com edit_file: (1) leia o index.html; (2) troque cada bloco marcado com <!-- TROQUE --> pelo '
+            + 'conteúdo do pedido — textos reais, específicos do negócio, sem inventar fato que você não sabe; '
+            + '(3) no topo do style.css troque só as cores --blue, --orange, --cyan (e as -deep) pelas cores que '
+            + 'combinam com o negócio; (4) apague os comentários TROQUE. Pode remover uma seção que não faz '
+            + 'sentido para o negócio (e o link dela no menu). Não mexa no script.js.',
+    },
+};
+
+/** Qual kit este pedido quer, ou null. */
+function escolher(pedido) {
+    const t = String(pedido || '');
+    if (!RE_LANDING.test(t) || RE_SEM_KIT.test(t)) return null;
+    return KITS.landing;
+}
+
+/** A pasta está livre para receber o kit? (não existe, ou só tem memory.md) */
+function pastaLivre(dir) {
+    try {
+        const tem = fs.readdirSync(dir).filter((n) => !n.startsWith('.') && n !== 'memory.md');
+        return tem.length === 0;
+    } catch { return true; }
+}
+
+/** Copia o kit para `dir`. Devolve os arquivos copiados, ou [] se não copiou. */
+function aplicar(kit, dir) {
+    if (!kit || !pastaLivre(dir)) return [];
+    fs.mkdirSync(dir, { recursive: true });
+    const feitos = [];
+    for (const nome of kit.arquivos) {
+        const destino = path.join(dir, nome);
+        if (fs.existsSync(destino)) continue;
+        fs.copyFileSync(path.join(PASTA_KITS, kit.nome, nome), destino);
+        feitos.push(nome);
+    }
+    return feitos;
+}
+
+module.exports = { KITS, PASTA_KITS, escolher, pastaLivre, aplicar };

package/lib/mencoes.js

@@ -0,0 +1,98 @@
+// O que a pessoa TRAZ para o pedido, além do texto: as instruções do projeto
+// (PRIMO.md, AGENTS.md, CLAUDE.md) e os arquivos citados com @.
+//
+// Ideia tirada do Claude Code (CLAUDE.md, @arquivo, /init) e do Codex
+// (AGENTS.md). Quem já escreveu um AGENTS.md para outro agente não deveria ter
+// de escrever de novo para o PrimoCode — então os três nomes valem.
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+
+/* ── INSTRUÇÕES DO PROJETO ───────────────────────────────────────────────
+ * Só o PRIMEIRO que existir, na ordem abaixo: um repo com AGENTS.md e
+ * CLAUDE.md quase sempre tem o mesmo texto nos dois (um aponta pro outro), e
+ * mandar os dois é pagar duas vezes pela mesma regra. O PRIMO.md vem antes
+ * porque é o que a pessoa escreveu PARA nós. */
+const NOMES_INSTRUCOES = ['PRIMO.md', 'AGENTS.md', 'CLAUDE.md'];
+const LIMITE_INSTRUCOES = 6000;
+
+// A cabeça fica, o rabo sai: é no começo que se escreve o que mais importa.
+function cortar(texto, limite) {
+    if (texto.length <= limite) return texto;
+    return texto.slice(0, limite).trimEnd() + '\n(cortado)';
+}
+
+function lerSeExiste(arquivo) {
+    try {
+        if (!fs.statSync(arquivo).isFile()) return '';
+        return fs.readFileSync(arquivo, 'utf-8');
+    } catch { return ''; }
+}
+
+/** O texto que entra no contexto, ou '' se não há instrução nenhuma. */
+function instrucoesDoProjeto(projectDir, limite = LIMITE_INSTRUCOES) {
+    const partes = [];
+    // HOME lido na hora, não na carga do módulo: o teste troca a casa.
+    const global = lerSeExiste(path.join(os.homedir(), '.primocode', 'PRIMO.md'));
+    if (global.trim()) partes.push(`[~/.primocode/PRIMO.md — suas instruções para todo projeto]\n${cortar(global, limite)}`);
+    if (projectDir) {
+        for (const nome of NOMES_INSTRUCOES) {
+            const texto = lerSeExiste(path.join(projectDir, nome));
+            if (!texto.trim()) continue;
+            partes.push(`[${nome} — instruções deste projeto: siga]\n${cortar(texto, limite)}`);
+            break;
+        }
+    }
+    return partes.join('\n\n');
+}
+
+/* ── @ARQUIVO ────────────────────────────────────────────────────────────
+ * O @ só conta no começo de uma palavra: "joel@x.com" e "@" solto passam
+ * direto. E só vira anexo o que existe DENTRO da pasta do projeto — "@../../
+ * .ssh/id_rsa" não pode mandar a chave de ninguém para o modelo. O que não
+ * resolve fica como está no texto: pode ser um @usuario de verdade. */
+const LIMITE_ARQUIVO = 40 * 1024;
+const LIMITE_TOTAL = 120 * 1024;
+const RE_MENCAO = /(^|[\s(])@(?:"([^"]+)"|([^\s"]+))/g;
+
+function pareceBinario(abs) {
+    let fd;
+    try {
+        fd = fs.openSync(abs, 'r');
+        const buf = Buffer.alloc(8000);
+        const lidos = fs.readSync(fd, buf, 0, buf.length, 0);
+        return buf.subarray(0, lidos).includes(0);
+    } catch { return true; }
+    finally { if (fd !== undefined) try { fs.closeSync(fd); } catch { /* já fechado */ } }
+}
+
+function mencoes(texto, projectDir, limites = {}) {
+    const porArquivo = limites.porArquivo || LIMITE_ARQUIVO;
+    const total = limites.total || LIMITE_TOTAL;
+    const arquivos = [];
+    const ignorados = [];
+    if (!texto || !projectDir) return { arquivos, ignorados };
+    const raiz = path.resolve(projectDir);
+    const vistos = new Set();
+    let soma = 0;
+    for (const m of String(texto).matchAll(RE_MENCAO)) {
+        // Pontuação colada ("veja @index.html.") é da frase, não do nome.
+        const bruto = m[2] || m[3].replace(/[.,;:!?)\]]+$/, '');
+        if (!bruto) continue;
+        const abs = path.resolve(raiz, bruto);
+        const rel = path.relative(raiz, abs);
+        if (!rel || rel.startsWith('..') || path.isAbsolute(rel)) continue;
+        let st;
+        try { st = fs.statSync(abs); } catch { continue; }
+        if (!st.isFile() || vistos.has(abs)) continue;
+        vistos.add(abs);
+        if (st.size > porArquivo) { ignorados.push({ rel, motivo: `grande demais (limite ${Math.round(porArquivo / 1024)} KB)` }); continue; }
+        if (pareceBinario(abs)) { ignorados.push({ rel, motivo: 'arquivo binário' }); continue; }
+        if (soma + st.size > total) { ignorados.push({ rel, motivo: `passou do total de ${Math.round(total / 1024)} KB` }); continue; }
+        soma += st.size;
+        arquivos.push({ rel, abs, bytes: st.size });
+    }
+    return { arquivos, ignorados };
+}
+
+module.exports = { mencoes, instrucoesDoProjeto, NOMES_INSTRUCOES, LIMITE_INSTRUCOES, LIMITE_ARQUIVO, LIMITE_TOTAL };