primocode 8.31.0 → 8.32.0

package/bin/primocode.js

@@ -21,6 +21,8 @@ const tools = require('../lib/tools');
 const cfg = require('../lib/config');
 const { runAct, interromper } = require('../lib/act');
 const claudeEngine = require('../lib/claude-engine');
+const codexEngine = require('../lib/codex-engine');
+const chaves = require('../lib/chaves');
 const pasta = require('../lib/pasta');
 const catalogo = require('../lib/catalogo');
 const effort = require('../lib/effort');
@@ -64,7 +66,7 @@ const state = {
     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)
+    engine: 'server',   // 'server' (OpenRouter/Groq) | 'claude-code' (/claude) | 'codex' (/codex)
 };
 
 // A janela do /app, quando aberta. Uma por sessão: o segundo /app traz a que
@@ -86,6 +88,9 @@ ${c.bold('Comandos')}
   ${c.brand('/run')} <comando>        executa no shell do projeto
   ${c.brand('/open')} <arquivo|url>   abre no navegador
   ${c.brand('/app')}                  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('/chave')} <provedor>    sua própria chave de API (Claude, Codex)
   ${c.brand('/entrar')}               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
   ${c.brand('/sair')}                 desconecta este computador
@@ -130,6 +135,9 @@ const SLASH_COMANDOS = [
     ['/run', 'roda um comando'],
     ['/open', 'abre no navegador'],
     ['/app', 'abre a janela do PrimoCode'],
+    ['/claude', 'usa o Claude Code da sua conta como motor'],
+    ['/codex', 'usa o Codex da sua conta como motor'],
+    ['/chave', 'sua própria chave de API (Claude, Codex)'],
     ['/entrar', 'entra na sua conta Conecta Primo'],
     ['/conta', 'sua conta, plano e computadores conectados'],
     ['/conversas', 'suas conversas salvas, as mesmas do app e do celular'],
@@ -483,7 +491,7 @@ 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: state.engine === 'claude-code' ? claudeEngine : api,
+                motor: motorDaVez(),
             });
 
             r = await rodarPasso();
