primocode 8.33.1 → 8.34.1

package/bin/primocode.js

@@ -63,6 +63,12 @@ const state = {
     // 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(),
+    /* 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: '',
     currentProject: null,
     workDir: null,     // pasta onde o agente trabalha nesta sessão
@@ -80,7 +86,6 @@ ${c.bold('Comandos')}
   ${c.brand('/project')}              lista projetos ou cria em ~/primocode: /project <nome>
   ${c.brand('/mode')}                 /mode primocode|chat|auto
   ${c.brand('/effort')}               esforço do agente — do rápido ao mais esperto
-  ${c.brand('/claude')}               liga o Claude Code local como motor (sem API paga) · /claude off volta ao padrão
   ${c.brand('/attach')} <arquivo>     anexa arquivo ao próximo pedido
   ${c.brand('/files')}                lista anexos   ${c.brand('/detach')} remove
   ${c.brand('/tudo')}                 lista tudo que ele sabe fazer
@@ -90,7 +95,7 @@ ${c.bold('Comandos')}
   ${c.brand('/open')} <arquivo|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('/codex')}                usa o Codex da SUA conta como motor (modelo barato)
+  ${c.brand('/gpt')}                  usa o GPT (Codex) da SUA conta como motor
   ${c.brand('/chave')} <provedor>    sua própria chave de API (Claude, Codex)
   ${c.brand('/conectar')}             entra na sua conta Conecta Primo · ${c.brand('/conta')} mostra o plano
   ${c.brand('/conversas')} [n]        suas conversas salvas — as mesmas do app e do celular
@@ -126,7 +131,6 @@ const SLASH_COMANDOS = [
     ['/dir', 'trabalhar numa pasta sua'],
     ['/mode', 'primocode | chat | auto'],
     ['/effort', 'esforço: low → ultracode (←/→ para ajustar)'],
-    ['/claude', 'liga o Claude Code local como motor · /claude off volta ao padrão'],
     ['/attach', 'anexa arquivo ao pedido'],
     ['/detach', 'remove os anexos'],
     ['/files', 'lista os anexos'],
@@ -137,7 +141,7 @@ const SLASH_COMANDOS = [
     ['/open', 'abre no navegador'],
     ['/rc', 'abre a janela do PrimoCode'],
     ['/claude', 'usa o Claude Code da sua conta como motor'],
-    ['/codex', 'usa o Codex da sua conta como motor'],
+    ['/gpt', 'usa o GPT (Codex) da sua conta como motor'],
     ['/chave', 'sua própria chave de API (Claude, Codex)'],
     ['/conectar', 'entra na sua conta Conecta Primo'],
     ['/conta', 'sua conta, plano e computadores conectados'],
@@ -264,9 +268,31 @@ function refreshPrompt() { if (rl) rl.setPrompt(makePrompt()); }
 // — 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); pendingAsk = resolve; return; }
+        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); });
     });
@@ -420,6 +446,22 @@ function prepararPasta(userText) {
 }
 
 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
+       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 o plano Premium ou Super.'));
+        console.log(c.muted('  Assine em ') + c.brand('conecta-primo-ai.vercel.app')
+            + c.muted(' · já assinou? ') + c.brand('/conectar'));
+        return;
+    }
+
     let prompt = userText;
     if (state.attachedFiles.length) {
         const parts = state.attachedFiles.map((f) => `Arquivo: ${f.path}\n\`\`\`\n${f.content}\n\`\`\``);
@@ -821,7 +863,10 @@ async function handleSlash(text) {
 
         /* O Codex da conta da pessoa, com o modelo barato.
            O protocolo é o MESMO do /claude — ver lib/codex-engine.js. */
-        case 'codex': {
+        /* `/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';
@@ -1504,40 +1549,56 @@ async function main() {
 
     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; }
         queue.push(line);
         drain();
     });
 
     rl.on('close', () => { closed = true; if (!busy) sayBye(); });
 
-    /* A primeira vez — e ela roda AQUI, depois de `line` e `close` existirem.
+    /* A ABERTURA — e ela roda AQUI, depois de `line` e `close` existirem.
      *
-     * Estava lá em cima, logo depois de criar o readline. Parecia certo e
-     * estava errado: o `await` do assistente segurava o resto do main(), e
-     * tudo o que chegasse pelo teclado nesse meio-tempo caía no vazio, porque
-     * ainda não havia ouvinte de `line` para pegar. Quem colasse dois comandos
-     * de uma vez perdia o segundo, e quem fechasse a entrada (Ctrl+D, um
-     * script) saía sem nem o "Até logo" — porque o ouvinte de `close` também
-     * ainda não existia.
+     * 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.
      *
-     * Digitando devagar ninguém via: os ouvintes ficavam prontos milissegundos
-     * depois. Foi preciso um terminal de mentira mandando as linhas de uma vez
-     * para o defeito aparecer.
+     * `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?".
      *
-     * Aparece UMA vez; depois disso, /conectar e /chave é que são o caminho. */
-    if (!boasVindas.jaAbriu({ arquivoConfig: cfg.CONFIG_FILE })) {
-        boasVindas.rodar({
-            perguntar: ask,
-            mostrar: (t) => console.log(t),
-            cores: c,
-            interativo: !!(process.stdin.isTTY && process.stdout.isTTY),
-            conectar: () => handleSlash('/conectar'),
-            configurarChave: () => handleSlash('/chave'),
-        }).then(() => { if (!closed && !busy) rl.prompt(); })
-          // Um assistente que falha não pode levar o CLI junto: ele é uma
-          // apresentação, não uma condição para usar o programa.
-          .catch(() => {});
-    }
+     * 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('/conectar').then(() => conta.atual()),
+        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 é
+        // o primocode-server, que tem a chave do provedor.
+        state.liberado = !r || r.liberado !== false;
+        state.motivoBloqueio = r && r.motivo;
+    }).catch(() => { state.liberado = true; }).then(() => {
+        // O que sobrou de adiantado não era resposta de nada: vira comando,
+        // na ordem em que foi digitado. Nada se perde, só esperou a vez.
+        segurando = false;
+        while (adiantadas.length) queue.push(adiantadas.shift());
+        if (queue.length) drain();
+        else if (!closed) rl.prompt();
+    });
 }
 
 main().catch((e) => { console.error(c.err(e.message || e)); process.exit(1); });

