primocode 9.10.0 → 10.0.0

package/lib/act.js

@@ -55,6 +55,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 +176,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 +256,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 +336,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 +404,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 +467,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);
@@ -487,6 +582,58 @@ 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").';
+
 /* `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 +652,7 @@ 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);
     return parts.join('\n\n');
 }
 
@@ -584,10 +732,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 +752,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
@@ -653,9 +806,7 @@ 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);
     }
     /* 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 +827,14 @@ 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: '
+                + '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.' });
+        } else if (producao.producao) {
             /* "SE ESTIVER NA SUA LISTA" não é hesitação — é a diferença entre
                a tarefa seguir e a tarefa morrer.
 
@@ -749,8 +906,13 @@ async function runAct(userPrompt, opts) {
     const MAX_ESPERAS_REDE = Number(process.env.PRIMOCODE_MAX_ESPERAS_REDE || 6);
 
     let voltas = 0;
+    if (!subagent) TRABALHANDO = true;
+    try {
     for (let iteration = 0; iteration < MAX_ITERATIONS && !PARAR; iteration++) {
         voltas++;
+        // 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 +931,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 +957,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 +985,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 +1128,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 +1139,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;
@@ -1037,7 +1216,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;
                 }
@@ -1117,6 +1296,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 +1349,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 +1366,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 }) });
@@ -1181,6 +1390,14 @@ async function runAct(userPrompt, opts) {
                 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 +1487,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
@@ -1480,5 +1702,5 @@ async function rodarPipeline(args, ctx) {
     });
 }
 
-module.exports = { runAct, buildMemoryContext, interromper, compactar, motivoDaParada, pareceParadaNoMeio, ehTetoDeToken, ehTransitorio, esperaDoErro,
+module.exports = { runAct, buildMemoryContext, leituraPeloShell, historicoEnxuto, interromper, mandarDuranteATarefa, trabalhando, sobrasDaCaixa, entregarRecados, compactar, motivoDaParada, pareceParadaNoMeio, ehTetoDeToken, ehTransitorio, esperaDoErro,
     anotacaoDoQueJaFoi, encolherParaContinuar, MAX_ITERATIONS };

package/lib/browser.js

@@ -14,6 +14,7 @@
 
 'use strict';
 
+const snapshot = require('./snapshot.js');
 const fs = require('fs');
 const os = require('os');
 const net = require('net');
@@ -658,7 +659,22 @@ async function candidatosNaPagina() {
     try { return JSON.parse(await evaluate(js)) || []; } catch { return []; }
 }
 
+/* O retrato da página com as refs (lib/snapshot.js), já em texto. */
+async function retrato(max = 80) {
+    try {
+        const r = await evaluate(snapshot.scriptDoRetrato(max));
+        return snapshot.formatar(r, max);
+    } catch { return ''; }
+}
+
 async function erroDeSeletor(selector) {
+    // Ref que não existe mais: a página mudou depois da leitura. Listar os
+    // seletores CSS aqui só confundiria — o caminho é ler de novo.
+    if (/data-primo-ref/.test(selector)) {
+        const err = new Error('essa ref não existe mais nesta página — ela mudou depois da leitura. '
+            + 'Estas são as refs de agora:\n' + await retrato(40));
+        return err;
+    }
     const candidatos = await candidatosNaPagina();
     const err = new Error(
         `seletor não encontrado: ${selector}`
@@ -1191,6 +1207,7 @@ function fecharRevisor() {
 }
 
 module.exports = {
+    retrato,
     SEM_KEYCHAIN,
     scriptDaSeta, verSeta, findChrome,
     open, click, clickText, clickSelector, type, typeInSelector,

package/lib/casar.js

@@ -0,0 +1,108 @@
+/**
+ * casar.js — acha no arquivo o trecho que o modelo MANDOU trocar, mesmo
+ * quando ele não copiou letra por letra.
+ *
+ * O modelo grátis erra o old_string de jeitos previsíveis: um espaço a mais
+ * no fim da linha, a indentação com 2 em vez de 4, o número de linha que o
+ * read_file com offset põe na frente ("12\t…"), um "\n" escapado. Cada erro
+ * desses virava "trecho não encontrado" → read_file de novo → edit de novo:
+ * duas voltas de modelo para um espaço. É o "fica o dia inteiro lendo o que
+ * fez". A ideia vem do opencode (MIT), que encadeia vários "casadores" do
+ * mais estrito ao mais frouxo; o código é nosso.
+ *
+ * A regra de ouro: frouxo, mas NUNCA ambíguo. Cada estratégia só vale se
+ * achar exatamente UM lugar. Dois lugares parecidos é pior que nenhum —
+ * trocar o errado estraga o arquivo calado.
+ *
+ *   achar(conteudo, alvo) → { inicio, fim, como } | { erro: 'nenhum' | 'varios', vezes }
+ */
+
+'use strict';
+
+// Onde está cada linha no texto: [inicio, fim) de cada uma, sem o \n.
+function linhasComPosicao(texto) {
+    const out = [];
+    let i = 0;
+    for (const l of texto.split('\n')) {
+        out.push({ texto: l, inicio: i, fim: i + l.length });
+        i += l.length + 1;
+    }
+    return out;
+}
+
+/* Procura um bloco de linhas do alvo no conteúdo comparando cada linha por
+   `igual`. Devolve todos os lugares (em caracteres do conteúdo original). */
+function porLinhas(conteudo, alvo, normalizar) {
+    const doArquivo = linhasComPosicao(conteudo);
+    let doAlvo = alvo.split('\n');
+    // Linha vazia no começo ou no fim do alvo é quase sempre sobra do modelo.
+    while (doAlvo.length > 1 && !doAlvo[0].trim()) doAlvo = doAlvo.slice(1);
+    while (doAlvo.length > 1 && !doAlvo[doAlvo.length - 1].trim()) doAlvo = doAlvo.slice(0, -1);
+    const alvoN = doAlvo.map(normalizar);
+    if (!alvoN.some(Boolean)) return [];
+    const achados = [];
+    for (let i = 0; i + alvoN.length <= doArquivo.length; i++) {
+        let bate = true;
+        for (let j = 0; j < alvoN.length; j++) {
+            if (normalizar(doArquivo[i + j].texto) !== alvoN[j]) { bate = false; break; }
+        }
+        if (bate) achados.push({ inicio: doArquivo[i].inicio, fim: doArquivo[i + alvoN.length - 1].fim });
+    }
+    return achados;
+}
+
+// Tira a indentação que todas as linhas não vazias têm em comum.
+function semIndentacaoComum(linhas) {
+    const recuos = linhas.filter((l) => l.trim()).map((l) => l.match(/^[ \t]*/)[0].length);
+    const menor = recuos.length ? Math.min(...recuos) : 0;
+    return linhas.map((l) => l.slice(Math.min(menor, l.match(/^[ \t]*/)[0].length)));
+}
+
+function porIndentacao(conteudo, alvo) {
+    const doArquivo = linhasComPosicao(conteudo);
+    const doAlvo = semIndentacaoComum(alvo.replace(/^\n+|\n+$/g, '').split('\n')).map((l) => l.trimEnd());
+    const n = doAlvo.length;
+    if (!doAlvo.some((l) => l.trim())) return [];
+    const achados = [];
+    for (let i = 0; i + n <= doArquivo.length; i++) {
+        const janela = semIndentacaoComum(doArquivo.slice(i, i + n).map((l) => l.texto)).map((l) => l.trimEnd());
+        if (janela.every((l, j) => l === doAlvo[j])) {
+            achados.push({ inicio: doArquivo[i].inicio, fim: doArquivo[i + n - 1].fim });
+        }
+    }
+    return achados;
+}
+
+function ocorrencias(conteudo, alvo) {
+    const out = [];
+    if (!alvo) return out;
+    let i = conteudo.indexOf(alvo);
+    while (i !== -1) { out.push({ inicio: i, fim: i + alvo.length }); i = conteudo.indexOf(alvo, i + alvo.length); }
+    return out;
+}
+
+/* Do mais estrito ao mais frouxo. O primeiro que achar UM lugar vence; o que
+   achar vários para a busca ali mesmo (ficar mais frouxo só pioraria). */
+const ESTRATEGIAS = [
+    ['exato', (c, a) => ocorrencias(c, a)],
+    // "12\t  <div>" — o prefixo que o read_file com offset põe em cada linha.
+    ['sem número de linha', (c, a) => (/^\s*\d+\t/m.test(a) ? ocorrencias(c, a.replace(/^\s*\d+\t/gm, '')) : [])],
+    // "\\n" e "\\t" que vieram escapados de um JSON mal montado.
+    ['sem escape', (c, a) => (/\\[nt"]/.test(a) && !/\\[nt"]/.test(c)
+        ? ocorrencias(c, a.replace(/\\n/g, '\n').replace(/\\t/g, '\t').replace(/\\"/g, '"')) : [])],
+    ['espaço no fim da linha', (c, a) => porLinhas(c, a, (l) => l.trimEnd())],
+    ['linha aparada', (c, a) => porLinhas(c, a, (l) => l.trim())],
+    ['indentação', (c, a) => porIndentacao(c, a)],
+    ['espaço normalizado', (c, a) => porLinhas(c, a, (l) => l.replace(/\s+/g, ' ').trim())],
+];
+
+function achar(conteudo, alvo) {
+    for (const [como, f] of ESTRATEGIAS) {
+        const achados = f(conteudo, alvo);
+        if (achados.length === 1) return { ...achados[0], como };
+        if (achados.length > 1) return { erro: 'varios', vezes: achados.length, como };
+    }
+    return { erro: 'nenhum' };
+}
+
+module.exports = { achar, ocorrencias };

package/lib/catalogo.js

@@ -87,12 +87,16 @@ const GRUPOS = [
               args: 'id. PREFIRA roteiro: {marca:{cores:{fundo,destaque,tinta},fontes:{titulo,texto},logo}, proporcao, '
                 + 'partes:[{tipo, fala, …}]} — o PrimoCode faz o layout, a voz com entonação, os ícones, a música e os sons. '
                 + 'Tipos: abertura{titulo,sub} titulo{titulo,sub} numero{valor,rotulo,sub} lista{titulo,itens} passos{titulo,itens} '
-                + 'contraste{nao,sim} citacao{texto,autor} imagem{busca,titulo,sub} grafico{titulo,barras:[{rotulo,valor}]} cta{titulo,link}. '
+                + 'contraste{nao,sim} citacao{texto,autor} imagem{busca,titulo,sub} grafico{titulo,barras:[{rotulo,valor}]} cta{titulo,link} '
+                + 'logo{titulo} cores{cores:[{nome,hex}]} produto{titulo,texto,destaque,selo,barras}. Em qualquer parte: destaque (a palavra-tese), fonte (a fonte citada). '
+                + 'estilo: motion (padrão, 3D contínuo) | vox (explainer editorial: tinta sobre papel, câmera que conta a frase) | '
+                + 'marca (brand reveal: brilho, letras em vetor, marca cromada, padrão) | lancamento (produto: cartões, painel, calendário) | impacto | cinema. '
+                + 'marca e lancamento aceitam visual:orbe|vetor|estrela|esfera|grade|site|padrao|cromo|cartoes|painel|cores numa parte. marca.nome dá o nome. '
                 + 'voz (thalita|antonio|francisca). Ajuste fino: plano: {formato:{largura,altura,fps}, cenas:[…], audio:{…}} — ou cenas direto. '
                 + 'cena (opcional): o número de UMA cena para trocar só ela, sem reescrever o resto. '
                 + 'motivo (opcional): fica no caderno. voltarPara (opcional): nome de uma versão. '
                 + 'Sem plano nem cenas, LÊ o plano atual. '
-                + 'Cada elemento é {tipo: texto|forma|imagem|video|icone|legenda|componente} com x, y, cor, tamanho e '
+                + 'Cada elemento é {tipo: texto|forma|imagem|video|icone|legenda|componente|kit} com x, y, cor, tamanho e '
                 + '"anima": {propriedade: [{t,v,e}]} — quadros-chave em segundos. A cena tem "camera": {zoom,x,y,rotacao} e '
                 + '"perspectiva" para 3D. NÃO existe layout pronto nem tema — cada propriedade do vídeo é escolha sua, a cada vídeo.' },
 

package/lib/config.js

@@ -74,8 +74,11 @@ function ensureDir(dir) {
     try { fs.mkdirSync(dir, { recursive: true }); } catch {}
 }
 
+// O dia LOCAL: toISOString é UTC, e no Brasil depois das 21h a memória saía
+// datada no dia seguinte.
 function today() {
-    return new Date().toISOString().split('T')[0];
+    const d = new Date();
+    return `${d.getFullYear()}-${String(d.getMonth() + 1).padStart(2, '0')}-${String(d.getDate()).padStart(2, '0')}`;
 }
 
 function ensureStructure() {
@@ -99,12 +102,16 @@ function slugify(name) {
         .toLowerCase()
         .replace(/[^a-z0-9]+/g, '-')
         .replace(/^-+|-+$/g, '')
-        .slice(0, 60);
+        .slice(0, 60)
+        .replace(/-+$/, '');   // o corte pode deixar hífen no fim
 }
 
 function createProjectDir(projectName) {
     ensureStructure();
-    const slug = slugify(projectName);
+    /* Nome sem letra nem número ("!!!", só emoji, só japonês) dava slug
+       VAZIO — e path.join(ROOT_DIR, '') é a própria raiz: o "projeto" virava
+       ~/primocode, com memory.md gravado nela. */
+    const slug = slugify(projectName) || `projeto-${today()}`;
     const projectDir = path.join(ROOT_DIR, slug);
     ensureDir(projectDir);
     const memoryPath = path.join(projectDir, 'memory.md');