primocode 9.10.0 → 10.0.9

package/lib/act.js

@@ -31,6 +31,7 @@ const preLeitura = require('./pre-leitura');
 // 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;
@@ -39,6 +40,10 @@ 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', 'estudio_site']);
+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
@@ -55,6 +60,44 @@ function interromper() {
     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"?
  *
@@ -138,9 +181,6 @@ function limparParaOModelo(result) {
 
 function logResult(kind, result, profundidade) {
     const p = fala.resultado(profundidade);
-    // A linha da janela (lib/app.js) fecha aqui: o mesmo resultado que o
-    // terminal desenha embaixo, resumido. Ver o canal em lib/fala.js.
-    fala.avisar('resultado', fala.resumoDoResultado(kind, result));
     if (!result) return;
     // Uma tool que falhou é informação para o AGENTE, que vai consertar na
     // volta seguinte — não é o erro do usuário. Âmbar, uma linha, sem o
@@ -221,9 +261,12 @@ function logResult(kind, result, profundidade) {
         case 'browser_open':
             console.log(p + c.muted(result.url || 'aberto'));
             return;
-        case 'browser_read':
-            console.log(p + c.muted(`${(result.text || '').length} caracteres lidos da página`));
+        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)) {
@@ -298,6 +341,50 @@ const RESTO_DO_RESULTADO = 300;
 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.
  *
@@ -322,11 +409,13 @@ function compactar(messages) {
 
     const indices = [];
     for (let i = 0; i < messages.length; i++) if (messages[i].role === 'tool') indices.push(i);
-    if (indices.length <= RESULTADOS_INTEIROS && !duplicadas.size) return messages;
+    if (indices.length <= RESULTADOS_INTEIROS && !duplicadas.size && !assistentesAntigas(messages).size) return messages;
 
     const chamadas = repeticao.chamadasPorId(messages);
     const encolher = new Set(indices.slice(0, -RESULTADOS_INTEIROS));
+    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)' };
         }
@@ -383,10 +472,21 @@ function esperaDoErro(e, tentativa = 0) {
     return Math.min(20, 3 * 2 ** Math.max(0, tentativa - 1)) * 1000;
 }
 
-/** Espera com o spinner de PENSAR girando — nunca um de "limite" ou
- *  "continuando em Ns". Quem olha vê o Primo pensando um pouco mais, e só. */
+/** 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) {
-    const sp = subagent ? null : new Spinner(PENSANDO).start();
+    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);
@@ -431,7 +531,7 @@ const TROCA_DE_ROTA = 'Você ficou três voltas sem conseguir rodar nada, repeti
     + '(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 }) {
+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}`;
     }
@@ -439,11 +539,11 @@ function motivoDaParada({ voltas, voltasEmFalso, falhasPendentes, 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 >= MAX_ITERATIONS) {
+    if (voltas >= teto) {
         const emFalso = voltasEmFalso
             ? ` ${voltasEmFalso} ${voltasEmFalso === 1 ? 'chamada foi repetida' : 'chamadas foram repetidas'} e não rodaram de novo.`
             : '';
-        return `Usei as ${MAX_ITERATIONS} voltas deste pedido sem chegar ao fim.${emFalso}`
+        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.';
@@ -487,6 +587,69 @@ function mapaDoProjeto(dir, limite = 80, achados = arquivosDoProjeto(dir, limite
     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). */
+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'
+    + '- 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.';
+
+/* 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.';
+
 /* `pedido` é opcional: com ele, o arquivo citado no pedido é o primeiro a
    entrar já lido (ver lib/pre-leitura.js). */
 function buildMemoryContext(projectDir, projectName, pedido = '') {
@@ -505,6 +668,12 @@ function buildMemoryContext(projectDir, projectName, pedido = '') {
     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);
+    // 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');
 }
 
@@ -584,10 +753,12 @@ async function runAct(userPrompt, opts) {
         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 {
-            fala.pensamento('abrindo a página para conferir antes de entregar', profundidade);
             medida = await medirPagina(pastaAtual);
-        } catch { medida = null; }
+        } catch { medida = null; } finally { sp.stop(); }
         msConferindo += Date.now() - t;
         tempos.somar('conferir página', Date.now() - t);
         if (!medida || !medida.testou) return null;
@@ -602,6 +773,9 @@ async function runAct(userPrompt, opts) {
     const jaChamado = repeticao.novo();
     // 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
@@ -625,12 +799,9 @@ async function runAct(userPrompt, opts) {
      * não é uma opção num plano limitado por token. */
     let pedido = userPrompt;
     if (!subagent) {
-        const comSkills = skills.montar(userPrompt);
+        const comSkills = skills.cardapio(userPrompt);
         pedido = comSkills.texto;
         if (instrucao) pedido = `${instrucao}\n\nPEDIDO: ${pedido}`;
-        if (comSkills.skills.length) {
-            fala.pensamento(`seguindo: ${comSkills.skills.map((s) => s.titulo).join(', ')}`, profundidade);
-        }
     }
     let voltasEmFalso = 0;
     // Pesquisas que voltaram de mãos vazias. A partir da terceira, a tool
@@ -653,9 +824,10 @@ async function runAct(userPrompt, opts) {
     if (!subagent) {
         const memory = buildMemoryContext(projectDir, projectName, userPrompt);
         if (memory) messages.push({ role: 'system', content: `Memória persistente:\n\n${memory}` });
-        for (const m of (history || []).slice(-20)) {
-            if (m && m.role && m.content) messages.push({ role: m.role, content: m.content });
-        }
+        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
@@ -676,8 +848,20 @@ async function runAct(userPrompt, opts) {
      * 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 producao = require('./estudio/diretor.js').precisaDeProducao(pedido);
-        if (producao.producao) {
+        const diretor = require('./estudio/diretor.js');
+        const producao = diretor.precisaDeProducao(pedido);
+        if (diretor.precisaDeEdicao(pedido)) {
+            // A gravação da pessoa: o editor por linha do tempo (lib/video/), pelo run_shell.
+            messages.push({ role: 'system', content: 'PARA EDITAR A GRAVAÇÃO DA PESSOA use o editor por linha do tempo via run_shell: '
+                + 'SE A PESSOA SÓ DISSE "edite esse vídeo" (sem dizer o quê), O VÍDEO É O PEDIDO: `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. '
+                + 'Senão: '
+                + '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'
+                + '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.
 
@@ -697,8 +881,14 @@ async function runAct(userPrompt, opts) {
                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:
-                `ESTE PEDIDO É DE PRODUÇÃO (formato "${producao.formato === 'apresentacao' ? 'slides' : 'video'}"). Faça em três passos: `
+                '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. '
@@ -749,8 +939,25 @@ async function runAct(userPrompt, opts) {
     const MAX_ESPERAS_REDE = Number(process.env.PRIMOCODE_MAX_ESPERAS_REDE || 6);
 
     let voltas = 0;
-    for (let iteration = 0; iteration < MAX_ITERATIONS && !PARAR; iteration++) {
+    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. */
+    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);
         const sp = new Spinner(subagent ? 'subagente trabalhando' : PENSANDO).start();
 
         const toolCalls = [];
@@ -769,11 +976,19 @@ async function runAct(userPrompt, opts) {
         emVoo = new AbortController();
         const tRodada = Date.now();
         try {
-            await motor.requestAct(server, { messages: compactar(messages), model, effort, token, projectDir: pastaAtual, projectName, subagent, sinal: emVoo.signal }, (evt) => {
+            const enviadas = compactar(messages);
+            traco(`volta ${voltas}${subagent ? ' (agente)' : ''} · ${enviadas.length} mensagens · ${JSON.stringify(enviadas).length} caracteres`);
+            await motor.requestAct(server, { messages: enviadas, model, effort, token, projectDir: pastaAtual, projectName, subagent, sinal: emVoo.signal }, (evt) => {
                 if (evt.erro) { streamError = evt.erro; return; }
-                if (evt.tool_call) { toolCalls.push(evt.tool_call); 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();
@@ -787,6 +1002,7 @@ async function runAct(userPrompt, opts) {
         } 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
@@ -814,6 +1030,7 @@ async function runAct(userPrompt, opts) {
         }
         sp.stop();
         emVoo = null;
+        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; }
 
@@ -956,7 +1173,7 @@ async function runAct(userPrompt, opts) {
                     messages.push({
                         role: 'user',
                         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 finalize de novo.',
+                            + 'Conserte SÓ o que está apontado, com edit_file no arquivo do erro (leia só ele, se precisar), e finalize de novo.',
                     });
                     finalText = '';
                     continue;
@@ -967,6 +1184,13 @@ async function runAct(userPrompt, opts) {
                 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;
@@ -999,13 +1223,13 @@ async function runAct(userPrompt, opts) {
         // 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 4 por rodada: acima disso é
-        // sinal de decomposição ruim, e o excedente roda em série mesmo.
+        // 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();
         if (spawns.length > 1 && !PARAR) {
-            const juntos = spawns.slice(0, 4);
+            const juntos = spawns.slice(0, 8);
             fala.paralelo(juntos.length, profundidade);
             const rs = await Promise.all(juntos.map((tc) =>
                 runSubagent(tc.arguments || {}, {
@@ -1014,6 +1238,22 @@ async function runAct(userPrompt, opts) {
             juntos.forEach((tc, i) => resultadosSpawn.set(tc.id, rs[i]));
         }
 
+        /* 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). */
+        const adiantadas = new Map();
+        const leituras = toolCalls.filter(ehLeitura);
+        if (leituras.length > 1 && !PARAR) {
+            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`);
+        }
+
         for (const tc of toolCalls) {
             if (PARAR) break;
             if (tc.name === 'finish') {
@@ -1037,7 +1277,7 @@ async function runAct(userPrompt, opts) {
                         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 (leia o arquivo antes de editar) ou, se for impossível, diga claramente ao usuário o que falhou.',
+                            + 'Conserte agora com edit_file no arquivo que falhou ou, se for impossível, diga claramente ao usuário o que falhou.',
                     });
                     continue;
                 }
@@ -1055,7 +1295,7 @@ async function runAct(userPrompt, opts) {
                         server, model, token, projectDir: pastaAtual, projectName, profundidade, motor, permissoes,
                     });
                 repeticao.executou(jaChamado, tc.name, tc.arguments);
-                messages.push({ role: 'tool', tool_call_id: tc.id, content: r });
+                messages.push({ role: 'tool', tool_call_id: tc.id, content: r + lembreteDeParalelo(todosDaTarefa, spawns.length) });
                 continue;
             }
 
@@ -1117,6 +1357,38 @@ async function runAct(userPrompt, opts) {
 
             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++;
                 messages.push({
@@ -1138,7 +1410,6 @@ async function runAct(userPrompt, opts) {
                 const porta = await permissao.pedir(portaoControle, tc.name, tc.arguments, autorizar);
                 if (!porta.ok) {
                     fala.acao(tc.name, tc.arguments, profundidade);
-                    fala.avisar('resultado', { nome: tc.name, ok: false, resumo: 'não autorizado' });
                     console.log(fala.resultado(profundidade) + c.warn('não autorizado'));
                     registro.anotar(livro, tc.name, tc.arguments, { ok: false, error: porta.error });
                     messages.push({ role: 'tool', tool_call_id: tc.id, content: JSON.stringify({ ok: false, error: porta.error }) });
@@ -1156,7 +1427,6 @@ async function runAct(userPrompt, opts) {
             });
             if (!risco.ok) {
                 fala.acao(tc.name, tc.arguments, profundidade);
-                fala.avisar('resultado', { nome: tc.name, ok: false, resumo: `não autorizado — ${risco.motivo}` });
                 console.log(fala.resultado(profundidade) + c.warn(`não autorizado — ${risco.motivo}`));
                 registro.anotar(livro, tc.name, tc.arguments, { ok: false, error: risco.error });
                 messages.push({ role: 'tool', tool_call_id: tc.id, content: JSON.stringify({ ok: false, error: risco.error }) });
@@ -1174,13 +1444,24 @@ async function runAct(userPrompt, opts) {
             /* O servidor, o token e o cliente da API vão junto: a legenda do
                estudio_video transcreve no servidor, e sem eles a ferramenta
                respondia "a transcrição precisa do servidor". */
-            const result = await tools.execute(tc.name, tc.arguments, { projectDir: pastaAtual, server, token, api });
+            traco(`executando ${tc.name}`);
+            const result = adiantadas.has(tc.id) ? adiantadas.get(tc.id)
+                : await tools.execute(tc.name, tc.arguments, { projectDir: pastaAtual, server, token, api });
+            traco(`${tc.name} devolveu ok=${result && result.ok}`);
             logResult(tc.name, result, profundidade);
             repeticao.executou(jaChamado, tc.name, tc.arguments);
             if (RELEITURA.has(tc.name) && result && result.ok !== false) {
                 leiturasGuardadas.set(eco.chave, summarizeForModel(result));
             }
             if (tc.name === 'write_todos' && result && Array.isArray(result.todos)) todosDaTarefa = result.todos;
+            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.
@@ -1270,9 +1551,14 @@ async function runAct(userPrompt, opts) {
         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
@@ -1289,7 +1575,7 @@ async function runAct(userPrompt, opts) {
     // 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 });
+        finalText = motivoDaParada({ voltas, voltasEmFalso, falhasPendentes, travou: rodadasParadas >= MAX_RODADAS_PARADAS, teto });
         if (!subagent) fala.aviso(finalText);
     }
 
@@ -1367,7 +1653,42 @@ async function runSubagent(args, ctx) {
 
     const resumo = r.assistantMessage.content || 'sem resultado';
     fala.agenteVoltou(resumo, profundidade);
-    return resumo;
+    return entregaDoAgente(especialistas.rotulo(esp), resumo, r.registro);
+}
+
+/* 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) {
+    const linhas = [`ENTREGA DO ${String(quem).toUpperCase()}`, String(texto).trim().slice(0, 4000)];
+    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 ═══════════════════════════════════════════
@@ -1480,5 +1801,5 @@ async function rodarPipeline(args, ctx) {
     });
 }
 
-module.exports = { runAct, buildMemoryContext, interromper, compactar, motivoDaParada, pareceParadaNoMeio, ehTetoDeToken, ehTransitorio, esperaDoErro,
+module.exports = { runAct, entregaDoAgente, lembreteDeParalelo, buildMemoryContext, leituraPeloShell, historicoEnxuto, interromper, mandarDuranteATarefa, trabalhando, sobrasDaCaixa, entregarRecados, compactar, motivoDaParada, pareceParadaNoMeio, ehTetoDeToken, ehTransitorio, esperaDoErro,
     anotacaoDoQueJaFoi, encolherParaContinuar, MAX_ITERATIONS };