primocode 8.30.0 → 8.31.0

package/bin/primocode.js

@@ -27,6 +27,7 @@ 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,6 +57,9 @@ 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
@@ -83,6 +87,7 @@ ${c.bold('Comandos')}
   ${c.brand('/open')} <arquivo|url>   abre no navegador
   ${c.brand('/app')}                  abre a janela do PrimoCode (chat, sem terminal)
   ${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
@@ -127,6 +132,7 @@ const SLASH_COMANDOS = [
     ['/app', 'abre a janela do PrimoCode'],
     ['/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'],
@@ -498,6 +504,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,6 +650,7 @@ 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' });
     }
 }
 
@@ -909,7 +920,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 +1058,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 +1368,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/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.31.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"
   },
   "engines": {
     "node": ">=18.17.0"