primocode 10.17.1 → 11.0.0

package/lib/act.js

@@ -41,6 +41,8 @@ const preLeitura = require('./pre-leitura');
 const travado = require('./travado');
 const auditoria = require('./auditoria');
 const chamadaTorta = require('./chamada-torta');
+const idioma = require('./idioma');
+const entregaveis = require('./entregaveis');
 
 // 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
@@ -56,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) || '')));
 
@@ -70,6 +72,9 @@ let PARAR = false;
 // rodada e outra: o modelo seguia escrevendo do outro lado e o usuário ficava
 // vendo o spinner girar depois de ter mandado parar.
 let emVoo = null;
+/** Se o último pedido foi parado com Esc Esc (o PARAR só volta a false no começo do próximo). */
+function interrompido() { return PARAR; }
+
 function interromper() {
     PARAR = true;
     if (emVoo) { try { emVoo.abort(); } catch {} }
@@ -134,6 +139,30 @@ function ehTetoDeToken(e) {
  * propósito: cota do DIA (esperar minutos não resolve), crédito, chave e o
  * teto de tokens (esse tem a função acima e o conserto próprio, encolher).
  */
+/**
+ * Erro que o NOSSO servidor mandou no meio do stream, sem chave própria.
+ *
+ * Quando a corrente inteira falha, o servidor repassa o erro do último
+ * provedor dela. Se esse último recusou a chave DELE (401/403), o erro chegava
+ * cru e virava "este servidor pede um token" — com o login da pessoa válido,
+ * e sem nova tentativa (23/10: o /comecar caiu assim, e o pedido seguinte
+ * passou). O 401 do nosso portão não vem por aqui: vem como HTTP 401, antes
+ * do stream. Então aqui é a corrente fora do ar, e isso é passageiro.
+ */
+function erroDaCorrente(erro) {
+    const s = String(erro || '');
+    if (!/\b40[13]\b|unauthorized|forbidden/i.test(s)) return erro;
+    traco(`a corrente falhou e o último provedor recusou a chave dele: ${s.slice(0, 160)}`);
+    return '503 nenhum provedor de IA do servidor respondeu agora';
+}
+
+/** A linha de quando respondeu um modelo de reserva: trocar em silêncio é a queixa nº 7 da pesquisa (Gemini cai
+    pra Flash sem avisar). O servidor manda { modelo, reserva } desde a 10.19; antes disso, nada aparece. */
+function linhaDaReserva(modelo) {
+    const nome = String(modelo || '').replace(/^[a-z0-9]+:/i, '') || 'outro modelo';
+    return `respondeu um modelo de reserva (${nome}): o principal estava ocupado, e a qualidade pode variar um pouco.`;
+}
+
 function ehTransitorio(e) {
     const s = String((e && e.message) || e || '').toLowerCase();
     if (/tokens per day|\btpd\b|free-models-per-day|per day|\b402\b|\b401\b|\b403\b|afford|credit/.test(s)) return false;
@@ -151,6 +180,41 @@ function ehTransitorio(e) {
  * ficou pronto. O agente perde o texto literal das ferramentas e mantém o que
  * importa para seguir: onde estava, o que já sabe, o que falta.
  */
+/** O motivo de uma tool que falhou, curto: o error, o código de saída e a linha de falha da saída do comando. */
+function porqueFalhou(corpo) {
+    let j = null;
+    try { j = JSON.parse(String(corpo).replace(/…\(truncado\)$/, '')); } catch { /* não é JSON inteiro */ }
+    if (!j) { const m = /"error"\s*:\s*"([^"]{1,160})/.exec(corpo); return m ? ` — ${m[1]}` : ''; }
+    const partes = [];
+    if (j.error) partes.push(String(j.error).slice(0, 140));
+    if (j.code != null && j.code !== 0) partes.push(`código ${j.code}`);
+    const linha = `${j.stdout || ''}\n${j.stderr || ''}`.split('\n').reverse().find((l) => require('./saida').FALHA.test(l));
+    if (linha) partes.push(linha.trim().slice(0, 160));
+    return partes.length ? ` — ${partes.join(' · ')}` : '';
+}
+
+/** O resumo de cima da anotação: os arquivos que a tarefa escreveu e o último comando que falhou (e não passou depois). */
+function resumoDoQueJaFoi(messages) {
+    const chamadas = repeticao.chamadasPorId(messages);
+    const escritos = new Set();
+    let ultimaFalha = null;
+    for (const m of messages) {
+        if (!m || m.role !== 'tool') continue;
+        const ch = chamadas.get(m.tool_call_id);
+        if (!ch) continue;
+        const ok = !/"ok"\s*:\s*false/.test(String(m.content || ''));
+        if (ok && /^(write_file|edit_file|multi_edit)$/.test(ch.nome) && ch.args && ch.args.path) escritos.add(ch.args.path);
+        if (ch.nome === 'run_shell' && ch.args && ch.args.command) {
+            if (!ok) ultimaFalha = { cmd: ch.args.command, porque: porqueFalhou(m.content) };
+            else if (ultimaFalha && mesmoComando(ultimaFalha.cmd, ch.args.command)) ultimaFalha = null;
+        }
+    }
+    const linhas = [];
+    if (escritos.size) linhas.push(`Arquivos que você já escreveu (estão no disco; releia antes de editar): ${[...escritos].join(', ')}`);
+    if (ultimaFalha) linhas.push(`Ainda falhando: \`${String(ultimaFalha.cmd).slice(0, 120)}\`${ultimaFalha.porque}`);
+    return linhas;
+}
+
 function anotacaoDoQueJaFoi(messages) {
     const chamadas = repeticao.chamadasPorId(messages);
     const feitos = [];
@@ -158,11 +222,11 @@ function anotacaoDoQueJaFoi(messages) {
         if (!m || m.role !== 'tool') continue;
         const ch = chamadas.get(m.tool_call_id);
         if (!ch) continue;
-        const alvo = ch.args && (ch.args.path || ch.args.consulta || ch.args.ferramenta || ch.args.titulo || ch.args.id);
+        const alvo = ch.args && (ch.args.path || ch.args.command || ch.args.consulta || ch.args.ferramenta || ch.args.titulo || ch.args.id);
         const corpo = String(m.content || '');
         const deuErrado = /"ok"\s*:\s*false/.test(corpo);
-        feitos.push(`- ${ch.nome}${alvo ? `(${String(alvo).slice(0, 60)})` : ''}: `
-            + (deuErrado ? 'FALHOU' : corpo.slice(0, 220).replace(/\s+/g, ' ')));
+        feitos.push(`- ${ch.nome}${alvo ? `(${String(alvo).slice(0, 80)})` : ''}: `
+            + (deuErrado ? `FALHOU${porqueFalhou(corpo)}` : corpo.slice(0, 220).replace(/\s+/g, ' ')));
     }
     return feitos;
 }
@@ -345,13 +409,27 @@ function logResult(kind, result, profundidade) {
     }
 }
 
+/** Dois comandos de shell que resolvem a mesma coisa: o mesmo texto, o mesmo `primocode kit <x> <n>`, ou os dois rodam testes/build. */
+const RODA_TESTE = /\b(test|tests|jest|vitest|mocha|pytest|unittest|cargo\s+test|go\s+test|tsc|build|lint|check)\b/i;
+function mesmoComando(a, b) {
+    const n = (c) => String(c || '').trim().replace(/\s+/g, ' ');
+    const x = n(a), y = n(b);
+    if (!x || !y) return false;
+    if (x === y) return true;
+    const kit = (c) => (/^(primocode|primo) kits? /.test(c) ? c.split(' ').slice(0, 4).join(' ') : null);
+    if (kit(x) && kit(x) === kit(y)) return true;
+    return RODA_TESTE.test(x) && RODA_TESTE.test(y);
+}
+
 // O que volta para o modelo. Cortamos saídas gigantes para não estourar a
 // janela de contexto na iteração seguinte.
 function summarizeForModel(result) {
     // As chaves com `_` são desenho de tela (as duas versões do arquivo, para
     // o diff). Se escapassem daqui, cada edição mandaria o arquivo inteiro,
     // duas vezes, de volta a um modelo que acabou de escrevê-lo.
-    const json = JSON.stringify(limparParaOModelo(result));
+    // saída de comando: começo + as falhas do meio + o fim, e o stderr com a sua cota (lib/saida.js)
+    const S = require('./saida');
+    const json = JSON.stringify(S.caber(S.resumirComando(limparParaOModelo(result))));
     return json.length > 6000 ? json.slice(0, 6000) + '…(truncado)' : json;
 }
 
@@ -482,7 +560,7 @@ function compactar(messages, { folgado = false } = {}) {
  * ficam — sem eles o agente não sabe mais o que estava fazendo.
  */
 function encolherParaContinuar(messages) {
-    const anotacao = anotacaoDoQueJaFoi(messages);
+    const anotacao = [...resumoDoQueJaFoi(messages), ...anotacaoDoQueJaFoi(messages)];
     const guardar = messages.filter((m) => m.role === 'system' || m.role === 'user');
     messages.length = 0;
     messages.push(...guardar);
@@ -550,18 +628,28 @@ async function pausar(ms, subagent) {
  * se o modelo perguntou, empurrá-lo faria ele decidir sozinho o que talvez
  * não devesse.
  */
-const INTENCAO = /(^|[.!\n]\s*)(agora\s+)?(vou|irei|deixa eu|deixe-me|preciso (agora )?(de )?(criar|ler|abrir|rodar|ver|conferir|pesquisar|mandar|fazer|gerar|escrever)|primeiro (vou|eu)|em seguida|pr[óo]ximo passo|a seguir,?\s+(vou|eu)|vamos (criar|ler|abrir|rodar|ver|conferir|come[çc]ar|fazer|gerar|escrever))\b/i;
+const INTENCAO = /(^|[.!,;\n]\s*)(agora\s+)?(vou|irei|deixa eu|deixe-me|preciso (agora )?(de )?(criar|ler|abrir|rodar|ver|conferir|pesquisar|mandar|fazer|gerar|escrever)|primeiro (vou|eu)|em seguida|pr[óo]ximo passo|a seguir,?\s+(vou|eu)|vamos (criar|ler|abrir|rodar|ver|conferir|come[çc]ar|fazer|gerar|escrever))\b/i;
+/* o mesmo em inglês: a trava de idioma responde na língua do pedido, e "Now I'll update the tests." parava a tarefa calado */
+const INTENCAO_EN = /(^|[.!,;\n]\s*)(now,?\s+|next,?\s+|first,?\s+|then,?\s+)?(i'll|i will|i'm going to|i am going to|i need to|let me|let's|we'll|we will|next step)\b/i;
 function pareceParadaNoMeio(texto, { todosPendentes = 0, rodouTool = false } = {}) {
     const t = String(texto || '').trim();
     if (!t) return false;
     if (todosPendentes > 0) return true;
     if (t.length > 700) return false;                              // resposta com corpo
     if (/\?\s*$/.test(t)) return false;                            // perguntou: não é parada
-    if (INTENCAO.test(t)) return true;
+    if (INTENCAO.test(t) || INTENCAO_EN.test(t)) return true;
     if (rodouTool && /[:…]\s*$|\.\.\.\s*$/.test(t)) return true;   // "Criando as cenas:" e nada depois
     return false;
 }
 
+/** O recado do plano com passo aberto (o "pronto" com "0/1 concluídas"). Puro. */
+function recadoDoPlanoAberto(abertos) {
+    const lista = abertos.map((t) => `"${t.content}"`).join('; ');
+    return `o seu plano ainda tem ${abertos.length} passo(s) aberto(s): ${lista}. `
+        + 'Termine esses passos e marque como feitos (write_todos). Se algum não dá pra fazer, '
+        + 'diga claramente o que falta e por quê, e finalize.';
+}
+
 /* O recado da troca de rota: não repete o que já tentou, quebra o que falta
    em pedaços e faz o primeiro. Quem divide a tarefa é o agente, não a pessoa. */
 const TROCA_DE_ROTA = 'Você ficou três voltas sem conseguir rodar nada, repetindo chamadas que já tinha feito. '
@@ -680,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. '
@@ -736,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.
@@ -744,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). */
@@ -761,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. */
@@ -848,8 +980,113 @@ async function runAct(userPrompt, opts) {
         if (medida.limpo) { fala.pensamento('a página abriu sem erro', profundidade); return null; }
         return conferencias >= 2 ? null : medida.relato;
     };
-    const comAviso = (texto) => (avisoDaPagina
-        ? `${texto}\n\nAtenção: abri a página e ela ainda tem problema — ${avisoDaPagina.trim()}` : texto);
+    /* ── RODAR OS TESTES ANTES DE DIZER "PRONTO" (lib/conferir.js) ──────
+     * Mexeu em arquivo e a pasta tem como testar (npm test, pytest, cargo…)?
+     * Antes de aceitar a entrega, roda. Passou: diz "funcionou" e marca o ponto
+     * pro /voltar. Falhou: a tarefa volta pro agente uma vez, com a saída. Na
+     * segunda, entrega dizendo que ainda falha. Prazo estourado não julga
+     * nada. É a brecha 6 da pesquisa: ninguém testa sozinho pro iniciante. */
+    let mexeuNoCodigo = false, rodadasDeTeste = 0, avisoDosTestes = '';
+    let erroQueHavia = '', notaDoConserto = '';   // o que estava errado, pra entrega dizer (pesquisa 4: o iniciante quer saber)
+    let avisouReserva = false;   // uma vez por tarefa: o modelo de reserva respondeu
+    /* A CHAVE NO CÓDIGO (lib/chave-exposta.js): os arquivos que a tarefa mexeu, olhados antes do "pronto". Achou,
+       a tarefa volta pro agente uma vez; na segunda, a entrega sai dizendo onde está. */
+    const arquivosDaTarefa = new Set();
+    let conferiuChaves = 0, avisoDaChave = '';
+    const conferirChaves = () => {
+        if (subagent || !arquivosDaTarefa.size || conferiuChaves >= 2) return null;
+        conferiuChaves++;
+        const K = require('./chave-exposta.js');
+        const achados = K.procurar([...arquivosDaTarefa], { raiz: pastaAtual });
+        avisoDaChave = K.relato(achados);
+        if (!avisoDaChave) return null;
+        console.log(c.warn(`  ⚠ ${avisoDaChave}`));
+        return conferiuChaves >= 2 ? null : `${avisoDaChave} Tire a chave do código: leia de um .env (process.env) ou do servidor, e ponha o .env no .gitignore.`;
+    };
+    const conferirTestes = async () => {
+        const C = require('./conferir.js');
+        if (!C.podeRodarSozinho({ subagent, mexeu: mexeuNoCodigo, rodadas: rodadasDeTeste, parar: PARAR, modo: perigo.normalizarModo(permissoes) })) return null;
+        const como = C.descobrir(pastaAtual);
+        if (!como) return null;
+        rodadasDeTeste++;
+        mexeuNoCodigo = false;
+        const t = Date.now();
+        const sp = new Spinner(`rodando ${como.rotulo} pra conferir`).start();
+        let r = null;
+        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) {
+            avisoDosTestes = '';
+            if (erroQueHavia) notaDoConserto = `O que estava errado: os testes falhavam (${erroQueHavia}); depois do conserto, passaram.`;
+            console.log(c.ok(`  ✓ ${ex.titulo}`) + c.dim(` (${como.comando})`));
+            try { checkpoint.marcarFuncionando(pastaAtual, `${como.comando}, pelo agente`); } catch { /* sem ponto pra marcar */ }
+            return null;
+        }
+        avisoDosTestes = `${ex.titulo} ${ex.linhas.slice(0, 2).join(' ')}`.trim();
+        // a frase que explica (a do Error:, se houver), não a do stack: é a que a pessoa entende
+        if (!erroQueHavia) erroQueHavia = String(ex.linhas.find((l) => /error|erro|assert|fail|falh/i.test(l)) || ex.linhas[0] || '').trim().slice(0, 140);
+        console.log(c.warn(`  ✗ ${ex.titulo}`) + c.dim(` (${como.comando})`));
+        return rodadasDeTeste >= 2 ? null : `Rodei \`${como.comando}\` e falhou:\n${r.saida}`;
+    };
+    /* O ARQUIVO QUE O PEDIDO MANDA GRAVAR (lib/entregaveis.js): "grave o
+       PLANO.md" não termina como feito com o PLANO.md sem existir. Volta uma
+       vez; na segunda, a entrega sai dizendo que o arquivo não existe. */
+    let cobrouArquivo = false, avisoDoArquivo = '';
+    const conferirEntregaveis = () => {
+        if (subagent || perigo.normalizarModo(permissoes) === 'plano') return null;
+        const falta = entregaveis.faltando(userPrompt, pastaAtual, arquivosDaTarefa);
+        avisoDoArquivo = falta.length ? `o pedido mandava gravar ${falta.join(', ')}, e ainda não existe.` : '';
+        if (!falta.length || cobrouArquivo) return null;
+        cobrouArquivo = true;
+        return entregaveis.recado(falta);
+    };
+    /* O PLANO COM PASSO ABERTO: o agente escreveu um plano (write_todos) e
+       disse "pronto" com passo por fazer ("0/1 concluídas"). Volta uma vez
+       pra terminar ou dizer o que falta e por quê; na segunda, a entrega sai
+       com os passos abertos. `todosDaTarefa` é lido na hora: é preenchido
+       mais abaixo, quando o write_todos roda. */
+    let cobrouPlano = false, avisoDoPlano = '';
+    const conferirPlano = () => {
+        if (subagent) return null;
+        const abertos = todosDaTarefa.filter((t) => t.status !== 'completed');
+        avisoDoPlano = abertos.length ? `o plano ficou com ${abertos.length} passo(s) aberto(s): ${abertos.map((t) => t.content).join('; ')}.` : '';
+        if (!abertos.length || cobrouPlano) return null;
+        cobrouPlano = true;
+        return recadoDoPlanoAberto(abertos);
+    };
+    /* O RESUMO QUE DIZ TER MUDADO UM ARQUIVO INTACTO (lib/afirmacoes.js): volta uma vez; na segunda, a entrega avisa. */
+    const inicioDaTarefa = Date.now();
+    let cobrouAfirmacao = false, avisoDaAfirmacao = '';
+    const conferirAfirmacoes = (resumo) => {
+        if (subagent) return null;
+        const A = require('./afirmacoes.js');
+        const falsos = A.semMudanca(resumo, { tocados: arquivosDaTarefa, pasta: pastaAtual, desde: inicioDaTarefa });
+        const semProva = A.testeSemProva(resumo, (livro && livro.testes) || []);
+        const partes = [];
+        if (falsos.length) partes.push(`o resumo diz que mudou ${falsos.join(', ')}, mas nesta tarefa nada foi escrito ${falsos.length > 1 ? 'neles' : 'nele'}`);
+        if (semProva) partes.push(`o resumo diz que o teste passou, mas ${semProva}`);
+        avisoDaAfirmacao = partes.length ? `${partes.join('; ')}.` : '';
+        if (!partes.length || cobrouAfirmacao) return null;
+        cobrouAfirmacao = true;
+        const pedidos = [];
+        if (falsos.length) pedidos.push(`você disse que mudou ${falsos.join(', ')}, mas nesta tarefa nada foi escrito ${falsos.length > 1 ? 'neles' : 'nele'}: faça a mudança agora (edit_file/write_file) ou corrija o resumo`);
+        if (semProva) pedidos.push(`você disse que o teste passou, mas ${semProva}: rode o teste agora e leia o resultado, ou tire isso do resumo`);
+        return `${pedidos.join('; e ')}.`;
+    };
+    const comAviso = (texto) => {
+        let t = avisoDaPagina ? `${texto}\n\nAtenção: abri a página e ela ainda tem problema — ${avisoDaPagina.trim()}` : texto;
+        if (avisoDosTestes) t += `\n\nAtenção: rodei os testes e eles ainda falham — ${avisoDosTestes}`;
+        if (avisoDaChave) t += `\n\nAtenção: ${avisoDaChave}`;
+        if (avisoDoArquivo) t += `\n\nAtenção: ${avisoDoArquivo}`;
+        if (avisoDoPlano) t += `\n\nAtenção: ${avisoDoPlano}`;
+        if (avisoDaAfirmacao) t += `\n\nAtenção: ${avisoDaAfirmacao}`;
+        if (notaDoConserto && !avisoDosTestes) t += `\n\n${notaDoConserto}`;
+        return t;
+    };
     // Quem já foi chamado, e quantas vezes. Ver lib/repeticao.js.
     const jaChamado = repeticao.novo();
     /* Andando em círculo? (lib/travado.js — o subagente de 01/10 que releu o
@@ -898,6 +1135,23 @@ async function runAct(userPrompt, opts) {
     if (!subagent) {
         const comSkills = skills.cardapio(userPrompt);
         pedido = comSkills.texto;
+        /* O menu de comandos (lib/nomes.js): "põe no ar" sem barra nenhuma e o
+           agente aponta o /ship. A IA decide pelo "quando" de cada um; nenhum
+           regex escolhe comando. Os .md da pessoa entram no fim do menu. */
+        let dela = [];
+        try { dela = require('./comandos.js').carregar({ projectDir }); } catch { /* disco estranho não trava o pedido */ }
+        pedido = `${require('./nomes.js').menuParaIA({ dela })}\n\n${pedido}`;
+        /* OS KITS DE ESTILO DE MOTION (lib/kits.js): um turno novo por pedido da pessoa (o `kit fazer` só
+           passa depois que ela respondeu ao cartão) e o menu dos kits. A IA escolhe o kit; o "parece motion"
+           só decide se vai o menu inteiro ou uma linha. */
+        try {
+            const kits = require('./kits.js');
+            kits.novoTurno();
+            const cabeca = kits.cabecaDoPedido(userPrompt, { projectDir });
+            // o vídeo esperando o sim vai colado na resposta da pessoa (é dela que a IA decide); o menu, na frente
+            if (cabeca && /^\[VÍDEO (ESPERANDO|SENDO MONTADO)/.test(cabeca) && pedido.endsWith(userPrompt)) pedido = `${pedido.slice(0, pedido.length - userPrompt.length)}${cabeca}\n\nRESPOSTA DA PESSOA: ${userPrompt}`;
+            else if (cabeca) pedido = `${cabeca}\n\n${pedido}`;
+        } catch { /* pacote sem kits: segue */ }
         if (instrucao) pedido = `${instrucao}\n\nPEDIDO: ${pedido}`;
     }
     let voltasEmFalso = 0;
@@ -915,7 +1169,9 @@ async function runAct(userPrompt, opts) {
        pedido seguinte. */
     let rodouTool = false;
     let todosDaTarefa = [];
-    let empurroes = 0;
+    let empurroes = 0, empurroesDoKit = 0;
+    // As travas do fim (idioma, arquivo pedido, plano aberto): cada uma manda de volta UMA vez por pedido.
+    let pediuIdioma = false;
 
     const messages = [];
     if (!subagent) {
@@ -1010,6 +1266,19 @@ async function runAct(userPrompt, opts) {
         }
     }
 
+    /* "O app não abre": o `primocode porta` (lib/porta.js) sabe a porta de verdade, e o modelo decide se roda.
+       A regra só SUGERE (a palavra apareceu); sem ela, a linha não ocupa o pedido de quem não falou disso. */
+    if (!subagent && profundidade === 0 && require('./porta.js').PEDE_PORTA.test(userPrompt)) {
+        messages.push({ role: 'system', content: 'SE a pessoa diz que o app ou o site não abre no navegador: rode `primocode porta` pelo run_shell, na pasta do projeto. '
+            + 'Ele diz a porta que o projeto declara, a que está respondendo de verdade (com o título da página) e o endereço certo. Use isso na resposta; não adivinhe a porta.' });
+    }
+
+    /* A LÍNGUA DO PEDIDO (lib/idioma.js): pedido em português, resposta em
+       português — mesmo quando as ferramentas devolvem inglês. */
+    if (!subagent) {
+        const linha = idioma.instrucao(userPrompt);
+        if (linha) messages.push({ role: 'system', content: linha });
+    }
     messages.push({ role: 'user', content: pedido });
 
     let finalText = '';
@@ -1060,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) {
@@ -1070,11 +1340,14 @@ 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 = [];
         let assistantText = '';
         let streamError = null;
+        let modeloDaVolta = null;   // { modelo, reserva }: o servidor conta quem respondeu
         // O texto do modelo NÃO sai letra a letra enquanto chega: fica guardado
         // até o fim da rodada, porque só ali se sabe o que ele É. Vieram
         // tool_calls junto? É PENSAMENTO ("o vídeo veio em .avi, vou
@@ -1090,10 +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) => {
-                if (evt.erro) { streamError = evt.erro; return; }
+            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; 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 || {};
@@ -1144,6 +1434,10 @@ async function runAct(userPrompt, opts) {
         }
         sp.stop();
         emVoo = null;
+        if (!subagent && !avisouReserva && modeloDaVolta && modeloDaVolta.reserva) {
+            avisouReserva = true;
+            console.log(c.dim(`  ⎿ ${linhaDaReserva(modeloDaVolta.modelo)}`));
+        }
         traco(`volta ${voltas} voltou em ${Math.round((Date.now() - tRodada) / 1000)}s · ${toolCalls.map((t) => t.name).join(', ') || 'texto'}${streamError ? ' · erro: ' + String(streamError).slice(0, 160) : ''}`);
         tempos.somar(subagent ? 'rodada do subagente' : 'rodada do modelo', Date.now() - tRodada);
         if (PARAR) { if (fluxo) fluxo.fechar(); break; }
@@ -1264,6 +1558,7 @@ async function runAct(userPrompt, opts) {
             if (finalText && empurroes < MAX_EMPURROES && !PARAR
                 && pareceParadaNoMeio(finalText, { todosPendentes: pendentes, rodouTool })) {
                 empurroes++;
+                if (pendentes) cobrouPlano = true;   // este empurrão já cobrou o plano aberto
                 if (!subagent) {
                     if (fluxo) fluxo.fechar();
                     else fala.pensamento(finalText, profundidade);
@@ -1279,6 +1574,21 @@ async function runAct(userPrompt, opts) {
                 finalText = '';
                 continue;
             }
+            /* O VÍDEO DE KIT MONTADO PELA METADE: a pessoa pediu (ou confirmou) e o modelo parou falando com
+               batida vazia em motion/plano.json (E2E do Lume, 27/10: "Now I understand the structure…" e fim). Volta
+               com a batida que falta; duas vezes no máximo, e só se o pedido continua o vídeo. */
+            if (finalText && !subagent && !PARAR && empurroesDoKit < 2) {
+                let falta = [];
+                try { const K = require('./kits.js'); if (K.continuaVideo(userPrompt)) falta = K.batidasFaltando(pastaAtual); } catch { /* sem kits */ }
+                if (falta.length) {
+                    empurroesDoKit++;
+                    if (fluxo) fluxo.fechar(); else fala.pensamento(finalText, profundidade);
+                    messages.push({ role: 'assistant', content: finalText });
+                    messages.push({ role: 'user', content: `O vídeo ainda não está montado: faltam as batidas ${falta.join(', ')} em motion/plano.json. Não explique — mande agora a batida ${falta[0]}: run_shell "primocode kit batida ${falta[0]} --camadas '[…]'" (o formulário: "primocode kit batida ${falta[0]}"), e siga até o cartão (primocode kit plano).` });
+                    finalText = '';
+                    continue;
+                }
+            }
             // Terminou falando, sem chamar finish: confere a página do mesmo jeito.
             if (finalText) {
                 const relato = await conferirPagina();
@@ -1292,6 +1602,45 @@ async function runAct(userPrompt, opts) {
                     finalText = '';
                     continue;
                 }
+                const relatoDaChave = conferirChaves();
+                if (relatoDaChave) {
+                    messages.push({ role: 'assistant', content: finalText });
+                    messages.push({ role: 'user', content: `AINDA NÃO: ${relatoDaChave} Depois finalize de novo.` });
+                    finalText = '';
+                    continue;
+                }
+                const relatoDosTestes = await conferirTestes();
+                if (relatoDosTestes) {
+                    messages.push({ role: 'assistant', content: finalText });
+                    messages.push({ role: 'user', content: `AINDA NÃO. ${relatoDosTestes}\n\nAche a causa, conserte só o que quebrou e finalize de novo.` });
+                    finalText = '';
+                    continue;
+                }
+                const semArquivo = conferirEntregaveis();
+                if (semArquivo) {
+                    if (fluxo) fluxo.fechar();
+                    messages.push({ role: 'assistant', content: finalText });
+                    messages.push({ role: 'user', content: `AINDA NÃO: ${semArquivo}` });
+                    finalText = '';
+                    continue;
+                }
+                const planoAberto = conferirPlano();
+                if (planoAberto) {
+                    if (fluxo) fluxo.fechar();
+                    messages.push({ role: 'assistant', content: finalText });
+                    messages.push({ role: 'user', content: `AINDA NÃO: ${planoAberto}` });
+                    finalText = '';
+                    continue;
+                }
+                const troca = !subagent && !pediuIdioma && idioma.trocouDeIdioma(userPrompt, finalText);
+                if (troca) {
+                    pediuIdioma = true;
+                    if (fluxo) fluxo.fechar();
+                    messages.push({ role: 'assistant', content: finalText });
+                    messages.push({ role: 'user', content: `AINDA NÃO. ${troca} Responda só com o texto.` });
+                    finalText = '';
+                    continue;
+                }
                 finalText = comAviso(finalText);
             }
             if (!subagent) {
@@ -1400,6 +1749,20 @@ async function runAct(userPrompt, opts) {
             if (PARAR) break;
             prova.ver(tc);
             if (tc.name === 'finish') {
+                // Os testes vêm ANTES do portão de prova: quando o PrimoCode sabe testar a pasta, ele mesmo
+                // roda, e isso é a prova. Sem isso, o portão mandava o agente rodar o que o PrimoCode já ia rodar.
+                const relatoDaChave = conferirChaves();
+                if (relatoDaChave) {
+                    messages.push({ role: 'tool', tool_call_id: tc.id, content: `AINDA NÃO: ${relatoDaChave} Depois chame finish de novo.` });
+                    continue;
+                }
+                const rodadasAntes = rodadasDeTeste;
+                const relatoDosTestes = await conferirTestes();
+                if (rodadasDeTeste > rodadasAntes) prova.rodouPorFora();
+                if (relatoDosTestes) {
+                    messages.push({ role: 'tool', tool_call_id: tc.id, content: `AINDA NÃO. ${relatoDosTestes}\n\nAche a causa, conserte só o que quebrou e chame finish de novo.` });
+                    continue;
+                }
                 const faltaProva = prova.barrar();
                 if (faltaProva) {
                     messages.push({ role: 'tool', tool_call_id: tc.id, content: faltaProva });
@@ -1415,6 +1778,27 @@ async function runAct(userPrompt, opts) {
                     });
                     continue;
                 }
+                const semArquivo = conferirEntregaveis();
+                if (semArquivo) {
+                    messages.push({ role: 'tool', tool_call_id: tc.id, content: `AINDA NÃO: ${semArquivo}` });
+                    continue;
+                }
+                const planoAberto = conferirPlano();
+                if (planoAberto) {
+                    messages.push({ role: 'tool', tool_call_id: tc.id, content: `AINDA NÃO: ${planoAberto}` });
+                    continue;
+                }
+                const afirmou = conferirAfirmacoes((tc.arguments && tc.arguments.summary) || '');
+                if (afirmou) {
+                    messages.push({ role: 'tool', tool_call_id: tc.id, content: `AINDA NÃO: ${afirmou}` });
+                    continue;
+                }
+                const troca = !subagent && !pediuIdioma && idioma.trocouDeIdioma(userPrompt, (tc.arguments && tc.arguments.summary) || '');
+                if (troca) {
+                    pediuIdioma = true;
+                    messages.push({ role: 'tool', tool_call_id: tc.id, content: `AINDA NÃO. ${troca} Chame finish de novo com esse resumo.` });
+                    continue;
+                }
             }
             if (tc.name === 'finish') {
                 // Encerrar com falha pendente é como o agente dizia "pronto!"
@@ -1642,13 +2026,34 @@ async function runAct(userPrompt, opts) {
                 continue;
             }
 
+            /* Vai apagar dado do banco e a pessoa deixou (ou o modo livre deixa): copia o SQLite antes (lib/backup-banco.js).
+               O /undo devolve. Fica depois do portão de propósito: recusado não gera cópia. */
+            if (['run_shell', 'run_in_new_terminal', 'run_background'].includes(tc.name) && perigo.apagaBancoNoComando((tc.arguments || {}).command)) {
+                try {
+                    const copia = require('./backup-banco.js').fazer(pastaAtual);
+                    if (copia) console.log(c.ok('  ⎿ fiz uma cópia do banco antes') + c.dim(` (${copia.arquivos.join(', ')}) · /undo devolve`));
+                } catch { /* sem cópia o comando segue: ela é rede de segurança, não condição */ }
+            }
+
             algoRodou = true;
             rodouTool = true;
             fala.acao(tc.name, tc.arguments, profundidade);
             /* Antes de mexer no arquivo, guarda o original — é o que o /desfazer
                devolve. Caminho inválido não é problema nosso: a tool recusa. */
+            let antesDaEdicao = null, arquivoDaEdicao = null;   // pro alarme do arquivo que encolheu (lib/encolheu.js)
             if (checkpoint.MUDAM_ARQUIVO.has(tc.name)) {
-                try { checkpoint.antesDeMudar(tools.resolveInProject(tc.arguments && tc.arguments.path, pastaAtual), pastaAtual); } catch {}
+                mexeuNoCodigo = true;   // o conferirTestes roda no fim da tarefa
+                try {
+                    arquivoDaEdicao = tools.resolveInProject(tc.arguments && tc.arguments.path, pastaAtual);
+                    arquivosDaTarefa.add(arquivoDaEdicao);
+                    if (require('fs').statSync(arquivoDaEdicao).size < 2 * 1024 * 1024) antesDaEdicao = require('fs').readFileSync(arquivoDaEdicao, 'utf8');
+                } catch { antesDaEdicao = null; }   // arquivo novo, ou caminho que a tool vai recusar
+                try { checkpoint.antesDeMudar(tools.resolveInProject(tc.arguments && tc.arguments.path, pastaAtual), pastaAtual); }
+                catch (e) {
+                    // Caminho inválido a tool recusa sozinha. O resto (disco cheio, sem permissão)
+                    // quer dizer que o /desfazer não vai devolver este arquivo: a pessoa tem que saber.
+                    if (tc.arguments && tc.arguments.path) console.log(c.warn(`  ⚠ não guardei o original de ${tc.arguments.path}: o /undo não vai voltar este arquivo (${e.message})`));
+                }
             }
             /* 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
@@ -1656,8 +2061,18 @@ 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; }
+                const encolheu = require('./encolheu.js').julgar(antesDaEdicao, depois);
+                if (encolheu) {
+                    console.log(c.warn(`  ⚠ ${tc.arguments.path}: ${encolheu.texto}. Se sumiu código sem querer, /undo volta.`));
+                    result.aviso_encolheu = `ATENÇÃO: ${tc.arguments.path} ${encolheu.texto}. Confira se você não apagou código sem querer; se apagou, refaça a edição sem cortar nada.`;
+                }
+            }
             for (const aviso of hooks.rodar('PostToolUse', { nome: tc.name, args: tc.arguments, resultado: result, projectDir: pastaAtual }).avisos) console.log(c.dim(`  ⎿ ${aviso}`));
             traco(`${tc.name} devolveu ok=${result && result.ok}`);
             if (/^estudio_|^planejar_producao$/.test(tc.name) && result && result.ok !== false) {
@@ -1665,6 +2080,9 @@ async function runAct(userPrompt, opts) {
                 if (typeof id === 'string' && id) estudioDaTarefa = id;
             }
             logResult(tc.name, result, profundidade);
+            if (/^estudio_render/.test(tc.name) && result && result.conferencia && !subagent) {
+                for (const l of require('./estudio/conferencia.js').linhasPraPessoa(result.conferencia)) console.log(c.warn(`  ⎿ ${l}`));
+            }
             repeticao.executou(jaChamado, tc.name, tc.arguments);
             if (RELEITURA.has(tc.name) && result && result.ok !== false) {
                 leiturasGuardadas.set(eco.chave, summarizeForModel(result));
@@ -1711,10 +2129,13 @@ async function runAct(userPrompt, opts) {
             }
 
             if (result && result.ok === false) {
+                const cmd = tc.name === 'run_shell' ? String(tc.arguments?.command || '') : '';
                 falhasPendentes.push({
                     tool: tc.name,
                     alvo: tc.arguments?.path || '',
-                    texto: `${tc.name}(${tc.arguments?.path || ''}): ${result.error}`,
+                    comando: cmd,
+                    texto: cmd ? `run_shell(\`${cmd.slice(0, 120)}\`): saiu com código ${result.code ?? '?'}${result.error ? ` (${String(result.error).slice(0, 160)})` : ''}`
+                        : `${tc.name}(${tc.arguments?.path || ''}): ${result.error}`,
                 });
             } else {
                 // Deu certo: some com o que ESTA tool tinha deixado pendente.
@@ -1728,6 +2149,9 @@ async function runAct(userPrompt, opts) {
                 // exatamente o que esta guarda quer premiar, não punir.
                 const alvo = tc.arguments?.path;
                 const sobrou = falhasPendentes.filter((f) => {
+                    // comando de shell: só o MESMO comando (ou outro jeito de rodar os testes) passando limpa.
+                    // Antes um `ls` qualquer depois de um `npm test` vermelho apagava a dívida e o "pronto" passava.
+                    if (f.tool === 'run_shell' && tc.name === 'run_shell') return !mesmoComando(f.comando, tc.arguments?.command);
                     if (f.tool === tc.name) return false;                    // a mesma tool funcionou
                     if (alvo && f.alvo === alvo) return false;               // o mesmo arquivo foi resolvido
                     return true;
@@ -1874,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,
@@ -1897,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);
+    return entregaDoAgente(rot, resumo, r.registro, { pasta: projectDir });
 }
 
 /* UM AGENTE DE CADA VEZ é o padrão do modelo grátis: no teste da loja
@@ -1919,8 +2347,16 @@ function lembreteDeParalelo(todos, naRodada) {
    que falhou. É o contexto que o próximo especialista precisa no prompt
    dele, e é o que deixa o pai mandar a falha de volta para conserto (o laço
    do Qwen: planeja → despacha → confere → conserta). Pura, para o teste. */
-function entregaDoAgente(quem, texto, reg) {
+function entregaDoAgente(quem, texto, reg, { pasta } = {}) {
     const linhas = [`ENTREGA DO ${String(quem).toUpperCase()}`, require('./entrega').limitar(texto, { quem }).texto];
+    /* mexeu em código e não rodou teste nenhum: o subagente não roda o teste automático (só o agente de cima),
+       então quem chamou recebia "alterou x.js" sem prova. Diz com todas as letras e dá o comando do projeto. */
+    const codigo = (xs) => (xs || []).some((f) => /\.(m?[jt]sx?|cjs|py|go|rs|rb|php|java|kt|swift|vue|svelte|c|cc|cpp|h)$/i.test(String(f)));
+    if (reg && (codigo(reg.criados) || codigo(reg.alterados)) && !(reg.testes || []).length) {
+        let como = null;
+        try { como = pasta ? require('./conferir.js').descobrir(pasta) : null; } catch { /* sem pasta */ }
+        linhas.push(`NÃO TESTOU: mexeu em código e não rodou teste.${como ? ` Rode \`${como.comando}\` antes de dar por pronto.` : ' Confira rodando o que prova que funciona.'}`);
+    }
     if (reg) {
         const lista = (nome, xs) => { if (xs && xs.length) linhas.push(`${nome}: ${xs.slice(0, 15).join(', ')}`); };
         lista('criou', reg.criados);
@@ -2059,8 +2495,10 @@ function novoPortaoDeProva() {
             const a = (tc && tc.arguments) || {};
             if (tc.name === 'write_file' || tc.name === 'edit_file' || tc.name === 'multi_edit') {
                 if (CODIGO.test(String(a.path || a.file_path || ''))) edicao = ++seq;
-            } else if (tc.name === 'run_shell' || tc.name === 'run_in_new_terminal') rodou = ++seq;
+            } else if (tc.name === 'run_shell' || tc.name === 'run_in_new_terminal' || tc.name === 'run_background') rodou = ++seq;
         },
+        /** O PrimoCode rodou os testes por conta própria (conferirTestes): vale como o comando depois da edição. */
+        rodouPorFora() { if (edicao) rodou = ++seq; },
         barrar() {
             if (!edicao || rodou > edicao || avisou) return null;
             avisou = true;
@@ -2070,5 +2508,5 @@ function novoPortaoDeProva() {
     };
 }
 
-module.exports = { EDICAO_DE_VIDEO_FALADO, novoPortaoDeProva, runAct, videoForaDeEdicao, entregaDoAgente, lembreteDeParalelo, buildMemoryContext, leituraPeloShell, historicoEnxuto, interromper, mandarDuranteATarefa, trabalhando, sobrasDaCaixa, entregarRecados, compactar, motivoDaParada, pareceParadaNoMeio, ehTetoDeToken, ehTransitorio, esperaDoErro,
-    anotacaoDoQueJaFoi, encolherParaContinuar, MAX_ITERATIONS };
+module.exports = { summarizeForModel, mesmoComando, EDICAO_DE_VIDEO_FALADO, novoPortaoDeProva, runAct, erroDaCorrente, linhaDaReserva, videoForaDeEdicao, entregaDoAgente, lembreteDeParalelo, buildMemoryContext, leituraPeloShell, historicoEnxuto, interromper, interrompido, mandarDuranteATarefa, trabalhando, sobrasDaCaixa, entregarRecados, compactar, motivoDaParada, pareceParadaNoMeio, ehTetoDeToken, ehTransitorio, esperaDoErro,
+    anotacaoDoQueJaFoi, resumoDoQueJaFoi, encolherParaContinuar, recadoDoPlanoAberto, MAX_ITERATIONS };