primocode 8.6.0 → 8.7.0

package/bin/primocode.js

@@ -542,19 +542,35 @@ async function sendPrompt(userText) {
         // que está torto, diz qual é o entregável e o que conta como pronto.
         const prompt2 = await refinarPedido(prompt);
 
-        const r = await runAct(prompt2, {
-            server: state.config.server,
-            model: state.config.model,
-            effort: state.config.effort,
-            token: state.config.token,
-            history: memoria.paraEnviar(state.memoria, state.history),
-            projectDir: plan.dir,
-            projectName: plan.name || state.currentProject,
-            // Só chamado se o agente for mesmo MEXER EM ARQUIVO — abrir o Chrome
-            // não é motivo para criar pasta de projeto.
-            ensureWorkDir: plan.pending ? () => createPendingProject(plan) : null,
-            motor: state.engine === 'claude-code' ? claudeEngine : api,
-        });
+        // A tarefa grande vira passos, e cada passo é uma chamada própria — com
+        // conversa nova, e por isso pequena. Oculto: o usuário mandou UMA coisa.
+        const passos = await dividirTarefa(prompt2);
+
+        let r = null;
+        let jaFeito = '';
+        for (let i = 0; i < passos.length; i++) {
+            if (i > 0) console.log(c.dim(`  ⎿ ${passos[i].titulo}`));
+            const pedido = i === 0 ? passos[i].pedido
+                : `${passos[i].pedido}\n\nO QUE JÁ FOI FEITO ANTES (use estes fatos, não pesquise de novo):\n${jaFeito}`;
+
+            r = await runAct(pedido, {
+                server: state.config.server,
+                model: state.config.model,
+                effort: state.config.effort,
+                token: state.config.token,
+                // Só o primeiro passo enxerga a conversa: os seguintes recebem o
+                // que interessa em `jaFeito`, e conversa a mais só ocupa o teto.
+                history: i === 0 ? memoria.paraEnviar(state.memoria, state.history) : [],
+                projectDir: plan.dir,
+                projectName: plan.name || state.currentProject,
+                // Só chamado se o agente for mesmo MEXER EM ARQUIVO — abrir o Chrome
+                // não é motivo para criar pasta de projeto.
+                ensureWorkDir: plan.pending ? () => createPendingProject(plan) : null,
+                motor: state.engine === 'claude-code' ? claudeEngine : api,
+            });
+            jaFeito = String((r.assistantMessage && r.assistantMessage.content) || '').slice(0, 1200);
+            if (r.parado) break;   // Esc Esc no meio do plano para o plano inteiro
+        }
         state.history.push({ role: 'user', content: userText });
         state.history.push({ role: 'assistant', content: r.assistantMessage.content });
         state.lastResponse = r.assistantMessage.content;
@@ -568,6 +584,35 @@ async function sendPrompt(userText) {
     refreshPrompt();
 }
 
+/**
+ * Divide a tarefa grande em passos — e faz isso ESCONDIDO.
+ *
+ * O motivo é aritmético. Com 6.000 tokens por minuto, "pesquise sobre a X e
+ * crie um vídeo" não cabe numa conversa só: o custo fixo (prompt + tools) é
+ * ~3.700, a spec do formato ~1.400, os fatos da pesquisa o resto — e sobram
+ * 512 para o agente escrever o documento. Em DOIS pedidos cada um cabe
+ * folgado, porque cada um leva só as ferramentas e o prompt do seu passo.
+ *
+ * O dono queria isto automático: "o usuário manda a tarefa gigante, e a IA
+ * ocultamente vai quebrar a tarefa". E com razão — quem pede não sabe onde
+ * está a fronteira barata, e pode partir num pedaço que ainda não cabe.
+ *
+ * Falhou? Um passo só, que é o comportamento de sempre.
+ */
+async function dividirTarefa(pedido) {
+    const inteiro = [{ titulo: 'tarefa', pedido }];
+    try {
+        const r = await api.requestPlano(state.config.server, {
+            prompt: pedido, model: state.config.model, token: state.config.token,
+        });
+        const passos = (r && Array.isArray(r.passos) && r.passos.length) ? r.passos : inteiro;
+        if (passos.length > 1) console.log(c.dim(`  ⎿ ${passos[0].titulo}`));
+        return passos;
+    } catch {
+        return inteiro;
+    }
+}
+
 /**
  * Estrutura o pedido antes de mandar o agente executar.
  *

package/lib/act.js

@@ -37,6 +37,45 @@ function interromper() {
     if (emVoo) { try { emVoo.abort(); } catch {} }
 }
 
+/**
+ * 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);
+}
+
+/**
+ * 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.
+ */
+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.consulta || ch.args.ferramenta || ch.args.titulo || ch.args.id);
+        const corpo = String(m.content || '');
+        const deuErrado = /"ok"\s*:\s*false/.test(corpo);
+        feitos.push(`- ${ch.nome}${alvo ? `(${String(alvo).slice(0, 60)})` : ''}: `
+            + (deuErrado ? 'FALHOU' : corpo.slice(0, 220).replace(/\s+/g, ' ')));
+    }
+    return feitos;
+}
+
 function ident(profundidade) {
     return '  '.repeat(profundidade);
 }
