primocode 9.8.0-beta.0 → 9.8.0-beta.10

package/comandos/explicar.md

@@ -0,0 +1,14 @@
+---
+descricao: explica este projeto (ou um arquivo) para quem não programa
+---
+Me explique como se eu nunca tivesse programado: $ARGUMENTOS
+
+Se eu não disse o que explicar, explique o projeto inteiro desta pasta. Leia os arquivos antes de falar, não chute.
+
+Responda nesta ordem, em frases curtas:
+1. o que isto faz, em uma frase;
+2. as partes principais e o papel de cada uma (use comparações do dia a dia);
+3. como eu rodo e vejo funcionando;
+4. onde eu mexo para mudar o que é mais provável que eu queira mudar.
+
+Sem jargão. Se uma palavra técnica for inevitável, explique ela na hora.

package/comandos/publicar.md

@@ -0,0 +1,10 @@
+---
+descricao: guia passo a passo para colocar o projeto no ar, com link público
+---
+Quero colocar este projeto no ar, com um link que eu possa mandar para as pessoas. $ARGUMENTOS
+
+Primeiro olhe o projeto e me diga, em uma frase, que tipo de coisa ele é (site estático, app com servidor, etc.). Depois recomende UM caminho gratuito que sirva para ele (por exemplo GitHub Pages, Vercel, Netlify ou Railway) e diga por que esse.
+
+Me guie um passo por vez, esperando eu confirmar antes do próximo. Faça você o que der para fazer pelo terminal; o que só eu posso fazer (criar conta, clicar num botão no site) me diga exatamente onde clicar.
+
+Nunca coloque senha, chave ou arquivo .env no que for publicado. Se achar um, pare e me avise.

package/comandos/revisar.md

@@ -0,0 +1,13 @@
+---
+descricao: revisa o projeto (ou o que mudou) atrás de bugs, e explica sem jargão
+---
+Revise este projeto procurando bugs e coisas que vão quebrar. Se for um repositório git com mudanças ainda não salvas, comece pelo que mudou (git status e git diff); se não, olhe os arquivos principais.
+
+Foco, se eu disser: $ARGUMENTOS
+
+Para cada problema que achar, diga em linguagem simples, como para quem não programa:
+1. o que está errado e onde (arquivo e linha);
+2. o que acontece com quem usa, se ninguém consertar;
+3. como consertar.
+
+Ordene do mais grave para o menos grave. Não conserte nada ainda: só mostre a lista e pergunte quais eu quero que você arrume.

package/lib/act.js

@@ -21,7 +21,11 @@ const repeticao = require('./repeticao');
 const diff = require('./diff');
 const registro = require('./registro');
 const permissao = require('./permissao');
+const perigo = require('./perigo');
 const skills = require('./skills');
+const checkpoint = require('./checkpoint');
+const tempos = require('./tempos');
+const preLeitura = require('./pre-leitura');
 
 // 40, não 15: com o freio de repetição (repeticao.js) e o de rodada parada,
 // volta a mais não é volta em círculo — é trabalho. Quinze acabavam no meio
@@ -33,6 +37,8 @@ const MAX_EMPURROES = 3;
 // Voltas seguidas sem executar nada antes de desistir.
 const MAX_RODADAS_PARADAS = 3;
 const MAX_PROFUNDIDADE = 2; // principal + 1 nível de subagente
+// As leituras que, repetidas sem mudança no meio, devolvem o guardado.
+const RELEITURA = new Set(['read_file', 'list_dir']);
 
 // ── Interrupção (Esc Esc) ─────────────────────────────────────────────────
 // O usuário aperta Esc duas vezes e o agente PARA — entre uma rodada e outra
