primocode 9.8.0-beta.2 → 9.8.0-beta.4

package/bin/primocode.js

@@ -21,6 +21,7 @@ const api = require('../lib/api');
 const tools = require('../lib/tools');
 const cfg = require('../lib/config');
 const nomeProjeto = require('../lib/nome-projeto');
+const kits = require('../lib/kits');
 const provedorLocal = require('../lib/local/provedor');
 const { runAct, interromper, ehTetoDeToken, ehTransitorio, esperaDoErro } = require('../lib/act');
 const fala = require('../lib/fala');
@@ -31,13 +32,17 @@ const effort = require('../lib/effort');
 const memoria = require('../lib/memoria-conversa');
 const registro = require('../lib/registro');
 const permissao = require('../lib/permissao');
+const perigo = require('../lib/perigo');
 const skills = require('../lib/skills');
+const checkpoint = require('../lib/checkpoint');
+const comandosLib = require('../lib/comandos');
 const marketplace = require('../lib/marketplace');
 const vozModo = require('../lib/voz');
 const appLib = require('../lib/app');
 const conta = require('../lib/conta');
 const nuvem = require('../lib/nuvem');
 const compat = require('../lib/compatibilidade');
+const mencoesLib = require('../lib/mencoes');
 
 // Rede de segurança de último recurso: sem isto, uma exceção fora de um
 // try/catch (ex.: dentro de um callback de socket, como o parser de SSE) não
@@ -98,10 +103,13 @@ ${c.bold('Comandos')}
   ${c.brand('/project')}            lista projetos ou cria em ~/primocode: /project <nome>
   ${c.brand('/mode')}               /mode primocode|chat|auto
   ${c.brand('/effort')}             esforço do agente — do rápido ao mais esperto
+  ${c.brand('/permissoes')}         quando ele pergunta antes de agir: auto|perguntar|livre
   ${c.brand('/compact')}            resume a conversa e devolve o contexto
-  ${c.brand('/attach')} <arquivo>   anexa arquivo ao próximo pedido
+  ${c.brand('/init')}               estuda o projeto e escreve o PRIMO.md
+  ${c.brand('/attach')} <arquivo>   anexa arquivo ao próximo pedido · ou @arquivo no pedido
   ${c.brand('/files')}              lista anexos   ${c.brand('/detach')} remove
   ${c.brand('/all')}                lista tudo que ele sabe fazer
+  ${c.brand('/desfazer')} [lista|N]  desfaz o que o último pedido (ou os N últimos) mudou
   ${c.brand('/tree')} [n]           árvore do projeto
   ${c.brand('/read')} <arquivo>     mostra um arquivo
   ${c.brand('/run')} <comando>      executa no shell do projeto
@@ -110,6 +118,7 @@ ${c.bold('Comandos')}
   ${c.brand('/login')}              entra na sua conta · ${c.brand('/account')} mostra o plano
   ${c.brand('/chats')} [n]          suas conversas — as mesmas do app e do celular
   ${c.brand('/logout')}             desconecta este computador da conta
+  ${c.brand('/comandos')}           seus comandos (/revisar, /explicar…) · /comandos novo <nome>
   ${c.brand('/status')}             checa o servidor
   ${c.brand('/name')} <nome>        como o Primo te chama
   ${c.brand('/mascot')} <estilo>    mascote: primo|fox|cat