@@ -231,6 +270,29 @@ function compactar(messages) {
  * 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 = 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.',
+        });
+    }
+}
+
 function motivoDaParada({ voltas, voltasEmFalso, falhasPendentes, travou }) {
     if (falhasPendentes.length) {
         return `Parei sem concluir. A última falha foi: ${falhasPendentes[falhasPendentes.length - 1].texto}`;
@@ -294,6 +356,12 @@ async function runAct(userPrompt, opts) {
     // 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;
+
     let voltas = 0;
     for (let iteration = 0; iteration < MAX_ITERATIONS && !PARAR; iteration++) {
         voltas++;
@@ -318,6 +386,20 @@ async function runAct(userPrompt, opts) {
             });
         } catch (e) {
             sp.stop();
+            emVoo = null;
+            // 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.
+            if (ehTetoDeToken(e) && compactacoes < MAX_COMPACTACOES && !PARAR) {
+                compactacoes++;
+                const antes = messages.length;
+                encolherParaContinuar(messages);
+                if (!subagent) {
+                    console.log(ident(profundidade) + c.dim(`  ⎿ conversa encolhida para continuar (${antes} → ${messages.length} mensagens)`));
+                }
+                iteration--;          // esta volta não contou: nada foi decidido
+                continue;
+            }
             const amigavel = friendlyError(e);
             if (subagent) return { assistantMessage: { role: 'assistant', content: `Subagente falhou: ${amigavel}` } };
             console.log('\n' + c.err(amigavel));
@@ -327,6 +409,17 @@ async function runAct(userPrompt, opts) {
         emVoo = null;
         if (PARAR) break;
 
+        if (streamError && ehTetoDeToken(streamError) && compactacoes < MAX_COMPACTACOES && !PARAR) {
+            compactacoes++;
+            const antes = messages.length;
+            encolherParaContinuar(messages);
+            if (!subagent) {
+                console.log(ident(profundidade) + c.dim(`  ⎿ conversa encolhida para continuar (${antes} → ${messages.length} mensagens)`));
+            }
+            iteration--;
+            continue;
+        }
+
         if (streamError) {
             const amigavel = friendlyError(streamError);
             if (subagent) return { assistantMessage: { role: 'assistant', content: `Subagente falhou: ${amigavel}` } };
@@ -497,6 +590,10 @@ async function runAct(userPrompt, opts) {
     return {
         userMessage: { role: 'user', content: userPrompt },
         assistantMessage: { role: 'assistant', content: finalText },
+        // 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,
     };
 }
 
@@ -524,4 +621,5 @@ async function runSubagent(args, ctx) {
     return resumo;
 }
 
-module.exports = { runAct, interromper, compactar, motivoDaParada, MAX_ITERATIONS };
+module.exports = { runAct, interromper, compactar, motivoDaParada, ehTetoDeToken,
+    anotacaoDoQueJaFoi, encolherParaContinuar, MAX_ITERATIONS };

package/lib/api.js

@@ -162,6 +162,12 @@ function requestRefino(serverUrl, payload) {
     return request(serverUrl, '/api/refinar', body, token);
 }
 
+// O plano: a tarefa grande dividida em passos, para uma chamada por pedaço.
+function requestPlano(serverUrl, payload) {
+    const { token, ...body } = payload;
+    return request(serverUrl, '/api/plano', body, token);
+}
+
 function getHealth(serverUrl, token) {
     return new Promise((resolve, reject) => {
         const url = new URL('/health', serverUrl);
@@ -178,4 +184,4 @@ function getHealth(serverUrl, token) {
     });
 }
 
-module.exports = { request, requestStream, requestAct, requestChat, requestResumo, requestRefino, getHealth };
+module.exports = { request, requestStream, requestAct, requestChat, requestResumo, requestRefino, requestPlano, getHealth };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "primocode",
-  "version": "8.6.0",
+  "version": "8.7.0",
   "description": "PrimoCode — agente de engenharia com IA e cursor próprio. Modelos grátis. Cria arquivos, roda comandos, controla navegador e desktop: abre apps, clica em botões e ícones pelo nome, digita e usa atalhos.",
   "main": "bin/primocode.js",
   "bin": {
@@ -8,7 +8,7 @@
   },
   "scripts": {
     "start": "node bin/primocode.js",
-    "test": "node test/tools.test.js && node test/ui.test.js && node test/modo.test.js && node test/pasta.test.js && node test/catalogo.test.js && node test/desktop.test.js && node test/effort.test.js && node test/claude-engine.test.js && node test/regressao.test.js && node test/memoria-conversa.test.js && node test/repeticao.test.js && node test/referencia.test.js && node test/parar.test.js"
+    "test": "node test/tools.test.js && node test/ui.test.js && node test/modo.test.js && node test/pasta.test.js && node test/catalogo.test.js && node test/desktop.test.js && node test/effort.test.js && node test/claude-engine.test.js && node test/regressao.test.js && node test/memoria-conversa.test.js && node test/repeticao.test.js && node test/referencia.test.js && node test/parar.test.js && node test/continuar.test.js"
   },
   "engines": {
     "node": ">=18.17.0"