primocode 9.8.0-beta.1 → 9.8.0-beta.3

package/lib/codex-engine.js

@@ -0,0 +1,207 @@
+/**
+ * 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');
+
+/* O MOTOR EXTERNO NÃO APARECE — a mesma regra do claude-engine, e o mesmo
+   comentário longo mora lá. Em resumo: `execFileSync` sem `stdio` HERDA o
+   stderr, e um aviso do Codex cairia no meio da tela do PrimoCode com a cara de
+   outro produto. Capturado, ele some da tela e `e.stderr` passa a existir — o
+   `catch` daqui já lia esse campo e estava lendo `null` desde sempre. */
+const SEM_APARECER = { stdio: ['pipe', 'pipe', 'pipe'], windowsHide: true };
+
+const claude = require('./claude-engine');
+
+/**
+ * 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, ...SEM_APARECER }));
+    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: process.env, ...SEM_APARECER,
+    }));
+    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 escolha Codex no /api 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/comandos.js

@@ -0,0 +1,104 @@
+/**
+ * comandos.js — o pedido que a pessoa repete vira um comando dela.
+ *
+ * Quem pede "revisa o projeto e me explica os bugs sem jargão" toda semana
+ * não deveria digitar isso toda semana. Um arquivo `revisar.md` com o pedido
+ * dentro vira `/revisar`, e `/revisar o login` troca `$ARGUMENTOS` por
+ * "o login". É o mesmo desenho dos comandos do Claude Code.
+ *
+ * ── POR QUE NÃO É UMA SKILL ──────────────────────────────────────────────
+ * Skill entra sozinha quando o pedido casa com o `quando:` dela. Comando só
+ * entra quando a pessoa chama pelo nome. Um é conhecimento de fundo, o outro
+ * é um atalho de digitação — e misturar os dois faria um atalho disparar
+ * sem ninguém ter pedido.
+ *
+ * ── ONDE MORAM, E QUEM GANHA ─────────────────────────────────────────────
+ *   1. `comandos/` do pacote       — os três que vêm de fábrica ("primocode")
+ *   2. `~/.primocode/comandos/`    — os da pessoa, em qualquer projeto ("global")
+ *   3. `<projeto>/.primocode/comandos/` — os daquele projeto ("projeto")
+ * O mais perto do trabalho ganha: o do projeto sabe coisas do projeto que o
+ * global não sabe. E o de fábrica perde para qualquer um, para a pessoa poder
+ * reescrever o `/revisar` do jeito dela sem mexer no pacote.
+ */
+
+'use strict';
+
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+const { separar } = require('./skills.js');
+
+const PASTA_DO_PACOTE = path.join(__dirname, '..', 'comandos');
+// O nome vira `/nome` na caixa de digitar: sem espaço, sem acento estranho,
+// sem barra — senão o comando existe no disco e não há como digitá-lo.
+const NOME_VALIDO = /^[a-z0-9][a-z0-9_-]*$/;
+
+/** Um arquivo .md → { nome, descricao, corpo, arquivo }. */
+function ler(arquivo) {
+    const { cabecalho, corpo } = separar(fs.readFileSync(arquivo, 'utf-8'));
+    return {
+        nome: path.basename(arquivo, '.md').toLowerCase(),
+        descricao: cabecalho.descricao || cabecalho.description || '',
+        corpo,
+        arquivo,
+    };
+}
+
+function daPasta(pasta, origem) {
+    let nomes = [];
+    try { nomes = fs.readdirSync(pasta); } catch { return []; }   // pasta que não existe é lista vazia
+    const fora = [];
+    for (const n of nomes.filter((x) => x.endsWith('.md')).sort()) {
+        try {
+            const c = ler(path.join(pasta, n));
+            if (NOME_VALIDO.test(c.nome) && c.corpo) fora.push({ ...c, origem });
+        } catch { /* um arquivo ilegível não derruba os outros */ }
+    }
+    return fora;
+}
+
+/** A lista final, um por nome, já com a precedência aplicada. */
+function carregar({ projectDir, home = os.homedir(), pastaDoPacote = PASTA_DO_PACOTE } = {}) {
+    const porNome = new Map();
+    // Em ordem crescente de prioridade: quem vem depois sobrescreve.
+    const camadas = [
+        [pastaDoPacote, 'primocode'],
+        [path.join(home, '.primocode', 'comandos'), 'global'],
+    ];
+    if (projectDir) camadas.push([path.join(projectDir, '.primocode', 'comandos'), 'projeto']);
+    for (const [pasta, origem] of camadas) {
+        for (const c of daPasta(pasta, origem)) porNome.set(c.nome, c);
+    }
+    return [...porNome.values()].sort((a, b) => a.nome.localeCompare(b.nome));
+}
+
+/** O prompt que vai ao agente. */
+function expandir(comando, argumentos) {
+    const args = String(argumentos || '').trim();
+    const corpo = comando.corpo;
+    if (corpo.includes('$ARGUMENTOS')) return corpo.split('$ARGUMENTOS').join(args).trim();
+    // Sem a marca, o que foi digitado não pode sumir: vai no fim.
+    return args ? `${corpo}\n\n${args}` : corpo;
+}
+
+/** Cria ~/.primocode/comandos/<nome>.md com um esqueleto. Devolve o caminho. */
+function criar(nome, { home = os.homedir() } = {}) {
+    const n = String(nome || '').trim().toLowerCase().replace(/^\//, '');
+    if (!NOME_VALIDO.test(n)) return { ok: false, error: 'Nome só com letras minúsculas, números, - e _.' };
+    const pasta = path.join(home, '.primocode', 'comandos');
+    const arquivo = path.join(pasta, n + '.md');
+    if (fs.existsSync(arquivo)) return { ok: false, error: `Já existe: ${arquivo}`, arquivo };
+    fs.mkdirSync(pasta, { recursive: true });
+    fs.writeFileSync(arquivo, [
+        '---',
+        `descricao: o que o /${n} faz, numa linha`,
+        '---',
+        'Escreva aqui o pedido, do jeito que você digitaria.',
+        '',
+        'O que vier depois do comando entra no lugar desta palavra: $ARGUMENTOS',
+        '',
+    ].join('\n'));
+    return { ok: true, arquivo };
+}
+
+module.exports = { PASTA_DO_PACOTE, NOME_VALIDO, ler, carregar, expandir, criar };

package/lib/config.js

@@ -129,15 +129,25 @@ function listProjects() {
     } catch { return []; }
 }
 