@@ -141,11 +150,14 @@ const SLASH_COMANDOS = [
     ['/dir', 'trabalhar numa pasta sua'],
     ['/mode', 'primocode | chat | auto'],
     ['/effort', 'esforço: low → ultracode (←/→ para ajustar)'],
+    ['/permissoes', 'auto | perguntar | livre — quando ele pede licença'],
     ['/compact', 'resume a conversa e devolve o contexto'],
+    ['/init', 'estuda o projeto e escreve o PRIMO.md (as instruções dele)'],
     ['/attach', 'anexa arquivo ao pedido'],
     ['/detach', 'remove os anexos'],
     ['/files', 'lista os anexos'],
     ['/all', 'tudo que ele sabe fazer'],
+    ['/desfazer', 'desfaz o que o último pedido mudou nos arquivos (lista · N)'],
     ['/tree', 'árvore do projeto'],
     ['/read', 'mostra um arquivo'],
     ['/run', 'roda um comando'],
@@ -161,6 +173,7 @@ const SLASH_COMANDOS = [
     ['/skills', 'o que ele sabe fazer bem — ligue e desligue'],
     ['/marketplace', 'a tela das skills: navegue, ligue, crie'],
     ['/install-skill', 'instala uma skill de um arquivo'],
+    ['/comandos', 'seus comandos: um .md vira /nome · /comandos novo <nome>'],
     ['/api', 'usa a SUA chave (Gemini, ChatGPT, Claude…) direto daqui, sem o limite do servidor'],
     ['/status', 'checa o servidor'],
     ['/connectors', 'quem está atendendo os seus pedidos'],
@@ -312,9 +325,34 @@ function aplicarEffort(nome) {
 // Enquanto o slider está no ar, o fantasma do autocompletar não desenha.
 let sliderAtivo = false;
 
+/* Os comandos da pessoa (lib/comandos.js), com o do projeto atual por cima.
+   A caixa de digitar pede a lista a cada tecla para desenhar o fantasma; um
+   cache de dois segundos poupa ler três pastas por letra digitada, e ainda
+   pega na hora um arquivo que a pessoa acabou de salvar. */
+let cacheComandos = { em: 0, dir: null, lista: [] };
+function comandosDaPessoa() {
+    const agora = Date.now();
+    if (agora - cacheComandos.em > 2000 || cacheComandos.dir !== state.workDir) {
+        let lista = [];
+        try { lista = comandosLib.carregar({ projectDir: state.workDir }); } catch { /* disco estranho não trava a caixa */ }
+        cacheComandos = { em: agora, dir: state.workDir, lista };
+    }
+    return cacheComandos.lista;
+}
+
+/* O menu e o fantasma enxergam os dois tipos. O embutido vem primeiro e,
+   com o mesmo nome, o da pessoa nem aparece: quem ganha é sempre o embutido. */
+function comandosDoMenu() {
+    const embutidos = new Set(SLASH_COMANDOS.map(([n]) => n));
+    const deles = comandosDaPessoa()
+        .filter((x) => !embutidos.has('/' + x.nome))
+        .map((x) => ['/' + x.nome, x.descricao || `seu comando (${x.origem})`]);
+    return SLASH_COMANDOS.concat(deles);
+}
+
 function mostrarMenuSlash() {
     console.log('');
-    for (const [nome, desc] of SLASH_COMANDOS) {
+    for (const [nome, desc] of comandosDoMenu()) {
         console.log(`  ${c.brand(ui.padRight(nome, 12))}${c.muted(desc)}`);
     }
     console.log(c.dim('\n  Tab completa · metade do comando já serve: /eff vira /effort'));
@@ -554,14 +592,18 @@ const RE_PROJETO_NOVO = /\b(novo projeto|projeto novo|outro projeto|do zero|come
 const RE_CRIAR_UM = /\b(crie|cria|criar|fa[cç]a|faz|fazer|monte|monta|montar|gere|gera|desenvolva|construa|programe|quero|preciso de)\s+(um|uma|outro|outra|novo|nova)\b/;
 const RE_REFERE_ATUAL = /\b(isso|isto|esse|essa|este|esta|nele|nela|dele|dela|no projeto|nesse|nessa|neste|nesta|continua|continue|edita|edite|muda|mude|melhora|melhore|adiciona|adicione|coloca|coloque|p[oõ]e|corrige|corrija|arruma|arrume|ajusta|ajuste)\b/;
 
+/* "crie uma nova seção", "cria um botão", "faz uma tela de login": é um
+   PEDAÇO do projeto em que se está, não outro projeto. */
+const RE_PEDACO = /\b(um|uma|outro|outra|novo|nova)\s+(nov[ao]\s+)?(secao|secoes|parte|botao|botoes|tela|aba|menu|rodape|cabecalho|formulario|fase|funcao|funcionalidade|campo|imagem|animacao|efeito|cor|fonte|pagina interna|area|bloco|card|modal|link)\b/;
+
 function pedeProjetoNovo(texto) {
     const t = semAcento(texto);
     if (RE_PROJETO_NOVO.test(t)) return true;
-    if (!RE_CRIAR_UM.test(t) || RE_REFERE_ATUAL.test(t)) return false;
+    if (!RE_CRIAR_UM.test(t) || RE_REFERE_ATUAL.test(t) || RE_PEDACO.test(t)) return false;
     // Mesmo assunto do projeto atual ("crie uma fase nova pro jogo de carro")
     // é continuação, não projeto novo.
-    const atual = new Set(cfg.slugify(state.currentProject || '').split('-').filter((x) => x.length > 2));
-    const pedido = cfg.slugify(deriveProjectName(texto)).split('-').filter((x) => x.length > 2);
+    const atual = new Set(cfg.tokensDoAssunto(state.currentProject || ''));
+    const pedido = cfg.tokensDoAssunto(deriveProjectName(texto));
     return !pedido.some((x) => atual.has(x));
 }
 
@@ -642,10 +684,30 @@ function batizarDepois(plan, userText) {
         }, (evt) => { if (evt.delta) resposta += evt.delta; });
         return resposta;
     };
-    nomeProjeto.escolher({ pedido: userText, nomes: cfg.listProjects(), perguntar })
+    plan.batizando = nomeProjeto.escolher({ pedido: userText, nomes: cfg.listProjects(), perguntar })
         .then((nome) => { if (nome) plan.nomeEscolhido = nome; });
 }
 
+/* O kit de partida (lib/kits.js): pedido de landing numa pasta nova começa
+   de uma página pronta, e o agente só adapta. A pasta nasce AGORA, e não na
+   primeira escrita, porque o kit precisa estar lá antes de o agente ler. */
+async function prepararKit(plan, userText) {
+    const kit = kits.escolher(userText, { provedor: provedorLocal.atual() });
+    if (!kit) return '';
+    let dir = plan.dir;
+    if (plan.pending) {
+        await Promise.race([plan.batizando, new Promise((r) => setTimeout(r, 8000))]);
+        dir = createPendingProject(plan);
+        plan.pending = false;
+        plan.dir = dir;
+    }
+    if (!dir || path.resolve(dir) === path.resolve(cfg.ROOT_DIR)) return '';
+    const copiados = kits.aplicar(kit, dir);
+    if (!copiados.length) return '';
+    console.log(c.dim(`  ⎿ começando do kit de ${kit.nome} (${copiados.join(', ')}) — o agente só adapta`));
+    return kit.instrucao;
+}
+
 function createPendingProject(plan) {
     const dir = cfg.createProjectDir(plan.nomeEscolhido || plan.name);
     entrarNoProjeto(dir, 'projeto');
@@ -726,8 +788,15 @@ function prepararPasta(userText) {
  * Enter sozinho é NÃO. O padrão de quem apertou Enter sem ler não pode ser
  * entregar o mouse e o teclado.
  */
-async function autorizarControle(oQueVaiFazer, { primeira } = {}) {
-    if (primeira) {
+async function autorizarControle(oQueVaiFazer, { primeira, tipo } = {}) {
+    /* O mesmo portão serve ao /permissoes (lib/perigo.js): a pergunta muda de
+       cabeçalho, as três respostas são as mesmas. */
+    if (tipo) {
+        console.log('');
+        console.log('  ' + c.warn('▸▸') + ' ' + c.bold(c.white(tipo === 'perigo'
+            ? 'Isto não tem volta. O Primo quer:'
+            : 'O Primo quer (você escolheu /permissoes perguntar):')));
+    } else if (primeira) {
         console.log('');
         console.log('  ' + c.warn('▸▸') + ' ' + c.bold(c.white('O Primo quer usar o seu computador.')));
         console.log('  ' + c.muted('Ele vai mexer no mouse e no teclado de verdade, no programa que'));
@@ -758,7 +827,15 @@ async function autorizarControle(oQueVaiFazer, { primeira } = {}) {
  * simplesmente travava. Abrir o /voice e PEDIR em voz para ele mexer no
  * computador já é a autorização — é o produto funcionando como o Jarvis. Fica
  * dito no terminal, a cada ação, o que ele fez; e fechar o PrimoCode esquece. */
-async function autorizarPorVoz(oQueVaiFazer, { primeira } = {}) {
+async function autorizarPorVoz(oQueVaiFazer, { primeira, tipo } = {}) {
+    /* Pedir em voz é autorizar o que foi pedido — mas não o que não tem volta.
+       Ninguém está lendo o terminal para ver um `rm -rf` passar: o perigoso
+       é recusado, e o agente conta em voz o que ficou por fazer. */
+    if (tipo === 'perigo') {
+        console.log('  ' + c.warn('▸▸ recusado no modo voz: ') + c.muted(oQueVaiFazer));
+        return 'nao';
+    }
+    if (tipo) return 'agora';
     if (primeira) {
         console.log('  ' + c.warn('▸▸') + ' ' + c.muted('Modo voz: o Primo vai usar o mouse e o teclado. Você vê o cursor dele na tela.'));
     }
@@ -936,8 +1013,12 @@ async function sendPrompt(userText) {
     }
 
     let prompt = userText;
-    if (state.attachedFiles.length) {
-        const parts = state.attachedFiles.map((f) => `Arquivo: ${f.path}\n\`\`\`\n${f.content}\n\`\`\``);
+    // "@index.html" no pedido é um /attach só deste pedido: vai junto dos
+    // anexos, mas não fica em state.attachedFiles para o próximo.
+    const citados = mencoesDoPedido(userText);
+    const anexos = [...state.attachedFiles, ...citados];
+    if (anexos.length) {
+        const parts = anexos.map((f) => `Arquivo: ${f.path}\n\`\`\`\n${f.content}\n\`\`\``);
         prompt = parts.join('\n\n') + '\n\n' + userText;
     }
 
@@ -976,6 +1057,7 @@ async function sendPrompt(userText) {
         // num plano limitado por REQUISIÇÕES (o grátis da Groq são 30 por
         // minuto) cada chamada extra custa tanto quanto token.
         const passos = await dividirTarefa(prompt);
+        const instrucaoKit = await prepararKit(plan, userText);
 
         let r = null;
         let jaFeito = '';
@@ -984,6 +1066,8 @@ async function sendPrompt(userText) {
            interessa é o do pedido inteiro: quem pediu um vídeo não quer três
            balanços, quer saber o que existe no disco quando ele terminar. */
         const livro = registro.novo();
+        // Um checkpoint por PEDIDO (não por passo): é o que o /desfazer volta.
+        checkpoint.iniciar(userText);
         for (let i = 0; i < passos.length; i++) {
             if (i > 0) console.log(c.dim(`  ⎿ ${passos[i].titulo}`));
             // Só fato de passo CONCLUÍDO entra aqui. Num pedido real o passo de
@@ -1013,11 +1097,15 @@ async function sendPrompt(userText) {
                 ensureWorkDir: plan.pending ? () => createPendingProject(plan) : null,
                 // O portão do computador: quem pergunta é o terminal, quem
                 // lembra da resposta é a sessão.
-                autorizar: autorizarControle,
+                // No pedido único (`primo "…"`) não há ninguém para responder:
+                // sem `autorizar`, o que pede licença é recusado (lib/perigo.js).
+                autorizar: state.semTerminal ? undefined : autorizarControle,
                 controle: state.controle,
+                permissoes: state.config.permissoes,
                 // Pedido de mexer no computador leva a dica que libera as
                 // ferramentas desktop_* no servidor (ver DICA_COMPUTADOR).
-                instrucao: i === 0 && querComputador(userText) ? vozModo.DICA_COMPUTADOR : '',
+                instrucao: [instrucaoKit, i === 0 && querComputador(userText) ? vozModo.DICA_COMPUTADOR : '']
+                    .filter(Boolean).join('\n\n'),
             });
 
             r = await rodarPasso();
@@ -1058,6 +1146,7 @@ async function sendPrompt(userText) {
                 : '';
             if (r.parado) break;   // Esc Esc no meio do plano para o plano inteiro
         }
+        checkpoint.encerrar();
 
         /* O balanço, depois da resposta. Depois, e não antes, de propósito: o
            que a pessoa quer ler primeiro é o que ele TEM A DIZER; a lista de
@@ -1251,6 +1340,31 @@ async function esperarResumo(tetoMs = 15000) {
 /* A linha que vai junto do resumo: em que projeto se está. É o que faz
    "continua o jogo" e "muda a cor" caírem no mesmo projeto em vez de inventar
    outro. */
+function mencoesDoPedido(userText) {
+    const { arquivos, ignorados } = mencoesLib.mencoes(userText, projectDir());
+    const lidos = [];
+    for (const a of arquivos) {
+        try {
+            lidos.push({ path: a.rel, content: fs.readFileSync(a.abs, 'utf-8') });
+            console.log(c.dim(`  ⎿ anexado: ${a.rel} (${tools.fmtBytes(a.bytes)})`));
+        } catch { console.log(c.dim(`  ⎿ não consegui ler: ${a.rel}`)); }
+    }
+    for (const i of ignorados) console.log(c.dim(`  ⎿ não anexei ${i.rel}: ${i.motivo}`));
+    return lidos;
+}
+
+/* O pedido do /init. Passa pelo MESMO caminho de um pedido digitado
+   (sendPrompt → runAct), então usa as ferramentas e o provedor de agora — um
+   /init que falasse direto com o modelo não enxergaria os arquivos. */
+const PEDIDO_INIT = 'Estude este projeto (a pasta atual) e escreva um arquivo PRIMO.md na raiz dela. '
+    + 'Primeiro olhe de verdade: liste os arquivos, leia o README, o package.json (ou o equivalente) e os arquivos principais. '
+    + 'Depois escreva o PRIMO.md em português, curto (menos de 60 linhas), com estas seções: '
+    + 'o que é o projeto (2 ou 3 frases); como rodar (os comandos exatos que você viu, de instalar, rodar e testar); '
+    + 'a stack (linguagem, frameworks, banco); as convenções que o código segue (nomes, estilo, onde ficam os testes); '
+    + 'e onde está cada coisa (as pastas e arquivos que importam, uma linha cada). '
+    + 'Só escreva o que você conferiu nos arquivos — nada de inventar comando ou dependência. '
+    + 'Esse arquivo vai ser lido no começo de todo pedido neste projeto, então cada linha precisa valer o espaço.';
+
 function contextoDoProjeto() {
     if (!state.currentProject) return '';
     return `Projeto atual: ${state.currentProject} (pasta ${shortPath(projectDir())}). `
@@ -1258,6 +1372,14 @@ function contextoDoProjeto() {
         + 'trabalhe nos arquivos que já existem lá, não crie outro projeto.';
 }
 
+/* O chat não passa pelo runAct, e é no runAct (buildMemoryContext) que as
+   instruções do projeto entram. Sem isto o PRIMO.md valeria para o agente e
+   seria ignorado quando o modo auto manda o pedido para a conversa. */
+function comInstrucoes(history) {
+    const texto = mencoesLib.instrucoesDoProjeto(state.currentProject || state.workDir ? projectDir() : null);
+    return texto ? [{ role: 'system', content: texto }, ...history] : history;
+}
+
 // O chat também precisa parar no Esc Esc. Sem isto o texto continuava saindo
 // na tela depois de o usuário ter mandado parar.
 let chatEmVoo = null;
@@ -1284,7 +1406,7 @@ async function runChat(promptForModel, userTextForMemory) {
         try {
             await api.requestChat(state.config.server, {
                 prompt: promptForModel,
-                history: memoria.paraEnviar(state.memoria, state.history, contextoDoProjeto()),
+                history: comInstrucoes(memoria.paraEnviar(state.memoria, state.history, contextoDoProjeto())),
                 model: state.config.model,
                 token: state.config.token,
                 sinal: chatEmVoo.signal,
@@ -1411,6 +1533,49 @@ const RENOMEADOS = {
     tudo: 'all', capacidades: 'all',
 };
 
+/* Abrir uma conversa salva e seguir dela. Uma função só, para o /chats n e o
+   `primo -c` carregarem a conversa do MESMO jeito: dois caminhos divergiriam
+   no primeiro detalhe (a memória, o gravador) e um deles gravaria errado. */
+async function abrirConversa(alvo) {
+    const sp = new Spinner('abrindo').start();
+    const conv = await nuvem.lerConversa(alvo.id);
+    sp.stop();
+    if (!conv.ok) return conv;
+    // A memória entra ZERADA: o resumo antigo não veio junto, e um
+    // resumo de outra conversa colado aqui faria o modelo responder
+    // sobre coisa que não foi dita nesta.
+    state.history = conv.mensagens.map((m) => ({
+        role: m.papel, content: m.texto,
+    }));
+    state.memoria = memoria.nova();
+    state.gravador.retomar(alvo.id, alvo.titulo, conv.mensagens.length);
+    return conv;
+}
+
+/* `primo --continue` / `primo -c`: volta na última conversa, sem passar pelo
+   /chats. A lista do servidor já vem da mais recente para a mais antiga, então
+   a última é a primeira. Sem conta ou sem conversa, começa do zero e diz. */
+async function continuarUltima() {
+    if (!conta.atual()) {
+        console.log(c.dim('  ⎿ sem conta conectada, não há conversa para continuar — começando do zero'));
+        return false;
+    }
+    const l = await nuvem.listarConversas({ limite: 1 });
+    const alvo = l.ok && l.conversas[0];
+    if (!alvo) {
+        console.log(c.dim('  ⎿ nenhuma conversa salva ainda — começando do zero'));
+        return false;
+    }
+    const conv = await abrirConversa(alvo);
+    if (!conv.ok) {
+        console.log(c.dim(`  ⎿ não consegui abrir a última conversa (${conv.error}) — começando do zero`));
+        return false;
+    }
+    const quando = alvo.atualizada ? new Date(alvo.atualizada).toLocaleString('pt-BR') : 'data desconhecida';
+    console.log(c.dim(`  ⎿ continuando: ${alvo.titulo.slice(0, 60)} (${quando})`));
+    return true;
+}
+
 async function handleSlash(text) {
     const [cmd] = text.trim().slice(1).split(/\s+/);
     const rest = text.trim().slice(1 + cmd.length).trim();
@@ -1496,6 +1661,38 @@ async function handleSlash(text) {
             break;
         }
 
+        /* Quando ele pergunta antes de agir. Os três modos e o porquê de cada
+           um estão em lib/perigo.js. */
+        case 'permissoes':
+        case 'permissions': {
+            const DIZ = {
+                auto: 'roda tudo, mas pergunta antes do que não tem volta (apagar fora do projeto, push --force, sudo…)',
+                perguntar: 'pergunta antes de todo comando e de toda escrita de arquivo',
+                livre: 'nunca pergunta — nem antes do que não tem volta',
+            };
+            const atual = perigo.normalizarModo(state.config.permissoes);
+            if (!rest) {
+                console.log(c.muted('  Agora: ') + c.brand(atual) + c.muted(' — ' + DIZ[atual]));
+                for (const m of perigo.MODOS) console.log(`  ${m === atual ? c.brand('● ' + m) : c.muted('○ ' + m)}  ${c.dim(DIZ[m])}`);
+                console.log(c.dim('  Use /permissoes auto|perguntar|livre'));
+                break;
+            }
+            const pedido = rest.toLowerCase();
+            if (!perigo.MODOS.includes(perigo.normalizarModo(pedido)) || (perigo.normalizarModo(pedido) === 'auto' && pedido !== 'auto')) {
+                console.log(c.err('Uso: /permissoes auto|perguntar|livre'));
+                break;
+            }
+            const m = perigo.normalizarModo(pedido);
+            state.config.permissoes = m;
+            cfg.saveConfig({ permissoes: m });
+            console.log(c.ok(`  Permissões: ${m}`) + c.muted(' — ' + DIZ[m]));
+            if (m === 'livre') {
+                console.log('  ' + c.warn('▸▸ Atenção: ele vai apagar, forçar push e usar sudo sem te perguntar.'));
+                console.log('  ' + c.warn('   O que der errado pode não ter volta. /permissoes auto desfaz.'));
+            }
+            break;
+        }
+
         case 'mode': {
             const m = rest.toLowerCase();
             if (['primocode', 'chat', 'auto'].includes(m)) {
@@ -1556,6 +1753,20 @@ async function handleSlash(text) {
             break;
         }
 
+        case 'init': {
+            const alvo = path.join(projectDir(), 'PRIMO.md');
+            if (fs.existsSync(alvo) && !(await confirm(`Já existe um PRIMO.md em ${shortPath(projectDir())}. Escrever outro por cima?`))) {
+                console.log(c.muted('  Deixei o PRIMO.md como estava.'));
+                break;
+            }
+            // Escrever arquivo pede o agente: no modo chat (ou num auto que
+            // achasse que é conversa) o /init só responderia um texto.
+            const modoAntes = state.mode;
+            state.mode = 'primocode';
+            try { await sendPrompt(PEDIDO_INIT); } finally { state.mode = modoAntes; }
+            break;
+        }
+
         case 'detach': state.attachedFiles = []; console.log(c.ok('Anexos removidos.')); refreshPrompt(); break;
 
         case 'files':
@@ -1581,6 +1792,35 @@ async function handleSlash(text) {
             break;
         }
 
+        /* ── /desfazer ────────────────────────────────────────────────
+         * Quem não sabe git não tem como voltar uma edição ruim. Aqui volta:
+         * cada pedido guardou o original dos arquivos que mexeu. */
+        case 'desfazer': case 'undo': case 'rewind': {
+            const cps = checkpoint.lista(projectDir());
+            if (!cps.length) { console.log(c.muted('  Nada para desfazer nesta pasta.')); break; }
+            const quando = (cp) => new Date(cp.quando).toLocaleString('pt-BR', { dateStyle: 'short', timeStyle: 'short' });
+            if (/^(lista|list|ls)$/i.test(rest)) {
+                cps.forEach((cp, i) => console.log(`  ${c.brand(String(i + 1).padStart(2))}  ${c.dim(quando(cp))}  `
+                    + `${c.white(cp.pedido.slice(0, 50) + (cp.pedido.length > 50 ? '…' : ''))}  ${c.muted(cp.arquivos.length + ' arq.')}`));
+                console.log(c.muted('\n  /desfazer N volta os N últimos pedidos.'));
+                break;
+            }
+            const n = rest ? parseInt(rest, 10) : 1;
+            if (!(n >= 1)) { console.log(c.err('Uso: /desfazer · /desfazer lista · /desfazer N')); break; }
+            const alvo = cps.slice(0, n);
+            console.log(c.muted(`\n  Volta ${alvo.length === 1 ? 'o último pedido' : `os ${alvo.length} últimos pedidos`}:`));
+            for (const cp of alvo) {
+                console.log(`  ${c.dim(quando(cp))}  ${c.white(cp.pedido.slice(0, 60))}`);
+                for (const a of cp.arquivos) console.log(c.muted(`    ${a.existia ? 'volta ao original' : 'apaga (era novo)'}  `) + shortPath(a.caminho));
+            }
+            if (!(await confirm('Desfazer?'))) { console.log(c.muted('Cancelado.')); break; }
+            for (const f of checkpoint.desfazer(projectDir(), n)) {
+                const rotulo = f.acao === 'falhou' ? c.err(`  falhou: ${f.erro}  `) : c.ok(`  ${f.acao}  `);
+                console.log(rotulo + shortPath(f.caminho));
+            }
+            break;
+        }
+
         case 'tree': console.log(tools.treeDir(projectDir(), parseInt(rest, 10) || 2)); break;
 
         case 'read': {
@@ -1853,6 +2093,7 @@ async function handleSlash(text) {
                         return resposta;
                     }
                     const plan = prepararPasta(texto);
+                    checkpoint.iniciar(texto);
                     const resultado = await runAct(texto, {
                         instrucao: vozModo.COMO_FALAR,
                         server: state.config.server,
@@ -1865,6 +2106,7 @@ async function handleSlash(text) {
                         ensureWorkDir: plan.pending ? () => createPendingProject(plan) : null,
                         autorizar: autorizarPorVoz,
                         controle: state.controle,
+                        permissoes: state.config.permissoes,
                     });
                     const resposta = (resultado.assistantMessage && resultado.assistantMessage.content) || '';
                     // A conversa é a MESMA do terminal: sair do modo voz e
@@ -2067,18 +2309,8 @@ async function handleSlash(text) {
             const n = Number(rest);
             const alvo = l.conversas[n - 1];
             if (!alvo) { console.log(c.err(`  Não achei a conversa ${rest}.`)); break; }
-            const sp2 = new Spinner('abrindo').start();
-            const conv = await nuvem.lerConversa(alvo.id);
-            sp2.stop();
+            const conv = await abrirConversa(alvo);
             if (!conv.ok) { console.log(c.err(`  ${conv.error}`)); break; }
-            // A memória entra ZERADA: o resumo antigo não veio junto, e um
-            // resumo de outra conversa colado aqui faria o modelo responder
-            // sobre coisa que não foi dita nesta.
-            state.history = conv.mensagens.map((m) => ({
-                role: m.papel, content: m.texto,
-            }));
-            state.memoria = memoria.nova();
-            state.gravador.retomar(alvo.id, alvo.titulo, conv.mensagens.length);
             console.log(c.ok(`  ${alvo.titulo}`)
                 + c.muted(`  · ${conv.mensagens.length} mensagens carregadas`));
             console.log(c.dim('  Pode continuar daqui — o que você disser volta pro app e pro celular.'));
@@ -2154,6 +2386,29 @@ async function handleSlash(text) {
             break;
         }
 
+        /* Os comandos da pessoa: lista, e explica como fazer o dela. */
+        case 'comandos': {
+            const novo = rest.match(/^(novo|new|criar)\s+(\S+)$/i);
+            if (novo) {
+                const r = comandosLib.criar(novo[2]);
+                if (!r.ok) { console.log(c.err(`  ${r.error}`)); break; }
+                cacheComandos.em = 0;
+                console.log(c.ok(`  Criado: /${path.basename(r.arquivo, '.md')}`) + c.muted('  abra e escreva o pedido:'));
+                console.log('  ' + c.white(r.arquivo));
+                break;
+            }
+            const lista = comandosDaPessoa();
+            console.log(c.white('\n  Seus comandos'));
+            for (const x of lista) {
+                console.log(`  ${c.brand(ui.padRight('/' + x.nome, 14))}${c.dim(ui.padRight(x.origem, 11))}${c.muted(x.descricao)}`);
+            }
+            console.log(c.dim('\n  Um arquivo .md vira um comando: revisar.md é /revisar.'));
+            console.log(c.dim('  ~/.primocode/comandos/ vale em todo projeto · <projeto>/.primocode/comandos/ só naquele.'));
+            console.log(c.dim('  $ARGUMENTOS no texto recebe o que você digitar depois: /revisar o login.'));
+            console.log(c.dim('  /comandos novo <nome> cria um para você editar.'));
+            break;
+        }
+
         case 'claude': case 'gpt': case 'codex': case 'key': case 'keys': {
             console.log(c.muted('  Não existe mais provedor para configurar.'));
             console.log(c.muted('  A API já vem com o PrimoCode: entrou na conta, pode usar.'));
@@ -2165,7 +2420,18 @@ async function handleSlash(text) {
             // "/" sozinho abre o menu; um prefixo único autopreenche e executa
             // ("/eff" → /effort); prefixo ambíguo mostra as opções.
             if (!cmd) { mostrarMenuSlash(); break; }
-            const casam = SLASH_COMANDOS.map(([nome]) => nome.slice(1)).filter((n) => n.startsWith(cmd.toLowerCase()));
+            // Chegou aqui, não é embutido: o switch já atendeu todos eles.
+            // Por isso um /help.md da pessoa nunca troca o /help de verdade.
+            const proprio = comandosDaPessoa().find((x) => x.nome === nome);
+            if (proprio) {
+                console.log(c.dim(`  ⎿ /${proprio.nome} · ${proprio.origem}`));
+                // O MESMO caminho de um pedido digitado: modo, pasta, plano,
+                // tudo. Um atalho que pulasse o sendPrompt pularia junto o
+                // portão do plano e a escolha da pasta.
+                await sendPrompt(comandosLib.expandir(proprio, rest));
+                break;
+            }
+            const casam = comandosDoMenu().map(([nome]) => nome.slice(1)).filter((n) => n.startsWith(cmd.toLowerCase()));
             if (casam.length === 1) {
                 console.log(c.dim(`  → /${casam[0]}`));
                 await handleSlash('/' + casam[0] + (rest ? ' ' + rest : ''));
@@ -2174,7 +2440,7 @@ async function handleSlash(text) {
             if (casam.length > 1) {
                 console.log(c.muted(`  /${cmd}… pode ser:`));
                 for (const n of casam) {
-                    const [, desc] = SLASH_COMANDOS.find(([nome]) => nome === '/' + n);
+                    const [, desc] = comandosDoMenu().find(([nome]) => nome === '/' + n);
                     console.log(`    ${c.brand(ui.padRight('/' + n, 12))}${c.dim(desc)}`);
                 }
                 break;
@@ -2247,7 +2513,11 @@ async function main() {
     // mesmo que uma refatoração.
     state.mode = ['primocode', 'chat', 'auto'].includes(state.config.mode) ? state.config.mode : 'auto';
 
-    const args = process.argv.slice(2);
+    // `-c` / `--continue` pode vir em qualquer posição e sai da lista: o
+    // resto (one-shot, -f) segue sendo lido do jeito de sempre.
+    const todos = process.argv.slice(2);
+    const continuar = todos.some((a) => a === '-c' || a === '--continue');
+    const args = todos.filter((a) => a !== '-c' && a !== '--continue');
 
     // Flags padrão de CLI — funcionam em qualquer máquina, úteis em scripts/CI.
     if (args[0] === '--version' || args[0] === '-v' || args[0] === '-V') {
@@ -2312,28 +2582,23 @@ async function main() {
         const fileFlag = args.indexOf('-f');
         const words = fileFlag >= 0 ? args.slice(0, fileFlag) : args;
         const promptText = words.join(' ');
-        let fullPrompt = promptText;
 
         if (fileFlag >= 0 && args[fileFlag + 1]) {
             try {
                 const fc = fs.readFileSync(path.resolve(args[fileFlag + 1]), 'utf-8');
-                fullPrompt = `Arquivo: ${args[fileFlag + 1]}\n\`\`\`\n${fc}\n\`\`\`\n\n${promptText}`;
+                state.attachedFiles.push({ path: args[fileFlag + 1], content: fc });
             } catch { console.log(c.err(`Não consegui ler: ${args[fileFlag + 1]}`)); process.exit(1); }
         }
 
-        // Mesma função do modo interativo: detecta a pasta, adota projeto que já
-        // existe, e só então decide se há projeto novo pendente.
-        const plan = prepararPasta(promptText);
-        await runAct(fullPrompt, {
-            server: state.config.server,
-            model: state.config.model,
-            effort: state.config.effort,
-            token: state.config.token,
-            history: [],
-            projectDir: plan.dir,
-            projectName: plan.name || state.currentProject,
-            ensureWorkDir: plan.pending ? () => createPendingProject(plan) : null,
-        });
+        // Com -c, o pedido continua a última conversa em vez de chegar sozinho.
+        if (continuar) await continuarUltima();
+        /* O MESMO caminho do pedido digitado (sendPrompt). Este modo tinha um
+           runAct próprio, e por isso ficava sem tudo o que vive lá: o kit de
+           partida, o plano em passos, a retomada automática, o @arquivo, o
+           checkpoint do /desfazer. Medido em 24/09: `primo "crie uma landing…"`
+           não pegou o kit. */
+        state.semTerminal = true;
+        await sendPrompt(promptText);
         process.exit(0);
     }
 
@@ -2345,7 +2610,7 @@ async function main() {
     }));
     rl = entrada.criar({
         status: barraDeStatus,
-        comandos: () => SLASH_COMANDOS,
+        comandos: comandosDoMenu,
         vazio: 'peça alguma coisa, ou / para os comandos',
     });
 
@@ -2484,15 +2749,19 @@ async function main() {
         // o primocode-server, que tem a chave do provedor.
         state.liberado = !r || r.liberado !== false;
         state.motivoBloqueio = r && r.motivo;
-    }).catch(() => { state.liberado = true; }).then(() => {
-        // O que sobrou de adiantado não era resposta de nada: vira comando,
-        // na ordem em que foi digitado. Nada se perde, só esperou a vez.
-        segurando = false;
-        while (adiantadas.length) queue.push(adiantadas.shift());
-        if (queue.length) drain();
-        else if (!closed) rl.prompt();
-        conferirServidor();
-    });
+    }).catch(() => { state.liberado = true; })
+        // Depois da abertura, porque é nela que a pessoa entra na conta — e
+        // sem conta não há conversa para achar.
+        .then(() => (continuar ? continuarUltima().catch(() => false) : null))
+        .then(() => {
+            // O que sobrou de adiantado não era resposta de nada: vira comando,
+            // na ordem em que foi digitado. Nada se perde, só esperou a vez.
+            segurando = false;
+            while (adiantadas.length) queue.push(adiantadas.shift());
+            if (queue.length) drain();
+            else if (!closed) rl.prompt();
+            conferirServidor();
+        });
 }
 
 main().catch((e) => { console.error(c.err(e.message || e)); process.exit(1); });

package/comandos/explicar.md

@@ -0,0 +1,14 @@
+---
+descricao: explica este projeto (ou um arquivo) para quem não programa
+---
+Me explique como se eu nunca tivesse programado: $ARGUMENTOS
+
+Se eu não disse o que explicar, explique o projeto inteiro desta pasta. Leia os arquivos antes de falar, não chute.
+
+Responda nesta ordem, em frases curtas:
+1. o que isto faz, em uma frase;
+2. as partes principais e o papel de cada uma (use comparações do dia a dia);
+3. como eu rodo e vejo funcionando;
+4. onde eu mexo para mudar o que é mais provável que eu queira mudar.
+
+Sem jargão. Se uma palavra técnica for inevitável, explique ela na hora.