primocode 10.19.0 → 11.1.0

package/lib/session/runner/act.js

@@ -0,0 +1,2522 @@
+// Loop do agente autônomo — streaming via /api/act/stream.
+//
+// O contrato com o servidor é uma conversa completa (`messages`, estilo OpenAI).
+// Cada volta: o servidor devolve tool_calls -> executamos AQUI, com await, e
+// devolvemos o resultado na volta seguinte. Sem isso o modelo fica cego e
+// repete a mesma tool até estourar o limite.
+//
+// spawn_agent roda este mesmo loop recursivamente, com conversa própria: o
+// subagente não enxerga o diálogo do usuário e devolve só o resumo final.
+
+'use strict';
+
+/* A EDIÇÃO COMPLETA de vídeo falado (20/10/2026): o motor do EDIT IA PRO, pela
+   ferramenta editor_pro ou, com servidor antigo, pelo `primocode editor` no
+   run_shell. É o caminho SE a pessoa quer o vídeo editado; quem decide é o modelo. */
+const EDICAO_DE_VIDEO_FALADO = 'SE ELA QUER A GRAVAÇÃO DELA FALANDO EDITADA DE VERDADE (a edição completa: "edita meu vídeo", "faz um reels disso", '
+    + '"coloca legenda e efeitos", corte + legenda + gancho + efeitos + sons + trilha), o caminho é o editor_pro (motor EDIT IA PRO; a skill editar-video explica): '
+    + 'acao:"cortar" {video} → leia a fala que volta, com os tempos → acao:"montar" {pasta, plano:{gancho, pecas, broll}} → entregue <pasta>/final.mp4 só com o portão PASSOU '
+    + '(atalho sem plano: acao:"editar"). Se editor_pro não estiver na sua lista de ferramentas, rode o mesmo pelo run_shell: '
+    + '`primocode editor cortar --json \'{"video":"<arquivo>"}\'` (montar e editar do mesmo jeito; a saída é uma linha de JSON).\n';
+
+const { c, Spinner, PENSANDO } = require('../../tui/ui');
+const fala = require('../../fala');
+const especialistas = require('../../skill/especialistas');
+const limites = require('../../config/limites');
+let avisouParalelo = false;
+const tools = require('../../tool/tools');
+const api = require('../../provider/api');
+const cfg = require('../../config/config');
+const catalogo = require('../../skill/catalogo');
+const repeticao = require('../../repeticao');
+const diff = require('../../diff');
+const registro = require('../../registro');
+const permissao = require('../../permission/permissao');
+const perigo = require('../../permission/perigo');
+const skills = require('../../skill/skills');
+const checkpoint = require('../checkpoint');
+const hooks = require('../../hooks');
+const tempos = require('../../tempos');
+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('../../plugin/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
+// de um vídeo de dez cenas com pesquisa, e a pessoa lia "gastei as voltas".
+const MAX_ITERATIONS = Number(process.env.PRIMOCODE_MAX_VOLTAS || 40);
+const MAX_VOLTAS_AGENTE = Number(process.env.PRIMOCODE_MAX_VOLTAS_AGENTE || 20);
+// Quantas vezes o agente é EMPURRADO quando para no meio para narrar
+// ("agora vou criar o arquivo…") em vez de fazer. Ver `pareceParadaNoMeio`.
+const MAX_EMPURROES = 3;
+// Voltas seguidas sem executar nada antes de desistir.
+const MAX_RODADAS_PARADAS = 3;
+const MAX_PROFUNDIDADE = 2; // principal + 1 nível de subagente
+// As leituras que, repetidas sem mudança no meio, devolvem o guardado.
+const RELEITURA = new Set(['read_file', 'list_dir']);
+/* 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', '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) || '')));
+
+// ── Interrupção (Esc Esc) ─────────────────────────────────────────────────
+// O usuário aperta Esc duas vezes e o agente PARA — entre uma rodada e outra
+// e entre uma tool e a seguinte (uma tool já em execução termina; o que ela
+// fez, ficou feito). A flag é do módulo de propósito: parar o principal para
+// os subagentes junto.
+let PARAR = false;
+// O pedido que está em voo agora. Sem isto o Esc Esc só valia entre uma
+// 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 {} }
+}
+
+/* ── A CAIXA DE ENTRADA: o que a pessoa digita enquanto ele trabalha ────
+ * Antes, a linha digitada durante uma tarefa ia para a fila do terminal e só
+ * rodava DEPOIS — como um pedido novo, que não sabia nada do que estava em
+ * curso. "Mesmo quando ela estiver trabalhando poderá enviar mensagem; ela
+ * vai à fila e, quando o PrimoCode termina um passo, recebe a mensagem e
+ * integra na tarefa." É o que o Claude Code e o Codex fazem: o recado entra
+ * na conversa na fronteira seguinte — depois do resultado das ferramentas,
+ * antes da próxima ida ao modelo. Nenhuma ferramenta é cortada no meio.
+ *
+ * Só o pedido PRINCIPAL lê a caixa (o subagente trabalha para ele). O que
+ * sobrar quando a tarefa acabar volta para o terminal como pedido normal. */
+const CAIXA = [];
+let TRABALHANDO = false;
+function mandarDuranteATarefa(texto) {
+    const t = String(texto || '').trim();
+    if (!t || !TRABALHANDO) return false;
+    CAIXA.push(t);
+    return true;
+}
+function trabalhando() { return TRABALHANDO; }
+/** O que ficou na caixa sem ser lido — o terminal roda como pedido novo. */
+function sobrasDaCaixa() { return CAIXA.splice(0); }
+/* Esvazia a caixa dentro da conversa. Devolve quantos recados entraram. */
+function entregarRecados(messages, profundidade) {
+    if (!CAIXA.length) return 0;
+    const recados = CAIXA.splice(0);
+    for (const r of recados) fala.pensamento(`recado recebido — entrando na tarefa: ${r}`, profundidade);
+    messages.push({
+        role: 'user',
+        content: (recados.length === 1 ? 'MENSAGEM NOVA do usuário, enviada enquanto você trabalhava:\n'
+            : 'MENSAGENS NOVAS do usuário, enviadas enquanto você trabalhava:\n')
+            + recados.map((r) => `- ${r}`).join('\n')
+            + '\n\nIntegre isto na tarefa em curso: se é um ajuste, aplique; se muda o rumo, siga o novo rumo; '
+            + 'se é uma pergunta, responda em uma frase e continue. Não recomece o que já está feito.',
+    });
+    return recados.length;
+}
+
+/**
+ * Este erro é "não coube no minuto"?
+ *
+ * É o único erro que a gente sabe consertar sozinho: encolher o que já foi
+ * feito e continuar. Rede, cota do dia e chave inválida não se resolvem
+ * assim, e tentar de novo só gastaria a vez do usuário.
+ */
+function ehTetoDeToken(e) {
+    const s = String((e && e.message) || e || '').toLowerCase();
+    return /não cabe no teto|conversa passou do teto|request too large|tokens per minute|\btpm\b|reduce your message size/.test(s);
+}
+
+/**
+ * Este erro é PASSAGEIRO — daqui a alguns segundos a mesma chamada passa?
+ *
+ * 429 por pedidos, 5xx do provedor ou do servidor, conexão que caiu no meio.
+ * Nada disso é do usuário, e nada disso ele precisa ver: espera-se um pouco
+ * e repete-se, com o spinner de pensar girando. O que NÃO entra aqui, de
+ * 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;
+    return /rate.?limit|too many requests|\b429\b|\b50[234]\b|bad gateway|service unavailable|gateway timeout|overloaded|socket hang up|econnreset|etimedout|aborted|internal server error|\b500\b/.test(s);
+}
+
+/**
+ * O /compact automático, feito no meio da tarefa.
+ *
+ * O dono: "quando bate no teto dos 6 mil, ele roda o compact ocultamente e
+ * continua a tarefa, pega todo o contexto que ele fez antes, como se nada
+ * tivesse acontecido".
+ *
+ * Troca as rodadas já feitas por UMA anotação do que se descobriu e do que
+ * 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 = [];
+    for (const m of 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.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, 80)})` : ''}: `
+            + (deuErrado ? `FALHOU${porqueFalhou(corpo)}` : corpo.slice(0, 220).replace(/\s+/g, ' ')));
+    }
+    return feitos;
+}
+
+function ident(profundidade) {
+    return '  '.repeat(profundidade);
+}
+
+/* O bloco de diff embaixo do resultado.
+ *
+ * O `_antes`/`_depois` vem das tools de arquivo e existe só para isto: são as
+ * duas versões do texto, que o `limparParaOModelo` apaga antes de a conversa
+ * seguir. Sem essa limpeza, cada edição mandaria o arquivo inteiro de volta
+ * ao modelo — que acabou de escrevê-lo e não aprende nada relendo. */
+function mostrarDiff(result, profundidade) {
+    if (!result || typeof result._antes !== 'string' || typeof result._depois !== 'string') return;
+    const bloco = diff.desenhar(result._antes, result._depois, {
+        prefixo: fala.recuo(profundidade),
+    });
+    if (bloco) console.log(bloco);
+}
+
+/* O que NÃO pode ir para a conversa. Chave com `_` é desenho de tela: o
+   arquivo inteiro, duas vezes, por edição. */
+function limparParaOModelo(result) {
+    if (!result || typeof result !== 'object') return result;
+    const limpo = {};
+    for (const [k, v] of Object.entries(result)) if (!k.startsWith('_')) limpo[k] = v;
+    return limpo;
+}
+
+function logResult(kind, result, profundidade) {
+    const p = fala.resultado(profundidade);
+    if (!result) return;
+    // Uma tool que falhou é informação para o AGENTE, que vai consertar na
+    // volta seguinte — não é o erro do usuário. Âmbar, uma linha, sem o
+    // vermelho que faz parecer que a tarefa morreu.
+    if (result.ok === false) {
+        const texto = String(result.error || `exit ${result.code ?? 'erro'}`).replace(/\s+/g, ' ').trim();
+        // Erro de permissão não corta: a instrução que resolve ("Acessibilidade…
+        // peça de novo") fica justamente depois do 160º caractere.
+        const teto = result.permissao === false ? 400 : 160;
+        console.log(p + c.warn(texto.length > teto ? texto.slice(0, teto - 1) + '…' : texto));
+        return;
+    }
+
+    switch (kind) {
+        case 'write_file':
+            console.log(p + c.muted(`${result.created ? 'criado' : 'atualizado'} · ${tools.fmtBytes(result.bytes)}`));
+            // Reescrever arquivo que já existia apaga o que estava lá. O
+            // número de bytes não conta isso; o bloco embaixo conta.
+            mostrarDiff(result, profundidade);
+            return;
+        case 'edit_file':
+        case 'multi_edit': {
+            const delta = result.linhasDepois - result.linhasAntes;
+            const sinal = delta > 0 ? c.ok(`+${delta}`) : delta < 0 ? c.err(`${delta}`) : c.muted('±0');
+            console.log(p + c.muted(`${result.substituicoes} troca${result.substituicoes > 1 ? 's' : ''} · `) + sinal + c.muted(' linhas'));
+            mostrarDiff(result, profundidade);
+            return;
+        }
+        case 'read_file':
+            console.log(p + c.muted(result.de
+                ? `linhas ${result.de}–${result.ate} de ${result.linhas}`
+                : `${result.linhas} linhas · ${tools.fmtBytes(result.bytes || 0)}${result.truncado ? ' (cortado)' : ''}`));
+            return;
+        case 'list_dir': {
+            const linhas = (result.tree || '').split('\n').filter(Boolean);
+            for (const l of linhas.slice(0, 8)) console.log(p + c.muted(l));
+            if (linhas.length > 8) console.log(p + c.muted(`… +${linhas.length - 8}`));
+            return;
+        }
+        case 'glob':
+            console.log(p + c.muted(`${result.total} arquivo${result.total === 1 ? '' : 's'}`));
+            for (const f of (result.arquivos || []).slice(0, 5)) console.log(p + c.dim(f));
+            if ((result.arquivos || []).length > 5) console.log(p + c.dim(`… +${result.arquivos.length - 5}`));
+            return;
+        case 'grep': {
+            console.log(p + c.muted(`${result.total} ocorrência${result.total === 1 ? '' : 's'} em ${result.arquivosVistos} arquivos`));
+            for (const r of (result.resultados || []).slice(0, 5)) {
+                console.log(p + c.dim(`${r.arquivo}:${r.linha}`));
+            }
+            if ((result.resultados || []).length > 5) console.log(p + c.dim(`… +${result.resultados.length - 5}`));
+            return;
+        }
+        case 'run_shell': {
+            const saida = (result.stdout || '').trim().split('\n').filter(Boolean);
+            for (const l of saida.slice(0, 6)) console.log(p + c.muted(l.slice(0, 160)));
+            if (saida.length > 6) console.log(p + c.muted(`… +${saida.length - 6} linhas`));
+            if (!saida.length) console.log(p + c.ok('exit 0'));
+            return;
+        }
+        case 'open_in_browser':
+            console.log(p + c.muted(result.opener || 'aberto'));
+            return;
+        case 'multi_edit': {
+            const delta = result.linhasDepois - result.linhasAntes;
+            const sinal = delta > 0 ? c.ok(`+${delta}`) : delta < 0 ? c.err(`${delta}`) : c.muted('±0');
+            console.log(p + c.muted(`${result.substituicoes} trocas · `) + sinal + c.muted(' linhas'));
+            return;
+        }
+        case 'write_todos': {
+            const marca = { completed: c.ok('✔'), in_progress: c.brand('▶'), pending: c.dim('○') };
+            for (const t of result.todos || []) {
+                const texto = t.status === 'completed' ? c.dim(t.content) : c.white(t.content);
+                console.log(p + `${marca[t.status] || c.dim('○')} ${texto}`);
+            }
+            console.log(p + c.muted(`${result.feitos}/${result.total} concluídas`));
+            return;
+        }
+        case 'browser_open':
+            console.log(p + c.muted(result.url || 'aberto'));
+            return;
+        case 'browser_read': {
+            const refs = (String(result.pagina || '').match(/^@e\d+/gm) || []).length;
+            console.log(p + c.muted(refs ? `${refs} elementos com ref · ${(result.text || '').length} caracteres de texto`
+                : `${(result.text || '').length} caracteres lidos da página`));
+            return;
+        }
+        case 'pesquisar_referencia': {
+            console.log(p + c.muted(`${result.fontes} fonte${result.fontes === 1 ? '' : 's'} lida${result.fontes === 1 ? '' : 's'} sobre "${result.consulta}"`));
+            for (const r of (result.referencias || []).slice(0, 4)) {
+                console.log(p + c.dim(`${r.titulo}`.slice(0, 100)));
+                console.log(p + c.dim(`  ${r.url}`.slice(0, 110)));
+            }
+            return;
+        }
+        case 'mcp_procurar': {
+            console.log(p + c.muted(`${(result.resultados || []).length} MCP para "${result.busca}"`));
+            for (const r of (result.resultados || []).slice(0, 4)) console.log(p + c.dim(`${r.nome} · ${r.descricao}`.slice(0, 110)));
+            return;
+        }
+        case 'mcp_conectar':
+            console.log(p + c.ok('conectado') + c.muted(` · ${result.servidor} · ${(result.ferramentas || []).length} tools`));
+            return;
+        case 'mcp_usar':
+            console.log(p + c.muted(`${result.servidor}.${result.ferramenta} · ${String(result.resultado || '').length} caracteres`));
+            return;
+        case 'desktop_windows': {
+            console.log(p + c.muted(`${result.total} janela${result.total === 1 ? '' : 's'}`));
+            for (const j of (result.janelas || []).slice(0, 5)) console.log(p + c.dim(`${j.app ? j.app + ' · ' : ''}${j.titulo}`.slice(0, 120)));
+            if ((result.janelas || []).length > 5) console.log(p + c.dim(`… +${result.janelas.length - 5}`));
+            return;
+        }
+        case 'desktop_elements': {
+            console.log(p + c.muted(`${result.total} elemento${result.total === 1 ? '' : 's'} em “${result.janela || 'janela em foco'}”`));
+            for (const e of (result.elementos || []).slice(0, 5)) console.log(p + c.dim(`${e.nome} (${e.x},${e.y})`.slice(0, 120)));
+            if ((result.elementos || []).length > 5) console.log(p + c.dim(`… +${result.elementos.length - 5}`));
+            return;
+        }
+        case 'desktop_click_element':
+            console.log(p + c.ok('ok') + c.muted(` · ${result.duplo ? 'clique duplo' : 'clique'} em “${result.clicado}” (${result.x},${result.y})`));
+            return;
+        case 'desktop_open_app':
+            console.log(p + c.ok('ok') + c.muted(` · ${result.app}`));
+            return;
+        case 'desktop_focus':
+            console.log(p + c.ok('ok') + c.muted(` · ${result.janela || 'em foco'}`));
+            return;
+        case 'browser_screenshot':
+        case 'desktop_screenshot':
+            console.log(p + c.muted(`${result.path} · ${tools.fmtBytes(result.bytes || 0)}`));
+            return;
+        case 'browser_click':
+        case 'browser_type':
+        case 'browser_key':
+        case 'browser_scroll':
+        case 'browser_wait':
+        case 'browser_eval':
+        case 'desktop_click':
+        case 'desktop_double_click':
+        case 'desktop_move':
+        case 'desktop_drag':
+        case 'desktop_type':
+        case 'desktop_key':
+        case 'desktop_scroll':
+        case 'desktop_size':
+            console.log(p + c.ok('ok') + (result.text || result.tag || result.selector || result.width ? c.muted(' · ' + (result.selector || result.tag || (result.width ? `${result.width}×${result.height}` : ''))) : ''));
+            return;
+    }
+}
+
+/** 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.
+    // 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;
+}
+
+// Quantos resultados de tool ficam INTEIROS na conversa. Os mais novos são o
+// que o modelo precisa para decidir o próximo passo; os velhos viram peso.
+const RESULTADOS_INTEIROS = 3;
+const RESTO_DO_RESULTADO = 300;
+/* ── COM MOTOR PRÓPRIO, A MEMÓRIA NÃO É AMPUTADA ────────────────────────
+ * Os 3 e os 300 de cima são para o teto de ~6 mil tokens por minuto do
+ * servidor grátis. Com Claude Code, Codex ou chave própria (`provedor.atual()`)
+ * eles valiam igual, e o modelo perdia o arquivo que tinha acabado de ler:
+ * no jogo de carro de 09/10 o Claude leu o world.js (458 linhas) sete vezes,
+ * em fatias, porque a cada três ferramentas a leitura anterior virava 300
+ * caracteres. A pre-leitura já folgava com motor próprio; o compactar agora
+ * também. */
+const RESULTADOS_INTEIROS_FOLGADO = 20;
+const RESTO_DO_RESULTADO_FOLGADO = 1500;
+// A pesquisa é MATÉRIA-PRIMA, não passo intermediário: é dela que saem os
+// fatos do vídeo, do post, do slide. Ela sempre fica velha (pesquisa-se no
+// começo, escreve-se no fim), e a 300 caracteres não sobrava fato nenhum — o
+// modelo escrevia genérico, que foi exatamente a reclamação de "está tudo
+// padrão". Encolhe também, mas com espaço para os fatos sobreviverem.
+const RESTO_DA_PESQUISA = 1500;
+const MATERIA_PRIMA = new Set(['pesquisar_referencia']);
+
+/* ── O ARQUIVO JÁ GRAVADO NÃO VIAJA DE NOVO ─────────────────────────────
+ * O `compactar` encolhia o resultado das ferramentas e deixava intacto o que
+ * o MODELO escreveu — e o que ele escreve num site é o arquivo inteiro, dentro
+ * da chamada write_file. Medido em 29/09 ("crie uma landing de barbearia"):
+ * depois do index.html (7,6 KB) e do style.css (15 KB), cada ida ao modelo
+ * levava os dois de novo, passava do teto de tokens por minuto do plano
+ * grátis e ficava esperando a janela virar, em silêncio — "escreve dois
+ * arquivos e trava". O conteúdo já está no disco: nas voltas antigas ele vira
+ * um ponteiro. As duas últimas ficam inteiras (é nelas que o modelo decide o
+ * próximo passo, e é delas que sai a releitura sem disco — ver read_file). */
+const ESCRITAS_INTEIRAS = 2;
+const RESTO_DA_ESCRITA = 400;
+function assistentesAntigas(messages) {
+    const idx = [];
+    for (let i = 0; i < messages.length; i++) {
+        const m = messages[i];
+        if (m && m.role === 'assistant' && Array.isArray(m.tool_calls) && m.tool_calls.length) idx.push(i);
+    }
+    return new Set(idx.slice(0, -ESCRITAS_INTEIRAS));
+}
+function encolherEscritas(m) {
+    let mudou = false;
+    const tool_calls = m.tool_calls.map((tc) => {
+        const f = tc && tc.function;
+        if (!f || !/^(write_file|edit_file|multi_edit)$/.test(f.name)) return tc;
+        const bruto = String(f.arguments || '');
+        if (bruto.length <= RESTO_DA_ESCRITA) return tc;
+        let a;
+        try { a = JSON.parse(bruto); } catch { return tc; }
+        const ponteiro = (n) => `(${n} caracteres — já gravado no disco; para mudar, leia com read_file e use edit_file)`;
+        if (f.name === 'write_file' && typeof a.content === 'string' && a.content.length > RESTO_DA_ESCRITA) a.content = ponteiro(a.content.length);
+        else if (f.name === 'edit_file' && typeof a.new_string === 'string' && a.new_string.length > RESTO_DA_ESCRITA) {
+            a.new_string = ponteiro(a.new_string.length);
+            if (typeof a.old_string === 'string' && a.old_string.length > 200) a.old_string = a.old_string.slice(0, 200) + '…';
+        } else if (f.name === 'multi_edit' && Array.isArray(a.edits)) {
+            a.edits = a.edits.map((e) => (e && typeof e.new_string === 'string' && e.new_string.length > RESTO_DA_ESCRITA
+                ? { ...e, new_string: ponteiro(e.new_string.length), old_string: String(e.old_string || '').slice(0, 200) } : e));
+        } else return tc;
+        mudou = true;
+        return { ...tc, function: { ...f, arguments: JSON.stringify(a) } };
+    });
+    return mudou ? { ...m, tool_calls } : m;
+}
+
+/**
+ * Encolhe os resultados de tool ANTIGOS antes de mandar a conversa.
+ *
+ * Sem isto, cada página lida e cada pesquisa ficava inteira no histórico para
+ * sempre. Medido num pedido real ("pesquise sobre a empresa X e faça um
+ * vídeo"): cinco pesquisas e seis leituras de página levaram a conversa a
+ * 27.454 tokens contra um teto de 6.000 por minuto do plano grátis — a tarefa
+ * morreu no meio, depois de todo o trabalho de pesquisa já feito.
+ *
+ * MAS: encolher REFERÊNCIA cria um loop. O manual e as specs do estúdio são o
+ * formato que o modelo precisa ter em mãos na hora de escrever o documento;
+ * encolhidos, ele pede de novo — e é encolhido de novo. Foi assim que um
+ * pedido de vídeo pesquisou e leu a mesma spec sete vezes sem criar nada. A
+ * cópia mais nova de cada referência fica INTEIRA; as velhas, que são o mesmo
+ * texto repetido, viram um ponteiro para ela.
+ *
+ * Nenhuma mensagem é REMOVIDA: a API exige que cada role:'tool' continue
+ * pareada com o tool_call que a pediu. Só o texto encolhe.
+ */
+function compactar(messages, { folgado = false } = {}) {
+    const { inteiras, duplicadas } = repeticao.referenciasNaConversa(messages);
+    const quantosInteiros = folgado ? RESULTADOS_INTEIROS_FOLGADO : RESULTADOS_INTEIROS;
+    const resto = folgado ? RESTO_DO_RESULTADO_FOLGADO : RESTO_DO_RESULTADO;
+
+    const indices = [];
+    for (let i = 0; i < messages.length; i++) if (messages[i].role === 'tool') indices.push(i);
+    if (indices.length <= quantosInteiros && !duplicadas.size && !assistentesAntigas(messages).size) return messages;
+
+    const chamadas = repeticao.chamadasPorId(messages);
+    const encolher = new Set(indices.slice(0, -quantosInteiros));
+    const antigas = assistentesAntigas(messages);
+    return messages.map((m, i) => {
+        if (antigas.has(i)) return encolherEscritas(m);
+        if (duplicadas.has(i)) {
+            return { ...m, content: '(a mesma referência aparece inteira mais adiante nesta conversa — use aquela)' };
+        }
+        if (inteiras.has(i) || !encolher.has(i)) return m;
+        const chamada = chamadas.get(m.tool_call_id);
+        const limite = chamada && MATERIA_PRIMA.has(chamada.nome) ? Math.max(RESTO_DA_PESQUISA, resto) : resto;
+        const texto = String(m.content || '');
+        if (texto.length <= limite) return m;
+        return { ...m, content: texto.slice(0, limite) + `…(resultado antigo encurtado; eram ${texto.length} caracteres)` };
+    });
+}
+
+/**
+ * Por que parou, quando o modelo não disse.
+ *
+ * "Parei sem concluir e sem explicação do modelo" era a resposta para tudo, e
+ * quase sempre mentia: na prática o agente tinha gastado as 15 voltas dando
+ * murro em ponta de faca. Dizer o motivo certo é a diferença entre o usuário
+ * saber o que fazer e ficar no escuro.
+ */
+/**
+ * Troca as rodadas já feitas por uma ANOTAÇÃO do que se descobriu, no lugar.
+ *
+ * Mexe no array recebido de propósito: quem chamou continua o mesmo loop, com
+ * a mesma conversa, só que leve. O pedido do usuário e a mensagem de sistema
+ * ficam — sem eles o agente não sabe mais o que estava fazendo.
+ */
+function encolherParaContinuar(messages) {
+    const anotacao = [...resumoDoQueJaFoi(messages), ...anotacaoDoQueJaFoi(messages)];
+    const guardar = messages.filter((m) => m.role === 'system' || m.role === 'user');
+    messages.length = 0;
+    messages.push(...guardar);
+    if (anotacao.length) {
+        messages.push({
+            role: 'system',
+            content: 'O QUE VOCÊ JÁ FEZ NESTA TAREFA (a conversa foi encolhida para caber no limite; '
+                + 'estas são as suas anotações, continue de onde parou e NÃO refaça o que já está aqui):\n'
+                + anotacao.join('\n')
+                + '\n\nSiga para o próximo passo. Se já tem o que precisa, PRODUZA o resultado agora.',
+        });
+    }
+}
+
+/** Quanto esperar quando o minuto estourou. O provedor costuma dizer
+ * ("Please try again in 7.664s"); sem isso, meio minuto é seguro. */
+function esperaDoErro(e, tentativa = 0) {
+    const m = /try again in ([0-9.]+)s/i.exec(String((e && e.message) || e || ''));
+    if (m) return Math.min(70, Math.max(5, Math.ceil(parseFloat(m[1])) + 2)) * 1000;
+    // Sem o tempo do provedor, cresce a passada a cada tentativa: bater na
+    // mesma porta a cada 30s por horas só esquenta o rate limit.
+    if (ehTetoDeToken(e)) return Math.min(70, Math.max(5, 30 + tentativa * 10)) * 1000;
+    // Rede e 5xx voltam em segundos, não em minutos: 3, 6, 12, 20, 20…
+    // Esperar meio minuto para um servidor que já voltou é a tela parada à toa.
+    return Math.min(20, 3 * 2 ** Math.max(0, tentativa - 1)) * 1000;
+}
+
+/** Espera a vez no modelo — À VISTA, com os segundos, também no subagente.
+ *  Antes girava o spinner de "pensando" (e no subagente, nada): eram minutos
+ *  de tela parada que pareciam trava. "As coisas estão acontecendo, só não
+ *  estão sendo mostradas." Dizer que é a vez do modelo, sem alarme, é a
+ *  diferença entre esperar e desistir. */
+/* PRIMOCODE_TRACO=1: uma linha por ida ao modelo no stderr — o tamanho da
+   conversa, o erro e a espera. É o que diz ONDE uma tarefa travou quando a
+   tela (ou um log sem terminal) só mostra o último arquivo escrito. */
+function traco(texto) {
+    if (process.env.PRIMOCODE_TRACO === '1') process.stderr.write(`  [traço ${new Date().toTimeString().slice(0, 8)}] ${texto}\n`);
+}
+
+async function pausar(ms, subagent) {
+    traco(`esperando ${Math.round(ms / 1000)}s pela vez no modelo${subagent ? ' (agente)' : ''}`);
+    const sp = new Spinner(subagent ? 'o agente espera a vez no modelo' : 'esperando a vez no modelo').start();
+    await new Promise((r) => setTimeout(r, ms));
+    if (sp) sp.stop();
+    tempos.somar('espera de cota/rede', ms);
+}
+
+/**
+ * O modelo devolveu TEXTO, sem tool e sem finish. Isso é resposta — ou é o
+ * agente parando no meio para narrar o que ia fazer?
+ *
+ * Reclamação do dono: "ele tá parando sem concluir, ele deve continuar até o
+ * fim". Medido: o modelo escreve "Agora vou criar o vídeo com as cenas…" e
+ * para, porque texto sem tool encerra a rodada. Quem lê vê uma promessa no
+ * lugar da entrega. Três sinais dizem que foi parada, não resposta:
+ *
+ *   1. Há um plano (write_todos) com item por fazer — ele mesmo disse que
+ *      não acabou.
+ *   2. O texto é INTENÇÃO: anuncia o próximo passo ("vou", "em seguida",
+ *      "próximo passo"), ou termina em dois-pontos e reticências.
+ *   3. É curto. Uma resposta de verdade a "explique este erro" tem corpo; um
+ *      "vou abrir o arquivo agora" não tem.
+ *
+ * Pergunta ao usuário NÃO conta como parada: o prompt proíbe perguntar, mas
+ * 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;
+/* 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) || 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. '
+    + 'Não repita nenhuma delas. Olhe o que já está pronto na conversa, divida o que falta em passos pequenos '
+    + '(write_todos) e faça AGORA o primeiro passo, por um caminho diferente: outra ferramenta, outro arquivo, '
+    + 'outro comando. Se não houver caminho, chame finish e diga em uma frase o que impediu.';
+
+function motivoDaParada({ voltas, voltasEmFalso, falhasPendentes, travou, teto = MAX_ITERATIONS }) {
+    if (falhasPendentes.length) {
+        return `Parei sem concluir. A última falha foi: ${falhasPendentes[falhasPendentes.length - 1].texto}`;
+    }
+    if (travou) {
+        return 'Fiquei preso: tentei dois caminhos e os dois voltaram ao mesmo lugar, então parei antes de gastar sua cota à toa. '
+            + 'O que já fiz está salvo. Diga "continua" que eu retomo daqui.';
+    }
+    if (voltas >= teto) {
+        const emFalso = voltasEmFalso
+            ? ` ${voltasEmFalso} ${voltasEmFalso === 1 ? 'chamada foi repetida' : 'chamadas foram repetidas'} e não rodaram de novo.`
+            : '';
+        return `Usei as ${teto} voltas deste pedido sem chegar ao fim.${emFalso}`
+            + ' O que já fiz está salvo. Diga "continua" que eu retomo daqui.';
+    }
+    return 'Parei sem concluir e sem explicação do modelo. Diga "continua" que eu tento de novo daqui.';
+}
+
+/* ── O MAPA DO PROJETO ───────────────────────────────────────────────────
+ * "Continua o jogo" num projeto de vinte arquivos: o agente começava às
+ * cegas, gastava uma volta listando a pasta — ou, pior, escrevia um index.html
+ * novo por cima do que existia. Agora ele recebe, junto da memória, a lista dos
+ * arquivos do projeto (até 80, sem node_modules nem build), e sabe de saída
+ * onde está cada coisa. Só em pasta de projeto: a raiz ~/primocode lista
+ * outros projetos, não este. */
+const PULAR_NO_MAPA = new Set(['node_modules', '.git', 'dist', 'build', '.next', '.nuxt', 'out',
+    '.cache', 'coverage', '__pycache__', '.venv', 'venv', '.turbo', '.vercel', '.idea', '.vscode']);
+
+function arquivosDoProjeto(dir, limite = 80) {
+    const path = require('path');
+    const fs = require('fs');
+    if (!dir || path.resolve(dir) === path.resolve(cfg.ROOT_DIR)) return [];
+    const achados = [];
+    const andar = (atual, fundo) => {
+        if (fundo > 4 || achados.length >= limite) return;
+        let itens = [];
+        try { itens = fs.readdirSync(atual, { withFileTypes: true }); } catch { return; }
+        itens.sort((a, b) => (a.isDirectory() === b.isDirectory() ? a.name.localeCompare(b.name) : a.isDirectory() ? 1 : -1));
+        for (const it of itens) {
+            if (achados.length >= limite) return;
+            if (PULAR_NO_MAPA.has(it.name) || (it.name.startsWith('.') && it.name !== '.env.example')) continue;
+            const cheio = path.join(atual, it.name);
+            if (it.isDirectory()) andar(cheio, fundo + 1);
+            else if (it.name !== 'memory.md') achados.push(path.relative(dir, cheio));
+        }
+    };
+    andar(dir, 0);
+    return achados;
+}
+
+function mapaDoProjeto(dir, limite = 80, achados = arquivosDoProjeto(dir, limite)) {
+    if (!achados.length) return '';
+    const mais = achados.length >= limite ? `\n… (mais arquivos — use glob para achar)` : '';
+    return `Arquivos que JÁ existem neste projeto (edite-os em vez de recriar):\n${achados.join('\n')}${mais}`;
+}
+
+/* O comando de shell que só LÊ um arquivo — `cat x`, `sed -n '10,40p' x`,
+   `head -50 x`, `tail x`, `nl x`, com ou sem `cd pasta &&` na frente. Medido
+   num pedido de site (29/09): depois de escrever o script.js, o agente o
+   releu em quatro fatias de `sed -n`, uma volta de modelo cada. Devolve o
+   caminho lido (absoluto quando houve cd), ou null. */
+function leituraPeloShell(comando) {
+    const m = /^\s*(?:cd\s+("[^"]+"|'[^']+'|\S+)\s*&&\s*)?(?:cat|nl|sed\s+-n\s+(?:'[^']*'|"[^"]*"|\S+)|head(?:\s+-n?\s*\d+)?|tail(?:\s+-n?\s*\d+)?)\s+("[^"]+"|'[^']+'|[^\s|;&><]+)\s*$/.exec(String(comando || ''));
+    if (!m) return null;
+    const tira = (x) => String(x || '').replace(/^["']|["']$/g, '');
+    const arquivo = tira(m[2]);
+    return m[1] ? require('path').resolve(tira(m[1]), arquivo) : arquivo;
+}
+
+/* ── O HISTÓRICO QUE VIAJA ─────────────────────────────────────────────
+ * Vinte mensagens INTEIRAS iam em toda volta do agente principal. Medido em
+ * 29/09: num pedido de site, 28 mil dos 38 mil caracteres da primeira ida
+ * eram respostas de pedidos anteriores — sozinhas, acima do teto por minuto
+ * do plano grátis. O que a conversa precisa para continuar é o fio (o que
+ * foi pedido, o que ficou pronto), não o texto inteiro: cada mensagem entra
+ * até um teto, e o total também, das mais novas para as mais velhas. */
+const HISTORICO_POR_MENSAGEM = 1200;
+const HISTORICO_TOTAL = 6000;
+function historicoEnxuto(history) {
+    const fora = [];
+    let total = 0;
+    for (const m of (history || []).slice(-20).reverse()) {
+        if (!m || !m.role || !m.content) continue;
+        let t = String(m.content);
+        if (t.length > HISTORICO_POR_MENSAGEM) t = t.slice(0, HISTORICO_POR_MENSAGEM) + '…(encurtado)';
+        if (total + t.length > HISTORICO_TOTAL && fora.length) break;
+        total += t.length;
+        fora.unshift({ role: m.role, content: t });
+    }
+    // A API quer a conversa começando pelo usuário.
+    while (fora.length && fora[0].role !== 'user') fora.shift();
+    return fora;
+}
+
+/* ── O RITMO ─────────────────────────────────────────────────────────
+ * "A potência não deve vir do modelo, deve vir do sistema." O prompt do
+ * servidor manda "leia antes de editar" e "confira antes de dizer que
+ * terminou" — certo para editar código dos outros, e a receita do laço
+ * quando o arquivo foi ele mesmo que escreveu um minuto antes. Estas regras
+ * vêm do que o opencode e o Codex põem nos prompts deles para o modelo não
+ * reler o que fez; entram em TODO pedido, curtas, porque o plano conta token.
+ * A conferência de verdade é nossa (a página aberta no Chrome escondido). */
+/* MCP primeiro, mouse por último: vale no modo local e no subagente, que não
+   recebem o prompt do servidor. */
+const FERRAMENTA_CERTA = '- FERRAMENTA CERTA: para agir num serviço ou app, use primeiro um MCP (veja [mcp]). '
+    + 'Sem MCP: mcp_procurar → mcp_conectar → mcp_usar. Mouse/desktop_* só quando não houver MCP, API ou CLI.';
+
+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. '
+    + 'Cada um volta com uma ENTREGA: confira; o que falhou volta para conserto; a parte que depende de outra recebe a entrega dela no prompt.\n'
+    + '- Antes de dizer pronto, PROVE: rode o teste ou o comando, abra o resultado, olhe a imagem. Sem prova, não está pronto.\n'
+    + FERRAMENTA_CERTA;
+
+/* O ritmo do subagente: o mesmo, sem a parte de orquestrar (ele não abre outro agente). */
+const RITMO_AGENTE = '[ritmo]\n'
+    + '- O resultado de write_file/edit_file é a verdade. Não releia o que acabou de escrever.\n'
+    + '- Leia um arquivo INTEIRO uma vez (read_file sem offset). Não leia aos pedaços, não leia de novo o que não mudou.\n'
+    + '- Várias ações independentes na MESMA resposta.\n'
+    + '- Faça o que a sua parte pede, prove (teste ou comando) e chame finish. Polimento além do pedido não é sua parte.\n'
+    + FERRAMENTA_CERTA;
+
+/* `pedido` é opcional: com ele, o arquivo citado no pedido é o primeiro a
+   entrar já lido (ver lib/pre-leitura.js). */
+/** O agente quer o editor de gravação (`primocode video`) num pedido que não é editar gravação? Puro. */
+function videoForaDeEdicao(nome, args, ehEdicao) {
+    return nome === 'run_shell' && !ehEdicao && /^\s*(?:cd\s+\S+\s*&&\s*)?(?:npx\s+)?primocode\s+video\b/.test(String((args || {}).command || ''));
+}
+
+function buildMemoryContext(projectDir, projectName, pedido = '', { memoriaDaPasta = true } = {}) {
+    const parts = [];
+    /* NO SERVIDOR O CONTEXTO É CURTO (13/10: "continua lendo e listando
+       coisas desnecessárias"). O plano grátis guarda ~1.900 tokens de
+       conversa; 3.400 de contexto fixo empurravam para fora o que o modelo
+       acabou de ler, e ele lia de novo. Com provedor próprio (/api) nada muda. */
+    let proprio = false;
+    try { proprio = !!require('../../provider/local/provedor.js').atual(); } catch { /* sem provedor próprio */ }
+    const curto = (t) => (proprio || t.length <= 1500 ? t : '…' + t.slice(-1500));
+    // As instruções vêm primeiro: são regra de quem manda no projeto, e a
+    // memória é o que o agente anotou. Entram aqui (e não no bin) para valer
+    // igual no terminal, no modo voz e em cada passo de um plano.
+    const instrucoes = require('../../mencoes.js').instrucoesDoProjeto(projectDir);
+    if (instrucoes) parts.push(instrucoes);
+    /* A conversa das sessões anteriores NESTA pasta (lib/agents-md.js). É o
+       que faz a sessão de amanhã começar de onde a de hoje parou. Quando o
+       resumo da conversa já a carrega (`memoriaDaPasta: false`, quem sabe é o
+       bin), ela não vem de novo. */
+    if (memoriaDaPasta) {
+        const daPasta = require('../../agents-md.js').ler(projectDir);
+        if (daPasta) parts.push(`[AGENTS.md — memória desta pasta: de onde a conversa parou]\n${curto(daPasta)}`);
+    }
+    // A memória entre sessões (lib/memoria-usuario.js): a instrução e o índice; no servidor, só as 25 primeiras.
+    try { parts.push(require('../../memoria-usuario.js').blocoDoContexto(undefined, { linhas: proprio ? undefined : 25 })); } catch { /* memória é conveniência */ }
+    const geral = cfg.readGeneralMemory();
+    if (geral.trim()) parts.push(`[memory-geral.md]\n${curto(geral)}`);
+    const projeto = cfg.readProjectMemory(projectDir);
+    if (projeto.trim()) parts.push(`[${projectName || 'projeto'}/memory.md]\n${curto(projeto)}`);
+    const arquivos = arquivosDoProjeto(projectDir);
+    const mapa = mapaDoProjeto(projectDir, proprio ? 80 : 30, arquivos);
+    if (mapa) parts.push(`[${projectName || 'projeto'}/arquivos]\n${mapa}\n\n${preLeitura.JUNTAR_LEITURAS}`);
+    const lidos = preLeitura.bloco(preLeitura.escolher(projectDir, arquivos, pedido));
+    if (lidos) parts.push(lidos);
+    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/mcp.js).
+    try { const m = require('../../mcp/mcp.js').dica(projectDir); if (m) parts.push(m); } catch { /* sem mcp */ }
+    // A equipe calada (lib/skill/personas.js): o olhar do especialista que o pedido pede.
+    const equipe = require('../../skill/personas.js').bloco(pedido);
+    if (equipe) parts.push(equipe);
+    return parts.join('\n\n');
+}
+
+/* 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/session/memoria-conversa.js). */
+        memoriaDaPasta = true,
+        /* Quem troca a pasta de trabalho quando o modelo chama mudar_pasta:
+           async ({ caminho, motivo }) → { ok, caminho, memoria?, error? }.
+           Vem do bin, porque é lá que se PERGUNTA ao usuário — sem ele (pipe,
+           subagente) a troca é recusada. */
+        mudarPasta = null,
+        /* Quem responde ao pedido de controle do computador, e o estado da
+           resposta. Vêm de fora porque quem sabe perguntar é o terminal, e
+           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. */
+        permissoes = 'auto',
+        /* O cliente HTTP, injetável. NÃO é mais um comutador de motor — o
+           PrimoCode tem um motor só, o do servidor, e não há provedor para o
+           usuário escolher. Continua um parâmetro porque é por aqui que o
+           teste põe um servidor de mentira no lugar da rede: sem ele,
+           `test/repeticao.js` e `test/continuar.js` teriam de falar com a
+           internet para verificar o loop do agente. */
+        motor = api,
+        /* Instrução de FORMA que vai junto do pedido mas não É o pedido — a
+           do modo voz ("responda em três frases faladas"). Ela chega ao
+           modelo; a memória e o histórico guardam só o que a pessoa disse.
+           Antes ela ia colada no texto, e a memória do projeto enchia de
+           "[MODO VOZ] A sua resposta vai ser lida em voz alta…". */
+        instrucao = '',
+        /* Quem abre a página para conferir antes do "pronto". Injetável pelo
+           mesmo motivo do `motor`: o teste mede a regra sem abrir um Chrome. */
+        medirPagina = (dir) => require('../../pipeline.js').medirNoNavegador(dir),
+        /* Quem LIGA o navegador escondido antes da hora. Injetável pelo mesmo
+           motivo do `medirPagina` — e só vale junto com o padrão dele: um
+           teste que troca o medidor não pode subir um Chrome de verdade. */
+        aquecerPagina = opts && opts.medirPagina ? null
+            : () => require('../../browser.js').aquecerRevisor(),
+        /* Quem é este agente no livro de ações (auditoria.js). */
+        rotulo = subagent ? 'subagente' : 'principal',
+    } = opts || {};
+
+    // A pasta de projeto só nasce quando o agente for mesmo MEXER EM ARQUIVO.
+    // Antes ela nascia na primeira tool qualquer — pedir "abre o Chrome" criava
+    // um projeto vazio, e ~/primocode enchia de pasta que não era projeto de
+    // nada. Quem decide é o catálogo: `escreve: true`.
+    let criarPasta = ensureWorkDir || null;
+    let pastaAtual = projectDir;      // onde as tools agem AGORA
+    let estudioDaTarefa = null;       // o projeto do Estúdio desta tarefa, se houver
+    let temPasta = !criarPasta;       // já é a pasta definitiva?
+    /* Cria a pasta do projeto pendente, uma vez. Chamado antes de qualquer
+       ferramenta que faz código (ver `criaProjeto` no catálogo) — e ANTES do
+       subagente e do pipeline, que senão escreviam na raiz de ~/primocode. */
+    const garantirPasta = () => {
+        if (!criarPasta) return;
+        const nova = criarPasta();
+        if (nova) pastaAtual = nova;
+        criarPasta = null;
+        temPasta = true;
+    };
+    const falhasPendentes = [];
+    let tentativasDeEncerrar = 0;
+    // Portão de prova fresca (Gravitas, comum/desmontados/udaysharmadev-Gravitas.md): o
+    // `finish` depois de editar código sem rodar nada depois volta UMA vez.
+    const prova = novoPortaoDeProva();
+    /* ── CONFERIR ANTES DE DIZER "PRONTO" ───────────────────────────────
+     * Mexeu em página (html, css, js) nesta tarefa? Antes de aceitar o
+     * `finish`, o PrimoCode abre a página num navegador invisível e olha: tela
+     * em branco, erro de JavaScript, recurso que não carregou. Achou problema,
+     * a tarefa volta para o agente com o relato — uma vez só, para não virar
+     * laço. É a diferença entre "pronto!" e "pronto, e abre". */
+    let mexeuNaPagina = false;       // mexeu desde a última conferência?
+    let conferencias = 0;            // até duas: entregar, e conferir o conserto
+    let avisoDaPagina = '';          // o que ainda estava quebrado na última
+    let msConferindo = 0;            // para o PRIMOCODE_TEMPOS separar as fases
+    /* Abre a página e devolve o relato quando é para VOLTAR (achou problema e
+       ainda cabe uma volta); null quando é para entregar. O que ficar
+       quebrado na última conferência fica em `avisoDaPagina`, e a entrega sai
+       com ele — nunca "pronto" seco sobre uma página com erro. Vale para os
+       dois jeitos de terminar: a ferramenta finish e a resposta em texto. */
+    const conferirPagina = async () => {
+        if (subagent || !mexeuNaPagina || conferencias >= 2 || PARAR) return null;
+        conferencias++;
+        mexeuNaPagina = false;
+        let medida = null;
+        const t = Date.now();
+        // Com spinner: eram segundos de tela parada entre o último arquivo e o
+        // "pronto", e parecia que tinha travado ali.
+        const sp = new Spinner('abrindo a página escondido para conferir').start();
+        try {
+            medida = await medirPagina(pastaAtual);
+        } catch { medida = null; } finally { sp.stop(); }
+        msConferindo += Date.now() - t;
+        tempos.somar('conferir página', Date.now() - t);
+        if (!medida || !medida.testou) return null;
+        avisoDaPagina = medida.limpo ? ''
+            : String(medida.relato || '').split('\n').filter((l) => /·|BRANCO/.test(l)).slice(0, 3).join(' ');
+        if (medida.limpo) { fala.pensamento('a página abriu sem erro', profundidade); return null; }
+        return conferencias >= 2 ? null : medida.relato;
+    };
+    /* ── 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/plugin/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
+       mesmo arquivo por uma hora). Empurra uma vez; na segunda, para. */
+    const circulo = travado.novo();
+    let paradoPorTravar = null;
+    /* Anota ANTES de agir (lib/auditoria.js): recusado também fica no livro. */
+    const anotar = (tc, decisao, motivo) => {
+        if (decisao !== 'recusada' && decisao !== 'negada') require('../../plugin/voz-ponte').ferramenta(tc.name, tc.arguments);
+        const id = auditoria.antes({ agente: rotulo, ferramenta: tc.name, args: tc.arguments, decisao, motivo });
+        const falhou = auditoria.problema();
+        if (falhou) console.log(c.warn(`⚠ ${falhou}`));
+        return id;
+    };
+    // O que read_file/list_dir devolveram, pela chave da época (repeticao.js).
+    const leiturasGuardadas = new Map();
+    // O que ELE escreveu inteiro nesta tarefa, por caminho absoluto — para
+    // não gastar uma volta relendo o próprio texto (ver read_file abaixo).
+    const escritosNaTarefa = new Map();
+    /* O livro deste pedido: arquivos, comandos, links, testes e falhas. Sai
+       no fim como balanço (ver lib/registro.js). O subagente tem o seu, que
+       não se mistura com o do principal — mas o que ele fez também precisa
+       aparecer, então o de cima incorpora o de baixo no retorno. */
+    const livro = registro.novo();
+    /* A autorização do computador vale pela SESSÃO, então o estado vem de
+       fora. Um subagente que criasse o seu perguntaria de novo o que já foi
+       respondido — e uma pergunta repetida é uma pergunta que se responde
+       sem ler. Sem ninguém de fora (teste, pipe), nasce um aqui, que começa
+       fechado. */
+    const portaoControle = controle || permissao.novo();
+
+    /* AS SKILLS entram na frente do pedido, e só as que casam com ele.
+     *
+     * No pedido principal, não no subagente: o subagente já recebe o briefing
+     * do especialista dele, e empilhar os dois gastaria o teto de tokens
+     * duas vezes para dizer coisas parecidas.
+     *
+     * O que decide quais entram é o `quando:` de cada skill — ver
+     * lib/skill/skills.js, que também explica por que mandar todas em todo pedido
+     * não é uma opção num plano limitado por token. */
+    let pedido = userPrompt;
+    /* Editar a GRAVAÇÃO da pessoa? Decide pelo que ELA escreveu (userPrompt),
+       não pelo `pedido` já com skills e instruções na frente: uma skill com
+       "editar… o vídeo" no corpo bastava para virar edição. */
+    const ehEdicaoDaGravacao = require('../../plugin/estudio/diretor.js').precisaDeEdicao(userPrompt);
+    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('../../cli/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/plugin/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('../../plugin/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;
+    // Pesquisas que voltaram de mãos vazias. A partir da terceira, a tool
+    // para de rodar e devolve ORDEM DE SEGUIR: sem isto o agente entrava em
+    // ciclo — buscava, não achava, lia "tente outra consulta", buscava de
+    // novo — até a cota do minuto acabar e o modelo responder vazio. Foi
+    // assim que "crie um vídeo para a tostudy" morreu sem entregar nada.
+    let pesquisasSecas = 0;
+    let rodadasParadas = 0;
+    let trocouDeRota = false;
+    /* Para o `pareceParadaNoMeio`: se alguma tool já rodou nesta tarefa, e o
+       último plano que o modelo escreveu (write_todos) — desta TAREFA, não da
+       sessão: um plano velho, de um pedido interrompido, não pode empurrar o
+       pedido seguinte. */
+    let rodouTool = false;
+    let todosDaTarefa = [];
+    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) {
+        const memory = buildMemoryContext(projectDir, projectName, userPrompt, { memoriaDaPasta });
+        if (memory) messages.push({ role: 'system', content: `Memória persistente:\n\n${memory}` });
+        for (const m of historicoEnxuto(history)) messages.push(m);
+    } else {
+        // O subagente também trabalha no ritmo: sem isto ele relia o mesmo arquivo aos pedaços.
+        messages.push({ role: 'system', content: RITMO_AGENTE });
+    }
+    /* O que VAI para o modelo é `pedido` (com as skills na frente); o que
+       fica guardado na memória e no histórico é `userPrompt`, o que a pessoa
+       escreveu. Guardar o texto inflado faria a conversa crescer com o mesmo
+       conhecimento repetido em cada turno. */
+    /* ── O GATILHO DO DIRETOR ────────────────────────────────────────────
+     *
+     *   "A IA identifica que precisa criar vídeo, ativa o agente, esse agente
+     *    faz a estrutura e manda pra IA, e depois ela só faz o vídeo."
+     *
+     * Deixar isso só escrito no catálogo não basta: com um pedido curto
+     * ("faz um vídeo do produto") o modelo pula direto para montar cena,
+     * porque montar cena é o que ele sabe fazer — e o roteiro, escrito no
+     * meio do JSON, vira legenda de slide. Quem reconhece o pedido é uma
+     * regra (diretor.precisaDeProducao), e ela entra como ORDEM na conversa,
+     * não como conselho perdido no meio de quarenta e sete ferramentas.
+     *
+     * Num subagente não entra: ele já está fazendo uma parte de um plano, e
+     * um diretor dentro do diretor é uma volta a mais para o mesmo lugar. */
+    if (!subagent && profundidade === 0) {
+        const diretor = require('../../plugin/estudio/diretor.js');
+        // Vídeo que o Estúdio fez se edita no Remotion Studio, não no editor por linha do tempo.
+        const EDITAR_DO_ESTUDIO = 'SE ELA QUER EDITAR UM VÍDEO QUE O ESTÚDIO FEZ (não uma gravação dela): '
+            + 'estudio_projeto acao:"editar" com o id do projeto abre o Remotion Studio no navegador; diga a pasta a ela e pare.\n';
+        const EDICAO_COMPLETA = EDICAO_DE_VIDEO_FALADO;
+        const producao = diretor.precisaDeProducao(userPrompt);
+        if (ehEdicaoDaGravacao) {
+            /* A gravação da pessoa FALANDO: a edição completa é do motor do EDIT IA PRO
+               (lib/plugin/editor-pro.js), decisão do Joel em 20/10 depois de comparar os dois no
+               mesmo vídeo. O editor por linha do tempo (lib/plugin/video/) fica para as operações
+               soltas. Quem escolhe entre os dois é o modelo, pelo que a pessoa pediu. */
+            messages.push({ role: 'system', content: EDITAR_DO_ESTUDIO + EDICAO_COMPLETA
+                + 'SE ela pediu UMA operação solta na gravação (cortar um trecho, juntar, exportar, trocar o fundo, um efeito que segue a mão), use o editor por linha do tempo via run_shell: '
+                + 'SE A GRAVAÇÃO TRAZ PEDIDOS FALADOS ("separe em camadas", "me coloca numa praia"): `primocode video import --json \'{"path":"<arquivo>"}\'`, '
+                + 'depois `primocode video auto --json \'{}\'` (lê o que ela FALA na gravação e aplica cada efeito no momento em que diz), inspect, export e abra o mp4. '
+                + 'Nos outros casos: '
+                + 'rode `primocode video help` UMA vez (lista as operações), depois import → remove_silence/remove_words → add_captions → inspect (olhe o png) → export. '
+                + 'Cada edição devolve um delta curto e tem undo: edite sem pedir licença a cada passo.\n'
+                /* "deixar os vídeos cinematográficos… fazer um color grading sozinha" (13/10). */
+                + 'CINEMATOGRÁFICO: `primocode video grade --json \'{}\'` mede a imagem e faz o color grading de cinema sozinho (look:cinema|quente|noite|natural|pb, intensidade); use antes do export quando a pessoa quer o vídeo bonito, e OLHE o inspect.\n'
+                + 'EFEITOS que seguem a pessoa: separate_layers (recorte + momento 3D), replace_background (fundo novo no estalo), '
+                + 'attach_3d (logo 3D na mão, segue a mão), merge_on_join (mãos juntas → fusão → cérebro), cut_silence_at (silêncio depois do estalo), '
+                + 'style_captions (cor, legenda em cima da cabeça) — detalhe em `primocode video help efeitos`. Atalho: `primocode video do --json \'{"pedido":"<o pedido em português>"}\'`.' });
+        } else if (producao.producao) {
+            /* "SE ESTIVER NA SUA LISTA" não é hesitação — é a diferença entre
+               a tarefa seguir e a tarefa morrer.
+
+               A primeira versão mandava chamar `planejar_producao` sem
+               ressalva. Só que quem declara as ferramentas ao modelo é o
+               SERVIDOR, e este texto é do cliente: com o servidor
+               desatualizado, o modelo obedecia a uma ordem para chamar algo
+               que não estava na lista dele, e o provedor recusava com
+               "attempted to call tool 'planejar_producao' which was not in
+               request.tools" — erro FATAL, em inglês, na cara do usuário, com
+               a tarefa perdida antes da primeira ação.
+
+               Um modelo não chama tool fora da lista por conta própria. Só
+               chamou porque este parágrafo mandou. */
+            /* O caminho do ROTEIRO (lib/plugin/estudio/composicao.js). Antes esta
+               ordem mandava chamar o diretor e depois compor "cena a cena,
+               com as primitivas" — o modelo escrevia posição em pixel e o
+               vídeo saía quebrado, além de custar três ou quatro rodadas a
+               mais de modelo (medido em 25/09). */
+            /* A IA DECIDE (01/10): "pedi um roteiro de vídeo e ela já ia fazer o
+               motion". A regra só sabe que a palavra "vídeo" apareceu; quem sabe
+               se a pessoa quer o vídeo PRONTO ou só o roteiro, a ideia ou uma
+               resposta é o modelo. Então isto é o caminho SE for produzir, e não
+               mais uma ordem de produzir. */
+            messages.push({ role: 'system', content:
+                EDITAR_DO_ESTUDIO + EDICAO_COMPLETA + 'VOCÊ DECIDE o que entregar, pelo que a pessoa pediu: se ela quer só o roteiro, a ideia, um texto ou uma resposta, ESCREVA isso e pare — não produza vídeo. '
+                + `SE ela quer a peça pronta (formato "${producao.formato === 'apresentacao' ? 'slides' : 'video'}"), faça em três passos: `
+                + `estudio_projeto acao:"criar" com formato "${producao.formato === 'apresentacao' ? 'slides' : 'video'}" → `
+                + 'estudio_plano com "roteiro" (partes com tipo e fala; o PrimoCode faz layout, voz, ícones, música e sons) → '
+                + 'estudio_render. Se a peça for de uma marca de verdade, estudio_site antes, e use as cores e a logo em roteiro.marca. '
+                /* "todo vídeo começa igual" (09/10): o cardápio de estruturas e o
+                   que os últimos vídeos usaram. O modelo escolhe; nada aqui força. */
+                + 'ANTES de escrever as partes, escolha a estrutura do roteiro e diga qual em roteiro.estrutura. '
+                + 'SE a pessoa pediu duas vozes, dois narradores ou diálogo: roteiro.vozes {nome: voz} e falante em cada parte.\n'
+                + diretor.cardapioEstruturas() + '\n'
+                + 'NÃO escreva cenas, elementos nem posições à mão. '
+                + 'Se estudio_plano não aceitar "roteiro" (servidor antigo), siga com as ferramentas que você tem. '
+                + 'Nunca chame uma ferramenta que não está na sua lista — a chamada é recusada e a tarefa se perde.' });
+        }
+    }
+
+    /* "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 = '';
+
+    // Pedido novo zera o pedido de parada anterior.
+    if (!subagent) PARAR = false;
+
+    // Quantas vezes já encolhemos por estouro de teto. Duas bastam: se depois
+    // disso ainda não couber, o problema é o custo fixo, e encolher de novo só
+    // apagaria o trabalho sem resolver.
+    let compactacoes = 0;
+    const MAX_COMPACTACOES = 2;
+
+    // O provedor recusa chamada de função malformada com um 400 que dizia
+    // "Failed to call a function. Please adjust your prompt." NA CARA do
+    // usuário — que não tem prompt nenhum para ajustar. É o modelo tropeçando
+    // ao escrever o JSON da chamada, e quase sempre acerta na segunda.
+    let funcoesQuebradas = 0;
+    /* As ferramentas que o provedor recusou por não estarem na lista do
+       pedido. Guardadas para não entrar em laço: tira a instrução, tenta de
+       novo UMA vez, e se voltar a acontecer com a mesma ferramenta é porque a
+       causa é outra. */
+    const toolsRecusadas = new Set();
+    let respostasVazias = 0;
+    // O teto de tokens é POR MINUTO, somando TODAS as chamadas — o plano, o
+    // resumo e cada rodada do loop dividem a mesma cota. Um pedido perfeito
+    // estoura se a rodada anterior já gastou o minuto. Encolher não resolve
+    // isso (num caso real "encolheu" de 2 para 2 mensagens); esperar a janela
+    // virar, sim.
+    let esperas = 0;
+    // Ordem do dono: limite de token NUNCA mais encerra a tarefa. Ele espera
+    // o quanto precisar — Esc Esc continua sendo a saída na mão do usuário.
+    // 200 esperas de até 70s são horas: na prática, para quem não apertou
+    // Esc, é "espera até dar".
+    // O teste derruba para 2 via env; em produção são 200.
+    const MAX_ESPERAS = Number(process.env.PRIMOCODE_MAX_ESPERAS || 200);
+    // Rede e 5xx têm teto menor: seis esperas curtas (~1 min) e aí é o
+    // servidor que caiu de verdade, e a pessoa merece saber.
+    const MAX_ESPERAS_REDE = Number(process.env.PRIMOCODE_MAX_ESPERAS_REDE || 6);
+
+    let voltas = 0;
+    const teto = subagent ? MAX_VOLTAS_AGENTE : MAX_ITERATIONS;
+    let avisouTeto = false;
+    if (!subagent) TRABALHANDO = true;
+    try {
+    /* O AGENTE TEM TETO PRÓPRIO. No teste da loja (01/10) o "fechar
+       pendências do painel" passou de 38 voltas lendo o mesmo app.js aos
+       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) {
+            avisouTeto = true;
+            messages.push({ role: 'user', content: `Faltam ${teto - voltas + 1} voltas para o seu limite. Feche o essencial do que foi pedido agora, `
+                + 'prove (rode o teste ou o comando) e chame finish dizendo o que ficou de fora. Nada de polimento extra.' });
+        }
+        // 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
+        // converter") e sai recuado, em cinza, com ✦. Não veio tool nenhuma? É
+        // a RESPOSTA, e sai com ● na cor da marca. Antes tudo saía em branco
+        // no mesmo lugar, e "vou converter" e "pronto, converti" tinham a
+        // mesma cara. A exceção é texto longo: passou do limiar sem tool à
+        // vista, é resposta — e aí volta a correr na tela conforme chega.
+        let fluxo = null;
+
+        emVoo = new AbortController();
+        const tRodada = Date.now();
+        try {
+            let folgado = false;
+            try { folgado = !!require('../../provider/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('../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, 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('../../cli/statusline').registrarModelo(evt.modelo); return; }
+                if (evt.tool_call) {
+                    toolCalls.push(evt.tool_call);
+                    const a = evt.tool_call.arguments || {};
+                    sp.detalhe = `${toolCalls.length} ${toolCalls.length > 1 ? 'ações prontas' : 'ação pronta'} · ${evt.tool_call.name}${a.path ? ' ' + a.path : ''}`;
+                    return;
+                }
+                if (evt.delta) {
+                    assistantText += evt.delta;
+                    sp.detalhe = assistantText.length > 200 ? `${Math.round(assistantText.length / 100) / 10} mil caracteres` : '';
+                    if (!subagent && !toolCalls.length) {
+                        if (!fluxo && assistantText.length > fala.LIMIAR_PENSAMENTO) {
+                            sp.stop();
+                            fluxo = fala.fluxo();
+                            fluxo.escrever(assistantText);
+                        } else if (fluxo) fluxo.escrever(evt.delta);
+                    }
+                }
+                if (evt.assistant_message) assistantText = evt.assistant_message.content || assistantText;
+            });
+        } catch (e) {
+            sp.stop();
+            emVoo = null;
+            traco(`erro na volta ${voltas}: ${String((e && e.message) || e).slice(0, 200)}`);
+            if (fluxo) fluxo.fechar();
+            // Estourou o minuto: encolhe o que já foi feito e CONTINUA, em vez
+            // de devolver erro e jogar fora o trabalho. O usuário não precisa
+            // saber que isso aconteceu — a tarefa é dele, o encanamento é
+            // nosso. E não sabe MESMO: nada disto vai para a tela; o spinner de
+            // pensar segue girando com as frases de sempre.
+            if (ehTetoDeToken(e) && !PARAR && messages.length > 8 && compactacoes < MAX_COMPACTACOES) {
+                compactacoes++;
+                encolherParaContinuar(messages);
+                iteration--;          // esta volta não contou: nada foi decidido
+                continue;
+            }
+            if ((ehTetoDeToken(e) || ehTransitorio(e)) && !PARAR) {
+                const teto = ehTetoDeToken(e) ? MAX_ESPERAS : MAX_ESPERAS_REDE;
+                if (esperas < teto) {
+                    esperas++;
+                    await pausar(esperaDoErro(e, esperas), subagent);
+                    iteration--;
+                    continue;
+                }
+            }
+            if (subagent) return { assistantMessage: { role: 'assistant', content: `Subagente falhou: ${fala.frase(e)}` } };
+            fala.problema(e);
+            throw e;
+        }
+        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; }
+
+        // Chamada de função malformada: o modelo errou a SINTAXE da chamada,
+        // não a tarefa. Repetir a mesma rodada quase sempre resolve — e sem
+        // isto o 400 cru do provedor ("Failed to call a function. Please
+        // adjust your prompt.") caía na tela de quem não tem prompt nenhum
+        // para ajustar.
+        // "failed to parse tool call arguments" é a variante nova do mesmo
+        // tropeço: o provedor recusou o JSON que o MODELO gerou. Medido em
+        // produção num "crie um vídeo" — o documento grande saía torto e o
+        // erro cru parava a tarefa com a corrente inteira ainda de pé.
+        // Tudo o que é encanamento daqui para baixo acontece EM SILÊNCIO: o
+        // tropeço, o encolhimento, a espera. Antes cada um escrevia uma linha
+        // cinza ("o modelo tropeçou", "conversa encolhida (12 → 4)"), e quem
+        // lia via a máquina engasgando no meio do trabalho.
+        if (streamError && /failed to call a function|failed to parse tool call|failed_generation|tool_use_failed/i.test(String(streamError))
+            && funcoesQuebradas < 4 && !PARAR) {
+            funcoesQuebradas++;
+            if (fluxo) fluxo.fechar();
+            iteration--;
+            continue;
+        }
+
+        /* FERRAMENTA FORA DA LISTA DO PEDIDO — recuperável, e antes não era.
+           O provedor recusa com "attempted to call tool 'X' which was not in
+           request.tools" e a rodada morria ali: erro cru em inglês, tarefa
+           perdida antes da primeira ação. Visto em produção num "crie um
+           vídeo para a Paris Group".
+
+           Quem mandou chamar aquilo foi uma instrução NOSSA, de sistema (o
+           gatilho do diretor). Então a cura é tirar a instrução que cita a
+           ferramenta recusada e repetir a rodada: o modelo segue com o que
+           ele realmente tem, e a pessoa recebe o trabalho em vez de um erro.
+           Uma vez por ferramenta — insistindo, o problema é outro. */
+        const foraDaLista = streamError && String(streamError)
+            .match(/attempted to call tool '([^']+)' which was not in request\.tools/i);
+        if (foraDaLista && !PARAR && !toolsRecusadas.has(foraDaLista[1])) {
+            toolsRecusadas.add(foraDaLista[1]);
+            const nome = foraDaLista[1];
+            for (let i = messages.length - 1; i >= 0; i--) {
+                if (messages[i].role === 'system' && String(messages[i].content || '').includes(nome)) {
+                    messages.splice(i, 1);
+                }
+            }
+            messages.push({ role: 'system', content:
+                `A ferramenta "${nome}" NÃO está disponível nesta sessão. Não a chame e não procure `
+                + 'equivalente com outro nome: siga a tarefa com as ferramentas da sua lista. '
+                + 'Se nenhuma delas servir para o que foi pedido, diga isso ao usuário em uma frase, '
+                + 'em vez de desistir sem explicar.' });
+            if (fluxo) fluxo.fechar();
+            iteration--;
+            continue;
+        }
+
+        if (streamError && !PARAR && (ehTetoDeToken(streamError) || ehTransitorio(streamError))) {
+            if (fluxo) fluxo.fechar();
+            // Conversa longa: encolher resolve, porque o peso é o histórico.
+            if (ehTetoDeToken(streamError) && messages.length > 8 && compactacoes < MAX_COMPACTACOES) {
+                compactacoes++;
+                encolherParaContinuar(messages);
+                iteration--;
+                continue;
+            }
+            // Conversa curta: o peso é o MINUTO, não o histórico — as chamadas
+            // anteriores gastaram a cota. Espera a janela virar e repete. O
+            // 5xx e a rede caem no mesmo lugar, com o teto menor.
+            const teto = ehTetoDeToken(streamError) ? MAX_ESPERAS : MAX_ESPERAS_REDE;
+            if (esperas < teto) {
+                esperas++;
+                await pausar(esperaDoErro(streamError, esperas), subagent);
+                iteration--;
+                continue;
+            }
+        }
+
+        if (streamError) {
+            if (fluxo) fluxo.fechar();
+            const amigavel = fala.frase(streamError);
+            if (subagent) return { assistantMessage: { role: 'assistant', content: `Subagente falhou: ${amigavel}` }, concluiu: false };
+            fala.problema(streamError);
+            // concluiu: false — o plano de passos não pode tratar um erro de
+            // provedor como resultado e passá-lo adiante como "fato".
+            return { assistantMessage: { role: 'assistant', content: amigavel }, concluiu: false };
+        }
+
+        // Sem tool_calls: o modelo respondeu e acabou.
+        if (!toolCalls.length) {
+            finalText = assistantText.trim();
+            // Resposta VAZIA não é resposta: sem tool, sem texto e sem erro é
+            // o modelo grátis engasgando. Cair direto no "parei sem concluir"
+            // jogava a tarefa fora quando repetir a MESMA rodada quase sempre
+            // resolve — visto em produção no primeiro pedido de vídeo.
+            if (!finalText && respostasVazias < 3 && !PARAR) {
+                respostasVazias++;
+                // Repetir o MESMO contexto costuma produzir o mesmo vazio: se
+                // o turno anterior já engasgou, o que falta é um empurrão
+                // curto e concreto. A partir da segunda vez, entra um pedido
+                // explícito de fechamento — barato em tokens (é justamente
+                // quando a cota está no fim) e suficiente para o modelo
+                // escrever a resposta ou chamar finish.
+                if (respostasVazias >= 2) {
+                    messages.push({
+                        role: 'user',
+                        content: 'Sua última resposta veio vazia. Não pesquise mais nem explique o processo: '
+                            + 'faça agora a entrega pedida com o que você já tem e finalize.',
+                    });
+                }
+                iteration--;
+                continue;
+            }
+            /* PAROU NO MEIO? Texto de intenção ("agora vou criar…") ou plano
+               com item aberto não é entrega. Em vez de encerrar, a tarefa
+               volta: "isso foi uma promessa — faça". Três empurrões; se
+               depois disso ele insistir em só falar, a resposta é dele. */
+            const pendentes = todosDaTarefa.filter((t) => t.status !== 'completed').length;
+            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);
+                }
+                messages.push({ role: 'assistant', content: finalText });
+                messages.push({
+                    role: 'user',
+                    content: 'Isso foi uma intenção, não uma entrega: você parou no meio. Não narre o próximo '
+                        + 'passo — CHAME a tool agora e siga até o fim'
+                        + (pendentes ? `, o seu plano ainda tem ${pendentes} item(ns) por fazer` : '')
+                        + '. Só pare quando tudo estiver feito, com finish("o que foi feito").',
+                });
+                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('../../plugin/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();
+                if (relato) {
+                    messages.push({ role: 'assistant', content: finalText });
+                    messages.push({
+                        role: 'user',
+                        content: `AINDA NÃO. Abri a página para conferir e ela tem problema:\n${relato}\n\n`
+                            + 'Conserte SÓ o que está apontado, com edit_file no arquivo do erro (leia só ele, se precisar), e finalize de novo.',
+                    });
+                    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) {
+                if (fluxo) fluxo.fechar();
+                else fala.resposta(finalText);
+            }
+            /* Ia terminar, mas chegou recado no meio: a tarefa não acaba com
+               a pessoa esperando resposta. A volta seguinte entrega o recado. */
+            if (!subagent && CAIXA.length && !PARAR) {
+                messages.push({ role: 'assistant', content: finalText });
+                finalText = '';
+                continue;
+            }
+            break;
+        }
+        respostasVazias = 0;
+
+        // O que o modelo disse ANTES de agir é pensamento, e sai como tal.
+        if (!subagent) {
+            if (fluxo) fluxo.fechar();
+            else if (assistantText.trim()) fala.pensamento(assistantText, profundidade);
+        }
+
+        // Registra o turno do assistente COM os tool_calls. A API exige que
+        // cada mensagem role:'tool' venha logo depois deste turno.
+        messages.push({
+            role: 'assistant',
+            content: assistantText || null,
+            tool_calls: toolCalls.map((tc) => ({
+                id: tc.id,
+                type: 'function',
+                function: { name: tc.name, arguments: JSON.stringify(tc.arguments || {}) },
+            })),
+        });
+
+        let finished = null;
+        let algoRodou = false;
+        const tTools = Date.now();
+        const conferindoAntes = msConferindo;
+
+        // ORQUESTRAÇÃO: subagentes da MESMA rodada rodam juntos. O modelo que
+        // pede "3 agentes, um por arquivo" esperava paralelismo e recebia uma
+        // fila — cada subagente só começava quando o anterior terminava, e a
+        // rodada custava a soma dos três. Agora as chamadas spawn_agent da
+        // rodada disparam de uma vez (Promise.all) e cada resultado volta na
+        // posição certa da conversa. Limite de 8 por rodada (era 4: o laço do
+        // Qwen despacha várias direções de uma vez); o excedente roda em série.
+        const spawns = toolCalls.filter((tc) => tc.name === 'spawn_agent');
+        const resultadosSpawn = new Map();
+        if (spawns.length && !PARAR) garantirPasta();
+        /* O plano decide quantos subagentes rodam JUNTOS (lib/config/limites.js; grátis e
+           Primo: um de cada vez, o resto continua em fila). Nunca recusa: só diz o porquê. */
+        const par = spawns.length > 1 ? await limites.paralelo() : null;
+        if (par) { const av = par.aviso(spawns.length); if (av && !avisouParalelo) { avisouParalelo = true; console.log(`  ${av}`); } }
+        if (spawns.length > 1 && par.max > 1 && !PARAR) {
+            const juntos = spawns.slice(0, par.max);
+            fala.paralelo(juntos.length, profundidade);
+            const ids = juntos.map((tc) => anotar(tc, 'permitida'));
+            const rs = await Promise.all(juntos.map((tc) =>
+                runSubagent(tc.arguments || {}, {
+                    server, model, token, projectDir: pastaAtual, projectName, profundidade, motor, permissoes,
+                }).catch((e) => `Subagente falhou: ${e && e.message}`)));
+            juntos.forEach((tc, i) => { resultadosSpawn.set(tc.id, rs[i]); auditoria.depois(ids[i], { ok: true }); });
+        }
+
+        /* LEITURAS JUNTAS. O RITMO pede ao modelo para juntar as ações
+           independentes numa resposta só — e ele junta: três read_file, um
+           grep e uma pesquisa. Só que o laço abaixo rodava uma de cada vez, e
+           a rodada custava a soma. O que só LÊ (não muda arquivo, tela nem
+           conta) roda tudo de uma vez aqui; o laço usa o resultado pronto,
+           passando pelos mesmos freios de sempre (repetição, registro).
+           Só entra no lote o que o laço NÃO vai recusar: a releitura, a
+           mesma leitura duas vezes na resposta e a pesquisa depois de três
+           secas ficam de fora. Senão rodavam aqui e o livro anotava
+           "recusada" para o que já tinha rodado. */
+        const adiantadas = new Map();
+        const chavesDoLote = new Set();
+        const leituras = toolCalls.filter(ehLeitura).filter((tc) => {
+            if (tc.name === 'pesquisar_referencia' && pesquisasSecas >= 3) return false;
+            if (chamadaTorta.ehTorta(tc.arguments)) return false;
+            const { repetida, chave } = repeticao.espiar(jaChamado, tc.name, tc.arguments);
+            if (repetida || chavesDoLote.has(chave)) return false;
+            chavesDoLote.add(chave);
+            return true;
+        });
+        const idsAdiantados = new Map();
+        if (leituras.length > 1 && !PARAR) {
+            leituras.slice(0, 8).forEach((tc) => idsAdiantados.set(tc.id, anotar(tc, 'permitida')));
+            const rs = await Promise.all(leituras.slice(0, 8).map((tc) =>
+                tools.execute(tc.name, tc.arguments, { projectDir: pastaAtual, server, token, api })
+                    .catch((e) => ({ ok: false, error: e && e.message }))));
+            leituras.slice(0, 8).forEach((tc, i) => adiantadas.set(tc.id, rs[i]));
+            traco(`${adiantadas.size} leituras em paralelo`);
+        }
+
+        let motivoTravou = null;
+        for (const tc of toolCalls) {
+            /* O JSON da chamada veio quebrado (lib/chamada-torta.js): a
+               ferramenta não roda, e o modelo recebe o erro com os argumentos
+               crus para se corrigir — em vez de rodar com `{}` e repetir. */
+            if (chamadaTorta.ehTorta(tc.arguments)) {
+                anotar(tc, 'recusada', 'argumentos não são JSON válido');
+                messages.push({ role: 'tool', tool_call_id: tc.id, content: chamadaTorta.erroParaOModelo(tc.name, tc.arguments) });
+                continue;
+            }
+            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 });
+                    continue;
+                }
+                const relato = await conferirPagina();
+                if (relato) {
+                    messages.push({
+                        role: 'tool',
+                        tool_call_id: tc.id,
+                        content: `AINDA NÃO. Abri a página para conferir e ela tem problema:\n${relato}\n\n`
+                            + 'Conserte (leia o arquivo antes de editar) e chame finish de novo.',
+                    });
+                    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!"
+                // sem ter mudado nada. Devolvemos a tarefa para ele.
+                if (falhasPendentes.length && tentativasDeEncerrar < 2) {
+                    tentativasDeEncerrar++;
+                    messages.push({
+                        role: 'tool',
+                        tool_call_id: tc.id,
+                        content: `NÃO terminou. Estas tools falharam e você não corrigiu: ${falhasPendentes.map((f) => f.texto).join('; ')}. `
+                            + 'Conserte agora com edit_file no arquivo que falhou ou, se for impossível, diga claramente ao usuário o que falhou.',
+                    });
+                    continue;
+                }
+                algoRodou = true;
+                finished = comAviso((tc.arguments && tc.arguments.summary) || 'Concluído.');
+                messages.push({ role: 'tool', tool_call_id: tc.id, content: 'ok' });
+                continue;
+            }
+
+            /* TROCAR DE PASTA mora aqui, e não no tools.execute: ela muda
+               `pastaAtual`, que é deste laço, e precisa de quem PERGUNTA ao
+               usuário (o bin). Sem a resposta dele, não troca. */
+            if (tc.name === 'mudar_pasta') {
+                algoRodou = true;
+                fala.acao(tc.name, tc.arguments, profundidade);
+                const idA = anotar(tc, 'permitida');
+                const r = await require('../../outra-pasta.js').pedirTroca(tc.arguments || {}, {
+                    atual: pastaAtual, subagent, trocar: mudarPasta,
+                });
+                if (r.ok) {
+                    pastaAtual = r.caminho;
+                    criarPasta = null;
+                    temPasta = true;
+                }
+                logResult(tc.name, r, profundidade);
+                auditoria.depois(idA, r);
+                repeticao.executou(jaChamado, tc.name, tc.arguments);
+                messages.push({ role: 'tool', tool_call_id: tc.id, content: JSON.stringify(r) });
+                continue;
+            }
+
+            if (tc.name === 'spawn_agent') {
+                algoRodou = true;
+                const idA = resultadosSpawn.has(tc.id) ? null : anotar(tc, 'permitida');
+                const r = resultadosSpawn.has(tc.id)
+                    ? resultadosSpawn.get(tc.id)
+                    : await runSubagent(tc.arguments || {}, {
+                        server, model, token, projectDir: pastaAtual, projectName, profundidade, motor, permissoes,
+                    });
+                if (idA) auditoria.depois(idA, { ok: true });
+                repeticao.executou(jaChamado, tc.name, tc.arguments);
+                messages.push({ role: 'tool', tool_call_id: tc.id, content: r + lembreteDeParalelo(todosDaTarefa, spawns.length) });
+                continue;
+            }
+
+            /* O DIRETOR mora aqui pela mesma razão: ele É uma conversa
+               nova, e quem sabe abrir conversa é este arquivo. */
+            if (tc.name === 'planejar_producao') {
+                algoRodou = true;
+                fala.acao(tc.name, tc.arguments, profundidade);
+                const idA = anotar(tc, 'permitida');
+                const r = await rodarDiretor(tc.arguments || {}, {
+                    server, model, token, projectDir: pastaAtual, projectName, profundidade, motor, permissoes,
+                });
+                logResult(tc.name, r, profundidade);
+                auditoria.depois(idA, r);
+                messages.push({ role: 'tool', tool_call_id: tc.id, content: JSON.stringify(r) });
+                continue;
+            }
+
+            /* O PIPELINE DE QUATRO PAPÉIS mora aqui pelo mesmo motivo que o
+               `spawn_agent`: ele PRECISA rodar agentes, e quem sabe rodar
+               agente é este arquivo. Pôr isto no `tools.execute` obrigaria
+               aquele módulo a conhecer o loop do agente — e um segundo lugar
+               que sabe abrir conversa com o modelo é um segundo lugar para
+               esquecer de passar o token ou a pasta. */
+            if (tc.name === 'construir_app') {
+                algoRodou = true;
+                garantirPasta();
+                fala.acao(tc.name, tc.arguments, profundidade);
+                const idA = anotar(tc, 'permitida');
+                const r = await rodarPipeline(tc.arguments || {}, {
+                    server, model, token, projectDir: pastaAtual, projectName, profundidade, motor, permissoes, livro, autorizar, controle: portaoControle,
+                });
+                logResult(tc.name, r, profundidade);
+                auditoria.depois(idA, r);
+                repeticao.executou(jaChamado, tc.name, tc.arguments);
+                messages.push({ role: 'tool', tool_call_id: tc.id, content: JSON.stringify(r) });
+                if (r && r.ok && catalogo.escreveArquivo(tc.name)) temPasta = true;
+                continue;
+            }
+
+            // Repetiu a mesma chamada? Não executa de novo. Rodar outra vez
+            // gastaria a cota para devolver exatamente o mesmo texto, e é
+            // esse texto que convence o modelo a repetir mais uma vez. Sem
+            // linha na tela: o freio é nosso, não do usuário — o modelo recebe
+            // o aviso e segue, e quem olha vê o trabalho continuar.
+            const eco = repeticao.ver(jaChamado, tc.name, tc.arguments);
+            if (eco.repetida) {
+                voltasEmFalso++;
+                anotar(tc, 'recusada', `repetida (${eco.vezes}ª vez) — não executou de novo`);
+                /* RELER SEM MUDANÇA devolve o que já foi lido, uma vez.
+                   O aviso seco ("o resultado está na conversa acima") mentia
+                   depois do `compactar`: a leitura velha já tinha virado 300
+                   caracteres, e o modelo gastava OUTRA ida ao servidor para
+                   achar o arquivo por outro caminho (um `cat`, um grep). Na
+                   segunda vez vai o conteúdo guardado — ler de novo sem nada
+                   mudar dá o mesmo texto, então não há o que executar. Da
+                   terceira em diante é laço, e o freio segue como era. */
+                const guardado = eco.vezes === 2 && leiturasGuardadas.get(eco.chave);
+                messages.push({ role: 'tool', tool_call_id: tc.id, content: guardado
+                    ? `(sem mudança desde a última leitura — é o mesmo conteúdo; não precisa ler de novo)\n${guardado}`
+                    : eco.aviso });
+                continue;
+            }
+
+            /* Só conta o que passou do freio de repetição: a chamada idêntica
+               já é barrada lá (e a rodada parada desiste sozinha). Aqui entra
+               o que escapa dele — a fatia sobreposta, a volta sem nada novo. */
+            /* VÍDEO SE FAZ NO ESTÚDIO (13/10). Pedida uma animação 3D, o modelo
+               do servidor rodou `primocode video do` e `primocode video help`
+               pelo shell cinco vezes até o freio parar — o editor por linha do
+               tempo é para a GRAVAÇÃO da pessoa, e as ferramentas do Estúdio
+               estavam ali. Fora de edição, a chamada volta com o caminho certo. */
+            if (videoForaDeEdicao(tc.name, tc.arguments, ehEdicaoDaGravacao)) {
+                anotar(tc, 'recusada', 'primocode video fora de edição de gravação');
+                messages.push({ role: 'tool', tool_call_id: tc.id, content: JSON.stringify({ ok: false,
+                    error: '`primocode video` é só para editar uma GRAVAÇÃO da pessoa. Para criar vídeo, animação ou motion: '
+                        + 'estudio_projeto acao:"criar" → estudio_plano com o roteiro → estudio_render.' }) });
+                continue;
+            }
+
+            motivoTravou = motivoTravou || travado.observar(circulo, tc.name, tc.arguments, pastaAtual);
+
+            if (criarPasta && catalogo.criaProjeto(tc.name, tc.arguments)) garantirPasta();
+
+            /* RELER O QUE ACABOU DE ESCREVER. O modelo grátis escreve o
+               index.html e, na volta seguinte, pede para lê-lo "para
+               conferir" — uma ida ao servidor para receber o texto que ele
+               mesmo mandou, e que continua inteiro na chamada write_file dele
+               (o `compactar` só encolhe resultado de ferramenta, nunca o que
+               o modelo escreveu). Se o arquivo está byte a byte como ele
+               deixou, a resposta é essa, sem abrir nada. Depois de um
+               edit_file não vale: aí o texto na conversa está em pedaços. */
+            const relido = tc.name === 'read_file' && tc.arguments && tc.arguments.path
+                ? tc.arguments.path
+                : tc.name === 'run_shell' ? leituraPeloShell(tc.arguments && tc.arguments.command) : null;
+            if (relido && escritosNaTarefa.size) {
+                let igual = false;
+                try {
+                    const abs = require('path').isAbsolute(relido) ? relido : tools.resolveInProject(relido, pastaAtual);
+                    const e = escritosNaTarefa.get(abs);
+                    // Só enquanto a escrita ainda viaja inteira na conversa
+                    // (as duas últimas voltas — ver ESCRITAS_INTEIRAS).
+                    igual = !!e && voltas - e.volta <= 1 && require('fs').readFileSync(abs, 'utf8') === e.texto;
+                } catch { igual = false; }
+                if (igual) {
+                    fala.acao(tc.name, tc.arguments, profundidade);
+                    console.log(fala.resultado(profundidade) + c.muted('igual ao que ele escreveu — não precisou ler'));
+                    messages.push({ role: 'tool', tool_call_id: tc.id, content: JSON.stringify({
+                        ok: true, igualAoQueVoceEscreveu: true,
+                        aviso: 'Este arquivo está EXATAMENTE como você o escreveu nesta tarefa — o conteúdo é o da sua '
+                            + 'chamada write_file acima. Não precisa ler. Para mudar, use edit_file direto; se terminou, siga.',
+                    }) });
+                    continue;
+                }
+            }
+
+            if (tc.name === 'pesquisar_referencia' && pesquisasSecas >= 3) {
+                voltasEmFalso++;
+                anotar(tc, 'recusada', 'três pesquisas seguidas sem fonte');
+                messages.push({
+                    role: 'tool',
+                    tool_call_id: tc.id,
+                    content: 'PARE DE PESQUISAR. Três buscas seguidas não trouxeram fonte nenhuma; '
+                        + 'mais uma vai gastar a cota e devolver o mesmo nada. FAÇA AGORA a entrega '
+                        + 'pedida com o que você já sabe. Se faltar um fato específico (número, data, '
+                        + 'preço, nome de pessoa), NÃO invente: escreva a peça sem ele e avise o '
+                        + 'usuário no final, em uma linha, o que não deu para confirmar.',
+                });
+                continue;
+            }
+
+            /* O PORTÃO do controle do computador. Antes da ação, não depois:
+               depois é o ponteiro já tendo andado. Ler a tela não passa por
+               aqui — ver é o que ele precisa fazer para saber onde clicar. */
+            if (permissao.precisa(tc.name)) {
+                const porta = await permissao.pedir(portaoControle, tc.name, tc.arguments, autorizar);
+                if (!porta.ok) {
+                    anotar(tc, 'recusada', porta.error);
+                    fala.acao(tc.name, tc.arguments, profundidade);
+                    console.log(fala.resultado(profundidade) + c.warn('não autorizado'));
+                    registro.anotar(livro, tc.name, tc.arguments, { ok: false, error: porta.error });
+                    messages.push({ role: 'tool', tool_call_id: tc.id, content: JSON.stringify({ ok: false, error: porta.error }) });
+                    continue;
+                }
+            }
+
+            /* O PORTÃO do que não tem volta (lib/permission/perigo.js). No mesmo lugar do
+               portão do desktop e pelo mesmo motivo: antes, não depois. A
+               resposta mora no mesmo objeto da sessão — quem lembra é ela. */
+            if (!portaoControle.perigo) portaoControle.perigo = perigo.novo();
+            const risco = await perigo.portao(portaoControle.perigo, {
+                modo: permissoes, nome: tc.name, args: tc.arguments,
+                projectDir: pastaAtual, subagent, perguntar: autorizar,
+            });
+            if (!risco.ok) {
+                anotar(tc, 'recusada', risco.motivo || risco.error);
+                fala.acao(tc.name, tc.arguments, profundidade);
+                console.log(fala.resultado(profundidade) + c.warn(`não autorizado — ${risco.motivo}`));
+                registro.anotar(livro, tc.name, tc.arguments, { ok: false, error: risco.error });
+                messages.push({ role: 'tool', tool_call_id: tc.id, content: JSON.stringify({ ok: false, error: risco.error }) });
+                continue;
+            }
+
+            /* Hook PreToolUse (lib/hooks.js): exit 2 bloqueia a ferramenta. */
+            const gancho = hooks.rodar('PreToolUse', { nome: tc.name, args: tc.arguments, projectDir: pastaAtual });
+            if (gancho.bloqueado) {
+                anotar(tc, 'recusada', gancho.motivo);
+                fala.acao(tc.name, tc.arguments, profundidade);
+                console.log(fala.resultado(profundidade) + c.warn(`bloqueado por hook — ${gancho.motivo.slice(0, 80)}`));
+                registro.anotar(livro, tc.name, tc.arguments, { ok: false, error: gancho.motivo });
+                messages.push({ role: 'tool', tool_call_id: tc.id, content: JSON.stringify({ ok: false, error: `Bloqueado por hook: ${gancho.motivo}` }) });
+                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/session/encolheu.js)
+            if (checkpoint.MUDAM_ARQUIVO.has(tc.name)) {
+                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
+               respondia "a transcrição precisa do servidor". */
+            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, 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) {
+                const id = result.id || (result.projeto && result.projeto.id) || (tc.arguments && tc.arguments.id);
+                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('../../plugin/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));
+            }
+            if (tc.name === 'write_todos' && result && Array.isArray(result.todos)) todosDaTarefa = result.todos;
+            if (/^(write_file|edit_file|multi_edit)$/.test(tc.name) && tc.arguments && tc.arguments.path) {
+                try {
+                    const abs = tools.resolveInProject(tc.arguments.path, pastaAtual);
+                    if (tc.name === 'write_file' && result && result.ok !== false && typeof tc.arguments.content === 'string') {
+                        escritosNaTarefa.set(abs, { texto: tc.arguments.content, volta: voltas });
+                    } else escritosNaTarefa.delete(abs);
+                } catch { /* caminho inválido: a tool já recusou */ }
+            }
+            // Além de narrar, ANOTA: no fim do pedido sai o balanço do que
+            // nasceu, mudou, rodou e falhou. Narrar sozinho não basta — numa
+            // tarefa de trinta ações, a primeira já saiu da tela.
+            registro.anotar(livro, tc.name, tc.arguments, result);
+            if (result && result.ok !== false && catalogo.criaProjeto(tc.name, tc.arguments)
+                && /\.(html?|css|m?jsx?|tsx?|vue|svelte)$/i.test(String((tc.arguments && tc.arguments.path) || ''))) {
+                mexeuNaPagina = true;
+                /* O NAVEGADOR ESCONDIDO SOBE AGORA, e não no `finish`.
+                   A conferência só roda quando o agente diz "pronto", e até
+                   lá ainda há pelo menos uma rodada do modelo. Subir o Chrome
+                   ali, em paralelo com ela, tira do "pronto" o tempo de ligar
+                   o navegador e de fazer a PRIMEIRA navegação dele, que é a
+                   parte cara (ver `aquecerRevisor` em lib/browser.js). Medido
+                   em 24/09: a conferência num Chrome recém-aberto levava de
+                   2,1 a 4,6s; aquecido antes, 1,24s — que é o assentar de
+                   1,2s, e nada mais. Sem `await` e sem erro: se não subir, a
+                   conferência tenta de novo e diz o que houve. */
+                if (aquecerPagina && !subagent && conferencias < 2) {
+                    try { Promise.resolve(aquecerPagina()).catch(() => {}); } catch { /* segue */ }
+                }
+            }
+
+            // Uma escrita bem-sucedida limpa a dívida — mas só a do MESMO
+            // arquivo. Escrever algo sem relação (ou um run_shell qualquer)
+            // não corrige um teste quebrado noutro lugar; antes isto zerava
+            // a lista inteira e o agente conseguia dizer "concluído" com uma
+            // falha real ainda pendente.
+            if (tc.name === 'pesquisar_referencia') {
+                if (result && result.ok === false) pesquisasSecas++;
+                else pesquisasSecas = 0;      // achou fonte: o ciclo se rompeu
+            }
+
+            if (result && result.ok === false) {
+                const cmd = tc.name === 'run_shell' ? String(tc.arguments?.command || '') : '';
+                falhasPendentes.push({
+                    tool: tc.name,
+                    alvo: tc.arguments?.path || '',
+                    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.
+                //
+                // Antes só write_file/edit_file limpavam, e por caminho. Uma
+                // falha já superada continuava bloqueando o finish para sempre:
+                // medido num pedido real, o browser_read errou o seletor
+                // ("main"), acertou na tentativa seguinte lendo 5.240 chars — e
+                // mesmo assim a tarefa morreu com "Parei sem concluir. A última
+                // falha foi: browser_read()". Acertar depois de errar é
+                // 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;
+                });
+                falhasPendentes.length = 0;
+                falhasPendentes.push(...sobrou);
+            }
+
+            messages.push({ role: 'tool', tool_call_id: tc.id, content: summarizeForModel(result) });
+        }
+
+        // A conferência da página tem linha própria: aqui fica só o resto.
+        tempos.somar('ferramentas', Date.now() - tTools - (msConferindo - conferindoAntes));
+
+        /* ANDANDO EM CÍRCULO (lib/travado.js): a primeira vez, um empurrão
+           com o que ele está repetindo; a segunda, para — antes da cota. */
+        const giro = travado.fimDaVolta(circulo);
+        const travou = finished ? null : travado.decidir(circulo, motivoTravou || giro);
+        if (travou && travou.acao === 'empurrar') {
+            traco(`travado: ${motivoTravou || giro}`);
+            messages.push({ role: 'user', content: travou.texto });
+        } else if (travou) {
+            paradoPorTravar = travou.texto;
+            break;
+        }
+
+        // Uma volta inteira sem executar nada é o modelo preso. Insistir custa
+        // um pedido ao servidor por volta, e as 15 voltas saíam caras para
+        // terminar no mesmo lugar — melhor parar e devolver a vez ao usuário.
+        if (!algoRodou && toolCalls.length) {
+            rodadasParadas++;
+            /* Antes de desistir, UMA troca de rota, sem aparecer na tela. Parar
+               aqui devolvia ao usuário o trabalho de dividir a tarefa — que é
+               justamente o que ele não sabe fazer e o sistema sabe: o que já
+               foi feito está na conversa, e o que falta é outro caminho. */
+            if (rodadasParadas >= MAX_RODADAS_PARADAS && !trocouDeRota) {
+                trocouDeRota = true;
+                rodadasParadas = 0;
+                messages.push({ role: 'user', content: TROCA_DE_ROTA });
+                continue;
+            }
+            // Quem fala é o motivoDaParada, uma vez só — aqui havia uma
+            // segunda frase de "travei", e as duas saíam em sequência.
+            if (rodadasParadas >= MAX_RODADAS_PARADAS) break;
+        } else {
+            rodadasParadas = 0;
+        }
+
+        if (finished) {
+            finalText = finished;
+            if (!subagent) fala.resposta(finished);
+            // Recado chegou enquanto ele fechava: entrega e segue.
+            if (!subagent && CAIXA.length && !PARAR) { finalText = ''; continue; }
+            break;
+        }
+    }
+    } finally {
+        if (!subagent) TRABALHANDO = false;
+    }
+
+    // O que o modelo entregou por vontade própria, ANTES dos textos de
+    // desistência. É esta a diferença que o plano de passos precisa: um passo
+    // que "parou sem concluir" não pode virar fato para o passo seguinte.
+    const concluiu = Boolean(finalText) && !PARAR;
+
+    let passagemDaParada = null;
+    if (paradoPorTravar && !finalText) {
+        finalText = paradoPorTravar;
+        if (!subagent) fala.aviso(finalText);
+        // Parou sem terminar: a memória leva o estado, não só "parei" (lib/passagem.js).
+        passagemDaParada = require('../../passagem').montar({ pedido: userPrompt, motivo: finalText, registro: livro, falhasPendentes });
+    }
+
+    if (PARAR && !finalText) {
+        finalText = 'Parado por você (Esc Esc). O que já foi feito, ficou feito.';
+        if (!subagent) fala.aviso(finalText);
+    }
+
+    // Nunca terminar em silêncio. Quando o modelo devolvia resposta vazia sem
+    // chamar tool, o usuário via a tela parar e mais nada — pior que erro, porque
+    // não dá nem para saber que acabou. Medido: um pedido de navegador morria assim
+    // depois de a primeira tentativa de seletor falhar.
+    if (!finalText) {
+        finalText = motivoDaParada({ voltas, voltasEmFalso, falhasPendentes, travou: rodadasParadas >= MAX_RODADAS_PARADAS, teto });
+        if (!subagent) fala.aviso(finalText);
+        passagemDaParada = require('../../passagem').montar({ pedido: userPrompt, motivo: finalText, registro: livro, falhasPendentes });
+    }
+
+    // Nada de arquivo mexido = nada para lembrar. E grava em `pastaAtual`, não em
+    // `projectDir`: quando a pasta do projeto nasceu no meio do caminho, a memória
+    // precisa ir para ela, não para a raiz onde a sessão começou.
+    //
+    // `projectName` NÃO entra na condição: ele só rotula a memória no prompt
+    // (buildMemoryContext), e sessão sem projeto nomeado (ex.: primeiro pedido
+    // antes de /project) tem `projectName` undefined mesmo já tendo mexido em
+    // arquivo de verdade — a memória era descartada nesse caso, sempre.
+    // A raiz de trabalho não é projeto: um memory.md solto em ~/primocode
+    // era o que um pedido de vídeo (que trabalha na raiz) deixava para trás.
+    if (!subagent && temPasta && require('path').resolve(pastaAtual) !== require('path').resolve(cfg.ROOT_DIR)) {
+        cfg.appendProjectMemory(pastaAtual, passagemDaParada || `**Pedido:** ${userPrompt.slice(0, 300)}\n**Resultado:** ${finalText.slice(0, 500)}`);
+    }
+
+    // A memória GERAL é gravada sempre, tenha havido pasta ou não.
+    //
+    // Antes ela só era escrita se o agente chamasse `remember_general` — e ele
+    // quase nunca chamava. Pior: a memória de projeto acima depende de
+    // `temPasta`, e tarefa de estúdio (vídeo, slides) não cria pasta nenhuma.
+    // Resultado prático: quem só fazia vídeo NUNCA teve memória gravada, de
+    // tipo nenhum. O usuário notou: "nunca atualiza os arquivos de memória, e
+    // ela deve atualizar independente do projeto".
+    //
+    // Fica curto de propósito — isto entra em todo pedido seguinte. Uma linha
+    // por tarefa concluída, e podada por config.js quando passa do limite.
+    if (!subagent && concluiu && finalText.trim()) {
+        const pedido = userPrompt.replace(/\s+/g, ' ').trim().slice(0, 160);
+        const feito = finalText.replace(/\s+/g, ' ').trim().slice(0, 240);
+        cfg.appendGeneralMemory(`- **${pedido}** → ${feito}`);
+    }
+
+    return {
+        userMessage: { role: 'user', content: userPrompt },
+        assistantMessage: { role: 'assistant', content: finalText },
+        registro: livro,
+        // Esc Esc no meio de um plano de vários passos precisa parar o plano
+        // INTEIRO, não só o passo — senão o próximo passo começa logo depois
+        // de o usuário ter mandado parar.
+        parado: PARAR,
+        concluiu,
+        // Onde terminou: o mudar_pasta pode ter trocado no meio.
+        pasta: pastaAtual,
+        // O projeto do Estúdio em que se mexeu, para a memória ir para a pasta dele.
+        estudio: estudioDaTarefa,
+    };
+}
+
+async function runSubagent(args, ctx) {
+    const { server, model, token, projectDir, projectName, profundidade, motor, permissoes } = ctx;
+    const descricao = args.description || 'sub-tarefa';
+
+    if (profundidade + 1 >= MAX_PROFUNDIDADE) {
+        return 'Recusado: subagente não pode criar outro subagente. Faça você mesmo.';
+    }
+    if (!args.prompt) return 'Recusado: prompt do subagente vazio.';
+
+    // 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.
+    // 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').refinar(args.especialista, args.prompt);   // o catálogo confere o chute do modelo
+    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);
+
+    // modelo_sugerido do briefing vale quando o placar ainda não tem dado desse tipo de tarefa.
+    let modeloDoAgente = model;
+    if (novos.length) {
+        let temDado = false;
+        try {
+            const P = require('../../placar.js');
+            temDado = Object.values(P.ler().tipos[P.classificar(args.prompt)] || {}).some((c) => (c.ganhos || 0) + (c.perdas || 0) >= P.MIN_AMOSTRAS);
+        } catch { /* sem placar: sem dado */ }
+        modeloDoAgente = agentes.modeloPara(novos, model, { placarTemDados: temDado });
+    }
+    const r = await runAct(novos.length ? agentes.montarTarefa(novos, args.prompt) : especialistas.montarTarefa(esp, args.prompt), {
+        server, model: modeloDoAgente, token, projectDir, projectName,
+        history: [],
+        profundidade: profundidade + 1,
+        subagent: true,
+        motor,
+        permissoes,
+        autorizar: ctx.autorizar,
+        controle: ctx.controle,   // o mesmo objeto: a resposta vale para todos
+        rotulo: `subagente: ${String(descricao).slice(0, 60)}`,
+    });
+
+    /* O que o subagente fez entra no livro de quem o chamou. Sem isto, o
+       balanço no fim mentiria por omissão: o especialista escreveu cinco
+       arquivos e a tela diria "nenhum arquivo". A conversa dele continua
+       separada — o que se junta é o registro do que aconteceu no disco. */
+    if (ctx.livro && r.registro) registro.juntar(ctx.livro, r.registro);
+
+    const resumo = r.assistantMessage.content || 'sem resultado';
+    fala.agenteVoltou(resumo, profundidade);
+    return entregaDoAgente(rot, resumo, r.registro, { pasta: projectDir });
+}
+
+/* UM AGENTE DE CADA VEZ é o padrão do modelo grátis: no teste da loja
+   (API + site + painel, 01/10) ele despachou os três em fila — 6 + 8 + 5
+   minutos — quando o site e o painel só dependiam do contrato, que já
+   existia. Quem decide continua sendo ele; a volta só lembra que as partes
+   que faltam podem ir JUNTAS. Pura. */
+function lembreteDeParalelo(todos, naRodada) {
+    const faltam = (todos || []).filter((t) => t && t.status !== 'completed' && t.status !== 'concluida');
+    if (naRodada > 1 || faltam.length < 2) return '';
+    return `\n\n(Faltam ${faltam.length} partes do plano. As que não dependem uma da outra vão JUNTAS: `
+        + 'vários spawn_agent na MESMA resposta rodam em paralelo.)';
+}
+
+/* O SALTO ENTRE AGENTES. O pai recebia só o texto final do especialista —
+   "pronto, fiz a API" — e, para passar a vez ao próximo (o do front, o
+   revisor), tinha de adivinhar o que existia. Agora a volta é uma ENTREGA:
+   quem fez, o que disse, os arquivos que nasceram e mudaram, os comandos, o
+   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, { 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);
+        lista('alterou', reg.alterados);
+        lista('rodou', (reg.comandos || []).map((x) => `${x.comando}${x.ok === false ? ` (saiu ${x.code})` : ''}`));
+        lista('testes', (reg.testes || []).map((x) => `${x.comando}: ${x.ok ? 'passou' : 'FALHOU'}`));
+        if (reg.falhas && reg.falhas.length) linhas.push('FALHOU: ' + reg.falhas.slice(0, 6).map((f) => `${f.acao} ${f.alvo}: ${f.motivo}`.slice(0, 200)).join(' | '));
+    }
+    linhas.push(reg && ((reg.falhas && reg.falhas.length) || (reg.testes || []).some((x) => !x.ok))
+        ? 'PRÓXIMO: há falha acima — mande de volta para conserto (spawn_agent com o erro no prompt) ou conserte você, antes de seguir.'
+        : 'PRÓXIMO: se outra parte depende desta, passe a vez (spawn_agent) com esta entrega no prompt; senão, confira e siga.');
+    return linhas.join('\n');
+}
+
+/* ══ O PIPELINE DE QUATRO PAPÉIS ═══════════════════════════════════════════
+ *
+ *   "Engenheiro de Prompt → Construtor 1 (protótipo) → Construtor 2 (MVP) →
+ *    Revisador (testa ocultamente) → loop de correção → abre no navegador."
+ *
+ * As regras dos papéis, os prompts e o revisor que abre a página moram em
+ * `pipeline.js`, que não conhece o loop do agente. O que esta função faz é a
+ * costura: dar a ele uma forma de RODAR um agente, uma de escrever na tela e
+ * uma de abrir o navegador da pessoa.
+ *
+ * Cada papel roda com `history: []` — conversa própria, sem ver a do usuário
+ * nem a do papel anterior. É essa separação que faz o revisor valer alguma
+ * coisa: quem acabou de escrever o código é o pior revisor dele, porque lê o
+ * que quis escrever em vez do que escreveu.
+ */
+/**
+ * O DIRETOR: estrutura antes de alguém produzir.
+ *
+ * Por que uma conversa PRÓPRIA, e não mais um parágrafo no prompt de quem
+ * produz: o modelo que está montando as cenas já gastou a atenção dele em
+ * JSON — fonte, cor, duração, posição — e é ali que o roteiro morre. Vira
+ * legenda do que aparece na tela ("Vantagens", "Nossos serviços"), sem arco,
+ * sem narração escrita, sem decisão de voz. O diretor não vê JSON de cena
+ * nenhum: ele decide o que se conta, em que ordem, em quantos segundos, com
+ * que voz e com que direção de arte. Depois disso o produtor tem pouco a
+ * inventar — e inventar é onde ele erra.
+ */
+async function rodarDiretor(args, ctx) {
+    const { server, model, token, projectDir, projectName, profundidade, motor, permissoes } = ctx;
+    if (profundidade > 0) {
+        return { ok: false, error: 'Recusado: o diretor não roda dentro de um subagente. '
+            + 'Produza com o plano que você já recebeu.' };
+    }
+    const diretor = require('../../plugin/estudio/diretor.js');
+    const correr = async (prompt, rotulo) => {
+        if (PARAR) return '';
+        fala.agente('Diretor', rotulo, profundidade);
+        const r = await runAct(prompt, {
+            server, model, token, projectDir, projectName,
+            history: [], profundidade: profundidade + 1, subagent: true, motor, permissoes,
+        });
+        return (r && r.assistantMessage && r.assistantMessage.content) || '';
+    };
+
+    const r = await diretor.planejar({
+        pedido: args.pedido || args.prompt || '',
+        segundos: Number(args.segundos) || 30,
+        formato: args.formato === 'apresentacao' ? 'apresentacao' : 'video',
+        contexto: args.contexto || '',
+        correr,
+        mostrar: (t) => fala.agente('Diretor', t, profundidade),
+    });
+    if (!r.ok) return r;
+
+    /* A PAUTA é o que volta para o produtor, não o JSON cru. O JSON cru
+       convida a copiar campo por campo para dentro do plano de cena — e aí o
+       "fundo": "verde descendo" viraria uma string num lugar que espera cor.
+       A pauta é prosa: o produtor LÊ e compõe com os primitivos que ele tem. */
+    return {
+        ok: true,
+        aprovado: r.aprovado,
+        defeitos: r.defeitos.length ? r.defeitos : undefined,
+        pauta: diretor.pauta(r.plano),
+        voz: r.plano.voz,
+        midia: r.plano.midia,
+        trilha: r.plano.trilha,
+        segundos: r.plano.segundos,
+        proporcao: r.plano.proporcao,
+    };
+}
+
+async function rodarPipeline(args, ctx) {
+    const { server, model, token, projectDir, projectName, profundidade, motor, permissoes } = ctx;
+    if (profundidade > 0) {
+        return { ok: false, error: 'Recusado: o pipeline não roda dentro de um subagente — '
+            + 'os papéis dele já são subagentes. Faça a parte que te cabe.' };
+    }
+
+    const pipeline = require('../../pipeline.js');
+    const path = require('path');
+    const pedido = args.pedido || args.prompt || '';
+    const base = projectDir || cfg.ROOT_DIR;
+    /* Dentro de um projeto, o app é montado NA pasta dele. A subpasta com
+       nome derivado do pedido só vale na raiz: era ela que fazia o app nascer
+       num lugar que a conversa nunca mais achava. */
+    const naRaiz = path.resolve(base) === path.resolve(cfg.ROOT_DIR);
+    const pasta = args.pasta
+        ? path.resolve(base, args.pasta)
+        : (naRaiz ? pipeline.pastaPara(pedido, base) : base);
+
+    const correr = async (prompt, rotulo) => {
+        if (PARAR) return '';
+        fala.agente('Agente', rotulo, profundidade);
+        const r = await runAct(prompt, {
+            server, model, token, projectDir: pasta, projectName,
+            history: [], profundidade: profundidade + 1, subagent: true, motor, permissoes,
+        });
+        return (r && r.assistantMessage && r.assistantMessage.content) || '';
+    };
+
+    return pipeline.construir({
+        pedido,
+        pasta,
+        rodadas: args.rodadas,
+        correr,
+        mostrar: (linha) => console.log(fala.resultado(profundidade) + c.muted(linha)),
+        abrir: tools.openInBrowser,
+    });
+}
+
+/**
+ * Portão de prova fresca: marca a edição de código e o comando rodado, nessa
+ * ordem. `barrar()` devolve a frase de "AINDA NÃO" (uma vez só) quando o
+ * último código editado não tem comando depois dele; senão null. Página
+ * (html/css) fica com o conferirPagina.
+ */
+const CODIGO = /\.(m?[jt]sx?|cjs|py|rb|go|rs|java|php|sh|c|cpp|cs)$/i;
+function novoPortaoDeProva() {
+    let seq = 0, edicao = 0, rodou = 0, avisou = false;
+    return {
+        ver(tc) {
+            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' || 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;
+            return 'AINDA NÃO: você editou código e não rodou nada depois. Rode o teste ou o comando que prova '
+                + 'que funciona, leia o resultado e chame finish de novo (ou diga o que não conseguiu conferir).';
+        },
+    };
+}
+
+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 };