+/* Palavras que dizem o TIPO da coisa, não QUAL coisa. "landing da barbearia"
+   e "landing-nova" (de outra empresa) dividiam "landing", e o pedido novo caía
+   dentro do projeto antigo — medido em 24/09: a landing da Navalha de Ouro foi
+   escrita em landing-nova/. Só o assunto conta como parecido. */
+const GENERICAS = new Set(['landing', 'lading', 'page', 'pagina', 'site', 'app', 'aplicativo', 'projeto',
+    'novo', 'nova', 'sistema', 'web', 'html', 'teste', 'versao', 'final', 'the', 'para', 'pra']);
+function tokensDoAssunto(nome) {
+    return slugify(nome).split('-').filter((t) => t.length > 2 && !GENERICAS.has(t) && !/^v?\d+$/.test(t));
+}
+
 // Projeto parecido com o que o usuário pediu? Compara os pedaços do slug.
 // "jogo-de-carro" vs "jogo-carro-2d" -> compartilham jogo+carro -> 0.5
 function findSimilarProject(projectName, minScore = 0.4) {
-    const wanted = new Set(slugify(projectName).split('-').filter((t) => t.length > 2));
+    const wanted = new Set(tokensDoAssunto(projectName));
     if (!wanted.size) return null;
 
     let best = null;
     for (const existing of listProjects()) {
-        const tokens = new Set(existing.split('-').filter((t) => t.length > 2));
+        const tokens = new Set(tokensDoAssunto(existing));
         if (!tokens.size) continue;
         let shared = 0;
         for (const t of wanted) if (tokens.has(t)) shared++;
@@ -288,6 +298,9 @@ function loadConfig() {
         theme: file.theme || 'primo',
         // Modo escolhido dura entre sessões: quem liga o auto quer o auto amanhã.
         mode: process.env.PRIMOCODE_MODE || file.mode || 'auto',
+        // O /permissoes: quando ele pergunta antes de agir. Dura entre sessões
+        // pelo mesmo motivo do modo — quem escolheu "perguntar" quer amanhã também.
+        permissoes: file.permissoes || 'auto',
         rootDir: ROOT_DIR,
         _file: file,
     };
@@ -297,8 +310,8 @@ function saveConfig(partial) {
     ensureDir(CONFIG_DIR);
     const cur = (() => { try { return JSON.parse(fs.readFileSync(CONFIG_FILE, 'utf8')); } catch { return {}; } })();
     // Só persiste o que faz sentido guardar — nada de campos derivados.
-    const { server, model, effort, token, autoApply, currentProject, userName, mascot, theme, mode } = { ...cur, ...partial };
-    const next = { server, model, effort, token, autoApply, currentProject, userName, mascot, theme, mode };
+    const { server, model, effort, token, autoApply, currentProject, userName, mascot, theme, mode, permissoes } = { ...cur, ...partial };
+    const next = { server, model, effort, token, autoApply, currentProject, userName, mascot, theme, mode, permissoes };
     fs.writeFileSync(CONFIG_FILE, JSON.stringify(next, null, 2), 'utf8');
     return next;
 }
@@ -338,6 +351,7 @@ function esquecerProjeto() {
 }
 
 module.exports = {
+    tokensDoAssunto, GENERICAS,
     lembrarProjeto, projetoLembrado, esquecerProjeto, PROJETO_ATIVO_FILE,
     loadConfig, saveConfig, appendHistory,
     CONFIG_DIR, CONFIG_FILE, HISTORY_FILE, ROOT_DIR, GENERAL_MEMORY,

package/lib/kits.js

@@ -0,0 +1,81 @@
+/**
+ * kits.js — o modelo grátis começa de uma página pronta, e não do zero.
+ *
+ *   "A IA free fez essa página, ficou boa, mas quero que ela seja mais
+ *    rápida." · "Como chegar nesse nível com os modelos free? Nem terminou,
+ *    demora 10 anos." (24/09/2026)
+ *
+ * ── A CONTA ──────────────────────────────────────────────────────────────
+ * Uma landing boa são ~30 KB de HTML+CSS+JS — uns 9 mil tokens de SAÍDA. No
+ * plano grátis (6 mil tokens por minuto, entrada e saída juntas) isso não
+ * cabe numa resposta: o servidor manda "uma tool por vez", e a página sai em
+ * pedaços, com espera a cada minuto. E o modelo fraco, desenhando do zero,
+ * erra justamente o que dá o nível: tipografia, espaço, animação.
+ *
+ * Com o kit, o design já está resolvido (a landing que o Claude fez, com o
+ * conteúdo trocado por marcadores). O agente só TROCA texto e três cores com
+ * edit_file: ~1–2 mil tokens de saída em vez de 9 mil. Mais rápido E melhor,
+ * pela mesma razão — o trabalho difícil já foi feito uma vez, por quem faz
+ * bem.
+ *
+ * Só entra em pasta NOVA (ou vazia): num projeto que já tem página, copiar
+ * um kit por cima seria apagar o trabalho da pessoa.
+ */
+
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+
+const PASTA_KITS = path.join(__dirname, '..', 'kits');
+
+/* O pedido de landing. Estreito de propósito: "crie um app de tarefas" não é
+   landing, e um kit errado é pior que kit nenhum. */
+const RE_LANDING = /\b(landing|lading|p[áa]gina (de vendas|de captura|inicial|institucional|de apresenta[çc][ãa]o|pr[ao]|do meu|da minha|da empresa|do neg[óo]cio)|site (institucional|da empresa|do meu|da minha|pr[ao] (minha|meu|a|o))|one ?page|home ?page)\b/i;
+// Pedido que não quer a cara do kit: nada de puxar o kit por cima disso.
+const RE_SEM_KIT = /\b(do zero|sem modelo|sem template|sem kit|react|next(\.?js)?|vue|svelte|angular|tailwind|wordpress)\b/i;
+
+const KITS = {
+    landing: {
+        nome: 'landing',
+        arquivos: ['index.html', 'style.css', 'script.js'],
+        instrucao: 'A PASTA JÁ TEM UMA LANDING PRONTA (index.html, style.css, script.js), com design profissional, '
+            + 'animações e responsiva. NÃO reescreva os arquivos com write_file: é lento e piora o design. '
+            + 'ADAPTE com edit_file: (1) leia o index.html; (2) troque cada bloco marcado com <!-- TROQUE --> pelo '
+            + 'conteúdo do pedido — textos reais, específicos do negócio, sem inventar fato que você não sabe; '
+            + '(3) no topo do style.css troque só as cores --blue, --orange, --cyan (e as -deep) pelas cores que '
+            + 'combinam com o negócio; (4) apague os comentários TROQUE. Pode remover uma seção que não faz '
+            + 'sentido para o negócio (e o link dela no menu). Não mexa no script.js.',
+    },
+};
+
+/** Qual kit este pedido quer, ou null. */
+function escolher(pedido) {
+    const t = String(pedido || '');
+    if (!RE_LANDING.test(t) || RE_SEM_KIT.test(t)) return null;
+    return KITS.landing;
+}
+
+/** A pasta está livre para receber o kit? (não existe, ou só tem memory.md) */
+function pastaLivre(dir) {
+    try {
+        const tem = fs.readdirSync(dir).filter((n) => !n.startsWith('.') && n !== 'memory.md');
+        return tem.length === 0;
+    } catch { return true; }
+}
+
+/** Copia o kit para `dir`. Devolve os arquivos copiados, ou [] se não copiou. */
+function aplicar(kit, dir) {
+    if (!kit || !pastaLivre(dir)) return [];
+    fs.mkdirSync(dir, { recursive: true });
+    const feitos = [];
+    for (const nome of kit.arquivos) {
+        const destino = path.join(dir, nome);
+        if (fs.existsSync(destino)) continue;
+        fs.copyFileSync(path.join(PASTA_KITS, kit.nome, nome), destino);
+        feitos.push(nome);
+    }
+    return feitos;
+}
+
+module.exports = { KITS, PASTA_KITS, escolher, pastaLivre, aplicar };

package/lib/local/motor-cli.js

@@ -0,0 +1,90 @@
+/**
+ * motor-cli.js — o Claude Code ou o Codex da pessoa como cérebro do PrimoCode.
+ *
+ *   "Coloca o /claude de novo, mas dentro do /api: aí coloca /claude e
+ *    /codex." (24/09/2026)
+ *
+ * Sem chave: usa a assinatura que a pessoa já tem nessas ferramentas. O
+ * agente (o loop, as ferramentas, a tela) continua sendo o do PrimoCode; a
+ * ferramenta de fora só decide o próximo passo, pelo protocolo de bloco
+ * marcado de lib/claude-engine.js (o Codex usa o mesmo).
+ *
+ * Os motores só sabem o `requestAct`. Chat e resumo, aqui, são uma pergunta
+ * de texto simples ao mesmo CLI; o plano não divide (uma ida a mais a um CLI
+ * lento custaria mais do que a divisão poupa) e segue em passo único.
+ */
+
+'use strict';
+
+const { execFileSync } = require('child_process');
+const cerebro = require('./cerebro.json');
+
+const SEM_APARECER = { stdio: ['pipe', 'pipe', 'pipe'], windowsHide: true };
+
+function motorDe(id) {
+    if (id === 'codex') {
+        /* O padrão antigo do motor (gpt-5-mini) é recusado por conta de
+           assinatura do ChatGPT — medido: "o Codex não aceitou o modelo", e
+           uma segunda chamada em TODA rodada. Pelo /api, vai o modelo da
+           conta. Quem quiser outro ainda usa PRIMOCODE_CODEX_MODELO. */
+        if (process.env.PRIMOCODE_CODEX_MODELO === undefined) process.env.PRIMOCODE_CODEX_MODELO = '';
+        return require('../codex-engine.js');
+    }
+    return require('../claude-engine.js');
+}
+
+/** Uma pergunta de texto, resposta de texto. Sem protocolo, sem ferramenta. */
+function perguntar(id, texto) {
+    if (id === 'codex') return String(motorDe('codex').chamarCodex(texto) || '').trim();
+    const claude = motorDe('claude-code');
+    const saida = execFileSync('claude', ['-p', '--output-format', 'json', ...claude.argsDoModelo()], {
+        encoding: 'utf-8', timeout: 120000, input: texto, maxBuffer: 8 * 1024 * 1024, ...SEM_APARECER,
+    });
+    try { return String(JSON.parse(saida).result || '').trim(); } catch { return String(saida || '').trim(); }
+}
+
+function criar(id) {
+    const motor = motorDe(id);
+    return {
+        requestAct: (servidor, payload, emit) => motor.requestAct(servidor, payload, emit),
+
+        async requestChat(_servidor, { messages, prompt, history } = {}, emit) {
+            const turnos = Array.isArray(messages) ? messages
+                : [...(Array.isArray(history) ? history : []), ...(prompt ? [{ role: 'user', content: prompt }] : [])];
+            const conversa = turnos.filter((m) => m && m.role && typeof m.content === 'string')
+                .map((m) => `${m.role === 'user' ? 'PESSOA' : 'VOCÊ'}: ${m.content}`).join('\n');
+            try {
+                const resposta = perguntar(id, `${cerebro.SYSTEM_CHAT}\n\nResponda só à última fala da PESSOA.\n\n${conversa}`);
+                if (resposta) emit({ delta: resposta });
+            } catch (e) {
+                emit({ erro: e.message });
+            }
+            emit({ done: true });
+        },
+
+        async requestResumo(_servidor, { resumo, mensagens } = {}) {
+            const novas = (mensagens || []).filter((m) => m && m.role);
+            if (!novas.length) return { resumo: String(resumo || '') };
+            const corpo = (resumo ? `RESUMO ANTERIOR:\n${resumo}\n\n` : '') + 'MENSAGENS NOVAS:\n'
+                + novas.map((m) => `${m.role === 'user' ? 'USUÁRIO' : m.role === 'assistant' ? 'AGENTE' : 'FERRAMENTA'}: `
+                    + String(typeof m.content === 'string' ? m.content : JSON.stringify(m.content || '')).slice(0, 1200)).join('\n');
+            try {
+                return { resumo: perguntar(id, `${cerebro.SYSTEM_RESUMO}\n\n${corpo}`) || String(resumo || '') };
+            } catch (e) {
+                return { resumo: String(resumo || ''), erro: e.message };
+            }
+        },
+
+        async requestPlano(_servidor, { prompt } = {}) {
+            return { passos: [{ titulo: 'tarefa', pedido: String(prompt || '').trim() }], dividiu: false };
+        },
+    };
+}
+
+/** A ferramenta está instalada? (sem rodar nada caro) */
+function instalado(id) {
+    if (id === 'codex') return motorDe('codex').temCodex();
+    return motorDe('claude-code').temClaudeCode();
+}
+
+module.exports = { criar, instalado, perguntar };

package/lib/local/provedor.js

@@ -33,6 +33,22 @@ const ARQUIVO = () => path.join(os.homedir(), '.primocode', 'provedor.json');
 /* A ordem é a do menu. `modelos` é a preferência: ao colar a chave, fica o
    primeiro que a conta da pessoa de fato tem (a lista vem da própria API). */
 const PROVEDORES = {
+    /* Sem chave: a assinatura que a pessoa já tem na ferramenta de fora, que
+       roda escondida como cérebro (lib/local/motor-cli.js). */
+    'claude-code': {
+        nome: 'Claude Code',
+        cli: true,
+        modelos: ['opus'],
+        onde: 'https://docs.claude.com/claude-code',
+        dica: 'sua assinatura do Claude, sem chave',
+    },
+    codex: {
+        nome: 'Codex',
+        cli: true,
+        modelos: [''],
+        onde: 'https://github.com/openai/codex',
+        dica: 'sua assinatura do ChatGPT, sem chave',
+    },
     gemini: {
         nome: 'Gemini (Google)',
         base: 'https://generativelanguage.googleapis.com/v1beta/openai',
@@ -96,7 +112,9 @@ function atual() {
     try {
         const j = JSON.parse(fs.readFileSync(ARQUIVO(), 'utf8'));
         const p = PROVEDORES[j.provedor];
-        cache = p && j.chave ? { id: j.provedor, nome: p.nome, base: j.base || p.base, modelo: j.modelo || p.modelos[0], chave: j.chave } : null;
+        cache = p && (j.chave || p.cli)
+            ? { id: j.provedor, nome: p.nome, cli: !!p.cli, base: j.base || p.base, modelo: j.modelo || p.modelos[0], chave: j.chave || '' }
+            : null;
     } catch { cache = null; }
     cacheMtime = st.mtimeMs;
     return cache;
@@ -106,7 +124,7 @@ function salvar({ provedor, chave, modelo }) {
     if (!PROVEDORES[provedor]) throw new Error(`provedor desconhecido: ${provedor}`);
     const arq = ARQUIVO();
     fs.mkdirSync(path.dirname(arq), { recursive: true });
-    fs.writeFileSync(arq, JSON.stringify({ provedor, chave: String(chave).trim(), modelo }, null, 2), { mode: 0o600 });
+    fs.writeFileSync(arq, JSON.stringify({ provedor, chave: String(chave || '').trim(), modelo }, null, 2), { mode: 0o600 });
     try { fs.chmodSync(arq, 0o600); } catch { /* Windows */ }
     cache = null;
     return atual();