primocode 11.0.0 → 11.1.0

package/lib/cli/sessao.js

@@ -0,0 +1,4152 @@
+/**
+ * PrimoCode CLI
+ *   Modos: primocode (agente completo, PADRÃO) · chat (conversa pura)
+ *   Cada sessão trabalha dentro de uma pasta de projeto em ~/primocode/.
+ */
+
+'use strict';
+
+const readline = require('readline');
+const path = require('path');
+const fs = require('fs');
+const os = require('os');
+
+const pkg = require('../../package.json');
+const ui = require('../tui/ui');
+const entrada = require('../tui/entrada');
+const { c, welcomeBox, Spinner } = ui;
+const { escolherModo } = require('../modo.js');
+const api = require('../provider/api');
+const tools = require('../tool/tools');
+const cfg = require('../config/config');
+const nomeProjeto = require('../nome-projeto');
+const { nomeCurto } = require('../nome-curto');
+const provedorLocal = require('../provider/local/provedor');
+const { runAct, interromper, ehTetoDeToken, ehTransitorio, esperaDoErro, mandarDuranteATarefa, sobrasDaCaixa } = require('../session/runner/act');
+const fala = require('../fala');
+const boasVindas = require('./boas-vindas');
+const pasta = require('../pasta');
+const outraPasta = require('../outra-pasta');
+const agentsMd = require('../agents-md');
+const catalogo = require('../skill/catalogo');
+const effort = require('../effort');
+const memoria = require('../session/memoria-conversa');
+const registro = require('../registro');
+const permissao = require('../permission/permissao');
+const perigo = require('../permission/perigo');
+const skills = require('../skill/skills');
+const checkpoint = require('../session/checkpoint');
+const comandosLib = require('./comandos');
+const nomes = require('../nomes');
+const marketplace = require('../skill/marketplace');
+const portaoSkill = require('../skill/portao-skill');
+const vozModo = require('../plugin/voz');
+const conta = require('../config/conta');
+const planosTela = require('../planos.js');
+const nuvem = require('../nuvem');
+const retomar = require('../session/retomar');
+const compat = require('../compatibilidade');
+const mencoesLib = require('../mencoes');
+const extra = require('./comandos-extra');
+const offline = require('../offline');
+const conferirLib = require('../conferir');
+
+/* O /custo: toda conversa com o modelo passa pelo lib/provider/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 /usage separa. */
+const contadorDaSessao = extra.novoContador();
+extra.instalarContador(api, contadorDaSessao, () => {
+    const p = provedorLocal.atual();
+    return p ? p.nome : 'Servidor PrimoCode';
+});
+const tempos = require('../tempos');
+
+// Rede de segurança de último recurso: sem isto, uma exceção fora de um
+// try/catch (ex.: dentro de um callback de socket, como o parser de SSE) não
+// era pega por ninguém e derrubava o processo INTEIRO em silêncio — o usuário
+// via a resposta parar no meio e cair de volta pro shell, sem mensagem
+// nenhuma. Agora vira um erro visível, e o processo continua de pé.
+process.on('uncaughtException', (e) => {
+    fala.problema(e);
+});
+/* O Node sai com 0 quando o laço de eventos esvazia — e uma promessa que
+   nunca resolve, sem timer nem socket vivo, faz exatamente isso: o pedido
+   "termina" calado no meio (visto no vídeo de escopo fechado, 01/10). Com
+   tarefa em andamento, sair assim é bug: diz, e sai com erro. */
+process.on('beforeExit', () => {
+    if (global.__primocodeTarefa) {
+        process.stderr.write(`\n  ⚠ o PrimoCode ia sair no meio da tarefa (${global.__primocodeTarefa}). Diga "continua" para retomar.\n`);
+        process.exitCode = 3;
+        global.__primocodeTarefa = null;
+    }
+});
+process.on('unhandledRejection', (e) => {
+    fala.problema(e instanceof Error ? e : new Error(String(e)));
+});
+
+// A pasta de onde o comando foi dado. Não é mais onde ele trabalha (o padrão é
+// ~/primocode), mas continua servindo de ponto de partida para achar pasta que
+// o usuário mencionar por nome relativo.
+const CWD_INICIAL = process.cwd();
+
+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
+    attachedFiles: [],
+    // O resumo incremental da conversa — um /compact automático. O porquê
+    // está em lib/session/memoria-conversa.js.
+    memoria: memoria.nova(),
+    // O histórico que o app desktop e o celular enxergam. Cifrado antes de
+    // sair daqui; o porquê de cada peça está em lib/nuvem.js.
+    gravador: nuvem.gravador({
+        // título de 2 a 5 palavras escrito pelo modelo, depois da primeira resposta (lib/session/titulo-conversa.js)
+        batizar: (pedido, resposta) => require('../session/titulo-conversa.js').escolher({ pedido, resposta, perguntar: perguntarNome }),
+    }),
+    /* Começa LIBERADO e a abertura decide depois. Começar bloqueado deixaria
+       um instante em que a pessoa digita e leva "sem acesso" antes de o
+       plano ter sido conferido — e num pipe, onde a abertura nem roda, o
+       bloqueio ficaria para sempre. */
+    liberado: true,
+    motivoBloqueio: null,
+    lastResponse: '',
+    trabalhando: false,   // o agente está no meio de um pedido (a barra muda)
+    /* A autorização para mexer no computador. Vale pela SESSÃO e morre com
+       ela: não há arquivo de "sempre permitir" de propósito — autorização
+       permanente é exatamente a que ninguém lembra de ter dado. */
+    controle: permissao.novo(),
+    currentProject: null,
+    workDir: null,     // pasta onde o agente trabalha nesta sessão
+    workDirOrigem: null, // 'padrao' | '/dir' | 'detectada' | 'projeto' | 'terminal' (o -p) — para o /dir explicar
+};
+
+/* 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.bold('Modos')}
+  ${c.warn('Primo Code')}  ${c.muted('Agente completo — cria arquivos, roda comandos, abre o navegador')}
+  ${c.brandDim('Chat')}        ${c.muted('Conversa pura — sem tools, só diálogo. Gasta bem menos token')}
+  ${c.brand('Auto')}        ${c.muted('Escolhe por pedido: conversa vai pro chat, tarefa vai pro agente')}
+
+${c.bold('Onde ele trabalha')}
+  ${c.muted('Sempre em')} ${c.warn('~/primocode')}${c.muted(', não importa de onde você abriu o PrimoCode.')}
+  ${c.muted('Para outra pasta, dois caminhos:')}
+  ${c.muted('  ·')} ${c.brand('/dir <caminho>')} ${c.muted('aponta para qualquer pasta sua')}
+  ${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 · /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)'],
+    ['/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 um arquivo ou uma página (/attach <url>) · sem nada, lista · /detach tira'],
+    ['/detach', 'remove os anexos'],
+    ['/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'],
+    ['/testar-app', 'sobe o app, abre, clica nos fluxos e conserta os erros (até 2 rodadas)'],
+    ['/pesquisar', 'relatório com fontes: /pesquisar <tema> grava em pesquisas/'],
+    ['/placar', 'qual modelo grátis acerta mais em cada tipo de tarefa, aprendido aqui · /placar zerar apaga'],
+    ['/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'],
+    ['/review', 'revisa o que mudou em duas passadas: acha e depois confere cada achado · /review rápido: uma passada só'],
+    ['/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 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)'],
+    ['/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 · /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)'],
+    ['/voice', 'liga o Primo: clique nele e fale; ele faz e responde em voz alta, com a tela dele (robô, agenda, clima, música)'],
+    ['/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 · /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'],
+    ['/offline', 'roda o servidor aqui no seu computador, com as chaves do Render'],
+    ['/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 · /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'],
+    ['/cls', 'limpa a tela'],
+    ['/uninstall', 'remove o PrimoCode'],
+    ['/version', 'versão'],
+    ['/exit', 'sair'],
+];
+
+/* /api: a chave da própria pessoa — lib/cli/comando-api.js. */
+const comandoApi = require('./comando-api.js').criar({ rl: () => rl, ask: (...a) => ask(...a), askSecret: (...a) => askSecret(...a) });
+
+// ── /effort: o slider de esforço (estilo Claude Code) ──────────────────
+// Régua com os níveis, o marcador ▲ embaixo do escolhido, "Faster" à
+// esquerda e "Smarter" à direita. ←/→ move, Enter confirma, Esc cancela.
+
+// O layout sai em texto PLANO, com as marcas de onde pintar. Assim os dois
+// pintores (o normal e o do ultracode animado) desenham exatamente a mesma
+// régua — sem duas contas de posição para manter em sincronia.
+
+// Desenha, escuta as setas, e devolve o nome escolhido (ou null se cancelou).
+function sliderEffort(atual) {
+    return new Promise((resolve) => {
+        if (!process.stdin.isTTY) {   // sem terminal (pipe, CI) não há slider
+            console.log(c.muted(`  Esforço atual: ${effort.normalizar(atual)}. Use /effort <${effort.NOMES.join('|')}>.`));
+            return resolve(null);
+        }
+        let idx = effort.indiceDe(atual);
+        const ALTURA = 9;   // linhas que o desenho ocupa — para redesenhar por cima
+        let fase = 0;
+        let anima = null;
+
+        const pintar = (primeira) => {
+            // Na tela cheia o slider desenha no painel dela, acima da caixa.
+            if (rl && rl.cheia) return rl.painel(effort.desenharEffort(idx, fase));
+            if (!primeira) process.stdout.write(`\x1b[${ALTURA}A\r`);
+            process.stdout.write(effort.desenharEffort(idx, fase).split('\n').map((l) => '\x1b[2K' + l).join('\n') + '\n');
+        };
+
+        // O fundo do ultracode ondula; sair dele apaga a animação na hora, para
+        // não redesenhar sozinho um painel que já está parado.
+        const cuidarDaAnimacao = () => {
+            const ultra = effort.NOMES[idx] === 'ultracode';
+            if (ultra && !anima) {
+                anima = setInterval(() => { fase += 0.32; pintar(false); }, 90);
+                anima.unref();
+            } else if (!ultra && anima) {
+                clearInterval(anima); anima = null;
+            }
+        };
+
+        pintar(true);
+        cuidarDaAnimacao();
+
+        const aoTeclar = (ch, key) => {
+            if (!key) return;
+            if (key.name === 'right' || key.name === 'l') { idx = Math.min(effort.NOMES.length - 1, idx + 1); cuidarDaAnimacao(); pintar(false); return; }
+            if (key.name === 'left' || key.name === 'h') { idx = Math.max(0, idx - 1); cuidarDaAnimacao(); pintar(false); return; }
+            if (key.name === 'return' || key.name === 'enter') { encerrar(effort.NOMES[idx]); return; }
+            if (key.name === 'escape' || (key.ctrl && key.name === 'c')) { encerrar(null); return; }
+        };
+        const encerrar = (valor) => {
+            if (anima) { clearInterval(anima); anima = null; }
+            process.stdin.removeListener('keypress', aoTeclar);
+            sliderAtivo = false;
+            if (rl && rl.retomar) rl.retomar();
+            resolve(valor);
+        };
+        sliderAtivo = true;
+        // A caixa sai da frente e larga o teclado: dois desenhos no mesmo
+        // lugar, e as setas moveriam os dois ao mesmo tempo.
+        if (rl && rl.suspender) rl.suspender();
+        process.stdin.on('keypress', aoTeclar);
+    });
+}
+
+function aplicarEffort(nome) {
+    const nivel = effort.nivelDe(nome);
+    state.config.effort = nivel.nome;
+    state.config.model = nivel.model;
+    cfg.saveConfig({ effort: nivel.nome, model: nivel.model });
+    console.log(c.ok(`Esforço: ${nivel.nome}`) + c.muted(`  ${nivel.resumo}`));
+    if (nivel.pesquisa) console.log(c.dim('  Pesquisa de referência ligada: ele consulta docs e exemplos antes de escrever.'));
+    refreshPrompt();
+}
+
+// Enquanto o slider está no ar, o fantasma do autocompletar não desenha.
+let sliderAtivo = false;
+
+/* Os comandos da pessoa (lib/cli/comandos.js), com o do projeto atual por cima.
+   A caixa de digitar pede a lista a cada tecla para desenhar o fantasma; um
+   cache de dois segundos poupa ler três pastas por letra digitada, e ainda
+   pega na hora um arquivo que a pessoa acabou de salvar. */
+let cacheComandos = { em: 0, dir: null, lista: [] };
+function comandosDaPessoa() {
+    const agora = Date.now();
+    if (agora - cacheComandos.em > 2000 || cacheComandos.dir !== state.workDir) {
+        let lista = [];
+        try { lista = comandosLib.carregar({ projectDir: state.workDir }); } catch { /* disco estranho não trava a caixa */ }
+        cacheComandos = { em: agora, dir: state.workDir, lista };
+    }
+    return cacheComandos.lista;
+}
+
+/* O menu e o fantasma enxergam os dois tipos. O embutido vem primeiro e,
+   com o mesmo nome, o da pessoa nem aparece: quem ganha é sempre o embutido. */
+function comandosDoMenu() {
+    const embutidos = new Set(SLASH_COMANDOS.map(([n]) => n));
+    const deles = comandosDaPessoa()
+        .filter((x) => !embutidos.has('/' + x.nome))
+        .map((x) => ['/' + x.nome, x.descricao || `seu comando (${x.origem})`]);
+    return SLASH_COMANDOS.concat(deles);
+}
+
+function mostrarMenuSlash() {
+    // "/" sozinho mostra as 9 intenções, não a lista seca; o /help tem tudo, com descrição.
+    console.log('');
+    for (const g of nomes.agrupados()) {
+        console.log(`  ${c.bold(ui.padRight(g.titulo, 19))}${c.brand(g.comandos.map((n) => '/' + n).join('  '))}`);
+    }
+    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;
+
+/* ── A BARRA DE STATUS ───────────────────────────────────────────────────
+ * As duas linhas embaixo da caixa de digitar. Elas existem para responder,
+ * sem a pessoa perguntar, as coisas que ela erra quando não sabe:
+ *
+ *   · EM QUE PASTA ele está mexendo — de longe o que mais confunde, porque
+ *     o PrimoCode NÃO trabalha na pasta de onde você o abriu;
+ *   · em que ramo do git, quando a pasta é um repositório: um agente que
+ *     escreve arquivo no `main` sem ninguém perceber é o pior tipo de
+ *     surpresa;
+ *   · quanto da conversa já foi gasto, para o /compact chegar antes do teto;
+ *   · qual o modo e qual o esforço, que mudam o que ele pode fazer.
+ *
+ * A segunda linha é a dos atalhos. Ela repete o que existe porque atalho que
+ * a pessoa não vê é atalho que não existe.
+ */
+
+// `git rev-parse` a cada quadro seria um processo por tecla digitada. O ramo
+// muda devagar; cinco segundos de atraso não confundem ninguém.
+const ramoCache = new Map();
+function ramoDoGit(dir) {
+    if (!dir) return '';
+    const guardado = ramoCache.get(dir);
+    if (guardado && Date.now() - guardado.quando < 5000) return guardado.ramo;
+    let ramo = '';
+    try {
+        ramo = require('child_process').execSync('git rev-parse --abbrev-ref HEAD', {
+            cwd: dir, stdio: ['ignore', 'pipe', 'ignore'], timeout: 1500,
+        }).toString().trim();
+    } catch { ramo = ''; }
+    ramoCache.set(dir, { quando: Date.now(), ramo });
+    return ramo;
+}
+
+/* O que a caixa mostra além do texto, no desenho do OpenCode: DENTRO do
+   painel, o modo e o esforço ("Auto · alto" — o "Build · Nemotron" de lá);
+   FORA, uma linha só, com a pasta e o ramo à esquerda e o contexto e os
+   atalhos à direita. A cor da barra do painel é a do modo. */
+const COR_MODO = { auto: '\x1b[38;5;75m', primocode: '\x1b[38;5;216m', chat: '\x1b[38;5;45m' };
+const NOME_MODO = { auto: 'Auto', primocode: 'Primo Code', chat: 'Chat' };
+
+function barraDeStatus() {
+    const partes = [];
+
+    // A PASTA, e o ramo do git colado nela ("~/primocode/loja:main"), como
+    // o rodapé do OpenCode. Quem apontou com /dir para fora do ~/primocode
+    // precisa ver onde está.
+    const dir = state.workDir || process.cwd();
+    partes.push(c.brandDim(shortPath(dir)));
+    const ramo = ramoDoGit(dir);
+    if (ramo) partes.push(c.dim('⎇ ' + ramo));
+
+    if (state.attachedFiles.length) {
+        partes.push(c.muted(`+${state.attachedFiles.length} anexo${state.attachedFiles.length > 1 ? 's' : ''}`));
+    }
+
+    /* Enquanto o controle do computador está liberado, isso fica escrito na
+       barra. Uma autorização que some da vista é uma autorização que a pessoa
+       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('../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
+       vermelho a partir de 100%, que é quando `/compact` deixa de ser
+       conselho e vira o que fazer. */
+    const direita = [];
+    const uso = memoria.usoDoContexto(state.memoria, state.history);
+    // Modelo que respondeu · contexto · tokens de hoje (os mesmos do /usage) — lib/cli/statusline.js.
+    const SL = require('./statusline.js');
+    direita.push(...SL.partes({ modelo: SL.modelo(), ctxPct: uso.pct, tokensHoje: SL.tokensDeHoje(), c }));
+    direita.push(state.trabalhando && rl && rl.ocupado
+        ? c.warn('trabalhando') + c.dim(' · ') + c.white('esc esc') + c.dim(' para')
+        : c.white('tab') + c.dim(' modos  ') + c.white('ctrl+p') + c.dim(' comandos'));
+
+    /* O modo DENTRO do painel. No auto, depois do primeiro pedido, ele diz
+       qual modo acabou respondendo — senão você nunca sabe quem respondeu. */
+    const cor = COR_MODO[state.mode] || COR_MODO.auto;
+    let modo = `${cor}${NOME_MODO[state.mode] || 'Auto'}${c.reset}`;
+    if (state.mode === 'auto' && state.modoEfetivo) {
+        modo += c.dim(' → ') + c.muted(NOME_MODO[state.modoEfetivo] || state.modoEfetivo);
+    }
+    modo += c.dim(' · ') + c.white(effort.normalizar(state.config.effort)) + ' ' + c.dim('PrimoCode');
+
+    return { modo, cor, esquerda: partes.join(c.dim(' · ')), direita: direita.join(c.dim('   ')) };
+}
+
+/* A barra da direita da tela cheia, como a do OpenCode: o contexto (quantos
+   tokens a conversa já ocupa e quanto isso é do teto), o modo e o esforço, e
+   no pé a pasta com o ramo e a versão. */
+function barraLateral() {
+    const uso = memoria.usoDoContexto(state.memoria, state.history);
+    const dir = state.workDir || process.cwd();
+    const ramo = ramoDoGit(dir);
+    const m = state.mode === 'auto' && state.modoEfetivo ? state.modoEfetivo : state.mode;
+    const secoes = [
+        { titulo: 'Contexto', linhas: [
+            c.muted(`${uso.tokens.toLocaleString('pt-BR')} tokens`),
+            (uso.pct >= 100 ? c.err : uso.pct >= 70 ? c.warn : c.muted)(`${uso.pct}% usado`),
+        ] },
+        { titulo: 'Modo', linhas: [
+            `${COR_MODO[m] || COR_MODO.auto}${NOME_MODO[m] || m}${c.reset}` + c.muted(` · esforço ${effort.normalizar(state.config.effort)}`),
+        ] },
+    ];
+    if (state.attachedFiles.length) {
+        secoes.push({ titulo: 'Anexos', linhas: state.attachedFiles.map((f) => c.muted(path.basename(f.path))) });
+    }
+    if (state.controle && state.controle.liberado) secoes.push({ titulo: 'Controle do PC', linhas: [c.warn('liberado até fechar')] });
+    return {
+        secoes,
+        rodape: [
+            c.muted(shortPath(dir)) + (ramo ? c.white(':' + ramo) : ''),
+            c.brand('●') + ' ' + c.bold(c.white('Primo')) + c.white('Code') + ' ' + c.dim(VERSION),
+        ],
+    };
+}
+
+/* O Tab com a caixa vazia gira o modo, como o "tab agents" do OpenCode:
+   auto → primo code → chat → auto. A escolha fica salva, como a do /mode. */
+function trocarModo() {
+    const ordem = ['auto', 'primocode', 'chat'];
+    const m = ordem[(ordem.indexOf(state.mode) + 1) % ordem.length];
+    state.mode = m;
+    state.modoEfetivo = null;
+    cfg.saveConfig({ mode: m });
+    refreshPrompt();
+}
+
+// A barra se redesenha sozinha a cada quadro; isto só pede um quadro novo.
+function refreshPrompt() { if (rl) rl.prompt(); }
+
+// Enquanto uma pergunta está no ar, a próxima linha digitada é a RESPOSTA dela
+// — não um novo comando. Sem isso o "s" de confirmação virava prompt para a IA.
+let pendingAsk = null;
+
+/* ── O QUE A PESSOA ADIANTA ──────────────────────────────────────────────
+ * Enquanto a abertura corre — e ela demora, porque confere o plano no
+ * servidor — o que for digitado não é comando nem resposta ainda: a pergunta
+ * ainda não apareceu. Fica aqui.
+ *
+ * Sem isto, esse texto caía como PEDIDO no agente. Medido no pacote
+ * publicado: o "2" da escolha da IA virou pergunta no chat e o modelo
+ * respondeu "Oi! Como posso ajudar?".
+ *
+ * E guardar não bastava: preso na fila de comandos, ele nunca chegava à
+ * pergunta que veio depois. Por isso o `ask` olha aqui ANTES de esperar uma
+ * linha nova — quem digitou 2 antes de ver o menu escolheu a 2, e a escolha
+ * dela vale.
+ */
+let segurando = false;
+const adiantadas = [];
+
+function ask(question) {
+    return new Promise((resolve) => {
+        if (rl) {
+            process.stdout.write(question);
+            if (adiantadas.length) { const a = adiantadas.shift(); process.stdout.write(a + '\n'); return resolve(a); }
+            pendingAsk = resolve;
+            return;
+        }
+        const tmp = readline.createInterface({ input: process.stdin, output: process.stdout });
+        tmp.question(question, (a) => { tmp.close(); resolve(a); });
+    });
+}
+
+/**
+ * Pergunta sem mostrar o que se digita — para a senha do /login.
+ *
+ * Com a caixa de digitar no ar, ela mesma oculta a próxima linha (ver
+ * `ocultarProxima` em lib/tui/entrada.js). Sem a caixa, o readline ecoa cada
+ * tecla pelo `_writeToOutput`; enquanto a pergunta está aberta, só a quebra
+ * de linha passa. Nos dois casos a resposta fica fora do histórico: senão a
+ * seta para cima devolveria a senha na tela.
+ */
+function askSecret(question) {
+    if (!process.stdin.isTTY) return ask(question);
+    if (rl && typeof rl.ocultarProxima === 'function') {
+        return new Promise((resolve) => {
+            process.stdout.write(question);
+            rl.ocultarProxima();
+            pendingAsk = resolve;
+        });
+    }
+    return new Promise((resolve) => {
+        const alvo = rl || readline.createInterface({ input: process.stdin, output: process.stdout });
+        const original = alvo._writeToOutput;
+        process.stdout.write(question);
+        alvo._writeToOutput = function (texto) {
+            if (/[\r\n]/.test(texto)) original.call(alvo, '\n');
+        };
+        const fim = (resposta) => {
+            alvo._writeToOutput = original;
+            if (Array.isArray(alvo.history) && alvo.history[0] === resposta) alvo.history.shift();
+            if (!rl) alvo.close();
+            resolve(resposta);
+        };
+        if (rl) pendingAsk = fim;
+        else alvo.question('', fim);
+    });
+}
+
+async function confirm(question) {
+    const raw = await ask(`${c.brand('?')} ${question} ${c.muted('(S/n)')} `);
+    if (!process.stdin.isTTY) process.stdout.write('\n'); // pipe não ecoa o Enter
+    const a = raw.trim().toLowerCase();
+    return a === '' || a === 's' || a === 'sim' || a === 'y' || a === 'yes';
+}
+
+// ── Projetos ───────────────────────────────────────────────────────────
+
+/* ── O NOME DO PROJETO ───────────────────────────────────────────────────
+ * O nome saía das cinco primeiras palavras depois de "crie um": "agora deixa o
+ * carro mais rápido" virava a pasta `agora-deixa-o-carro-mais`, e "oi primo,
+ * faz um site" virava `oi-primo-faz-um-site`. Agora o começo da frase
+ * (saudação, o nome dele, verbo de pedido, artigo) é pulado, o assunto vai até
+ * a primeira palavra que emenda outra ideia ("com", "que", "usando"…), e
+ * sobram até quatro palavras que dizem O QUE é: "jogo de carro", "site
+ * padaria", "loja roupas". */
+const ABERTURA = new Set([
+    'oi', 'ola', 'ei', 'hey', 'e', 'ai', 'primo', 'bom', 'boa', 'dia', 'tarde', 'noite', 'ok', 'beleza',
+    'entao', 'agora', 'tipo', 'por', 'favor', 'pfv', 'pf', 'voce', 'vc', 'pode', 'poderia', 'consegue',
+    'crie', 'cria', 'criar', 'faca', 'faz', 'fazer', 'monte', 'monta', 'montar', 'desenvolva', 'desenvolver',
+    'construa', 'construir', 'gere', 'gera', 'gerar', 'programe', 'programa', 'escreva', 'escreve',
+    'quero', 'queria', 'gostaria', 'preciso', 'precisamos', 'vamos', 'bora', 'me', 'pra', 'para', 'mim',
+    'um', 'uma', 'uns', 'umas', 'o', 'a', 'os', 'as', 'de', 'novo', 'nova', 'outro', 'outra', 'projeto',
+    'simples', 'pequeno', 'pequena', 'rapido', 'bonito', 'bonita',
+    // os verbos de CONTINUAR: sem eles, "agora deixa o carro…" virava nome
+    'deixa', 'deixe', 'continua', 'continue', 'edita', 'edite', 'muda', 'mude', 'melhora', 'melhore',
+    'adiciona', 'adicione', 'coloca', 'coloque', 'poe', 'bota', 'corrige', 'corrija', 'arruma', 'arrume',
+    'ajusta', 'ajuste', 'abre', 'abra', 'termina', 'termine',
+]);
+const EMENDA = new Set(['com', 'que', 'usando', 'onde', 'mas', 'porque', 'igual', 'como', 'sobre',
+    'em', 'no', 'na', 'nos', 'nas', 'e', 'tipo', 'estilo', 'feito', 'utilizando', 'mais', 'menos']);
+// Palavras que não dizem o que a coisa É — saem de qualquer posição.
+const DE_ENCHER = new Set(['minha', 'meu', 'minhas', 'meus', 'nossa', 'nosso', 'para', 'pra', 'uma', 'um',
+    'simples', 'bonito', 'bonita', 'pequeno', 'pequena', 'legal', 'rapido', 'rapida', 'basico', 'basica',
+    'completo', 'completa', 'novo', 'nova']);
+
+function semAcento(x) { return String(x || '').normalize('NFD').replace(/[̀-ͯ]/g, '').toLowerCase(); }
+
+function deriveProjectName(text) {
+    const palavras = String(text || '').split(/\s+/)
+        .map((w) => w.replace(/[^\wáéíóúâêôãõçÁÉÍÓÚÂÊÔÃÕÇ-]/gi, ''))
+        .filter(Boolean);
+    let i = 0;
+    while (i < palavras.length && ABERTURA.has(semAcento(palavras[i]))) i++;
+    const assunto = [];
+    for (; i < palavras.length && assunto.length < 6; i++) {
+        const w = semAcento(palavras[i]);
+        if (assunto.length && EMENDA.has(w)) break;
+        if (DE_ENCHER.has(w)) continue;
+        assunto.push(palavras[i]);
+    }
+    while (assunto.length && /^(de|do|da|dos|das)$/i.test(semAcento(assunto[assunto.length - 1]))) assunto.pop();
+    const nome = assunto.slice(0, 4).join(' ').trim();
+    return nome || 'projeto';
+}
+
+/* ── "CRIE UM…" DENTRO DE UM PROJETO ────────────────────────────────────
+ * Depois de entrar num projeto, TUDO ia para ele — até "crie um site de
+ * receitas" no meio do jogo de carro. E fora dele, qualquer "continua" virava
+ * projeto novo. A regra agora: dentro de um projeto, só um pedido que CLARAMENTE
+ * abre outra coisa sai dele — verbo de criar + "um/uma/outro/novo", assunto
+ * que não tem nada a ver com o projeto atual, e nenhuma referência a ele
+ * ("isso", "esse", "nele"). Todo o resto ("continua", "muda a cor", "agora
+ * põe fases") fica. */
+const RE_PROJETO_NOVO = /\b(novo projeto|projeto novo|outro projeto|do zero|come[cç]a(r)? (um|uma|outro|outra))\b/;
+/* "crie UM site…" e também "crie O SITE da barbearia": o artigo definido com
+   o tipo da coisa é projeto novo com nome (medido em 29/09: "crie o site
+   bench-barbearia" nasceu DENTRO do projeto que estava aberto). Se for o
+   mesmo assunto do projeto atual, a comparação de assunto em pedeProjetoNovo
+   segura como continuação. */
+const RE_CRIAR_UM = /\b(crie|cria|criar|fa[cç]a|faz|fazer|monte|monta|montar|gere|gera|desenvolva|construa|programe|quero|preciso de)\s+(um|uma|outro|outra|novo|nova|(o|a)\s+(site|app|aplicativo|jogo|projeto|landing|pagina|sistema|loja|dashboard|painel))\b/;
+const RE_REFERE_ATUAL = /\b(isso|isto|esse|essa|este|esta|nele|nela|dele|dela|no projeto|nesse|nessa|neste|nesta|continua|continue|edita|edite|muda|mude|melhora|melhore|adiciona|adicione|coloca|coloque|p[oõ]e|corrige|corrija|arruma|arrume|ajusta|ajuste)\b/;
+
+/* "crie uma nova seção", "cria um botão", "faz uma tela de login": é um
+   PEDAÇO do projeto em que se está, não outro projeto. */
+const RE_PEDACO = /\b(um|uma|outro|outra|novo|nova)\s+(nov[ao]\s+)?(secao|secoes|parte|botao|botoes|tela|aba|menu|rodape|cabecalho|formulario|fase|funcao|funcionalidade|campo|imagem|animacao|efeito|cor|fonte|pagina interna|area|bloco|card|modal|link)\b/;
+
+function pedeProjetoNovo(texto) {
+    const t = semAcento(texto);
+    if (RE_PROJETO_NOVO.test(t)) return true;
+    if (!RE_CRIAR_UM.test(t) || RE_REFERE_ATUAL.test(t) || RE_PEDACO.test(t)) return false;
+    // Mesmo assunto do projeto atual ("crie uma fase nova pro jogo de carro")
+    // é continuação, não projeto novo.
+    const atual = new Set(cfg.tokensDoAssunto(state.currentProject || ''));
+    const pedido = cfg.tokensDoAssunto(deriveProjectName(texto));
+    return !pedido.some((x) => atual.has(x));
+}
+
+/* Pedido de mexer no computador da pessoa (abrir app, clicar, digitar,
+   mostrar o cursor). Serve só para mandar a dica das ferramentas desktop_*. */
+const RE_COMPUTADOR = /\b(abr[ae]|abrir|clica|clique|clicar|digita|digite|digitar|mouse|cursor|teclado|meu computador|no (meu )?mac|na (minha )?tela|aplicativo|spotify|safari|finder|whatsapp|mensagens|m[úu]sica|configura[çc][õo]es|ajustes)\b/i;
+function querComputador(texto) { return RE_COMPUTADOR.test(String(texto || '')); }
+
+/* Pedido de VER o navegador ("abre o youtube", "entra no site x", "testa no
+   Chrome"). Sem isto as ferramentas browser_* rodam escondidas: pesquisar e
+   conferir não precisam abrir aba na tela da pessoa (02/10). */
+const RE_NAVEGADOR = /\b(navegador|chrome|browser|edge|brave|aba|abas|youtube|gmail|instagram|facebook|linkedin|login|loga|logar|(abr[ae]|abrir|entr[ae]|entrar|acess[ae]|acessar|mostr[ae]|testa|testar)\b[^.?!]{0,25}\b(site|p[áa]gina|link|url|google|navegador))\b/i;
+function querNavegador(texto) { return RE_NAVEGADOR.test(String(texto || '')); }
+
+/* Guarda onde se está, para a próxima sessão continuar aqui. */
+function entrarNoProjeto(dir, origem = 'projeto') {
+    state.workDir = dir;
+    state.currentProject = path.basename(dir);
+    state.workDirOrigem = origem;
+    cfg.lembrarProjeto(dir, origem);
+}
+
+// Pasta em que é seguro deixar um agente criar e editar arquivo. A home e a raiz
+// do disco não contam — ninguém quer um agente soltando arquivo no meio de
+// C:\Users\você. O ~/primocode ERA recusado aqui, de quando a pasta atual do
+// terminal era adotada; hoje ele é o padrão, então recusá-lo não faz sentido.
+function pastaSegura(dir) {
+    const home = os.homedir();
+    const resolved = path.resolve(dir);
+    if (resolved === path.resolve(home)) return false;
+    if (resolved === path.parse(resolved).root) return false;
+    return true;
+}
+
+// Escolhe onde trabalhar SEM criar nada.
+//
+// Três casos, nesta ordem:
+//   1. pasta escolhida a dedo (/dir, ou detectada no pedido) — manda, sempre.
+//   2. projeto que JÁ existe e parece com o pedido — entra nele agora, senão a
+//      memory.md dele não carrega neste turno.
+//   3. projeto novo — fica PENDENTE: age em ~/primocode e só cria a pasta se o
+//      agente for mexer em arquivo. Pedir para abrir o Chrome não cria projeto.
+// Pedido que se resolve DENTRO do estúdio: vídeo, slides, arte, documento,
+// planilha, diagrama. O que sai dali já é guardado pelo próprio estúdio, em
+// ~/.primocode/studio/arquivos — não precisa (e não deve) virar pasta de
+// código em ~/primocode, cheia de memory.md sobre um vídeo.
+const PEDIDO_DE_ESTUDIO = /\b(v[íi]deo|reels?|anima[çc][ãa]o|slides?|apresenta[çc][ãa]o|deck|post|banner|capa|thumbnail|arte|cartaz|planilha|documento|relat[óo]rio|diagrama|fluxograma|narra[çc][ãa]o|est[úu]dio)\b/i;
+// ...a menos que ele também peça código ou página: aí é projeto de verdade.
+const PEDIDO_DE_CODIGO = /\b(html|css|javascript|js|react|next|python|api|site|p[áa]gina|app|aplicativo|script|reposit[óo]rio|c[óo]digo|programa|servidor|banco de dados)\b/i;
+
+function ehSoEstudio(texto) {
+    const t = String(texto || '');
+    return PEDIDO_DE_ESTUDIO.test(t) && !PEDIDO_DE_CODIGO.test(t);
+}
+
+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', '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))) {
+        return { dir: state.workDir, pending: false, name: state.currentProject };
+    }
+    // "Quando eu peço um vídeo, não é pra ficar com projeto. Só vai criar
+    // projeto quando tiver um HTML, quando tiver um código."
+    if (ehSoEstudio(userText)) {
+        return { dir: cfg.ROOT_DIR, pending: false, name: state.currentProject, estudio: true };
+    }
+    const proposto = deriveProjectName(userText);
+    const parecido = cfg.findSimilarProject(proposto);
+    if (parecido) return { dir: parecido.dir, pending: false, name: parecido.name, similar: true };
+    return { dir: cfg.ROOT_DIR, projeto: cfg.getProjectDir(proposto), pending: true, name: proposto };
+}
+
+/* O nome da pasta nova vem do modelo (lib/nome-projeto.js), pedido em
+   paralelo com o trabalho: a pasta só nasce na primeira escrita, e até lá a
+   resposta já chegou. Só pergunta quando o pedido é de CRIAR algo — pedir
+   para abrir o Chrome não gasta chamada com nome de pasta. */
+async function perguntarNome(texto) {
+    let resposta = '';
+    await api.requestChat(state.config.server, {
+        prompt: texto, history: [], model: state.config.model, token: state.config.token,
+    }, (evt) => { if (evt.delta) resposta += evt.delta; });
+    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 })
+        .then((nome) => { if (nome) plan.nomeEscolhido = nome; });
+}
+
+function createPendingProject(plan) {
+    const dir = cfg.createProjectDir(plan.nomeEscolhido || plan.name);
+    entrarNoProjeto(dir, 'projeto');
+    const rotulo = plan.similar ? 'Continuando em' : 'Projeto novo:';
+    console.log(c.ok(`  ${rotulo} ${state.currentProject}`) + c.muted(`  (${dir})`));
+    refreshPrompt();
+    return dir;
+}
+
+function projectDir() {
+    return state.workDir || process.cwd();
+}
+
+// ── Envio ──────────────────────────────────────────────────────────────
+
+/**
+ * Falou de OUTRA pasta? Ele LÊ lá sem pedir, e só TROCA com o seu sim.
+ *
+ * "Quando eu perguntar de algo de outra pasta, ela vai procurar lá; e se ela
+ * está aberta numa pasta e eu trabalho em outra, ela muda — com permissão."
+ * A pasta citada (caminho, "pasta X", ou o nome de um projeto/pasta recente)
+ * fica liberada para leitura (lib/tool/tools.js). A troca pergunta, Enter é NÃO.
+ *
+ * Devolve a nota para o modelo quando a pessoa ficou onde estava — é ela que
+ * diz ao agente que pode procurar lá. Com mais de uma pasta do mesmo nome,
+ * lista e espera o /dir: heurística não escolhe onde o agente escreve.
+ */
+async function talvezTrocarDePasta(userText) {
+    const r = outraPasta.detectar(userText, {
+        conhecidas: outraPasta.conhecidas({ raiz: cfg.ROOT_DIR, recentes: cfg.pastasRecentes() }),
+        atual: projectDir(),
+        resolver: (cand) => pasta.resolverPasta(cand, { raiz: cfg.ROOT_DIR, cwd: CWD_INICIAL }),
+    });
+    if (r.ambiguo) {
+        console.log(c.warn(`  Achei ${r.ambiguo.length} pastas chamadas "${r.candidato}":`));
+        r.ambiguo.forEach((a) => console.log(`   ${c.dim('·')} ${c.white(shortPath(a.caminho))}`));
+        console.log(c.dim('  Escolha com /dir <caminho>.'));
+        return '';
+    }
+    const alvo = (r.pastas || []).find((p) => pastaSegura(p.caminho));
+    if (!alvo) return '';   // home ou raiz: só por /dir explícito
+
+    /* Ler lá só se libera DEPOIS do sim (a troca): recusa não destrava nada. */
+
+    /* No pedido único (`primocode "crie x na pasta loja"`) não há a quem
+       perguntar — e a pasta veio escrita no próprio comando, com marca
+       ("pasta", caminho). Aí vale o que ele sempre fez: troca. Nome solto
+       ("olha o landing-padaria") nunca troca sem pergunta. */
+    if (state.semTerminal) {
+        if (alvo.como !== 'caminho') return '';
+        entrarNoProjeto(alvo.caminho, 'detectada');
+        return '';
+    }
+    console.log(c.dim(`  ⎿ você citou ${shortPath(alvo.caminho)}`));
+    if (!(await perguntarTroca(alvo.caminho))) return '';
+    trocarPara(alvo.caminho, 'detectada', `você falou "${alvo.nome}"`);
+    return '';
+}
+
+/* A pergunta da troca. Enter sozinho é NÃO: trocar muda onde os arquivos
+   nascem, e o padrão de quem apertou Enter sem ler não pode ser esse. */
+async function perguntarTroca(caminho, motivo = '') {
+    if (motivo) console.log('  ' + c.muted(motivo));
+    const dito = String(await ask(`${c.brand('?')} Trabalhar em ${c.white(shortPath(caminho))} a partir de agora? ${c.muted('(s/N)')} `))
+        .trim().toLowerCase().replace(/[.!?,;:…]+/g, ' ').trim();
+    if (!process.stdin.isTTY) process.stdout.write('\n');
+    return /^(s|sim|y|yes|pode|ok|claro|muda|troca)\b/.test(dito);
+}
+
+/* Entra na pasta e avisa. A memória dela (AGENTS.md) entra no próximo
+   pedido pelo buildMemoryContext, porque ainda não está no resumo. */
+function trocarPara(caminho, origem, porque) {
+    entrarNoProjeto(caminho, origem);
+    const tem = agentsMd.ler(caminho) ? ' · com memória das sessões anteriores' : '';
+    console.log(c.ok(`  Trabalhando em ${shortPath(caminho)}`) + c.dim(`  (${porque}${tem})`));
+    refreshPrompt();
+}
+
+/* Servidor MCP do .mcp.json do PROJETO: roda comando na máquina, então pergunta
+   mesmo no auto (lib/mcp/mcp.js lembra o sim por projeto + configuração). */
+require('../mcp/mcp.js').usarPerguntador(async ({ nome, resumo }) => {
+    if (state.semTerminal) return false;
+    console.log('');
+    console.log('  ' + c.warn('▸▸') + ' ' + c.bold(c.white(`O .mcp.json deste projeto quer rodar o servidor "${nome}".`)));
+    console.log('  ' + c.dim(resumo.slice(0, 200)));
+    const dito = String(await ask(`${c.brand('?')} Deixar rodar? ${c.muted('(s/N)')} `)).trim().toLowerCase();
+    if (!process.stdin.isTTY) process.stdout.write('\n');
+    return /^(s|sim|y|yes)\b/.test(dito);
+});
+
+/* O mudar_pasta do modelo chega aqui (lib/outra-pasta.js → pedirTroca). */
+async function mudarPastaPeloAgente({ caminho, motivo }) {
+    if (state.semTerminal) return { ok: false, error: 'sem terminal para o usuário responder.' };
+    console.log('');
+    console.log('  ' + c.warn('▸▸') + ' ' + c.bold(c.white('O Primo quer trabalhar em outra pasta.')));
+    if (!(await perguntarTroca(caminho, motivo ? `Motivo: ${motivo}` : ''))) {
+        console.log('  ' + c.muted('Fica onde está.'));
+        return { ok: false };
+    }
+    trocarPara(caminho, 'detectada', 'você autorizou');
+    return { ok: true, caminho, memoria: agentsMd.ler(caminho) || undefined };
+}
+
+/**
+ * Decide, de uma vez, onde este pedido vai trabalhar.
+ *
+ * ESTA É A ÚNICA função que decide pasta. Existiam duas cópias — uma no
+ * sendPrompt e outra no modo um-tiro — e a do um-tiro ficou sem a detecção: pedir
+ * `primocode "crie x na pasta loja"` ignorava a pasta e criava projeto novo.
+ * Duas cópias da mesma decisão significam que uma delas está errada.
+ */
+async function prepararPasta(userText) {
+    // A pasta é decidida ANTES de o agente começar. Trocar no meio faria as
+    // primeiras tools agirem num lugar e as seguintes em outro.
+    const notaOutraPasta = await talvezTrocarDePasta(userText);
+
+    const plan = planWorkDir(userText);
+    batizarDepois(plan, userText);
+
+    // Projeto que já existe: entra nele AGORA. Se deixasse para depois, o
+    // buildMemoryContext deste turno leria a pasta errada e a memória do projeto
+    // não carregaria.
+    if (!plan.pending && path.resolve(plan.dir) !== path.resolve(projectDir())) {
+        entrarNoProjeto(plan.dir, 'projeto');
+        console.log(c.ok(`  Continuando em ${state.currentProject}`) + c.muted(`  (${shortPath(plan.dir)})`));
+        refreshPrompt();
+    }
+    plan.notaOutraPasta = notaOutraPasta;
+    return plan;
+}
+
+/* ── O PEDIDO PARA MEXER NO COMPUTADOR ───────────────────────────────────
+ * Três respostas: agora, a sessão inteira, não.
+ *
+ * A do meio existe porque uma tarefa de desktop são dez, vinte ações. Pedir a
+ * cada clique transforma a permissão num botão que se aperta sem ler — o
+ * mesmo que não pedir, com uma etapa a mais. Uma vez, com o que ele vai fazer
+ * escrito, é a pergunta que ainda é lida.
+ *
+ * Enter sozinho é NÃO. O padrão de quem apertou Enter sem ler não pode ser
+ * entregar o mouse e o teclado.
+ */
+async function autorizarControle(oQueVaiFazer, { primeira, tipo } = {}) {
+    /* O mesmo portão serve ao /permissoes (lib/permission/perigo.js): a pergunta muda de
+       cabeçalho, as três respostas são as mesmas. */
+    if (tipo) {
+        console.log('');
+        console.log('  ' + c.warn('▸▸') + ' ' + c.bold(c.white(tipo === 'perigo'
+            ? 'Isto não tem volta. O Primo quer:'
+            : 'O Primo quer (você escolheu /perms perguntar):')));
+    } else if (primeira) {
+        console.log('');
+        console.log('  ' + c.warn('▸▸') + ' ' + c.bold(c.white('O Primo quer usar o seu computador.')));
+        console.log('  ' + c.muted('Ele vai mexer no mouse e no teclado de verdade, no programa que'));
+        console.log('  ' + c.muted('estiver na frente. Você vê cada passo aqui enquanto acontece.'));
+    }
+    console.log('');
+    console.log('  ' + c.brand('●') + ' ' + c.white(oQueVaiFazer));
+    console.log('  ' + c.dim('1') + c.muted(' agora  ')
+        + c.dim('2') + c.muted(' esta sessão inteira  ')
+        + c.dim('Enter') + c.muted(' não'));
+
+    // Sem pontuação: a resposta pode vir FALADA (/voice), e o Whisper devolve
+    // "Sim." e "Pode, sim." — que também são sim.
+    const dito = String(await ask('  ' + c.brand('❯ ') + c.muted('1, 2 ou Enter '))).trim().toLowerCase()
+        .replace(/[.!?,;:…]+/g, ' ').replace(/\s+/g, ' ').trim();
+    if (/sess|sempre|tudo|todas/.test(dito) && dito !== '1') {
+        console.log('  ' + c.ok('✔ autorizado') + c.dim(' — esta sessão inteira. Fechar o PrimoCode esquece.'));
+        return 'sessao';
+    }
+    if (dito === '1' || /^(s|sim|ok|pode|agora|y|yes|claro|vai)\b/.test(dito)) {
+        console.log('  ' + c.ok('✔ autorizado') + c.dim(' — só esta ação'));
+        return 'agora';
+    }
+    if (dito === '2' || /sess|sempre|tudo|todas/.test(dito)) {
+        console.log('  ' + c.ok('✔ autorizado') + c.dim(' — esta sessão inteira. Fechar o PrimoCode esquece.'));
+        return 'sessao';
+    }
+    console.log('  ' + c.muted('Não autorizado.') + c.dim(' Ele vai resolver por outro caminho.'));
+    return 'nao';
+}
+
+/* ── A TELA DO MARKETPLACE ───────────────────────────────────────────────
+ * O desenho e as teclas vivem em lib/skill/marketplace.js, que é função pura. O que
+ * mora aqui é o que precisa do terminal: tirar a caixa de digitar da frente,
+ * escutar as setas, e fazer o que a tela pediu (ligar uma skill, abrir o
+ * diálogo de criar).
+ *
+ * A divisão é a mesma do /effort, e pelo mesmo motivo: dois desenhos no mesmo
+ * lugar brigam pelo teclado e pelo cursor.
+ */
+function abrirMarketplace() {
+    return new Promise((resolve) => {
+        if (!process.stdin.isTTY) {
+            // Sem terminal não há seta para apertar. Cair no /skills é melhor
+            // que desenhar uma tela que ninguém pode usar.
+            return handleSlash('/skills').then(resolve);
+        }
+
+        let estado = marketplace.novo(skills.listar());
+        const altura = () => Math.max(6, Math.min(16, (process.stdout.rows || 24) - 10));
+        let alturaDesenhada = 0;
+
+        const pintar = (primeira) => {
+            const texto = marketplace.montar(estado, {
+                colunas: process.stdout.columns || 80, altura: altura(),
+            });
+            if (rl && rl.cheia) return rl.painel(texto);
+            const linhas = texto.split('\n');
+            // Redesenha POR CIMA do quadro anterior em vez de rolar a tela:
+            // sem isso, cada seta empurraria a tela inteira para cima e o
+            // terminal viraria um rolo de cópias do marketplace.
+            if (!primeira && alturaDesenhada) process.stdout.write(`\x1b[${alturaDesenhada}A\r`);
+            process.stdout.write(linhas.map((l) => '\x1b[2K' + l).join('\n') + '\n');
+            // O quadro novo pode ser mais curto que o anterior (a descrição
+            // que some ao mudar de item): o resto é apagado, senão sobra
+            // lixo da linha antiga embaixo.
+            if (alturaDesenhada > linhas.length) {
+                const sobra = alturaDesenhada - linhas.length;
+                process.stdout.write('\x1b[2K\n'.repeat(sobra) + `\x1b[${sobra}A`);
+            }
+            alturaDesenhada = Math.max(linhas.length, alturaDesenhada);
+        };
+
+        const aoTeclar = (ch, key) => {
+            if (!key) return;
+            const { estado: novoEstado, acao } = marketplace.andar(estado, key, { altura: altura() });
+            estado = novoEstado;
+
+            if (!acao) { pintar(false); return; }
+
+            if (acao.tipo === 'fechar') { encerrar(); resolve(); return; }
+
+            if (acao.tipo === 'alternar') {
+                skills.ligar(acao.skill.nome, !acao.skill.ligada);
+                // A lista é relida do disco: a skill muda de seção, e a tela
+                // tem de mostrar isso na hora — senão parece que nada
+                // aconteceu e a pessoa aperta Enter de novo.
+                estado = { ...estado, skills: skills.listar() };
+                pintar(false);
+                return;
+            }
+
+            if (acao.tipo === 'nova' || acao.tipo === 'instalar') {
+                encerrar();
+                (acao.tipo === 'nova' ? criarSkill() : instalarSkill())
+                    .then(() => abrirMarketplace())
+                    .then(resolve);
+            }
+        };
+
+        /* Largar o teclado e devolver a caixa. Chamado por TODAS as saídas —
+           o Esc, o "New Skill" e o "Instalar" —, porque o diálogo que vem
+           depois usa o `ask`, e o `ask` precisa da caixa de volta. */
+        const encerrar = () => {
+            process.stdin.removeListener('keypress', aoTeclar);
+            process.stdin.removeListener('end', aoAcabar);
+            process.stdin.removeListener('close', aoAcabar);
+            sliderAtivo = false;
+            if (rl && rl.retomar) rl.retomar();
+        };
+
+        /* A entrada pode acabar com a tela aberta (pipe que terminou, Ctrl+D,
+           terminal fechado). Sem isto o programa ficaria esperando para
+           sempre uma tecla que não vem mais — pendurado e calado, que é o
+           pior jeito de travar. */
+        const aoAcabar = () => { encerrar(); resolve(); };
+        process.stdin.once('end', aoAcabar);
+        process.stdin.once('close', aoAcabar);
+
+        sliderAtivo = true;
+        if (rl && rl.suspender) rl.suspender();
+        pintar(true);
+        process.stdin.on('keypress', aoTeclar);
+    });
+}
+
+/* ── New Skill: o nome, e depois o prompt ────────────────────────────────
+ * Em sequência, como foi pedido. O conteúdo é multilinha e termina numa linha
+ * com apenas `.` — não em Enter: o prompt de uma skill tem parágrafos, e
+ * terminar no primeiro Enter tornaria impossível escrever uma skill de
+ * verdade sem colar tudo numa linha só.
+ */
+async function criarSkill() {
+    console.log('');
+    console.log('  ' + c.bold(c.brand('New Skill')));
+    console.log('  ' + c.muted('Uma skill é conhecimento em texto: o que o Primo deve saber'));
+    console.log('  ' + c.muted('e seguir quando o assunto aparecer.'));
+    console.log('');
+
+    const nome = String(await ask('  ' + c.brand('❯ ') + c.white('Nome da skill: '))).trim();
+    if (!nome) { console.log(c.muted('  Sem nome, sem skill.')); return; }
+
+    console.log('');
+    console.log('  ' + c.muted('Agora o conteúdo — o prompt inteiro dela.'));
+    console.log('  ' + c.dim('Escreva quantas linhas quiser. Termine com um ponto sozinho numa linha.'));
+    console.log('');
+
+    const linhas = [];
+    for (;;) {
+        const l = await ask('  ' + c.dim('│ '));
+        if (String(l).trim() === '.') break;
+        linhas.push(l);
+        // Sem teto, um Enter preso na tecla viraria um arquivo de milhões de
+        // linhas. 400 é muito mais do que qualquer skill precisa.
+        if (linhas.length >= 400) { console.log(c.muted('  (chegou ao limite de linhas)')); break; }
+    }
+    const corpo = linhas.join('\n').trim();
+    if (!corpo) { console.log(c.muted('  Sem conteúdo, sem skill.')); return; }
+
+    console.log('');
+    const quando = String(await ask('  ' + c.brand('❯ ') + c.white('Quando usar? ')
+        + c.dim('(palavras separadas por vírgula) '))).trim();
+    const descricao = String(await ask('  ' + c.brand('❯ ') + c.white('Uma linha do que ela faz: '))).trim();
+
+    const r = skills.criar(nome, corpo, { quando, descricao });
+    if (!r.ok) { console.log(c.err(`  ${r.error}`)); return; }
+    console.log('');
+    console.log(c.ok(`  Skill cadastrada: ${r.nome}`) + c.muted(`  (${shortPath(r.caminho)})`));
+    if (!quando) {
+        // Sem gatilho ela nunca entra sozinha num pedido. Dizer isso agora
+        // evita a conclusão de que "a skill não funciona".
+        console.log(c.warn('  Sem palavras em "quando usar", ela não vai entrar sozinha nos pedidos.'));
+        console.log(c.dim('  Edite o arquivo e preencha o campo `quando:` quando quiser.'));
+    }
+}
+
+async function instalarSkill() {
+    console.log('');
+    const caminho = String(await ask('  ' + c.brand('❯ ') + c.white('Caminho do SKILL.md: '))).trim();
+    if (!caminho) return;
+    const r = await instalarComPortao(caminho);
+    console.log(r.ok ? c.ok(`  Skill instalada: ${r.nome}`) : c.err(`  ${r.error}`));
+}
+
+/* Instala passando pelo portão (lib/skill/portao-skill.js). Achou algo: mostra cada
+   achado com arquivo:linha e faz a mesma pergunta do que não tem volta
+   (autorizarControle) — Enter sozinho é NÃO. */
+async function instalarComPortao(caminho) {
+    const r = skills.instalarDe(caminho);
+    if (!r.bloqueada) return r;
+    console.log('');
+    console.log('  ' + c.err(r.error));
+    for (const linha of portaoSkill.descrever(r.achados).slice(0, 20)) console.log('    ' + c.warn(linha));
+    if (r.achados.length > 20) console.log(c.dim(`    … e mais ${r.achados.length - 20}`));
+    console.log('  ' + c.dim('Leia cada linha: o portão acha padrão, não intenção.'));
+    const resposta = await autorizarControle(`instalar a skill de ${caminho} mesmo assim`, { tipo: 'perigo' });
+    if (resposta !== 'agora' && resposta !== 'sessao') return { ok: false, error: 'Skill não instalada.' };
+    return skills.instalarDe(caminho, { forcar: true });
+}
+
+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.
+
+       De cortesia, não de segurança — este arquivo vai publicado no npm com o
+       código à vista, e a checagem é uma linha que qualquer um apaga. Quem
+       segura de verdade é o primocode-server. O que ele faz aqui é dizer o
+       que houve e como resolver, em vez de deixar a pessoa achando que o
+       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('/account plans')
+            + c.muted(' · já assinou? ') + c.brand('/account'));
+        return;
+    }
+
+    /* Pedido grande: uma linha dizendo quanto deve gastar do plano de hoje (lib/config/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('../config/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('../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('../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('../session/runner/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();
+        if (linha) console.log(c.dim(`  ⏱ ${linha}`));
+        /* O fecho de cada resposta, como no OpenCode ("▣ Build · Nemotron ·
+           4.0s"): quem respondeu, com que esforço, e quanto levou. */
+        const m = state.mode === 'auto' ? (state.modoEfetivo || 'auto') : state.mode;
+        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('../fundo.js').linhasRodape(require('../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/config/limite.js): é o que o /usage soma. */
+const IDENTIDADE_DA_SESSAO = `${process.pid}-${Date.now()}`;
+/* Tarefa em segundo plano que acabou sozinha: uma linha na tela (o modelo recebe o aviso na próxima volta). */
+require('../fundo.js').aoTerminar((a) => {
+    if (state.semTerminal) return;
+    process.stdout.write('\n  ' + (a.ok ? c.ok('✔') : c.err('✘')) + ' ' + c.muted(`tarefa ${a.id} terminou (código ${a.codigo}): ${a.comando.slice(0, 60)}`) + '\n');
+});
+function guardarUsoDeHoje() {
+    try {
+        const { total } = extra.resumoCusto(contadorDaSessao);
+        require('../config/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('../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\`\`\``);
+        prompt = parts.join('\n\n') + '\n\n' + userText;
+    }
+
+    // O modo primocode manda o schema das 30 tools em todo pedido (~4.700
+    // tokens). No auto, quem não vai usar ferramenta não paga por ela.
+    let modo = state.mode;
+    if (modo === 'auto') {
+        // O modo do pedido ANTERIOR entra na decisão: no meio de uma tarefa,
+        // "refaz" e "agora põe música" são continuação, não papo novo.
+        const escolha = escolherModo(userText, { ultimoModo: state.modoEfetivo });
+        modo = escolha.modo;
+        state.modoEfetivo = modo;
+        const rotulo = modo === 'primocode' ? c.warn('Primo Code') : c.brandDim('Chat');
+        console.log(c.dim(`  ⎿ ${ui.stripAnsi(rotulo)} · ${escolha.motivo}`));
+        refreshPrompt();
+    }
+
+    if (modo === 'primocode') {
+        // "baixa o vídeo" / "exporta em mp4" não precisa de IA NENHUMA: é
+        // abrir a última criação do Studio com #gravar — o navegador pede a
+        // permissão de tela (a aprovação), grava a passada e baixa no fim.
+        // Antes isso virava uma tarefa inteira de modelo (id inventado,
+        // mídia inventada, limite estourado) para chegar no mesmo lugar.
+        if (await baixarCriacaoDireto(userText)) { refreshPrompt(); return; }
+
+        const plan = await prepararPasta(userText);
+
+        // O Chrome só aparece na tela quando o pedido é de navegador (lib/browser.js, definirVisivel).
+        require('../browser.js').definirVisivel(querNavegador(userText));
+
+        /* AS REFERÊNCIAS DO VÍDEO (lib/plugin/estudio/referencias.js) saem do próprio
+           pedido. O padrão é SEM IMAGEM, e o menu 1/2/3 saiu: "por padrão, NÃO
+           usar imagens; somente quando o usuário pedir explicitamente" (07/10). */
+        const referencias = require('../plugin/estudio/referencias.js');
+        referencias.limpar();
+        const producao = require('../plugin/estudio/diretor.js').precisaDeProducao(userText);
+        if (producao.producao && producao.formato === 'video') {
+            const r = referencias.inferir(userText);
+            referencias.definir(r.modo, r.escopo, r.explicito);
+            console.log(c.dim(`  ⎿ imagens: ${{ aberto: 'sim, da web', fechado: 'só de ' + r.escopo, sem: r.explicito ? 'nenhuma, só motion' : 'nenhuma (o padrão)' }[r.modo]}`)
+                + (r.modo === 'sem' && !r.explicito ? c.dim(' · diga "adicione imagens de apoio" para usar') : ''));
+        }
+
+        // O resumo da rodada anterior é feito em segundo plano logo depois
+        // dela; aqui só se espera ele terminar, para não sair com memória velha.
+        //
+        // O pedido passa por uma cabeça antes de virar trabalho: conserta o
+        // que está torto, diz qual é o entregável e o que conta como pronto.
+        // UMA chamada faz as duas coisas: arruma o pedido torto e, se fizer
+        // sentido, divide em passos. Eram duas idas ao modelo por pedido, e
+        // num plano limitado por REQUISIÇÕES (o grátis da Groq são 30 por
+        // minuto) cada chamada extra custa tanto quanto token.
+        //
+        // As duas esperas correm JUNTAS. Uma não lê o que a outra escreve: o
+        // plano só olha o texto do pedido, e o resumo só a conversa de antes.
+        // Em fila, o pedido de duas fases pagava o resumo e DEPOIS o plano —
+        // duas idas ao modelo em série antes da primeira rodada.
+        const [, passos] = await Promise.all([
+            tempos.medir('espera do resumo', () => esperarResumo()),
+            tempos.medir('plano', () => dividirTarefa(prompt)),
+        ]);
+
+        let r = null;
+        let jaFeito = '';
+        /* O livro do PEDIDO, não do passo. Um plano de três passos são três
+           chamadas de runAct, cada uma com o seu registro — e o balanço que
+           interessa é o do pedido inteiro: quem pediu um vídeo não quer três
+           balanços, quer saber o que existe no disco quando ele terminar. */
+        const livro = registro.novo();
+        // Um checkpoint por PEDIDO (não por passo): é o que o /desfazer volta.
+        // Com a pasta: a foto do projeto inteiro sai AGORA, antes de qualquer
+        // tool — é ela que dá volta ao `rm`/`mv` que o run_shell fizer.
+        checkpoint.iniciar(userText, projectDir());
+        for (let i = 0; i < passos.length; i++) {
+            if (i > 0) console.log(c.dim(`  ⎿ ${passos[i].titulo}`));
+            // Só fato de passo CONCLUÍDO entra aqui. Num pedido real o passo de
+            // pesquisa morreu e o texto "Parei sem concluir..." foi injetado
+            // como "use estes fatos" — e o passo seguinte obedeceu: criou o
+            // vídeo sem fato nenhum, proibido de pesquisar.
+            const contexto = !jaFeito ? ''
+                : `\n\nO QUE JÁ FOI FEITO ANTES (use estes fatos, não pesquise de novo):\n${jaFeito}`;
+            const semFatos = i > 0 && !jaFeito
+                ? '\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.'
+                : '';
+            // 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('../escopo.js').nota(userText);
+
+            const rodarPasso = (texto = pedido) => runAct(texto, {
+                server: state.config.server,
+                model: state.config.model,
+                effort: state.config.effort,
+                token: state.config.token,
+                // Só o primeiro passo enxerga a conversa: os seguintes recebem o
+                // que interessa em `jaFeito`, e conversa a mais só ocupa o teto.
+                history: i === 0 ? memoria.paraEnviar(state.memoria, state.history, contextoDoProjeto()) : [],
+                projectDir: plan.dir,
+                projectName: plan.name || state.currentProject,
+                // Só chamado se o agente for mesmo MEXER EM ARQUIVO — abrir o Chrome
+                // não é motivo para criar pasta de projeto.
+                ensureWorkDir: plan.pending ? () => createPendingProject(plan) : null,
+                // O portão do computador: quem pergunta é o terminal, quem
+                // lembra da resposta é a sessão.
+                // No pedido único (`primo "…"`) não há ninguém para responder:
+                // sem `autorizar`, o que pede licença é recusado (lib/permission/perigo.js).
+                autorizar: state.semTerminal ? undefined : autorizarControle,
+                escolher: state.semTerminal ? undefined : (q, o, op) => {
+                    const PQ = require('../tool/perguntar');
+                    if (process.stdin.isTTY && process.stdout.isTTY) {
+                        return PQ.escolherComSetas({ stdin: process.stdin, stdout: process.stdout, suspender: () => rl && rl.suspender && rl.suspender(), retomar: () => rl && rl.retomar && rl.retomar() }, c, q, o, { ...op, ask });
+                    }
+                    return PQ.escolherNoTerminal(ask, c, q, o, op);
+                },
+                // A memória do AGENTS.md só vai se o resumo ainda não a carrega.
+                memoriaDaPasta: !memoria.jaDobrou(state.memoria, plan.dir),
+                mudarPasta: state.semTerminal ? null : mudarPastaPeloAgente,
+                controle: state.controle,
+                permissoes: state.config.permissoes,
+                // Pedido de mexer no computador leva a dica que libera as
+                // ferramentas desktop_* no servidor (ver DICA_COMPUTADOR).
+                instrucao: [i === 0 && querComputador(userText) ? vozModo.DICA_COMPUTADOR : '',
+                    i === 0 ? require('../plugin/estudio/referencias.js').instrucao() : '',
+                    // As imagens do pedido (arrastadas ou coladas): guardadas para o Estúdio importar, e ditas ao agente.
+                    i === 0 ? (() => { const R = require('../plugin/estudio/referencias.js'); return R.instrucaoDasImagens(R.guardarImagens(R.imagensNoTexto(userText))); })() : '',
+                    i === 0 ? plan.notaOutraPasta || '' : ''].filter(Boolean).join('\n\n'),
+            });
+
+            r = await rodarPasso();
+            // O mudar_pasta trocou no meio: os passos seguintes seguem lá.
+            if (r && r.pasta && path.resolve(r.pasta) !== path.resolve(plan.dir)) { plan.dir = r.pasta; plan.pending = false; }
+            if (r && r.estudio) state.estudioAtivo = r.estudio;
+            /* Passo que parou no meio NÃO devolve a tarefa para a pessoa
+               dividir. Se ele já tinha feito alguma coisa (arquivo, comando),
+               o próprio CLI pede a continuação — com a lista do que já existe
+               no disco, para não refazer. Até CONTINUACOES vezes, e só
+               enquanto cada volta produz algo: continuação que não mexe em
+               nada é laço, e laço para.
+               Num plano de vários passos, o passo que desistiu sem fazer nada
+               ganha UMA segunda chance — costuma ser tropeço transitório do
+               modelo grátis. Falhou de novo: o
+               plano segue com o aviso de "sem fatos", nunca com o texto da
+               falha fantasiado de resultado. */
+            let continuacoes = 0;
+            let tentouDeNovo = false;
+            while (!r.parado && r.concluiu === false) {
+                registro.juntar(livro, r.registro);
+                // Sem registro é erro do provedor (cota, rede): retomar só bate
+                // no mesmo muro.
+                if (r.registro && !registro.vazio(r.registro) && continuacoes < CONTINUACOES) {
+                    continuacoes++;
+                    console.log(c.dim('  ⎿ continuando de onde parou'));
+                    r = await rodarPasso(pedidoDeContinuacao(passos[i].pedido, livro));
+                    continue;
+                }
+                if (!tentouDeNovo && passos.length > 1 && registro.vazio(r.registro) && continuacoes === 0) {
+                    tentouDeNovo = true;
+                    console.log(c.dim('  ⎿ o passo não concluiu — tentando de novo'));
+                    r = await rodarPasso();
+                    continue;
+                }
+                break;
+            }
+            if (r.concluiu !== false || r.parado) registro.juntar(livro, r.registro);
+            jaFeito = (r.concluiu !== false)
+                ? String((r.assistantMessage && r.assistantMessage.content) || '').slice(0, 1200)
+                : '';
+            if (r.parado) break;   // Esc Esc no meio do plano para o plano inteiro
+        }
+        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('../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('../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) {
+            const humor = r.parado ? 'parado' : r.concluiu === false ? 'preocupado' : 'feliz';
+            console.log(ui.reacao(state.config.mascot, humor));
+        }
+        state.history.push({ role: 'user', content: userText });
+        // 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('../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 });
+        // Sobe cifrado, atrás, sem segurar o prompt. Se não houver conta ou
+        // 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));
+    }
+
+    state.attachedFiles = [];
+    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('../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/permission/perigo.js) e só aplica com o sim. /undo volta. */
+async function parceiroFaz(nome, pedido) {
+    const team = require('../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.
+ *
+ * ARRUMAR: gente pede curto e torto ("cria um vidro anunciando o founders
+ * ai"). Sem isso o agente adivinha, e adivinha errado. É oculto porque
+ * encanamento não é conversa: o usuário quer ver a coisa acontecendo, não um
+ * relatório do que a máquina entendeu — e não há o que aprovar, já que o
+ * refino não decide nada, só desambigua o que ele já disse.
+ *
+ * DIVIDIR: o motivo é aritmético. Com 6.000 tokens por minuto, "pesquise
+ * sobre a X e crie um vídeo" não cabe numa conversa só — custo fixo ~3.700,
+ * spec do formato ~1.400, fatos da pesquisa o resto, e sobram 512 para o
+ * agente escrever. Em dois pedidos cada um cabe folgado, porque cada um leva
+ * só as ferramentas e o prompt do seu passo.
+ *
+ * As duas numa chamada só: elas leem o mesmo texto, e num plano limitado por
+ * requisições por minuto a segunda ida ao modelo custa tanto quanto token.
+ *
+ * Falhou? O pedido do usuário, inteiro, como ele escreveu.
+ */
+// A ÚNICA divisão que compensa: DESCOBRIR uma coisa e CRIAR outra com ela.
+// O resto é pedido de uma fase só, e mandar para o planejador era pagar uma
+// chamada de API para ouvir "não divida" — quando o modelo não resolvia
+// inventar passos que ninguém pediu, que era o "faz coisas nada a ver".
+const RE_DESCOBRIR = /\b(pesquis|busca|procur|descubr|investig|analis|leia|estud|olh[ae] (o site|a p[áa]gina)|ver o que)\w*/i;
+const RE_CRIAR_DEPOIS = /\b(cri[ae]|faz|faça|mont[ae]|ger[ae]|escrev[ae]|produz|desenvolv)\w*/i;
+
+/* A outra divisão que compensa: o pedido LONGO que emenda entregas diferentes
+   ("cria o site, depois põe login e publica"). Estreita de propósito — o
+   planejador dividindo pedido de uma fase só era o "faz coisas nada a ver" —
+   e o servidor ainda devolve passo único na dúvida. */
+const RE_ACAO = /\b(cri[ae]r?|fa[zç]a?|fazer|mont[ae]r?|ger[ae]r?|escrev[ae]r?|adicion[ae]r?|coloc[ae]r?|p[oõ]e|implement[ae]r?|public[ae]r?|sob[ea]|instal[ae]r?|configur[ae]r?|test[ae]r?|corrig[ei]r?|arrum[ae]r?|mud[ae]r?|integr[ae]r?|conect[ae]r?)\b/gi;
+function pedidoDeVariasPartes(pedido) {
+    const t = String(pedido || '');
+    if (t.length < 200) return false;
+    const acoes = new Set((t.match(RE_ACAO) || []).map((x) => x.toLowerCase().slice(0, 4)));
+    return acoes.size >= 3 && /\b(depois|em seguida|e tamb[ée]m|al[ée]m disso|por fim|e ent[ãa]o)\b|\n\s*(\d+[.)]|[-*•])\s/i.test(t);
+}
+
+/* "me manda o vídeo" resolvido na hora, sem gastar modelo.
+ *
+ * Antes isso abria a última criação do Studio no navegador com `#gravar`, e a
+ * pessoa precisava aceitar uma permissão de tela para o navegador GRAVAR a
+ * animação passando — era assim que o mp4 nascia.
+ *
+ * Isso acabou junto com o renderizador de navegador: o Remotion escreve o
+ * arquivo direto, e todo render já deixa um .mp4 em `saida/`. Então "baixa o
+ * vídeo" não é mais uma tarefa — é dizer onde ele está, que o CLI sabe sem
+ * perguntar a modelo nenhum.
+ */
+const RE_BAIXAR = /\b(baixa\w*|exporta\w*|download|salva\w*|me manda|manda(r)? (o|a|esse|essa)|gera(r)? o arquivo|em mp4|pra mandar|arquivo do|onde (est[áa]|ficou))\b/i;
+const RE_PECA_STUDIO = /\b(v[ií]deo|mp4|apresenta[çc][ãa]o|slides?|reels?|anima[çc][ãa]o|filme)\b/i;
+
+async function baixarCriacaoDireto(texto) {
+    if (!(RE_BAIXAR.test(texto) && RE_PECA_STUDIO.test(texto))) return false;
+    try {
+        const { projeto } = require('../plugin/estudio');
+        // O mais recente que já foi renderizado: quem diz "me manda o vídeo"
+        // fala do último, e um projeto sem render não tem o que mandar.
+        const comArquivo = projeto.listar({ limite: 30 })
+            .find((p) => (p.renders || []).some((r) => fs.existsSync(r.arquivo)));
+        if (!comArquivo) return false;
+        const ultimo = [...comArquivo.renders].reverse().find((r) => fs.existsSync(r.arquivo));
+
+        await tools.execute('open_in_browser', { target: ultimo.arquivo },
+            { projectDir: state.workDir || os.homedir() });
+        console.log(c.ok(`  ⎿ abrindo "${comArquivo.titulo}"`));
+        console.log(c.muted('    ') + c.white(ultimo.arquivo));
+        console.log(c.dim(`    ${(ultimo.bytes / 1048576).toFixed(1)} MB · o arquivo já estava pronto, é só copiar daí.`));
+        return true;
+    } catch {
+        return false;   // sem projeto renderizado: segue o caminho normal
+    }
+}
+
+/* Quantas vezes um passo que parou no meio é retomado sozinho. */
+const CONTINUACOES = 2;
+
+/**
+ * O pedido de retomada: o pedido original + o que já existe, para o agente
+ * seguir em vez de recomeçar. A conversa do passo anterior não vai junto (é
+ * ela que estourou) — vai o que aconteceu no disco, que é o que importa.
+ */
+function pedidoDeContinuacao(original, livro) {
+    const linhas = [];
+    if (livro.criados.length) linhas.push(`Arquivos criados: ${livro.criados.slice(0, 20).join(', ')}`);
+    if (livro.alterados.length) linhas.push(`Arquivos alterados: ${livro.alterados.slice(0, 20).join(', ')}`);
+    const cmds = livro.comandos.slice(-8).map((x) => `${x.comando} (${x.ok ? 'ok' : 'falhou'})`);
+    if (cmds.length) linhas.push(`Comandos rodados: ${cmds.join('; ')}`);
+    const falhas = livro.falhas.slice(-3).map((f) => `${f.acao}: ${f.motivo}`);
+    if (falhas.length) linhas.push(`Falhas: ${falhas.join('; ')}`);
+    return `CONTINUAÇÃO — a tarefa abaixo já foi começada e parou no meio. NÃO recomece do zero: `
+        + `leia o que já existe, veja o que falta, divida o que falta em passos pequenos (write_todos) e termine.\n\n`
+        + `O QUE JÁ FOI FEITO:\n${linhas.join('\n') || '(nada registrado)'}\n\nA TAREFA:\n${original}`;
+}
+
+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
+    // dar ao modelo a chance de dividir o que não devia.
+    if (!(RE_DESCOBRIR.test(pedido) && RE_CRIAR_DEPOIS.test(pedido)) && !pedidoDeVariasPartes(pedido)) return inteiro;
+    const sp = new Spinner('Primo Code pensando').start();
+    try {
+        const r = await api.requestPlano(state.config.server, {
+            prompt: pedido, model: state.config.model, token: state.config.token,
+        });
+        sp.stop();
+        const passos = (r && Array.isArray(r.passos) && r.passos.length) ? r.passos : inteiro;
+        if (passos.length > 1) console.log(c.dim(`  ⎿ ${passos[0].titulo}`));
+        return passos;
+    } catch {
+        sp.stop();   // preparar o pedido é melhoria, não requisito
+        return inteiro;
+    }
+}
+
+/**
+ * Atualiza o resumo da conversa, se já compensar.
+ *
+ * Silencioso quando não há o que fazer: nas primeiras rodadas a conversa é
+ * curta e o resumo não pagaria a chamada.
+ */
+/* `forcado` é o `/compact`: a pessoa mandou resumir, e mandar resumir tem de
+   resumir. Sem isso o comando responderia "nada a fazer" justamente quando
+   ela está vendo a IA se perder — e "não fiz nada" é a pior resposta possível
+   para quem acabou de pedir socorro. */
+async function comprimirConversa(forcado = false, { silencioso = false } = {}) {
+    if (!forcado && !memoria.precisaResumir(state.memoria, state.history)) return;
+    // Em segundo plano não há spinner: ele disputaria a tela com o prompt.
+    const sp = silencioso ? { stop() {} } : new Spinner('resumindo a conversa').start();
+    try {
+        const conversa = state.history;
+        const dir = projectDir();
+        /* A memória que o AGENTS.md desta pasta já tinha entra no resumo
+           (uma vez por pasta): sem isto a primeira resposta de uma sessão nova
+           reescreveria o AGENTS.md só com ela, e o "de onde parei" de ontem
+           sumia. */
+        if (!memoria.jaDobrou(state.memoria, dir) && !(state.memoria.semente && state.memoria.semente.pasta === dir)) {
+            state.memoria = memoria.semear(state.memoria, dir, agentsMd.ler(dir));
+        }
+        // O mesmo `resumir` da compactação automática do agente (lib/session/compactacao.js): resumo + arquivos mexidos + to-dos.
+        const nova = await memoria.atualizar(state.memoria, conversa, ({ resumo, mensagens }) =>
+            require('../session/compactacao.js').resumirComFatos({ resumo, mensagens },
+                (p) => api.requestResumo(state.config.server, { ...p, token: state.config.token }).then((r) => r.resumo)));
+        // /clear ou /chats trocaram a conversa enquanto o resumo era feito:
+        // o resumo é da conversa velha e não pode voltar por cima da nova.
+        if (state.history !== conversa) { sp.stop(); return; }
+        state.memoria = nova;
+        sp.stop();
+        gravarMemoriaDaPasta(dir);
+        const e = memoria.economia(state.memoria, state.history);
+        if (!silencioso && e.poupado > 0) console.log(c.dim(`  ⎿ conversa resumida · ${e.cheio} → ${e.enxuto} tokens por pedido`));
+    } catch {
+        sp.stop();   // resumo é economia, não requisito: falhou, segue a vida
+    }
+}
+
+/* ── O RESUMO DE CADA RODADA ─────────────────────────────────────────────
+ * "Gere um resumo a cada mensagem, pra na próxima ela ler só esse resumo."
+ * O resumo começa assim que a resposta termina, atrás, sem segurar o prompt —
+ * a pessoa lê a resposta enquanto ele é feito. O pedido seguinte espera por
+ * ele (com teto: rede lenta não pode travar a conversa), e aí leva só o
+ * resumo, não a conversa inteira. Ver lib/session/memoria-conversa.js. */
+function resumirDepois() {
+    const anterior = state.resumindo || Promise.resolve();
+    const atual = anterior.then(() => comprimirConversa(false, { silencioso: true })).catch(() => {});
+    state.resumindo = atual;
+    atual.then(() => { if (state.resumindo === atual) state.resumindo = null; });
+}
+
+/* ── O AGENTS.md DE CADA PASTA ───────────────────────────────────────────
+ * "Eu preciso de um AGENTS.md com a memória da conversa em cada pasta."
+ * O resumo da conversa vai para o AGENTS.md da pasta de trabalho (só o bloco
+ * do PrimoCode; o resto do arquivo é da pessoa — lib/agents-md.js), e para a
+ * pasta do projeto do Estúdio em que se mexeu, se houver. A raiz
+ * ~/primocode fica de fora: é o corredor, não um projeto. */
+function gravarMemoriaDaPasta(dir = projectDir()) {
+    const resumo = state.memoria && state.memoria.resumo;
+    if (!resumo) return;
+    try { agentsMd.gravar(dir, resumo, { raiz: cfg.ROOT_DIR }); } catch { /* memória é conveniência */ }
+    if (state.estudioAtivo) {
+        try {
+            const p = require('../plugin/estudio/projeto.js').ler(state.estudioAtivo);
+            if (p) agentsMd.gravar(p.pasta, resumo, { titulo: p.titulo });
+        } catch { /* projeto sumiu */ }
+    }
+}
+
+async function esperarResumo(tetoMs = 6000) {
+    if (!state.resumindo) return;
+    await Promise.race([state.resumindo, new Promise((ok) => setTimeout(ok, tetoMs))]);
+}
+
+/* A linha que vai junto do resumo: em que projeto se está. É o que faz
+   "continua o jogo" e "muda a cor" caírem no mesmo projeto em vez de inventar
+   outro. */
+function mencoesDoPedido(userText) {
+    const { arquivos, ignorados } = mencoesLib.mencoes(userText, projectDir());
+    const lidos = [];
+    for (const a of arquivos) {
+        try {
+            lidos.push({ path: a.rel, content: fs.readFileSync(a.abs, 'utf-8') });
+            console.log(c.dim(`  ⎿ anexado: ${a.rel} (${tools.fmtBytes(a.bytes)})`));
+        } catch { console.log(c.dim(`  ⎿ não consegui ler: ${a.rel}`)); }
+    }
+    for (const i of ignorados) console.log(c.dim(`  ⎿ não anexei ${i.rel}: ${i.motivo}`));
+    return lidos;
+}
+
+/* O pedido do /init. Passa pelo MESMO caminho de um pedido digitado
+   (sendPrompt → runAct), então usa as ferramentas e o provedor de agora — um
+   /init que falasse direto com o modelo não enxergaria os arquivos. */
+const PEDIDO_INIT = 'Estude este projeto (a pasta atual) e escreva um arquivo PRIMO.md na raiz dela. '
+    + 'Primeiro olhe de verdade: liste os arquivos, leia o README, o package.json (ou o equivalente) e os arquivos principais. '
+    + 'Depois escreva o PRIMO.md em português, curto (menos de 60 linhas), com estas seções: '
+    + 'o que é o projeto (2 ou 3 frases); como rodar (os comandos exatos que você viu, de instalar, rodar e testar); '
+    + 'a stack (linguagem, frameworks, banco); as convenções que o código segue (nomes, estilo, onde ficam os testes); '
+    + 'e onde está cada coisa (as pastas e arquivos que importam, uma linha cada). '
+    + 'Só escreva o que você conferiu nos arquivos — nada de inventar comando ou dependência. '
+    + 'Esse arquivo vai ser lido no começo de todo pedido neste projeto, então cada linha precisa valer o espaço.';
+
+function contextoDoProjeto() {
+    if (!state.currentProject) return '';
+    return `Projeto atual: ${state.currentProject} (pasta ${shortPath(projectDir())}). `
+        + 'Pedidos como "continua", "edita", "muda", "melhora" ou "isso" são sobre ELE: '
+        + 'trabalhe nos arquivos que já existem lá, não crie outro projeto.';
+}
+
+/* O chat não passa pelo runAct, e é no runAct (buildMemoryContext) que as
+   instruções do projeto entram. Sem isto o PRIMO.md valeria para o agente e
+   seria ignorado quando o modo auto manda o pedido para a conversa. */
+function comInstrucoes(history) {
+    const dir = state.currentProject || state.workDir ? projectDir() : null;
+    let texto = mencoesLib.instrucoesDoProjeto(dir);
+    // A memória do AGENTS.md também vale no chat, enquanto o resumo não a tem.
+    const daPasta = dir && !memoria.jaDobrou(state.memoria, dir) ? agentsMd.ler(dir) : '';
+    if (daPasta) texto = [texto, `[AGENTS.md — memória desta pasta: de onde a conversa parou]\n${daPasta}`].filter(Boolean).join('\n\n');
+    return texto ? [{ role: 'system', content: texto }, ...history] : history;
+}
+
+// O chat também precisa parar no Esc Esc. Sem isto o texto continuava saindo
+// na tela depois de o usuário ter mandado parar.
+let chatEmVoo = null;
+
+/* O ouvinte de voz em segundo plano.
+   Um por sessão: dois processos disputando o mesmo microfone dão um vazio
+   intermitente que parece defeito de hardware e não é. */
+let vozPainel = null;      // /voice painel: só o HUD
+let vozEmEspera = null;   // a sessão do /voice: { processo, falar, calar }
+/* Por onde a fala entra no terminal. Nasce no main(), junto da fila — é lá
+   que moram o `busy`, a fila e o `ask` pendente. */
+let entradaDeVoz = null;
+
+async function runChat(promptForModel, userTextForMemory) {
+    chatEmVoo = new AbortController();
+    const sp = new Spinner(ui.PENSANDO).start();
+    const saida = fala.fluxo();
+    let text = '';
+    // O chat não tinha a paciência do agente: o primeiro 429 ou teto do
+    // minuto saía em vermelho na tela, na primeira recusa. Agora o que é
+    // passageiro (minuto, 429, 5xx, rede) espera a janela e repete calado,
+    // com o spinner de pensar girando — até seis vezes. O que NÃO é
+    // passageiro (crédito, chave, cota do dia) continua saindo, como aviso.
+    // Texto já na tela não se repete: se o erro veio no meio da resposta, ela
+    // fica como está e o aviso vem embaixo.
+    for (let tentativa = 0; ; tentativa++) {
+        let erro = null;
+        try {
+            await api.requestChat(state.config.server, {
+                prompt: promptForModel,
+                history: comInstrucoes(memoria.paraEnviar(state.memoria, state.history, contextoDoProjeto())),
+                model: state.config.model,
+                token: state.config.token,
+                sinal: chatEmVoo.signal,
+            }, (evt) => {
+                if (evt.erro) { erro = evt.erro; return; }
+                if (evt.delta) {
+                    if (!saida.escreveu()) sp.stop();
+                    text += evt.delta;
+                    saida.escrever(evt.delta);
+                }
+            });
+        } catch (e) { erro = e; }
+        if (!erro) break;
+        const passageiro = ehTetoDeToken(erro) || ehTransitorio(erro);
+        if (passageiro && tentativa < 6 && !text && !chatEmVoo.signal.aborted) {
+            await new Promise((r) => setTimeout(r, esperaDoErro(erro, tentativa + 1)));
+            continue;
+        }
+        sp.stop();
+        saida.fechar();
+        if (!chatEmVoo.signal.aborted) fala.problema(erro);
+        if (!text) return;
+        break;
+    }
+    sp.stop();
+    saida.fechar();
+    if (text) {
+        state.history.push({ role: 'user', content: userTextForMemory });
+        state.history.push({ role: 'assistant', content: text });
+        resumirDepois();
+        state.lastResponse = text;
+        cfg.appendHistory({ mode: 'chat', prompt: userTextForMemory });
+        state.gravador.turno(userTextForMemory, text, { modo: 'chat' });
+    }
+}
+
+// ── Slash commands ─────────────────────────────────────────────────────
+
+function isSlash(text) { return text.trim().startsWith('/'); }
+
+/* ── "!comando" RODA NO SHELL ────────────────────────────────────────────
+ *
+ *   "quando eu mande uma mensagem que comece com ! ele rode em bash"
+ *
+ * Por que não mandar ao agente e deixar ele chamar run_shell: porque são
+ * coisas diferentes. Pedir ao agente é dizer o QUE se quer e deixá-lo
+ * decidir; o "!" é dizer o COMANDO. Quem digita `!git status` não quer que
+ * alguém interprete a intenção — quer a saída do git status, agora, sem
+ * volta ao modelo, sem gastar cota e sem o risco de o agente achar que
+ * entendeu melhor.
+ *
+ * A saída sai CRUA, como no terminal: ela não passa pelo desenhador de
+ * Markdown. Saída de comando tem alinhamento próprio (colunas do `ls`,
+ * tabela do `docker ps`), e reformatá-la seria estragá-la.
+ */
+function ehBash(text) { return /^\s*!/.test(String(text || '')); }
+
+async function rodarBash(text) {
+    const comando = String(text).replace(/^\s*!/, '').trim();
+    if (!comando) return;
+
+    const pasta = state.workDir || process.cwd();
+    console.log('');
+    console.log('  ' + c.warn('$ ') + c.white(comando));
+
+    const inicio = Date.now();
+    const r = await tools.execute('run_shell', { command: comando, timeout: 600000 },
+        { projectDir: pasta });
+    const segundos = ((Date.now() - inicio) / 1000).toFixed(1);
+
+    /* Crua, e inteira. `run_shell` corta em 10 MB, que é o teto do buffer;
+       cortar mais aqui esconderia justamente a linha do erro, que costuma
+       estar no fim. */
+    const saida = [r.stdout, r.stderr].filter((x) => String(x || '').trim()).join('\n');
+    if (saida) console.log(saida.replace(/\n$/, ''));
+
+    if (r.ok) {
+        console.log('  ' + c.dim(`ok · ${segundos}s`));
+    } else if (r.killed) {
+        console.log('  ' + c.warn(`interrompido depois de ${segundos}s`));
+    } else {
+        console.log('  ' + c.warn(`saiu com ${r.code} · ${segundos}s`));
+    }
+    console.log('');
+
+    /* O agente FICA SABENDO, e isto é o que torna o "!" útil dentro de uma
+       conversa: rodar o teste e depois perguntar "por que falhou?" só
+       funciona se ele tiver visto a saída. Sem isto seriam dois mundos
+       separados na mesma tela. */
+    state.history.push({ role: 'user', content: `Rodei no shell: ${comando}` });
+    state.history.push({
+        role: 'assistant',
+        content: `Saída (código ${r.code ?? 0}):\n${saida.slice(0, 4000) || '(vazia)'}`,
+    });
+    resumirDepois();
+}
+
+/* ── OS NOMES ANTIGOS ────────────────────────────────────────────────────
+ * 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
+   no primeiro detalhe (a memória, o gravador) e um deles gravaria errado. */
+async function abrirConversa(alvo) {
+    const sp = new Spinner('abrindo').start();
+    const conv = await nuvem.lerConversa(alvo.id);
+    sp.stop();
+    if (!conv.ok) return conv;
+    // A memória entra ZERADA: o resumo antigo não veio junto, e um
+    // resumo de outra conversa colado aqui faria o modelo responder
+    // sobre coisa que não foi dita nesta.
+    state.history = conv.mensagens.map((m) => ({
+        role: m.papel, content: m.texto,
+    }));
+    state.memoria = memoria.nova();
+    state.gravador.retomar(alvo.id, alvo.titulo, conv.mensagens.length);
+    return conv;
+}
+
+/* `primo --continue` / `primo -c`: volta na última conversa, sem passar pelo
+   /chats. A lista do servidor já vem da mais recente para a mais antiga, então
+   a última é a primeira. Sem conta ou sem conversa, começa do zero e diz. */
+async function continuarUltima() {
+    if (!conta.atual()) {
+        console.log(c.dim('  ⎿ sem conta conectada, não há conversa para continuar — começando do zero'));
+        return false;
+    }
+    const l = await nuvem.listarConversas({ limite: 1 });
+    const alvo = l.ok && l.conversas[0];
+    if (!alvo) {
+        console.log(c.dim('  ⎿ nenhuma conversa salva ainda — começando do zero'));
+        return false;
+    }
+    const conv = await abrirConversa(alvo);
+    if (!conv.ok) {
+        console.log(c.dim(`  ⎿ não consegui abrir a última conversa (${conv.error}) — começando do zero`));
+        return false;
+    }
+    const quando = alvo.atualizada ? new Date(alvo.atualizada).toLocaleString('pt-BR') : 'data desconhecida';
+    console.log(c.dim(`  ⎿ continuando: ${alvo.titulo.slice(0, 60)} (${quando})`));
+    return true;
+}
+
+/* /resume e --resume: sem referência lista as conversas; com número ou id, retoma. */
+async function retomarConversa(ref, { listar = true } = {}) {
+    if (!conta.atual()) { console.log(c.muted('  Não conectado. ') + c.brand('/login') + c.muted(' para retomar conversas.')); return false; }
+    const l = await nuvem.listarConversas({ limite: 20 });
+    if (!l.ok) { console.log(c.err(`  ${l.error}`)); return false; }
+    if (!l.conversas.length) { console.log(c.muted('  Nenhuma conversa salva ainda.')); return false; }
+    if (!ref) {
+        if (!listar) return false;
+        console.log(c.white('\n  Conversas recentes'));
+        l.conversas.forEach((x, i) => console.log('  ' + c.dim(String(i + 1).padStart(2)) + ' ' + c.white(x.titulo.slice(0, 52).padEnd(52))
+            + c.dim(`${String(x.mensagens).padStart(3)} msg  ${x.atualizada ? new Date(x.atualizada).toLocaleDateString('pt-BR') : '—'}`)));
+        console.log(c.dim('\n  /resume <número ou id> retoma.'));
+        return false;
+    }
+    const alvo = retomar.escolher(l.conversas, ref);
+    if (!alvo) { console.log(c.err(`  Não achei a conversa ${ref}.`)); return false; }
+    const conv = await abrirConversa(alvo);
+    if (!conv.ok) { console.log(c.err(`  ${conv.error}`)); return false; }
+    console.log(c.ok(`  ${alvo.titulo}`) + c.muted(`  · ${conv.mensagens.length} mensagens carregadas`));
+    return true;
+}
+
+/* `--resume` sem id: mostra a lista e pergunta o número (só em terminal). */
+async function escolherNaAbertura() {
+    await retomarConversa(null);
+    if (!process.stdin.isTTY) return false;
+    const rl = require('readline').createInterface({ input: process.stdin, output: process.stdout });
+    const resp = await new Promise((res) => rl.question('  Qual? (número, Enter cancela) ', res));
+    rl.close();
+    return resp.trim() ? retomarConversa(resp.trim()) : false;
+}
+
+/* /worktree <nome>: cria e entra. */
+function entrarNoWorktree(nome) {
+    const w = retomar.criarWorktree(nome, projectDir());
+    if (!w.ok) { console.log(c.err(`  ${w.error}`)); return false; }
+    entrarNoProjeto(w.path, '/dir');
+    console.log(c.ok(`  worktree ${shortPath(w.path)}`) + c.muted(`  · branch ${w.branch}`));
+    return true;
+}
+
+/* /new sem nada: as 3 perguntas (era o /new). */
+async function comecarPerguntas() {
+    const comecar = require('./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('../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/skill/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('../plugin/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 restoDigitado = text.trim().slice(1 + cmd.length).trim();
+
+    let nome = cmd.toLowerCase();
+    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': if (/^(all|tudo)$/i.test(rest)) mostrarTudo(); else console.log(montarHelp()); break;
+
+        case 'resume': await retomarConversa(rest); break;
+        case 'worktree':
+            if (!rest) console.log(c.muted('  Uso: /worktree <nome>  (cria ../<repo>-<nome> numa branch nova e entra)'));
+            else entrarNoWorktree(rest.split(/\s+/)[0]);
+            break;
+
+        /* /projetos e /project sem nome são a MESMA lista: antes o /project só
+           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 'projects': {
+            const lista = extra.listarProjetos(cfg.ROOT_DIR);
+            const numero = /^\d+$/.test(rest) ? Number(rest) : 0;
+            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];
+                    if (!alvo) { console.log(c.err(`  Não há projeto ${numero}. São ${lista.length}.`)); break; }
+                    entrarNoProjeto(alvo.dir, 'projeto');
+                    console.log(c.ok(`  Trabalhando em ${alvo.nome}`) + c.muted(`  (${shortPath(alvo.dir)})`));
+                    refreshPrompt();
+                    break;
+                }
+                console.log('');
+                const largura = Math.min(34, Math.max(...lista.map((x) => x.nome.length)));
+                lista.forEach((x, i) => {
+                    const aqui = x.nome === state.currentProject;
+                    const nomeCol = ui.padRight(ui.truncate(aqui ? c.brand(x.nome) : c.white(x.nome), largura), largura);
+                    console.log(`  ${aqui ? c.brand('●') : ' '} ${c.dim(String(i + 1).padStart(2))}  ${nomeCol}  `
+                        + 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)} · /projects 1 entra no primeiro · /new <descrição> começa outro`));
+                break;
+            }
+            const dir = cfg.createProjectDir(rest);
+            entrarNoProjeto(dir, 'projeto');
+            console.log(c.ok(`Projeto: ${state.currentProject}`) + c.muted(`  (${dir})`));
+            refreshPrompt();
+            break;
+        }
+
+        // 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': {
+            if (!rest) {
+                const de = {
+                    padrao: 'a pasta padrão do PrimoCode',
+                    '/dir': 'você escolheu com /dir',
+                    detectada: 'você falou dela no pedido',
+                    projeto: 'projeto do PrimoCode',
+                };
+                console.log(`  ${c.white(shortPath(projectDir()))}`);
+                console.log(c.muted(`  ${de[state.workDirOrigem] || 'pasta atual do terminal'}`));
+                console.log(c.dim('  /dir <caminho> muda · /project <nome> cria uma nova em ~/primocode'));
+                break;
+            }
+
+            // ~ e caminho relativo resolvem contra a pasta ativa, não contra o
+            // cwd do processo: depois de um /dir, "src" é dentro dela.
+            const bruto = rest.replace(/^~(?=$|[/\\])/, os.homedir());
+            const alvo = path.resolve(projectDir(), bruto);
+
+            if (!fs.existsSync(alvo)) {
+                if (!(await confirm(`A pasta ${shortPath(alvo)} não existe. Criar?`))) {
+                    console.log(c.muted('  Nada mudou.'));
+                    break;
+                }
+                try { fs.mkdirSync(alvo, { recursive: true }); }
+                catch (e) { console.log(c.err(`  Não consegui criar: ${e.message}`)); break; }
+            } else if (!fs.statSync(alvo).isDirectory()) {
+                console.log(c.err(`  ${shortPath(alvo)} é um arquivo, não uma pasta.`));
+                break;
+            }
+
+            // A home e a raiz do disco são recusadas por padrão em qualquer
+            // lugar do código — aqui o pedido é explícito, então pergunta em vez
+            // de recusar, mas pergunta mesmo: é onde um write_file erra feio.
+            if (!pastaSegura(alvo)) {
+                console.log(c.warn(`  ${shortPath(alvo)} é a sua home ou a raiz do disco.`));
+                if (!(await confirm('O agente pode criar e editar arquivos aí. Confirma?'))) {
+                    console.log(c.muted('  Nada mudou.'));
+                    break;
+                }
+            }
+
+            entrarNoProjeto(alvo, '/dir');
+            const quantos = (() => { try { return fs.readdirSync(alvo).length; } catch { return 0; } })();
+            console.log(c.ok(`  Trabalhando em ${shortPath(alvo)}`) + c.muted(`  (${quantos} ${quantos === 1 ? 'item' : 'itens'})`));
+            refreshPrompt();
+            break;
+        }
+
+        /* Quando ele pergunta antes de agir. Os três modos e o porquê de cada
+           um estão em lib/permission/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 'taste': {
+            const G = require('../plugin/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.')); }
+                break;
+            }
+            if (a === 'refazer') {
+                console.log(c.muted('  Abri uma tela no navegador (até 10 min). Feche ou pule pra voltar.'));
+                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 (/^provar\b/.test(a)) {
+                const assunto = String(rest).trim().replace(/^provar\s*/i, '') || 'um vídeo de apresentação';
+                const P = require('../plugin/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 'memory': {
+            const M = require('../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: /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: /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 · /memory esquecer <nome> · /memory pasta`));
+            break;
+        }
+        case 'sandbox': {
+            const sb = require('../permission/sandbox.js');
+            const [a, b] = String(rest || '').toLowerCase().split(/\s+/);
+            if (a === 'on' || a === 'off') sb.salvar({ ligado: a === 'on' });
+            else if (a === 'rede' && (b === 'on' || b === 'off')) sb.salvar({ rede: b === 'on' });
+            else if (a === 'ssh' && (b === 'on' || b === 'off')) sb.salvar({ ssh_agent: b === 'on' });
+            else if (a && a !== 'status') { console.log(c.err('Uso: /sandbox [on|off|rede on|rede off|ssh on|ssh off|status]')); break; }
+            const e = sb.estado();
+            console.log(c.muted('  Sandbox: ') + (e.ativo ? c.ok('ligado') : c.warn(e.ligado ? 'ligado, mas sem mecanismo neste computador' : 'desligado'))
+                + c.muted(` · mecanismo: ${e.mecanismo || 'nenhum'} · rede: ${e.rede ? 'aberta' : 'bloqueada'} · ssh-agent: ${e.ssh_agent ? 'liberado' : 'fora'} · modo: ${e.modo}`));
+            console.log(c.dim('  Escreve só no projeto, /tmp e ~/.primocode/cache; não lê ~/.ssh, ~/.aws, ~/.npmrc, a sua conta do PrimoCode e outros arquivos de credencial, nem .env*.'));
+            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 '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',
+                livre: 'nunca pergunta — nem antes do que não tem volta',
+                plano: 'só lê: recusa escrita e comando que muda coisa; investiga e entrega o plano',
+            };
+            const atual = perigo.normalizarModo(state.config.permissoes);
+            if (!rest) {
+                console.log(c.muted('  Agora: ') + c.brand(atual) + c.muted(' — ' + DIZ[atual]));
+                for (const m of perigo.MODOS) console.log(`  ${m === atual ? c.brand('● ' + m) : c.muted('○ ' + m)}  ${c.dim(DIZ[m])}`);
+                console.log(c.dim('  Use /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: /perms auto|perguntar|livre|plano'));
+                break;
+            }
+            const m = perigo.normalizarModo(pedido);
+            state.config.permissoes = m;
+            cfg.saveConfig({ permissoes: m });
+            console.log(c.ok(`  Permissões: ${m}`) + c.muted(' — ' + DIZ[m]));
+            if (m === 'livre') {
+                console.log('  ' + c.warn('▸▸ Atenção: ele vai apagar, forçar push e usar sudo sem te perguntar.'));
+                console.log('  ' + c.warn('   O que der errado pode não ter volta. /perms auto desfaz.'));
+            }
+            break;
+        }
+
+        case 'mode': {
+            const m = rest.toLowerCase();
+            if (['primocode', 'chat', 'auto'].includes(m)) {
+                state.mode = m;
+                state.modoEfetivo = null;
+                cfg.saveConfig({ mode: m });
+                console.log(c.ok(`Modo: ${m}`) + (m === 'auto'
+                    ? c.muted('  — escolho por pedido: conversa vai pro chat, tarefa vai pro agente')
+                    : ''));
+                refreshPrompt();
+            } else console.log(c.err('Uso: /mode primocode|chat|auto'));
+            break;
+        }
+
+        // O /model virou /effort: você escolhe o ESFORÇO num slider (←/→,
+        // Enter confirma, Esc cancela) e o modelo sai daí. Com argumento
+        // ("/effort high") aplica direto, para quem já sabe o que quer.
+        case 'effort': {
+            const pedido = rest.toLowerCase().trim();
+            if (pedido) {
+                if (!effort.NOMES.includes(pedido)) {
+                    console.log(c.err(`Esforço inválido. Use: ${effort.NOMES.join(' | ')}`));
+                    break;
+                }
+                aplicarEffort(pedido);
+                break;
+            }
+            const escolhido = await sliderEffort(state.config.effort);
+            if (escolhido) aplicarEffort(escolhido);
+            else console.log(c.muted('  Nada mudou.'));
+            break;
+        }
+
+        // Continua existindo para quem fixa um ID do OpenRouter na unha; o
+        // caminho normal é o /effort.
+        case 'model': {
+            const m = rest.toLowerCase();
+            if (m.includes('/')) {
+                state.config.model = m;
+                cfg.saveConfig({ model: m });
+                console.log(c.ok(`Modelo fixo: ${m}`) + c.muted('  precisa aceitar tools no modo primocode'));
+                console.log(c.dim('  Para voltar ao normal, use /effort.'));
+            } else {
+                console.log(c.muted('  O modelo agora vem do esforço. Use ') + c.brand('/effort') + c.muted('.'));
+                console.log(c.dim(`  Agora: ${state.config.effort} → modelo ${effort.modeloDe(state.config.effort)}`));
+            }
+            break;
+        }
+
+        case 'attach': {
+            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.
+                const content = fs.readFileSync(path.resolve(projectDir(), rest), 'utf-8');
+                state.attachedFiles.push({ path: rest, content });
+                console.log(c.ok(`Anexado: ${rest} (${tools.fmtBytes(content.length)})`));
+                refreshPrompt();
+            } catch { console.log(c.err(`Não consegui ler: ${rest}`)); }
+            break;
+        }
+
+        case 'init': {
+            const alvo = path.join(projectDir(), 'PRIMO.md');
+            if (fs.existsSync(alvo) && !(await confirm(`Já existe um PRIMO.md em ${shortPath(projectDir())}. Escrever outro por cima?`))) {
+                console.log(c.muted('  Deixei o PRIMO.md como estava.'));
+                break;
+            }
+            // Escrever arquivo pede o agente: no modo chat (ou num auto que
+            // achasse que é conversa) o /init só responderia um texto.
+            const modoAntes = state.mode;
+            state.mode = 'primocode';
+            // o /init reescreve o PRIMO.md inteiro: as regras do /regra voltam pro topo depois
+            const regras = require('../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;
+
+
+        // A lista vem de lib/skill/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.
+
+        /* ── /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 'undo': {
+            const cps = checkpoint.lista(projectDir());
+            const BK = require('../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'}`)
+                    + (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('../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: /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))}`);
+            const previa = checkpoint.previa(projectDir(), n);
+            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; }
+            try { require('../placar.js').desfez(); } catch { /* placar é conveniência */ }   // desfez logo depois do pedido: conta como perda do modelo
+            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/session/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('../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('../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('../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('../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('../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('../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('../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('../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('../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. */
+        /* /review: duas passadas (lib/review.js) — achar e depois conferir cada achado. /review rápido = o comando de fábrica de uma passada. */
+        case 'review': {
+            if (/^(r[aá]pido|simples)\b/i.test(rest)) {
+                const fabrica = comandosDaPessoa().find((x) => x.nome === 'review');
+                if (fabrica) { await sendPrompt(comandosLib.expandir(fabrica, rest.replace(/^\S+\s*/, ''))); break; }
+            }
+            const R = require('../review.js');
+            const chamar = async (prompt) => {
+                let resposta = '';
+                await api.requestChat(state.config.server, { prompt, history: [], model: state.config.model, token: state.config.token },
+                    (evt) => { if (evt.delta) resposta += evt.delta; });
+                return resposta;
+            };
+            const sp = new Spinner('revisando o que mudou (passada 1: achar)').start();
+            let r;
+            try { r = await R.revisar({ dir: projectDir(), foco: rest, chamar }); } catch (e) { r = { ok: false, erro: String((e && e.message) || e) }; }
+            sp.stop();
+            console.log('\n' + R.formatar(r).split('\n').map((l) => '  ' + l).join('\n') + '\n');
+            break;
+        }
+        case 'explain': {
+            const E = require('../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('../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/permission/perigo.js → lib/trava.js). */
+        case 'lock': {
+            const T = require('../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('../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('../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;
+        }
+        case 'testar-app': {
+            const A = require('../plugin/autoteste.js');
+            const r = await A.testar({ dir: projectDir(), log: (l) => console.log(c.muted('  ' + l)), consertar: (erros, prints) => sendPrompt(A.pedidoDeConserto(erros, prints)) });
+            console.log(r.ok ? c.ok('  O app passou no teste.') : c.warn('  ' + r.erro));
+            break;
+        }
+        /* /placar: qual modelo grátis acerta mais em cada tipo de tarefa, neste computador (lib/placar.js). */
+        case 'placar': {
+            const P = require('../placar.js');
+            if (/^(zerar|limpar|reset)$/i.test(rest.trim())) { P.zerar(); console.log(c.ok('  Placar zerado. Ele começa a aprender de novo.')); break; }
+            console.log(P.texto(P.ler()).split('\n').map((l) => '  ' + l.replace(/^ {2}/, '')).join('\n'));
+            break;
+        }
+        case 'pesquisar': {
+            if (!rest) { console.log(c.muted('  Uso: /pesquisar <tema>')); break; }
+            const r = await require('../plugin/pesquisar.js').pesquisar({ tema: rest, dir: projectDir(), log: (l) => console.log(c.muted('  ' + l)) });
+            console.log(r.ok ? c.ok(`  Relatório: ${r.arquivo}`) : c.warn('  ' + r.erro));
+            break;
+        }
+        /* /schedule: pedido que roda sozinho no Mac, pelo launchd (lib/agendar.js). */
+        case 'schedule': {
+            const A = require('../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('../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('../session/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 'read': {
+            if (!rest) { console.log(c.err('Uso: /read <arquivo>')); break; }
+            try {
+                const content = fs.readFileSync(path.resolve(projectDir(), rest), 'utf-8');
+                console.log(c.muted(`\n--- ${rest} ---\n`));
+                console.log(content.length > 2000 ? content.slice(0, 2000) + '\n…' : content);
+            } catch { console.log(c.err(`Não consegui ler: ${rest}`)); }
+            break;
+        }
+
+        case 'run': {
+            if (!rest) { console.log(c.err('Uso: /run <comando>')); break; }
+            console.log(c.muted(`$ ${rest}`));
+            const result = await tools.runShell(rest, 60000, projectDir());
+            if (result.stdout) console.log(result.stdout);
+            if (result.stderr) console.log(c.err(result.stderr));
+            if (result.code !== 0) console.log(c.err(`exit ${result.code}`));
+            break;
+        }
+
+        /* /novo: projeto novo por ORDEM da pessoa. Sem ele, "crie um site de
+           receitas" pode cair dentro de "site-receitas-velho" porque o nome
+           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 '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 /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 'open': {
+            if (!rest) {
+                const pastaAtual = projectDir();
+                if (path.resolve(pastaAtual) === path.resolve(cfg.ROOT_DIR)) {
+                    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>. O app devia estar rodando? /port diz por que não abre.'));
+                    break;
+                }
+                const r = await tools.openInBrowser(alvo.url || alvo.caminho);
+                if (r && r.ok === false) { console.log(c.err(`  Não consegui abrir: ${r.error}`)); break; }
+                console.log(c.ok(`  Aberto: ${alvo.url || shortPath(alvo.caminho)}`) + c.dim(`  (${alvo.porque})`));
+                break;
+            }
+            const target = /^https?:\/\//i.test(rest) ? rest : path.resolve(projectDir(), rest);
+            await tools.openInBrowser(target);
+            console.log(c.ok(`Aberto: ${rest}`));
+            break;
+        }
+
+        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 });
+            console.log(c.ok(`Feito! Vou te chamar de ${rest}.`));
+            break;
+        }
+
+        /* A galeria: todos lado a lado, número e nome em cima. Escolhe por
+           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/plugin/marca-kit.js): /marca criar|listar|usar <nome> [aqui]|mostrar|apagar <nome>
+        case 'brand': {
+            const kit = require('../plugin/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': {
+            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;
+                state.config.reacoes = quer;
+                cfg.saveConfig({ reacoes: quer });
+                console.log(c.ok(`  Reações do mascote: ${quer ? 'ligadas' : 'desligadas'}`)
+                    + (quer ? '  ' + ui.reacao(state.config.mascot, 'feliz').trim() : ''));
+                break;
+            }
+            let pedido = rest;
+            if (!pedido) {
+                console.log('');
+                console.log(ui.galeriaMascotes(state.config.mascot || 'primo', process.stdout.columns || 80));
+                if (!process.stdin.isTTY || state.semTerminal) {
+                    console.log(c.muted('  Escolha: /mascot <nome ou número>') + c.dim('  · /mascot reacoes off desliga o rostinho'));
+                    break;
+                }
+                pedido = String(await ask(`  ${c.brand('?')} Nome ou número ${c.dim('(Enter mantém)')}: `)).trim();
+                if (!pedido) { console.log(c.muted('  Nada mudou.')); break; }
+            }
+            const m = ui.resolverMascote(pedido);
+            if (!m) { console.log(c.err(`  Não conheço "${pedido}".`) + c.dim(`  São: ${ui.MASCOTES.join(', ')}`)); break; }
+            state.config.mascot = m;
+            cfg.saveConfig({ mascot: m });
+            const info = ui.mascoteInfo(m);
+            console.log('');
+            const arte = ui.mascot(m);
+            arte.forEach((l, i) => console.log('  ' + l + (i === 0 ? '  ' + c.bold(c.white(info.nome))
+                : i === 1 ? '  ' + c.dim(`"${info.frase}"`) : '')));
+            console.log(c.ok(`\n  Mascote: ${m}`));
+            break;
+        }
+
+        case 'config': {
+            console.log('');
+            console.log(`  ${c.muted('nome')}      ${c.white(state.config.userName || '(nenhum)')}`);
+            console.log(`  ${c.muted('mascote')}   ${c.white(state.config.mascot || 'primo')}${c.dim(state.config.reacoes === false ? '  · sem reações' : '  · com reações')}`);
+            console.log(`  ${c.muted('esforço')}   ${c.white(state.config.effort)}${c.dim('  · /effort muda')}`);
+            console.log(`  ${c.muted('modelo')}    ${c.white(state.config.model)}${c.dim('  (vem do esforço)')}`);
+            console.log(`  ${c.muted('modo')}      ${c.white(state.mode)}`);
+            console.log(`  ${c.muted('servidor')}  ${c.dim(state.config.server)}`);
+            console.log(c.muted(`\n  ${cfg.CONFIG_FILE}`));
+            break;
+        }
+
+        // Limpar aqui não apaga o que já subiu: encerra ESTA conversa e a
+        // próxima pergunta abre outra. Apagar do histórico é decisão da
+        // pessoa, e ela toma no app — não de raspão num comando de limpar tela.
+        /* Resume a conversa por ordem da pessoa. Diferente do /clear: aqui
+           nada é esquecido — o que já passou vira resumo e o fim continua
+           cru, então dá para seguir de onde parou. */
+        case 'compact': {
+            if (!state.history.length) {
+                console.log(c.muted('  A conversa está vazia — não há o que resumir.'));
+                break;
+            }
+            const antes = memoria.usoDoContexto(state.memoria, state.history);
+            await comprimirConversa(true);
+            const depois = memoria.usoDoContexto(state.memoria, state.history);
+            if (depois.tokens >= antes.tokens) {
+                // Pode não haver o que dobrar (conversa curta, ou o servidor
+                // recusou). Dizer isso é melhor que fingir que encolheu.
+                console.log(c.muted('  Não deu para encolher mais desta vez.'));
+            } else {
+                console.log(c.ok('  Conversa resumida.')
+                    + c.muted(`  ctx ${antes.pct}% → ${depois.pct}%`));
+            }
+            refreshPrompt();
+            break;
+        }
+
+        case 'clear': state.history = []; state.memoria = memoria.nova();
+            state.gravador.zerar(); console.log(c.ok('Conversa limpa.')); break;
+        case 'cls': process.stdout.write('\x1Bc'); break;
+
+        /* 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': {
+            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),
+                provedor: () => provedorLocal.atual(),
+                conferirChave: (id, chave) => provedorLocal.conferir(id, chave),
+                cliInstalado: (id) => require('../provider/local/motor-cli').instalado(id),
+                acharChrome: () => require('../browser').findChrome(),
+                raiz: cfg.ROOT_DIR,
+                arquivoConfig: cfg.CONFIG_FILE,
+            });
+            sp.stop();
+            console.log('');
+            for (const l of linhas) {
+                const marca = l.ok === true ? c.ok('✓') : l.ok === false ? c.err('✗') : c.dim('·');
+                console.log(`  ${marca} ${ui.padRight(c.white(l.item), 18)}${ui.truncate(c.muted(l.detalhe || ''), Math.max(20, (process.stdout.columns || 80) - 23))}`);
+                if (l.conserto) console.log(`    ${c.dim('→ ' + l.conserto)}`);
+            }
+            for (const l of require('../preparar.js').estudioLinhas()) linhas.push(l), console.log(`  ${l.ok === true ? c.ok('✓') : l.ok === false ? c.err('✗') : c.dim('·')} ${ui.padRight(c.white(l.item), 18)}${c.muted(l.detalhe || '')}`), l.conserto && console.log(`    ${c.dim('→ ' + l.conserto)}`);
+            const ruins = linhas.filter((l) => l.ok === false).length;
+            console.log(ruins ? c.warn(`\n  ${ruins} ${ruins === 1 ? 'coisa para arrumar' : 'coisas para arrumar'}.`) : c.ok('\n  Tudo certo.'));
+            break;
+        }
+
+        case 'usage': {
+            const Lim = require('../config/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);
+            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)'))}${l.emCache ? c.dim(' · ') + c.ok(extra.fmtNumero(l.emCache) + ' do cache') : ''}`);
+            }
+            if (linhas.length > 1) {
+                console.log(`  ${c.white(ui.padRight('Total', 22))}${c.muted(ui.padRight(total.pedidos + ' pedidos', 12))}`
+                    + `${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;
+        }
+
+        /* O que o agente deixou de pé com run_background (lib/fundo.js). */
+        case 'tasks': {
+            const fundo = require('../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('../plugin/estudio/exportar.js').main(rest.split(/\s+/).filter(Boolean)).texto);
+            break;
+        }
+
+        /* /exportar: a conversa vira um .md local, com chave e senha escondidas (lib/session/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('../session/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 '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.'));
+                console.log(c.dim('  /chats mostra as conversas inteiras da sua conta.'));
+                break;
+            }
+            console.log('');
+            const largura = Math.max(30, (process.stdout.columns || 80) - 34);
+            for (const e of achados) {
+                const quando = new Date(e.ts).toLocaleString('pt-BR', { dateStyle: 'short', timeStyle: 'short' });
+                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}"` : ''} · /history <termo> filtra · /chats abre conversas`));
+            break;
+        }
+
+        case 'keys': {
+            console.log('');
+            for (const [tecla, faz] of extra.ATALHOS) console.log(`  ${c.brand(ui.padRight(tecla, 20))}${c.muted(faz)}`);
+            break;
+        }
+
+
+        /* ── AS SKILLS ───────────────────────────────────────────────────
+         * `/skills` lista, `/install-skill` traz de um arquivo, e
+         * `/marketplace` é a tela onde se navega e liga.
+         *
+         * Nenhum dos três pede confirmação para ligar ou desligar: skill é
+         * TEXTO, e o pior que um texto ruim faz é dar um conselho ruim ao
+         * 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);
+            console.log('');
+            console.log(c.bold(c.white('  Skills')) + c.dim(`  ${ligadas.length} de ${lista.length} ligadas`));
+            console.log('');
+            for (const s of lista) {
+                const marca = s.ligada ? c.ok('●') : c.dim('○');
+                console.log(`  ${marca} ${c.white(ui.padRight(s.titulo, 28))}`
+                    + c.dim(ui.truncate(s.descricao, (process.stdout.columns || 80) - 36)));
+            }
+            console.log('');
+            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;
+        }
+
+
+        /* ── /voice ──────────────────────────────────────────────────────
+         * O ouvido e a boca são Python (voz/primo_voz); o cérebro é este
+         * terminal. Ver entradaDeVoz no main() e lib/plugin/voz.js.
+         */
+        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
+               mesmo roteador de conversa — e a resposta final sai em voz alta.
+               O terminal continua seu: dá para falar e digitar ao mesmo tempo.
+
+               Desligar é o primeiro caso de propósito: quem quer fechar o
+               microfone quer AGORA, sem esbarrar em checagem de dependência. */
+            const argVoz = (rest || '').trim();
+            // Só o painel (HUD em tela cheia no Mac; quadro no terminal fora dele).
+            if (/^painel$/i.test(argVoz)) {
+                const py = vozModo.python();
+                if (!py) { console.log(c.err('  O painel precisa do Python 3.')); break; }
+                if (vozPainel) { try { vozPainel.processo.kill(); } catch {} vozPainel = null; }
+                vozPainel = vozModo.abrirPainel({ python: py });
+                console.log(c.muted(vozPainel.tela ? '  Tela do Primo aberta — ESC esconde.' : '  Sem o painel gráfico aqui: rode `primocode voz painel` num terminal separado.'));
+                break;
+            }
+            // /voice nome <Nome>: a pessoa dá o nome ao assistente (o nome não ativa nada: o modo voz só abre no clique).
+            const mNome = argVoz.match(/^nome\s+(.{2,20})$/i);
+            if (mNome) {
+                const salvo = vozModo.definirNome(mNome[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 (/^(parar|stop|off|sair)$/i.test(argVoz)) {
+                if (vozPainel) { try { vozPainel.processo.kill(); } catch {} vozPainel = null; }
+                if (!vozEmEspera) { console.log(c.muted(vozPainel === null ? '  Modo voz e painel fechados.' : '  O modo voz não está ligado.')); break; }
+                try { vozEmEspera.processo.kill(); } catch {}
+                vozEmEspera = null;
+                console.log(c.muted('  Modo voz desligado. O microfone fechou.'));
+                break;
+            }
+            if (vozEmEspera) {
+                console.log(c.muted('  O modo voz já está ouvindo — é só falar.') + c.dim('  /voice parar desliga.'));
+                break;
+            }
+
+            // "Instale tudo que precisa, rode tudo que precisa." Da segunda vez
+            // em diante tudo já está lá, e isto leva um segundo.
+            const sp = new Spinner('preparando o modo voz').start();
+            const prep = await vozModo.preparar((msg) => { sp.text = msg; });
+            sp.stop();
+            if (!prep.ok) {
+                console.log(c.err(`  ${prep.error}`));
+                if (prep.comoResolver) console.log(c.muted(`  ${prep.comoResolver}`));
+                for (const a of prep.avisos) console.log(c.dim(`  ${a}`));
+                break;
+            }
+            for (const a of prep.avisos) console.log(c.dim(`  ${a}`));
+            if (process.platform === 'darwin') { try { vozModo.instalarApp({ python: prep.python }); } catch { /* o app é bônus */ } }
+
+            const sessao = vozModo.abrir({
+                python: prep.python,
+                servidor: state.config.server,
+                token: state.config.token,
+                voz: state.config.voz || 'antonio',
+                aoPronto: () => {
+                    console.log('  ' + c.bold(c.brand('🎙 Modo voz ligado')) + c.muted(' — é só falar. A resposta sai em voz alta.'));
+                    console.log('  ' + c.dim('Falar por cima corta a voz · digitar continua valendo · /voice parar desliga'));
+                },
+                aoParar: () => { try { require('../session/runner/act.js').interromper(); } catch { /* nada rodando */ } },
+                aoOuvir: (texto) => { if (entradaDeVoz) entradaDeVoz(texto); },
+                mostrar: (texto) => console.log('  ' + c.dim(texto)),
+            });
+            vozEmEspera = sessao;
+            require('../plugin/voz-ponte').escutar((nome, args) => sessao.ferramenta(nome, args));
+            sessao.pronto.then((r) => {
+                if (vozEmEspera === sessao) vozEmEspera = null;
+                if (r && !r.ok) console.log(c.err(`  o modo voz fechou: ${r.error}`));
+            });
+            break;
+        }
+
+
+        /* ── /connectors ─────────────────────────────────────────────────
+         * Só mostra. Não há o que configurar — os conectores vivem no
+         * servidor, com as chaves dele, e é assim de propósito: a promessa do
+         * produto é que a API já vem pronta.
+         *
+         * Então por que existe? Porque "a IA está lenta hoje" e "ele errou o
+         * código" têm causas diferentes e invisíveis: qual conector atendeu.
+         * Sem esta tela, a única resposta possível é dar de ombros. Com ela,
+         * dá para ver que o preferido está fora e outro assumiu — e essa é a
+         * primeira pergunta de todo suporte.
+         */
+        case 'connectors': {
+            const sp = new Spinner('lendo os conectores').start();
+            let dados = null;
+            try {
+                dados = await api.getConectores(state.config.server, state.config.token);
+            } catch (e) { sp.stop(); console.log(c.err(`  Não deu para ler: ${ui.friendlyError(e)}`)); break; }
+            sp.stop();
+
+            const lista = (dados && dados.conectores) || [];
+            if (!lista.length) { console.log(c.muted('  O servidor não listou conector nenhum.')); break; }
+
+            console.log('');
+            console.log(c.bold(c.white('  Conectores')) + c.dim('  — quem atende os seus pedidos'));
+            console.log('');
+            for (const cx of lista) {
+                const marca = cx.ligado ? c.ok('●') : c.dim('○');
+                const selos = [
+                    cx.gratis ? c.dim('grátis') : c.warn('pago'),
+                    cx.faz && cx.faz.ferramentas ? c.dim('ferramentas') : c.dim('só conversa'),
+                ].join(c.dim(' · '));
+                console.log(`  ${marca} ${c.white(ui.padRight(cx.nome, 24))}${selos}`);
+                console.log(`    ${c.dim(ui.truncate(cx.porque || '', (process.stdout.columns || 80) - 6))}`);
+            }
+            const dePe = lista.filter((x) => x.ligado).length;
+            console.log('');
+            console.log(c.muted(`  ${dePe} de ${lista.length} de pé.`)
+                + c.dim('  Quem está fora não some da fila: entra assim que o servidor tiver a chave.'));
+            console.log(c.dim('  Não há nada para você configurar — a API vem com o PrimoCode.'));
+            break;
+        }
+
+        /* A janela (/rc, /ide, `primo --app`) saiu na 10.0: o PrimoCode é
+           o terminal. O nome antigo ainda responde, uma linha, para o dedo
+           viciado não achar que a atualização quebrou. */
+        case 'rc':
+        case 'ide':
+            console.log(c.muted('  A janela saiu na 10.0 — o PrimoCode agora é só o terminal.'));
+            break;
+
+        /* A conta do PrimoCode (lib/config/conta.js). Padrão: abre o navegador, onde
+           se cria a conta, entra ou redefine a senha. `/login senha` é o
+           caminho sem navegador (SSH, servidor). */
+        case 'login': {
+            const partes = String(rest || '').trim().split(/\s+/);
+            const jaEsta = conta.atual();
+            if (jaEsta && !partes.includes('trocar')) {
+                console.log(c.muted('  Já conectado como ') + c.brand(jaEsta.email || (jaEsta.uid.slice(0, 12) + '…'))
+                    + c.muted(` · plano ${jaEsta.plano}`));
+                console.log(c.dim('  Para entrar com outra conta: ') + c.brand('/login trocar'));
+                break;
+            }
+            if (jaEsta || conta.doConectaAntigo()) conta.sair();
+
+            let r;
+            if (partes.includes('senha')) {
+                const email = String(await ask(c.brand('  E-mail: ')) || '').trim();
+                if (!email) { console.log(c.muted('  Login cancelado.')); break; }
+                const senha = await askSecret(c.brand('  Senha: '));
+                if (!senha) { console.log(c.muted('  Login cancelado.')); break; }
+                const sp = new Spinner('entrando').start();
+                r = await conta.entrar({ email, senha });
+                sp.stop();
+            } else {
+                const sp = new Spinner('esperando você entrar no navegador').start();
+                r = await conta.entrarPeloNavegador({
+                    aviso: (url) => {
+                        sp.stop();
+                        console.log(c.muted('  Abri o navegador para você criar a conta ou entrar.'));
+                        console.log(c.dim('  Não abriu? Copie: ') + c.brand(url));
+                        console.log(c.dim('  Sem navegador aqui? ') + c.brand('/login senha'));
+                        sp.start();
+                    },
+                });
+                sp.stop();
+            }
+            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('/account plans')));
+            return r;
+        }
+
+        /* O histórico da conta — o MESMO que o app desktop e o celular
+           mostram. Sem número, lista; com número, abre e continua dali. */
+        case 'chats': {
+            if (!conta.atual()) {
+                console.log(c.muted('  Não conectado. ') + c.brand('/login')
+                    + c.muted(' para ver suas conversas aqui, no app e no celular.'));
+                break;
+            }
+            const sp = new Spinner('lendo suas conversas').start();
+            const l = await nuvem.listarConversas({ limite: 20 });
+            sp.stop();
+            if (!l.ok) { console.log(c.err(`  ${l.error}`)); break; }
+            if (!l.conversas.length) {
+                console.log(c.muted('  Nenhuma conversa salva ainda. A próxima já fica.'));
+                break;
+            }
+            if (!rest) {
+                console.log(c.white('\n  Suas conversas'));
+                l.conversas.forEach((x, i) => {
+                    const quando = x.atualizada
+                        ? new Date(x.atualizada).toLocaleDateString('pt-BR') : '—';
+                    console.log('  ' + c.dim(String(i + 1).padStart(2))
+                        + ' ' + c.white(x.titulo.slice(0, 52).padEnd(52))
+                        + c.dim(`${String(x.mensagens).padStart(3)} msg  ${quando}`));
+                });
+                console.log(c.dim('\n  /chats 1  abre a primeira e continua dela.'));
+                break;
+            }
+            const n = Number(rest);
+            const alvo = l.conversas[n - 1];
+            if (!alvo) { console.log(c.err(`  Não achei a conversa ${rest}.`)); break; }
+            const conv = await abrirConversa(alvo);
+            if (!conv.ok) { console.log(c.err(`  ${conv.error}`)); break; }
+            console.log(c.ok(`  ${alvo.titulo}`)
+                + c.muted(`  · ${conv.mensagens.length} mensagens carregadas`));
+            console.log(c.dim('  Pode continuar daqui — o que você disser volta pro app e pro celular.'));
+            break;
+        }
+
+        case 'logout': {
+            if (!conta.atual()) { console.log(c.muted('  Você não está conectado.')); break; }
+            conta.sair();
+            console.log(c.ok('  Desconectado deste computador.')
+                + c.dim('  A conta continua intacta; entre de novo com /login.'));
+            break;
+        }
+
+        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.'));
+                break;
+            }
+            const sp = new Spinner('conferindo').start();
+            // O plano guardado é a foto do último login: quem sabe é o documento da conta.
+            const s = await conta.sessao();
+            sp.stop();
+            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('/account plans')));
+            } else if (s.offline) {
+                console.log(c.white('  Plano   ') + c.muted(eu.plano) + c.dim('  (sem rede — último conhecido)'));
+            } else {
+                console.log(c.err(`  ${s.error}`));
+            }
+            console.log(c.dim('  Senha: ') + c.brand(`${conta.SITE}/entrar#esqueci`));
+            break;
+        }
+
+
+        case 'uninstall': {
+            if (await confirm('Remover o PrimoCode? Seus projetos em ~/primocode NÃO serão apagados.')) {
+                await tools.uninstall();
+            } else console.log(c.muted('Cancelado.'));
+            break;
+        }
+
+        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': 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
+         * Claude Code ou o Codex, colava uma chave de API, e só então o
+         * agente pensava.
+         *
+         * Isso acabou. A API vem configurada no produto: quem entra na conta
+         * já tem motor, e não há provedor nenhum para escolher.
+         *
+         * Eles não somem calados. Quem tem o dedo viciado em `/claude` e
+         * bate num "comando não existe" conclui que a atualização quebrou
+         * alguma coisa — e não vai procurar no /help, vai desinstalar. */
+        case 'api': {
+            await comandoApi(rest);
+            break;
+        }
+
+        /* 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': {
+            if (/^(off|sair|desligar|parar)$/i.test(rest)) {
+                if (!state.servidorAntes) { console.log(c.muted('  O /offline não está ligado.')); break; }
+                offline.desligar();
+                state.config.server = state.servidorAntes;
+                state.servidorAntes = null;
+                console.log(c.ok('  Voltei ao servidor de antes: ') + c.dim(state.config.server));
+                break;
+            }
+            if (state.servidorAntes) { console.log(c.muted('  Já está no servidor local: ') + c.dim(state.config.server) + c.muted(' · /offline off volta')); break; }
+            const chaves = offline.prepararEnv();
+            if (chaves.criado || !chaves.temChave) {
+                console.log(c.warn(`  ${chaves.criado ? 'Criei' : 'Falta chave em'} ${chaves.arquivo}`));
+                console.log(c.muted('  Cole nele as chaves do Render (primocode-server → Environment), uma por linha:'));
+                console.log(c.dim('  GROQ_API_KEY=…  OPENROUTER_API_KEY=…  GEMINI_API_KEY=…'));
+                console.log(c.muted('  Depois rode ') + c.brand('/offline') + c.muted(' de novo.'));
+                break;
+            }
+            const dir = offline.acharServidor({ pedido: rest });
+            const sp = new Spinner('subindo o servidor aqui').start();
+            const r = await offline.ligar({ dir, env: chaves.env });
+            sp.stop();
+            if (!r.ok) {
+                console.log(c.err('  ' + r.error));
+                if (r.comoResolver) console.log(c.dim('  → ' + r.comoResolver));
+                break;
+            }
+            state.servidorAntes = state.config.server;
+            state.config.server = r.url;
+            console.log(c.ok(`  Servidor ${r.versao || ''} ${r.reaproveitado ? 'que já estava de pé' : 'rodando aqui'}: `) + c.dim(r.url));
+            console.log(c.dim(`  ${dir || ''}${dir ? ' · ' : ''}chaves: ${chaves.nomes.join(', ')}${r.reaproveitado ? '' : ' · log em ' + offline.ARQUIVO_LOG}`));
+            if (provedorLocal.atual()) console.log(c.warn('  Atenção: o /api está ligado e fala direto com a IA. Para usar o servidor local, /api off.'));
+            console.log(c.muted('  Vale até fechar o PrimoCode. ') + c.brand('/offline off') + c.muted(' volta antes.'));
+            break;
+        }
+
+        /* Os comandos da pessoa: lista, e explica como fazer o dela. */
+        case 'styles': {
+            // Os kits de estilo de motion (lib/plugin/kits.js): a lista no terminal e a galeria (capa + preview + nome).
+            const K = require('../plugin/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('../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]);
+                if (!r.ok) { console.log(c.err(`  ${r.error}`)); break; }
+                cacheComandos.em = 0;
+                console.log(c.ok(`  Criado: /${path.basename(r.arquivo, '.md')}`) + c.muted('  abra e escreva o pedido:'));
+                console.log('  ' + c.white(r.arquivo));
+                break;
+            }
+            const lista = comandosDaPessoa();
+            console.log(c.white('\n  Seus comandos'));
+            for (const x of lista) {
+                console.log(`  ${c.brand(ui.padRight('/' + x.nome, 14))}${c.dim(ui.padRight(x.origem, 11))}${c.muted(x.descricao)}`);
+            }
+            console.log(c.dim('\n  Um arquivo .md vira um comando: 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: /review o login.'));
+            console.log(c.dim('  /commands novo <nome> cria um para você editar.'));
+            break;
+        }
+
+        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'));
+            break;
+        }
+
+        default: {
+            // "/" sozinho abre o menu; um prefixo único autopreenche e executa
+            // ("/eff" → /effort); prefixo ambíguo mostra as opções.
+            if (!cmd) { mostrarMenuSlash(); break; }
+            // Chegou aqui, não é embutido: o switch já atendeu todos eles.
+            // Por isso um /help.md da pessoa nunca troca o /help de verdade.
+            const proprio = comandosDaPessoa().find((x) => x.nome === nome);
+            if (proprio) {
+                console.log(c.dim(`  ⎿ /${proprio.nome} · ${proprio.origem}`));
+                // O MESMO caminho de um pedido digitado: modo, pasta, plano,
+                // tudo. Um atalho que pulasse o sendPrompt pularia junto o
+                // portão do plano e a escolha da pasta.
+                await sendPrompt(comandosLib.expandir(proprio, rest));
+                break;
+            }
+            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 : ''));
+                break;
+            }
+            if (casam.length > 1) {
+                console.log(c.muted(`  /${cmd}… pode ser:`));
+                for (const n of casam) {
+                    const [, desc] = comandosDoMenu().find(([nome]) => nome === '/' + n);
+                    console.log(`    ${c.brand(ui.padRight('/' + n, 12))}${c.dim(desc)}`);
+                }
+                break;
+            }
+            console.log(c.err(`Comando desconhecido: /${cmd}. Digite / para ver o menu.`));
+        }
+    }
+}
+
+// ── Main ───────────────────────────────────────────────────────────────
+
+function shortPath(p) {
+    // Normaliza as barras antes de comparar — no Windows o cwd vem com "\"
+    // e a home pode vir com "/", e aí o prefixo nunca batia.
+    const norm = (s) => path.resolve(s).replace(/\\/g, '/');
+    const home = norm(os.homedir());
+    const full = norm(p);
+    return full.startsWith(home + '/') ? '~' + full.slice(home.length) : full;
+}
+
+/* O CLIENTE NOVO E O SERVIDOR VELHO.
+ *
+ * Quem declara ao modelo quais ferramentas existem é o servidor. Quando a
+ * lista dele fica para trás, o que a pessoa vê é "a ferramenta não está
+ * disponível" e tarefas que param no meio — duas frases que não apontam para
+ * a causa. Uma linha no começo da sessão troca isso por algo acionável.
+ *
+ * Sem prender nada: a busca corre em paralelo e, se o servidor estiver
+ * dormindo ou a rede fora, não se diz nada. Acusar o servidor porque a rede
+ * caiu manda consertar o que não quebrou. */
+let jaConferiu = false;
+function conferirServidor() {
+    if (jaConferiu) return;
+    jaConferiu = true;
+    const minimo = (pkg.primocode && pkg.primocode.servidorMinimo) || '';
+    if (!minimo) return;
+    // Com a chave própria (/api), quem pensa não é o servidor: a versão dele
+    // não muda nada no que a pessoa pede.
+    if (provedorLocal.atual()) return;
+    const servidor = state.config.server;
+    Promise.resolve()
+        .then(() => api.getHealth(servidor, state.config.token))
+        .then((saude) => {
+            const r = compat.avaliar({ saude, minimo, servidor });
+            const texto = compat.aviso(r, c);
+            if (texto) console.log('\n' + texto + '\n');
+        })
+        .catch(() => {});
+}
+
+async function main() {
+    /* `primocode autoteste|preview|review|pesquisar`: entradas sem sessão (lib/cli/subcomandos.js). */
+    if (require('./subcomandos.js').NOMES.includes(process.argv[2])) {
+        process.exit(await require('./subcomandos.js').main(process.argv[2], process.argv.slice(3)));
+    }
+    /* `primocode --tentativas N "pedido"`: best of N em worktrees separados (lib/cli/tentativas.js). */
+    if (process.argv.slice(2).some((a) => a === '--tentativas' || a.startsWith('--tentativas='))) {
+        process.exit(await require('./tentativas.js').main(process.argv.slice(2)));
+    }
+    /* `primocode video <op>`: o editor de vídeo por linha do tempo
+       (lib/plugin/video/). Sai ANTES de tudo — sem sessão, sem pasta padrão —
+       porque quem chama é o agente pelo run_shell, na pasta da gravação. */
+    if (process.argv[2] === 'video') {
+        process.exit(await require('../plugin/video/cli.js').main(process.argv.slice(3)));
+    }
+    /* `primocode editor <acao> --json '{...}'`: a edição completa de vídeo falado
+       (lib/plugin/editor-pro.js, motor do EDIT IA PRO), pelo run_shell quando o servidor
+       ainda não declara a ferramenta editor_pro. Uma linha de JSON no stdout. */
+    if (process.argv[2] === 'editor') {
+        process.exit(await require('../plugin/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/plugin/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('../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('../plugin/estudio/gosto.js'), P = require('../plugin/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('../plugin/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('../plugin/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('../plugin/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('../plugin/motioncraft.js').main(process.argv.slice(3)));
+    }
+    // `primocode mcp …`: os servidores MCP pelo run_shell (lib/mcp/mcp.js).
+    if (process.argv[2] === 'videos') {
+        const r = require('../plugin/estudio/exportar.js').main(process.argv.slice(3));
+        console.log(r.texto); process.exit(r.ok ? 0 : 1);
+    }
+    if (process.argv[2] === 'conversas' || process.argv[2] === 'conversa') {
+        process.exit(await require('../app-chat.js').main(process.argv[2], process.argv.slice(3)));
+    }
+    if (process.argv[2] === 'menu-comandos') {     // a paleta de / do app: os mesmos do terminal, mais os da pessoa
+        const embutidos = new Set(SLASH_COMANDOS.map(([n]) => n));
+        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/plugin/kits.js). Pelo run_shell do agente ele roda dentro do processo (lib/tool/tools.js).
+    if (process.argv[2] === 'kit' || process.argv[2] === 'kits') {
+        const r = await require('../plugin/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('../skill/skills.js').main(process.argv.slice(3)));
+    }
+    // `primocode planos`: a tabela comparativa, sem abrir a sessão.
+    // `primocode voz nome <Nome>` / `primocode voz painel`: o Primo sem abrir a sessão.
+    if (process.argv[2] === 'voz') {
+        const vz = require('../plugin/voz.js');
+        const [sub, ...resto] = process.argv.slice(3);
+        if (sub === 'nome') {
+            const n = vz.definirNome(resto.join(' '));
+            console.log(n ? `Fechado: o assistente agora se chama ${n}.` : 'Uso: primocode voz nome <Nome>  (1 ou 2 palavras)');
+            process.exit(n ? 0 : 1);
+        }
+        if (sub === 'painel') {
+            const py = vz.python();
+            if (!py) { console.log('O painel precisa do Python 3.'); process.exit(1); }
+            const r = vz.abrirPainel({ python: py });
+            r.processo.on('close', () => process.exit(0));
+            return;
+        }
+        if (sub === 'instalar-app') {
+            const py = vz.python();
+            if (!py) { console.log('O app precisa do Python 3 (rode /voice uma vez para preparar o ambiente).'); process.exit(1); }
+            const r = vz.instalarApp({ python: py, dock: resto.includes('--dock') });
+            console.log(r.ok ? `Primo.app instalado em ${r.app}. Abra pelo Launchpad, Spotlight ou Finder.` : `Não deu: ${r.erro || 'veja o log'}`);
+            process.exit(r.ok ? 0 : 1);
+        }
+        console.log('Uso: primocode voz nome <Nome> | primocode voz painel | primocode voz instalar-app [--dock] (o resto é /voice dentro da sessão)');
+        process.exit(0);
+    }
+    if (['doutor', 'doctor', 'preparar'].includes(process.argv[2])) {
+        process.exit(await require('../preparar.js').main(process.argv.slice(2)));
+    }
+    if (process.argv[2] === 'planos') {
+        const { loadConfig } = require('../config/config');
+        const r = await planosTela.buscarPlanos(loadConfig().server);
+        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);
+        process.exit(0);
+    }
+    if (process.argv[2] === 'marca') {
+        process.exit(await require('../plugin/marca-kit.js').main(process.argv.slice(3)));
+    }
+    if (process.argv[2] === 'mcp') {
+        process.exit(await require('../mcp/mcp.js').main(process.argv.slice(3)));
+    }
+    cfg.ensureStructure();
+    // O token da conta dura uma hora: renova agora e a cada minuto (lib/config/conta.js).
+    await conta.manterVivo();
+
+    // Padrão fixo: ~/primocode, não importa de onde o comando foi dado. Antes ele
+    // adotava a pasta atual do terminal, e o mesmo "crie um site" caía num lugar
+    // diferente a cada vez — quem digitava não tinha como saber onde ia parar.
+    state.workDir = cfg.ROOT_DIR;
+    state.currentProject = null;
+    state.workDirOrigem = 'padrao';
+    // O projeto em que se estava na última sessão (até uma semana atrás): o
+    // "continua o jogo" de amanhã cai nele, e não num projeto novo.
+    // O app do Primo (voz) manda a pasta de cada pedido: PRIMOCODE_PASTA (+ ORIGEM) e nunca herda a última do terminal.
+    const lembrado = process.env.PRIMOCODE_APP === '1'
+        ? (process.env.PRIMOCODE_PASTA && fs.existsSync(process.env.PRIMOCODE_PASTA)
+            ? { dir: process.env.PRIMOCODE_PASTA, origem: process.env.PRIMOCODE_PASTA_ORIGEM === '/dir' ? '/dir' : 'projeto' } : null)
+        : cfg.projetoLembrado();
+    if (lembrado && pastaSegura(lembrado.dir)) {
+        state.workDir = lembrado.dir;
+        state.currentProject = path.basename(lembrado.dir);
+        state.workDirOrigem = lembrado.origem === '/dir' ? '/dir' : 'projeto';
+    }
+
+    // Modo guardado entre sessões. O padrão é auto: sem ele, um "oi" gasta o
+    // mesmo que uma refatoração.
+    state.mode = ['primocode', 'chat', 'auto'].includes(process.env.PRIMOCODE_MODO || state.config.mode) ? (process.env.PRIMOCODE_MODO || state.config.mode) : 'auto';
+
+    // `-c` / `--continue` pode vir em qualquer posição e sai da lista: o
+    // resto (one-shot, -f) segue sendo lido do jeito de sempre.
+    const todos = process.argv.slice(2);
+    const continuar = todos.some((a) => a === '-c' || a === '--continue');
+    const fl = retomar.analisar(todos.filter((a) => a !== '-c' && a !== '--continue'));
+    const args = fl.args;
+    if (fl.erro) { console.error(fl.erro); process.exit(1); }
+    if (fl.worktree) {
+        // Antes de tudo: a sessão inteira nasce dentro do worktree.
+        const w = retomar.criarWorktree(fl.worktree, process.cwd());
+        if (!w.ok) { console.error(w.error); process.exit(1); }
+        process.chdir(w.path);
+        console.log(c.dim(`  ⎿ worktree ${w.path} (branch ${w.branch})`));
+    }
+
+    // Flags padrão de CLI — funcionam em qualquer máquina, úteis em scripts/CI.
+    if (args[0] === '--version' || args[0] === '-v' || args[0] === '-V') {
+        console.log(`PrimoCode v${VERSION}`);
+        process.exit(0);
+    }
+    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(montarHelp());
+        process.exit(0);
+    }
+
+    /* `-p` / `--print`: o modo de script e CI (lib/cli/headless.js). Sem tela, o
+       stdin entra no pedido, e --output-format json devolve um JSON só. */
+    {
+        const H = require('./headless.js');
+        const h = H.analisar(args);
+        if (h.ativo) {
+            if (h.erro) { console.error(h.erro); process.exit(1); }
+            if (h.permissao) {
+                const perm = perigo.normalizarModo(h.permissao);
+                state.config.permissoes = perm; // só nesta execução, não grava
+            }
+            const inicio = Date.now();
+            const pedido = H.montarPedido(h.resto.filter((a) => a !== '-f'), await H.lerStdin());
+            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
+                require('../plugin/voz-ponte').escutar((nome, a) => process.stderr.write(`ferramenta: ${nome} ${JSON.stringify(a || {}).slice(0, 220)}\n`));
+            }
+            let erro = null;
+            const antes = state.history.length;
+            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' });
+            await state.gravador.esperar();   // o último turno termina de subir, e o id da conversa existe
+            if (h.formato === 'json') console.log(H.resultadoJson({ texto, erro, inicio, permissao: state.config.permissoes, conversa: state.gravador.id, markdown: H.ultimaResposta(state.history, antes) }));
+            else if (erro) console.error(erro);
+            process.exit(erro ? 1 : 0);
+        }
+    }
+
+    // Modo one-shot: primocode "crie um jogo de carro"
+    if (args.length && !args[0].startsWith('-')) {
+        const fileFlag = args.indexOf('-f');
+        const words = fileFlag >= 0 ? args.slice(0, fileFlag) : args;
+        const promptText = words.join(' ');
+
+        if (fileFlag >= 0 && args[fileFlag + 1]) {
+            try {
+                const fc = fs.readFileSync(path.resolve(args[fileFlag + 1]), 'utf-8');
+                state.attachedFiles.push({ path: args[fileFlag + 1], content: fc });
+            } catch { console.log(c.err(`Não consegui ler: ${args[fileFlag + 1]}`)); process.exit(1); }
+        }
+
+        // Com -c, o pedido continua a última conversa em vez de chegar sozinho.
+        if (typeof fl.resume === 'string') await retomarConversa(fl.resume);
+        else if (continuar) await continuarUltima();
+        /* O MESMO caminho do pedido digitado (sendPrompt). Este modo tinha um
+           runAct próprio, e por isso ficava sem tudo o que vive lá: o plano em
+           passos, a retomada automática, o @arquivo, o checkpoint do /desfazer. */
+        state.semTerminal = true;
+        global.__primocodeTarefa = promptText.slice(0, 60);
+        await sendPrompt(promptText);
+        global.__primocodeTarefa = null;
+        process.exit(0);
+    }
+
+    /* A TELA CHEIA do OpenCode (lib/tui/tela.js) é o padrão: a conversa rola em
+       cima, a caixa fica presa no pé, a barra da direita mostra a sessão e o
+       contexto, e sem conversa a home põe o logo e a caixa no meio da tela.
+       PRIMOCODE_TELA=linha (ou "tela": "linha" no config) volta ao jeito
+       antigo, que escreve em linha pelo terminal. */
+    const telaCheia = process.stdout.isTTY && process.stdout.rows >= 16
+        && (process.env.PRIMOCODE_TELA || state.config.tela || 'cheia') !== 'linha';
+    if (!telaCheia) {
+        if (process.stdout.isTTY && process.stdout.rows >= 20) {
+            const rows = process.stdout.rows;
+            const alto = 8 + 6;                       // o logo com a versão + a caixa
+            process.stdout.write('\n'.repeat(rows) + '\x1b[H' + '\n'.repeat(Math.max(0, Math.floor((rows - alto) / 2) - 1)));
+        }
+        console.log(welcomeBox(VERSION, state.workDir ? shortPath(state.workDir) : null, {
+            pastaPadrao: state.workDirOrigem === 'padrao',
+        }));
+    }
+    rl = entrada.criar({
+        status: barraDeStatus,
+        comandos: comandosDoMenu,
+        vazio: ui.convite(),
+        telaCheia,
+        lateral: barraLateral,
+        logoAnimado: (quadro, trabalhando) => ui.logoAnimado(state.config.mascot, quadro, trabalhando),
+        agora: () => (ui.agora.texto && Date.now() - ui.agora.desde < 10 * 60 * 1000 ? ui.agora.texto : ''),
+        versao: VERSION,
+        logo: ui.logoComMascote(state.config.mascot),
+        pasta: () => {
+            const dir = state.workDir || process.cwd();
+            const ramo = ramoDoGit(dir);
+            return shortPath(dir) + (ramo ? ':' + ramo : '');
+        },
+    });
+    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('../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/tui/entrada.js mostrarSpinner).
+    if (rl.tty) Spinner.caixa = rl;
+    ui.titulo('PrimoCode');
+
+    rl.prompt();
+
+    // Fila: o readline continua emitindo 'line' enquanto um pedido está sendo
+    // processado. Sem enfileirar, dois pedidos rodariam sobrepostos.
+    const queue = [];
+    let busy = false;
+    let closed = false;
+    let saidBye = false;
+
+    /* ── Esc Esc: parar o agente no meio do trabalho ──
+     * Um Esc avisa; o segundo (em até 2s) manda parar. A caixa não sabe o
+     * que é "parar o agente" — ela só avisa que o Esc aconteceu, e quem
+     * decide o que fazer é aqui.
+     *
+     * A sugestão fantasma, que morava aqui, foi junto com o readline: hoje
+     * ela é desenhada pela própria caixa (ver lib/tui/entrada.js). */
+    let ultimoEsc = 0;
+    rl.on('escape', () => {
+        if (!busy) { ultimoEsc = 0; return; }
+        const agora = Date.now();
+        if (agora - ultimoEsc < 2000) {
+            ultimoEsc = 0;
+            interromper();
+            if (chatEmVoo) { try { chatEmVoo.abort(); } catch {} }
+            console.log(c.warn('  ⏹ parando o agente…'));
+        } else {
+            ultimoEsc = agora;
+            console.log(c.dim('  Esc de novo para parar o agente'));
+        }
+    });
+
+    // Ctrl+C com a caixa vazia: sair é sair, mas sem deixar o último turno
+    // pela metade — o sayBye espera a gravação subir.
+    rl.on('sigint', () => rl.close());
+    rl.on('trocar-modo', trocarModo);
+
+    function sayBye() {
+        if (saidBye) return;
+        saidBye = true;
+
+        /* O MICROFONE FECHA JUNTO.
+           O ouvinte de voz é um processo filho, e filho no POSIX não morre
+           porque o pai saiu: ficaria um Python segurando o microfone depois
+           de o terminal fechar — sem janela, sem jeito de desligar a não ser
+           pelo gerenciador de tarefas, e com a luzinha da câmera do lado
+           acesa. Matar aqui é o que faz "fechei o terminal" significar
+           "fechei tudo". */
+        if (vozEmEspera) {
+            try { vozEmEspera.processo.kill(); } catch { /* já morreu */ }
+            vozEmEspera = null;
+        }
+        // O último turno pode ainda estar subindo — gravar é de propósito
+        // 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('../fundo.js').pararTodas();
+        const fim = () => console.log(c.muted('\nAté logo!'));
+        Promise.race([
+            state.gravador.esperar(),
+            // Rede pendurada não vira terminal pendurado. `unref` porque o
+            // temporizador sozinho seguraria o processo por 3s mesmo quando a
+            // gravação já terminou — um "Até logo!" seguido de três segundos
+            // de nada é o tipo de coisa que quem usa chama de travado.
+            new Promise((r) => { const t = setTimeout(r, 3000); if (t.unref) t.unref(); }),
+        ]).then(fim, fim);
+    }
+
+    async function drain() {
+        if (busy) return;
+        busy = true;
+        // A caixa esmaece enquanto ele trabalha, e a segunda linha da barra
+        // troca os atalhos pelo que importa naquele momento: como parar.
+        state.trabalhando = true;
+        if (rl.trabalhando) rl.trabalhando(true);
+        while (queue.length) {
+            const text = queue.shift().trim();
+            if (!text) continue;
+            ui.titulo(`⠋ PrimoCode — ${text}`);
+            // Comando (/effort, /help) não é trabalho do agente: a caixa e a
+            // barra da direita só dizem "trabalhando" quando ele trabalha.
+            if (rl.trabalhando) rl.trabalhando(!isSlash(text));
+            try {
+                if (ehBash(text)) await rodarBash(text);
+                else if (isSlash(text)) await handleSlash(text);
+                else {
+                    await sendPrompt(text, { digitado: true });
+                }
+            } catch (e) {
+                fala.problema(e);
+                if (vozEmEspera && vozEmEspera.estado) vozEmEspera.estado('erro');
+            }
+            // Pedido falado (ou tarefa que recebeu recado falado): a resposta
+            // final sai em voz alta, resumida. O detalhe fica na tela.
+            if (vozEmEspera && (deVoz.delete(text) || vozNaTarefa)) {
+                vozNaTarefa = false;
+                const ultima = state.history.slice().reverse().find((m) => m.role === 'assistant');
+                if (ultima && ultima.content) vozEmEspera.falar(ultima.content);
+            } else if (vozEmEspera && vozEmEspera.estado) vozEmEspera.estado('esperando');
+            // Recado que chegou tarde demais para a tarefa (ela já tinha
+            // acabado): vira o próximo pedido, na ordem. Nada se perde.
+            queue.unshift(...sobrasDaCaixa());
+        }
+        busy = false;
+        state.trabalhando = false;
+        if (rl.trabalhando) rl.trabalhando(false);
+        ui.titulo('PrimoCode');
+        // Se o stdin já fechou (pipe, Ctrl+D), a despedida espera a fila terminar
+        // — senão ela aparece antes do resultado do último pedido.
+        if (closed) sayBye();
+        else rl.prompt();
+    }
+
+    rl.on('line', (line) => {
+        if (pendingAsk) { const resolve = pendingAsk; pendingAsk = null; resolve(line); return; }
+        // Abertura correndo: guarda em vez de mandar ao agente.
+        if (segurando) { adiantadas.push(line); return; }
+        /* Digitou com o agente no meio de uma tarefa: o recado entra NELA,
+           depois do passo atual (ver a caixa em lib/session/runner/act.js), em vez de
+           esperar a tarefa acabar para virar um pedido que não sabe de nada.
+           Comando (/…) e shell (!…) continuam indo para a fila. */
+        const t = line.trim();
+        if (busy && t && !isSlash(t) && !ehBash(t) && mandarDuranteATarefa(t)) {
+            console.log(c.dim('  ↳ recado guardado — entra na tarefa depois do passo atual'));
+            return;
+        }
+        queue.push(line);
+        drain();
+    });
+
+    rl.on('close', () => { closed = true; if (!busy) sayBye(); });
+
+    /* A FALA ENTRA AQUI, pelo mesmo caminho da linha digitada: responde a
+       pergunta pendente (a autorização, por exemplo — "pode" é resposta), vira
+       recado se ele está no meio de uma tarefa, ou vira pedido na fila. O que
+       veio falado é marcado para a resposta sair em voz alta. */
+    const deVoz = new Set();
+    let vozNaTarefa = false;
+    entradaDeVoz = (texto) => {
+        console.log('  ' + c.brand('🎙 ') + c.white(texto));
+        if (pendingAsk) { const resolve = pendingAsk; pendingAsk = null; resolve(texto); return; }
+        if (segurando) { adiantadas.push(texto); return; }
+        if (busy && !isSlash(texto) && mandarDuranteATarefa(texto)) {
+            vozNaTarefa = true;
+            console.log(c.dim('  ↳ recado guardado — entra na tarefa depois do passo atual'));
+            return;
+        }
+        deVoz.add(texto);
+        queue.push(texto);
+        drain();
+    };
+
+    /* A ABERTURA — e ela roda AQUI, depois de `line` e `close` existirem.
+     *
+     * Estava antes deles. O `await` segurava o resto do main(), e tudo o que
+     * chegasse pelo teclado nesse meio-tempo caía no vazio: não havia ouvinte
+     * para pegar. Quem colasse dois comandos perdia o segundo, e quem
+     * fechasse a entrada saía sem nem o "Até logo". Digitando devagar ninguém
+     * via — os ouvintes ficam prontos milissegundos depois. */
+    /* A FILA FICA SEGURA ENQUANTO A ABERTURA CORRE.
+     *
+     * `busy` já é o freio do `drain`, e é ele que se usa aqui. Sem isso, tudo
+     * o que a pessoa digitar antes de a pergunta aparecer — e ela demora,
+     * porque confere o plano no servidor — cai como PEDIDO no agente. Medido
+     * no pacote publicado: o "2" da escolha da IA virou uma pergunta no chat,
+     * e o modelo respondeu "Oi! Como posso ajudar?".
+     *
+     * O ouvinte de `line` continua atendendo o `ask` normalmente: ele olha o
+     * `pendingAsk` antes da fila. O que fica retido é só o que não era
+     * resposta a nada. */
+    segurando = true;
+    boasVindas.rodar({
+        perguntar: ask,
+        mostrar: (t) => console.log(t),
+        cores: c,
+        interativo: !!(process.stdin.isTTY && process.stdout.isTTY),
+        conectado: () => conta.atual(),
+        conectar: () => handleSlash('/login').then((r) => (r && r.ok === false ? r : conta.atual() || r)),
+        sessao: () => conta.sessao(),
+    }).then((r) => {
+        // O bloqueio de quem não é Premium/Super. É de CORTESIA: este arquivo
+        // vai publicado no npm com o código à vista. Quem segura de verdade é
+        // o primocode-server, que tem a chave do provedor.
+        state.liberado = !r || r.liberado !== false;
+        state.motivoBloqueio = r && r.motivo;
+    }).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)
+            : fl.resume ? retomarConversa(fl.resume).catch(() => false)
+                : continuar ? continuarUltima().catch(() => false) : null))
+        .then(() => {
+            // O que sobrou de adiantado não era resposta de nada: vira comando,
+            // na ordem em que foi digitado. Nada se perde, só esperou a vez.
+            segurando = false;
+            while (adiantadas.length) queue.push(adiantadas.shift());
+            if (queue.length) drain();
+            else if (!closed) rl.prompt();
+            conferirServidor();
+        });
+}
+
+main().catch((e) => { console.error(c.err(e.message || e)); process.exit(1); });