primocode 8.42.1 → 9.0.0

package/bin/primocode.js

@@ -14,6 +14,7 @@ const os = require('os');
 
 const pkg = require('../package.json');
 const ui = require('../lib/ui');
+const entrada = require('../lib/entrada');
 const { c, welcomeBox, Spinner } = ui;
 const { escolherModo } = require('../lib/modo.js');
 const api = require('../lib/api');
@@ -21,14 +22,16 @@ const tools = require('../lib/tools');
 const cfg = require('../lib/config');
 const { runAct, interromper, ehTetoDeToken, ehTransitorio, esperaDoErro } = require('../lib/act');
 const fala = require('../lib/fala');
-const claudeEngine = require('../lib/claude-engine');
-const codexEngine = require('../lib/codex-engine');
-const chaves = require('../lib/chaves');
 const boasVindas = require('../lib/boas-vindas');
 const pasta = require('../lib/pasta');
 const catalogo = require('../lib/catalogo');
 const effort = require('../lib/effort');
 const memoria = require('../lib/memoria-conversa');
+const registro = require('../lib/registro');
+const permissao = require('../lib/permissao');
+const skills = require('../lib/skills');
+const marketplace = require('../lib/marketplace');
+const vozModo = require('../lib/voz');
 const appLib = require('../lib/app');
 const conta = require('../lib/conta');
 const nuvem = require('../lib/nuvem');
@@ -71,10 +74,14 @@ const state = {
     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' — para o /dir explicar
-    engine: 'server',   // 'server' (OpenRouter/Groq) | 'claude-code' (/claude) | 'codex' (/codex)
 };
 
 // A janela do /rc, quando aberta. Uma por sessão: o segundo /rc traz a que
@@ -96,9 +103,6 @@ ${c.bold('Comandos')}
   ${c.brand('/run')} <comando>      executa no shell do projeto
   ${c.brand('/open')} <arq|url>     abre no navegador
   ${c.brand('/rc')}                 abre a janela do PrimoCode (chat, sem terminal)
-  ${c.brand('/claude')}             usa o Claude Code da SUA conta como motor (Opus)
-  ${c.brand('/gpt')}                usa o GPT (Codex) da SUA conta como motor
-  ${c.brand('/key')} <provedor>     sua própria chave de API (Claude, GPT)
   ${c.brand('/connect')}            entra na sua conta · ${c.brand('/account')} mostra o plano
   ${c.brand('/chats')} [n]          suas conversas — as mesmas do app e do celular
   ${c.brand('/logout')}             desconecta este computador da conta
