primocode 8.10.1 → 8.10.2

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

@@ -362,6 +362,12 @@ 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;
+
     let voltas = 0;
     for (let iteration = 0; iteration < MAX_ITERATIONS && !PARAR; iteration++) {
         voltas++;
@@ -409,6 +415,19 @@ async function runAct(userPrompt, opts) {
         emVoo = null;
         if (PARAR) break;
 
+        // 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) && compactacoes < MAX_COMPACTACOES && !PARAR) {
             compactacoes++;
             const antes = messages.length;
@@ -422,9 +441,11 @@ async function runAct(userPrompt, opts) {
 
         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 +582,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 +620,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,
     };
 }
 

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/package.json

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