primocode 10.17.1 → 10.19.0

package/bin/primocode.js

@@ -38,6 +38,7 @@ const perigo = require('../lib/perigo');
 const skills = require('../lib/skills');
 const checkpoint = require('../lib/checkpoint');
 const comandosLib = require('../lib/comandos');
+const nomes = require('../lib/nomes');
 const marketplace = require('../lib/marketplace');
 const portaoSkill = require('../lib/portao-skill');
 const vozModo = require('../lib/voz');
@@ -49,10 +50,11 @@ const compat = require('../lib/compatibilidade');
 const mencoesLib = require('../lib/mencoes');
 const extra = require('../lib/comandos-extra');
 const offline = require('../lib/offline');
+const conferirLib = require('../lib/conferir');
 
 /* O /custo: toda conversa com o modelo passa pelo lib/api.js, e o contador
    embrulha as funções dele uma vez, aqui. Quem atende é o provedor do /api
-   quando há um, senão o servidor — é por eles que o /custo separa. */
+   quando há um, senão o servidor — é por eles que o /usage separa. */
 const contadorDaSessao = extra.novoContador();
 extra.instalarContador(api, contadorDaSessao, () => {
     const p = provedorLocal.atual();
@@ -93,6 +95,7 @@ const VERSION = pkg.version;
 const state = {
     config: cfg.loadConfig(),
     history: [],
+    passosProntos: null, // os passos que a pessoa aprovou no /plan: o próximo enviarPedido usa em vez de dividir
     resumindo: null,   // o resumo da última rodada, sendo feito em segundo plano
     mode: null,        // 'primocode' | 'chat' | 'auto' — vem da config em main()
     modoEfetivo: null, // no auto, o modo que o último pedido usou de fato
@@ -120,55 +123,32 @@ const state = {
     controle: permissao.novo(),
     currentProject: null,
     workDir: null,     // pasta onde o agente trabalha nesta sessão
-    workDirOrigem: null, // 'padrao' | '/dir' | 'detectada' | 'projeto' — para o /dir explicar
+    workDirOrigem: null, // 'padrao' | '/dir' | 'detectada' | 'projeto' | 'terminal' (o -p) — para o /dir explicar
 };
 
-const HELP = `
-${c.bold('Comandos')}
-  ${c.brand('/resume')} [n|id]      retoma uma conversa salva (sem argumento, lista)
-  ${c.brand('/worktree')} <nome>    cria ../<repo>-<nome> numa branch nova e entra
-  ${c.brand('/dir')} <caminho>      trabalha numa pasta que já existe (onde você quiser)
-  ${c.brand('/project')}            lista projetos ou cria em ~/primocode: /project <nome>
-  ${c.brand('/projetos')} [n]       projetos do mais recente, com tamanho · /projetos 2 entra
-  ${c.brand('/novo')} <descrição>   começa um projeto NOVO do zero, em pasta própria
-  ${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|plano
+/* O /help: os comandos nos 9 grupos de lib/nomes.js, cada um com a descrição
+   que o menu já tem (SLASH_COMANDOS + os .md da pessoa e de fábrica). É função
+   porque SLASH_COMANDOS nasce depois deste ponto do arquivo. */
+function linhasDosGrupos() {
+    const desc = new Map(comandosDoMenu().map(([n, d]) => [n.slice(1), d]));
+    const saida = [];
+    for (const g of nomes.agrupados()) {
+        saida.push(c.bold(g.titulo));
+        for (const n of g.comandos) {
+            const d = desc.get(n);
+            saida.push(d ? `  ${c.brand(ui.padRight('/' + n, 16))}${c.muted(d)}` : `  ${c.brand('/' + n)}`);
+        }
+        saida.push('');
+    }
+    return saida;
+}
+
+function montarHelp() {
+    return `
+${c.bold('Comandos')} ${c.dim('· os nomes em português continuam valendo (/desfazer = /undo)')}
+
+${linhasDosGrupos().join('\n')}
   ${c.brand('-p')} "pedido"          modo script: sem tela, aceita stdin e --output-format json
-  ${c.brand('/memoria')}            o que ele lembra de você: /memoria esquecer <nome> · /memoria pasta
-  ${c.brand('/gosto')}              o seu gosto de motion: /gosto refazer|apagar
-  ${c.brand('/sandbox')}            isola os comandos do agente: on|off|rede on|off|status
-  ${c.brand('/compact')}            resume a conversa e devolve o contexto
-  ${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
-  ${c.brand('/open')} <arq|url>     abre no navegador
-  ${c.brand('/abrir')}              abre o projeto: o servidor de pé, ou a index.html
-  ${c.brand('/copiar')}             copia a última resposta
-  ${c.brand('/videos')}             seus vídeos prontos (abrir <n> · pasta <n>)
-  ${c.brand('/historico')} [termo]  procura nos seus pedidos antigos
-  ${c.brand('/login')}              entra na sua conta · ${c.brand('/account')} mostra o plano
-  ${c.brand('/planos')}             os planos e o link para assinar
-  ${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('/offline')}            roda o servidor no seu computador (temporário) · /offline off volta
-  ${c.brand('/doctor')}             confere tudo (servidor, /api, Chrome, disco…) e diz como consertar
-  ${c.brand('/custo')}              tokens e pedidos desta sessão, por provedor
-  ${c.brand('/atalhos')}            as teclas que ajudam
-  ${c.brand('/name')} <nome>        como o Primo te chama
-  ${c.brand('/marca')} [criar|listar|usar]  o kit de marca: cores, fontes e logo em todo vídeo
-  ${c.brand('/mascot')} [nome|n]    galeria dos mascotes · /mascot reacoes on|off
-  ${c.brand('/config')}             mostra suas preferências
-  ${c.brand('/clear')}              limpa a conversa   ${c.brand('/cls')} limpa a tela
-  ${c.brand('/uninstall')}          remove o PrimoCode
-  ${c.brand('/exit')}               sai do PrimoCode
 
 ${c.bold('Modos')}
   ${c.warn('Primo Code')}  ${c.muted('Agente completo — cria arquivos, roda comandos, abre o navegador')}
@@ -182,39 +162,55 @@ ${c.bold('Onde ele trabalha')}
   ${c.muted('  ·')} ${c.muted('falar o nome dela no pedido — ele procura no seu computador')}
   ${c.dim('Pasta de projeto nova só nasce quando ele vai mexer em arquivo.')}
 `;
+}
 
 // ── Autopreenchimento dos comandos (estilo Claude Code) ────────────────
 // Metade do comando já serve: Tab completa, e um prefixo único executa
 // direto — "/eff" vira "/effort" sozinho. A lista é só a dos nomes
 // canônicos; os apelidos (/cd, /stream…) continuam valendo por extenso.
 const SLASH_COMANDOS = [
-    ['/help', 'todos os comandos'],
-    ['/project', 'lista/cria projetos em ~/primocode'],
-    ['/projetos', 'projetos do mais recente, com tamanho · /projetos 2 entra'],
-    ['/novo', 'começa um projeto novo do zero: /novo site da padaria'],
+    ['/help', 'todos os comandos · /help all: tudo que ele sabe fazer'],
+    ['/projects', 'seus projetos, do mais recente · /projects 2 entra · /projects <nome> cria'],
+    ['/new', 'projeto novo do zero: /new site da padaria · sem nada: 3 perguntas pra quem nunca programou'],
     ['/dir', 'trabalhar numa pasta sua'],
+    ['/worktree', 'cria ../<repo>-<nome> numa branch nova e entra'],
+    ['/resume', 'retoma uma conversa salva (sem número, lista)'],
+    ['/sandbox', 'isola os comandos do agente: on | off | rede on | off | status'],
     ['/mode', 'primocode | chat | auto'],
     ['/effort', 'esforço: low → ultracode (←/→ para ajustar)'],
-    ['/permissoes', 'auto | perguntar | livre | plano — quando ele pede licença'],
-    ['/memoria', 'o que ele lembra de você · esquecer <nome> · pasta'],
+    ['/perms', 'auto | perguntar | livre | plano — quando ele pede licença'],
+    ['/memory', 'o que ele lembra de você · esquecer <nome> · pasta'],
+    ['/taste', 'o seu gosto de motion e pra onde ele inclina (refazer, apagar, tirar N) · /taste referencias: ensina com vídeos que você curtiu'],
     ['/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'],
+    ['/attach', 'anexa um arquivo ou uma página (/attach <url>) · sem nada, lista · /detach tira'],
     ['/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'],
+    ['/undo', 'desfaz o que o último pedido mudou nos arquivos (lista · N · out)'],
+    ['/redo', 'volta o que o último /undo desfez'],
+    ['/check', 'testa o projeto e diz se funcionou (/conferir e /testar ainda valem)'],
+    ['/restore', 'volta pro último ponto que o /check marcou como funcionando'],
+    ['/show', 'abre o app no celular de alguém no mesmo Wi-Fi, sem publicar'],
+    ['/howto', 'escreve no PRIMO.md como abrir e testar este projeto'],
+    ['/save', 'guarda o projeto no GitHub (privado) e mostra o link · também vale /guardar'],
+    ['/secrets', 'as chaves que o projeto usa (só os nomes) · /secrets add NOME guarda uma, escondida, no .env · também vale /segredos'],
+    ['/schedule', 'um pedido que roda sozinho: /schedule "toda segunda às 9h" <pedido> · sem nada, lista · /schedule off 1 tira · também vale /agendar'],
+    ['/lock', 'arquivos que o agente só pode ler · /lock login.js trava · /lock off login.js solta · sem nada, lista'],
+    ['/rule', 'uma regra que o PrimoCode segue sempre, mesmo depois de resumir a conversa'],
+    ['/port', 'o app não abre? diz qual porta responde e o endereço certo'],
+    ['/map', 'o que tem no projeto, em português, e o que está faltando · /map tree: as pastas'],
+    ['/explain', 'o que o último pedido mudou, em até 5 linhas · /explain commit: uma palavra · /explain projeto: o projeto todo'],
+    ['/plan', 'mostra 3 a 5 passos e só começa quando você aperta Enter (ou muda um passo) · /plan <pedido>'],
+    ['/changes', 'o que mudou no projeto, em português (arquivos e linhas)'],
+    ['/timeline', 'abre a história do projeto numa página'],
     ['/read', 'mostra um arquivo'],
     ['/run', 'roda um comando'],
-    ['/open', 'abre no navegador'],
-    ['/abrir', 'abre o projeto atual: o servidor de pé, ou a index.html'],
-    ['/copiar', 'copia a última resposta'],
+    ['/open', 'abre o projeto (sem nada), um arquivo ou um site no navegador'],
+    ['/export', 'salva a conversa num .md, sem chave nem senha'],
+    ['/copy', 'copia a última resposta'],
     ['/videos', 'seus vídeos prontos (abrir n · pasta n)'],
-    ['/historico', 'procura nos seus pedidos antigos: /historico login'],
+    ['/history', 'procura nos seus pedidos antigos: /history login'],
     ['/login', 'entra na sua conta (abre o navegador) · /login senha: e-mail e senha aqui'],
-    ['/account', 'sua conta e o seu plano'],
-    ['/planos', 'os planos do PrimoCode e o link para assinar'],
+    ['/account', 'sua conta e o seu plano · /account plans: os planos e o link para assinar'],
     ['/chats', 'suas conversas salvas, as mesmas do app e do celular'],
     ['/logout', 'desconecta este computador da conta'],
     ['!comando', 'roda direto no shell, sem passar pelo agente (o campo fica âmbar)'],
@@ -222,19 +218,19 @@ const SLASH_COMANDOS = [
     ['/voice painel', 'só o painel do Primo (ESC esconde)'],
     ['/voice nome <Nome>', 'dá outro nome ao assistente (só o nome; o modo voz abre no clique)'],
     ['/voice parar', 'desliga o modo voz e fecha o microfone'],
-    ['/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>'],
+    ['/skills', 'o que ele sabe fazer bem · /skills store: a loja · /skills add <arquivo>: instala'],
+    ['/commands', 'seus comandos: um .md vira /nome · /commands novo <nome>'],
+    ['/styles', 'os estilos de motion (kits): a lista e a galeria · /styles <estilo>: o preview dele'],
+    ['/team', 'trabalhar junto com o claude, codex, gemini, agy ou opencode: /team <nome> liga · /team off'],
     ['/api', 'usa a SUA chave (Gemini, ChatGPT, Claude…) direto daqui, sem o limite do servidor'],
-    ['/status', 'checa o servidor'],
     ['/offline', 'roda o servidor aqui no seu computador, com as chaves do Render'],
-    ['/doctor', 'confere se está tudo certo e diz como consertar'],
-    ['/custo', 'tokens e pedidos desta sessão, por provedor'],
-    ['/atalhos', 'as teclas que ajudam'],
+    ['/doctor', 'confere se está tudo certo e diz como consertar · /doctor status: só o servidor'],
+    ['/usage', 'quanto você gastou (agora e hoje) e quando zera · /usage limite 100000 ensina o limite do seu plano'],
+    ['/tasks', 'o que roda em segundo plano · rodar <cmd> · abrir · parar <id>'],
+    ['/keys', 'as teclas que ajudam'],
     ['/connectors', 'quem está atendendo os seus pedidos'],
-    ['/name', 'como ele te chama'],
-    ['/marca', 'kit de marca: cores, fontes e logo'],
+    ['/name', 'como ele te chama · /name voz <Nome>: o nome do assistente de voz'],
+    ['/brand', 'kit de marca: cores, fontes e logo'],
     ['/mascot', 'galeria dos mascotes · escolha por nome ou número'],
     ['/config', 'suas preferências'],
     ['/clear', 'limpa a conversa'],
@@ -417,11 +413,15 @@ function comandosDoMenu() {
 }
 
 function mostrarMenuSlash() {
+    // "/" sozinho mostra as 9 intenções, não a lista seca; o /help tem tudo, com descrição.
     console.log('');
-    for (const [nome, desc] of comandosDoMenu()) {
-        console.log(`  ${c.brand(ui.padRight(nome, 12))}${c.muted(desc)}`);
+    for (const g of nomes.agrupados()) {
+        console.log(`  ${c.bold(ui.padRight(g.titulo, 19))}${c.brand(g.comandos.map((n) => '/' + n).join('  '))}`);
     }
-    console.log(c.dim('\n  Tab completa · metade do comando já serve: /eff vira /effort'));
+    const dela = comandosDaPessoa().filter((x) => !nomes.COMANDOS[x.nome]);
+    if (dela.length) console.log(`  ${c.bold(ui.padRight('Os seus', 19))}${c.brand(dela.map((x) => '/' + x.nome).join('  '))}`);
+    console.log(c.dim('\n  /help explica cada um · Tab completa · metade do comando já serve: /eff vira /effort'));
+    console.log(c.dim('  Os nomes em português continuam valendo: /undo chama o /undo.'));
 }
 
 let rl = null;
@@ -486,6 +486,14 @@ function barraDeStatus() {
        esquece que deu — e ela vale até o PrimoCode fechar. */
     if (state.controle && state.controle.liberado) partes.push(c.warn('controle do pc'));
 
+    /* O que o agente deixou de pé (run_background). Servidor esquecido segura
+       a porta e gasta bateria: tem que estar à vista enquanto roda. */
+    const vivos = require('../lib/fundo.js').listar().filter((t) => t.rodando);
+    if (vivos.length) {
+        const porta = vivos.length === 1 && vivos[0].url && (vivos[0].url.match(/:(\d+)/) || [])[1];
+        partes.push(c.ok('●') + ' ' + c.muted(porta ? `de pé :${porta}` : `${vivos.length} de pé`));
+    }
+
     /* O CONTEXTO. Só aparece depois que há conversa: um "ctx 0%" na abertura
        é ruído, e ruído que aparece sempre é o que a pessoa aprende a não
        enxergar — inclusive quando marcar 90%. Âmbar a partir de 70% e
@@ -772,7 +780,7 @@ function ehSoEstudio(texto) {
 function planWorkDir(userText) {
     // O /novo já criou a pasta e entrou nela: nenhuma heurística decide outra.
     if (state.projetoFixo) return { dir: state.workDir, pending: false, name: state.currentProject };
-    const escolhida = ['/dir', 'detectada', 'projeto'].includes(state.workDirOrigem);
+    const escolhida = ['/dir', 'detectada', 'projeto', 'terminal'].includes(state.workDirOrigem);
     // Pasta escolhida a dedo (/dir, ou dita no pedido) manda sempre. Projeto
     // em andamento manda também — a menos que o pedido abra outra coisa.
     if (escolhida && !(state.workDirOrigem === 'projeto' && pedeProjetoNovo(userText))) {
@@ -801,6 +809,32 @@ async function perguntarNome(texto) {
     return resposta;
 }
 
+/* O corpo do /novo, num lugar só: o /comecar também cria a pasta e roda o
+   pedido preso nela, e dois caminhos copiados divergiriam. */
+async function criarProjetoNovo(rest) {
+    const nomes = cfg.listProjects();
+    const sp = new Spinner('escolhendo o nome da pasta').start();
+    const sugerido = await nomeProjeto.escolher({ pedido: rest, nomes, perguntar: perguntarNome }).catch(() => null);
+    sp.stop();
+    const nomeNovo = extra.nomeDoNovo({
+        descricao: rest, nomes, sugerido, derivar: deriveProjectName,
+        // A régua curta (lib/nome-curto.js) também no /novo.
+        slugify: (t) => nomeCurto(t) || cfg.slugify(t), semColisao: nomeProjeto.semColisao,
+    });
+    const dir = cfg.createProjectDir(nomeNovo);
+    entrarNoProjeto(dir, 'projeto');
+    // Conversa nova junto: o que se falou do projeto anterior puxaria o
+    // agente de volta para ele.
+    state.history = []; state.memoria = memoria.nova(); state.gravador.zerar();
+    console.log(c.ok(`  Projeto novo: ${state.currentProject}`) + c.muted(`  (${shortPath(dir)})`));
+    refreshPrompt();
+    const modoAntes = state.mode;
+    state.mode = 'primocode';
+    state.projetoFixo = true;
+    try { await sendPrompt(extra.pedidoDoNovo(rest, state.currentProject)); }
+    finally { state.mode = modoAntes; state.projetoFixo = false; }
+}
+
 function batizarDepois(plan, userText) {
     if (!plan.pending || !(RE_CRIAR_UM.test(semAcento(userText)) || PEDIDO_DE_CODIGO.test(userText))) return;
     plan.batizando = nomeProjeto.escolher({ pedido: userText, nomes: cfg.listProjects(), perguntar: perguntarNome })
@@ -956,7 +990,7 @@ async function autorizarControle(oQueVaiFazer, { primeira, 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):')));
+            : 'O Primo quer (você escolheu /perms perguntar):')));
     } else if (primeira) {
         console.log('');
         console.log('  ' + c.warn('▸▸') + ' ' + c.bold(c.white('O Primo quer usar o seu computador.')));
@@ -1158,7 +1192,7 @@ async function instalarComPortao(caminho) {
     return skills.instalarDe(caminho, { forcar: true });
 }
 
-async function sendPrompt(userText) {
+async function sendPrompt(userText, { digitado = false } = {}) {
     /* O portão do plano. Sem ele o bloqueio da abertura seria só um texto na
        tela: a pessoa leria "você não tem acesso" e mandaria a primeira coisa
        do mesmo jeito, e funcionaria.
@@ -1170,14 +1204,49 @@ async function sendPrompt(userText) {
        produto está quebrado. */
     if (state.liberado === false) {
         console.log(c.err('  O PrimoCode pede um plano (a partir de R$ 69,90/mês).'));
-        console.log(c.muted('  Veja e assine com ') + c.brand('/planos')
+        console.log(c.muted('  Veja e assine com ') + c.brand('/account plans')
             + c.muted(' · já assinou? ') + c.brand('/account'));
         return;
     }
 
+    /* Pedido grande: uma linha dizendo quanto deve gastar do plano de hoje (lib/limite.js). Sem o limite do plano,
+       diz isso com todas as letras (uma vez por conversa) em vez de inventar %. Só pra quem digitou, no terminal. */
+    if (digitado && !state.semTerminal && process.stdin.isTTY) {
+        try {
+            const L = require('../lib/limite.js');
+            const anexos = state.attachedFiles.reduce((n, f) => n + String(f.content || '').length, 0);
+            const limite = L.limiteConhecido();
+            if (L.pedidoGrande(userText, anexos) && (limite || !state.avisouSemLimite)) {
+                const { total } = extra.resumoCusto(contadorDaSessao);
+                const media = total.pedidos ? Math.round((total.enviados + total.recebidos) / total.pedidos) : 0;
+                console.log(c.muted('  ' + L.linhaDoPedido({ tokens: L.estimar({ texto: userText, anexosChars: anexos, mediaPorPedido: media }), limite, usadoHoje: L.usoDeHoje().tokens })));
+                if (!limite) state.avisouSemLimite = true;
+            }
+        } catch { /* a estimativa nunca derruba o pedido */ }
+    }
+
     // PRIMOCODE_TEMPOS=1: uma linha no fim com o custo de cada fase.
     tempos.comecar();
     const inicio = Date.now();
+    /* Pedido em lista, com 4 itens ou mais (lib/partes.js): PERGUNTA se faz um de cada vez. Só no terminal de
+       verdade; no app e no -p, segue inteiro como sempre. */
+    // só o que a PESSOA digitou: o pedido que o próprio PrimoCode monta (o conserto do /conferir leva a saída do teste,
+    // e o mocha escreve "1) nome do teste") não pode virar "esse pedido tem 4 partes" (achado da revisão de 24/10)
+    const divisao = digitado && !state.semTerminal && process.stdin.isTTY ? require('../lib/partes.js').dividir(userText) : null;
+    if (divisao && await confirm(`Esse pedido tem ${divisao.partes.length} partes. De uma vez só, pedido grande costuma travar no meio. Faço uma de cada vez, conferindo entre elas?`)) {
+        const P = require('../lib/partes.js');
+        try {
+            for (let i = 0; i < divisao.partes.length; i++) {
+                console.log(c.brand(`\n  ▸ parte ${i + 1} de ${divisao.partes.length}: `) + c.white(divisao.partes[i].slice(0, 80)));
+                await enviarPedido(P.pedidoDaParte(divisao, i));
+                if (require('../lib/act.js').interrompido()) break;   // Esc Esc numa parte para as que faltam
+            }
+        } finally {
+            const linha = tempos.relatorio();
+            if (linha) console.log(c.dim(`  ⏱ ${linha}`));
+        }
+        return;
+    }
     try { await enviarPedido(userText); }
     finally {
         const linha = tempos.relatorio();
@@ -1188,15 +1257,37 @@ async function sendPrompt(userText) {
         if (!state.semTerminal) {
             console.log('\n  ' + `${COR_MODO[m] || COR_MODO.auto}▣${c.reset} ` + c.white(NOME_MODO[m] || m)
                 + c.dim(` · ${effort.normalizar(state.config.effort)} · ${((Date.now() - inicio) / 1000).toFixed(1)}s`) + '\n');
+            // O que o agente deixou de pé (run_background), com o endereço pra abrir.
+            const rodape = require('../lib/fundo.js').linhasRodape(require('../lib/fundo.js').listar(), c);
+            if (rodape.length) console.log(rodape.join('\n') + '\n');
         }
     }
 }
 
+/* Marca no arquivo de hoje o que ESTA conversa já gastou (lib/limite.js): é o que o /usage soma. */
+const IDENTIDADE_DA_SESSAO = `${process.pid}-${Date.now()}`;
+function guardarUsoDeHoje() {
+    try {
+        const { total } = extra.resumoCusto(contadorDaSessao);
+        require('../lib/limite.js').guardarSessao(IDENTIDADE_DA_SESSAO, total.enviados + total.recebidos);
+    } catch { /* contar nunca derruba um pedido */ }
+}
+
 async function enviarPedido(userText) {
     let prompt = userText;
+    const custoAntes = extra.resumoCusto(contadorDaSessao);   // pro "Este pedido: …" do fim
     // "@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);
+    // "@https://…" no pedido é um /web só deste pedido (lib/web-pagina.js)
+    const W = require('../lib/web-pagina.js');
+    for (const url of W.urlsDoPedido(userText)) {
+        const r = await W.baixar(url);
+        if (r.ok) {
+            citados.push({ path: r.url, content: (r.titulo ? `# ${r.titulo}\n\n` : '') + r.texto });
+            console.log(c.dim(`  ⎿ anexado: ${r.titulo || r.url} (${r.palavras} palavras${r.cortado ? ', o começo da página' : ''})`));
+        } else console.log(c.dim(`  ⎿ não anexei ${url}: ${r.error}`));
+    }
     const anexos = [...state.attachedFiles, ...citados];
     if (anexos.length) {
         const parts = anexos.map((f) => `Arquivo: ${f.path}\n\`\`\`\n${f.content}\n\`\`\``);
@@ -1285,7 +1376,8 @@ async function enviarPedido(userText) {
                 ? '\n\nATENÇÃO: o passo anterior não trouxe fatos. Trabalhe só com o que está no pedido. '
                   + 'É PROIBIDO inventar dado de empresa, data, preço ou pessoa — na dúvida, não afirme.'
                 : '';
-            const pedido = passos[i].pedido + contexto + semFatos;
+            // o pedido citou arquivo: o agente sabe antes, não só no aviso do fim (lib/escopo.js)
+            const pedido = passos[i].pedido + contexto + semFatos + require('../lib/escopo.js').nota(userText);
 
             const rodarPasso = (texto = pedido) => runAct(texto, {
                 server: state.config.server,
@@ -1362,11 +1454,32 @@ async function enviarPedido(userText) {
         }
         checkpoint.encerrar();
 
+        // O pedido nomeou arquivo e o agente mexeu em outros? Diz quais, e o /desfazer fora volta só esses (lib/escopo.js).
+        try {
+            const escopo = require('../lib/escopo.js');
+            const ultimo = checkpoint.lista(projectDir())[0];
+            if (ultimo && ultimo.pedido === String(userText).replace(/\s+/g, ' ').trim()) {
+                const fora = escopo.foraDoPedido(userText, ultimo.mudou, projectDir());
+                if (fora.length) {
+                    escopo.texto(escopo.citados(userText), fora).forEach((l, i, ls) => console.log(i === 0 ? c.warn('  ' + l) : i === ls.length - 1 ? c.muted('  ' + l) : c.white('  ' + l)));
+                }
+            }
+        } catch { /* o aviso nunca derruba o pedido */ }
+        // "nunca mexa no logo" dito no pedido: oferece guardar como regra, não guarda sozinho (lib/regras.js)
+        try {
+            const regras = require('../lib/regras.js');
+            const sug = regras.sugerir(userText, regras.ler(projectDir()));
+            if (sug) console.log(c.muted('  Isso vale sempre? ') + c.white(`/rule ${sug}`) + c.muted('  (fica no PRIMO.md e não some quando a conversa é resumida)'));
+        } catch { /* a oferta nunca derruba o pedido */ }
+
         /* 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
            arquivos é a conferência, e conferência se lê por último. */
         const balanco = registro.resumo(livro, { colunas: process.stdout.columns || 80 });
         if (balanco) console.log(balanco);
+        const custo = extra.custoDoPedido(custoAntes, extra.resumoCusto(contadorDaSessao));
+        if (custo) console.log(c.dim(`  ${custo}`));
+        guardarUsoDeHoje();
         // O rostinho do mascote, por último e numa linha só. O humor sai do
         // que aconteceu, não de adivinhar pelo texto da resposta.
         if (state.config.reacoes !== false && r) {
@@ -1374,7 +1487,10 @@ async function enviarPedido(userText) {
             console.log(ui.reacao(state.config.mascot, humor));
         }
         state.history.push({ role: 'user', content: userText });
-        state.history.push({ role: 'assistant', content: r.assistantMessage.content });
+        // na memória da conversa vai também o que o pedido fez no disco (arquivos, último teste): o pedido seguinte sabe
+        let feito = '';
+        try { feito = require('../lib/registro.js').paraMemoria(r.registro); } catch { /* sem registro */ }
+        state.history.push({ role: 'assistant', content: r.assistantMessage.content + (feito ? `\n\n${feito}` : '') });
         resumirDepois();
         state.lastResponse = r.assistantMessage.content;
         cfg.appendHistory({ mode: 'primocode', project: state.currentProject, prompt: userText });
@@ -1382,6 +1498,8 @@ async function enviarPedido(userText) {
         // rede, não acontece nada — a conversa segue aqui do mesmo jeito.
         state.gravador.turno(userText, r.assistantMessage.content,
             { modo: 'primocode', projeto: state.currentProject || null });
+        // O parceiro do /team revisa o que mudou (lib/team.js). Depois do histórico: o conserto vem como pedido seguinte.
+        await revisaoDoParceiro(userText, livro, r);
     } else {
         await tempos.medir('espera do resumo', () => esperarResumo());
         await tempos.medir('chat', () => runChat(prompt, userText));
@@ -1391,6 +1509,72 @@ async function enviarPedido(userText) {
     refreshPrompt();
 }
 
+/* "UM FAZ, O OUTRO REVISA" (/team). O PrimoCode fez; o parceiro lê a mudança
+   (só lendo, na pasta do projeto, com prazo) e devolve a revisão. Achou
+   problema, a pessoa diz se corrige; o conserto não é revisado de novo. */
+async function revisaoDoParceiro(userText, livro, r) {
+    const nome = state.config.team;
+    if (!nome || state.consertandoRevisao || !r || r.parado || !livro) return;
+    const arquivos = [...(livro.criados || []), ...(livro.alterados || [])];
+    if (!arquivos.length) return;
+    const team = require('../lib/team.js');
+    const dele = team.instalados().find((x) => x.nome === nome);
+    if (!dele) { console.log(c.warn(`  O ${nome} não está mais instalado: sem revisão. /team mostra os que você tem.`)); return; }
+    const dir = r.pasta || projectDir();
+    const diff = team.diffDaVez(dir, arquivos);
+    if (!diff) return;
+    console.log(c.muted(`  ${dele.titulo} revisando o que eu fiz (só lendo)…`));
+    const rev = await team.rodar(nome, 'revisar', { prompt: team.pedidoDeRevisao({ pedido: userText, diff }), dir, caminho: dele.caminho,
+        linha: (l) => console.log(c.dim(`  ${nome} │ ${l}`)) });
+    if (!rev.ok) { console.log(c.warn(`  ${rev.erro}`)); return; }
+    if (!rev.texto || team.semProblema(rev.texto)) { console.log(c.ok(`  ✓ ${nome} revisou: nada a corrigir.`)); return; }
+    console.log(c.white(`  A revisão do ${nome}:`));
+    for (const l of rev.texto.split('\n')) console.log(`  ${l}`);
+    if (state.semTerminal) return;
+    if (!(await confirm('Corrijo o que a revisão achou?'))) return;
+    state.consertandoRevisao = true;
+    try { await sendPrompt(team.pedidoDeConserto(nome, rev.texto)); } finally { state.consertandoRevisao = false; }
+}
+
+/* `/team <nome> faz <pedido>`: o parceiro faz numa cópia do projeto (git
+   worktree, ou cópia da pasta), o PrimoCode mostra o que mudou, passa cada
+   arquivo pelo portão (lib/perigo.js) e só aplica com o sim. /undo volta. */
+async function parceiroFaz(nome, pedido) {
+    const team = require('../lib/team.js');
+    const dele = team.instalados().find((x) => x.nome === nome);
+    const dir = projectDir();
+    if (!pastaSegura(dir) || path.resolve(dir) === path.resolve(cfg.ROOT_DIR)) {
+        console.log(c.warn('  Entre num projeto antes (/projects ou /dir): o parceiro trabalha numa cópia dele.'));
+        return;
+    }
+    let copia;
+    try { copia = team.prepararCopia(dir); } catch (e) { console.log(c.warn(`  Não consegui preparar a cópia do projeto: ${String(e.message || e).split('\n')[0]}`)); return; }
+    try {
+        console.log(c.muted(`  ${dele.titulo} trabalhando numa cópia do projeto${copia.git ? ' (git worktree)' : ''}…`));
+        const r = await team.rodar(nome, 'fazer', { prompt: team.pedidoDeFazer(pedido), dir: copia.pasta, caminho: dele.caminho,
+            linha: (l) => console.log(c.dim(`  ${nome} │ ${l}`)) });
+        if (!r.ok) { console.log(c.warn(`  ${r.erro}`)); return; }
+        if (r.texto) { console.log(c.white(`  O ${nome} disse:`)); for (const l of r.texto.split('\n')) console.log(`  ${l}`); }
+        const m = team.mudancasDaCopia(copia);
+        if (!m.arquivos.length) { console.log(c.muted('  Ele não mudou nenhum arquivo. O projeto ficou como estava.')); return; }
+        console.log(c.white(`  O que ele mudou (${m.arquivos.length} arquivo${m.arquivos.length > 1 ? 's' : ''}):`));
+        const linhas = m.patch.split('\n');
+        for (const l of linhas.slice(0, 200)) console.log('  ' + (/^\+(?!\+\+)/.test(l) ? c.ok(l) : /^-(?!--)/.test(l) ? c.err(l) : c.dim(l)));
+        if (linhas.length > 200) console.log(c.dim(`  … e mais ${linhas.length - 200} linhas`));
+        if (!state.controle.perigo) state.controle.perigo = perigo.novo();
+        const recusas = await team.passarPeloPortao(m.arquivos, { projectDir: dir, aplicarEm: copia.aplicarEm, modo: state.config.permissoes,
+            estado: state.controle.perigo, perguntar: state.semTerminal ? undefined : autorizarControle });
+        if (recusas.length) { console.log(c.warn(`  O portão do PrimoCode recusou: ${recusas.join('; ')}. Nada foi aplicado.`)); return; }
+        if (state.semTerminal) { console.log(c.muted('  No modo script eu não aplico sozinho: rode no terminal do PrimoCode pra aplicar.')); return; }
+        if (!(await confirm('Aplico essa mudança no projeto?'))) { console.log(c.muted('  Não apliquei. O projeto ficou como estava.')); return; }
+        checkpoint.iniciar(`/team ${nome} faz ${pedido}`, dir);
+        for (const a of m.arquivos) checkpoint.antesDeMudar(path.join(copia.aplicarEm, a.caminho), dir);
+        const ap = team.aplicar(copia, m.patch);
+        checkpoint.encerrar();
+        console.log(ap.ok ? c.ok(`  ✓ Apliquei. /undo volta.`) : c.warn(`  ${ap.erro}`));
+    } finally { copia.limpar(); }
+}
+
 /**
  * Arruma o pedido e divide em passos — as duas coisas, ESCONDIDAS.
  *
@@ -1488,6 +1672,8 @@ function pedidoDeContinuacao(original, livro) {
 }
 
 async function dividirTarefa(pedido) {
+    // O /plan já dividiu, e a pessoa aprovou: nada de chamar o servidor de novo.
+    if (state.passosProntos) { const prontos = state.passosProntos; state.passosProntos = null; console.log(c.dim(`  ⎿ ${prontos[0].titulo}`)); return prontos; }
     const inteiro = [{ titulo: 'tarefa', pedido }];
     if (!pedido || pedido.trim().length < 12) return inteiro;
     // Sem as duas fases no texto, nem chama o servidor: mais rápido, e sem
@@ -1760,35 +1946,10 @@ async function rodarBash(text) {
 }
 
 /* ── OS NOMES ANTIGOS ────────────────────────────────────────────────────
- * Os comandos passaram a ser todos em inglês. Metade já era; a outra metade
- * estava em português, e a mistura era o que a especificação chamou de
- * bagunça — `/run` ao lado de `/pasta`, `/tree` ao lado de `/tudo`.
- *
- * O nome antigo NÃO some: ele responde e ensina o novo. Sumir de vez faz quem
- * tem o dedo viciado bater num "comando não existe" e concluir que a
- * atualização quebrou alguma coisa — e essa pessoa não vai procurar no /help,
- * vai desinstalar.
- *
- * Uma tabela, e não um `if` dentro de cada `case`: com dezoito apelidos, o
- * `if` espalhado é o jeito garantido de esquecer um. Aqui, esquecer é não
- * escrever a linha, e a linha some da lista.
- */
-const RENOMEADOS = {
-    // a conta
-    entrar: 'login', conectar: 'login',
-    conta: 'account',
-    plano: 'planos', assinar: 'planos', assinatura: 'planos', precos: 'planos',
-    sair: 'exit',        // sair é SAIR; desconectar a conta é /logout
-    // o histórico
-    // /historico deixou de ser apelido do /chats: agora procura nos pedidos
-    // guardados nesta máquina (lib/comandos-extra.js). /chats segue sendo a
-    // conversa inteira, da conta.
-    conversas: 'chats',
-    // o resto
-    pasta: 'dir',
-    esforco: 'effort', esforço: 'effort',
-    tudo: 'all', capacidades: 'all',
-};
+ * Os comandos são todos em inglês curto e o nome antigo NÃO some: ele responde
+ * e ensina o novo. Sumir de vez faz quem tem o dedo viciado achar que a
+ * atualização quebrou — e essa pessoa não procura no /help, desinstala.
+ * A tabela (apelido → nome novo, e os 9 grupos) mora em lib/nomes.js. */
 
 /* 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
@@ -1874,19 +2035,126 @@ function entrarNoWorktree(nome) {
     return true;
 }
 
+/* /new sem nada: as 3 perguntas (era o /new). */
+async function comecarPerguntas() {
+    const comecar = require('../lib/comecar');
+    let oque = (await ask('  O que você quer criar? Conte do seu jeito. (Enter: ver ideias)\n  > ')).trim();
+    if (!oque) {
+        // Sem ideia não é motivo pra desistir: mostra por onde começar.
+        console.log(c.muted('\n  Algumas ideias pra começar:'));
+        comecar.IDEIAS.forEach((ideia, i) => console.log(`  ${c.brand(String(i + 1))}  ${ideia}`));
+        oque = comecar.escolherIdeia(await ask('\n  Escolha um número, ou escreva a sua ideia (Enter cancela)\n  > ')) || '';
+    }
+    if (!oque) { console.log(c.muted('  Tudo bem, sem pressa. Quando quiser, é só digitar /new de novo.')); return; }
+    console.log(c.muted(`  → ${oque}`));
+    const praQuem = (await ask('  Pra quem é? (Enter pula)\n  > ')).trim();
+    const onde = (await ask('  Abre onde: no navegador, no celular, ou tanto faz? (Enter pula)\n  > ')).trim();
+    await criarProjetoNovo(comecar.montarPedidoComecar({ oque, praQuem, onde }));
+    // quem acabou de fazer o primeiro app não sabe que pode conferir nem voltar: é a hora de contar
+    console.log(c.muted(`\n  ${comecar.DEPOIS_DO_PRIMEIRO_APP}`));
+    return;
+}
+
+/* /attach <url>: a página vira texto e vai junto do próximo pedido (lib/web-pagina.js). */
+async function anexarPagina(rest) {
+        const sp = new Spinner('lendo a página').start();
+    const r = await require('../lib/web-pagina.js').baixar(rest.trim());
+    sp.stop();
+    if (!r.ok) { console.log(c.err(`  Não anexei: ${r.error}.`)); return; }
+    state.attachedFiles.push({ path: r.url, content: (r.titulo ? `# ${r.titulo}\n\n` : '') + r.texto });
+    console.log(c.ok(`  Anexei: ${r.titulo || r.url}`) + c.muted(` · ${r.palavras} palavras${r.cortado ? ' (o começo da página)' : ''}`));
+    console.log(c.muted('  Vai junto do próximo pedido. /attach mostra, /detach tira.'));
+    refreshPrompt();
+    return;
+}
+
+/* /attach sem nada: o que está anexado. */
+function listarAnexos() {
+    if (!state.attachedFiles.length) console.log(c.muted('Nenhum arquivo anexado.'));
+    else state.attachedFiles.forEach((f) => console.log(`  ${c.brand(f.path)} ${c.muted(tools.fmtBytes(f.content.length))}`));
+}
+
+/* /help all: tudo que ele sabe fazer (lib/catalogo.js). */
+function mostrarTudo() {
+    const cols = Math.max(40, Math.min(process.stdout.columns || 90, 110));
+    console.log('');
+    for (const g of catalogo.GRUPOS) {
+        console.log('  ' + c.bold(c.white(g.nome)) + ' ' + ui.truncate(c.dim('— ' + g.resumo), cols - 4 - ui.visibleWidth(g.nome)));
+        for (const i of g.itens) {
+            console.log('    ' + c.brand(ui.padRight(i.tool, 23)) + ui.truncate(c.muted(i.faz), cols - 28));
+        }
+        console.log('');
+    }
+    console.log(c.dim(`  ${catalogo.TODAS.length} ferramentas. Você não precisa saber nenhum desses nomes — peça em português.`));
+    return;
+}
+
+/* /taste referencias: a tela pra soltar os motions que você curtiu. */
+async function abrirReferencias() {
+    const G = require('../lib/estudio/gosto.js');
+    console.log(c.muted(process.env.PRIMOCODE_APP === '1' ? '  Abri a tela do gosto (até 10 min): solte os vídeos que você curtiu e salve.' : '  Abri uma tela no navegador (até 10 min): solte os vídeos que você curtiu e salve.'));
+    const r = await G.abrirOndeDer({ inicio: 'referencias' });
+    if (!r.ok) console.log(c.warn(r.motivo === 'pulou' ? '  Você pulou: nada foi salvo.' : r.motivo === 'tempo' ? '  Acabou o tempo: nada foi salvo.' : r.motivo === 'fechou' ? '  Você fechou a tela: nada foi salvo.' : '  Não consegui abrir a tela.'));
+    const rs = G.resumo(G.ler());
+    console.log(rs ? c.muted('  ') + rs : c.muted('  Ainda não tem gosto salvo. /taste referencias abre a tela.'));
+    return;
+}
+
+/* /doctor status: só o servidor, a versão e a conversa. */
+async function mostrarStatus() {
+    const sp = new Spinner('verificando').start();
+    try {
+        const h = await api.getHealth(state.config.server, state.config.token);
+        sp.stop();
+        console.log(c.ok(`Servidor: ${h.status || 'ok'}`));
+        if (h.version) console.log(c.muted(`  Versão: ${h.version}`));
+        if (h.model) console.log(c.muted(`  Modelo: ${h.model}`) + (h.gratis ? c.dim('  · grátis') : ''));
+        // A corrente inteira: é o que garante que um modelo no limite não
+        // vira erro na sua tela.
+        if (h.correntes && h.correntes[state.config.model || 'main']) {
+            const fila = h.correntes[state.config.model] || h.correntes.main;
+            console.log(c.dim(`  Reservas: ${fila.length - 1}`));
+        }
+    } catch (e) { sp.stop(); console.log(c.err(`Indisponível: ${e.message}`)); }
+    // A memória da conversa: quanto ela está poupando por pedido.
+    if (state.history.length) {
+        const e = memoria.economia(state.memoria, state.history);
+        console.log(c.muted(`  Conversa: ${state.history.length} mensagens`)
+            + (state.memoria.resumo
+                ? c.dim(`  · resumida, ${e.enxuto} tokens por pedido em vez de ${e.cheio}`)
+                : c.dim(`  · ${e.enxuto} tokens por pedido`)));
+    }
+    return;
+}
+
+/* /account plans: os planos e o link pra assinar. */
+async function mostrarPlanos() {
+    const sp = new Spinner('buscando os planos').start();
+    const r = await planosTela.buscarPlanos(state.config.server);
+    sp.stop();
+    const eu = conta.atual();
+    for (const l of planosTela.desenhar(r, { cores: c, atual: eu && eu.pro ? eu.plano : null, site: conta.SITE })) console.log(l);
+    return;
+}
+
 async function handleSlash(text) {
     const [cmd] = text.trim().slice(1).split(/\s+/);
-    const rest = text.trim().slice(1 + cmd.length).trim();
+    const restoDigitado = text.trim().slice(1 + cmd.length).trim();
 
     let nome = cmd.toLowerCase();
-    if (RENOMEADOS[nome]) {
-        const novo = RENOMEADOS[nome];
-        console.log(c.muted('  Agora é ') + c.brand('/' + novo) + c.muted('.'));
-        nome = novo;
+    const apelido = nomes.ehApelido(nome);
+    // O comando da própria pessoa com o nome antigo (um ~/.primocode/comandos/revisar.md) ganha do apelido.
+    const dela = apelido && comandosDaPessoa().find((x) => x.nome === nome && x.origem !== 'primocode');
+    let rest = restoDigitado;
+    if (apelido && !dela) {
+        const junto = nomes.PREFIXO[nome];
+        console.log(c.muted('  Agora é ') + c.brand('/' + apelido + (junto ? ' ' + junto : '')) + c.muted('.'));
+        nome = apelido;
+        if (junto) rest = `${junto} ${restoDigitado}`.trim();   // /account plans vira /account plans
     }
 
     switch (nome) {
-        case 'help': console.log(HELP); break;
+        case 'help': if (/^(all|tudo)$/i.test(rest)) mostrarTudo(); else console.log(montarHelp()); break;
 
         case 'resume': await retomarConversa(rest); break;
         case 'worktree':
@@ -1898,10 +2166,10 @@ async function handleSlash(text) {
            listava os nomes, em ordem alfabética, e quem procurava "o de ontem"
            tinha de abrir pasta por pasta. Agora vem do mais recente, com
            quando mexeu e o tamanho, e um número para entrar. */
-        case 'projetos': case 'project': {
+        case 'projects': {
             const lista = extra.listarProjetos(cfg.ROOT_DIR);
             const numero = /^\d+$/.test(rest) ? Number(rest) : 0;
-            if (!rest || (numero && nome === 'projetos') || (numero && numero <= lista.length)) {
+            if (!rest || (numero && cmd.toLowerCase() === 'projetos') || (numero && numero <= lista.length)) {
                 if (!lista.length) { console.log(c.muted('  Nenhum projeto ainda. Peça algo e eu crio o primeiro.')); break; }
                 if (numero) {
                     const alvo = lista[numero - 1];
@@ -1920,7 +2188,7 @@ async function handleSlash(text) {
                         + c.muted(ui.padRight(extra.quandoFoi(x.modificado), 11))
                         + c.dim(`${extra.fmtTamanho(x.bytes)}${x.cortado ? '+' : ''} · ${x.arquivos} arq.`));
                 });
-                console.log(c.dim(`\n  ${shortPath(cfg.ROOT_DIR)} · /projetos 1 entra no primeiro · /novo <descrição> começa outro`));
+                console.log(c.dim(`\n  ${shortPath(cfg.ROOT_DIR)} · /projects 1 entra no primeiro · /new <descrição> começa outro`));
                 break;
             }
             const dir = cfg.createProjectDir(rest);
@@ -1932,8 +2200,7 @@ async function handleSlash(text) {
 
         // Antes só existia /project, que SEMPRE cria em ~/primocode/<nome>. Se a
         // sua pasta já existe em outro lugar, não havia como apontar para ela.
-        case 'dir':
-        case 'cd': {
+        case 'dir': {
             if (!rest) {
                 const de = {
                     padrao: 'a pasta padrão do PrimoCode',
@@ -1984,10 +2251,13 @@ async function handleSlash(text) {
 
         /* Quando ele pergunta antes de agir. Os três modos e o porquê de cada
            um estão em lib/perigo.js. */
+        /* Os motions que a pessoa curtiu: ela solta os vídeos na tela e o PrimoCode mede e soma no gosto (gosto-medir.js). */
+
         /* O gosto de motion: a tela abre sozinha no primeiro estudio_motion; aqui dá pra ver, refazer ou apagar. */
-        case 'gosto': {
+        case 'taste': {
             const G = require('../lib/estudio/gosto.js');
             const a = String(rest || '').trim().toLowerCase();
+            if (/^(referencias|ref|refs)$/.test(a)) { await abrirReferencias(); break; }
             if (a === 'apagar') {
                 try { fs.unlinkSync(G.arquivo()); console.log(c.ok('  Gosto de motion apagado. O próximo motion pergunta de novo.')); }
                 catch { console.log(c.muted('  Não havia gosto salvo.')); }
@@ -1995,32 +2265,58 @@ async function handleSlash(text) {
             }
             if (a === 'refazer') {
                 console.log(c.muted('  Abri uma tela no navegador (até 10 min). Feche ou pule pra voltar.'));
-                const r = await G.abrirTela();
+                const r = await G.abrirOndeDer();
                 if (!r.ok) console.log(c.warn(r.motivo === 'pulou' ? '  Você pulou: sem gosto salvo.' : r.motivo === 'tempo' ? '  Acabou o tempo: nada foi salvo.' : '  Não consegui abrir a tela.'));
-            } else if (a && a !== 'ver') { console.log(c.err('Uso: /gosto [refazer|apagar]')); break; }
-            const rs = G.resumo(G.ler());
-            console.log(rs ? c.muted('  ') + rs : c.muted('  Ainda não tem gosto salvo. /gosto refazer abre a tela.'));
+            } else if (/^provar\b/.test(a)) {
+                const assunto = String(rest).trim().replace(/^provar\s*/i, '') || 'um vídeo de apresentação';
+                const P = require('../lib/estudio/gosto-prova.js');
+                for (const l of P.texto(P.provar(G.pesos(G.ler()), { assunto }), assunto)) console.log('  ' + l);
+                break;
+            } else if (/^for[cç]a\s+\S/.test(a)) {
+                const r = G.definirForca(a.replace(/^for[cç]a\s+/, ''));
+                if (!r.ok) { console.log(c.err(`  ${r.error}`)); break; }
+                console.log(c.ok(`  Força das referências: ${{ pouco: 'pouco (só sugerem)', medio: 'médio', muito: 'muito (puxam forte)' }[r.forca]}.`));
+            } else if (/^salvar\s+\S/.test(a)) {
+                const r = G.salvarEstilo(String(rest).trim().replace(/^salvar\s+/i, ''));
+                console.log(r.ok ? c.ok(`  Estilo "${r.nome}" salvo. /taste usar ${r.nome} volta pra ele quando quiser.`) : c.err(`  ${r.error}`));
+                break;
+            } else if (/^usar\s+\S/.test(a)) {
+                const r = G.usarEstilo(String(rest).trim().replace(/^usar\s+/i, ''));
+                if (!r.ok) { console.log(c.err(`  ${r.error}`)); break; }
+                console.log(c.ok(`  Agora o gosto em uso é o "${r.nome}".`));
+            } else if (a === 'estilos') {
+                const lista = G.estilos();
+                console.log(lista.length ? '  Estilos salvos: ' + lista.join(', ') + c.muted('  · /taste usar <nome>') : c.muted('  Nenhum estilo salvo ainda. /taste salvar <nome> guarda o gosto de agora.'));
+                break;
+            } else if (/^tirar\s+\d+$/.test(a)) {
+                const g = G.tirarReferencia(a.split(/\s+/)[1]);
+                console.log(g ? c.ok(`  Referência ${a.split(/\s+/)[1]} tirada.`) : c.err('  Não tem essa referência. /taste mostra os números.'));
+            } else if (a && a !== 'ver') { console.log(c.err('Uso: /taste [refazer|apagar|tirar N|força pouco/médio/muito|provar [assunto]|salvar <nome>|usar <nome>|estilos]')); break; }
+            const linhas = G.listar(G.ler());
+            if (!linhas.length) { console.log(c.muted('  Ainda não tem gosto salvo. /taste refazer abre a tela, e /taste referencias recebe os vídeos que você curtiu.')); break; }
+            for (const l of linhas) console.log(/^\s*"/.test(l) ? c.muted('  ' + l) : '  ' + l);
+            if ((G.ler().referencias || []).length) console.log(c.muted('  /taste tirar N tira um vídeo · /taste referencias traz mais'));
             break;
         }
         /* A memória entre sessões (lib/memoria-usuario.js): ver, esquecer, achar a pasta. */
-        case 'memoria': {
+        case 'memory': {
             const M = require('../lib/memoria-usuario.js');
             const [sub, ...resto] = String(rest || '').trim().split(/\s+/);
             const a = (sub || '').toLowerCase();
             if (a === 'pasta') { console.log(c.muted('  ') + M.pasta()); break; }
             if (a === 'esquecer') {
                 const alvo = resto.join(' ');
-                if (!alvo) { console.log(c.err('Uso: /memoria esquecer <nome>')); break; }
+                if (!alvo) { console.log(c.err('Uso: /memory esquecer <nome>')); break; }
                 const r = M.apagar(alvo);
                 console.log(r.ok ? c.ok(`  Esqueci "${r.nome}".`) : c.err('  ' + r.error));
                 break;
             }
-            if (a) { console.log(c.err('Uso: /memoria [esquecer <nome> | pasta]')); break; }
+            if (a) { console.log(c.err('Uso: /memory [esquecer <nome> | pasta]')); break; }
             const lista = M.listar();
             if (!lista.length) { console.log(c.muted('  Ainda não lembro de nada. Conforme você trabalha, eu vou anotando.')); break; }
             console.log('');
             for (const m of lista) console.log('  ' + c.brand(m.nome) + c.dim(` (${m.tipo})`) + c.muted(' — ' + m.descricao));
-            console.log(c.dim(`\n  ${lista.length} memórias · /memoria esquecer <nome> · /memoria pasta`));
+            console.log(c.dim(`\n  ${lista.length} memórias · /memory esquecer <nome> · /memory pasta`));
             break;
         }
         case 'sandbox': {
@@ -2037,8 +2333,7 @@ async function handleSlash(text) {
             console.log(c.dim(`  ${e.rede ? 'Com a rede aberta, o que o comando LÊ pode sair pela internet: a lista acima é o que fica protegido. ' : ''}Detalhes: docs/sandbox.md`));
             break;
         }
-        case 'permissoes':
-        case 'permissions': {
+        case 'perms': {
             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',
@@ -2049,12 +2344,12 @@ async function handleSlash(text) {
             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|plano'));
+                console.log(c.dim('  Use /perms auto|perguntar|livre|plano'));
                 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|plano'));
+                console.log(c.err('Uso: /perms auto|perguntar|livre|plano'));
                 break;
             }
             const m = perigo.normalizarModo(pedido);
@@ -2063,7 +2358,7 @@ async function handleSlash(text) {
             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.'));
+                console.log('  ' + c.warn('   O que der errado pode não ter volta. /perms auto desfaz.'));
             }
             break;
         }
@@ -2118,7 +2413,8 @@ async function handleSlash(text) {
         }
 
         case 'attach': {
-            if (!rest) { console.log(c.err('Uso: /attach <arquivo>')); break; }
+            if (!rest) { listarAnexos(); break; }
+            if (/^https?:\/\//i.test(rest)) { await anexarPagina(rest); break; }
             try {
                 // Relativo à pasta de trabalho (a do /dir), como o /read — não ao
                 // terminal de onde o PrimoCode foi aberto.
@@ -2140,55 +2436,65 @@ async function handleSlash(text) {
             // 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; }
+            // o /init reescreve o PRIMO.md inteiro: as regras do /regra voltam pro topo depois
+            const regras = require('../lib/regras.js');
+            const guardadas = regras.ler(projectDir());
+            try { await sendPrompt(PEDIDO_INIT); } finally {
+                state.mode = modoAntes;
+                if (regras.garantir(projectDir(), guardadas).length) console.log(c.muted(`  As suas ${guardadas.length === 1 ? 'regra voltou' : guardadas.length + ' regras voltaram'} pro topo do PRIMO.md.`));
+            }
             break;
         }
 
         case 'detach': state.attachedFiles = []; console.log(c.ok('Anexos removidos.')); refreshPrompt(); break;
 
-        case 'files':
-            if (!state.attachedFiles.length) console.log(c.muted('Nenhum arquivo anexado.'));
-            else state.attachedFiles.forEach((f) => console.log(`  ${c.brand(f.path)} ${c.muted(tools.fmtBytes(f.content.length))}`));
-            break;
 
         // A lista vem de lib/catalogo.js, e o test/catalogo.test.js cruza aquela
         // lista com as tools que o tools.execute realmente atende. Ou seja: esta
         // tela não consegue prometer coisa que o programa não faz.
-        case 'all':
-        case 'tools': {
-            const cols = Math.max(40, Math.min(process.stdout.columns || 90, 110));
-            console.log('');
-            for (const g of catalogo.GRUPOS) {
-                console.log('  ' + c.bold(c.white(g.nome)) + ' ' + ui.truncate(c.dim('— ' + g.resumo), cols - 4 - ui.visibleWidth(g.nome)));
-                for (const i of g.itens) {
-                    console.log('    ' + c.brand(ui.padRight(i.tool, 23)) + ui.truncate(c.muted(i.faz), cols - 28));
-                }
-                console.log('');
-            }
-            console.log(c.dim(`  ${catalogo.TODAS.length} ferramentas. Você não precisa saber nenhum desses nomes — peça em português.`));
-            break;
-        }
 
         /* ── /desfazer ────────────────────────────────────────────────
          * Quem não sabe git não tem como voltar uma edição ruim. Aqui volta:
          * cada pedido tirou uma foto do projeto (com git) ou guardou o
          * original dos arquivos que mexeu (sem git). */
-        case 'desfazer': case 'undo': case 'rewind': {
+        case 'undo': {
             const cps = checkpoint.lista(projectDir());
-            if (!cps.length) { console.log(c.muted('  Nada para desfazer nesta pasta.')); break; }
+            const BK = require('../lib/backup-banco.js');
+            const hora = (iso) => new Date(iso).toLocaleString('pt-BR', { dateStyle: 'short', timeStyle: 'short' });
+            if (!cps.length) {
+                // sem foto do pedido (a pasta está fora do git, ou o banco é ignorado), a cópia do banco ainda volta
+                const sobra = BK.pendentes(projectDir()).slice(-1)[0];
+                if (!sobra) { console.log(c.muted('  Nada para desfazer nesta pasta.')); break; }
+                console.log(c.muted(`  Tem uma cópia do banco de ${hora(sobra.criado)}: ${sobra.arquivos.join(', ')}`));
+                if (!(await confirm('Voltar o banco para essa cópia?'))) { console.log(c.muted('Cancelado.')); break; }
+                for (const f of BK.restaurar(projectDir(), sobra)) console.log(f.acao === 'falhou' ? c.err(`  falhou: ${f.erro}  ${f.arquivo}`) : c.ok('  banco voltou  ') + f.arquivo);
+                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.mudou.length} ${cp.mudou.length === 1 ? 'arquivo mudou' : 'arquivos mudaram'}`)));
-                console.log(c.muted('\n  /desfazer N volta os N últimos pedidos.'));
+                    + c.muted(`${cp.mudou.length} ${cp.mudou.length === 1 ? 'arquivo mudou' : 'arquivos mudaram'}`)
+                    + (cp.funcionava ? ` ${c.ok('✓ funcionava')}${cp.funcionava_como ? c.dim(' · ' + cp.funcionava_como) : ''}` : '')));
+                console.log(c.muted('\n  /undo N volta os N últimos pedidos.'));
                 if (checkpoint.modo(projectDir()) === 'arquivo') {
                     console.log(c.muted('  Sem git aqui: só volta o que o agente escreveu com as ferramentas de arquivo (não o que um comando apagou).'));
                 }
                 break;
             }
+            // /desfazer fora: só o que o último pedido mudou sem você ter citado (lib/escopo.js)
+            if (/^(fora|extras?)$/i.test(rest)) {
+                // tirado do checkpoint (o pedido fica no manifest), não da memória: vale depois de fechar e abrir o PrimoCode
+                const ultimo = cps[0];
+                const fora = ultimo ? require('../lib/escopo.js').foraDoPedido(ultimo.pedido, ultimo.mudou, projectDir()) : [];
+                if (!fora.length) { console.log(c.muted('  O último pedido não mexeu em nada além do que você citou.')); break; }
+                const feitos = checkpoint.desfazerArquivos(projectDir(), fora.map((f) => f.caminho));
+                for (const f of feitos) console.log(f.acao === 'falhou' ? c.err(`  ✗ ${shortPath(f.caminho)}: ${f.erro}`) : c.ok(`  ↺ ${path.relative(projectDir(), f.caminho)}`) + c.dim(` (${f.acao})`));
+                console.log(c.muted('  O que você pediu ficou. /undo volta o pedido inteiro.'));
+                break;
+            }
             const n = rest ? parseInt(rest, 10) : 1;
-            if (!(n >= 1)) { console.log(c.err('Uso: /desfazer · /desfazer lista · /desfazer N')); break; }
+            if (!(n >= 1)) { console.log(c.err('Uso: /undo · /undo lista · /undo N · /undo fora')); 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))}`);
@@ -2196,15 +2502,348 @@ async function handleSlash(text) {
             if (!previa.length) console.log(c.muted('    (o disco já está como estava antes)'));
             for (const a of previa.slice(0, 40)) console.log(c.muted(`    ${a.acao}  `) + shortPath(a.caminho));
             if (previa.length > 40) console.log(c.muted(`    … e mais ${previa.length - 40}`));
+            // a cópia do banco feita durante esses pedidos: a MAIS VELHA é o banco de antes de tudo
+            const copiaDoBanco = BK.desde(projectDir(), alvo[alvo.length - 1].quando).slice(-1)[0];
+            if (copiaDoBanco) console.log(c.muted('    banco  ') + `volta pra cópia de ${hora(copiaDoBanco.criado)} (${copiaDoBanco.arquivos.join(', ')})`);
             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));
             }
+            if (copiaDoBanco) for (const f of BK.restaurar(projectDir(), copiaDoBanco)) console.log(f.acao === 'falhou' ? c.err(`  falhou: ${f.erro}  ${f.arquivo}`) : c.ok('  banco voltou  ') + f.arquivo);
+            if (checkpoint.refazerDisponivel(projectDir())) console.log(c.muted('\n  Mudou de ideia? ') + c.brand('/redo') + c.muted(' devolve.'));
+            break;
+        }
+
+        /* /refazer: o arrependimento do /desfazer. Só o último, e só enquanto
+           nenhum pedido novo mexeu nos arquivos (lib/checkpoint.js). */
+        case 'redo': {
+            const volta = checkpoint.refazerDisponivel(projectDir());
+            if (!volta) { console.log(c.muted('  Nada para refazer: o /redo só volta o último /undo, antes de um pedido novo mudar os arquivos.')); break; }
+            console.log(c.muted(`\n  Refaz ${volta.pedidos.length === 1 ? 'o pedido' : `os ${volta.pedidos.length} pedidos`}:`));
+            for (const p of volta.pedidos) console.log(`  ${c.white(String(p || '').slice(0, 60))}`);
+            if (!(await confirm('Refazer?'))) { console.log(c.muted('Cancelado.')); break; }
+            for (const f of checkpoint.refazer(projectDir())) {
+                const rotulo = f.acao === 'falhou' ? c.err(`  falhou: ${f.erro}  `) : c.ok(`  ${f.acao}  `);
+                console.log(rotulo + shortPath(f.caminho));
+            }
+            break;
+        }
+
+        /* /conferir: "funcionou / não funcionou" em português simples. Passou?
+           O ponto fica marcado e o /restore sabe para onde ir. Falhou? Oferece
+           a IA consertar com a saída do erro já na mão. */
+        case 'check': {
+            const achou = conferirLib.descobrir(projectDir());
+            if (!achou && require('../lib/pipeline.js').acharEntrada(projectDir())) {
+                // sem script de teste, mas é uma página: abrir escondido e olhar é o teste que existe
+                const spP = new Spinner('abrindo a página escondido pra conferir').start();
+                let m = null;
+                try { m = await require('../lib/pipeline.js').medirNoNavegador(projectDir()); } catch (e) { m = { testou: false, relato: e.message }; }
+                spP.stop();
+                const exP = conferirLib.explicarPagina(m);
+                if (exP.ok) {
+                    console.log(c.ok(`  ✓ ${exP.titulo}`));
+                    if (checkpoint.marcarFuncionando(projectDir(), 'a página abriu sem erro')) console.log(c.muted("  Marquei este ponto como 'funcionava': /restore volta pra cá, e a /timeline mostra."));
+                    break;
+                }
+                console.log((exP.testou ? c.err : c.warn)(`  ${exP.testou ? '✗' : '·'} ${exP.titulo}`));
+                for (const l of exP.linhas) console.log(c.muted(`    ${l}`));
+                if (exP.testou && await confirm('Quero que a IA conserte?')) {
+                    await sendPrompt(`Abri a página escondido e ela tem problema:\n${m.relato}\nAche a causa, conserte e confira de novo.`);
+                }
+                break;
+            }
+            if (!achou) { console.log(c.muted("  Não achei como testar este projeto (sem script de test/build, e sem página pra abrir). Peça: 'cria testes pra isso'.")); break; }
+            console.log(c.muted(`  $ ${achou.comando}`));
+            const sp = new Spinner(`rodando ${achou.rotulo}`).start();
+            const r = await conferirLib.rodar(achou.comando, projectDir());
+            sp.stop();
+            if (r.semTeste) { console.log(c.muted(`  O ${achou.comando} não achou teste pra rodar (ou o pytest não está instalado). Peça: 'cria testes pra isso'.`)); break; }
+            const ex = conferirLib.explicar(r, achou);
+            if (r.ok) {
+                console.log(c.ok(`  ✓ ${ex.titulo}`));
+                if (checkpoint.marcarFuncionando(projectDir(), achou.comando)) {
+                    console.log(c.muted("  Marquei este ponto como 'funcionava': /restore volta pra cá, e a /timeline mostra."));
+                } else {
+                    // sem pedido nenhum nesta pasta ainda, não há ponto pra marcar: dizer, em vez de calar
+                    console.log(c.muted('  Ainda não tem ponto pra marcar: o primeiro pedido que mexer nos arquivos cria um, e o próximo /check marca.'));
+                }
+                break;
+            }
+            console.log(c.err(`  ✗ ${ex.titulo}`));
+            for (const l of ex.linhas) console.log(c.muted(`    ${l}`));
+            if (await confirm('Quero que a IA conserte?')) {
+                await sendPrompt(`Rodei \`${achou.comando}\` e falhou. A saída:\n${r.saida}\nAche a causa, conserte e rode \`${achou.comando}\` de novo até passar.`);
+            }
+            break;
+        }
+
+        /* /voltar: o /desfazer com destino certo — o último ponto que o
+           /check marcou como funcionando, em vez de "N pedidos" no chute. */
+        case 'restore': {
+            const ponto = checkpoint.ultimoQueFuncionava(projectDir());
+            if (!ponto) { console.log(c.muted('  Nenhum ponto marcado ainda. Quando estiver funcionando, rode /check: ele marca.')); break; }
+            if (ponto.indice === 0) { console.log(c.muted('  Você já está no último ponto que funcionava.')); break; }
+            const quando = (cp) => new Date(cp.quando).toLocaleString('pt-BR', { dateStyle: 'short', timeStyle: 'short' });
+            const alvo = checkpoint.lista(projectDir()).slice(0, ponto.indice);
+            console.log(c.muted(`\n  O último ponto que funcionava: ${quando(ponto.cp)}, "${String(ponto.cp.pedido || '').slice(0, 50)}"`)
+                + (ponto.cp.funcionava_como ? c.dim(` (conferido: ${ponto.cp.funcionava_como})`) : ''));
+            console.log(c.muted(`\n  Volta ${alvo.length === 1 ? 'o pedido' : `os ${alvo.length} pedidos`} feito${alvo.length === 1 ? '' : 's'} depois do último ponto que funcionava:`));
+            for (const cp of alvo) console.log(`  ${c.dim(quando(cp))}  ${c.white(cp.pedido.slice(0, 60))}`);
+            const previa = checkpoint.previa(projectDir(), ponto.indice);
+            if (!previa.length) console.log(c.muted('    (o disco já está como estava antes)'));
+            for (const a of previa.slice(0, 40)) console.log(c.muted(`    ${a.acao}  `) + shortPath(a.caminho));
+            if (previa.length > 40) console.log(c.muted(`    … e mais ${previa.length - 40}`));
+            if (!(await confirm('Voltar?'))) { console.log(c.muted('Cancelado.')); break; }
+            for (const f of checkpoint.desfazer(projectDir(), ponto.indice)) {
+                const rotulo = f.acao === 'falhou' ? c.err(`  falhou: ${f.erro}  `) : c.ok(`  ${f.acao}  `);
+                console.log(rotulo + shortPath(f.caminho));
+            }
+            if (checkpoint.refazerDisponivel(projectDir())) console.log(c.muted('\n  Mudou de ideia? ') + c.brand('/redo') + c.muted(' devolve.'));
+            console.log(c.muted('  A história inteira do projeto, numa página: ') + c.brand('/timeline'));
+            break;
+        }
+
+        /* /linha-do-tempo: o /desfazer lista numa página que quem não sabe
+           git consegue ler. Pedido explícito, então abre o navegador; se não
+           abrir (app de voz), mostra onde o arquivo ficou. */
+        /* /mostrar: o app no celular de alguém no mesmo Wi-Fi, com link de prazo, sem publicar (lib/mostrar.js). */
+        case 'show': {
+            const arg = String(rest || '').trim().toLowerCase();
+            if (state.mostrando && (arg === 'parar' || arg === 'stop')) { await state.mostrando.fechar(); state.mostrando = null; console.log(c.ok('  Parei de mostrar. O link não abre mais.')); break; }
+            if (arg === 'parar' || arg === 'stop') { console.log(c.muted('  Não estou mostrando nada agora.')); break; }
+            const entradaMostrar = require('../lib/pipeline.js').acharEntrada(projectDir());
+            if (!entradaMostrar) { console.log(c.muted('  Não achei uma página pra mostrar (um index.html). Esse projeto roda como servidor? Peça "roda o projeto".')); break; }
+            if (state.mostrando) await state.mostrando.fechar();
+            const minutos = Math.max(5, Math.min(240, Number(arg) || 60));
+            const r = await require('../lib/mostrar.js').abrir(projectDir(), { minutos, entrada: entradaMostrar });   // lista.html sem index.html também abre
+            if (!r.ok) { console.log(c.err(`  Não consegui abrir: ${r.error}`)); break; }
+            state.mostrando = r;
+            console.log(c.ok(`  Mostrando ${path.basename(projectDir())} por ${minutos} min, só pra quem está no mesmo Wi-Fi:`));
+            console.log('  ' + c.white(r.url || r.urlLocal));
+            console.log(c.muted('  Nada foi publicado: o link morre no prazo ou quando você fecha o PrimoCode. .env, .git e node_modules nunca saem. /show parar fecha agora.'));
+            break;
+        }
+        /* /como-rodar: o bloco "Como rodar" do PRIMO.md, tirado do disco sem modelo (lib/como-rodar.js). */
+        case 'howto': {
+            const r = require('../lib/como-rodar.js').gravar(projectDir());
+            if (!r.passos.length) { console.log(c.muted('  Ainda não deu pra saber como este projeto roda (sem package.json, index.html nem main.py).')); break; }
+            console.log(c.ok(`  ${r.criou ? 'Criei o PRIMO.md' : 'Atualizei o PRIMO.md'} com o "Como rodar":`));
+            r.passos.forEach((p, i) => console.log(`  ${c.brand(String(i + 1))}  ${p.texto}${p.comando ? c.muted(': ') + c.white(p.comando) : ''}`));
+            console.log(c.muted('  O PrimoCode lê o PRIMO.md em todo pedido. Rodar de novo atualiza o bloco.'));
+            break;
+        }
+        /* /porta: "o app não abre" por causa da porta, dito em português (lib/porta.js). */
+        case 'port': {
+            const r = await require('../lib/porta.js').diagnostico(projectDir());
+            r.linhas.forEach((l, i) => console.log(i === 0 ? '  ' + (r.url ? c.ok(l) : c.warn(l)) : /^Abra:|abra: http/.test(l) ? '  ' + c.white(l) : c.muted('  ' + l)));
+            if (r.url) console.log(c.muted(`  /open ${r.url} abre no navegador.`));
+            break;
+        }
+        /* /regra: "nunca mexa em X" no topo do PRIMO.md, que entra em todo pedido e não vira resumo (lib/regras.js). */
+        case 'rule': {
+            const R = require('../lib/regras.js');
+            const mostrar = (lista) => lista.forEach((r, i) => console.log(`  ${c.brand(String(i + 1))}  ${r}`));
+            const tira = rest.match(/^(?:tirar|tira|apagar|remover)\s+(\d+)$/i);
+            if (tira) {
+                const r = R.tirar(projectDir(), tira[1]);
+                if (!r) { console.log(c.err(`  Não tem regra ${tira[1]}. /rule mostra a lista.`)); break; }
+                console.log(c.ok(`  Tirei: ${r.tirada}`));
+                if (r.regras.length) mostrar(r.regras); else console.log(c.muted('  Não sobrou nenhuma regra.'));
+                break;
+            }
+            if (!rest.trim()) {
+                const lista = R.ler(projectDir());
+                if (!lista.length) { console.log(c.muted('  Nenhuma regra ainda. Exemplo: /rule nunca mexa no style.css')); break; }
+                console.log(c.white(`  As regras de ${path.basename(projectDir())} (o PrimoCode segue em todo pedido):`));
+                mostrar(lista);
+                console.log(c.muted('  /rule tirar N tira uma.'));
+                break;
+            }
+            const r = R.adicionar(projectDir(), rest);
+            console.log(r.ja_tinha ? c.muted('  Essa regra já estava lá.') : c.ok('  Guardei no topo do PRIMO.md. Vale em todo pedido, mesmo depois de resumir a conversa:'));
+            mostrar(r.regras);
+            break;
+        }
+        /* /mapa: o que tem no projeto, em português, e o arquivo que é pedido mas não existe (lib/mapa.js). */
+        case 'map': {
+            const arvore = rest.match(/^(?:tree|arvore|árvore)\b\s*(\d*)/i);
+            if (arvore) { console.log(tools.treeDir(projectDir(), parseInt(arvore[1], 10) || 2)); break; }
+            const M = require('../lib/mapa.js');
+            const m = M.montar(projectDir());
+            for (const l of M.texto(m, path.basename(projectDir()))) console.log(/⚠/.test(l) ? c.warn(l) : /^\S/.test(l) ? '  ' + c.white(l) : c.muted(l));
+            if (m.faltando.length) console.log(c.muted('  Peça: "cria o que está faltando", ou rode /check pra ver a página abrindo.'));
+            break;
+        }
+        /* /mudou: o que mudou no projeto, em português simples (lib/mudou.js), e não um diff. */
+        case 'changes': {
+            const r = require('../lib/mudou.js').medir(projectDir());
+            console.log('  ' + c.white(r.frase));
+            for (const a of r.arquivos.slice(0, 15)) {
+                const rotulo = r.git ? (a.novo ? c.ok('novo    ') : a.apagado ? c.warn('apagado ') : c.muted('editado ')) : c.muted((a.acao || 'mudou').padEnd(8));
+                const conta = r.git && !a.novo && !a.apagado ? c.dim(`  +${a.mais} −${a.menos}`) : '';
+                console.log(`    ${rotulo}${a.arquivo}${conta}`);
+            }
+            if (r.arquivos.length > 15) console.log(c.dim(`    … e mais ${r.arquivos.length - 15}`));
+            if (r.arquivos.length) console.log(c.muted('  Quebrou algo? /restore volta pro último ponto que funcionava.'));
+            break;
+        }
+        /* /explain: sem nada, o último pedido em 5 linhas; com uma palavra, uma linha; "projeto" é o comando de fábrica. */
+        case 'explain': {
+            const E = require('../lib/explicar.js');
+            const m = E.modo(rest);
+            if (m.tipo === 'projeto') {
+                const fabrica = comandosDaPessoa().find((x) => x.nome === 'explain');
+                if (!fabrica) { console.log(c.err('  Não achei o comando de fábrica (comandos/explain.md).')); break; }
+                console.log(c.dim(`  ⎿ /explain projeto · ${fabrica.origem}`));
+                await sendPrompt(comandosLib.expandir(fabrica, ''));
+                break;
+            }
+            if (m.tipo === 'termo') { await sendPrompt(E.pedidoDoTermo(m.termo)); break; }
+            const ultimo = E.doUltimoPedido(projectDir());
+            if (!ultimo) { console.log(c.muted('  Ainda não mudou nada por aqui. /explain projeto explica o projeto; /explain <palavra> explica uma palavra.')); break; }
+            await sendPrompt(E.pedidoDoUltimo(ultimo));
+            break;
+        }
+        /* /plan: 1ª fase no modo plano (só lê) mostra 3 a 5 passos; Enter começa, um número muda o passo (lib/plano-previo.js). */
+        case 'plan': {
+            const P = require('../lib/plano-previo.js');
+            if (!rest) { console.log(c.muted('  Uso: /plan <pedido>  — ele mostra os passos e só começa quando você aperta Enter.')); break; }
+            const antes = state.config.permissoes, tamanho = state.history.length;
+            state.config.permissoes = 'plano';
+            try { await sendPrompt(P.pedidoDoPlano(rest)); } finally { state.config.permissoes = antes; }
+            const ultima = state.history.length > tamanho ? state.history[state.history.length - 1] : null;
+            const passos = ultima && ultima.role === 'assistant' ? P.extrairPassos(ultima.content) : [];
+            if (passos.length < 2) { console.log(c.muted('  Não consegui montar uma lista de passos. Peça de novo, ou mande o pedido sem o /plan.')); break; }
+            for (;;) {
+                console.log(c.white('\n  O plano:'));
+                passos.forEach((p, i) => console.log(`  ${c.brand(String(i + 1))}  ${p}`));
+                const r = P.resposta(await ask(`\n${c.brand('?')} ${c.muted('Enter começa · número muda o passo · n cancela')} `), passos);
+                if (r.acao === 'cancelar') { console.log(c.muted('  Cancelado. Nada foi mexido.')); passos.length = 0; break; }
+                if (r.acao === 'comecar') break;
+                if (r.acao === 'editar') {
+                    const novo = (await ask(`  ${c.muted(`Passo ${r.n}, com as suas palavras (vazio apaga):`)} `)).trim();
+                    if (novo) passos[r.n - 1] = novo; else if (passos.length > 1) passos.splice(r.n - 1, 1);
+                } else console.log(c.muted('  Aperte Enter para começar, digite o número de um passo, ou n.'));
+            }
+            if (!passos.length) break;
+            state.passosProntos = P.comoPassos(rest, passos);
+            try { await sendPrompt(rest); } finally { state.passosProntos = null; }
+            break;
+        }
+        /* /lock: arquivo que o agente só lê. A recusa mora no portão (lib/perigo.js → lib/trava.js). */
+        case 'lock': {
+            const T = require('../lib/trava.js');
+            const palavras = (rest.match(/"[^"]+"|'[^']+'|\S+/g) || []).map((x) => x.replace(/^["']|["']$/g, ''));
+            const lista = (ts) => ts.forEach((t, i) => console.log(`  ${c.brand(String(i + 1))}  ${t}`));
+            if (/^(off|soltar|solta|destravar|unlock)$/i.test(palavras[0] || '')) {
+                if (palavras.length < 2) { console.log(c.err('  Uso: /lock off <arquivo>  (ou /lock off tudo)')); break; }
+                const alvos = palavras.slice(1);
+                for (const a of alvos) {
+                    const r = T.soltar(projectDir(), a);
+                    console.log(r.soltos.length ? c.ok(`  Soltei ${r.soltos.join(', ')}. O agente volta a poder mexer.`) : c.muted(`  ${a} não estava travado.`));
+                }
+                break;
+            }
+            if (!palavras.length) {
+                const ts = T.ler(projectDir());
+                if (!ts.length) { console.log(c.muted('  Nenhum arquivo travado. Exemplo: /lock login.js logo.png')); break; }
+                console.log(c.white(`  Travados em ${path.basename(projectDir())} (o agente só pode ler):`));
+                lista(ts);
+                console.log(c.muted('  /lock off <arquivo> solta um.'));
+                break;
+            }
+            const r = T.travar(projectDir(), palavras);
+            for (const f of r.fora) console.log(c.warn(`  ${f} está fora da pasta do projeto: não travei.`));
+            for (const n of r.novos) if (!fs.existsSync(path.join(projectDir(), n))) console.log(c.muted(`  ${n} ainda não existe: travei mesmo assim.`));
+            if (r.novos.length) console.log(c.ok(`  Travei ${r.novos.join(', ')}. O agente só pode ler.`));
+            else if (!r.fora.length) console.log(c.muted('  Esses já estavam travados.'));
+            if (r.travados.length) { lista(r.travados); console.log(c.muted('  /lock off <arquivo> solta um.')); }
+            break;
+        }
+        /* /save: guarda o projeto no GitHub, num repositório privado (lib/guardar.js). */
+        case 'save': {
+            const r = require('../lib/guardar.js').salvar(projectDir(), { log: (l) => console.log(c.muted('  ' + l)) });
+            console.log(r.ok ? c.ok(`  Seu trabalho está guardado fora do computador: ${r.url}`) : c.warn(`  ${r.erro}`));
+            break;
+        }
+        /* /secrets: nomes das chaves, nunca os valores; `add` pede o valor escondido (lib/segredos.js). */
+        case 'secrets': {
+            const S = require('../lib/segredos.js');
+            const [sub, nomeDado] = rest.split(/\s+/).filter(Boolean);
+            if (/^(add|adicionar|novo)$/i.test(sub || '')) {
+                const n = S.nomeValido(nomeDado);
+                if (!n) { console.log(c.warn('  Qual o nome? Exemplo: /secrets add OPENAI_API_KEY')); break; }
+                console.log(c.warn('  Isto é uma chave, não mostre pra ninguém.') + c.muted(' O que você digitar não aparece na tela.'));
+                const valor = (await askSecret(`  Valor de ${n}: `)).trim();
+                if (!valor) { console.log(c.muted('  Vazio: não guardei nada.')); break; }
+                try {
+                    const r = S.gravar(projectDir(), n, valor);
+                    console.log(c.ok(`  ${r.substituiu ? 'Troquei' : 'Guardei'} ${n} no .env${r.criou ? ' (criei o arquivo)' : ''}.`));
+                    if (r.gitignore) console.log(c.muted('  Pus .env no .gitignore: ele não vai pro GitHub.'));
+                } catch (e) { console.log(c.warn(`  ${e.message}`)); }
+                break;
+            }
+            const lista = S.listar(projectDir());
+            if (!lista.length) { console.log(c.muted('  Este projeto não usa nenhuma chave (ainda). Quando precisar: /secrets add NOME')); break; }
+            console.log(c.white('  Chaves deste projeto (só os nomes, nunca o valor):'));
+            for (const x of lista) {
+                const estado = x.noEnv && !x.vazia ? c.ok('guardada') : x.noEnv ? c.warn('vazia no .env') : c.warn('falta guardar');
+                console.log(`  ${c.brand(ui.padRight(x.nome, 28))}${ui.padRight(estado, 16)}${c.dim(x.usadaEm.length ? 'usada em ' + x.usadaEm.join(', ') : '')}`);
+            }
+            console.log(c.muted('  /secrets add NOME guarda uma. Isto é uma chave, não mostre pra ninguém.'));
+            break;
+        }
+        /* /schedule: pedido que roda sozinho no Mac, pelo launchd (lib/agendar.js). */
+        case 'schedule': {
+            const A = require('../lib/agendar.js');
+            const off = rest.match(/^(?:off|tirar|remover|cancelar)\s+(\S+)/i);
+            if (off) {
+                const r = A.remover(projectDir(), off[1]);
+                console.log(r.ok ? c.ok(`  Tirei: ${r.item.quando} · ${r.item.pedido.slice(0, 60)}`) : c.warn(`  ${r.erro}`));
+                break;
+            }
+            if (!rest) {
+                const lista = A.listar(projectDir());
+                if (!lista.length) { console.log(c.muted('  Nada agendado. Exemplo: /schedule "toda segunda às 9h" resuma o que mudou na semana')); break; }
+                console.log(c.white('  Agendados neste projeto:'));
+                lista.forEach((x, i) => console.log(`  ${c.brand(String(i + 1))}  ${c.white(x.quando)}  ${c.muted(x.pedido.slice(0, 60))}`));
+                console.log(c.muted('  O resultado de cada dia fica em .primocode/agendados/<data>.md · /schedule off <número> tira um.'));
+                break;
+            }
+            const { quando, pedido } = A.separar(rest);
+            const r = A.criar(projectDir(), quando, pedido);
+            if (!r.ok) { console.log(c.warn(`  ${r.erro}`)); break; }
+            console.log(c.ok(`  Agendado: ${r.item.quando}. O resultado vai para .primocode/agendados/<data>.md`));
+            console.log(c.muted(r.relogio ? '  Roda sozinho, mesmo com o PrimoCode fechado (o Mac precisa estar ligado). /schedule off ' + r.item.id + ' tira.'
+                : '  Atenção: o relógio automático só existe no Mac. O pedido ficou salvo, mas não vai rodar sozinho neste computador.'));
+            break;
+        }
+        /* /ship: site estático, Next e app Node simples vão pro ar de verdade (lib/publicar.js); o resto cai no guia
+           de fábrica (comandos/ship.md), que também vale pro /ship.md que a pessoa escreveu. */
+        case 'ship': {
+            const guia = comandosDaPessoa().find((x) => x.nome === 'ship');
+            if (guia && guia.origem !== 'primocode') { console.log(c.dim(`  ⎿ /ship · ${guia.origem}`)); await sendPrompt(comandosLib.expandir(guia, rest)); break; }
+            const r = await require('../lib/publicar.js').publicar(projectDir(), { log: (l) => console.log(c.muted('  ' + l)), confirmar: (q) => confirm(q) });
+            if (r.guiado) {
+                if (!guia) { console.log(c.err('  Não achei o guia de fábrica (comandos/ship.md).')); break; }
+                console.log(c.muted('  Este projeto eu não publico sozinho: vou te guiar passo a passo.'));
+                await sendPrompt(comandosLib.expandir(guia, rest));
+                break;
+            }
+            if (r.recusou) console.log(c.muted('  Tudo bem, não enviei nada.'));
+            else console.log(r.ok ? c.ok(`  Seu projeto está no ar: ${r.url}`) : c.warn(`  ${r.erro}`));
+            break;
+        }
+        case 'timeline': {
+            const arquivo = require('../lib/linha-do-tempo').gravar(projectDir());
+            const r = await tools.openInBrowser(arquivo);
+            if (r && r.ok === false) console.log(c.muted('  A página está em: ') + arquivo);
+            else console.log(c.ok('  Abri a história do projeto no navegador.') + c.dim('  ' + shortPath(arquivo)));
             break;
         }
 
-        case 'tree': console.log(tools.treeDir(projectDir(), parseInt(rest, 10) || 2)); break;
 
         case 'read': {
             if (!rest) { console.log(c.err('Uso: /read <arquivo>')); break; }
@@ -2231,46 +2870,27 @@ async function handleSlash(text) {
            parece (findSimilarProject) — e quem quer começar do zero não tem
            como dizer isso. Aqui a pasta nasce antes, com nome que não colide,
            e o pedido roda preso nela. */
-        case 'novo': case 'new': {
-            if (!rest) { console.log(c.err('Uso: /novo <o que você quer criar>') + c.dim('  ex.: /novo site da padaria')); break; }
-            const nomes = cfg.listProjects();
-            const sp = new Spinner('escolhendo o nome da pasta').start();
-            const sugerido = await nomeProjeto.escolher({ pedido: rest, nomes, perguntar: perguntarNome }).catch(() => null);
-            sp.stop();
-            const nomeNovo = extra.nomeDoNovo({
-                descricao: rest, nomes, sugerido, derivar: deriveProjectName,
-                // A régua curta (lib/nome-curto.js) também no /novo.
-                slugify: (t) => nomeCurto(t) || cfg.slugify(t), semColisao: nomeProjeto.semColisao,
-            });
-            const dir = cfg.createProjectDir(nomeNovo);
-            entrarNoProjeto(dir, 'projeto');
-            // Conversa nova junto: o que se falou do projeto anterior puxaria o
-            // agente de volta para ele.
-            state.history = []; state.memoria = memoria.nova(); state.gravador.zerar();
-            console.log(c.ok(`  Projeto novo: ${state.currentProject}`) + c.muted(`  (${shortPath(dir)})`));
-            refreshPrompt();
-            const modoAntes = state.mode;
-            state.mode = 'primocode';
-            state.projetoFixo = true;
-            try { await sendPrompt(extra.pedidoDoNovo(rest, state.currentProject)); }
-            finally { state.mode = modoAntes; state.projetoFixo = false; }
+        case 'new': {
+            // sem nada: as 3 perguntas de quem nunca programou (era o /new)
+            if (!rest) { await comecarPerguntas(); break; }
+            await criarProjetoNovo(rest);
             break;
         }
 
-        /* /open sem nada (e /abrir) acha sozinho o que abrir: o servidor do
+        /* /open sem nada (e /open) acha sozinho o que abrir: o servidor do
            projeto de pé, ou a index.html. Antes pedia o caminho, e quem não
            sabe que a página se chama index.html ficava parado aqui. */
-        case 'abrir': case 'open': {
+        case 'open': {
             if (!rest) {
                 const pastaAtual = projectDir();
                 if (path.resolve(pastaAtual) === path.resolve(cfg.ROOT_DIR)) {
-                    console.log(c.muted('  Nenhum projeto aberto.') + c.dim('  /projetos para escolher um'));
+                    console.log(c.muted('  Nenhum projeto aberto.') + c.dim('  /projects para escolher um'));
                     break;
                 }
                 const alvo = await extra.acharAlvoAbrir(pastaAtual);
                 if (!alvo) {
                     console.log(c.muted(`  Não achei página nem servidor em ${shortPath(pastaAtual)}.`));
-                    console.log(c.dim('  Peça "roda o projeto" ao Primo, ou /open <arquivo>.'));
+                    console.log(c.dim('  Peça "roda o projeto" ao Primo, ou /open <arquivo>. O app devia estar rodando? /port diz por que não abre.'));
                     break;
                 }
                 const r = await tools.openInBrowser(alvo.url || alvo.caminho);
@@ -2285,6 +2905,13 @@ async function handleSlash(text) {
         }
 
         case 'name': {
+            // /name voz <Nome>: o nome do assistente de voz (o mesmo do /voice nome)
+            const nomeVoz = rest.match(/^(?:voz|voice|assistente)\s+(.{2,20})$/i);
+            if (nomeVoz) {
+                const salvo = vozModo.definirNome(nomeVoz[1]);
+                console.log(salvo ? c.ok(`  Fechado: o assistente agora se chama ${salvo}. Vale na próxima vez que ligar o /voice.`) : c.err('  Nome inválido (1 ou 2 palavras, até 20 letras).'));
+                break;
+            }
             if (!rest) { console.log(c.muted(`  Nome atual: ${state.config.userName || '(nenhum)'}`)); break; }
             state.config.userName = rest;
             cfg.saveConfig({ userName: rest });
@@ -2296,14 +2923,14 @@ async function handleSlash(text) {
            nome ou número — na hora, se há teclado; senão pelo /mascot <n>.
            Num pipe não pergunta: a "resposta" seria o próximo comando. */
         // O kit de marca (lib/marca-kit.js): /marca criar|listar|usar <nome> [aqui]|mostrar|apagar <nome>
-        case 'marca': {
+        case 'brand': {
             const kit = require('../lib/marca-kit.js');
             const perguntar = async (t, p) => (String(await ask(`${c.brand('?')} ${t}${p ? c.muted(` [${p}]`) : ''}: `)).trim() || p || '');
             await kit.main((rest || 'mostrar').split(/\s+/), { perguntar, dizer: (t) => console.log(c.muted(t)), pasta: state.workDir || process.cwd() });
             break;
         }
 
-        case 'mascot': case 'mascote': {
+        case 'mascot': {
             const reac = rest.match(/^(reac(?:oes|ões)?|rea[cç][aã]o|reactions?)\s*(on|off|liga[r]?|desliga[r]?|sim|n[aã]o)?$/i);
             if (reac) {
                 const quer = reac[2] ? /^(on|liga|ligar|sim)$/i.test(reac[2]) : state.config.reacoes === false;
@@ -2381,7 +3008,8 @@ async function handleSlash(text) {
 
         /* O /status olha só o servidor. O /doctor olha tudo o que costuma
            ser o motivo de "não funciona" — e cada ✗ diz como consertar. */
-        case 'doctor': case 'doutor': case 'medico': case 'médico': {
+        case 'doctor': {
+            if (/^status$/i.test(rest)) { await mostrarStatus(); break; }
             const sp = new Spinner('conferindo').start();
             const linhas = await extra.diagnosticar({
                 saude: () => api.getHealth(state.config.server, state.config.token),
@@ -2405,10 +3033,21 @@ async function handleSlash(text) {
             break;
         }
 
-        case 'custo': case 'cost': case 'tokens': {
+        case 'usage': {
+            const Lim = require('../lib/limite.js');
+            const querLimite = /^(limite|limit)\b/i.exec(rest) && rest.replace(/^\S+\s*/, '').replace(/[.\s]/g, '').replace(/mil$/i, '000');
+            if (querLimite) {   // /usage limite 100000 ensina o limite do plano; sem número, mostra o uso de hoje
+                console.log(Lim.definirLimite(querLimite) ? c.ok(`  Anotei: ${Number(querLimite).toLocaleString('pt-BR')} tokens por dia. Agora os pedidos grandes dizem quantos % gastam.`) : c.warn('  Não entendi o número. Exemplo: /usage limite 100000'));
+                break;
+            }
+            guardarUsoDeHoje();
             const { linhas, total } = extra.resumoCusto(contadorDaSessao);
-            if (!linhas.length) { console.log(c.muted('  Nenhum pedido ao modelo nesta sessão ainda.')); break; }
-            console.log('');
+            const hojeL = Lim.resumoDeHoje({ tokens: Lim.usoDeHoje().tokens, limite: Lim.limiteConhecido() });
+            if (!linhas.length) { console.log(c.muted('  Nenhum pedido ao modelo nesta sessão ainda.')); hojeL.forEach((l) => console.log(c.muted('  ' + l))); break; }
+            const simples = extra.resumoSimples({ linhas, total });
+            console.log('\n  ' + c.white('Nesta conversa: ') + simples.frase);
+            console.log('  ' + c.ok(simples.quemPaga));
+            console.log(c.dim('\n  Em tokens (a unidade que o modelo conta):'));
             for (const l of linhas) {
                 console.log(`  ${c.white(ui.padRight(l.provedor, 22))}${c.muted(ui.padRight(l.pedidos + (l.pedidos === 1 ? ' pedido' : ' pedidos'), 12))}`
                     + `${c.dim('enviou ')}${c.white(extra.fmtNumero(l.enviados))}${c.dim(' · recebeu ')}${c.white(extra.fmtNumero(l.recebidos))}${c.dim(' tokens' + (l.exato ? '' : ' (estimado)'))}`);
@@ -2418,22 +3057,70 @@ async function handleSlash(text) {
                     + `${c.dim('enviou ')}${c.white(extra.fmtNumero(total.enviados))}${c.dim(' · recebeu ')}${c.white(extra.fmtNumero(total.recebidos))}`);
             }
             if (linhas.some((l) => !l.exato)) console.log(c.dim('\n  Estimado = caracteres ÷ 4. Conta cada pedido inteiro, com a conversa que vai junto.'));
+            console.log(''); hojeL.forEach((l) => console.log(c.white('  ' + l)));
             break;
         }
 
-        case 'videos': case 'vídeos': {
+        /* O que o agente deixou de pé com run_background (lib/fundo.js). */
+        case 'tasks': {
+            const fundo = require('../lib/fundo.js');
+            const [sub, alvo] = rest.split(/\s+/).filter(Boolean);
+            if (/^(rodar|run)$/i.test(sub || '')) {
+                // A pessoa também deixa coisa de pé, sem pedir ao agente (como o /run, mas sem travar).
+                const cmd = rest.replace(/^\S+\s*/, '');
+                if (!cmd) { console.log(c.warn('  Qual comando? /tasks rodar npm run dev')); break; }
+                const r = fundo.iniciar(cmd, { projectDir: projectDir(), env: tools.ambienteLimpo(process.env, tools.permitidasNoShell()) });
+                console.log(r.ok ? c.ok(`  ${r.id} rodando em segundo plano.`) + c.muted(' /tasks mostra a saída e o endereço.') : c.warn(`  ${r.error}`));
+                break;
+            }
+            if (/^(abrir|open)$/i.test(sub || '')) {
+                // Sem id: a primeira que anunciou endereço — quase sempre é a única.
+                const t = fundo.listar().find((x) => x.url && x.rodando && (!alvo || x.id === alvo));
+                if (!t) { console.log(c.warn(alvo ? `  ${alvo} não anunciou endereço (ou já parou).` : '  Nada rodando com endereço pra abrir.')); break; }
+                const r = await tools.openInBrowser(t.url);
+                console.log(r && r.ok === false ? c.warn(`  Não abriu: ${r.error}. Abra você: ${t.url}`) : c.ok(`  Abri ${t.url}`));
+                break;
+            }
+            if (/^(parar|stop|kill)$/i.test(sub || '')) {
+                if (!alvo) { console.log(c.warn('  Qual? /tasks parar <id>')); break; }
+                const r = fundo.parar(alvo);
+                console.log(r.ok ? c.ok(`  Parei ${alvo}.`) : c.warn(`  ${r.error}`));
+                break;
+            }
+            const lista = fundo.listar();
+            if (!lista.length) { console.log(c.muted('  Nada rodando em segundo plano.')); break; }
+            console.log('');
+            for (const t of lista) {
+                const estado = t.rodando ? c.ok('rodando') : c.muted(`terminou${t.codigo === null ? '' : ' (código ' + t.codigo + ')'}`);
+                const tempo = t.segundos >= 60 ? `${Math.floor(t.segundos / 60)}min${String(t.segundos % 60).padStart(2, '0')}s` : `${t.segundos}s`;
+                console.log(`  ${c.white(ui.padRight(t.id, 12))}${ui.padRight(estado, 28)}${c.dim(ui.padRight(tempo, 9))}${ui.truncate(c.muted(t.comando), Math.max(20, (process.stdout.columns || 80) - 52))}`);
+                if (t.url && t.rodando) console.log(`  ${' '.repeat(12)}${c.brand(t.url)}`);
+            }
+            break;
+        }
+
+        case 'videos': {
             console.log(require('../lib/estudio/exportar.js').main(rest.split(/\s+/).filter(Boolean)).texto);
             break;
         }
 
-        case 'copiar': case 'copy': {
+        /* /exportar: a conversa vira um .md local, com chave e senha escondidas (lib/exportar-conversa.js). */
+        case 'export': {
+            const conversa = state.history.filter((m) => m.role === 'user' || m.role === 'assistant');
+            if (!conversa.length) { console.log(c.muted('  Ainda não tem conversa pra exportar: faça um pedido primeiro.')); break; }
+            const arq = require('../lib/exportar-conversa.js').gravar(conversa, { projeto: path.basename(projectDir()) });
+            console.log(c.ok(`  Conversa salva (${conversa.length} mensagens): `) + shortPath(arq));
+            console.log(c.muted('  Chave e senha saem trocadas por [chave escondida]. É um arquivo seu, sem link público.'));
+            break;
+        }
+        case 'copy': {
             const r = extra.copiar(state.lastResponse);
             if (r.ok) console.log(c.ok('  Copiado.') + c.dim(`  ${state.lastResponse.length} caracteres · é só colar`));
             else console.log(c.muted(`  Não copiei: ${r.error}.`));
             break;
         }
 
-        case 'historico': case 'histórico': {
+        case 'history': {
             const achados = extra.buscarHistorico(cfg.HISTORY_FILE, rest, 20);
             if (!achados.length) {
                 console.log(c.muted(rest ? `  Nada com "${rest}" nos seus pedidos.` : '  Nenhum pedido guardado ainda.'));
@@ -2447,41 +3134,16 @@ async function handleSlash(text) {
                 console.log(`  ${c.dim(quando)}  ${c.muted(ui.padRight(ui.truncate(e.project || e.mode || '', 14), 14))} `
                     + ui.truncate(c.white(String(e.prompt).replace(/\s+/g, ' ')), largura));
             }
-            console.log(c.dim(`\n  ${achados.length === 20 ? 'Os 20 mais recentes' : achados.length + ' pedido(s)'}${rest ? ` com "${rest}"` : ''} · /historico <termo> filtra · /chats abre conversas`));
+            console.log(c.dim(`\n  ${achados.length === 20 ? 'Os 20 mais recentes' : achados.length + ' pedido(s)'}${rest ? ` com "${rest}"` : ''} · /history <termo> filtra · /chats abre conversas`));
             break;
         }
 
-        case 'atalhos': case 'shortcuts': case 'teclas': {
+        case 'keys': {
             console.log('');
             for (const [tecla, faz] of extra.ATALHOS) console.log(`  ${c.brand(ui.padRight(tecla, 20))}${c.muted(faz)}`);
             break;
         }
 
-        case 'status': {
-            const sp = new Spinner('verificando').start();
-            try {
-                const h = await api.getHealth(state.config.server, state.config.token);
-                sp.stop();
-                console.log(c.ok(`Servidor: ${h.status || 'ok'}`));
-                if (h.version) console.log(c.muted(`  Versão: ${h.version}`));
-                if (h.model) console.log(c.muted(`  Modelo: ${h.model}`) + (h.gratis ? c.dim('  · grátis') : ''));
-                // A corrente inteira: é o que garante que um modelo no limite não
-                // vira erro na sua tela.
-                if (h.correntes && h.correntes[state.config.model || 'main']) {
-                    const fila = h.correntes[state.config.model] || h.correntes.main;
-                    console.log(c.dim(`  Reservas: ${fila.length - 1}`));
-                }
-            } catch (e) { sp.stop(); console.log(c.err(`Indisponível: ${e.message}`)); }
-            // A memória da conversa: quanto ela está poupando por pedido.
-            if (state.history.length) {
-                const e = memoria.economia(state.memoria, state.history);
-                console.log(c.muted(`  Conversa: ${state.history.length} mensagens`)
-                    + (state.memoria.resumo
-                        ? c.dim(`  · resumida, ${e.enxuto} tokens por pedido em vez de ${e.cheio}`)
-                        : c.dim(`  · ${e.enxuto} tokens por pedido`)));
-            }
-            break;
-        }
 
         /* ── AS SKILLS ───────────────────────────────────────────────────
          * `/skills` lista, `/install-skill` traz de um arquivo, e
@@ -2492,6 +3154,21 @@ async function handleSlash(text) {
          * modelo — que o usuário vê acontecendo, ação por ação, na tela.
          */
         case 'skills': {
+            const sub = rest.match(/^(store|loja|add|instalar)\b\s*(.*)$/i);
+            if (sub && /^(store|loja)$/i.test(sub[1])) { await abrirMarketplace(); break; }
+            if (sub) {
+                const alvo = sub[2].trim();
+                if (!alvo) {
+                    console.log(c.muted('  Uso: ') + c.brand('/skills add <caminho do SKILL.md>'));
+                    console.log(c.dim('  Ou abra o ') + c.brand('/skills store') + c.dim(' e escolha "New Skill" para escrever uma.'));
+                    break;
+                }
+                const r = await instalarComPortao(alvo);
+                if (!r.ok) { console.log(c.err(`  ${r.error}`)); break; }
+                console.log(c.ok(`  Skill instalada: ${r.nome}`) + c.muted(`  (${shortPath(r.caminho)})`));
+                console.log(c.dim('  Já está ligada. /skills mostra todas.'));
+                break;
+            }
             const lista = skills.listar();
             if (!lista.length) { console.log(c.muted('  Nenhuma skill instalada.')); break; }
             const ligadas = lista.filter((s) => s.ligada);
@@ -2504,29 +3181,17 @@ async function handleSlash(text) {
                     + c.dim(ui.truncate(s.descricao, (process.stdout.columns || 80) - 36)));
             }
             console.log('');
-            console.log(c.dim('  /marketplace liga e desliga · o corpo da skill só entra no pedido'));
+            console.log(c.dim('  /skills store liga e desliga · o corpo da skill só entra no pedido'));
             console.log(c.dim('  quando o assunto bate, para não gastar o teto de tokens à toa.'));
             break;
         }
 
-        case 'install-skill': case 'installskill': {
-            if (!rest) {
-                console.log(c.muted('  Uso: ') + c.brand('/install-skill <caminho do SKILL.md>'));
-                console.log(c.dim('  Ou abra o ') + c.brand('/marketplace') + c.dim(' e escolha "New Skill" para escrever uma.'));
-                break;
-            }
-            const r = await instalarComPortao(rest);
-            if (!r.ok) { console.log(c.err(`  ${r.error}`)); break; }
-            console.log(c.ok(`  Skill instalada: ${r.nome}`) + c.muted(`  (${shortPath(r.caminho)})`));
-            console.log(c.dim('  Já está ligada. /skills mostra todas.'));
-            break;
-        }
 
         /* ── /voice ──────────────────────────────────────────────────────
          * O ouvido e a boca são Python (voz/primo_voz); o cérebro é este
          * terminal. Ver entradaDeVoz no main() e lib/voz.js.
          */
-        case 'voice': case 'voz': {
+        case 'voice': {
             /* ── O MODO VOZ É UMA FORMA DE DIGITAR ─────────────────────────
                Você fala; o que foi dito entra aqui como se tivesse sido
                digitado — a mesma fila, o mesmo recado no meio da tarefa, o
@@ -2601,10 +3266,6 @@ async function handleSlash(text) {
             break;
         }
 
-        case 'marketplace': case 'market': {
-            await abrirMarketplace();
-            break;
-        }
 
         /* ── /connectors ─────────────────────────────────────────────────
          * Só mostra. Não há o que configurar — os conectores vivem no
@@ -2617,7 +3278,7 @@ async function handleSlash(text) {
          * dá para ver que o preferido está fora e outro assumiu — e essa é a
          * primeira pergunta de todo suporte.
          */
-        case 'connectors': case 'conectores': {
+        case 'connectors': {
             const sp = new Spinner('lendo os conectores').start();
             let dados = null;
             try {
@@ -2694,7 +3355,7 @@ async function handleSlash(text) {
             }
             if (!r.ok) { console.log(c.err(`  ${r.error}`)); break; }
             console.log(c.ok('  Conectado.')
-                + c.muted(r.pro ? `  Plano ${r.plano}.` : '  Sua conta ainda não tem plano: ') + (r.pro ? '' : c.brand('/planos')));
+                + c.muted(r.pro ? `  Plano ${r.plano}.` : '  Sua conta ainda não tem plano: ') + (r.pro ? '' : c.brand('/account plans')));
             return r;
         }
 
@@ -2746,6 +3407,7 @@ async function handleSlash(text) {
         }
 
         case 'account': {
+            if (/^(plans?|planos?)$/i.test(rest)) { await mostrarPlanos(); break; }
             const eu = conta.atual();
             if (!eu) {
                 console.log(c.muted('  Não conectado. ') + c.brand('/login') + c.muted(' para entrar.'));
@@ -2758,7 +3420,7 @@ async function handleSlash(text) {
             console.log(c.white('  Conta   ') + c.muted(eu.email || eu.uid));
             if (s.ok) {
                 const ate = s.planoAte ? c.dim(`  até ${new Date(s.planoAte).toLocaleDateString('pt-BR')}`) : '';
-                console.log(c.white('  Plano   ') + (s.pro ? c.brand(s.plano) + ate : c.muted('sem plano  ') + c.brand('/planos')));
+                console.log(c.white('  Plano   ') + (s.pro ? c.brand(s.plano) + ate : c.muted('sem plano  ') + c.brand('/account plans')));
             } else if (s.offline) {
                 console.log(c.white('  Plano   ') + c.muted(eu.plano) + c.dim('  (sem rede — último conhecido)'));
             } else {
@@ -2768,14 +3430,6 @@ async function handleSlash(text) {
             break;
         }
 
-        case 'planos': {
-            const sp = new Spinner('buscando os planos').start();
-            const r = await planosTela.buscarPlanos(state.config.server);
-            sp.stop();
-            const eu = conta.atual();
-            for (const l of planosTela.desenhar(r, { cores: c, atual: eu && eu.pro ? eu.plano : null, site: conta.SITE })) console.log(l);
-            break;
-        }
 
         case 'uninstall': {
             if (await confirm('Remover o PrimoCode? Seus projetos em ~/primocode NÃO serão apagados.')) {
@@ -2787,7 +3441,7 @@ async function handleSlash(text) {
         case 'version': console.log(c.brand(`PrimoCode v${VERSION}`)); break;
         // rl.close() em vez de process.exit(): sair na marra descarta o que
         // ainda estava no buffer de saída.
-        case 'exit': case 'quit': if (rl) rl.close(); break;
+        case 'exit': if (rl) rl.close(); break;
         /* ── OS COMANDOS APOSENTADOS ──────────────────────────────────────
          * `/claude`, `/gpt`, `/codex` e `/key` existiam quando o PrimoCode
          * rodava em cima da assinatura da própria pessoa: ela instalava o
@@ -2808,7 +3462,7 @@ async function handleSlash(text) {
         /* O servidor aqui, no computador da pessoa, até a sessão acabar
            (lib/offline.js). "Enquanto não tenho acesso ao Railway, eu testo
            com o projeto rodando localmente." (24/09/2026) */
-        case 'offline': case 'local': {
+        case 'offline': {
             if (/^(off|sair|desligar|parar)$/i.test(rest)) {
                 if (!state.servidorAntes) { console.log(c.muted('  O /offline não está ligado.')); break; }
                 offline.desligar();
@@ -2845,7 +3499,60 @@ async function handleSlash(text) {
         }
 
         /* Os comandos da pessoa: lista, e explica como fazer o dela. */
-        case 'comandos': {
+        case 'styles': {
+            // Os kits de estilo de motion (lib/kits.js): a lista no terminal e a galeria (capa + preview + nome).
+            const K = require('../lib/kits.js');
+            const a = String(rest || '').trim();
+            if (a && !/^(galeria|abrir|lista)$/i.test(a)) {
+                const k = K.achar(a);
+                if (!k) { console.log(c.warn(`  Não achei o estilo "${a}". /styles mostra todos.`)); break; }
+                console.log(`  ${c.brand(k.nome)} ${c.muted(`(${k.slug} · ${k.familia})`)}`);
+                console.log(`  ${k.descricao}`);
+                if (k.quando.length) console.log(c.muted(`  Serve pra: ${k.quando.slice(0, 3).join('; ')}`));
+                if (!K.previewPronto(k)) console.log(c.muted('  Renderizando o preview aqui (uma vez só)…'));
+                const r = await K.main(['preview', k.slug], { aoFalar: (t) => process.stdout.write(c.muted(`\r  ⎿ ${t}`.padEnd(60))) });
+                process.stdout.write('\n');
+                if (r.ok && r.video) { if (process.env.PRIMOCODE_APP !== '1') tools.openInBrowser(r.video); console.log(c.ok(`  ${r.texto}`)); }
+                else console.log(c.warn(`  ${r.texto}`));
+                console.log(c.muted(`  Pra usar: peça o vídeo dizendo "estilo ${k.nome.split(' · ')[0].toLowerCase()}".`));
+                break;
+            }
+            for (const l of K.listaParaPessoa()) console.log(/^\s/.test(l) ? c.muted(l) : `  ${c.brand(l)}`);
+            if (a.toLowerCase() === 'lista') break;
+            // a tela de estilos (os kits no carrossel da tela de gosto): no terminal abre no navegador, no app numa janela
+            console.log(c.muted(`  Abri a tela de estilos${process.env.PRIMOCODE_APP === '1' ? '' : ' no navegador'} (até 10 min). Escolha um estilo ou feche pra voltar.`));
+            const r = await K.main(['galeria']);
+            console.log((r.ok ? c.ok : c.muted)(`  ${r.texto} · /styles <estilo> mostra o preview no terminal`));
+            break;
+        }
+        case 'team': {
+            const team = require('../lib/team.js');
+            const achados = team.instalados();
+            const o = team.entender(rest, achados);
+            if (o.erro) { console.log(c.warn(`  ${o.erro}`)); break; }
+            if (o.acao === 'status') {
+                const ligado = achados.some((x) => x.nome === state.config.team) ? state.config.team : null;
+                team.status(achados, ligado).forEach((l, i) => console.log(i === 0 ? c.white(`  ${l}`) : c.muted(`  ${l}`)));
+                break;
+            }
+            if (o.acao === 'desligar') {
+                state.config.team = null;
+                cfg.saveConfig({ team: null });
+                console.log(c.ok('  O PrimoCode volta a trabalhar sozinho.'));
+                break;
+            }
+            if (o.acao === 'ligar') {
+                state.config.team = o.nome;
+                cfg.saveConfig({ team: o.nome });
+                console.log(c.ok(`  ${team.PARCEIROS[o.nome].titulo} ligado: o PrimoCode faz e ele revisa, só lendo.`));
+                console.log(c.dim(`  /team ${o.nome} faz <pedido> deixa ele fazer · /team off desliga`));
+                break;
+            }
+            await parceiroFaz(o.nome, o.pedido);
+            break;
+        }
+
+        case 'commands': {
             const novo = rest.match(/^(novo|new|criar)\s+(\S+)$/i);
             if (novo) {
                 const r = comandosLib.criar(novo[2]);
@@ -2860,14 +3567,14 @@ async function handleSlash(text) {
             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('\n  Um arquivo .md vira um comando: review.md é /review.'));
             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.'));
+            console.log(c.dim('  $ARGUMENTOS no texto recebe o que você digitar depois: /review o login.'));
+            console.log(c.dim('  /commands novo <nome> cria um para você editar.'));
             break;
         }
 
-        case 'claude': case 'gpt': case 'codex': case 'key': case 'keys': {
+        case 'claude': case 'gpt': case 'codex': case 'key': {
             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.'));
             console.log(c.dim('  /effort escolhe o esforço · /account mostra o seu plano'));
@@ -2889,7 +3596,9 @@ async function handleSlash(text) {
                 await sendPrompt(comandosLib.expandir(proprio, rest));
                 break;
             }
-            const casam = comandosDoMenu().map(([nome]) => nome.slice(1)).filter((n) => n.startsWith(cmd.toLowerCase()));
+            let casam = comandosDoMenu().map(([nome]) => nome.slice(1)).filter((n) => n.startsWith(cmd.toLowerCase()));
+            // Meio apelido antigo também serve: "/desf" chega no /undo.
+            if (!casam.length) casam = nomes.porPrefixo(cmd).filter((n) => comandosDoMenu().some(([m]) => m === '/' + n));
             if (casam.length === 1) {
                 console.log(c.dim(`  → /${casam[0]}`));
                 await handleSlash('/' + casam[0] + (rest ? ' ' + rest : ''));
@@ -2962,6 +3671,52 @@ async function main() {
     if (process.argv[2] === 'editor') {
         process.exit(await require('../lib/editor-pro.js').main(process.argv.slice(3)));
     }
+    /* `primocode gosto medir <video> [mais videos] [--salvar]`: os números do vídeo que a pessoa curtiu (lib/estudio/gosto-medir.js).
+       Com --salvar, cada um entra no gosto como referência. (O /taste de dentro da sessão é outra entrada.) */
+    // `primocode gosto` fora da sessão: o mesmo que o /gosto mostra (o que você escolheu, as referências, pra onde inclina)
+    // `primocode porta`: o /porta fora da sessão, na pasta atual — é o que o agente roda pelo run_shell (lib/porta.js)
+    if (process.argv[2] === 'porta') {
+        const r = await require('../lib/porta.js').diagnostico(path.resolve(process.argv[3] || process.cwd()));
+        for (const l of r.linhas) console.log('  ' + l);
+        process.exit(0);
+    }
+    if (process.argv[2] === 'gosto' && process.argv[3] === 'provar') {
+        const G = require('../lib/estudio/gosto.js'), P = require('../lib/estudio/gosto-prova.js');
+        const assunto = process.argv.slice(4).join(' ').trim() || 'um vídeo de apresentação';
+        for (const l of P.texto(P.provar(G.pesos(G.ler()), { assunto }), assunto)) console.log('  ' + l);
+        process.exit(0);
+    }
+    if (process.argv[2] === 'gosto' && (!process.argv[3] || process.argv[3] === 'ver')) {
+        const G = require('../lib/estudio/gosto.js');
+        const linhas = G.listar(G.ler());
+        if (!linhas.length) console.log('  Ainda não tem gosto salvo. Dentro do PrimoCode: /taste referencias recebe os vídeos que você curtiu.\n  Daqui: primocode gosto medir <vídeo ou pasta> --salvar');
+        else for (const l of linhas) console.log('  ' + l);
+        process.exit(0);
+    }
+    if (process.argv[2] === 'gosto' && process.argv[3] === 'medir') {
+        const salvar = process.argv.includes('--salvar'), json = process.argv.includes('--json');
+        const { medir, explicar, videosDe } = require('../lib/estudio/gosto-medir.js');
+        const pedidos = process.argv.slice(4).filter((x) => x !== '--salvar' && x !== '--json');
+        const arquivos = videosDe(pedidos.map((x) => path.resolve(x)));
+        if (!pedidos.length) { console.error('Uso: primocode gosto medir <vídeo ou pasta> [mais] [--salvar] [--json]'); process.exit(1); }
+        if (!arquivos.length) { console.error('Não achei vídeo (mp4, mov, m4v ou webm) nessa pasta.'); process.exit(1); }
+        if (salvar && arquivos.length > 5) console.log('  O gosto guarda até 5 vídeos: ficam os 5 últimos desta lista.\n');
+        const G = require('../lib/estudio/gosto.js');
+        let falhou = false;
+        for (const f of arquivos) {
+            const m = await medir(f);
+            if (m.ok && salvar) G.adicionarReferencia(m, { nome: path.basename(f) });
+            if (!m.ok) falhou = true;
+            if (json) console.log(JSON.stringify(m, null, 2));
+            else console.log(explicar(m, { cor: !!process.stdout.isTTY }).join('\n') + '\n');
+        }
+        if (!json) console.log(salvar ? '  Guardado no seu gosto. O próximo motion leva isso em conta (/taste mostra).' : '  Pra guardar como referência do seu gosto: --salvar');
+        process.exit(falhou ? 1 : 0);
+    }
+    // `primocode motioncraft …`: o motion com o MotionCraft + a voz do PrimoCode.
+    if (process.argv[2] === 'motioncraft') {
+        process.exit(require('../lib/motioncraft.js').main(process.argv.slice(3)));
+    }
     // `primocode mcp …`: os servidores MCP pelo run_shell (lib/mcp.js).
     if (process.argv[2] === 'videos') {
         const r = require('../lib/estudio/exportar.js').main(process.argv.slice(3));
@@ -2975,6 +3730,12 @@ async function main() {
         console.log(JSON.stringify({ ok: true, comandos: comandosDoMenu().map(([nome, descricao]) => ({ nome, descricao: ui.stripAnsi ? ui.stripAnsi(String(descricao)) : String(descricao), embutido: embutidos.has(nome) })) }));
         process.exit(0);
     }
+    // `primocode kit …`: os kits de estilo de motion (lib/kits.js). Pelo run_shell do agente ele roda dentro do processo (lib/tools.js).
+    if (process.argv[2] === 'kit' || process.argv[2] === 'kits') {
+        const r = await require('../lib/kits.js').main(process.argv.slice(3), { projectDir: process.cwd(), aoFalar: (t) => process.stderr.write(`  ⎿ ${t}\n`) });
+        console.log(r.texto);
+        process.exit(r.ok ? 0 : 1);
+    }
     if (process.argv[2] === 'skill' || process.argv[2] === 'skills') {
         process.exit(require('../lib/skills.js').main(process.argv.slice(3)));
     }
@@ -3070,7 +3831,7 @@ async function main() {
     }
     if (args[0] === '--help' || args[0] === '-h') {
         console.log(welcomeBox(VERSION, null, { mascot: state.config.mascot, userName: state.config.userName, modo: state.mode }));
-        console.log(HELP);
+        console.log(montarHelp());
         process.exit(0);
     }
 
@@ -3090,6 +3851,9 @@ async function main() {
             if (!pedido) { console.error('Uso: primocode -p "pedido" [--output-format json] [--permission-mode plan]'); process.exit(1); }
             if (typeof fl.resume === 'string') await retomarConversa(fl.resume);
             else if (continuar) await continuarUltima();
+            // O script trabalha na pasta de onde rodou, não no último projeto (sem lembrar: é só nesta execução).
+            const aqui = H.pastaDoScript({ cwd: process.cwd(), casa: os.homedir(), raiz: cfg.ROOT_DIR, app: process.env.PRIMOCODE_APP === '1' });
+            if (aqui) { state.workDir = aqui; state.currentProject = path.basename(aqui); state.workDirOrigem = 'terminal'; }
             state.semTerminal = true;
             process.env.PRIMOCODE_SEM_TELA = '1';   // modo script: nenhuma tela de gosto abre no navegador (com PRIMOCODE_APP=1 o app abre pela linha `primocode:abrir-gosto`)
             if (process.env.PRIMOCODE_LOG_FERRAMENTAS === '1') {     // o app do Primo registra cada ferramenta no log dele
@@ -3097,7 +3861,7 @@ async function main() {
             }
             let erro = null;
             const antes = state.history.length;
-            const comando = isSlash(pedido);       // `-p "/tree"`: o comando roda como no terminal (o app usa isso)
+            const comando = isSlash(pedido);       // `-p "/map tree"`: o comando roda como no terminal (o app usa isso)
             const texto = await H.capturar(async () => {
                 try { if (comando) await handleSlash(pedido); else await sendPrompt(pedido); } catch (e) { erro = e.message || String(e); }
             }, { calar: h.formato === 'json' });
@@ -3170,6 +3934,15 @@ async function main() {
     if (telaCheia && state.workDirOrigem === 'padrao') {
         console.log(c.warn(`  pasta padrão: ${shortPath(state.workDir)}`) + c.dim('  · /dir <pasta> para trabalhar numa sua'));
     }
+    /* A última conversa desta pasta, em uma linha (lib/passagem.js). Uma vez por abertura, só aqui (o -p já saiu
+       antes) e só se a pessoa não abriu já retomando (-c / --resume). */
+    if (!state.dicaRetomarMostrada && !continuar && !fl.resume && state.workDirOrigem !== 'padrao') {
+        state.dicaRetomarMostrada = true;
+        try {
+            const linha = require('../lib/passagem.js').linhaDeAbertura(fs.readFileSync(path.join(state.workDir || process.cwd(), 'memory.md'), 'utf8').slice(-20000));
+            if (linha) console.log(c.muted('  ' + linha));
+        } catch { /* a dica nunca derruba a abertura */ }
+    }
     // O spinner desenha dentro da caixa (lib/entrada.js mostrarSpinner).
     if (rl.tty) Spinner.caixa = rl;
     ui.titulo('PrimoCode');
@@ -3229,6 +4002,9 @@ async function main() {
         // solto, para não segurar o prompt. Fechar o terminal em cima dele
         // perderia justamente a resposta que a pessoa acabou de ler, e ela
         // não veria falta nenhuma até procurar no celular.
+        // O que ficou de pé em segundo plano morre junto: o filho com a saída
+        // ligada ao PrimoCode seguraria o processo vivo depois do "Até logo!".
+        require('../lib/fundo.js').pararTodas();
         const fim = () => console.log(c.muted('\nAté logo!'));
         Promise.race([
             state.gravador.esperar(),
@@ -3258,7 +4034,7 @@ async function main() {
                 if (ehBash(text)) await rodarBash(text);
                 else if (isSlash(text)) await handleSlash(text);
                 else {
-                    await sendPrompt(text);
+                    await sendPrompt(text, { digitado: true });
                 }
             } catch (e) {
                 fala.problema(e);
@@ -3357,7 +4133,11 @@ 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; })
+    }).catch((e) => {
+        // A abertura quebrou (rede, arquivo da conta). Não prende a pessoa, mas diz o que foi.
+        state.liberado = true;
+        console.log(c.muted(`  (a abertura falhou: ${e && e.message ? e.message : e}. Se algo estranhar, rode /doctor)`));
+    })
         // Depois da abertura, porque é nela que a pessoa entra na conta — e
         // sem conta não há conversa para achar.
         .then(() => (fl.resume === true ? escolherNaAbertura().catch(() => false)