package/lib/boas-vindas.js

@@ -1,26 +1,40 @@
 /**
- * boas-vindas.js — a primeira vez que alguém roda `primo`.
+ * boas-vindas.js — a abertura do PrimoCode.
  *
- *   "Eu desinstalei e instalei novamente, está na versão nova, e quando mandei
- *    ele já abriu. Não veio a parte pra mim fazer login, selecionar qual IA eu
- *    quero — se quero usar já o Conecta Primo AI como IA, se quero usar outra
- *    IA. Não tem nada disso."
+ *   "O usuário vai rodar o comando de instalação do npm, vai instalar, vai
+ *    rodar `primo`, e aí, como acabou de instalar, vai aparecer pra fazer
+ *    login. Ele vai abrir automaticamente a janela lá no Conecta Primo AI com
+ *    o token, tudo pra fazer login na conta. Aí fez o login, o terminal checa
+ *    se sua conta é Premium ou Super. Se for, ele libera para a próxima etapa.
+ *    Se não, ele fala que você não tem acesso ao PrimoCode, porque tem que ter
+ *    o plano Premium ou Super.
  *
- * Tinha razão: o CLI abria direto no prompt. Quem instalava não descobria que
- * existe conta, não descobria que dá para usar a própria chave, e ia usar o
- * gratuito achando que era só aquilo — até bater na cota e concluir que o
- * produto não presta.
+ *    A próxima etapa, se liberar o acesso, é selecionar: continuar com a API
+ *    padrão, ou usar conta Claude, GPT etc. Continuar com a API padrão, ele
+ *    libera e aparece aquela tela pronta pra enviar o primeiro pedido. Se
+ *    clicar em continuar com Claude/GPT, você seleciona, deu Enter, ele vai
+ *    pra próxima tela, e aí você seleciona Claude ou GPT — e quando seleciona,
+ *    ele dá aquele /gpt ou /claude, e vai funcionar como já funciona hoje."
  *
- * ── POR QUE ISTO É UM MÓDULO, E NÃO CÓDIGO SOLTO NO bin/ ─────────────────
- * Porque tem decisão dentro: quando aparecer, o que perguntar, o que gravar,
- * e o que fazer quando a pessoa só aperta Enter. Isso precisa de teste, e
- * teste não digita em terminal. Aqui a entrada e a saída são funções que o
- * teste passa; o bin/ liga nas de verdade.
+ * ── A ORDEM É O PRODUTO ──────────────────────────────────────────────────
+ * Conectar → conferir o plano → escolher o motor. Nesta ordem, e não em
+ * outra. A primeira versão disto oferecia o login como UMA OPÇÃO de menu, ao
+ * lado de "decidir depois", e deixava quem não assina usar assim mesmo. Era
+ * um produto diferente do que foi pedido.
  *
- * ── APARECE UMA VEZ SÓ, E DÁ PARA PULAR ──────────────────────────────────
- * Um assistente que volta toda vez vira obstáculo. Este grava a marca de que
- * já rodou e não volta — nem se a pessoa escolher "depois". Quem quiser
- * rever chama `/conectar` ou `/chave`, que é onde as duas coisas moram.
+ * ── O BLOQUEIO É DELIBERADO ──────────────────────────────────────────────
+ * Sem Premium ou Super, o PrimoCode não trabalha. Isso é uma decisão de
+ * produto do dono, tomada com o custo na mesa: quem já instalou no gratuito
+ * perde o acesso na atualização. Está escrito aqui para ninguém "consertar"
+ * isso mais adiante achando que é bug.
+ *
+ * O bloqueio é de CORTESIA, não de segurança: este arquivo vai publicado no
+ * npm com o código à vista e qualquer um apaga a checagem. Quem segura de
+ * verdade é o primocode-server, que é quem tem a chave do provedor.
+ *
+ * ── POR QUE ISTO É UM MÓDULO ─────────────────────────────────────────────
+ * Porque tem decisão dentro, e decisão precisa de teste — e teste não digita
+ * em terminal. Aqui a entrada e a saída são funções que quem chama fornece.
  */
 
 'use strict';