@@ -143,14 +147,16 @@ const SLASH_COMANDOS = [
     ['/run', 'roda um comando'],
     ['/open', 'abre no navegador'],
     ['/rc', 'abre a janela do PrimoCode'],
-    ['/claude', 'usa o Claude Code da sua conta como motor'],
-    ['/gpt', 'usa o GPT (Codex) da sua conta como motor'],
-    ['/key', 'sua própria chave de API (Claude, Codex)'],
     ['/connect', 'entra na sua conta Conecta Primo'],
     ['/account', 'sua conta, plano e computadores conectados'],
     ['/chats', 'suas conversas salvas, as mesmas do app e do celular'],
     ['/logout', 'desconecta este computador da conta'],
+    ['/voice', 'o Primo Code em modo voz: você fala, ele faz'],
+    ['/skills', 'o que ele sabe fazer bem — ligue e desligue'],
+    ['/marketplace', 'a tela das skills: navegue, ligue, crie'],
+    ['/install-skill', 'instala uma skill de um arquivo'],
     ['/status', 'checa o servidor'],
+    ['/connectors', 'quem está atendendo os seus pedidos'],
     ['/name', 'como ele te chama'],
     ['/mascot', 'primo | fox | cat'],
     ['/config', 'suas preferências'],
@@ -161,15 +167,6 @@ const SLASH_COMANDOS = [
     ['/exit', 'sair'],
 ];
 
-// O completer do readline: Tab completa o que der. Só age na palavra do
-// comando — depois do primeiro espaço o argumento é seu, não dele.
-function completarSlash(line) {
-    if (!line.startsWith('/') || /\s/.test(line)) return [[], line];
-    const baixa = line.toLowerCase();
-    const acertos = SLASH_COMANDOS.map(([nome]) => nome).filter((nome) => nome.startsWith(baixa));
-    return [acertos, line];
-}
-
 // ── /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.
@@ -221,72 +218,13 @@ function sliderEffort(atual) {
             if (anima) { clearInterval(anima); anima = null; }
             process.stdin.removeListener('keypress', aoTeclar);
             sliderAtivo = false;
+            if (rl && rl.retomar) rl.retomar();
             resolve(valor);
         };
         sliderAtivo = true;
-        process.stdin.on('keypress', aoTeclar);
-    });
-}
-
-/* ── A LISTA COM AS SETINHAS ─────────────────────────────────────────────
- *
- *   "O usuário seleciona usando as setinhas, igual você."
- *
- * ↑↓ anda, Enter confirma, Esc fica com o primeiro item. O número também
- * funciona — quem já sabe qual quer não precisa navegar até lá.
- *
- * Devolve `undefined` quando não há terminal de verdade: aí quem chamou cai
- * na lista numerada, que funciona em pipe e em CI. `null` é outra coisa —
- * é Esc, que É uma resposta ("tanto faz, a primeira").
- */
-function menuSetas({ titulo, ajuda, lista }) {
-    return new Promise((resolve) => {
-        if (!process.stdin.isTTY || !process.stdout.isTTY) return resolve(undefined);
-        let idx = 0;
-        const linhas = () => {
-            const fora = [''];
-            fora.push(c.bold(c.brand('  ' + titulo)));
-            if (ajuda) fora.push(c.muted('  ' + ajuda));
-            fora.push('');
-            lista.forEach((e, i) => {
-                const aqui = i === idx;
-                fora.push((aqui ? c.brand('  ❯ ') : '    ') + (aqui ? c.bold(c.white(e.titulo)) : c.muted(e.titulo)));
-                fora.push('      ' + c.dim(e.detalhe || ''));
-            });
-            fora.push('');
-            return fora;
-        };
-        const ALTURA = linhas().length;
-
-        const pintar = (primeira) => {
-            if (!primeira) process.stdout.write(`\x1b[${ALTURA}A\r`);
-            process.stdout.write(linhas().map((l) => '\x1b[2K' + l).join('\n') + '\n');
-        };
-
-        const encerrar = (valor) => {
-            process.stdin.removeListener('keypress', aoTeclar);
-            sliderAtivo = false;
-            try { process.stdout.write('\x1b[?25h'); } catch {}
-            resolve(valor);
-        };
-        const aoTeclar = (ch, key) => {
-            if (!key) return;
-            if (key.name === 'down' || key.name === 'j' || (key.name === 'tab' && !key.shift)) {
-                idx = (idx + 1) % lista.length; return pintar(false);
-            }
-            if (key.name === 'up' || key.name === 'k' || (key.name === 'tab' && key.shift)) {
-                idx = (idx - 1 + lista.length) % lista.length; return pintar(false);
-            }
-            if (/^[1-9]$/.test(ch || '') && Number(ch) <= lista.length) {
-                idx = Number(ch) - 1; return pintar(false);
-            }
-            if (key.name === 'return' || key.name === 'enter') return encerrar(lista[idx].id);
-            if (key.name === 'escape' || (key.ctrl && key.name === 'c')) return encerrar(null);
-        };
-
-        sliderAtivo = true;   // enquanto está no ar, o resto do teclado se cala
-        try { process.stdout.write('\x1b[?25l'); } catch {}
-        pintar(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);
     });
 }
