primocode 11.0.0 → 11.2.0

package/lib/act.js

@@ -1,2512 +0,0 @@
-// 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('./ui');
-const fala = require('./fala');
-const especialistas = require('./especialistas');
-const limites = require('./limites');
-let avisouParalelo = false;
-const tools = require('./tools');
-const api = require('./api');
-const cfg = require('./config');
-const catalogo = require('./catalogo');
-const repeticao = require('./repeticao');
-const diff = require('./diff');
-const registro = require('./registro');
-const permissao = require('./permissao');
-const perigo = require('./perigo');
-const skills = require('./skills');
-const checkpoint = require('./checkpoint');
-const 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('./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('./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.js).
-    try { const m = require('./mcp.js').dica(projectDir); if (m) parts.push(m); } catch { /* sem mcp */ }
-    // A equipe calada (lib/personas.js): o olhar do especialista que o pedido pede.
-    const equipe = require('./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/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/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('./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/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('./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('./comandos.js').carregar({ projectDir }); } catch { /* disco estranho não trava o pedido */ }
-        pedido = `${require('./nomes.js').menuParaIA({ dela })}\n\n${pedido}`;
-        /* OS KITS DE ESTILO DE MOTION (lib/kits.js): um turno novo por pedido da pessoa (o `kit fazer` só
-           passa depois que ela respondeu ao cartão) e o menu dos kits. A IA escolhe o kit; o "parece motion"
-           só decide se vai o menu inteiro ou uma linha. */
-        try {
-            const kits = require('./kits.js');
-            kits.novoTurno();
-            const cabeca = kits.cabecaDoPedido(userPrompt, { projectDir });
-            // o vídeo esperando o sim vai colado na resposta da pessoa (é dela que a IA decide); o menu, na frente
-            if (cabeca && /^\[VÍDEO (ESPERANDO|SENDO MONTADO)/.test(cabeca) && pedido.endsWith(userPrompt)) pedido = `${pedido.slice(0, pedido.length - userPrompt.length)}${cabeca}\n\nRESPOSTA DA PESSOA: ${userPrompt}`;
-            else if (cabeca) pedido = `${cabeca}\n\n${pedido}`;
-        } catch { /* pacote sem kits: segue */ }
-        if (instrucao) pedido = `${instrucao}\n\nPEDIDO: ${pedido}`;
-    }
-    let voltasEmFalso = 0;
-    // 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('./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/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/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/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('./local/provedor.js').atual(); } catch { /* sem provedor próprio */ }
-            /* RESUMO AUTOMÁTICO (lib/session/compactacao.js): passou de ~80% da janela do modelo → as voltas antigas viram
-               um resumo feito pelo modelo (objetivo, decisões, arquivos, to-dos). Só depois o compactar() encolhe o resto. */
-            if (voltas - voltaDoResumo >= 3) {
-                try {
-                    const comp = require('./session/compactacao');
-                    if (comp.precisaCompactar(messages, { janela: comp.janelaDe(ultimoModelo) })) {
-                        voltaDoResumo = voltas;
-                        const r = await comp.compactarMensagens(messages, {
-                            todos: todosDaTarefa,
-                            resumir: ({ resumo, mensagens }, todos) => comp.resumirComFatos({ resumo, mensagens },
-                                (p) => motor.requestResumo(server, { ...p, token }).then((x) => x && x.resumo), todos),
-                        });
-                        if (r.ok) console.log(ident(profundidade) + c.dim(`  ⎿ conversa passou de 80% da janela: ${r.resumidas} mensagens viraram resumo (${r.antes} → ${r.depois} tokens)`));
-                    }
-                } catch { /* resumo é economia, não requisito */ }
-            }
-            const enviadas = compactar(messages, { folgado });
-            traco(`volta ${voltas}${subagent ? ' (agente)' : ''} · ${enviadas.length} mensagens · ${JSON.stringify(enviadas).length} caracteres`);
-            await motor.requestAct(server, { messages: enviadas, model, preferido: preferido || undefined, effort, token, projectDir: pastaAtual, projectName, subagent, sinal: emVoo.signal }, (evt) => {
-                if (evt.erro) { streamError = folgado ? evt.erro : erroDaCorrente(evt.erro); return; }
-                if (evt.modelo) { modeloDaVolta = evt; ultimoModelo = evt.modelo; if (sinais) sinais.modelo = evt.modelo; require('./statusline').registrarModelo(evt.modelo); return; }
-                if (evt.tool_call) {
-                    toolCalls.push(evt.tool_call);
-                    const a = evt.tool_call.arguments || {};
-                    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('./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/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/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/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('./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').resolver(args.especialista);
-    const esp = novos.length ? null : especialistas.escolher(args.especialista, args.prompt);
-    const agentes = require('./agentes');
-    const rot = novos.length ? agentes.rotulo(novos) : especialistas.rotulo(esp);
-    fala.agente(rot, descricao, profundidade);
-
-    const r = await runAct(novos.length ? agentes.montarTarefa(novos, args.prompt) : especialistas.montarTarefa(esp, args.prompt), {
-        server, model, token, projectDir, projectName,
-        history: [],
-        profundidade: profundidade + 1,
-        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('./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 };