primocode 8.10.1 → 8.10.3

package/bin/primocode.js

@@ -550,10 +550,19 @@ async function sendPrompt(userText) {
         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, {
+            // Só fato de passo CONCLUÍDO entra aqui. Num pedido real o passo de
+            // pesquisa morreu e o texto "Parei sem concluir..." foi injetado
+            // como "use estes fatos" — e o passo seguinte obedeceu: criou o
+            // vídeo sem fato nenhum, proibido de pesquisar.
+            const contexto = !jaFeito ? ''
+                : `\n\nO QUE JÁ FOI FEITO ANTES (use estes fatos, não pesquise de novo):\n${jaFeito}`;
+            const semFatos = i > 0 && !jaFeito
+                ? '\n\nATENÇÃO: o passo anterior não trouxe fatos. Trabalhe só com o que está no pedido. '
+                  + 'É PROIBIDO inventar dado de empresa, data, preço ou pessoa — na dúvida, não afirme.'
+                : '';
+            const pedido = passos[i].pedido + contexto + semFatos;
+
+            const rodarPasso = () => runAct(pedido, {
                 server: state.config.server,
                 model: state.config.model,
                 effort: state.config.effort,
@@ -568,7 +577,19 @@ async function sendPrompt(userText) {
                 ensureWorkDir: plan.pending ? () => createPendingProject(plan) : null,
                 motor: state.engine === 'claude-code' ? claudeEngine : api,
             });
-            jaFeito = String((r.assistantMessage && r.assistantMessage.content) || '').slice(0, 1200);
+
+            r = await rodarPasso();
+            // Passo que desistiu (modelo mudo, voltas esgotadas) ganha UMA
+            // segunda chance — costuma ser tropeço transitório do modelo
+            // grátis. Falhou de novo: o plano segue com o aviso de "sem
+            // fatos", nunca com o texto da falha fantasiado de resultado.
+            if (!r.parado && r.concluiu === false && passos.length > 1) {
+                console.log(c.dim('  ⎿ o passo não concluiu — tentando de novo'));
+                r = await rodarPasso();
+            }
+            jaFeito = (r.concluiu !== false)
+                ? 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 });

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}`;
@@ -362,6 +370,19 @@ async function runAct(userPrompt, opts) {
     let compactacoes = 0;
     const MAX_COMPACTACOES = 2;
 
+    // O provedor recusa chamada de função malformada com um 400 que dizia
+    // "Failed to call a function. Please adjust your prompt." NA CARA do
+    // usuário — que não tem prompt nenhum para ajustar. É o modelo tropeçando
+    // ao escrever o JSON da chamada, e quase sempre acerta na segunda.
+    let funcoesQuebradas = 0;
+    // 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++) {
         voltas++;
@@ -390,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}` } };
@@ -409,22 +445,55 @@ 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)`));
-            }
+        // Chamada de função malformada: o modelo errou a SINTAXE da chamada,
+        // não a tarefa. Repetir a mesma rodada quase sempre resolve — e sem
+        // isto o 400 cru do provedor ("Failed to call a function. Please
+        // adjust your prompt.") caía na tela de quem não tem prompt nenhum
+        // para ajustar.
+        if (streamError && /failed to call a function|failed_generation|tool_use_failed/i.test(String(streamError))
+            && funcoesQuebradas < 2 && !PARAR) {
+            funcoesQuebradas++;
+            if (!subagent) console.log(ident(profundidade) + c.dim('  ⎿ o modelo tropeçou na chamada — tentando de novo'));
             iteration--;
             continue;
         }
 
+        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;
+            }
+        }
+
         if (streamError) {
             const amigavel = friendlyError(streamError);
-            if (subagent) return { assistantMessage: { role: 'assistant', content: `Subagente falhou: ${amigavel}` } };
+            if (subagent) return { assistantMessage: { role: 'assistant', content: `Subagente falhou: ${amigavel}` }, concluiu: false };
             console.log('\n' + c.err(amigavel));
-            return { assistantMessage: { role: 'assistant', content: amigavel } };
+            // concluiu: false — o plano de passos não pode tratar um erro de
+            // provedor como resultado e passá-lo adiante como "fato".
+            return { assistantMessage: { role: 'assistant', content: amigavel }, concluiu: false };
         }
 
         // Sem tool_calls: o modelo respondeu e acabou.
@@ -561,6 +630,11 @@ async function runAct(userPrompt, opts) {
         }
     }
 
+    // O que o modelo entregou por vontade própria, ANTES dos textos de
+    // desistência. É esta a diferença que o plano de passos precisa: um passo
+    // que "parou sem concluir" não pode virar fato para o passo seguinte.
+    const concluiu = Boolean(finalText) && !PARAR;
+
     if (PARAR && !finalText) {
         finalText = 'Parado por você (Esc Esc). O que já foi feito, ficou feito.';
         if (!subagent) console.log('\n' + c.warn('⏹ ' + finalText));
@@ -594,6 +668,7 @@ async function runAct(userPrompt, opts) {
         // INTEIRO, não só o passo — senão o próximo passo começa logo depois
         // de o usuário ter mandado parar.
         parado: PARAR,
+        concluiu,
     };
 }
 
@@ -621,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/studio.js

@@ -256,7 +256,26 @@ const manual = () => comStudio(async () => ({ ok: true, ...(await pedir('GET', '
 const ferramentas = () => comStudio(async () => ({ ok: true, ferramentas: await pedir('GET', '/api/ferramentas') }));
 const spec = (slug) => comStudio(async () => ({ ok: true, spec: await pedir('GET', `/api/ferramentas/${encodeURIComponent(slug)}`) }));
 const listar = () => comStudio(async () => ({ ok: true, arquivos: await pedir('GET', '/api/arquivos') }));
-const ler = (id) => comStudio(async () => ({ ok: true, arquivo: await pedir('GET', `/api/arquivos/${encodeURIComponent(id)}`) }));
+// 404 de id é quase sempre id INVENTADO: num pedido real o agente criou o
+// arquivo, recebeu "corte-founders-ea74b" de volta, e chamou studio_ler com
+// "imersao-foulders-ai" — um id que ele imaginou. O erro seco ("não
+// encontrado") não dizia isso, e ele insistia. O erro que ensina, diz.
+async function comIdReal(id, fn) {
+    try {
+        return await fn();
+    } catch (e) {
+        if (!/HTTP 404/.test(String(e && e.message))) throw e;
+        let existem = [];
+        try { existem = (await pedir('GET', '/api/arquivos')).map((a) => a.id).slice(0, 8); } catch {}
+        return {
+            ok: false,
+            error: `O id "${id}" não existe. NÃO invente id: use EXATAMENTE o campo "id" que studio_criar devolveu.`
+                + (existem.length ? ` Os que existem agora: ${existem.join(', ')}.` : ''),
+        };
+    }
+}
+
+const ler = (id) => comStudio(() => comIdReal(id, async () => ({ ok: true, arquivo: await pedir('GET', `/api/arquivos/${encodeURIComponent(id)}`) })));
 
 const criar = ({ ferramenta, titulo, doc }) => comStudio(async () => {
     if (!ferramenta) return { ok: false, error: 'Diga a ferramenta: prisma, tela, prosa, grade, corte ou traco.' };
@@ -265,14 +284,14 @@ const criar = ({ ferramenta, titulo, doc }) => comStudio(async () => {
     return { ok: true, ...r };
 });
 
-const atualizar = ({ id, titulo, doc }) => comStudio(async () => {
+const atualizar = ({ id, titulo, doc }) => comStudio(() => comIdReal(id, async () => {
     if (!id) return { ok: false, error: 'Falta o id do arquivo.' };
     const corpo = {};
     if (titulo != null) corpo.titulo = titulo;
     if (doc != null) corpo.doc = doc;
     const r = await pedir('PUT', `/api/arquivos/${encodeURIComponent(id)}`, corpo);
     return { ok: true, ...r };
-});
+}));
 
 // ── Mídia: a imagem de fundo e a música do usuário ───────────────────────
 // Sem isto o agente não tinha como pôr foto de fundo nem trilha própria: a
@@ -288,7 +307,15 @@ const midiaListar = () => comStudio(async () => ({ ok: true, midia: await pedir(
 const midiaEnviar = ({ arquivo, nome }) => comStudio(async () => {
     if (!arquivo) return { ok: false, error: 'Diga o caminho do arquivo (arquivo: "foto.jpg").' };
     const caminho = path.resolve(arquivo);
-    if (!fs.existsSync(caminho)) return { ok: false, error: `Arquivo não existe: ${arquivo}` };
+    if (!fs.existsSync(caminho)) {
+        return {
+            ok: false,
+            error: `Arquivo não existe: ${arquivo}. NÃO invente arquivo de mídia — num pedido real o agente `
+                + 'tentou fundo.jpg, trilha.mp3 e logo.png que nunca existiram. Sem arquivo do usuário, siga sem mídia: '
+                + 'fundo pode ser "aurora"/"raios"/"brilho" (gerados), e trilha pode ser gerada — '
+                + '"trilha":{"tipo":"gerada","estilo":"epico"}. O vídeo fica pronto do mesmo jeito.',
+        };
+    }
 
     const ext = path.extname(caminho).toLowerCase();
     if (!TIPOS_MIDIA[ext]) {

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.1",
+  "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": {