primocode 8.30.0 → 8.32.0

package/bin/primocode.js

@@ -21,12 +21,15 @@ 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');
 const memoria = require('../lib/memoria-conversa');
 const appLib = require('../lib/app');
 const conta = require('../lib/conta');
+const nuvem = require('../lib/nuvem');
 
 // Rede de segurança de último recurso: sem isto, uma exceção fora de um
 // try/catch (ex.: dentro de um callback de socket, como o parser de SSE) não
@@ -56,11 +59,14 @@ const state = {
     // O resumo incremental da conversa — um /compact automático. O porquê
     // está em lib/memoria-conversa.js.
     memoria: memoria.nova(),
+    // 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(),
     lastResponse: '',
     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
@@ -82,7 +88,11 @@ ${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
   ${c.brand('/status')}               checa o servidor
   ${c.brand('/name')} <nome>          como o Primo te chama
@@ -125,8 +135,12 @@ 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'],
     ['/sair', 'desconecta este computador'],
     ['/status', 'checa o servidor'],
     ['/name', 'como ele te chama'],
@@ -477,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();
@@ -498,6 +512,10 @@ async function sendPrompt(userText) {
         state.history.push({ role: 'assistant', content: r.assistantMessage.content });
         state.lastResponse = r.assistantMessage.content;
         cfg.appendHistory({ mode: 'primocode', project: state.currentProject, prompt: userText });
+        // Sobe cifrado, atrás, sem segurar o prompt. Se não houver conta ou
+        // rede, não acontece nada — a conversa segue aqui do mesmo jeito.
+        state.gravador.turno(userText, r.assistantMessage.content,
+            { modo: 'primocode', projeto: state.currentProject || null });
     } else {
         await comprimirConversa();
         await runChat(prompt, userText);
@@ -640,11 +658,23 @@ async function runChat(promptForModel, userTextForMemory) {
         state.history.push({ role: 'assistant', content: text });
         state.lastResponse = text;
         cfg.appendHistory({ mode: 'chat', prompt: userTextForMemory });
+        state.gravador.turno(userTextForMemory, text, { modo: 'chat' });
     }
 }
 
 // ── 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) {
@@ -744,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; }
@@ -760,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;
         }
@@ -909,7 +1006,11 @@ async function handleSlash(text) {
             break;
         }
 
