primocode 8.31.0 → 8.33.0

package/lib/api.js

@@ -35,6 +35,39 @@ function buildOptions(url, method, extraHeaders, bodyLength, token) {
     };
 }
 
+/* ── OS PRAZOS ────────────────────────────────────────────────────────────
+ * Sem prazo, um servidor que aceita a conexão e fica MUDO pendura o CLI para
+ * sempre: sem mensagem, sem spinner que pare, sem nada — e a pessoa só sai
+ * com Ctrl-C, sem saber o que houve. Aconteceu num teste real e custou um
+ * bom tempo de investigação para descobrir que não era lentidão, era trava.
+ *
+ * ── POR QUE NÃO UM PRAZO CURTO PARA CONECTAR ────────────────────────────
+ * A tentação é cortar em 20s "porque conectar é rápido". Aqui não é: o
+ * servidor roda no plano gratuito do Render, que DORME. A primeira chamada
+ * depois de um tempo parado espera a máquina subir — 30, 40, às vezes 60
+ * segundos — com o socket já aceito e nenhum byte voltando. Um teto curto
+ * trocaria uma trava rara por uma quebra TODO DIA, na primeira pergunta da
+ * manhã, e a pessoa leria "timeout" achando que está sem internet.
+ *
+ * Então os prazos são generosos e medem a coisa certa:
+ *
+ *   · Nas chamadas curtas (refinar, plano, resumo), um teto duro na resposta
+ *     inteira. Elas são pequenas; se passou disso, travou.
+ *
+ *   · No stream, o prazo é de SILÊNCIO e reinicia a cada pedaço que chega.
+ *     Um modelo pensando três minutos e escrevendo nunca é cortado; quem é
+ *     cortado é quem para de falar sem fechar a conexão — a trava que não
+ *     dava sinal nenhum.
+ */
+const PRAZO_RESPOSTA = Number(process.env.PRIMOCODE_TIMEOUT_RESPOSTA || 180000);
+const PRAZO_SILENCIO = Number(process.env.PRIMOCODE_TIMEOUT_SILENCIO || 240000);
+
+function erroDeTempo(oque, ms) {
+    return new Error(
+        `O servidor não ${oque} em ${Math.round(ms / 1000)}s (timeout). `
+        + 'Pode ser a rede, ou o servidor fora do ar — tente de novo.');
+}
+
 function request(serverUrl, endpoint, payload, token) {
     return new Promise((resolve, reject) => {
         const url = new URL(endpoint, serverUrl);
@@ -51,7 +84,17 @@ function request(serverUrl, endpoint, payload, token) {
                 else resolve(json);
             });
         });
-        req.on('error', reject);
+        // Um relógio só, na resposta inteira. Nada de prazo de socket: ele
+        // mediria o silêncio da máquina subindo no Render e mataria a
+        // primeira chamada do dia.
+        const relogio = setTimeout(() => {
+            req.destroy(erroDeTempo('terminou de responder', PRAZO_RESPOSTA));
+        }, PRAZO_RESPOSTA);
+        if (relogio.unref) relogio.unref();
+        const parar = () => clearTimeout(relogio);
+        req.on('close', parar);
+
+        req.on('error', (e) => { parar(); reject(e); });
         req.write(data);
         req.end();
     });