@@ -656,6 +664,17 @@ 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('/'); }
 
 async function handleSlash(text) {
@@ -755,6 +774,72 @@ 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 'chave': case 'chaves': {
+            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  /chave claude sk-ant-…   guarda a chave'));
+                console.log(c.dim('  /chave codex 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(`/chave ${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. */
+        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; }
@@ -771,7 +856,8 @@ async function handleSlash(text) {
             }
             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})`));
+            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;
         }

package/lib/chaves.js

@@ -0,0 +1,149 @@
+/**
+ * chaves.js — a chave de API da própria pessoa.
+ *
+ *   "Você vai usar com a API que já está ali, e pode configurar sua própria
+ *    API, por exemplo do Claude, do Codex, etc."
+ *
+ * ── ONDE ELAS MORAM ──────────────────────────────────────────────────────
+ * Em `~/.primocode/chaves.json`, com permissão 600 — o mesmo lugar e o mesmo
+ * cuidado da credencial da conta, e pela mesma razão: o `config.json` é o
+ * arquivo que alguém abre para conferir um ajuste, cola num chamado de
+ * suporte ou copia para outra máquina. Chave junto de preferência é chave que
+ * vaza por hábito, não por ataque.
+ *
+ * ── COMO ELAS CHEGAM AO MOTOR ────────────────────────────────────────────
+ * Como VARIÁVEL DE AMBIENTE do processo filho, que é o jeito que o Claude
+ * Code e o Codex já leem chave. Não se escreve em arquivo de configuração
+ * deles, não se mexe no login que a pessoa já fez: quem não configurar nada
+ * aqui continua usando a conta em que entrou nas ferramentas, e quem
+ * configurar passa a chave só naquela chamada.
+ *
+ * ── O QUE NUNCA APARECE ──────────────────────────────────────────────────
+ * A chave inteira. Nem ao listar, nem ao salvar, nem numa mensagem de erro. O
+ * que se mostra é o suficiente para a pessoa reconhecer qual é (o começo e o
+ * fim), porque quem tem três chaves precisa saber qual está ali — e é isso
+ * que evita ela colar a chave na tela para conferir.
+ */
+
+'use strict';
+
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+
+const ARQUIVO = () => path.join(os.homedir(), '.primocode', 'chaves.json');
+
+/**
+ * Os provedores que o PrimoCode sabe usar, e a variável que cada um lê.
+ *
+ * O nome da variável é o do provedor, não um inventado aqui: é o que as
+ * ferramentas já procuram, e inventar um significaria a chave certa no lugar
+ * errado — configurada, aceita, e ignorada na hora de valer.
+ */
+const PROVEDORES = {
+    claude: {
+        nome: 'Claude',
+        variavel: 'ANTHROPIC_API_KEY',
+        prefixo: 'sk-ant-',
+        onde: 'https://console.anthropic.com/settings/keys',
+        motor: 'claude-code',
+    },
+    codex: {
+        nome: 'Codex',
+        variavel: 'OPENAI_API_KEY',
+        prefixo: 'sk-',
+        onde: 'https://platform.openai.com/api-keys',
+        motor: 'codex',
+    },
+};
+
+function ler() {
+    try { return JSON.parse(fs.readFileSync(ARQUIVO(), 'utf8')); }
+    catch { return {}; }
+}
+
+function gravar(dados) {
+    const caminho = ARQUIVO();
+    fs.mkdirSync(path.dirname(caminho), { recursive: true });
+    fs.writeFileSync(caminho, JSON.stringify(dados, null, 2), 'utf8');
+    // 600 = só o dono lê. No Windows o modo é ignorado pelo sistema de
+    // arquivos e a chamada não falha — lá quem protege é a pasta do perfil.
+    try { fs.chmodSync(caminho, 0o600); } catch {}
+}
+
+/** O bastante para reconhecer, nunca o bastante para usar. */
+function disfarcar(chave) {
+    const s = String(chave || '');
+    if (s.length <= 12) return '•'.repeat(s.length);
+    return `${s.slice(0, 7)}…${s.slice(-4)}`;
+}
+
+/**
+ * Guarda uma chave. Recusa a que claramente não é do provedor pedido — o
+ * erro mais comum é colar a do Claude no Codex, e sem esta conferência isso
+ * só apareceria como "não autorizado" no meio de uma tarefa, longe da causa.
+ */
+function guardar(provedor, chave) {
+    const p = PROVEDORES[provedor];
+    if (!p) return { ok: false, error: `não conheço "${provedor}". Use: ${Object.keys(PROVEDORES).join(', ')}` };
+    const limpa = String(chave || '').trim();
+    if (!limpa) return { ok: false, error: 'a chave veio vazia' };
+    if (limpa.length < 20) return { ok: false, error: 'isso é curto demais para ser uma chave' };
+    if (!limpa.startsWith(p.prefixo)) {
+        return { ok: false,
+            error: `uma chave do ${p.nome} começa com "${p.prefixo}", e essa não. Colou a do outro provedor?` };
+    }
+    // A do Claude também começa com "sk-", então o Codex precisa da recusa
+    // explícita: sem ela, `sk-ant-…` passaria como chave da OpenAI.
+    if (provedor === 'codex' && limpa.startsWith('sk-ant-')) {
+        return { ok: false, error: `essa é uma chave do Claude. Use /chave claude para ela.` };
+    }
+    const tudo = ler();
+    tudo[provedor] = limpa;
+    gravar(tudo);
+    return { ok: true, provedor, nome: p.nome, disfarce: disfarcar(limpa) };
+}
+
+function esquecer(provedor) {
+    const tudo = ler();
+    if (!(provedor in tudo)) return { ok: false, error: `não havia chave do ${provedor}` };
+    delete tudo[provedor];
+    gravar(tudo);
+    return { ok: true };
+}
+
+/** O que está configurado, disfarçado. */
+function listar() {
+    const tudo = ler();
+    return Object.entries(PROVEDORES).map(([id, p]) => ({
+        id, nome: p.nome, variavel: p.variavel, onde: p.onde,
+        tem: typeof tudo[id] === 'string' && tudo[id].length > 0,
+        disfarce: tudo[id] ? disfarcar(tudo[id]) : null,
+    }));
+}
+
+/**
+ * O ambiente para rodar o motor de um provedor: o de agora, mais a chave.
+ *
+ * Sem chave configurada devolve o ambiente INTACTO — nem a variável vazia,
+ * que apagaria a chave que a pessoa já tem exportada no shell e faria a
+ * ferramenta parar de funcionar por ter sido "configurada".
+ */
+function ambienteDe(provedor, base = process.env) {
+    const p = PROVEDORES[provedor];
+    if (!p) return base;
+    const chave = ler()[provedor];
+    if (!chave) return base;
+    return { ...base, [p.variavel]: chave };
+}
+
+/** Qual provedor um motor usa. */
+function provedorDoMotor(motor) {
+    for (const [id, p] of Object.entries(PROVEDORES)) if (p.motor === motor) return id;
+    return null;
+}
+
+module.exports = {
+    PROVEDORES, guardar, esquecer, listar, ambienteDe, disfarcar,
+    provedorDoMotor, ARQUIVO,
+};

package/lib/claude-engine.js

@@ -17,6 +17,29 @@ const { execSync, execFileSync } = require('child_process');
 const MARCA_INICIO = '<<<PRIMOCODE>>>';
 const MARCA_FIM = '<<<FIM>>>';
 
+/**
+ * O modelo que o /claude pede.
+ *
+ *   "Ele usa o modelo Opus 5 [no Claude]."
+ *
+ * Vai o APELIDO (`opus`), não o identificador completo: o apelido é o que o
+ * Claude Code resolve para o Opus do dia, e um identificador fixo aqui
+ * envelheceria dentro de um pacote publicado no npm — a pessoa atualizaria o
+ * Claude Code, o modelo sairia de catálogo, e o PrimoCode pediria um modelo
+ * que não existe mais.
+ *
+ * Quem quiser outro põe PRIMOCODE_CLAUDE_MODELO. Vazio manda sem `--model`, e
+ * aí vale o padrão da conta da pessoa.
+ */
+const MODELO_CLAUDE = process.env.PRIMOCODE_CLAUDE_MODELO !== undefined
+    ? process.env.PRIMOCODE_CLAUDE_MODELO
+    : 'opus';
+
+/** Os argumentos do modelo, ou nenhum quando a escolha é do dono da conta. */
+function argsDoModelo() {
+    return MODELO_CLAUDE ? ['--model', MODELO_CLAUDE] : [];
+}
+
 /**
  * Acha o ÚLTIMO bloco marcado no texto (pode vir ruído de terminal — prompt
  * ANSI, texto solto — antes e depois) e devolve o JSON de dentro dele.
@@ -101,6 +124,7 @@ function lerJSON(bruto) {
 }
 
 const catalogo = require('./catalogo');
+const chaves = require('./chaves');
 
 /** Serializa lib/catalogo.js em texto — única fonte de verdade, sem
  * duplicar a lista de ferramentas num arquivo separado. */
@@ -473,21 +497,44 @@ function linhaDoHistorico(m) {
     return `${m.role}: ${m.content}`;
 }
 
-async function requestActViaHeadless(payload, onEvent) {
+/**
+ * O protocolo INTEIRO, mais a conversa, num prompt só.
+ *
+ * A versão anterior dizia "use a skill primocode-engine" e confiava que o
+ * headless a carregaria — quando não carregava, o Claude respondia sem bloco
+ * nenhum e o turno morria. Prompt maior, mas o motor tem contexto de sobra e
+ * o formato SEMPRE chega.
+ *
+ * SEM o cabeçalho YAML da skill: ele começa com "---", e um prompt que começa
+ * com traço o parser de argumentos lê como OPÇÃO — "error: unknown option
+ * '---'" na cara do usuário, com o protocolo inteiro despejado no terminal.
+ * Foi exatamente o que aconteceu.
+ *
+ * Isto é o que o /claude e o /codex têm em comum, e é de propósito que more
+ * num lugar só: são dois motores, e tem de ser UM protocolo.
+ */
+function corpoDoProtocolo() {
+    return textoBootstrap().replace(/^---[\s\S]*?---\s*/, '');
+}
+
+/** O pedido de conserto: o protocolo de novo, mais o que saiu errado. Sem a
+ *  conversa — o assunto aqui é a FORMA, e repetir o histórico inteiro só
+ *  gastaria contexto no que não é o problema. */
+function promptDeCorrecao(aviso) {
+    return corpoDoProtocolo() + '\n\n' + aviso;
+}
+
+function promptDoProtocolo(payload) {
     const historico = (payload.messages || []).map(linhaDoHistorico).join('\n\n');
-    // O protocolo vai INTEIRO no prompt. A versão anterior dizia "use a skill
-    // primocode-engine" e confiava que o headless a carregaria — quando não
-    // carregava, o Claude respondia sem bloco nenhum e o turno morria. Prompt
-    // maior, mas o Claude Code tem contexto de sobra, e o formato SEMPRE chega.
-    // SEM o cabeçalho YAML da skill: ele começa com "---", e um prompt que
-    // começa com traço o parser de argumentos do claude lê como OPÇÃO —
-    // "error: unknown option '---'" na cara do usuário, com o protocolo
-    // inteiro despejado no terminal. Foi exatamente o que aconteceu.
-    const corpoBootstrap = textoBootstrap().replace(/^---[\s\S]*?---\s*/, '');
-    const prompt = corpoBootstrap
+    return corpoDoProtocolo()
         + '\n\nIMPORTANTE: no JSON do bloco, escreva quebras de linha como \\n (escapadas), nunca linha de verdade.'
         + '\n\n# A conversa até aqui\n\n' + historico
         + '\n\nResponda com exatamente UM bloco marcado.';
+}
+
+async function requestActViaHeadless(payload, onEvent) {
+    const corpoBootstrap = corpoDoProtocolo();
+    const prompt = promptDoProtocolo(payload);
     // --dangerously-skip-permissions: mesma razão do caminho ORCA acima —
     // a skill já proíbe o Claude Code de usar suas próprias ferramentas
     // nativas; a flag só evita que ele pare pedindo permissão pra si mesmo
@@ -499,7 +546,9 @@ async function requestActViaHeadless(payload, onEvent) {
         '-p',
         '--output-format', 'json',
         '--dangerously-skip-permissions',
-    ], { encoding: 'utf-8', timeout: 180000, input: prompt, maxBuffer: 32 * 1024 * 1024 });
+        ...argsDoModelo(),
+    ], { encoding: 'utf-8', timeout: 180000, input: prompt, maxBuffer: 32 * 1024 * 1024,
+        env: chaves.ambienteDe('claude') });
     const r = JSON.parse(saida);
     // A correção é uma segunda ida ao motor, com o mesmo protocolo e o
     // diagnóstico do que saiu errado. Barata: o prompt é curto, e evita que
@@ -507,9 +556,11 @@ async function requestActViaHeadless(payload, onEvent) {
     const pedirCorrecao = (aviso) => {
         const s = execFileSync('claude', [
             '-p', '--output-format', 'json', '--dangerously-skip-permissions',
+            ...argsDoModelo(),
         ], {
             encoding: 'utf-8', timeout: 120000, maxBuffer: 32 * 1024 * 1024,
-            input: corpoBootstrap + '\n\n' + aviso,
+            env: chaves.ambienteDe('claude'),
+            input: promptDeCorrecao(aviso),
         });
         return JSON.parse(s).result || '';
     };
@@ -543,6 +594,13 @@ async function requestAct(server, payload, onEvent) {
 module.exports = {
     MARCA_INICIO, MARCA_FIM, extrairDecisao,
     catalogoParaTexto, textoBootstrap,
+    // O protocolo sai daqui para o lib/codex-engine.js usar o MESMO. Ele é o
+    // que faz um motor de fora virar cérebro do PrimoCode: o texto que
+    // ensina o formato, a leitura do bloco marcado e a volta para consertar
+    // o que veio torto. Reimplementar aquilo no outro motor seria manter dois
+    // protocolos que divergem na primeira correção de um deles.
+    linhaDoHistorico, nomesDasTools, promptDoProtocolo, promptDeCorrecao,
+    MODELO_CLAUDE, argsDoModelo,
     SKILL_DIR, SKILL_PATH, garantirSkill,
     temClaudeCode, temOrca, orcaAlcancavel, escolherCaminho,
     garantirEngine, requestAct, emitirDecisao,

package/lib/codex-engine.js

@@ -0,0 +1,201 @@
+/**
+ * codex-engine.js — motor do agente rodando no Codex da SUA conta.
+ *
+ *   "Você pode usar a barra codex para usar os modelos com a sua conta. No
+ *    Claude ele usa o modelo Opus 5; no Codex ele vai usar o modelo baratinho
+ *    ali."
+ *
+ * ── É UM MOTOR NOVO, NÃO UM PROTOCOLO NOVO ───────────────────────────────
+ * O que ensina um modelo de fora a ser cérebro do PrimoCode — o texto do
+ * protocolo, a leitura do bloco marcado, a volta para consertar o que veio
+ * torto — mora inteiro no claude-engine.js e é IMPORTADO daqui. Copiar
+ * aquilo para cá daria dois protocolos, e o segundo começaria a divergir do
+ * primeiro na primeira correção feita só de um lado — sem erro nenhum
+ * aparecendo, só um dos motores ficando pior que o outro com o tempo.
+ *
+ * O que muda de verdade entre os dois é uma coisa só: qual programa se chama
+ * e com quais argumentos. É isso, e só isso, que este arquivo tem.
+ *
+ * ── POR QUE LER A SAÍDA COMO TEXTO CRU ───────────────────────────────────
+ * O `claude -p` tem `--output-format json` e o formato é estável. O `codex`
+ * mudou de forma mais de uma vez, e amarrar-se ao JSON dele seria escolher
+ * quebrar no dia em que ele mudar de novo — calado, porque a saída
+ * continuaria vindo, só que com outras chaves.
+ *
+ * Então aqui se lê o texto e se procura o bloco marcado nele, que é o que o
+ * `extrairDecisao` já faz: ele varre ruído de terminal e fica com o último
+ * bloco legível. Enquanto o Codex escrever o bloco em algum lugar da saída,
+ * este motor funciona — independente de como ele embrulhe o resto.
+ */
+
+'use strict';
+
+const { execSync, execFileSync } = require('child_process');
+
+const claude = require('./claude-engine');
+const chaves = require('./chaves');
+
+/**
+ * O modelo barato do Codex.
+ *
+ * O /claude vai no Opus porque ali o que se quer é a decisão mais certa. Aqui
+ * o pedido foi o contrário — "o modelo baratinho" — e faz sentido: quem liga
+ * o /codex está usando a franquia da própria conta, e o motor do PrimoCode dá
+ * muitas voltas por tarefa.
+ *
+ * Vazio manda sem `--model`, e vale o padrão da conta. E se o Codex recusar
+ * este modelo, o motor tenta de novo SEM ele em vez de morrer — ver
+ * `chamarCodex`.
+ */
+const MODELO_CODEX = process.env.PRIMOCODE_CODEX_MODELO !== undefined
+    ? process.env.PRIMOCODE_CODEX_MODELO
+    : 'gpt-5-mini';
+
+/** O programa. Trocável para o teste pôr um de mentira no lugar. */
+const CODEX = process.env.PRIMOCODE_CODEX_BIN || 'codex';
+
+const TEMPO = 180000;
+const BUFFER = 32 * 1024 * 1024;
+
+function temCodex(executor = (cmd) => execSync(cmd, { stdio: ['ignore', 'pipe', 'ignore'] })) {
+    try { executor(`${CODEX} --version`); return true; }
+    catch { return false; }
+}
+
+/**
+ * O que o `codex exec` desta máquina aceita.
+ *
+ * Passar uma opção que a versão instalada não conhece não dá "opção
+ * desconhecida" e pronto: dá uma saída de ajuda no lugar da resposta, e o
+ * motor devolveria "não consegui ler a decisão" em toda rodada — com a
+ * pessoa sem nenhuma pista de que o problema é uma flag.
+ *
+ * Perguntar ao `--help` custa uma chamada por sessão e responde com o que
+ * ESTA versão faz, em vez do que a versão de hoje fazia quando isto foi
+ * escrito.
+ */
+let _ajuda = null;
+function ajudaDoExec(executor) {
+    if (_ajuda !== null) return _ajuda;
+    const rodar = executor || ((args) => execFileSync(CODEX, args,
+        { encoding: 'utf-8', timeout: 20000, stdio: ['ignore', 'pipe', 'ignore'] }));
+    try { _ajuda = String(rodar(['exec', '--help']) || ''); }
+    catch { _ajuda = ''; }        // sem ajuda: segue com o mínimo
+    return _ajuda;
+}
+
+function esquecerAjuda() { _ajuda = null; }
+
+/**
+ * Os argumentos da chamada.
+ *
+ * `--skip-git-repo-check` só entra se esta versão o conhecer: sem ele, o
+ * Codex se recusa a rodar fora de um repositório git — e o PrimoCode trabalha
+ * em pasta comum o tempo todo.
+ */
+function argsDoExec({ comModelo = true, ajuda = null } = {}) {
+    const h = ajuda === null ? ajudaDoExec() : ajuda;
+    const args = ['exec'];
+    if (h.includes('--skip-git-repo-check')) args.push('--skip-git-repo-check');
+    // O Codex pede confirmação para agir na máquina. Aqui ele não age: o
+    // protocolo proíbe ferramenta nativa, quem executa é o PrimoCode. A opção
+    // só evita que ele pare esperando uma resposta que ninguém vai dar.
+    if (h.includes('--dangerously-bypass-approvals-and-sandbox')) {
+        args.push('--dangerously-bypass-approvals-and-sandbox');
+    } else if (h.includes('--full-auto')) {
+        args.push('--full-auto');
+    }
+    if (comModelo && MODELO_CODEX) args.push('--model', MODELO_CODEX);
+    // O prompt vai por STDIN: por argumento ele teria limite de tamanho (a
+    // conversa cresce) e qualquer texto começando com traço seria lido como
+    // opção. `-` é como o exec pede para ler da entrada.
+    args.push('-');
+    return args;
+}
+
+/** Um modelo que a conta não tem é o erro mais provável desta chamada — e o
+ *  único que dá para consertar sozinho. */
+function recusouOModelo(texto) {
+    return /model|modelo/i.test(texto)
+        && /not (found|available|supported)|unknown|invalid|does not|inexistente|inválid/i.test(texto);
+}
+
+/**
+ * Chama o Codex e devolve o texto. Se ele recusar o modelo, tenta UMA vez sem
+ * `--model` e avisa — cair para o padrão da conta é melhor que a tarefa
+ * morrer por causa de um nome que mudou de catálogo.
+ */
+function chamarCodex(prompt, { executor, avisar = () => {} } = {}) {
+    // A chave própria da pessoa, quando ela configurou uma. Sem configuração
+    // o ambiente vai INTACTO — passar a variável vazia apagaria a chave que
+    // ela já tem exportada no shell, e o Codex pararia de funcionar por ter
+    // sido "configurado".
+    const rodar = executor || ((args, entrada) => execFileSync(CODEX, args, {
+        encoding: 'utf-8', timeout: TEMPO, input: entrada, maxBuffer: BUFFER,
+        env: chaves.ambienteDe('codex'),
+    }));
+    try {
+        return rodar(argsDoExec(), prompt);
+    } catch (e) {
+        const detalhe = `${e.message || ''}\n${(e.stderr || '')}\n${(e.stdout || '')}`;
+        if (MODELO_CODEX && recusouOModelo(detalhe)) {
+            avisar(`o Codex não aceitou o modelo ${MODELO_CODEX} — indo com o padrão da sua conta`);
+            return rodar(argsDoExec({ comModelo: false }), prompt);
+        }
+        throw new Error(primeiraLinhaUtil(detalhe) || e.message);
+    }
+}
+
+/** A primeira linha que diz alguma coisa. O erro do Codex costuma vir com
+ *  banner, versão e caminho antes do motivo, e jogar tudo isso na tela é
+ *  esconder o motivo no meio. */
+function primeiraLinhaUtil(texto) {
+    for (const linha of String(texto || '').split('\n')) {
+        const l = linha.trim();
+        if (l && !/^(Command failed|codex\b|\s*$)/i.test(l)) return l.slice(0, 300);
+    }
+    return '';
+}
+
+function garantirEngine() {
+    if (!temCodex()) {
+        return {
+            ok: false,
+            error: 'O Codex não está instalado nesta máquina.',
+            comoResolver: 'Instale o Codex CLI da OpenAI, entre na sua conta com `codex login`, '
+                + 'e rode /codex de novo.',
+        };
+    }
+    return { ok: true, modelo: MODELO_CODEX || '(o padrão da sua conta)' };
+}
+
+/** Mesma forma de api.requestAct(server, payload, onEvent) — é isso que deixa
+ *  o lib/act.js trocar de motor sem saber de nada disto. */
+async function requestAct(server, payload, onEvent) {
+    try {
+        const pronto = garantirEngine();
+        if (!pronto.ok) {
+            onEvent({ erro: `${pronto.error} ${pronto.comoResolver || ''}`.trim() });
+            return;
+        }
+        const prompt = claude.promptDoProtocolo(payload);
+        const saida = chamarCodex(prompt, { avisar: (m) => onEvent({ aviso: m }) });
+
+        // A correção é uma segunda ida ao motor, com o mesmo protocolo e o
+        // diagnóstico do que saiu errado. Barata, e evita que um erro de forma
+        // do motor vire erro na cara de quem pediu a tarefa.
+        const pedirCorrecao = (aviso) => chamarCodex(claude.promptDeCorrecao(aviso));
+
+        await claude.emitirDecisao(saida, onEvent, pedirCorrecao, 0,
+            claude.nomesDasTools(payload));
+    } catch (e) {
+        onEvent({ erro: e.message });
+    }
+}
+
+module.exports = {
+    MODELO_CODEX, CODEX,
+    temCodex, garantirEngine, requestAct,
+    argsDoExec, ajudaDoExec, esquecerAjuda,
+    chamarCodex, recusouOModelo, primeiraLinhaUtil,
+};

package/lib/config.js

@@ -19,8 +19,21 @@ const ROOT_DIR = path.join(HOME, 'primocode');
 const CONFIG_DIR = path.join(HOME, '.primocode');
 const CONFIG_FILE = path.join(CONFIG_DIR, 'config.json');
 const HISTORY_FILE = path.join(CONFIG_DIR, 'history.jsonl');
+const CONTA_FILE = path.join(CONFIG_DIR, 'conta.json');
 const GENERAL_MEMORY = path.join(ROOT_DIR, 'memory-geral.md');
 
+/* O token da conta, lido DIRETO do arquivo.
+ *
+ * Sem `require('./conta.js')` de propósito: o conta.js já carrega o
+ * config.js, e um exigir o outro nos dois sentidos deixa um dos dois com
+ * metade do módulo na mão — em Node isso não dá erro, dá `undefined` numa
+ * função no meio de um turno. Ler quatro linhas de JSON é mais barato que
+ * essa aula. */
+function tokenDaConta() {
+    try { return JSON.parse(fs.readFileSync(CONTA_FILE, 'utf8')).token || null; }
+    catch { return null; }
+}
+
 const GENERAL_MEMORY_TEMPLATE = `# Memória Geral
 
 Informações que valem para todos os projetos. O PrimoCode lê este arquivo
@@ -254,7 +267,19 @@ function loadConfig() {
         // Esforço, estilo Claude Code (/effort). É o que o usuário escolhe; o
         // modelo é derivado dele. Guardado para durar entre sessões.
         effort: process.env.PRIMOCODE_EFFORT || file.effort || 'medium',
-        token: process.env.PRIMOCODE_TOKEN || file.token || null,
+        /* O token que vai ao servidor.
+         *
+         * O da CONTA entra por último, como padrão de quem não configurou
+         * nada — é ele que faz o servidor reconhecer Premium/Super e liberar
+         * o teto. Entra AQUI e não em cada chamada porque são cinco lugares
+         * que mandam pedido: o sexto que alguém escrever esqueceria, e a
+         * pessoa veria o limite bater com a assinatura em dia.
+         *
+         * A ordem é a de quem manda mais: variável de ambiente ganha do
+         * arquivo, e o arquivo ganha da conta. Quem hospeda o próprio
+         * servidor e configurou um token não pode ter isso trocado por
+         * entrar numa conta. */
+        token: process.env.PRIMOCODE_TOKEN || file.token || tokenDaConta(),
         autoApply: file.autoApply === true,
         currentProject: file.currentProject || null,
         userName: file.userName || null,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "primocode",
-  "version": "8.31.0",
+  "version": "8.32.0",
   "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.",
   "main": "bin/primocode.js",
   "bin": {
@@ -8,7 +8,7 @@
   },
   "scripts": {
     "start": "node bin/primocode.js",
-    "test": "node test/tools.test.js && node test/ui.test.js && node test/modo.test.js && node test/pasta.test.js && node test/catalogo.test.js && node test/desktop.test.js && node test/effort.test.js && node test/claude-engine.test.js && node test/regressao.test.js && node test/memoria-conversa.test.js && node test/repeticao.test.js && node test/referencia.test.js && node test/parar.test.js && node test/continuar.test.js && node test/studio-spec.test.js && node test/studio-versoes.test.js && node test/voz.test.js && node test/editor.test.js && node test/estudio-projeto.test.js && node test/vocabulario.test.js && node test/video-export.test.js && node test/monotonia.test.js && node test/clipe.test.js && node test/midia-envio.test.js && node test/pausas.test.js && node test/app.test.js && node test/elementos.test.js && node test/remotion.test.js && node test/aplicativo.test.js && node test/conta.test.mjs && node test/nuvem.test.js"
+    "test": "node test/tools.test.js && node test/ui.test.js && node test/modo.test.js && node test/pasta.test.js && node test/catalogo.test.js && node test/desktop.test.js && node test/effort.test.js && node test/claude-engine.test.js && node test/regressao.test.js && node test/memoria-conversa.test.js && node test/repeticao.test.js && node test/referencia.test.js && node test/parar.test.js && node test/continuar.test.js && node test/studio-spec.test.js && node test/studio-versoes.test.js && node test/voz.test.js && node test/editor.test.js && node test/estudio-projeto.test.js && node test/vocabulario.test.js && node test/video-export.test.js && node test/monotonia.test.js && node test/clipe.test.js && node test/midia-envio.test.js && node test/pausas.test.js && node test/app.test.js && node test/elementos.test.js && node test/remotion.test.js && node test/aplicativo.test.js && node test/conta.test.mjs && node test/nuvem.test.js && node test/codex.test.js && node test/chaves.test.js"
   },
   "engines": {
     "node": ">=18.17.0"