-        case 'clear': state.history = []; state.memoria = memoria.nova(); console.log(c.ok('Conversa limpa.')); break;
+        // Limpar aqui não apaga o que já subiu: encerra ESTA conversa e a
+        // próxima pergunta abre outra. Apagar do histórico é decisão da
+        // pessoa, e ela toma no app — não de raspão num comando de limpar tela.
+        case 'clear': state.history = []; state.memoria = memoria.nova();
+            state.gravador.zerar(); console.log(c.ok('Conversa limpa.')); break;
         case 'cls': process.stdout.write('\x1Bc'); break;
 
         case 'status': {
@@ -1043,6 +1144,55 @@ async function handleSlash(text) {
             break;
         }
 
+        /* O histórico da conta — o MESMO que o app desktop e o celular
+           mostram. Sem número, lista; com número, abre e continua dali. */
+        case 'conversas': case 'historico': {
+            if (!conta.atual()) {
+                console.log(c.muted('  Não conectado. ') + c.brand('/entrar')
+                    + c.muted(' para ver suas conversas aqui, no app e no celular.'));
+                break;
+            }
+            const sp = new Spinner('lendo suas conversas').start();
+            const l = await nuvem.listarConversas({ limite: 20 });
+            sp.stop();
+            if (!l.ok) { console.log(c.err(`  ${l.error}`)); break; }
+            if (!l.conversas.length) {
+                console.log(c.muted('  Nenhuma conversa salva ainda. A próxima já fica.'));
+                break;
+            }
+            if (!rest) {
+                console.log(c.white('\n  Suas conversas'));
+                l.conversas.forEach((x, i) => {
+                    const quando = x.atualizada
+                        ? new Date(x.atualizada).toLocaleDateString('pt-BR') : '—';
+                    console.log('  ' + c.dim(String(i + 1).padStart(2))
+                        + ' ' + c.white(x.titulo.slice(0, 52).padEnd(52))
+                        + c.dim(`${String(x.mensagens).padStart(3)} msg  ${quando}`));
+                });
+                console.log(c.dim('\n  /conversas 1  abre a primeira e continua dela.'));
+                break;
+            }
+            const n = Number(rest);
+            const alvo = l.conversas[n - 1];
+            if (!alvo) { console.log(c.err(`  Não achei a conversa ${rest}.`)); break; }
+            const sp2 = new Spinner('abrindo').start();
+            const conv = await nuvem.lerConversa(alvo.id);
+            sp2.stop();
+            if (!conv.ok) { console.log(c.err(`  ${conv.error}`)); break; }
+            // A memória entra ZERADA: o resumo antigo não veio junto, e um
+            // resumo de outra conversa colado aqui faria o modelo responder
+            // sobre coisa que não foi dita nesta.
+            state.history = conv.mensagens.map((m) => ({
+                role: m.papel, content: m.texto,
+            }));
+            state.memoria = memoria.nova();
+            state.gravador.retomar(alvo.id, alvo.titulo, conv.mensagens.length);
+            console.log(c.ok(`  ${alvo.titulo}`)
+                + c.muted(`  · ${conv.mensagens.length} mensagens carregadas`));
+            console.log(c.dim('  Pode continuar daqui — o que você disser volta pro app e pro celular.'));
+            break;
+        }
+
         case 'sair': case 'logout': {
             if (!conta.atual()) { console.log(c.muted('  Você não está conectado.')); break; }
             conta.sair();
@@ -1304,7 +1454,19 @@ async function main() {
     function sayBye() {
         if (saidBye) return;
         saidBye = true;
-        console.log(c.muted('\nAté logo!'));
+        // O último turno pode ainda estar subindo — gravar é de propósito
+        // solto, para não segurar o prompt. Fechar o terminal em cima dele
+        // perderia justamente a resposta que a pessoa acabou de ler, e ela
+        // não veria falta nenhuma até procurar no celular.
+        const fim = () => console.log(c.muted('\nAté logo!'));
+        Promise.race([
+            state.gravador.esperar(),
+            // Rede pendurada não vira terminal pendurado. `unref` porque o
+            // temporizador sozinho seguraria o processo por 3s mesmo quando a
+            // gravação já terminou — um "Até logo!" seguido de três segundos
+            // de nada é o tipo de coisa que quem usa chama de travado.
+            new Promise((r) => { const t = setTimeout(r, 3000); if (t.unref) t.unref(); }),
+        ]).then(fim, fim);
     }
 
     async function drain() {

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/lib/nuvem.js

@@ -0,0 +1,407 @@
+/**
+ * nuvem.js — as conversas do PrimoCode no Firestore, cifradas.
+ *
+ *   "As conversas que você vai ter vão ficar salvas no histórico do aplicativo
+ *    desktop. Você vai poder acessá-las no terminal, e também acessá-las pelo
+ *    celular e poder mexer pelo celular. Lembrando que tudo tem que estar
+ *    criptografado."
+ *
+ * ── A CIFRA É A MESMA DO APP, BYTE POR BYTE ──────────────────────────────
+ * O `frontend/crypto.js` do Conecta Primo faz PBKDF2-SHA256 com 310.000
+ * voltas sobre o UID, com um sal de 16 bytes, e AES-256-GCM com o UID como
+ * dado autenticado. O sal viaja DENTRO do pacote (`s`), e é isso que faz uma
+ * conversa cifrada aqui abrir no celular — a chave se refaz de qualquer
+ * aparelho a partir do que está gravado.
+ *
+ * Reimplementar isso em Node não é escolha: o `crypto.subtle` do navegador não
+ * existe aqui do mesmo jeito, e o app não vai deixar de ser web. O que se pode
+ * fazer é garantir que as duas contas são a MESMA, e é o que o teste faz —
+ * ele cifra aqui, decifra no Chromium com o `crypto.js` de verdade, e ao
+ * contrário. Duas implementações que divergem em uma iteração produzem lixo
+ * ilegível sem erro em lugar nenhum.
+ *
+ * ── POR QUE FALAR DIRETO COM O FIRESTORE ─────────────────────────────────
+ * A alternativa era o servidor intermediar cada leitura e escrita, com uma
+ * autorização própria. Seria um SEGUNDO modelo de permissão ao lado das
+ * `firestore.rules`, e os dois divergiriam na primeira mudança delas. Aqui o
+ * CLI troca o token do PrimoCode por uma sessão curta (custom token → token de
+ * acesso) e usa a API REST: as regras do banco valem para o terminal
+ * exatamente como valem para o app e para o celular.
+ *
+ * ── ZERO DEPENDÊNCIA ─────────────────────────────────────────────────────
+ * Nada de `firebase-admin` nem do SDK web. O que se usa é o `crypto` e o
+ * `https` do Node, contra a API REST do Firestore e a do Identity Toolkit.
+ */
+
+'use strict';
+
+const crypto = require('crypto');
+const https = require('https');
+const http = require('http');
+
+const conta = require('./conta.js');
+
+/* Os dois endereços saem daqui em vez de estarem escritos no meio do código.
+   Não é para trocar de nuvem: é para o teste conseguir pôr um Firestore de
+   mentira no lugar e CONFERIR O QUE SOBE. Sem isso, a única forma de saber se
+   um título vai em claro seria olhar o console do Firebase depois — que é
+   exatamente tarde demais. */
+const FIRESTORE = process.env.PRIMOCODE_FIRESTORE || 'https://firestore.googleapis.com';
+const IDENTIDADE = process.env.PRIMOCODE_IDENTITY || 'https://identitytoolkit.googleapis.com';
+
+const VERSAO_CIFRA = 2;          // o mesmo `v` do frontend/crypto.js
+const ITERACOES = 310000;
+const TAM_IV = 12;
+
+// ── a cifra ──────────────────────────────────────────────────────────────
+
+function derivar(uid, sal) {
+    return crypto.pbkdf2Sync(Buffer.from(uid, 'utf8'), sal, ITERACOES, 32, 'sha256');
+}
+
+/* Cifra um texto no formato que o app grava e lê: { v, iv, ct, s }.
+ *
+ * O UID entra como AAD (dado autenticado, não cifrado): é o que impede mover
+ * um registro cifrado de uma conta para outra — a decifragem falha em vez de
+ * devolver o texto de outra pessoa. */
+function cifrar(texto, uid, salDado) {
+    const sal = salDado || crypto.randomBytes(16);
+    const chave = derivar(uid, sal);
+    const iv = crypto.randomBytes(TAM_IV);
+    const c = crypto.createCipheriv('aes-256-gcm', chave, iv);
+    c.setAAD(Buffer.from(uid, 'utf8'));
+    const corpo = Buffer.concat([c.update(Buffer.from(String(texto ?? ''), 'utf8')), c.final()]);
+    // O WebCrypto põe a etiqueta de autenticação NO FIM do texto cifrado; o
+    // Node a entrega à parte. Sem colar as duas, o navegador recusa tudo o que
+    // o terminal escrever — e o erro sai como "conversa corrompida".
+    const ct = Buffer.concat([corpo, c.getAuthTag()]);
+    return { v: VERSAO_CIFRA, iv: iv.toString('base64'), ct: ct.toString('base64'),
+        s: sal.toString('base64') };
+}
+
+function decifrar(pacote, uid) {
+    if (!pacote || !pacote.ct) return '';
+    const sal = Buffer.from(pacote.s || '', 'base64');
+    const chave = derivar(uid, sal);
+    const bruto = Buffer.from(pacote.ct, 'base64');
+    // Os últimos 16 bytes são a etiqueta — a mesma separação, ao contrário.
+    const etiqueta = bruto.subarray(bruto.length - 16);
+    const corpo = bruto.subarray(0, bruto.length - 16);
+    const d = crypto.createDecipheriv('aes-256-gcm', chave,
+        Buffer.from(pacote.iv, 'base64'));
+    d.setAAD(Buffer.from(uid, 'utf8'));
+    d.setAuthTag(etiqueta);
+    return Buffer.concat([d.update(corpo), d.final()]).toString('utf8');
+}
+
+const cifrarJson = (obj, uid) => cifrar(JSON.stringify(obj), uid);
+const decifrarJson = (p, uid) => JSON.parse(decifrar(p, uid));
+
+// ── a sessão do Firestore ────────────────────────────────────────────────
+
+function httpsJson(url, metodo, corpo, cabecalhos = {}, timeout = 20000) {
+    return new Promise((resolve, reject) => {
+        const u = new URL(url);
+        const lib = u.protocol === 'https:' ? https : http;
+        const dados = corpo == null ? null : Buffer.from(JSON.stringify(corpo), 'utf8');
+        const h = { Accept: 'application/json', ...cabecalhos };
+        if (dados) { h['Content-Type'] = 'application/json'; h['Content-Length'] = dados.length; }
+        const req = lib.request({
+            hostname: u.hostname, port: u.port || undefined,
+            path: u.pathname + u.search, method: metodo, timeout, headers: h,
+        }, (res) => {
+            let t = '';
+            res.setEncoding('utf8');
+            res.on('data', (c) => { t += c; });
+            res.on('end', () => {
+                let j = null;
+                try { j = JSON.parse(t); } catch { /* pode vir vazio */ }
+                if (res.statusCode >= 400) {
+                    const m = (j && j.error && (j.error.message || j.error)) || `HTTP ${res.statusCode}`;
+                    return reject(new Error(String(m)));
+                }
+                resolve(j || {});
+            });
+        });
+        req.on('timeout', () => req.destroy(new Error('o Firestore demorou demais')));
+        req.on('error', reject);
+        if (dados) req.write(dados);
+        req.end();
+    });
+}
+
+let _sessao = null;   // { uid, idToken, expira, projeto }
+
+/* Abre (ou renova) a sessão. O token de acesso do Firebase dura uma hora;
+   renovar cinco minutos antes evita a escrita que falha no meio de uma
+   conversa longa — e falhar ali perde a mensagem, não só o pedido. */
+async function abrir() {
+    if (_sessao && Date.now() < _sessao.expira - 300000) return _sessao;
+    const s = await conta.sessao();
+    if (!s.ok) return null;
+    if (!s.apiKey || !s.projeto) {
+        // O servidor não está configurado para isto (falta FIREBASE_API_KEY /
+        // FIREBASE_PROJECT_ID no ambiente dele). Dizer é melhor que tentar e
+        // falhar com "requisição inválida" mais adiante.
+        return null;
+    }
+    const r = await httpsJson(
+        `${IDENTIDADE}/v1/accounts:signInWithCustomToken?key=${s.apiKey}`,
+        'POST', { token: s.customToken, returnSecureToken: true });
+    _sessao = {
+        uid: s.uid, projeto: s.projeto, plano: s.plano, pro: s.pro,
+        idToken: r.idToken,
+        expira: Date.now() + (Number(r.expiresIn || 3600) * 1000),
+    };
+    return _sessao;
+}
+
+function esquecer() { _sessao = null; }
+
+const BASE = (proj) => `${FIRESTORE}/v1/projects/${proj}/databases/(default)/documents`;
+
+/* O Firestore REST embrulha cada valor num objeto de tipo. Só três tipos
+   aparecem aqui, e é de propósito: tudo que é conteúdo já vem cifrado num
+   `mapValue`, e o que fica em claro é o mínimo que a regra confere (`role`)
+   e o que ordena (`timestamp`). */
+function paraFirestore(v) {
+    if (v === null || v === undefined) return { nullValue: null };
+    if (typeof v === 'string') return { stringValue: v };
+    if (typeof v === 'number') return Number.isInteger(v)
+        ? { integerValue: String(v) } : { doubleValue: v };
+    if (typeof v === 'boolean') return { booleanValue: v };
+    if (Array.isArray(v)) return { arrayValue: { values: v.map(paraFirestore) } };
+    const fields = {};
+    for (const [k, x] of Object.entries(v)) fields[k] = paraFirestore(x);
+    return { mapValue: { fields } };
+}
+
+function doFirestore(v) {
+    if (!v || typeof v !== 'object') return v;
+    if ('stringValue' in v) return v.stringValue;
+    if ('integerValue' in v) return Number(v.integerValue);
+    if ('doubleValue' in v) return v.doubleValue;
+    if ('booleanValue' in v) return v.booleanValue;
+    if ('nullValue' in v) return null;
+    if ('arrayValue' in v) return (v.arrayValue.values || []).map(doFirestore);
+    if ('mapValue' in v) {
+        const o = {};
+        for (const [k, x] of Object.entries(v.mapValue.fields || {})) o[k] = doFirestore(x);
+        return o;
+    }
+    return null;
+}
+
+const campos = (obj) => {
+    const f = {};
+    for (const [k, v] of Object.entries(obj)) f[k] = paraFirestore(v);
+    return f;
+};
+
+// ── as conversas ─────────────────────────────────────────────────────────
+
+const COLECAO = 'primocode';
+
+/**
+ * Abre (ou continua) uma conversa. O TÍTULO sobe cifrado, como no app.
+ *
+ * Os campos são exatamente os que a regra aceita — `enc`, `createdAt`,
+ * `updatedAt`, `messageCount`. Um campo a mais e a gravação é RECUSADA em
+ * produção, o que é o preço declarado da lista de permitidos: recusa é
+ * ruidosa e se conserta em minutos; conteúdo em claro é silencioso.
+ */
+async function salvarConversa({ id, titulo, mensagens = 0 }) {
+    const s = await abrir();
+    if (!s) return { ok: false, error: 'não conectado' };
+    const ident = id || ('pc' + Date.now().toString(36) + crypto.randomBytes(4).toString('hex'));
+    const agora = new Date().toISOString();
+    const corpo = {
+        fields: campos({
+            enc: cifrarJson({ titulo: String(titulo || 'Conversa') }, s.uid),
+            updatedAt: agora,
+            messageCount: mensagens,
+            ...(id ? {} : { createdAt: agora }),
+        }),
+    };
+    // `updateMask` para não apagar `createdAt` ao atualizar: um PATCH sem ele
+    // substitui o documento inteiro, e a data de criação sumiria na primeira
+    // mensagem seguinte.
+    const mascara = Object.keys(corpo.fields).map((k) => `updateMask.fieldPaths=${k}`).join('&');
+    try {
+        await httpsJson(
+            `${BASE(s.projeto)}/users/${s.uid}/${COLECAO}/${ident}?${mascara}`,
+            'PATCH', corpo, { Authorization: `Bearer ${s.idToken}` });
+        return { ok: true, id: ident };
+    } catch (e) { return { ok: false, error: e.message }; }
+}
+
+/**
+ * Guarda uma mensagem. `papel` é 'user' ou 'assistant' — a regra confere.
+ * `feito` é o que o agente fez na volta (arquivos, comandos), e vai cifrado
+ * em `wenc`, no mesmo lugar em que o app guarda os cartões.
+ */
+async function salvarMensagem({ conversa, papel, texto, feito }) {
+    const s = await abrir();
+    if (!s) return { ok: false, error: 'não conectado' };
+    if (papel !== 'user' && papel !== 'assistant') {
+        return { ok: false, error: `papel inválido: ${papel}` };
+    }
+    const doc = { enc: cifrar(texto, s.uid), role: papel, timestamp: new Date().toISOString() };
+    if (feito) doc.wenc = cifrarJson(feito, s.uid);
+    try {
+        const r = await httpsJson(
+            `${BASE(s.projeto)}/users/${s.uid}/${COLECAO}/${conversa}/messages`,
+            'POST', { fields: campos(doc) }, { Authorization: `Bearer ${s.idToken}` });
+        return { ok: true, id: (r.name || '').split('/').pop() };
+    } catch (e) { return { ok: false, error: e.message }; }
+}
+
+/** As conversas mais recentes, com o título já decifrado. */
+async function listarConversas({ limite = 20 } = {}) {
+    const s = await abrir();
+    if (!s) return { ok: false, error: 'não conectado' };
+    try {
+        const r = await httpsJson(
+            `${BASE(s.projeto)}/users/${s.uid}/${COLECAO}?pageSize=${Math.min(100, limite)}`
+            + '&orderBy=updatedAt%20desc',
+            'GET', null, { Authorization: `Bearer ${s.idToken}` });
+        const fora = [];
+        for (const d of r.documents || []) {
+            const campos2 = {};
+            for (const [k, v] of Object.entries(d.fields || {})) campos2[k] = doFirestore(v);
+            let titulo = '(sem título)';
+            // Uma conversa que não decifra NÃO derruba a lista: ela pode ter
+            // vindo de uma versão anterior da cifra, e mostrar as outras é
+            // melhor que mostrar nenhuma.
+            try { titulo = decifrarJson(campos2.enc, s.uid).titulo || titulo; } catch {}
+            fora.push({
+                id: (d.name || '').split('/').pop(),
+                titulo,
+                mensagens: campos2.messageCount || 0,
+                atualizada: campos2.updatedAt || null,
+            });
+        }
+        return { ok: true, conversas: fora };
+    } catch (e) { return { ok: false, error: e.message }; }
+}
+
+/** As mensagens de uma conversa, em ordem, decifradas. */
+async function lerConversa(id, { limite = 200 } = {}) {
+    const s = await abrir();
+    if (!s) return { ok: false, error: 'não conectado' };
+    try {
+        const r = await httpsJson(
+            `${BASE(s.projeto)}/users/${s.uid}/${COLECAO}/${id}/messages`
+            + `?pageSize=${Math.min(300, limite)}&orderBy=timestamp`,
+            'GET', null, { Authorization: `Bearer ${s.idToken}` });
+        const msgs = [];
+        for (const d of r.documents || []) {
+            const f = {};
+            for (const [k, v] of Object.entries(d.fields || {})) f[k] = doFirestore(v);
+            try {
+                msgs.push({
+                    papel: f.role,
+                    texto: decifrar(f.enc, s.uid),
+                    feito: f.wenc ? decifrarJson(f.wenc, s.uid) : null,
+                    quando: f.timestamp,
+                });
+            } catch { /* mensagem ilegível: pula, não derruba a conversa */ }
+        }
+        return { ok: true, mensagens: msgs };
+    } catch (e) { return { ok: false, error: e.message }; }
+}
+
+// ── o gravador da sessão ─────────────────────────────────────────────────
+
+/** Título a partir da primeira frase: uma linha, curta, sem cortar no meio de
+ *  uma palavra quando dá para não cortar. */
+function tituloDe(texto) {
+    const limpo = String(texto || '').replace(/\s+/g, ' ').trim();
+    if (!limpo) return 'Conversa';
+    if (limpo.length <= 60) return limpo;
+    const corte = limpo.slice(0, 60);
+    const espaco = corte.lastIndexOf(' ');
+    return (espaco > 30 ? corte.slice(0, espaco) : corte) + '…';
+}
+
+/**
+ * Acompanha a sessão do terminal e vai subindo os turnos.
+ *
+ * ── POR QUE UMA FILA ─────────────────────────────────────────────────────
+ * Gravar não pode segurar o prompt: são três idas à rede por turno, e ninguém
+ * quer esperar um segundo para digitar a próxima frase. Então `turno()` volta
+ * na hora e o trabalho acontece atrás.
+ *
+ * Só que "atrás" e "em paralelo" não são a mesma coisa. Dois turnos soltos ao
+ * mesmo tempo criariam DUAS conversas — cada um veria `id` ainda vazio — e as
+ * mensagens chegariam fora de ordem. A fila é uma promessa só, encadeada: o
+ * segundo turno começa quando o primeiro acabou, sempre.
+ *
+ * ── POR QUE ENGOLIR O ERRO ───────────────────────────────────────────────
+ * Sem conta, sem rede, servidor fora: a conversa continua funcionando no
+ * terminal e simplesmente não sobe. Derrubar o turno de trabalho de alguém
+ * porque o histórico não salvou seria trocar um incômodo por um prejuízo.
+ */
+function gravador() {
+    let id = null;
+    let titulo = null;
+    let contagem = 0;
+    let fila = Promise.resolve();
+    let ultimoErro = null;
+
+    const enfileirar = (f) => {
+        fila = fila.then(f).catch((e) => { ultimoErro = e.message; });
+        return fila;
+    };
+
+    return {
+        get id() { return id; },
+        get mensagens() { return contagem; },
+        get erro() { return ultimoErro; },
+
+        /** Continua uma conversa que já existe (veio do app ou do celular). */
+        retomar(idExistente, tit, quantas = 0) {
+            id = idExistente; titulo = tit || null; contagem = quantas;
+        },
+        /** `/clear`: a próxima pergunta abre uma conversa nova. */
+        zerar() { id = null; titulo = null; contagem = 0; },
+
+        turno(pergunta, resposta, feito) {
+            return enfileirar(async () => {
+                const s = await abrir();
+                if (!s) return;                     // sem conta: fica só no local
+                if (!titulo) titulo = tituloDe(pergunta);
+                if (!id) {
+                    const r = await salvarConversa({ titulo });
+                    if (!r.ok) { ultimoErro = r.error; return; }
+                    id = r.id;
+                }
+                const a = await salvarMensagem({ conversa: id, papel: 'user', texto: pergunta });
+                if (!a.ok) { ultimoErro = a.error; return; }
+                const b = await salvarMensagem({ conversa: id, papel: 'assistant',
+                    texto: resposta, feito });
+                if (!b.ok) { ultimoErro = b.error; return; }
+                contagem += 2;
+                // A contagem e a data de mudança são o que ordena a lista no
+                // celular. Sem esta volta, a conversa de hoje aparece embaixo
+                // das de semana passada.
+                await salvarConversa({ id, titulo, mensagens: contagem });
+            });
+        },
+
+        /** O que ainda está subindo. Chamado na saída, para não perder o
+         *  último turno quando alguém fecha o terminal logo depois. */
+        esperar() { return fila; },
+    };
+}
+
+module.exports = {
+    cifrar, decifrar, cifrarJson, decifrarJson,
+    gravador, tituloDe,
+    abrir, esquecer,
+    salvarConversa, salvarMensagem, listarConversas, lerConversa,
+    COLECAO, VERSAO_CIFRA, ITERACOES, TAM_IV,
+    // A tradução para o formato do Firestore sai daqui porque é ela que decide
+    // o que vira `stringValue` em claro e o que vira `mapValue` cifrado.
+    paraFirestore, doFirestore,
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "primocode",
-  "version": "8.30.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"
+    "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"