@@ -73,7 +116,23 @@ function requestStream(serverUrl, endpoint, payload, onEvent, token, sinal) {
         const client = url.protocol === 'https:' ? https : http;
         const options = buildOptions(url, 'POST', { Accept: 'text/event-stream' }, Buffer.byteLength(data), token);
 
+        /* O relógio do SILÊNCIO. Reiniciado a cada pedaço que chega, então um
+           modelo que pensa três minutos e vai escrevendo nunca é cortado — só
+           é cortado quem para de falar e não fecha a conexão, que é
+           exatamente a trava que não dava sinal nenhum. */
+        let relogio = null;
+        const morrerSeCalar = () => {
+            clearTimeout(relogio);
+            relogio = setTimeout(() => {
+                req.destroy(erroDeTempo('mandou nada por', PRAZO_SILENCIO));
+            }, PRAZO_SILENCIO);
+            if (relogio.unref) relogio.unref();
+        };
+        const calarORelogio = () => clearTimeout(relogio);
+
         const req = client.request(options, (res) => {
+            morrerSeCalar();
+            res.on('data', morrerSeCalar);
             // Erro HTTP não vem como SSE — o corpo é um JSON de erro.
             if (res.statusCode >= 400) {
                 let body = '';
@@ -87,7 +146,7 @@ function requestStream(serverUrl, endpoint, payload, onEvent, token, sinal) {
             }
 
             let settled = false;
-            const finish = () => { if (!settled) { settled = true; resolve(); } };
+            const finish = () => { calarORelogio(); if (!settled) { settled = true; resolve(); } };
 
             let buffer = '';
             res.setEncoding('utf8');
@@ -125,13 +184,18 @@ function requestStream(serverUrl, endpoint, payload, onEvent, token, sinal) {
         const cortar = () => {
             if (cortado) return;
             cortado = true;
+            calarORelogio();
             try { req.destroy(); } catch {}
             resolve();
         };
         if (sinal) sinal.addEventListener('abort', cortar, { once: true });
 
-        req.on('error', (e) => { if (!cortado) reject(e); });
+        req.on('error', (e) => { calarORelogio(); if (!cortado) reject(e); });
         req.on('close', () => { if (sinal) sinal.removeEventListener('abort', cortar); });
+        // O relógio começa AQUI, não na primeira resposta: se o servidor
+        // aceitar a conexão e nunca mandar nada, `morrerSeCalar` nunca teria
+        // sido chamado e a trava voltaria inteira.
+        morrerSeCalar();
         req.write(data);
         req.end();
     });

package/lib/app.js

@@ -145,7 +145,23 @@ async function abrir(op) {
         emitir('estado', op.estado());
     }
 
+    // `async` por causa das rotas de histórico, que esperam a nuvem. Uma
+    // exceção aqui viraria unhandledRejection e derrubaria o CLI inteiro
+    // junto com a janela, então o corpo fica dentro de um try/catch.
     const servidor = http.createServer((req, res) => {
+        atender(req, res).catch((e) => {
+            // Uma exceção solta aqui vira unhandledRejection e derruba o CLI
+            // INTEIRO junto com a janela — o trabalho da pessoa some porque
+            // uma listagem de conversa tropeçou. Aqui ela vira um 500 e a
+            // janela segue de pé.
+            try {
+                if (!res.headersSent) res.writeHead(500, { 'Content-Type': 'application/json' });
+                res.end(JSON.stringify({ ok: false, error: e.message }));
+            } catch { /* socket já foi */ }
+        });
+    });
+
+    async function atender(req, res) {
         const url = new URL(req.url, 'http://127.0.0.1');
         const rota = url.pathname;
 
@@ -216,6 +232,28 @@ async function abrir(op) {
             return;
         }
 
+        /* O HISTÓRICO da janela vem do MESMO lugar que o do terminal:
+           lib/nuvem.js, coleção `primocode`, cifrado. A janela não fala com o
+           Firestore por conta própria — ela pergunta ao servidor dela, que já
+           tem a sessão e a cifra. Um segundo caminho até o banco significaria
+           uma segunda implementação da cifra, e a segunda divergiria da
+           primeira sem ninguém ver. */
+        if (rota === '/api/conversas') {
+            const nuvem = require('./nuvem.js');
+            const r = await nuvem.listarConversas({ limite: 40 })
+                .catch((e) => ({ ok: false, error: e.message }));
+            res.writeHead(200, { 'Content-Type': 'application/json; charset=utf-8' });
+            return res.end(JSON.stringify(r));
+        }
+
+        if (rota.startsWith('/api/conversa/')) {
+            const nuvem = require('./nuvem.js');
+            const id = decodeURIComponent(rota.slice('/api/conversa/'.length));
+            const r = await nuvem.lerConversa(id).catch((e) => ({ ok: false, error: e.message }));
+            res.writeHead(200, { 'Content-Type': 'application/json; charset=utf-8' });
+            return res.end(JSON.stringify(r));
+        }
+
         if (rota === '/api/estado') {
             res.writeHead(200, { 'Content-Type': 'application/json; charset=utf-8' });
             return res.end(JSON.stringify(Object.assign({ versao: op.versao }, op.estado())));
@@ -231,7 +269,7 @@ async function abrir(op) {
             res.writeHead(200, { 'Content-Type': tipoDe(nome) });
             res.end(dados);
         });
-    });
+    }
 
     const porta = await escutar(servidor, PORTA_PADRAO);
     servidor.__porta = porta;

package/lib/boas-vindas.js

@@ -0,0 +1,161 @@
+/**
+ * boas-vindas.js — a primeira vez que alguém roda `primo`.
+ *
+ *   "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."
+ *
+ * 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.
+ *
+ * ── 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.
+ *
+ * ── 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.
+ */
+
+'use strict';
+
+const fs = require('fs');
+const os = require('os');
+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;
+}
+
+function marcarQueAbriu(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');
+        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.',
+    },
+];
+
+/** 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
+}
+
+/**
+ * O assistente.
+ *
+ * @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
+ */
+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 };
+    }
+
+    mostrar('');
+    mostrar(c.bold(c.brand('  Primeira vez por aqui.')));
+    mostrar(c.muted('  Escolha qual IA vai pensar por trás do PrimoCode:'));
+    mostrar('');
+    ESCOLHAS.forEach((e, i) => {
+        mostrar('  ' + c.brand(String(i + 1)) + c.muted('. ') + c.white(e.titulo)
+            + (i === 0 ? c.dim('  (recomendado)') : ''));
+        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.'));
+    }
+    // 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';
+
+    let resultado = { escolha };
+    if (escolha === 'conecta' && conectar) {
+        mostrar('');
+        resultado.conexao = await conectar();
+    } else if (escolha === 'propria' && configurarChave) {
+        mostrar('');
+        resultado.chave = await configurarChave();
+    } else if (escolha === 'depois') {
+        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'));
+    }
+
+    // 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 });
+    mostrar('');
+    return { ok: true, perguntou: true, ...resultado };
+}
+
+module.exports = { jaAbriu, marcarQueAbriu, esquecer, lerEscolha, rodar, ESCOLHAS, MARCA };

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,