@@ -132,6 +138,9 @@ function limparParaOModelo(result) {
 
 function logResult(kind, result, profundidade) {
     const p = fala.resultado(profundidade);
+    // A linha da janela (lib/app.js) fecha aqui: o mesmo resultado que o
+    // terminal desenha embaixo, resumido. Ver o canal em lib/fala.js.
+    fala.avisar('resultado', fala.resumoDoResultado(kind, result));
     if (!result) return;
     // Uma tool que falhou é informação para o AGENTE, que vai consertar na
     // volta seguinte — não é o erro do usuário. Âmbar, uma linha, sem o
@@ -380,6 +389,7 @@ async function pausar(ms, subagent) {
     const sp = subagent ? null : new Spinner(PENSANDO).start();
     await new Promise((r) => setTimeout(r, ms));
     if (sp) sp.stop();
+    tempos.somar('espera de cota/rede', ms);
 }
 
 /**
@@ -449,10 +459,10 @@ function motivoDaParada({ voltas, voltasEmFalso, falhasPendentes, travou }) {
 const PULAR_NO_MAPA = new Set(['node_modules', '.git', 'dist', 'build', '.next', '.nuxt', 'out',
     '.cache', 'coverage', '__pycache__', '.venv', 'venv', '.turbo', '.vercel', '.idea', '.vscode']);
 
-function mapaDoProjeto(dir, limite = 80) {
+function arquivosDoProjeto(dir, limite = 80) {
     const path = require('path');
     const fs = require('fs');
-    if (!dir || path.resolve(dir) === path.resolve(cfg.ROOT_DIR)) return '';
+    if (!dir || path.resolve(dir) === path.resolve(cfg.ROOT_DIR)) return [];
     const achados = [];
     const andar = (atual, fundo) => {
         if (fundo > 4 || achados.length >= limite) return;
@@ -468,19 +478,33 @@ function mapaDoProjeto(dir, limite = 80) {
         }
     };
     andar(dir, 0);
+    return achados;
+}
+
+function mapaDoProjeto(dir, limite = 80, achados = arquivosDoProjeto(dir, limite)) {
     if (!achados.length) return '';
     const mais = achados.length >= limite ? `\n… (mais arquivos — use glob para achar)` : '';
     return `Arquivos que JÁ existem neste projeto (edite-os em vez de recriar):\n${achados.join('\n')}${mais}`;
 }
 
-function buildMemoryContext(projectDir, projectName) {
+/* `pedido` é opcional: com ele, o arquivo citado no pedido é o primeiro a
+   entrar já lido (ver lib/pre-leitura.js). */
+function buildMemoryContext(projectDir, projectName, pedido = '') {
     const parts = [];
+    // As instruções vêm primeiro: são regra de quem manda no projeto, e a
+    // memória é o que o agente anotou. Entram aqui (e não no bin) para valer
+    // igual no terminal, no modo voz e em cada passo de um plano.
+    const instrucoes = require('./mencoes.js').instrucoesDoProjeto(projectDir);
+    if (instrucoes) parts.push(instrucoes);
     const geral = cfg.readGeneralMemory();
     if (geral.trim()) parts.push(`[memory-geral.md]\n${geral}`);
     const projeto = cfg.readProjectMemory(projectDir);
     if (projeto.trim()) parts.push(`[${projectName || 'projeto'}/memory.md]\n${projeto}`);
-    const mapa = mapaDoProjeto(projectDir);
-    if (mapa) parts.push(`[${projectName || 'projeto'}/arquivos]\n${mapa}`);
+    const arquivos = arquivosDoProjeto(projectDir);
+    const mapa = mapaDoProjeto(projectDir, 80, arquivos);
+    if (mapa) parts.push(`[${projectName || 'projeto'}/arquivos]\n${mapa}\n\n${preLeitura.JUNTAR_LEITURAS}`);
+    const lidos = preLeitura.bloco(preLeitura.escolher(projectDir, arquivos, pedido));
+    if (lidos) parts.push(lidos);
     return parts.join('\n\n');
 }
 
@@ -493,6 +517,10 @@ async function runAct(userPrompt, opts) {
            quem sabe lembrar é a SESSÃO — um subagente não pode começar do
            zero e pedir de novo o que já foi autorizado. */
         autorizar = null, controle = null,
+        /* O modo do /permissoes (auto · perguntar · livre). Vem da config pela
+           CLI e desce para os subagentes pelo ctx: eles recusam o perigoso,
+           mas só sabem que é "livre" se alguém disser. */
+        permissoes = 'auto',
         /* O cliente HTTP, injetável. NÃO é mais um comutador de motor — o
            PrimoCode tem um motor só, o do servidor, e não há provedor para o
            usuário escolher. Continua um parâmetro porque é por aqui que o
@@ -509,6 +537,11 @@ async function runAct(userPrompt, opts) {
         /* Quem abre a página para conferir antes do "pronto". Injetável pelo
            mesmo motivo do `motor`: o teste mede a regra sem abrir um Chrome. */
         medirPagina = (dir) => require('./pipeline.js').medirNoNavegador(dir),
+        /* Quem LIGA o navegador escondido antes da hora. Injetável pelo mesmo
+           motivo do `medirPagina` — e só vale junto com o padrão dele: um
+           teste que troca o medidor não pode subir um Chrome de verdade. */
+        aquecerPagina = opts && opts.medirPagina ? null
+            : () => require('./browser.js').aquecerRevisor(),
     } = opts || {};
 
     // A pasta de projeto só nasce quando o agente for mesmo MEXER EM ARQUIVO.
@@ -539,6 +572,7 @@ async function runAct(userPrompt, opts) {
     let mexeuNaPagina = false;       // mexeu desde a última conferência?
     let conferencias = 0;            // até duas: entregar, e conferir o conserto
     let avisoDaPagina = '';          // o que ainda estava quebrado na última
+    let msConferindo = 0;            // para o PRIMOCODE_TEMPOS separar as fases
     /* Abre a página e devolve o relato quando é para VOLTAR (achou problema e
        ainda cabe uma volta); null quando é para entregar. O que ficar
        quebrado na última conferência fica em `avisoDaPagina`, e a entrega sai
@@ -549,10 +583,13 @@ async function runAct(userPrompt, opts) {
         conferencias++;
         mexeuNaPagina = false;
         let medida = null;
+        const t = Date.now();
         try {
             fala.pensamento('abrindo a página para conferir antes de entregar', profundidade);
             medida = await medirPagina(pastaAtual);
         } catch { medida = null; }
+        msConferindo += Date.now() - t;
+        tempos.somar('conferir página', Date.now() - t);
         if (!medida || !medida.testou) return null;
         avisoDaPagina = medida.limpo ? ''
             : String(medida.relato || '').split('\n').filter((l) => /·|BRANCO/.test(l)).slice(0, 3).join(' ');
@@ -563,6 +600,8 @@ async function runAct(userPrompt, opts) {
         ? `${texto}\n\nAtenção: abri a página e ela ainda tem problema — ${avisoDaPagina.trim()}` : texto);
     // Quem já foi chamado, e quantas vezes. Ver lib/repeticao.js.
     const jaChamado = repeticao.novo();
+    // O que read_file/list_dir devolveram, pela chave da época (repeticao.js).
+    const leiturasGuardadas = new Map();
     /* O livro deste pedido: arquivos, comandos, links, testes e falhas. Sai
        no fim como balanço (ver lib/registro.js). O subagente tem o seu, que
        não se mistura com o do principal — mas o que ele fez também precisa
@@ -612,7 +651,7 @@ async function runAct(userPrompt, opts) {
 
     const messages = [];
     if (!subagent) {
-        const memory = buildMemoryContext(projectDir, projectName);
+        const memory = buildMemoryContext(projectDir, projectName, userPrompt);
         if (memory) messages.push({ role: 'system', content: `Memória persistente:\n\n${memory}` });
         for (const m of (history || []).slice(-20)) {
             if (m && m.role && m.content) messages.push({ role: m.role, content: m.content });
@@ -724,6 +763,7 @@ async function runAct(userPrompt, opts) {
         let fluxo = null;
 
         emVoo = new AbortController();
+        const tRodada = Date.now();
         try {
             await motor.requestAct(server, { messages: compactar(messages), model, effort, token, projectDir: pastaAtual, projectName, subagent, sinal: emVoo.signal }, (evt) => {
                 if (evt.erro) { streamError = evt.erro; return; }
@@ -770,6 +810,7 @@ async function runAct(userPrompt, opts) {
         }
         sp.stop();
         emVoo = null;
+        tempos.somar(subagent ? 'rodada do subagente' : 'rodada do modelo', Date.now() - tRodada);
         if (PARAR) { if (fluxo) fluxo.fechar(); break; }
 
         // Chamada de função malformada: o modelo errou a SINTAXE da chamada,
@@ -946,6 +987,8 @@ async function runAct(userPrompt, opts) {
 
         let finished = null;
         let algoRodou = false;
+        const tTools = Date.now();
+        const conferindoAntes = msConferindo;
 
         // ORQUESTRAÇÃO: subagentes da MESMA rodada rodam juntos. O modelo que
         // pede "3 agentes, um por arquivo" esperava paralelismo e recebia uma
@@ -962,7 +1005,7 @@ async function runAct(userPrompt, opts) {
             fala.paralelo(juntos.length, profundidade);
             const rs = await Promise.all(juntos.map((tc) =>
                 runSubagent(tc.arguments || {}, {
-                    server, model, token, projectDir: pastaAtual, projectName, profundidade, motor,
+                    server, model, token, projectDir: pastaAtual, projectName, profundidade, motor, permissoes,
                 }).catch((e) => `Subagente falhou: ${e && e.message}`)));
             juntos.forEach((tc, i) => resultadosSpawn.set(tc.id, rs[i]));
         }
@@ -1005,7 +1048,7 @@ async function runAct(userPrompt, opts) {
                 const r = resultadosSpawn.has(tc.id)
                     ? resultadosSpawn.get(tc.id)
                     : await runSubagent(tc.arguments || {}, {
-                        server, model, token, projectDir: pastaAtual, projectName, profundidade, motor,
+                        server, model, token, projectDir: pastaAtual, projectName, profundidade, motor, permissoes,
                     });
                 repeticao.executou(jaChamado, tc.name, tc.arguments);
                 messages.push({ role: 'tool', tool_call_id: tc.id, content: r });
@@ -1018,7 +1061,7 @@ async function runAct(userPrompt, opts) {
                 algoRodou = true;
                 fala.acao(tc.name, tc.arguments, profundidade);
                 const r = await rodarDiretor(tc.arguments || {}, {
-                    server, model, token, projectDir: pastaAtual, projectName, profundidade, motor,
+                    server, model, token, projectDir: pastaAtual, projectName, profundidade, motor, permissoes,
                 });
                 logResult(tc.name, r, profundidade);
                 messages.push({ role: 'tool', tool_call_id: tc.id, content: JSON.stringify(r) });
@@ -1036,7 +1079,7 @@ async function runAct(userPrompt, opts) {
                 garantirPasta();
                 fala.acao(tc.name, tc.arguments, profundidade);
                 const r = await rodarPipeline(tc.arguments || {}, {
-                    server, model, token, projectDir: pastaAtual, projectName, profundidade, motor, livro, autorizar, controle: portaoControle,
+                    server, model, token, projectDir: pastaAtual, projectName, profundidade, motor, permissoes, livro, autorizar, controle: portaoControle,
                 });
                 logResult(tc.name, r, profundidade);
                 repeticao.executou(jaChamado, tc.name, tc.arguments);
@@ -1053,7 +1096,18 @@ async function runAct(userPrompt, opts) {
             const eco = repeticao.ver(jaChamado, tc.name, tc.arguments);
             if (eco.repetida) {
                 voltasEmFalso++;
-                messages.push({ role: 'tool', tool_call_id: tc.id, content: eco.aviso });
+                /* RELER SEM MUDANÇA devolve o que já foi lido, uma vez.
+                   O aviso seco ("o resultado está na conversa acima") mentia
+                   depois do `compactar`: a leitura velha já tinha virado 300
+                   caracteres, e o modelo gastava OUTRA ida ao servidor para
+                   achar o arquivo por outro caminho (um `cat`, um grep). Na
+                   segunda vez vai o conteúdo guardado — ler de novo sem nada
+                   mudar dá o mesmo texto, então não há o que executar. Da
+                   terceira em diante é laço, e o freio segue como era. */
+                const guardado = eco.vezes === 2 && leiturasGuardadas.get(eco.chave);
+                messages.push({ role: 'tool', tool_call_id: tc.id, content: guardado
+                    ? `(sem mudança desde a última leitura — é o mesmo conteúdo; não precisa ler de novo)\n${guardado}`
+                    : eco.aviso });
                 continue;
             }
 
@@ -1080,6 +1134,7 @@ async function runAct(userPrompt, opts) {
                 const porta = await permissao.pedir(portaoControle, tc.name, tc.arguments, autorizar);
                 if (!porta.ok) {
                     fala.acao(tc.name, tc.arguments, profundidade);
+                    fala.avisar('resultado', { nome: tc.name, ok: false, resumo: 'não autorizado' });
                     console.log(fala.resultado(profundidade) + c.warn('não autorizado'));
                     registro.anotar(livro, tc.name, tc.arguments, { ok: false, error: porta.error });
                     messages.push({ role: 'tool', tool_call_id: tc.id, content: JSON.stringify({ ok: false, error: porta.error }) });
@@ -1087,12 +1142,40 @@ async function runAct(userPrompt, opts) {
                 }
             }
 
+            /* O PORTÃO do que não tem volta (lib/perigo.js). No mesmo lugar do
+               portão do desktop e pelo mesmo motivo: antes, não depois. A
+               resposta mora no mesmo objeto da sessão — quem lembra é ela. */
+            if (!portaoControle.perigo) portaoControle.perigo = perigo.novo();
+            const risco = await perigo.portao(portaoControle.perigo, {
+                modo: permissoes, nome: tc.name, args: tc.arguments,
+                projectDir: pastaAtual, subagent, perguntar: autorizar,
+            });
+            if (!risco.ok) {
+                fala.acao(tc.name, tc.arguments, profundidade);
+                fala.avisar('resultado', { nome: tc.name, ok: false, resumo: `não autorizado — ${risco.motivo}` });
+                console.log(fala.resultado(profundidade) + c.warn(`não autorizado — ${risco.motivo}`));
+                registro.anotar(livro, tc.name, tc.arguments, { ok: false, error: risco.error });
+                messages.push({ role: 'tool', tool_call_id: tc.id, content: JSON.stringify({ ok: false, error: risco.error }) });
+                continue;
+            }
+
             algoRodou = true;
             rodouTool = true;
             fala.acao(tc.name, tc.arguments, profundidade);
-            const result = await tools.execute(tc.name, tc.arguments, { projectDir: pastaAtual });
+            /* Antes de mexer no arquivo, guarda o original — é o que o /desfazer
+               devolve. Caminho inválido não é problema nosso: a tool recusa. */
+            if (checkpoint.MUDAM_ARQUIVO.has(tc.name)) {
+                try { checkpoint.antesDeMudar(tools.resolveInProject(tc.arguments && tc.arguments.path, pastaAtual), pastaAtual); } catch {}
+            }
+            /* O servidor, o token e o cliente da API vão junto: a legenda do
+               estudio_video transcreve no servidor, e sem eles a ferramenta
+               respondia "a transcrição precisa do servidor". */
+            const result = await tools.execute(tc.name, tc.arguments, { projectDir: pastaAtual, server, token, api });
             logResult(tc.name, result, profundidade);
             repeticao.executou(jaChamado, tc.name, tc.arguments);
+            if (RELEITURA.has(tc.name) && result && result.ok !== false) {
+                leiturasGuardadas.set(eco.chave, summarizeForModel(result));
+            }
             if (tc.name === 'write_todos' && result && Array.isArray(result.todos)) todosDaTarefa = result.todos;
             // Além de narrar, ANOTA: no fim do pedido sai o balanço do que
             // nasceu, mudou, rodou e falhou. Narrar sozinho não basta — numa
@@ -1101,6 +1184,19 @@ async function runAct(userPrompt, opts) {
             if (result && result.ok !== false && catalogo.criaProjeto(tc.name, tc.arguments)
                 && /\.(html?|css|m?jsx?|tsx?|vue|svelte)$/i.test(String((tc.arguments && tc.arguments.path) || ''))) {
                 mexeuNaPagina = true;
+                /* O NAVEGADOR ESCONDIDO SOBE AGORA, e não no `finish`.
+                   A conferência só roda quando o agente diz "pronto", e até
+                   lá ainda há pelo menos uma rodada do modelo. Subir o Chrome
+                   ali, em paralelo com ela, tira do "pronto" o tempo de ligar
+                   o navegador e de fazer a PRIMEIRA navegação dele, que é a
+                   parte cara (ver `aquecerRevisor` em lib/browser.js). Medido
+                   em 24/09: a conferência num Chrome recém-aberto levava de
+                   2,1 a 4,6s; aquecido antes, 1,24s — que é o assentar de
+                   1,2s, e nada mais. Sem `await` e sem erro: se não subir, a
+                   conferência tenta de novo e diz o que houve. */
+                if (aquecerPagina && !subagent && conferencias < 2) {
+                    try { Promise.resolve(aquecerPagina()).catch(() => {}); } catch { /* segue */ }
+                }
             }
 
             // Uma escrita bem-sucedida limpa a dívida — mas só a do MESMO
@@ -1142,6 +1238,9 @@ async function runAct(userPrompt, opts) {
             messages.push({ role: 'tool', tool_call_id: tc.id, content: summarizeForModel(result) });
         }
 
+        // A conferência da página tem linha própria: aqui fica só o resto.
+        tempos.somar('ferramentas', Date.now() - tTools - (msConferindo - conferindoAntes));
+
         // Uma volta inteira sem executar nada é o modelo preso. Insistir custa
         // um pedido ao servidor por volta, e as 15 voltas saíam caras para
         // terminar no mesmo lugar — melhor parar e devolver a vez ao usuário.
@@ -1232,7 +1331,7 @@ async function runAct(userPrompt, opts) {
 }
 
 async function runSubagent(args, ctx) {
-    const { server, model, token, projectDir, projectName, profundidade, motor } = ctx;
+    const { server, model, token, projectDir, projectName, profundidade, motor, permissoes } = ctx;
     const descricao = args.description || 'sub-tarefa';
 
     if (profundidade + 1 >= MAX_PROFUNDIDADE) {
@@ -1251,6 +1350,7 @@ async function runSubagent(args, ctx) {
         profundidade: profundidade + 1,
         subagent: true,
         motor,
+        permissoes,
         autorizar: ctx.autorizar,
         controle: ctx.controle,   // o mesmo objeto: a resposta vale para todos
     });
@@ -1294,7 +1394,7 @@ async function runSubagent(args, ctx) {
  * inventar — e inventar é onde ele erra.
  */
 async function rodarDiretor(args, ctx) {
-    const { server, model, token, projectDir, projectName, profundidade, motor } = ctx;
+    const { server, model, token, projectDir, projectName, profundidade, motor, permissoes } = ctx;
     if (profundidade > 0) {
         return { ok: false, error: 'Recusado: o diretor não roda dentro de um subagente. '
             + 'Produza com o plano que você já recebeu.' };
@@ -1305,7 +1405,7 @@ async function rodarDiretor(args, ctx) {
         fala.agente('Diretor', rotulo, profundidade);
         const r = await runAct(prompt, {
             server, model, token, projectDir, projectName,
-            history: [], profundidade: profundidade + 1, subagent: true, motor,
+            history: [], profundidade: profundidade + 1, subagent: true, motor, permissoes,
         });
         return (r && r.assistantMessage && r.assistantMessage.content) || '';
     };
@@ -1338,7 +1438,7 @@ async function rodarDiretor(args, ctx) {
 }
 
 async function rodarPipeline(args, ctx) {
-    const { server, model, token, projectDir, projectName, profundidade, motor } = ctx;
+    const { server, model, token, projectDir, projectName, profundidade, motor, permissoes } = ctx;
     if (profundidade > 0) {
         return { ok: false, error: 'Recusado: o pipeline não roda dentro de um subagente — '
             + 'os papéis dele já são subagentes. Faça a parte que te cabe.' };
@@ -1361,7 +1461,7 @@ async function rodarPipeline(args, ctx) {
         fala.agente('Agente', rotulo, profundidade);
         const r = await runAct(prompt, {
             server, model, token, projectDir: pasta, projectName,
-            history: [], profundidade: profundidade + 1, subagent: true, motor,
+            history: [], profundidade: profundidade + 1, subagent: true, motor, permissoes,
         });
         return (r && r.assistantMessage && r.assistantMessage.content) || '';
     };
@@ -1376,5 +1476,5 @@ async function rodarPipeline(args, ctx) {
     });
 }
 
-module.exports = { runAct, interromper, compactar, motivoDaParada, pareceParadaNoMeio, ehTetoDeToken, ehTransitorio, esperaDoErro,
+module.exports = { runAct, buildMemoryContext, interromper, compactar, motivoDaParada, pareceParadaNoMeio, ehTetoDeToken, ehTransitorio, esperaDoErro,
     anotacaoDoQueJaFoi, encolherParaContinuar, MAX_ITERATIONS };

package/lib/api.js

@@ -201,14 +201,31 @@ function requestStream(serverUrl, endpoint, payload, onEvent, token, sinal) {
     });
 }
 
+/* Com um provedor configurado (/api), estas quatro rotas rodam AQUI,
+   com a chave da pessoa, em vez de ir ao servidor — ver lib/local/motor.js.
+   O resto (login, transcrição, conectores) continua no servidor. */
+function local() {
+    try {
+        const atual = require('./local/provedor.js').atual();
+        if (!atual) return null;
+        // Claude Code e Codex: a ferramenta de fora é o cérebro.
+        if (atual.cli) return require('./local/motor-cli.js').criar(atual.id);
+        return require('./local/motor.js');
+    } catch { return null; }
+}
+
 // Agente autônomo. `payload` carrega a conversa completa (messages).
 function requestAct(serverUrl, payload, onEvent) {
+    const m = local();
+    if (m) return m.requestAct(serverUrl, payload, onEvent);
     const { token, sinal, ...body } = payload;
     return requestStream(serverUrl, '/api/act/stream', body, onEvent, token, sinal);
 }
 
 // Chat puro.
 function requestChat(serverUrl, payload, onEvent) {
+    const m = local();
+    if (m) return m.requestChat(serverUrl, payload, onEvent);
     const { token, sinal, ...body } = payload;
     return requestStream(serverUrl, '/api/chat/stream', body, onEvent, token, sinal);
 }
@@ -216,6 +233,8 @@ function requestChat(serverUrl, payload, onEvent) {
 // Resumo incremental da conversa. Vai e volta pequeno: manda o resumo de
 // antes + o que é novo, recebe o resumo atualizado.
 function requestResumo(serverUrl, payload) {
+    const m = local();
+    if (m) return m.requestResumo(serverUrl, payload);
     const { token, ...body } = payload;
     return request(serverUrl, '/api/resumir', body, token);
 }
@@ -236,6 +255,8 @@ function requestRefino(serverUrl, payload) {
 
 // O plano: a tarefa grande dividida em passos, para uma chamada por pedaço.
 function requestPlano(serverUrl, payload) {
+    const m = local();
+    if (m) return m.requestPlano(serverUrl, payload);
     const { token, ...body } = payload;
     return request(serverUrl, '/api/plano', body, token);
 }