primocode 8.10.2 → 8.10.3

package/lib/act.js

@@ -293,6 +293,14 @@ function encolherParaContinuar(messages) {
     }
 }
 
+/** Quanto esperar quando o minuto estourou. O provedor costuma dizer
+ * ("Please try again in 7.664s"); sem isso, meio minuto é seguro. */
+function esperaDoErro(e) {
+    const m = /try again in ([0-9.]+)s/i.exec(String((e && e.message) || e || ''));
+    const s = m ? Math.ceil(parseFloat(m[1])) + 2 : 30;
+    return Math.min(70, Math.max(5, s)) * 1000;
+}
+
 function motivoDaParada({ voltas, voltasEmFalso, falhasPendentes, travou }) {
     if (falhasPendentes.length) {
         return `Parei sem concluir. A última falha foi: ${falhasPendentes[falhasPendentes.length - 1].texto}`;
@@ -367,6 +375,13 @@ async function runAct(userPrompt, opts) {
     // usuário — que não tem prompt nenhum para ajustar. É o modelo tropeçando
     // ao escrever o JSON da chamada, e quase sempre acerta na segunda.
     let funcoesQuebradas = 0;
+    // O teto de tokens é POR MINUTO, somando TODAS as chamadas — o plano, o
+    // resumo e cada rodada do loop dividem a mesma cota. Um pedido perfeito
+    // estoura se a rodada anterior já gastou o minuto. Encolher não resolve
+    // isso (num caso real "encolheu" de 2 para 2 mensagens); esperar a janela
+    // virar, sim.
+    let esperas = 0;
+    const MAX_ESPERAS = 3;
 
     let voltas = 0;
     for (let iteration = 0; iteration < MAX_ITERATIONS && !PARAR; iteration++) {
@@ -396,15 +411,30 @@ async function runAct(userPrompt, opts) {
             // 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)`));
+            if (ehTetoDeToken(e) && !PARAR) {
+                if (messages.length > 8 && compactacoes < MAX_COMPACTACOES) {
+                    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;
+                }
+                if (esperas < MAX_ESPERAS) {
+                    esperas++;
+                    const ms = esperaDoErro(e);
+                    if (!subagent) {
+                        const sp2 = new Spinner(`limite do minuto — continuando em ${Math.round(ms / 1000)}s`).start();
+                        await new Promise((r) => setTimeout(r, ms));
+                        sp2.stop();
+                    } else {
+                        await new Promise((r) => setTimeout(r, ms));
+                    }
+                    iteration--;
+                    continue;
                 }
-                iteration--;          // esta volta não contou: nada foi decidido
-                continue;
             }
             const amigavel = friendlyError(e);
             if (subagent) return { assistantMessage: { role: 'assistant', content: `Subagente falhou: ${amigavel}` } };
@@ -428,15 +458,33 @@ async function runAct(userPrompt, opts) {
             continue;
         }
 
-        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)`));
+        if (streamError && ehTetoDeToken(streamError) && !PARAR) {
+            // Conversa longa: encolher resolve, porque o peso é o histórico.
+            if (messages.length > 8 && compactacoes < MAX_COMPACTACOES) {
+                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;
+            }
+            // Conversa curta: o peso é o MINUTO, não o histórico — as chamadas
+            // anteriores gastaram a cota. Espera a janela virar e repete.
+            if (esperas < MAX_ESPERAS) {
+                esperas++;
+                const ms = esperaDoErro(streamError);
+                if (!subagent) {
+                    const sp2 = new Spinner(`limite do minuto — continuando em ${Math.round(ms / 1000)}s`).start();
+                    await new Promise((r) => setTimeout(r, ms));
+                    sp2.stop();
+                } else {
+                    await new Promise((r) => setTimeout(r, ms));
+                }
+                iteration--;
+                continue;
             }
-            iteration--;
-            continue;
         }
 
         if (streamError) {
@@ -648,5 +696,5 @@ async function runSubagent(args, ctx) {
     return resumo;
 }
 
-module.exports = { runAct, interromper, compactar, motivoDaParada, ehTetoDeToken,
+module.exports = { runAct, interromper, compactar, motivoDaParada, ehTetoDeToken, esperaDoErro,
     anotacaoDoQueJaFoi, encolherParaContinuar, MAX_ITERATIONS };

package/lib/tools.js

@@ -379,6 +379,19 @@ async function despachar(name, args, ctx) {
     {
         switch (name) {
             case 'write_file': {
+                // Vídeo e áudio NÃO se escrevem com write_file. Num pedido
+                // real o agente criou um "video.mp4" de 43 bytes de texto e
+                // disse "vídeo criado com sucesso" — um arquivo falso, morto,
+                // entregue como resultado. O caminho certo existe e é dele:
+                // o Studio.
+                if (/\.(mp4|mov|avi|mkv|webm|mp3|wav|ogg|m4a|flac)$/i.test(String(args.path || ''))) {
+                    return {
+                        ok: false,
+                        error: `"${args.path}" é arquivo de vídeo/áudio, e write_file só escreve TEXTO — isso criaria um arquivo falso que não abre. `
+                            + 'Vídeo se faz no Studio: studio_criar com ferramenta "corte" (leia studio_spec antes). '
+                            + 'O Studio devolve o link "ver" — é ESSE o vídeo. Não use ffmpeg: não é preciso.',
+                    };
+                }
                 const filePath = resolveInProject(args.path, projectDir);
                 const content = args.content || '';
                 const created = !fs.existsSync(filePath);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "primocode",
-  "version": "8.10.2",
+  "version": "8.10.3",
   "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": {