@@ -314,35 +252,98 @@ function mostrarMenuSlash() {
 
 let rl = null;
 
-function makePrompt() {
+/* ── 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;
+}
+
+function barraDeStatus() {
+    const partes = [];
+
+    /* 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 uso = memoria.usoDoContexto(state.memoria, state.history);
+    if (uso.pct >= 5) {
+        partes.push(uso.pct >= 100 ? c.err(`${uso.pct}% ctx`)
+            : uso.pct >= 70 ? c.warn(`${uso.pct}% ctx`)
+                : c.dim(`${uso.pct}% ctx`));
+    }
+
+    // O esforço, que é o que escolhe o modelo. Não há provedor para mostrar:
+    // a API vem com o produto.
+    partes.push(c.muted(effort.normalizar(state.config.effort)));
+
+    // A PASTA. O nome dela, e o caminho curto quando não é um projeto — 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'));
+
     // No auto o rótulo mostra "Auto" e, depois do primeiro pedido, qual modo
     // ele acabou usando — senão você nunca sabe quem respondeu.
-    let modeTag;
+    let modo;
     if (state.mode === 'auto') {
-        const ultimo = state.modoEfetivo === 'primocode' ? c.warn('primo') : state.modoEfetivo === 'chat' ? c.brandDim('chat') : '';
-        modeTag = c.brand('Auto') + (ultimo ? c.dim('·') + ultimo : '');
+        const ultimo = state.modoEfetivo === 'primocode' ? c.warn('primo')
+            : state.modoEfetivo === 'chat' ? c.brandDim('chat') : '';
+        modo = c.brand('auto') + (ultimo ? c.dim('·') + ultimo : '');
     } else {
-        modeTag = state.mode === 'primocode' ? c.warn('Primo Code') : c.brandDim('Chat');
+        modo = state.mode === 'primocode' ? c.warn('primo code') : c.brandDim('chat');
     }
-    const proj = state.currentProject ? c.dim(` ${state.currentProject}`) : '';
+    partes.push(modo);
 
-    /* O CONTEXTO na barra, como o pedido pede. 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%.
-       Fica âmbar a partir de 70% e vermelho a partir de 100%, que é quando
-       `/compact` deixa de ser conselho e vira o que fazer. */
-    const uso = memoria.usoDoContexto(state.memoria, state.history);
-    const ctx = uso.pct < 5 ? '' : c.dim(' · ')
-        + (uso.pct >= 100 ? c.err(`ctx ${uso.pct}%`)
-            : uso.pct >= 70 ? c.warn(`ctx ${uso.pct}%`)
-                : c.dim(`ctx ${uso.pct}%`));
-    // O modelo ativo: qual motor está pensando. No padrão é o do servidor.
-    const motor = state.engine === 'claude-code' ? c.dim(' · ') + c.dim('claude')
-        : state.engine === 'codex' ? c.dim(' · ') + c.dim('gpt') : '';
-    const att = state.attachedFiles.length ? c.muted(` +${state.attachedFiles.length}`) : '';
-    return `\n${c.muted(modeTag)}${motor}${ctx}${proj}${att} ${c.brand('❯')} `;
+    const primeira = partes.join(c.dim(' | '));
+
+    const atalhos = state.trabalhando
+        ? c.warn('▸▸ trabalhando') + c.dim('  (Esc Esc interrompe)')
+        : c.dim('/ comandos · ↑ histórico · \\ ou alt+enter quebra linha · Esc Esc interrompe');
+
+    return [primeira, atalhos];
 }
-function refreshPrompt() { if (rl) rl.setPrompt(makePrompt()); }
+
+// 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.
@@ -525,6 +526,195 @@ function prepararPasta(userText) {
     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 } = {}) {
+    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'));
+
+    const dito = String(await ask('  ' + c.brand('❯ ') + c.muted('1, 2 ou Enter '))).trim().toLowerCase();
+    if (dito === '1' || /^(s|sim|ok|pode|agora|y|yes)$/.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/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(),
+            });
+            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 = skills.instalarDe(caminho);
+    console.log(r.ok ? c.ok(`  Skill instalada: ${r.nome}`) : c.err(`  ${r.error}`));
+}
+
 async function sendPrompt(userText) {
     /* 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
@@ -587,6 +777,11 @@ async function sendPrompt(userText) {
 
         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();
         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
@@ -614,7 +809,10 @@ async function sendPrompt(userText) {
                 // 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,
-                motor: motorDaVez(),
+                // O portão do computador: quem pergunta é o terminal, quem
+                // lembra da resposta é a sessão.
+                autorizar: autorizarControle,
+                controle: state.controle,
             });
 
             r = await rodarPasso();
@@ -626,11 +824,18 @@ async function sendPrompt(userText) {
                 console.log(c.dim('  ⎿ o passo não concluiu — tentando de novo'));
                 r = await rodarPasso();
             }
+            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
         }
+
+        /* 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);
         state.history.push({ role: 'user', content: userText });
         state.history.push({ role: 'assistant', content: r.assistantMessage.content });
         state.lastResponse = r.assistantMessage.content;
@@ -675,30 +880,39 @@ async function sendPrompt(userText) {
 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;
 
-/** "baixa/exporta o vídeo" resolvido na hora, sem gastar modelo. */
-// "me manda o vídeo", "quero pra mandar no zap", "gera o arquivo" — a lista
-// era curta e o pedido sai de muitos jeitos. Fora dela, o pedido virava
-// tarefa de agente: gasto de API para abrir uma URL que o CLI já sabe.
-const RE_BAIXAR = /\b(baixa\w*|exporta\w*|download|salva\w*|grava\w*|me manda|manda(r)? (o|a|esse|essa)|gera(r)? o arquivo|em mp4|pra mandar|arquivo do)\b/i;
-const RE_PECA_STUDIO = /\b(v[ií]deo|mp4|mp3|apresenta[çc][ãa]o|slides?|reels?|anima[çc][ãa]o|filme)\b/i;
+/* "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 studio = require('../lib/studio');
-        const r = await studio.listar();
-        const lista = (r && r.arquivos) || [];
-        // a criação mais nova que é vídeo; sem vídeo, a mais nova de todas
-        const alvo = lista.find((a) => a.ferramenta === 'corte') || lista[0];
-        if (!alvo) return false;
-        const url = `http://localhost:7777/v/${alvo.id}#gravar`;
-        await tools.execute('open_in_browser', { target: url }, { projectDir: state.workDir || os.homedir() });
-        console.log(c.ok(`  ⎿ abrindo "${alvo.titulo}" para gravar`));
-        console.log(c.muted('    O navegador vai pedir permissão de tela — aceite (marque "compartilhar áudio da aba"'));
-        console.log(c.muted('    para levar a narração junto). O vídeo roda sozinho e baixa no fim.'));
+        const { projeto } = require('../lib/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;   // Studio fora do ar ou sem criações: segue o caminho normal
+        return false;   // sem projeto renderizado: segue o caminho normal
     }
 }
 
@@ -807,17 +1021,6 @@ async function runChat(promptForModel, userTextForMemory) {
 
 // ── Slash commands ─────────────────────────────────────────────────────
 
-/* Qual motor executa este turno.
- *
- * Um `if` a mais aqui e um `if` a menos em qualquer outro lugar seria o
- * caminho para o /codex funcionar no modo agente e não no chat, ou ao
- * contrário. Um lugar só decide, e os dois modos chamam este. */
-function motorDaVez() {
-    if (state.engine === 'claude-code') return claudeEngine;
-    if (state.engine === 'codex') return codexEngine;
-    return api;
-}
-
 function isSlash(text) { return text.trim().startsWith('/'); }
 
 /* ── OS NOMES ANTIGOS ────────────────────────────────────────────────────
@@ -841,8 +1044,6 @@ const RENOMEADOS = {
     entrar: 'connect', login: 'connect', conectar: 'connect',
     conta: 'account',
     sair: 'exit',        // sair é SAIR; desconectar a conta é /logout
-    // as chaves de API
-    chave: 'key', chaves: 'key',
     // o histórico
     conversas: 'chats', historico: 'chats', histórico: 'chats',
     // o resto
@@ -954,97 +1155,6 @@ async function handleSlash(text) {
             break;
         }
 
-        /* A chave de API da própria pessoa. Guardada em ~/.primocode/
-           chaves.json com permissão 600 — nunca no config.json, que é o
-           arquivo que se cola num chamado de suporte. */
-        case 'key': case 'keys': {
-            const [qual, ...resto] = rest.split(/\s+/).filter(Boolean);
-            const valor = resto.join(' ');
-
-            if (!qual) {
-                console.log(c.white('\n  Suas chaves de API'));
-                for (const p of chaves.listar()) {
-                    console.log('  ' + c.white(p.nome.padEnd(8))
-                        + (p.tem ? c.ok(p.disfarce) : c.dim('não configurada'))
-                        + c.dim(`   ${p.variavel}`));
-                }
-                console.log(c.dim('\n  /key claude sk-ant-…      guarda a chave'));
-                console.log(c.dim('  /key gpt remover          apaga a que estiver lá'));
-                console.log(c.muted('\n  Sem chave própria, cada motor usa a conta em que você já entrou nele.'));
-                break;
-            }
-            if (!chaves.PROVEDORES[qual]) {
-                console.log(c.err(`  Não conheço "${qual}". Use: ${Object.keys(chaves.PROVEDORES).join(', ')}`));
-                break;
-            }
-            if (valor === 'remover' || valor === 'apagar') {
-                const r = chaves.esquecer(qual);
-                console.log(r.ok ? c.ok(`  Chave do ${chaves.PROVEDORES[qual].nome} apagada.`)
-                    : c.muted(`  ${r.error}`));
-                break;
-            }
-            if (!valor) {
-                const p = chaves.PROVEDORES[qual];
-                console.log(c.muted(`  Uso: `) + c.brand(`/key ${qual} ${p.prefixo}…`));
-                console.log(c.dim(`  Pegue a sua em ${p.onde}`));
-                break;
-            }
-            const r = chaves.guardar(qual, valor);
-            if (!r.ok) { console.log(c.err(`  ${r.error}`)); break; }
-            // O que se mostra de volta é o disfarce, nunca a chave: a linha
-            // fica no scrollback do terminal e no print que a pessoa manda.
-            console.log(c.ok(`  Chave do ${r.nome} guardada.`) + c.muted(`  ${r.disfarce}`));
-            console.log(c.dim(`  Ela vai como ${chaves.PROVEDORES[qual].variavel} só quando o motor rodar.`));
-            break;
-        }
-
-        /* O Codex da conta da pessoa, com o modelo barato.
-           O protocolo é o MESMO do /claude — ver lib/codex-engine.js. */
-        /* `/gpt` e `/codex` são a mesma coisa e existem os dois de propósito:
-           o programa se chama Codex, mas quem usa fala "GPT" — e o comando que
-           a pessoa tenta é o nome que ela tem na cabeça, não o do fabricante. */
-        case 'gpt': case 'codex': {
-            if (rest.toLowerCase() === 'off') {
-                if (state.engine !== 'codex') { console.log(c.muted('  Já estava no motor padrão.')); break; }
-                state.engine = 'server';
-                console.log(c.ok('  Motor: OpenRouter/Groq (padrão)'));
-                break;
-            }
-            console.log(c.dim('  Checando o Codex…'));
-            const r = codexEngine.garantirEngine();
-            if (!r.ok) {
-                console.log(c.err(`  ${r.error}`));
-                if (r.comoResolver) console.log(c.muted(`  ${r.comoResolver}`));
-                break;
-            }
-            state.engine = 'codex';
-            console.log(c.ok(`  Motor: Codex (${r.modelo})`) + c.muted('  — na sua conta, não na minha'));
-            console.log(c.muted('  /codex off volta pro motor padrão.'));
-            break;
-        }
-
-        case 'claude': {
-            if (rest.toLowerCase() === 'off') {
-                if (state.engine !== 'claude-code') { console.log(c.muted('  Já estava no motor padrão.')); break; }
-                state.engine = 'server';
-                console.log(c.ok('  Motor: OpenRouter/Groq (padrão)'));
-                break;
-            }
-            console.log(c.dim('  Checando Claude Code e ORCA…'));
-            const r = await claudeEngine.garantirEngine();
-            if (!r.ok) {
-                console.log(c.err(`  ${r.error}`));
-                if (r.comoResolver) console.log(c.muted(`  ${r.comoResolver}`));
-                break;
-            }
-            state.engine = 'claude-code';
-            const onde = r.caminho === 'A' ? 'sessão contínua via ORCA' : 'chamada avulsa (claude -p, sem ORCA)';
-            console.log(c.ok(`  Motor: Claude Code (${onde})`)
-                + c.muted(`  — ${claudeEngine.MODELO_CLAUDE || 'o padrão da sua conta'}, na sua conta`));
-            console.log(c.muted('  /claude off volta pro motor padrão.'));
-            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.
@@ -1244,6 +1354,191 @@ async function handleSlash(text) {
             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 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('  /marketplace liga e desliga · o corpo da skill só entra no pedido'));
+            console.log(c.dim('  quando o assunto bate, para não gastar o teto de tokens à toa.'));
+            break;
+        }
+
+        case 'install-skill': case 'installskill': {
+            if (!rest) {
+                console.log(c.muted('  Uso: ') + c.brand('/install-skill <caminho do SKILL.md>'));
+                console.log(c.dim('  Ou abra o ') + c.brand('/marketplace') + c.dim(' e escolha "New Skill" para escrever uma.'));
+                break;
+            }
+            const r = skills.instalarDe(rest);
+            if (!r.ok) { console.log(c.err(`  ${r.error}`)); break; }
+            console.log(c.ok(`  Skill instalada: ${r.nome}`) + c.muted(`  (${shortPath(r.caminho)})`));
+            console.log(c.dim('  Já está ligada. /skills mostra todas.'));
+            break;
+        }
+
+        /* ── /voice ──────────────────────────────────────────────────────
+         * O modo voz abre uma janelinha com uma orb — não é uma janela de
+         * terminal. O aplicativo é Python (ver voz/primo_voz); o que acontece
+         * aqui é subir ele e responder ao que ele pedir.
+         *
+         * O cérebro NÃO vai junto: cada frase transcrita volta para o mesmo
+         * `runAct` do terminal, com as mesmas ferramentas, as mesmas skills e
+         * a mesma permissão de computador. Portar o laço do agente para o
+         * Python seria manter dois laços, e dois laços do mesmo agente é a
+         * garantia de que um deles está errado.
+         */
+        case 'voice': case 'voz': {
+            const pronto = vozModo.conferir();
+            if (!pronto.ok && !pronto.instalavel) {
+                console.log(c.err(`  ${pronto.error}`));
+                if (pronto.comoResolver) console.log(c.muted(`  ${pronto.comoResolver}`));
+                break;
+            }
+
+            if (!pronto.ok) {
+                console.log(c.muted(`  ${pronto.error}`));
+                if (!(await confirm('Instalar agora?'))) {
+                    console.log(c.muted('  Sem eles o modo voz não abre.'));
+                    if (pronto.comoResolver) console.log(c.dim(`  ${pronto.comoResolver}`));
+                    break;
+                }
+                const sp = new Spinner('instalando').start();
+                const r = await vozModo.instalar(pronto.python, pronto.instalavel, () => {});
+                sp.stop();
+                if (!r.ok) {
+                    console.log(c.err(`  não deu: ${r.error}`));
+                    console.log(c.muted(`  ${pronto.comoResolver}`));
+                    break;
+                }
+                const conferido = vozModo.conferir();
+                if (!conferido.ok) {
+                    console.log(c.err(`  ainda falta: ${conferido.error}`));
+                    if (conferido.comoResolver) console.log(c.muted(`  ${conferido.comoResolver}`));
+                    break;
+                }
+            }
+
+            const py = (pronto.ok ? pronto : vozModo.conferir()).python;
+            console.log('');
+            console.log('  ' + c.bold(c.brand('Primo Code Voice')));
+            console.log('  ' + c.muted('É só falar. A orb responde: ')
+                + c.dim('parada espera · pulsa ouvindo · respira pensando · brilha falando'));
+            console.log('  ' + c.dim('Falar por cima corta a resposta · Esc ou fechar a janela encerra'));
+            console.log('');
+
+            // A caixa de digitar sai da frente: quem está no modo voz não
+            // está digitando, e uma caixa piscando embaixo é ruído.
+            if (rl && rl.suspender) rl.suspender();
+            sliderAtivo = true;
+
+            const r = await vozModo.abrir({
+                python: py,
+                servidor: state.config.server,
+                token: state.config.token,
+                voz: state.config.voz || 'antonio',
+                mostrar: (texto, deErro) => {
+                    if (deErro) console.log('  ' + c.dim(texto));
+                    else console.log('  ' + c.brand('❯ ') + c.white(texto));
+                },
+                /* O agente de verdade. A instrução de FORMA vai na frente
+                   porque resposta boa de ler é ruim de ouvir — o trabalho é o
+                   mesmo, o jeito de contar é que muda. */
+                pensar: async (texto) => {
+                    const plan = prepararPasta(texto);
+                    const resultado = await runAct(`${vozModo.COMO_FALAR}\n\nPEDIDO: ${texto}`, {
+                        server: state.config.server,
+                        model: state.config.model,
+                        effort: state.config.effort,
+                        token: state.config.token,
+                        history: memoria.paraEnviar(state.memoria, state.history),
+                        projectDir: plan.dir,
+                        projectName: plan.name || state.currentProject,
+                        ensureWorkDir: plan.pending ? () => createPendingProject(plan) : null,
+                        autorizar: autorizarControle,
+                        controle: state.controle,
+                    });
+                    const resposta = (resultado.assistantMessage && resultado.assistantMessage.content) || '';
+                    // A conversa é a MESMA do terminal: sair do modo voz e
+                    // continuar digitando não pode começar do zero.
+                    state.history.push({ role: 'user', content: texto });
+                    state.history.push({ role: 'assistant', content: resposta });
+                    const balanco = registro.resumo(resultado.registro, { colunas: process.stdout.columns || 80 });
+                    if (balanco) console.log(balanco);
+                    return resposta;
+                },
+            });
+
+            sliderAtivo = false;
+            if (rl && rl.retomar) rl.retomar();
+            if (!r.ok) console.log(c.err(`  o modo voz fechou: ${r.error}`));
+            else console.log(c.muted('  Modo voz encerrado.'));
+            break;
+        }
+
+        case 'marketplace': case 'market': {
+            await abrirMarketplace();
+            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': case 'conectores': {
+            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. "Se mandar /rc pra ele, ele abre o aplicativo — para o
            Mac e o Windows, já instalado junto com o npm, com as cores do
            PrimoCode. Um chat estilo terminal para quem não quer o terminal."
@@ -1332,29 +1627,31 @@ async function handleSlash(text) {
                 abrir: (u) => tools.openInBrowser(u),
                 contar: (info) => {
                     sp.stop();
-                    /* O CÓDIGO NÃO APARECE MAIS NO TERMINAL.
-                     *
-                     *   "Pode tirar essa parte no login onde aparece o código
-                     *    — o terminal mandou o código, pode tirar."
-                     *
-                     * A página do token já resolve o pareamento sozinha: ela
-                     * pergunta o código ao 127.0.0.1 desta máquina, e onde o
-                     * navegador bloqueia isso (Safari) ela oferece "Colar" —
-                     * o código continua indo para a área de transferência,
-                     * que é o caminho sem leitura. Oito letras impressas aqui
-                     * eram uma tarefa para a pessoa que o produto já não
-                     * precisa, e a tela ficava dizendo que talvez precisasse.
-                     *
-                     * O código continua existindo no protocolo (lib/conta.js)
-                     * — some da TELA, não do pareamento. */
+                    const meio = info.codigo.length === 8
+                        ? info.codigo.slice(0, 4) + '-' + info.codigo.slice(4) : info.codigo;
                     console.log(c.muted('  Abrindo no navegador:'));
                     console.log('  ' + c.brand(info.url.replace(/[?&]porta=\d+/, '')));
                     console.log('');
-                    console.log('  ' + c.white('Entre com a sua conta na página que abriu — o resto é automático.'));
-                    if (!info.porta && info.copiado) {
-                        // Sem a porta local, quem fecha o pareamento é a área de
-                        // transferência: a página pede um toque em "Colar".
-                        console.log(c.dim('  Se a página pedir para colar, é só colar — já está na sua área de transferência.'));
+                    if (info.porta) {
+                        /* COM O SERVIDOR LOCAL DE PÉ, NÃO HÁ CÓDIGO PARA LER. A
+                           página pergunta ao 127.0.0.1 desta máquina, recebe o
+                           código e aprova sozinha assim que a pessoa entra com a
+                           conta — "não precisa colocar código, não precisa pra
+                           nada, porque ele já libera". Mostrar as oito letras
+                           grandes aqui era pedir para ler o que ninguém precisa
+                           mais; elas ficam numa linha apagada, só para o caso
+                           de o navegador bloquear o 127.0.0.1 (Safari) e a
+                           página voltar a pedir. */
+                        console.log('  ' + c.white('Entre com a sua conta na página que abriu — o resto é automático.'));
+                        console.log(c.dim(`  Se a página pedir um código: ${meio}${info.copiado ? ' (já copiado)' : ''}.`));
+                    } else {
+                        /* Sem porta local (ocupadas, ou bloqueadas), o código
+                           volta a ser o caminho — grande, partido em dois,
+                           porque é o que se lê de uma tela e se confere noutra. */
+                        console.log('    ' + c.bold(c.brand(meio.split('').join(' '))));
+                        console.log('');
+                        console.log(c.dim('  ' + (info.copiado ? 'O código já está copiado — cole na página.'
+                            : 'Digite o código na página.')));
                     }
                     console.log(c.dim('  Esperando o navegador…'));
                 },
@@ -1467,6 +1764,25 @@ async function handleSlash(text) {
         // rl.close() em vez de process.exit(): sair na marra descarta o que
         // ainda estava no buffer de saída.
         case 'exit': case 'quit': if (rl) rl.close(); break;
+        /* ── 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 'claude': case 'gpt': case 'codex': case 'key': case 'keys': {
+            console.log(c.muted('  Não existe mais provedor para configurar.'));
+            console.log(c.muted('  A API já vem com o PrimoCode: entrou na conta, pode usar.'));
+            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.
@@ -1611,7 +1927,11 @@ async function main() {
         userName: state.config.userName,
         pastaPadrao: state.workDirOrigem === 'padrao',
     }));
-    rl = readline.createInterface({ input: process.stdin, output: process.stdout, prompt: makePrompt(), completer: completarSlash });
+    rl = entrada.criar({
+        status: barraDeStatus,
+        comandos: () => SLASH_COMANDOS,
+        vazio: 'peça alguma coisa, ou / para os comandos',
+    });
 
     rl.prompt();
 
@@ -1622,57 +1942,31 @@ async function main() {
     let closed = false;
     let saidBye = false;
 
-    // ── Sugestão fantasma: o autopreenchimento VISÍVEL enquanto digita ──
-    // "/str" mostra "eaming" esmaecido na frente do cursor, como o Claude
-    // Code. Seta → (ou Tab) aceita; Enter com o pedaço já executa. Desenhada
-    // DEPOIS de o readline processar a tecla (setImmediate), por cima do que
-    // sobrou da linha (\\x1b[0K limpa), e o cursor volta para o lugar.
-    if (process.stdin.isTTY && process.stdout.isTTY) {
-        let fantasma = '';
-        const desenharFantasma = () => {
-            if (busy || pendingAsk || sliderAtivo || !rl) return;
-            const linha = rl.line;
-            const noFim = rl.cursor === linha.length;
-            fantasma = '';
-            if (noFim && linha.startsWith('/') && !/\s/.test(linha) && linha.length > 1) {
-                const baixa = linha.toLowerCase();
-                const hit = SLASH_COMANDOS.map(([n]) => n).find((n) => n.startsWith(baixa) && n.length > linha.length);
-                if (hit) fantasma = hit.slice(linha.length);
-            }
-            if (!noFim) return;   // cursor no meio: não mexe no que vem depois dele
-            // Limpa resto da linha (fantasma antigo) e desenha o novo, voltando o cursor.
-            process.stdout.write('\x1b[0K' + (fantasma ? `\x1b[2m${fantasma}\x1b[0m\x1b[${fantasma.length}D` : ''));
-        };
-        // ── Esc Esc: parar o agente no meio do trabalho ──
-        // Um Esc avisa; o segundo (em até 2s) manda parar. Dois Escs tão
-        // rápidos que chegam colados num chunk só viram UMA tecla com
-        // sequence "\x1b\x1b" — vale como os dois.
-        let ultimoEsc = 0;
-        process.stdin.on('keypress', (ch, key) => {
-            if (sliderAtivo) return;   // o slider é dono do teclado enquanto está no ar
-            if (key && (key.name === 'escape' || key.sequence === '\x1b\x1b')) {
-                if (!busy) { ultimoEsc = 0; return; }   // sem agente rodando, Esc é só Esc
-                const agora = Date.now();
-                if (key.sequence === '\x1b\x1b' || agora - ultimoEsc < 2000) {
-                    ultimoEsc = 0;
-                    interromper();
-                    if (chatEmVoo) { try { chatEmVoo.abort(); } catch {} }
-                    process.stdout.write('\n' + c.warn('  ⏹ parando o agente…') + '\n');
-                } else {
-                    ultimoEsc = agora;
-                    process.stdout.write('\n' + c.dim('  Esc de novo para parar o agente') + '\n');
-                }
-                return;
-            }
-            // Seta → no fim da linha aceita a sugestão inteira.
-            if (key && key.name === 'right' && fantasma && rl && rl.cursor === rl.line.length) {
-                const resto = fantasma;
-                fantasma = '';
-                rl.write(resto);
-            }
-            setImmediate(desenharFantasma);
-        });
-    }
+    /* ── 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/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());
 
     function sayBye() {
         if (saidBye) return;
@@ -1695,6 +1989,10 @@ async function main() {
     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;
@@ -1706,6 +2004,8 @@ async function main() {
             }
         }
         busy = false;
+        state.trabalhando = false;
+        if (rl.trabalhando) rl.trabalhando(false);
         // 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();
@@ -1713,10 +2013,6 @@ async function main() {
     }
 
     rl.on('line', (line) => {
-        // A lista de setinhas (e o slider do /effort) são donos do teclado
-        // enquanto estão no ar: o Enter que confirma a escolha não é uma
-        // linha para a fila, e sem isto ele vira um pedido em branco.
-        if (sliderAtivo) return;
         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; }
@@ -1752,31 +2048,7 @@ async function main() {
         interativo: !!(process.stdin.isTTY && process.stdout.isTTY),
         conectado: () => conta.atual(),
         conectar: () => handleSlash('/connect').then(() => conta.atual()),
-        /* A ESCOLHA, COM AS SETINHAS — E O QUE FOI DIGITADO ANTES DELA.
-         *
-         * A lista só aparece depois de o plano voltar do servidor, e quem
-         * colou "3⏎1⏎/version" já respondeu antes de ver. Esse texto está em
-         * `adiantadas`; se a lista ignorasse, a resposta se perderia e o
-         * menu ficaria esperando um teclado que já falou. Então: primeiro o
-         * que foi adiantado (se casar com algum item), depois as setinhas. O
-         * que não casa fica na fila — é comando, não resposta. */
-        selecionar: ({ titulo, ajuda, lista }) => {
-            while (adiantadas.length) {
-                const dito = String(adiantadas[0] || '').trim();
-                if (!dito) { adiantadas.shift(); continue; }
-                const qual = boasVindas.escolher(dito, lista);
-                if (!qual) break;                       // isso é comando, não escolha
-                adiantadas.shift();
-                const item = lista.find((e) => e.id === qual);
-                console.log('');
-                console.log(c.bold(c.brand('  ' + titulo)));
-                console.log(c.brand('  ❯ ') + c.white(item ? item.titulo : qual));
-                return Promise.resolve(qual);
-            }
-            return menuSetas({ titulo, ajuda, lista });
-        },
         sessao: () => conta.sessao(),
-        aplicar: (cmd) => handleSlash(cmd),
     }).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 é