@@ -31,131 +45,201 @@ const path = require('path');
 
 const MARCA = () => path.join(os.homedir(), '.primocode', 'ja-abriu.json');
 
-/**
- * Já passou por aqui?
- *
- * Duas provas, e basta uma: a marca própria, ou um config.json que já existe
- * de uma versão anterior. A segunda evita que quem já usava o PrimoCode há
- * meses veja um "bem-vindo, é sua primeira vez" ao atualizar — o que faria a
- * atualização parecer uma reinstalação, e é o tipo de coisa que assusta.
- */
-function jaAbriu({ arquivoConfig } = {}) {
-    try { if (fs.existsSync(MARCA())) return true; } catch {}
-    try { if (arquivoConfig && fs.existsSync(arquivoConfig)) return true; } catch {}
-    return false;
+/** Já escolheu o motor alguma vez? A marca guarda a escolha, não o login. */
+function jaEscolheu() {
+    try { return fs.existsSync(MARCA()); } catch { return false; }
 }
 
-function marcarQueAbriu(dados = {}) {
+function marcar(dados = {}) {
     try {
         const caminho = MARCA();
         fs.mkdirSync(path.dirname(caminho), { recursive: true });
-        fs.writeFileSync(caminho, JSON.stringify({
-            em: new Date().toISOString(), ...dados,
-        }, null, 2), 'utf8');
+        fs.writeFileSync(caminho, JSON.stringify({ em: new Date().toISOString(), ...dados }, null, 2), 'utf8');
         return true;
     } catch { return false; }
 }
 
-/** Para o teste e para quem quiser rever: apaga a marca. */
 function esquecer() {
     try { fs.rmSync(MARCA(), { force: true }); return true; } catch { return false; }
 }
 
-const ESCOLHAS = [
-    {
-        id: 'conecta',
-        titulo: 'Usar a IA do Conecta Primo AI',
-        detalhe: 'A que já vem pronta. Entra na sua conta; Premium ou Super libera o limite.',
-    },
-    {
-        id: 'propria',
-        titulo: 'Usar a minha própria IA',
-        detalhe: 'Sua chave do Claude ou do Codex, ou o Claude Code / Codex já instalados.',
-    },
-    {
-        id: 'depois',
-        titulo: 'Decidir depois',
-        detalhe: 'Começa no gratuito. /conectar e /chave estão lá quando você quiser.',
-    },
+// ── as duas telas de escolha ─────────────────────────────────────────────
+
+const MOTORES = [
+    { id: 'padrao', titulo: 'Continuar com a API padrão',
+        detalhe: 'A que já vem pronta, incluída no seu plano.' },
+    { id: 'propria', titulo: 'Usar a minha conta (Claude, GPT…)',
+        detalhe: 'O Claude Code ou o Codex que você já usa, na sua assinatura.' },
 ];
 
-/** O que a pessoa digitou → qual escolha. Aceita número, o id, ou Enter. */
-function lerEscolha(texto) {
-    const t = String(texto || '').trim().toLowerCase();
-    // Enter puro é a primeira opção: é a recomendada, e quem aperta Enter sem
-    // ler está dizendo "faz o que for melhor", não "não quero nada".
-    if (!t) return ESCOLHAS[0].id;
-    const n = Number(t);
-    if (Number.isInteger(n) && n >= 1 && n <= ESCOLHAS.length) return ESCOLHAS[n - 1].id;
-    for (const e of ESCOLHAS) if (t === e.id || t.startsWith(e.id.slice(0, 4))) return e.id;
-    if (/^(n|nao|não|depois|pular|skip)$/.test(t)) return 'depois';
-    if (/claude|codex|chave|propri/.test(t)) return 'propria';
-    if (/conecta|primo|conta|entrar/.test(t)) return 'conecta';
-    return null;      // não entendi: quem chama pergunta de novo
-}
+const PROVEDORES = [
+    { id: 'claude', titulo: 'Claude', comando: '/claude',
+        detalhe: 'Usa o Claude Code da sua conta, no Opus.' },
+    { id: 'gpt', titulo: 'GPT', comando: '/gpt',
+        detalhe: 'Usa o Codex da sua conta, num modelo barato.' },
+];
 
 /**
- * O assistente.
+ * O que a pessoa digitou → qual item da lista.
  *
- * @param {object} op
- * @param {(q:string)=>Promise<string>} op.perguntar  lê uma linha
- * @param {(s:string)=>void} op.mostrar               escreve na tela
- * @param {object} op.cores                           o `c` do ui.js
- * @param {()=>Promise<any>} op.conectar              roda o login (o /conectar)
- * @param {()=>Promise<any>} op.configurarChave       abre o /chave
- * @param {boolean} op.interativo                     false = não pergunta nada
+ * Aceita o número, o id, o começo do nome, e Enter (que é sempre o primeiro:
+ * quem aperta Enter sem ler está dizendo "faz o que for melhor").
  */
-async function rodar({ perguntar, mostrar, cores: c, conectar, configurarChave,
-    interativo = true } = {}) {
-    /* Sem terminal de verdade (pipe, script, CI) NÃO se pergunta nada. Um
-       assistente que espera resposta num lugar onde ninguém pode responder
-       trava o processo para sempre — e trava calado, que é o pior jeito. */
-    if (!interativo) {
-        marcarQueAbriu({ escolha: 'sem-terminal' });
-        return { ok: true, escolha: 'depois', perguntou: false };
+function escolher(texto, lista) {
+    const t = String(texto || '').trim().toLowerCase();
+    if (!t) return lista[0].id;
+    const n = Number(t);
+    if (Number.isInteger(n) && n >= 1 && n <= lista.length) return lista[n - 1].id;
+    for (const e of lista) {
+        if (t === e.id || t === e.titulo.toLowerCase()) return e.id;
+        if (e.id.length >= 3 && t.startsWith(e.id.slice(0, 3))) return e.id;
+    }
+    // O jeito como as pessoas falam, e não como a lista se chama.
+    if (lista === MOTORES) {
+        if (/padr|inclu|mesmo|pronta|voc[eê]s|de voc/.test(t)) return 'padrao';
+        if (/minha|meu|pr[oó]pri|conta|chave|assinatura/.test(t)) return 'propria';
+    } else {
+        if (/claude|anthropic|opus|sonnet/.test(t)) return 'claude';
+        if (/gpt|openai|codex|chatgpt/.test(t)) return 'gpt';
     }
+    return null;
+}
 
+async function perguntarDaLista({ perguntar, mostrar, cores: c, titulo, ajuda, lista }) {
     mostrar('');
-    mostrar(c.bold(c.brand('  Primeira vez por aqui.')));
-    mostrar(c.muted('  Escolha qual IA vai pensar por trás do PrimoCode:'));
+    mostrar(c.bold(c.brand('  ' + titulo)));
+    if (ajuda) mostrar(c.muted('  ' + ajuda));
     mostrar('');
-    ESCOLHAS.forEach((e, i) => {
-        mostrar('  ' + c.brand(String(i + 1)) + c.muted('. ') + c.white(e.titulo)
-            + (i === 0 ? c.dim('  (recomendado)') : ''));
+    lista.forEach((e, i) => {
+        mostrar('  ' + c.brand(String(i + 1)) + c.muted('. ') + c.white(e.titulo));
         mostrar('     ' + c.dim(e.detalhe));
     });
     mostrar('');
 
-    let escolha = null;
-    for (let tentativa = 0; tentativa < 3 && !escolha; tentativa++) {
-        const dito = await perguntar(c.brand('  ❯ ') + c.muted('1, 2 ou 3 (Enter = 1) '));
-        escolha = lerEscolha(dito);
-        if (!escolha) mostrar(c.muted('  Não entendi. Digite 1, 2 ou 3.'));
+    for (let tentativa = 0; tentativa < 3; tentativa++) {
+        const dito = await perguntar(c.brand('  ❯ ')
+            + c.muted(`1 a ${lista.length} (Enter = 1) `));
+        const qual = escolher(dito, lista);
+        if (qual) return qual;
+        mostrar(c.muted(`  Não entendi. Digite 1 a ${lista.length}.`));
     }
-    // Três tentativas sem entender: segue no gratuito em vez de insistir.
-    // Ninguém deve ficar preso numa pergunta para usar o programa.
-    if (!escolha) escolha = 'depois';
+    // Três tentativas sem entender: fica com a primeira em vez de prender
+    // alguém numa pergunta para usar o programa.
+    return lista[0].id;
+}
+
+// ── a abertura ───────────────────────────────────────────────────────────
+
+/**
+ * @param {object} op
+ * @param {(q:string)=>Promise<string>} op.perguntar
+ * @param {(s:string)=>void} op.mostrar
+ * @param {object} op.cores
+ * @param {boolean} op.interativo      false = pipe/CI: não pergunta nada
+ * @param {()=>any} op.conectado       a credencial local, ou null
+ * @param {()=>Promise<any>} op.conectar   roda o login (abre o navegador)
+ * @param {()=>Promise<any>} op.sessao     confirma o plano NO SERVIDOR
+ * @param {(cmd:string)=>Promise<any>} op.aplicar   executa /claude ou /gpt
+ */
+async function rodar({ perguntar, mostrar, cores: c, interativo = true,
+    conectado, conectar, sessao, aplicar } = {}) {
 
-    let resultado = { escolha };
-    if (escolha === 'conecta' && conectar) {
+    /* Sem terminal de verdade (pipe, script, CI) não se pergunta nada — uma
+       pergunta onde ninguém pode responder trava o processo para sempre, e
+       trava calado. Também não se BLOQUEIA: quem chamou não pode fazer login,
+       e barrar aqui transformaria um script quebrado num script mudo. Quem
+       segura de verdade é o servidor. */
+    if (!interativo) return { liberado: true, motivo: 'sem-terminal', perguntou: false };
+
+    // ── 1. conectar ──────────────────────────────────────────────────────
+    let credencial = conectado ? conectado() : null;
+    if (!credencial) {
+        mostrar('');
+        mostrar(c.bold(c.brand('  Bem-vindo ao PrimoCode.')));
+        mostrar(c.muted('  Primeiro, entre na sua conta do Conecta Primo AI.'));
+        mostrar(c.dim('  Vou abrir o navegador; é só confirmar por lá.'));
+        mostrar('');
+        const r = await conectar();
+        if (!r || r.ok === false) {
+            mostrar('');
+            mostrar(c.err('  Não deu para conectar' + (r && r.error ? `: ${r.error}` : '.')));
+            mostrar(c.muted('  Tente de novo com ') + c.brand('/conectar') + c.muted('.'));
+            return { liberado: false, motivo: 'sem-login' };
+        }
+        credencial = conectado ? conectado() : { plano: r.plano };
+    }
+
+    // ── 2. o plano ───────────────────────────────────────────────────────
+    const s = await sessao();
+    if (s && s.offline) {
+        /* Sem rede não se decide. Bloquear alguém porque o wi-fi tropeçou
+           seria transformar um problema de rede num "você não tem acesso" —
+           e a pessoa iria conferir a assinatura, que está em dia. Vale o
+           último plano conhecido; quem confere de verdade é o servidor, na
+           primeira chamada que sair daqui. */
+        mostrar(c.muted('  Sem rede para confirmar o plano — seguindo com o último conhecido.'));
+    } else if (!s || !s.ok) {
+        mostrar('');
+        mostrar(c.err('  Não consegui confirmar sua conta' + (s && s.error ? `: ${s.error}` : '.')));
+        mostrar(c.muted('  Entre de novo com ') + c.brand('/conectar') + c.muted('.'));
+        return { liberado: false, motivo: 'sessao-invalida' };
+    }
+
+    const plano = (s && s.ok ? s.plano : credencial && credencial.plano) || 'free';
+    const pro = s && s.ok ? !!s.pro : !!(credencial && credencial.pro);
+    if (!pro) {
+        mostrar('');
+        mostrar(c.err('  Você ainda não tem acesso ao PrimoCode.'));
+        mostrar(c.muted(`  Sua conta está no plano ${plano}, e o PrimoCode pede `)
+            + c.brand('Premium') + c.muted(' ou ') + c.brand('Super') + c.muted('.'));
+        mostrar('');
+        mostrar(c.dim('  Assine em ') + c.brand('conecta-primo-ai.vercel.app')
+            + c.dim(' e rode ') + c.brand('primo') + c.dim(' de novo.'));
+        mostrar(c.dim('  Já assinou? ') + c.brand('/conectar')
+            + c.dim(' atualiza o plano nesta máquina.'));
         mostrar('');
-        resultado.conexao = await conectar();
-    } else if (escolha === 'propria' && configurarChave) {
+        return { liberado: false, motivo: 'sem-plano', plano };
+    }
+
+    mostrar('');
+    mostrar(c.ok('  Conta liberada.') + c.muted(`  Plano ${plano}.`));
+
+    // ── 3. o motor ───────────────────────────────────────────────────────
+    // Só na primeira vez: quem já escolheu não quer responder isso toda vez.
+    if (jaEscolheu()) return { liberado: true, motivo: 'ja-escolheu', plano, perguntou: false };
+
+    const motor = await perguntarDaLista({
+        perguntar, mostrar, cores: c,
+        titulo: 'Com qual IA você quer trabalhar?',
+        lista: MOTORES,
+    });
+
+    if (motor === 'padrao') {
+        marcar({ motor: 'padrao', plano });
         mostrar('');
-        resultado.chave = await configurarChave();
-    } else if (escolha === 'depois') {
+        mostrar(c.muted('  Pronto. Pode pedir a primeira coisa.'));
         mostrar('');
-        mostrar(c.muted('  Tudo bem. Você está no gratuito — ele funciona, mas tem cota.'));
-        mostrar(c.dim('  ') + c.brand('/conectar') + c.dim(' entra na sua conta · ')
-            + c.brand('/chave') + c.dim(' usa a sua própria IA'));
+        return { liberado: true, motor: 'padrao', plano, perguntou: true };
     }
 
-    // A marca é gravada DEPOIS de tudo, mas grava mesmo se o login falhar:
-    // insistir no assistente a cada abertura porque a rede caiu uma vez
-    // seria punir a pessoa por um problema que não é dela.
-    marcarQueAbriu({ escolha });
+    // ── 4. qual provedor ─────────────────────────────────────────────────
+    const qual = await perguntarDaLista({
+        perguntar, mostrar, cores: c,
+        titulo: 'Qual conta?',
+        ajuda: 'Ele usa o programa que você já tem instalado e logado.',
+        lista: PROVEDORES,
+    });
+    const escolhido = PROVEDORES.find((p) => p.id === qual) || PROVEDORES[0];
+
+    marcar({ motor: escolhido.id, plano });
+    mostrar('');
+    if (aplicar) await aplicar(escolhido.comando);
     mostrar('');
-    return { ok: true, perguntou: true, ...resultado };
+    return { liberado: true, motor: escolhido.id, comando: escolhido.comando,
+        plano, perguntou: true };
 }
 
-module.exports = { jaAbriu, marcarQueAbriu, esquecer, lerEscolha, rodar, ESCOLHAS, MARCA };
+module.exports = {
+    rodar, jaEscolheu, marcar, esquecer, escolher,
+    MOTORES, PROVEDORES, MARCA,
+};

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "primocode",
-  "version": "8.33.1",
-  "description": "PrimoCode — agente de engenharia com IA e cursor próprio. Modelos grátis. Cria arquivos, roda comandos, controla navegador e desktop: abre apps, clica em botões e ícones pelo nome, digita e usa atalhos.",
+  "version": "8.34.1",
+  "description": "PrimoCode — agente de engenharia com IA e cursor próprio. Requer conta Conecta Primo AI (Premium ou Super). Cria arquivos, roda comandos, controla navegador e desktop: abre apps, clica em botões e ícones pelo nome, digita e usa atalhos.",
   "main": "bin/primocode.js",
   "bin": {
     "primocode": "bin/primocode.js"