primocode 11.0.0 → 11.1.0

package/lib/provider/codex-engine.js

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

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

package/lib/provider/local/motor.js

@@ -0,0 +1,267 @@
+/**
+ * motor.js — o agente falando DIRETO com a IA da pessoa, daqui da máquina.
+ *
+ * Faz o que o primocode-server faz nas rotas /api/act/stream, /api/chat/stream,
+ * /api/resumir e /api/plano, com o mesmo prompt e as mesmas ferramentas
+ * (lib/provider/local/cerebro.json, copiado do servidor por scripts/cerebro-do-servidor.js),
+ * e devolve os MESMOS eventos. Para o loop do agente (lib/session/runner/act.js), nada muda:
+ * ele não sabe se quem respondeu foi o servidor ou a API da pessoa.
+ *
+ * O que fica de fora de propósito: a fila de provedores e o orçamento de 6.000
+ * tokens por minuto. Os dois existem para caber na cota compartilhada — aqui
+ * a conta é da pessoa, e o teto é o dela.
+ */
+
+'use strict';
+
+const cerebro = require('./cerebro.json');
+const entrada = require('./entrada.js');
+const provedor = require('./provedor.js');
+const catalogo = require('../../skill/catalogo.js');
+const chamadaTorta = require('../../chamada-torta');
+
+// A conversa pode ocupar isto, em tokens, além do prompt e das ferramentas.
+// Folgado: os modelos de hoje têm 128 mil ou mais de contexto.
+const TETO_CONVERSA = Number(process.env.PRIMOCODE_TETO_LOCAL || 60000);
+const SAIDA_MAXIMA = 8192;
+const ESFORCO_PESQUISA = ['high', 'xhigh', 'max', 'ultracode'];
+
+/* ── AS FERRAMENTAS QUE ESTE CLIENTE EXECUTA ─────────────────────────────
+ * O servidor ainda oferece o Estúdio antigo (studio_*), que este cliente não
+ * executa mais; e o cliente tem o Estúdio novo (estudio_*, planejar_producao),
+ * que o servidor não conhece. Local, a lista certa é a do CLIENTE: o schema
+ * vem do servidor quando existe lá, e do catálogo quando só existe aqui. */
+function ferramentasDoCliente() {
+    const doServidor = new Map(cerebro.TOOLS.map((t) => [t.function.name, t]));
+    const lista = [];
+    for (const grupo of catalogo.GRUPOS) {
+        for (const item of grupo.itens) {
+            if (doServidor.has(item.tool)) { lista.push(doServidor.get(item.tool)); continue; }
+            lista.push({ type: 'function', function: {
+                name: item.tool,
+                description: `${item.faz}. Argumentos: ${item.args || 'nenhum'}`.slice(0, 1800),
+                parameters: { type: 'object', properties: {}, additionalProperties: true },
+            } });
+        }
+    }
+    if (!lista.some((t) => t.function.name === 'finish') && doServidor.has('finish')) lista.push(doServidor.get('finish'));
+    return lista;
+}
+let FERRAMENTAS = null;
+let FERRAMENTAS_SUB = null;
+function ferramentas(subagent) {
+    if (!FERRAMENTAS) {
+        FERRAMENTAS = ferramentasDoCliente();
+        FERRAMENTAS_SUB = FERRAMENTAS.filter((t) => !['spawn_agent', 'construir_app'].includes(t.function.name));
+    }
+    return subagent ? FERRAMENTAS_SUB : FERRAMENTAS;
+}
+
+/** O erro da API, no formato que o loop já sabe tratar (429 espera, 401 avisa). */
+async function erroHttp(r, p) {
+    let msg = '';
+    try {
+        const corpo = await r.text();
+        try {
+            const j = JSON.parse(corpo);
+            const e = Array.isArray(j) ? j[0] && j[0].error : j.error;
+            msg = (e && (e.message || e.status)) || j.message || corpo;
+        } catch { msg = corpo; }
+    } catch { /* sem corpo */ }
+    const quem = p ? p.nome : 'o provedor';
+    if (r.status === 401 || r.status === 403) {
+        return new Error(`${r.status} ${quem} recusou a chave. Rode /api para colar outra, ou /api off para voltar ao servidor.`);
+    }
+    const espera = r.headers && r.headers.get && r.headers.get('retry-after');
+    return new Error(`${r.status} ${quem}: ${String(msg).slice(0, 300)}${espera ? ` Please try again in ${espera}s.` : ''}`);
+}
+
+function cabecalhos(p) {
+    const h = { 'Content-Type': 'application/json', Authorization: `Bearer ${p.chave}` };
+    if (p.id === 'openrouter') { h['HTTP-Referer'] = 'https://github.com/parisgroup-ai/primocode'; h['X-Title'] = 'PrimoCode'; }
+    return h;
+}
+
+/** Uma chamada inteira, sem stream (resumo, plano). */
+async function completar(messages, { maxTokens = 600, temperatura = 0.2 } = {}) {
+    const p = provedor.atual();
+    const r = await fetch(`${p.base}/chat/completions`, {
+        method: 'POST',
+        headers: cabecalhos(p),
+        body: JSON.stringify({ model: p.modelo, messages, temperature: temperatura, max_tokens: maxTokens }),
+        signal: AbortSignal.timeout(90000),
+    });
+    if (!r.ok) throw await erroHttp(r, p);
+    const j = await r.json();
+    return String((j.choices && j.choices[0] && j.choices[0].message && j.choices[0].message.content) || '').trim();
+}
+
+/**
+ * Lê o stream SSE do /chat/completions. Chama `aoPedaco(delta, fim)` a cada
+ * pedaço. Resolve quando acaba ou quando `sinal` corta.
+ */
+async function lerStream(corpo, { sinal, aoPedaco }) {
+    const p = provedor.atual();
+    let r;
+    try {
+        r = await fetch(`${p.base}/chat/completions`, {
+            method: 'POST', headers: cabecalhos(p), body: JSON.stringify({ ...corpo, model: p.modelo, stream: true }), signal: sinal,
+        });
+    } catch (e) {
+        if (sinal && sinal.aborted) return;
+        throw new Error(`ECONNRESET não consegui falar com ${p.nome}: ${e.message}`);
+    }
+    if (!r.ok) throw await erroHttp(r, p);
+    const decod = new TextDecoder();
+    let buffer = '';
+    try {
+        for await (const pedaco of r.body) {
+            buffer += decod.decode(pedaco, { stream: true });
+            const linhas = buffer.split('\n');
+            buffer = linhas.pop();
+            for (const linha of linhas) {
+                const l = linha.trim();
+                if (!l.startsWith('data:')) continue;
+                const dado = l.slice(5).trim();
+                if (dado === '[DONE]') return;
+                let j;
+                try { j = JSON.parse(dado); } catch { continue; }
+                if (j.error) throw new Error(`${j.error.code || 400} ${j.error.message || JSON.stringify(j.error)}`);
+                const escolha = j.choices && j.choices[0];
+                if (escolha) aoPedaco(escolha.delta || {}, escolha.finish_reason);
+            }
+        }
+    } catch (e) {
+        if (sinal && sinal.aborted) return;
+        throw e;
+    }
+}
+
+/** Junta os pedaços de tool_call. Gemini às vezes manda sem `index` e sem `id`. */
+function juntarChamadas(acumuladas, pedacos) {
+    for (const tc of pedacos || []) {
+        let idx;
+        if (Number.isInteger(tc.index)) idx = tc.index;
+        else if (tc.id) {
+            idx = acumuladas.findIndex((a) => a && a.id === tc.id);
+            if (idx < 0) idx = acumuladas.length;             // id novo: chamada nova
+        } else idx = Math.max(0, acumuladas.length - 1);     // sem nada: continua a última
+        if (!acumuladas[idx]) acumuladas[idx] = { id: tc.id || '', name: '', arguments: '' };
+        const alvo = acumuladas[idx];
+        if (tc.id) alvo.id = tc.id;
+        if (tc.function && tc.function.name) alvo.name = tc.function.name;
+        if (tc.function && tc.function.arguments) {
+            const a = tc.function.arguments;
+            alvo.arguments += typeof a === 'string' ? a : JSON.stringify(a);
+        }
+    }
+    return acumuladas;
+}
+
+/* ── /api/act/stream ─────────────────────────────────────────────────── */
+async function requestAct(_servidor, body, emit) {
+    const { messages: convo = [], prompt, history, effort, projectDir, projectName, subagent, sinal } = body || {};
+    const pedido = [...convo].reverse().find((m) => m && m.role === 'user');
+    const texto = String((pedido && pedido.content) || prompt || '');
+    const forcar = effort && ESFORCO_PESQUISA.includes(String(effort)) ? ['pesquisa'] : [];
+
+    // Todas, sempre: o recorte por assunto do servidor existe para caber em
+    // 6.000 tokens por minuto, e ainda não conhece o Estúdio novo (estudio_*)
+    // — com ele, um pedido de vídeo chegaria sem a ferramenta de vídeo.
+    const tools = ferramentas(subagent);
+    const sistema = subagent
+        ? cerebro.SYSTEM_SUB
+        : entrada.montarPrompt(cerebro.SYSTEM_NUCLEO, cerebro.SECOES, texto, { forcar, jaAprendeu: entrada.jaAprendeu(convo) });
+    const messages = [{ role: 'system', content: sistema }];
+    if (projectDir) {
+        messages.push({ role: 'system', content: `[Projeto: ${projectName || 'sem nome'}]\n[Pasta: ${projectDir}]\n`
+            + 'Todo caminho que você passar para write_file/read_file/list_dir é relativo a esta pasta. '
+            + 'Use caminhos relativos simples (ex: "index.html", "src/app.js"). Nunca use caminho absoluto.' });
+    }
+    const conversa = convo.length ? convo : [...(history || []), { role: 'user', content: String(prompt || '') }];
+    messages.push(...entrada.caberNoTeto(conversa.filter((m) => m && m.role), TETO_CONVERSA).messages);
+
+    let texto_ = '';
+    const chamadas = [];
+    await lerStream({ messages, tools, tool_choice: 'auto', temperature: 0.1, max_tokens: SAIDA_MAXIMA }, {
+        sinal,
+        aoPedaco: (delta) => {
+            if (delta.tool_calls) juntarChamadas(chamadas, delta.tool_calls);
+            if (delta.content && !chamadas.length) { texto_ += delta.content; emit({ delta: delta.content }); }
+        },
+    });
+    chamadas.forEach((tc, i) => {
+        if (!tc || !tc.name) return;
+        /* JSON quebrado: tenta recuperar; se não der, o act.js devolve o erro
+           (com os argumentos crus) ao modelo — ver lib/chamada-torta.js. */
+        const rec = chamadaTorta.recuperar(tc.arguments);
+        const args = rec.ok ? rec.args : chamadaTorta.marcar(tc.arguments);
+        emit({ tool_call: { id: tc.id || `local_${Date.now()}_${i}`, name: tc.name, arguments: args } });
+    });
+    if (texto_) emit({ assistant_message: { content: texto_ } });
+    emit({ done: true });
+}
+
+/* ── /api/chat/stream ────────────────────────────────────────────────── */
+async function requestChat(_servidor, body, emit) {
+    const { messages, prompt, history, sinal } = body || {};
+    const turnos = Array.isArray(messages) ? messages
+        : [...(Array.isArray(history) ? history : []), ...(prompt ? [{ role: 'user', content: prompt }] : [])];
+    await lerStream({
+        messages: [{ role: 'system', content: cerebro.SYSTEM_CHAT }, ...turnos.filter((m) => m && m.role)],
+        temperature: 0.4, max_tokens: 1200,
+    }, { sinal, aoPedaco: (delta) => { if (delta.content) emit({ delta: delta.content }); } });
+    emit({ done: true });
+}
+
+/* ── /api/resumir ────────────────────────────────────────────────────── */
+async function requestResumo(_servidor, { resumo, mensagens } = {}) {
+    const novas = Array.isArray(mensagens) ? mensagens.filter((m) => m && m.role) : [];
+    if (!novas.length) return { resumo: String(resumo || '') };
+    const virarTexto = (m) => {
+        const quem = m.role === 'user' ? 'USUÁRIO' : m.role === 'assistant' ? 'AGENTE' : 'FERRAMENTA';
+        const conteudo = typeof m.content === 'string' ? m.content : JSON.stringify(m.content || '');
+        return `${quem}: ${conteudo.slice(0, 1200)}`;
+    };
+    const corpo = (resumo ? `RESUMO ANTERIOR:\n${resumo}\n\n` : '') + `MENSAGENS NOVAS:\n${novas.map(virarTexto).join('\n')}`;
+    try {
+        const limpo = await completar([{ role: 'system', content: cerebro.SYSTEM_RESUMO }, { role: 'user', content: corpo }], { maxTokens: 600 });
+        return { resumo: limpo || String(resumo || '') };
+    } catch (e) {
+        return { resumo: String(resumo || ''), erro: e.message };
+    }
+}
+
+/** Os passos do plano, tolerando cerca de markdown. Mesma regra do servidor. */
+function lerPassos(texto) {
+    const bruto = String(texto || '').trim().replace(/^```(?:json)?\s*/i, '').replace(/```\s*$/i, '');
+    const abre = bruto.indexOf('{');
+    const fecha = bruto.lastIndexOf('}');
+    if (abre === -1 || fecha <= abre) return null;
+    let j;
+    try { j = JSON.parse(bruto.slice(abre, fecha + 1)); } catch { return null; }
+    const lista = Array.isArray(j && j.passos) ? j.passos : null;
+    if (!lista || !lista.length) return null;
+    const limpos = lista
+        .map((p) => ({ titulo: String((p && p.titulo) || 'passo').slice(0, 60), pedido: String((p && p.pedido) || '').trim() }))
+        .filter((p) => p.pedido.length > 10)
+        .slice(0, 3);
+    return limpos.length ? limpos : null;
+}
+
+/* ── /api/plano ──────────────────────────────────────────────────────── */
+async function requestPlano(_servidor, { prompt } = {}) {
+    const cru = String(prompt || '').trim();
+    const passoUnico = [{ titulo: 'tarefa', pedido: cru }];
+    if (cru.length < 25) return { passos: passoUnico, dividiu: false };
+    try {
+        const passos = lerPassos(await completar(
+            [{ role: 'system', content: cerebro.SYSTEM_PLANO }, { role: 'user', content: cru }],
+            { maxTokens: 800, temperatura: 0.1 })) || passoUnico;
+        return { passos, dividiu: passos.length > 1 };
+    } catch {
+        return { passos: passoUnico, dividiu: false };
+    }
+}
+
+module.exports = { requestAct, requestChat, requestResumo, requestPlano, juntarChamadas, lerPassos, ferramentas, ativo: () => !!provedor.atual() };