primocode 10.19.0 → 11.0.0

package/bin/primocode.js

@@ -193,12 +193,16 @@ const SLASH_COMANDOS = [
     ['/howto', 'escreve no PRIMO.md como abrir e testar este projeto'],
     ['/save', 'guarda o projeto no GitHub (privado) e mostra o link · também vale /guardar'],
     ['/secrets', 'as chaves que o projeto usa (só os nomes) · /secrets add NOME guarda uma, escondida, no .env · também vale /segredos'],
+    ['/testar-app', 'sobe o app, abre, clica nos fluxos e conserta os erros (até 2 rodadas)'],
+    ['/pesquisar', 'relatório com fontes: /pesquisar <tema> grava em pesquisas/'],
+    ['/placar', 'qual modelo grátis acerta mais em cada tipo de tarefa, aprendido aqui · /placar zerar apaga'],
     ['/schedule', 'um pedido que roda sozinho: /schedule "toda segunda às 9h" <pedido> · sem nada, lista · /schedule off 1 tira · também vale /agendar'],
     ['/lock', 'arquivos que o agente só pode ler · /lock login.js trava · /lock off login.js solta · sem nada, lista'],
     ['/rule', 'uma regra que o PrimoCode segue sempre, mesmo depois de resumir a conversa'],
     ['/port', 'o app não abre? diz qual porta responde e o endereço certo'],
     ['/map', 'o que tem no projeto, em português, e o que está faltando · /map tree: as pastas'],
     ['/explain', 'o que o último pedido mudou, em até 5 linhas · /explain commit: uma palavra · /explain projeto: o projeto todo'],
+    ['/review', 'revisa o que mudou em duas passadas: acha e depois confere cada achado · /review rápido: uma passada só'],
     ['/plan', 'mostra 3 a 5 passos e só começa quando você aperta Enter (ou muda um passo) · /plan <pedido>'],
     ['/changes', 'o que mudou no projeto, em português (arquivos e linhas)'],
     ['/timeline', 'abre a história do projeto numa página'],
@@ -501,11 +505,9 @@ function barraDeStatus() {
        conselho e vira o que fazer. */
     const direita = [];
     const uso = memoria.usoDoContexto(state.memoria, state.history);
-    if (uso.pct >= 5) {
-        direita.push(uso.pct >= 100 ? c.err(`${uso.pct}% ctx`)
-            : uso.pct >= 70 ? c.warn(`${uso.pct}% ctx`)
-                : c.dim(`${uso.pct}% ctx`));
-    }
+    // Modelo que respondeu · contexto · tokens de hoje (os mesmos do /usage) — lib/statusline.js.
+    const SL = require('../lib/statusline.js');
+    direita.push(...SL.partes({ modelo: SL.modelo(), ctxPct: uso.pct, tokensHoje: SL.tokensDeHoje(), c }));
     direita.push(state.trabalhando && rl && rl.ocupado
         ? c.warn('trabalhando') + c.dim(' · ') + c.white('esc esc') + c.dim(' para')
         : c.white('tab') + c.dim(' modos  ') + c.white('ctrl+p') + c.dim(' comandos'));
@@ -1266,6 +1268,11 @@ async function sendPrompt(userText, { digitado = false } = {}) {
 
 /* Marca no arquivo de hoje o que ESTA conversa já gastou (lib/limite.js): é o que o /usage soma. */
 const IDENTIDADE_DA_SESSAO = `${process.pid}-${Date.now()}`;
+/* Tarefa em segundo plano que acabou sozinha: uma linha na tela (o modelo recebe o aviso na próxima volta). */
+require('../lib/fundo.js').aoTerminar((a) => {
+    if (state.semTerminal) return;
+    process.stdout.write('\n  ' + (a.ok ? c.ok('✔') : c.err('✘')) + ' ' + c.muted(`tarefa ${a.id} terminou (código ${a.codigo}): ${a.comando.slice(0, 60)}`) + '\n');
+});
 function guardarUsoDeHoje() {
     try {
         const { total } = extra.resumoCusto(contadorDaSessao);
@@ -1397,6 +1404,7 @@ async function enviarPedido(userText) {
                 // No pedido único (`primo "…"`) não há ninguém para responder:
                 // sem `autorizar`, o que pede licença é recusado (lib/perigo.js).
                 autorizar: state.semTerminal ? undefined : autorizarControle,
+                escolher: state.semTerminal ? undefined : (q, o, op) => require('../lib/tool/perguntar').escolherNoTerminal(ask, c, q, o, op),
                 // A memória do AGENTS.md só vai se o resumo ainda não a carrega.
                 memoriaDaPasta: !memoria.jaDobrou(state.memoria, plan.dir),
                 mudarPasta: state.semTerminal ? null : mudarPastaPeloAgente,
@@ -1718,9 +1726,10 @@ async function comprimirConversa(forcado = false, { silencioso = false } = {}) {
         if (!memoria.jaDobrou(state.memoria, dir) && !(state.memoria.semente && state.memoria.semente.pasta === dir)) {
             state.memoria = memoria.semear(state.memoria, dir, agentsMd.ler(dir));
         }
+        // O mesmo `resumir` da compactação automática do agente (lib/session/compactacao.js): resumo + arquivos mexidos + to-dos.
         const nova = await memoria.atualizar(state.memoria, conversa, ({ resumo, mensagens }) =>
-            api.requestResumo(state.config.server, { resumo, mensagens, token: state.config.token })
-                .then((r) => r.resumo));
+            require('../lib/session/compactacao.js').resumirComFatos({ resumo, mensagens },
+                (p) => api.requestResumo(state.config.server, { ...p, token: state.config.token }).then((r) => r.resumo)));
         // /clear ou /chats trocaram a conversa enquanto o resumo era feito:
         // o resumo é da conversa velha e não pode voltar por cima da nova.
         if (state.history !== conversa) { sp.stop(); return; }
@@ -2506,6 +2515,7 @@ async function handleSlash(text) {
             const copiaDoBanco = BK.desde(projectDir(), alvo[alvo.length - 1].quando).slice(-1)[0];
             if (copiaDoBanco) console.log(c.muted('    banco  ') + `volta pra cópia de ${hora(copiaDoBanco.criado)} (${copiaDoBanco.arquivos.join(', ')})`);
             if (!(await confirm('Desfazer?'))) { console.log(c.muted('Cancelado.')); break; }
+            try { require('../lib/placar.js').desfez(); } catch { /* placar é conveniência */ }   // desfez logo depois do pedido: conta como perda do modelo
             for (const f of checkpoint.desfazer(projectDir(), n)) {
                 const rotulo = f.acao === 'falhou' ? c.err(`  falhou: ${f.erro}  `) : c.ok(`  ${f.acao}  `);
                 console.log(rotulo + shortPath(f.caminho));
@@ -2690,6 +2700,26 @@ async function handleSlash(text) {
             break;
         }
         /* /explain: sem nada, o último pedido em 5 linhas; com uma palavra, uma linha; "projeto" é o comando de fábrica. */
+        /* /review: duas passadas (lib/review.js) — achar e depois conferir cada achado. /review rápido = o comando de fábrica de uma passada. */
+        case 'review': {
+            if (/^(r[aá]pido|simples)\b/i.test(rest)) {
+                const fabrica = comandosDaPessoa().find((x) => x.nome === 'review');
+                if (fabrica) { await sendPrompt(comandosLib.expandir(fabrica, rest.replace(/^\S+\s*/, ''))); break; }
+            }
+            const R = require('../lib/review.js');
+            const chamar = async (prompt) => {
+                let resposta = '';
+                await api.requestChat(state.config.server, { prompt, history: [], model: state.config.model, token: state.config.token },
+                    (evt) => { if (evt.delta) resposta += evt.delta; });
+                return resposta;
+            };
+            const sp = new Spinner('revisando o que mudou (passada 1: achar)').start();
+            let r;
+            try { r = await R.revisar({ dir: projectDir(), foco: rest, chamar }); } catch (e) { r = { ok: false, erro: String((e && e.message) || e) }; }
+            sp.stop();
+            console.log('\n' + R.formatar(r).split('\n').map((l) => '  ' + l).join('\n') + '\n');
+            break;
+        }
         case 'explain': {
             const E = require('../lib/explicar.js');
             const m = E.modo(rest);
@@ -2795,6 +2825,25 @@ async function handleSlash(text) {
             console.log(c.muted('  /secrets add NOME guarda uma. Isto é uma chave, não mostre pra ninguém.'));
             break;
         }
+        case 'testar-app': {
+            const A = require('../lib/plugin/autoteste.js');
+            const r = await A.testar({ dir: projectDir(), log: (l) => console.log(c.muted('  ' + l)), consertar: (erros, prints) => sendPrompt(A.pedidoDeConserto(erros, prints)) });
+            console.log(r.ok ? c.ok('  O app passou no teste.') : c.warn('  ' + r.erro));
+            break;
+        }
+        /* /placar: qual modelo grátis acerta mais em cada tipo de tarefa, neste computador (lib/placar.js). */
+        case 'placar': {
+            const P = require('../lib/placar.js');
+            if (/^(zerar|limpar|reset)$/i.test(rest.trim())) { P.zerar(); console.log(c.ok('  Placar zerado. Ele começa a aprender de novo.')); break; }
+            console.log(P.texto(P.ler()).split('\n').map((l) => '  ' + l.replace(/^ {2}/, '')).join('\n'));
+            break;
+        }
+        case 'pesquisar': {
+            if (!rest) { console.log(c.muted('  Uso: /pesquisar <tema>')); break; }
+            const r = await require('../lib/plugin/pesquisar.js').pesquisar({ tema: rest, dir: projectDir(), log: (l) => console.log(c.muted('  ' + l)) });
+            console.log(r.ok ? c.ok(`  Relatório: ${r.arquivo}`) : c.warn('  ' + r.erro));
+            break;
+        }
         /* /schedule: pedido que roda sozinho no Mac, pelo launchd (lib/agendar.js). */
         case 'schedule': {
             const A = require('../lib/agendar.js');
@@ -3050,7 +3099,7 @@ async function handleSlash(text) {
             console.log(c.dim('\n  Em tokens (a unidade que o modelo conta):'));
             for (const l of linhas) {
                 console.log(`  ${c.white(ui.padRight(l.provedor, 22))}${c.muted(ui.padRight(l.pedidos + (l.pedidos === 1 ? ' pedido' : ' pedidos'), 12))}`
-                    + `${c.dim('enviou ')}${c.white(extra.fmtNumero(l.enviados))}${c.dim(' · recebeu ')}${c.white(extra.fmtNumero(l.recebidos))}${c.dim(' tokens' + (l.exato ? '' : ' (estimado)'))}`);
+                    + `${c.dim('enviou ')}${c.white(extra.fmtNumero(l.enviados))}${c.dim(' · recebeu ')}${c.white(extra.fmtNumero(l.recebidos))}${c.dim(' tokens' + (l.exato ? '' : ' (estimado)'))}${l.emCache ? c.dim(' · ') + c.ok(extra.fmtNumero(l.emCache) + ' do cache') : ''}`);
             }
             if (linhas.length > 1) {
                 console.log(`  ${c.white(ui.padRight('Total', 22))}${c.muted(ui.padRight(total.pedidos + ' pedidos', 12))}`
@@ -3659,6 +3708,14 @@ function conferirServidor() {
 }
 
 async function main() {
+    /* `primocode autoteste|preview|review|pesquisar`: entradas sem sessão (lib/cli/subcomandos.js). */
+    if (require('../lib/cli/subcomandos.js').NOMES.includes(process.argv[2])) {
+        process.exit(await require('../lib/cli/subcomandos.js').main(process.argv[2], process.argv.slice(3)));
+    }
+    /* `primocode --tentativas N "pedido"`: best of N em worktrees separados (lib/cli/tentativas.js). */
+    if (process.argv.slice(2).some((a) => a === '--tentativas' || a.startsWith('--tentativas='))) {
+        process.exit(await require('../lib/cli/tentativas.js').main(process.argv.slice(2)));
+    }
     /* `primocode video <op>`: o editor de vídeo por linha do tempo
        (lib/video/). Sai ANTES de tudo — sem sessão, sem pasta padrão —
        porque quem chama é o agente pelo run_shell, na pasta da gravação. */

package/editor/helpers/camera_viva.py

@@ -40,6 +40,9 @@ from pathlib import Path
 MARCA = "camera_viva"
 ZOOM_A, ZOOM_B = 1.0, 1.12
 PUNCH_A, PUNCH_B = 1.25, 1.3
+# (maquina) o enquadramento não alterna mais 1.0/1.12 em tique-taque: gira por uma escala de quatro degraus e a
+# escolha vem do texto da própria frase (mesmo roteiro, mesma escolha; outro roteiro, outro ritmo), nunca repetindo.
+ZOOMS_MAQUINA = (1.0, 1.08, 1.12, 1.18)
 MIN_GAP_S = 2.5
 LONGA_S = 4.5          # a sentence longer than this is split in two
 CURTA_S = 1.2          # a sentence shorter than this joins the next one
@@ -157,6 +160,24 @@ def energia(db, w: dict) -> float:
     return float(np.percentile(seg, 90)) if len(seg) else -99.0
 
 
+def escolher_base(t: float, ultima: float) -> float:
+    """Escala de base do trecho que começa em `t`: gira pela escala, nunca repete a anterior e nunca salta mais
+    de dois degraus (para não parecer um tranco)."""
+    k = int(round(t * 1000)) * 2654435761 % (2 ** 32)
+    opcoes = [z for z in ZOOMS_MAQUINA if z != ultima]
+    if ultima in ZOOMS_MAQUINA:
+        i = ZOOMS_MAQUINA.index(ultima)
+        perto = [z for z in opcoes if abs(ZOOMS_MAQUINA.index(z) - i) <= 2]
+        opcoes = perto or opcoes
+    return opcoes[k % len(opcoes)]
+
+
+def punch_para(base: float, motivo: str) -> float:
+    """O aperto na palavra de ênfase: número aperta mais que negação, que aperta mais que a palavra forte."""
+    extra = {"número": 0.30, "negação": 0.24}.get(motivo, 0.18)
+    return round(max(PUNCH_A if base <= ZOOM_A else PUNCH_B, base + extra), 3)
+
+
 def enfase(ws: list[dict], f: list[int], db) -> tuple[int, str] | None:
     """(index, reason) of the emphasis word of a sentence: number, negation, or the loudest content word."""
     en = {i: energia(db, ws[i]) for i in f}
@@ -343,7 +364,12 @@ def plano(cfg: dict, ws: list[dict], cortes: list[float], vdur: float, db=None,
             for a, b in zip(pontos, pontos[1:]):
                 titulo = sob and any(x - 0.01 <= (a + b) / 2 <= y + 0.01 for x, y in titulos) and \
                     not any(x < b - 0.05 and a + 0.05 < y for x, y in sobre)
-                base = ZOOM_B if titulo else (ZOOM_A if sob or ultima_base == ZOOM_B else ZOOM_B)
+                if titulo:
+                    base = ZOOM_B
+                elif sob:
+                    base = ZOOM_A
+                else:
+                    base = escolher_base(a, ultima_base)
                 ultima_base = base
                 bloco = dict(cena="tela_cheia", de=round(a, 3), ate=round(b, 3), zoom=base, auto=MARCA)
                 if titulo:
@@ -359,7 +385,7 @@ def plano(cfg: dict, ws: list[dict], cortes: list[float], vdur: float, db=None,
                     t1 = round(min(ws[i]["end"] + PUNCH_FICA_S, b - 0.05), 3)
                     if any(x < t1 and t0 - 0.1 < y for x, y in ocupado):
                         continue
-                    bloco["zooms"] = [dict(em=round(t0, 3), ate=t1, escala=PUNCH_A if base == ZOOM_A else PUNCH_B,
+                    bloco["zooms"] = [dict(em=round(t0, 3), ate=t1, escala=punch_para(base, motivo),
                                            som=False, auto=MARCA)]
                     punches.append(dict(em=round(t0, 2), palavra=ws[i]["text"], motivo=motivo))
                     ultimo_punch = t0

package/lib/act.js

@@ -58,7 +58,7 @@ 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']);
 /* O que só lê: pode rodar junto com as outras leituras da mesma rodada. */
-const SO_LEITURA = new Set(['read_file', 'list_dir', 'glob', 'grep', 'pesquisar_referencia', 'estudio_site', 'mcp_procurar']);
+const SO_LEITURA = new Set(['read_file', 'list_dir', 'glob', 'grep', 'pesquisar_referencia', 'buscar_web', 'ler_url', 'estudio_site', 'mcp_procurar']);
 const ehLeitura = (tc) => SO_LEITURA.has(tc.name)
     || (tc.name === 'run_shell' && /^\s*primocode\s+(skill|mcp\s+list|video\s+(help|get_timeline|get_transcript))\b/.test(String((tc.arguments && tc.arguments.command) || '')));
 
@@ -768,6 +768,7 @@ const RITMO = '[ritmo]\n'
     + '- O resultado de write_file/edit_file é a verdade. Não releia um arquivo que você acabou de escrever para conferir (nem com cat/sed/head): a conferência é do PrimoCode.\n'
     + '- Várias ações independentes vão na MESMA resposta (ex.: escrever index.html, style.css e script.js juntos).\n'
     + '- Leia um arquivo inteiro uma vez, não em pedaços pequenos; não leia de novo o que não mudou.\n'
+    + '- PERGUNTAR (ferramenta perguntar) só quando está BLOQUEADO: duas saídas razoáveis e errar custa caro. Pergunta de educação gasta a vez da pessoa; escolha e siga.\n'
     + '- Não narre o próximo passo: faça. Termine com finish("o que foi feito").\n'
     + '- VOCÊ DECIDE O CAMINHO. Pedido simples: faça direto. Pedido grande com partes independentes: write_todos com as partes, '
     + 'depois spawn_agent — um por parte, até 8 NA MESMA resposta (rodam juntos), cada um com o especialista e tudo que ele precisa saber. '
@@ -824,6 +825,8 @@ function buildMemoryContext(projectDir, projectName, pedido = '', { memoriaDaPas
     const lidos = preLeitura.bloco(preLeitura.escolher(projectDir, arquivos, pedido));
     if (lidos) parts.push(lidos);
     parts.push(RITMO);
+    // Mastermind + Geral (lib/agentes): o núcleo sempre ligado; o resto o modelo busca (agentes_buscar, capacidade_buscar).
+    try { parts.push(require('./agentes').nucleo()); } catch { /* sem núcleo, segue com o ritmo */ }
     // Os servidores MCP configurados, numa linha (lib/mcp.js).
     try { const m = require('./mcp.js').dica(projectDir); if (m) parts.push(m); } catch { /* sem mcp */ }
     // A equipe calada (lib/personas.js): o olhar do especialista que o pedido pede.
@@ -832,9 +835,48 @@ function buildMemoryContext(projectDir, projectName, pedido = '', { memoriaDaPas
     return parts.join('\n\n');
 }
 
-async function runAct(userPrompt, opts) {
+/* O PLACAR (lib/placar.js): o PrimoCode aprende qual modelo grátis acerta mais em cada tipo de tarefa.
+   Aqui ele (1) classifica o pedido, (2) sem modelo fixado, manda ao servidor o melhor modelo do apelido como
+   DICA (`preferido`), e (3) no fim anota o desfecho. Só no agente principal e no servidor de verdade
+   (motor injetado = teste = sem placar). Qualquer falha aqui é ignorada: o placar nunca atrapalha a tarefa. */
+let _vivos = { em: 0, dados: null };
+async function modelosVivos(server, token, alias) {
+    if (!_vivos.dados || Date.now() - _vivos.em > 10 * 60 * 1000) {
+        const h = await Promise.race([api.getHealth(server, token), new Promise((_, rej) => setTimeout(() => rej(new Error('lento')), 2500))]);
+        _vivos = { em: Date.now(), dados: (h && (h.correntes_ativas || h.correntes)) || {} };
+    }
+    return _vivos.dados[alias] || [];
+}
+
+async function runAct(userPrompt, opts = {}) {
+    if (opts.subagent || (opts.profundidade || 0) > 0 || (opts.motor && opts.motor !== api) || opts.sinais || process.env.PRIMOCODE_PLACAR === 'off') {
+        return runActInterno(userPrompt, opts);
+    }
+    const P = require('./placar.js');
+    const tipo = P.classificar(userPrompt);
+    const sinais = { modelo: null, testes: null, diagSujo: false };
+    let preferido = null;
+    const fixado = /[\/:]/.test(String(opts.model || ''));   // /model <id>: o placar não mexe
+    if (!fixado) {
+        try {
+            const alias = ['fast', 'main', 'top'].includes(opts.model) ? opts.model : 'main';
+            const dados = P.ler();
+            const temDado = Object.values(dados.tipos[tipo] || {}).some((c) => (c.ganhos || 0) + (c.perdas || 0) >= P.MIN_AMOSTRAS);
+            if (temDado) {
+                const e = P.escolher(dados, tipo, await modelosVivos(opts.server, opts.token, alias));
+                if (e) preferido = e.modelo;
+            }
+        } catch { /* sem dica: o servidor decide */ }
+    }
+    const r = await runActInterno(userPrompt, { ...opts, sinais, preferido });
+    try { P.fechar(tipo, sinais, r && r.concluiu); } catch { /* anotar é conveniência */ }
+    return r;
+}
+
+async function runActInterno(userPrompt, opts) {
     const {
         server, model, token, history, projectDir, projectName,
+        sinais = null, preferido = null,   // o placar (lib/placar.js): onde anotar o que aconteceu, e a dica de modelo
         ensureWorkDir, profundidade = 0, subagent = false, effort,
         /* A memória do AGENTS.md entra no contexto? O bin diz não quando o
            resumo da conversa já a dobrou (lib/memoria-conversa.js). */
@@ -849,6 +891,8 @@ 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,
+        /* Quem mostra a pergunta com opções da ferramenta `perguntar` (terminal). Sem ele: 1ª opção + log. */
+        escolher = 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. */
@@ -972,6 +1016,7 @@ async function runAct(userPrompt, opts) {
         try { r = await C.rodar(como.comando, pastaAtual, { timeout: C.PRAZO_SOZINHO }); } catch { r = null; } finally { sp.stop(); }
         tempos.somar('rodar os testes', Date.now() - t);
         if (!r || r.estourou) { avisoDosTestes = ''; return null; }
+        if (sinais) sinais.testes = !!r.ok;
         registro.anotarTeste(livro, { comando: como.comando, ok: r.ok, code: r.codigo, saida: r.saida });
         const ex = C.explicar(r, como);
         if (r.ok) {
@@ -1284,6 +1329,7 @@ async function runAct(userPrompt, opts) {
        pedaços — a conversa dele inchou para 45 mil caracteres e uma resposta
        levou 22 minutos. Uma parte de um plano cabe em 20 voltas; na 15ª ele
        é avisado para fechar, e no teto volta com a entrega do que fez. */
+    let ultimoModelo = null; let voltaDoResumo = -9;   // lib/session/compactacao.js
     for (let iteration = 0; iteration < teto && !PARAR; iteration++) {
         voltas++;
         if (subagent && !avisouTeto && voltas >= teto - 5) {
@@ -1294,6 +1340,8 @@ async function runAct(userPrompt, opts) {
         // Recado digitado durante o passo anterior entra AGORA, antes da ida
         // ao modelo — o resultado das ferramentas já está na conversa.
         if (!subagent) entregarRecados(messages, profundidade);
+        // Tarefa em segundo plano que acabou desde a última volta (lib/fundo.js): o modelo fica sabendo.
+        if (!subagent) for (const av of require('./fundo').pegarAvisos()) messages.push({ role: 'user', content: av.texto });
         const sp = new Spinner(subagent ? 'subagente trabalhando' : PENSANDO).start();
 
         const toolCalls = [];
@@ -1315,11 +1363,27 @@ async function runAct(userPrompt, opts) {
         try {
             let folgado = false;
             try { folgado = !!require('./local/provedor.js').atual(); } catch { /* sem provedor próprio */ }
+            /* RESUMO AUTOMÁTICO (lib/session/compactacao.js): passou de ~80% da janela do modelo → as voltas antigas viram
+               um resumo feito pelo modelo (objetivo, decisões, arquivos, to-dos). Só depois o compactar() encolhe o resto. */
+            if (voltas - voltaDoResumo >= 3) {
+                try {
+                    const comp = require('./session/compactacao');
+                    if (comp.precisaCompactar(messages, { janela: comp.janelaDe(ultimoModelo) })) {
+                        voltaDoResumo = voltas;
+                        const r = await comp.compactarMensagens(messages, {
+                            todos: todosDaTarefa,
+                            resumir: ({ resumo, mensagens }, todos) => comp.resumirComFatos({ resumo, mensagens },
+                                (p) => motor.requestResumo(server, { ...p, token }).then((x) => x && x.resumo), todos),
+                        });
+                        if (r.ok) console.log(ident(profundidade) + c.dim(`  ⎿ conversa passou de 80% da janela: ${r.resumidas} mensagens viraram resumo (${r.antes} → ${r.depois} tokens)`));
+                    }
+                } catch { /* resumo é economia, não requisito */ }
+            }
             const enviadas = compactar(messages, { folgado });
             traco(`volta ${voltas}${subagent ? ' (agente)' : ''} · ${enviadas.length} mensagens · ${JSON.stringify(enviadas).length} caracteres`);
-            await motor.requestAct(server, { messages: enviadas, model, effort, token, projectDir: pastaAtual, projectName, subagent, sinal: emVoo.signal }, (evt) => {
+            await motor.requestAct(server, { messages: enviadas, model, preferido: preferido || undefined, effort, token, projectDir: pastaAtual, projectName, subagent, sinal: emVoo.signal }, (evt) => {
                 if (evt.erro) { streamError = folgado ? evt.erro : erroDaCorrente(evt.erro); return; }
-                if (evt.modelo) { modeloDaVolta = evt; return; }
+                if (evt.modelo) { modeloDaVolta = evt; ultimoModelo = evt.modelo; if (sinais) sinais.modelo = evt.modelo; require('./statusline').registrarModelo(evt.modelo); return; }
                 if (evt.tool_call) {
                     toolCalls.push(evt.tool_call);
                     const a = evt.tool_call.arguments || {};
@@ -1997,8 +2061,9 @@ async function runAct(userPrompt, opts) {
             traco(`executando ${tc.name}`);
             const idAcao = idsAdiantados.get(tc.id) || anotar(tc, 'permitida');
             const result = adiantadas.has(tc.id) ? adiantadas.get(tc.id)
-                : await tools.execute(tc.name, tc.arguments, { projectDir: pastaAtual, server, token, api });
+                : await tools.execute(tc.name, tc.arguments, { projectDir: pastaAtual, server, token, api, escolher: subagent ? undefined : escolher });
             auditoria.depois(idAcao, result);
+            if (sinais && result && result.ok && /^(write_file|edit_file|multi_edit)$/.test(tc.name)) sinais.diagSujo = !!result.diagnosticos;   // diagnóstico depois da edição
             if (antesDaEdicao != null && result && result.ok !== false) {
                 let depois = null;
                 try { depois = require('fs').readFileSync(arquivoDaEdicao, 'utf8'); } catch { depois = null; }
@@ -2233,10 +2298,14 @@ async function runSubagent(args, ctx) {
 
     // O ofício: o modelo diz quem faz (`especialista`), ou a tarefa sugere. O
     // briefing vai na frente da tarefa, na mesma mensagem — ver especialistas.js.
-    const esp = especialistas.escolher(args.especialista, args.prompt);
-    fala.agente(especialistas.rotulo(esp), descricao, profundidade);
-
-    const r = await runAct(especialistas.montarTarefa(esp, args.prompt), {
+    // Novo catálogo (agentes/): "id" ou "id1,id2" (até 3 olhares na mesma tarefa); o que não existe cai no legado.
+    const novos = require('./agentes').resolver(args.especialista);
+    const esp = novos.length ? null : especialistas.escolher(args.especialista, args.prompt);
+    const agentes = require('./agentes');
+    const rot = novos.length ? agentes.rotulo(novos) : especialistas.rotulo(esp);
+    fala.agente(rot, descricao, profundidade);
+
+    const r = await runAct(novos.length ? agentes.montarTarefa(novos, args.prompt) : especialistas.montarTarefa(esp, args.prompt), {
         server, model, token, projectDir, projectName,
         history: [],
         profundidade: profundidade + 1,
@@ -2256,7 +2325,7 @@ async function runSubagent(args, ctx) {
 
     const resumo = r.assistantMessage.content || 'sem resultado';
     fala.agenteVoltou(resumo, profundidade);
-    return entregaDoAgente(especialistas.rotulo(esp), resumo, r.registro, { pasta: projectDir });
+    return entregaDoAgente(rot, resumo, r.registro, { pasta: projectDir });
 }
 
 /* UM AGENTE DE CADA VEZ é o padrão do modelo grátis: no teste da loja

package/lib/agentes/index.js

@@ -0,0 +1,146 @@
+'use strict';
+/**
+ * lib/agentes — Mastermind + Geral (sempre ligados) e 90+ especialistas (sob demanda).
+ * Divulgação progressiva: o núcleo é curto; o índice e as receitas só entram quando o modelo busca.
+ * Formato: docs/rebuild/agentes-arquitetura.md
+ */
+const fs = require('fs');
+const path = require('path');
+
+const RAIZ = path.join(__dirname, '..', '..', 'agentes');
+
+const semAcento = (s) => String(s || '').toLowerCase().normalize('NFD').replace(/[̀-ͯ]/g, '');
+const palavras = (s) => semAcento(s).split(/[^a-z0-9+#.]+/).filter((w) => w.length > 1);
+
+function frontmatter(texto) {
+    const m = String(texto).match(/^---\n([\s\S]*?)\n---\n?([\s\S]*)$/);
+    if (!m) return null;
+    const meta = {};
+    for (const l of m[1].split('\n')) {
+        const i = l.indexOf(':');
+        if (i > 0) meta[l.slice(0, i).trim()] = l.slice(i + 1).trim();
+    }
+    return { meta, corpo: m[2].trim() };
+}
+
+let CACHE = null;
+function carregar(raiz = RAIZ) {
+    if (CACHE && raiz === RAIZ) return CACHE;
+    const mapa = new Map();
+    // 1) índice: uma linha por agente. id|Nome|area|quando_usar|palavras
+    const idx = path.join(raiz, 'indice.md');
+    if (fs.existsSync(idx)) {
+        for (const l of fs.readFileSync(idx, 'utf8').split('\n')) {
+            if (!l || l.startsWith('#') || !l.includes('|')) continue;
+            const [id, nome, area, quando, chaves = ''] = l.split('|').map((s) => s.trim());
+            if (id) mapa.set(id, { id, nome, area, quando_usar: quando, palavras: chaves, briefing: null });
+        }
+    }
+    // 2) arquivos completos sobrescrevem a linha do índice
+    for (const f of fs.existsSync(raiz) ? fs.readdirSync(raiz) : []) {
+        if (!f.endsWith('.md') || f === 'indice.md') continue;
+        const p = frontmatter(fs.readFileSync(path.join(raiz, f), 'utf8'));
+        if (!p || !p.meta.id) throw new Error(`agente inválido: ${f}`);
+        mapa.set(p.meta.id, { ...p.meta, briefing: p.corpo });
+    }
+    if (raiz === RAIZ) CACHE = mapa;
+    return mapa;
+}
+
+/** Briefing de um agente; os só-índice ganham um briefing genérico honesto, ancorado na área. */
+function briefing(a) {
+    if (a.briefing) return a.briefing;
+    return `Você é o especialista em ${a.nome} (${a.area}): ${a.quando_usar}. Leia o que já existe e siga o padrão dele; faça a menor mudança que resolve; `
+        + 'não invente API, flag ou fato que você não conferiu. Pronto só com prova: rode o comando/teste ou abra o resultado e cite a saída.';
+}
+
+function porId(id) {
+    const n = semAcento(id).trim();
+    const m = carregar();
+    if (m.has(n)) return m.get(n);
+    return null;
+}
+
+/** Os N agentes que melhor casam com a consulta (pontos por palavra em palavras > nome/id > quando_usar > area). */
+function buscar(consulta, n = 5) {
+    const q = [...new Set(palavras(consulta))];
+    const lista = [];
+    for (const a of carregar().values()) {
+        const chaves = new Set(palavras(a.palavras));
+        const nome = new Set(palavras(`${a.id} ${a.nome}`));
+        const quando = new Set(palavras(a.quando_usar));
+        const area = new Set(palavras(a.area));
+        let pts = 0;
+        for (const w of q) {
+            if (chaves.has(w)) pts += 3;
+            if (nome.has(w)) pts += 3;
+            if (quando.has(w)) pts += 1;
+            if (area.has(w)) pts += 1;
+        }
+        if (pts > 0) lista.push({ a, pts });
+    }
+    lista.sort((x, y) => y.pts - x.pts || x.a.id.localeCompare(y.a.id));
+    return lista.slice(0, n).map((x) => x.a);
+}
+
+function linha(a) { return `${a.id} — ${a.nome} (${a.area}): ${a.quando_usar}`; }
+
+/** A ferramenta agentes_buscar: lista curta; `ver` traz o briefing completo de um. */
+function ferramentaBuscar({ consulta, ver }) {
+    if (ver) {
+        const a = porId(ver);
+        return a ? { ok: true, id: a.id, briefing: briefing(a) } : { ok: false, error: `sem agente "${ver}"; use agentes_buscar com uma consulta` };
+    }
+    if (!consulta) return { ok: true, total: carregar().size, areas: [...new Set([...carregar().values()].map((a) => a.area))] };
+    const achados = buscar(consulta, 6);
+    return { ok: true, total: carregar().size, resultados: achados.map(linha), dica: 'Chame spawn_agent com especialista="id" (ou "id1,id2" para dois olhares na mesma tarefa).' };
+}
+
+// ── capacidades do Geral ────────────────────────────────────────────────
+let CAPS = null;
+function capacidades() {
+    if (CAPS) return CAPS;
+    const dir = path.join(RAIZ, 'geral', 'capacidades');
+    CAPS = [];
+    for (const f of fs.existsSync(dir) ? fs.readdirSync(dir).sort() : []) {
+        if (!f.endsWith('.json')) continue;
+        const g = JSON.parse(fs.readFileSync(path.join(dir, f), 'utf8'));
+        for (const it of g.itens) CAPS.push({ ...it, grupo: g.grupo });
+    }
+    return CAPS;
+}
+function gruposDeCapacidades() {
+    const o = {};
+    for (const c of capacidades()) o[c.grupo] = (o[c.grupo] || 0) + 1;
+    return o;
+}
+function ferramentaCapacidade({ consulta, grupo }) {
+    if (!consulta && !grupo) return { ok: true, total: capacidades().length, grupos: gruposDeCapacidades() };
+    const q = [...new Set(palavras(consulta))];
+    const pts = capacidades().filter((c) => !grupo || c.grupo === grupo).map((c) => {
+        const alvo = new Set(palavras(`${c.nome} ${c.quando || ''} ${c.id}`));
+        return { c, p: q.reduce((s, w) => s + (alvo.has(w) ? 2 : 0) + (semAcento(c.receita).includes(w) ? 1 : 0), q.length ? 0 : 1) };
+    }).filter((x) => x.p > 0).sort((a, b) => b.p - a.p).slice(0, 5);
+    return { ok: true, resultados: pts.map(({ c }) => ({ id: c.id, grupo: c.grupo, nome: c.nome, receita: c.receita, prova: c.prova })) };
+}
+
+// ── delegação ───────────────────────────────────────────────────────────
+/** "react" ou "react,seguranca": até 3 olhares na mesma tarefa. Devolve [] se nenhum id existe. */
+function resolver(nomes) {
+    const ids = String(nomes || '').split(/[,+;]/).map((s) => s.trim()).filter(Boolean).slice(0, 3);
+    return ids.map(porId).filter(Boolean);
+}
+function montarTarefa(agentes, tarefa) {
+    if (!agentes.length) return String(tarefa || '');
+    const cab = agentes.map((a) => briefing(a)).join('\n\n');
+    const nota = agentes.length > 1 ? `\n\n(Você acumula ${agentes.length} olhares: ${agentes.map((a) => a.nome).join(' + ')}. Faça a tarefa uma vez, passando por cada checagem.)` : '';
+    return `${cab}${nota}\n\nSUA TAREFA:\n${tarefa}`;
+}
+function rotulo(agentes) { return agentes.length ? `Agente·${agentes.map((a) => a.id).join('+')}` : 'Agente'; }
+
+/** O que o Mastermind faz com o que voltou de N especialistas (vai no resultado do lote). */
+const REVISAO_DO_LOTE = '[mastermind] Entregas acima: confira cada "como provar", cruze os contratos entre partes (nomes, rotas, formatos) e mande de volta só o que falhou.';
+
+function nucleo() { return require('./nucleo.js').NUCLEO; }
+
+module.exports = { carregar, buscar, porId, briefing, ferramentaBuscar, ferramentaCapacidade, capacidades, gruposDeCapacidades, resolver, montarTarefa, rotulo, nucleo, REVISAO_DO_LOTE, frontmatter, RAIZ };

package/lib/agentes/nucleo.js

@@ -0,0 +1,18 @@
+'use strict';
+/* O núcleo sempre ligado: Mastermind + Geral. Teto de ~1.5k tokens (test/agentes.test.js mede). */
+const NUCLEO = `[mastermind]
+Pense como um engenheiro sênior, mesmo sendo um modelo pequeno:
+1. ENTENDA: diga em uma linha o que será entregue e como saberá que ficou pronto. Pedido ambíguo e barato de adivinhar: assuma, escreva a suposição, siga. Só pergunte se errar custa caro.
+2. PLANEJE o menor caminho que prova o resultado. Pedido pequeno: faça direto. Grande: write_todos com 3 a 7 passos.
+3. OLHE antes de mexer: leia o que existe e siga o padrão da casa. Não invente API, arquivo, flag ou fato: confira (grep, ler, rodar) ou diga que não conferiu.
+4. FAÇA uma mudança por vez, a menor que resolve. Ações independentes vão juntas na mesma resposta.
+5. PROVE: rode o teste/comando ou abra o resultado e cite a saída. "Deve funcionar" não é prova. Falhou: leia o erro inteiro, mude a hipótese (nunca repita o mesmo comando), no máximo 3 tentativas e depois diga o bloqueio.
+6. PARE quando a prova passou. Sem extras, sem refatorar o que não foi pedido, sem reler o que acabou de escrever.
+7. FINALIZE com finish: o que mudou, a prova, o que ficou de fora.
+
+[delegar]
+Parte que pede ofício (linguagem, framework, segurança, design, banco...) ou 2+ partes independentes: agentes_buscar("o que preciso") acha o especialista; spawn_agent especialista="id" (ou "id1,id2" para dois olhares). Vários spawn_agent na mesma resposta rodam em paralelo. O prompt é completo: o subagente não vê esta conversa. Quando voltarem, VOCÊ revisa: confira o "como provar" de cada um, cruze contratos entre as partes, devolva só o que falhou. Edição pequena de um arquivo: faça você.
+
+[geral]
+Você é o agente que faz de tudo: código, pesquisa, texto, shell, git, depuração, dados, arquivos. Há um catálogo de receitas (capacidade_buscar("tarefa"), sem argumento lista os grupos): git, shell, depuração, código, pesquisa, escrita, dados, arquivos, web/API, segurança. Antes de improvisar tarefa conhecida (rebase, bisect, regex, curl com auth, migração), busque a receita: ela traz o passo e a prova. Segredo nunca vai no chat nem no commit. Ação destrutiva ou irreversível: diga o que vai acontecer e peça o sim.`;
+module.exports = { NUCLEO };

package/lib/catalogo.js

@@ -41,7 +41,7 @@ const GRUPOS = [
         resumo: 'rodar comando na sua máquina',
         itens: [
             { tool: 'run_shell',           escreve: false, faz: 'roda comando e devolve a saída',
-              args: 'command. timeout_ms (opcional, número, padrão 60000).' },
+              args: 'command. timeout_ms (opcional, número, padrão 60000). em_segundo_plano (opcional, true): roda solto, devolve um id e avisa quando terminar.' },
             { tool: 'run_in_new_terminal', escreve: false, faz: 'abre outro terminal quando a PESSOA quer ver o servidor ou o watch rodando',
               args: 'command. cwd (opcional): pasta onde rodar.' },
             { tool: 'run_background',      escreve: false, faz: 'se o comando fica de pé (servidor, watch), roda em segundo plano e deixa você ler a saída depois',
@@ -254,6 +254,16 @@ const GRUPOS = [
         itens: [
             { tool: 'write_todos', escreve: false, faz: 'monta o plano e vai marcando o que terminou',
               args: 'todos: lista de {content: a tarefa curta no imperativo, status: pending|in_progress|completed}. Reescreve a lista inteira a cada chamada; só uma "in_progress" por vez.' },
+            { tool: 'perguntar', escreve: false, faz: 'pergunta ao usuário com 2 a 4 opções — só quando está bloqueado',
+              args: 'pergunta. opcoes: lista de 2 a 4 textos curtos (a recomendada primeiro). texto_livre (opcional, padrão true).' },
+            { tool: 'buscar_web', escreve: false, faz: 'busca na internet e devolve links com trecho',
+              args: 'consulta: poucas palavras. limite (opcional, número, padrão 6).' },
+            { tool: 'ler_url', escreve: false, faz: 'abre um link e devolve o texto da página em markdown',
+              args: 'url: link completo. max_chars (opcional), desde (opcional, número: continua uma leitura cortada).' },
+            { tool: 'agentes_buscar', escreve: false, faz: 'acha o especialista certo no catálogo de 100+ agentes (ou traz o briefing de um)',
+              args: 'consulta: o que você precisa, em poucas palavras. ver (opcional): id de um agente para ler o briefing completo. Sem argumentos: lista as áreas.' },
+            { tool: 'capacidade_buscar', escreve: false, faz: 'acha uma receita pronta (git, shell, depuração, código, pesquisa, escrita, dados, arquivos, web, segurança)',
+              args: 'consulta: a tarefa. grupo (opcional): limita a um grupo. Sem argumentos: lista os grupos.' },
             { tool: 'pesquisar_referencia', escreve: false, faz: 'lê docs e exemplos antes de escrever — sobe a qualidade',
               args: 'consulta: o que pesquisar, de preferência em inglês. paginas (opcional, número, padrão 3, máximo 5).' },
             // Vai para memory-geral.md, FORA da pasta do projeto — por isso não
@@ -272,7 +282,7 @@ const GRUPOS = [
                 + 'Para só LER lá não precisa trocar: read_file/list_dir com o caminho absoluto, glob/grep com padrão absoluto.' },
             // Estas duas o loop do agente atende (lib/act.js), não o tools.execute.
             { tool: 'spawn_agent', escreve: false, faz: 'chama um subagente especialista para uma parte da tarefa', noLoop: true,
-              args: 'description: 3 a 5 palavras, aparece na tela do usuário. prompt: instrução completa e autossuficiente — o subagente não vê esta conversa. especialista (opcional): frontend, backend, testes, design, dados, revisor ou ambiente — cada um chega com o briefing da profissão (lib/especialistas.js); sem ele, a tarefa sugere.' },
+              args: 'description: 3 a 5 palavras, aparece na tela do usuário. prompt: instrução completa e autossuficiente — o subagente não vê esta conversa. especialista (opcional): id de agentes_buscar (frontend, backend, testes, react, sql, seguranca…) ou dois separados por vírgula — cada um chega com o briefing da profissão (lib/especialistas.js); sem ele, a tarefa sugere.' },
             { tool: 'construir_app', escreve: true, noLoop: true,
               faz: 'constrói um app ou site inteiro com quatro papéis: engenheiro de prompt → protótipo → MVP → revisor que testa escondido, em laço até passar',
               args: 'pedido: o que o usuário quer, com as palavras dele. pasta (opcional): onde construir — sem ela, uma pasta nova com o nome do pedido. rodadas (opcional, 1 a 4, padrão 2): quantas voltas de correção. '