primocode 9.2.0 → 9.2.2

package/README.md

@@ -1,4 +1,4 @@
-# PrimoCode v9.2.0
+# PrimoCode v9.2.2
 
 Agente de engenharia brasileiro para o terminal, no estilo Claude Code.
 Cria arquivos de verdade, roda comandos, **controla o navegador e o desktop** —
@@ -9,7 +9,7 @@ OpenRouter, e cada apelido (`top`/`main`/`fast`) é uma **corrente**: se um mode
 está no limite de pedidos, o próximo atende. Você não vê o erro, e não paga nada.
 
 ```
- ▐▛███▜▌   Primo Code v9.2.0
+ ▐▛███▜▌   Primo Code v9.2.2
 ▝▜█████▛▘  Bem-vindo de volta, Joel
   ▘▘ ▝▝    ~/primocode  · /dir <pasta> muda
 ```

package/lib/act.js

@@ -541,13 +541,29 @@ async function runAct(userPrompt, opts) {
     if (!subagent && profundidade === 0) {
         const producao = require('./estudio/diretor.js').precisaDeProducao(pedido);
         if (producao.producao) {
+            /* "SE ESTIVER NA SUA LISTA" não é hesitação — é a diferença entre
+               a tarefa seguir e a tarefa morrer.
+
+               A primeira versão mandava chamar `planejar_producao` sem
+               ressalva. Só que quem declara as ferramentas ao modelo é o
+               SERVIDOR, e este texto é do cliente: com o servidor
+               desatualizado, o modelo obedecia a uma ordem para chamar algo
+               que não estava na lista dele, e o provedor recusava com
+               "attempted to call tool 'planejar_producao' which was not in
+               request.tools" — erro FATAL, em inglês, na cara do usuário, com
+               a tarefa perdida antes da primeira ação.
+
+               Um modelo não chama tool fora da lista por conta própria. Só
+               chamou porque este parágrafo mandou. */
             messages.push({ role: 'system', content:
-                'ESTE PEDIDO É DE PRODUÇÃO AUDIOVISUAL. Antes de criar qualquer peça, chame '
-                + `planejar_producao com o pedido do usuário (formato "${producao.formato}"). `
-                + 'Ele devolve a pauta — arco, narração falada, voz, direção de arte e a mídia a buscar — '
-                + 'e é ela que você produz, cena a cena, compondo com as primitivas. Não comece pelo '
-                + 'estudio_plano: o roteiro escrito no meio do JSON da cena vira legenda de slide, '
-                + 'que é exatamente o que se quer evitar.' });
+                'ESTE PEDIDO É DE PRODUÇÃO AUDIOVISUAL. Se `planejar_producao` estiver na sua lista de '
+                + `ferramentas, chame-o ANTES de criar qualquer peça (formato "${producao.formato}"): `
+                + 'ele devolve a pauta — arco, narração falada, voz, direção de arte e a mídia a buscar — '
+                + 'e é ela que você produz, cena a cena, compondo com as primitivas. '
+                + 'Se ele NÃO estiver na sua lista, não o chame e não procure equivalente: siga com as '
+                + 'ferramentas que você tem e escreva o roteiro antes das cenas, não dentro do JSON delas. '
+                + 'Nunca chame uma ferramenta que não está na sua lista — a chamada é recusada e a tarefa '
+                + 'se perde.' });
         }
     }
 
@@ -569,6 +585,11 @@ 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;
+    /* As ferramentas que o provedor recusou por não estarem na lista do
+       pedido. Guardadas para não entrar em laço: tira a instrução, tenta de
+       novo UMA vez, e se voltar a acontecer com a mesma ferramenta é porque a
+       causa é outra. */
+    const toolsRecusadas = new Set();
     let respostasVazias = 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
@@ -674,6 +695,37 @@ async function runAct(userPrompt, opts) {
             continue;
         }
 
+        /* FERRAMENTA FORA DA LISTA DO PEDIDO — recuperável, e antes não era.
+           O provedor recusa com "attempted to call tool 'X' which was not in
+           request.tools" e a rodada morria ali: erro cru em inglês, tarefa
+           perdida antes da primeira ação. Visto em produção num "crie um
+           vídeo para a Paris Group".
+
+           Quem mandou chamar aquilo foi uma instrução NOSSA, de sistema (o
+           gatilho do diretor). Então a cura é tirar a instrução que cita a
+           ferramenta recusada e repetir a rodada: o modelo segue com o que
+           ele realmente tem, e a pessoa recebe o trabalho em vez de um erro.
+           Uma vez por ferramenta — insistindo, o problema é outro. */
+        const foraDaLista = streamError && String(streamError)
+            .match(/attempted to call tool '([^']+)' which was not in request\.tools/i);
+        if (foraDaLista && !PARAR && !toolsRecusadas.has(foraDaLista[1])) {
+            toolsRecusadas.add(foraDaLista[1]);
+            const nome = foraDaLista[1];
+            for (let i = messages.length - 1; i >= 0; i--) {
+                if (messages[i].role === 'system' && String(messages[i].content || '').includes(nome)) {
+                    messages.splice(i, 1);
+                }
+            }
+            messages.push({ role: 'system', content:
+                `A ferramenta "${nome}" NÃO está disponível nesta sessão. Não a chame e não procure `
+                + 'equivalente com outro nome: siga a tarefa com as ferramentas da sua lista. '
+                + 'Se nenhuma delas servir para o que foi pedido, diga isso ao usuário em uma frase, '
+                + 'em vez de desistir sem explicar.' });
+            if (fluxo) fluxo.fechar();
+            iteration--;
+            continue;
+        }
+
         if (streamError && !PARAR && (ehTetoDeToken(streamError) || ehTransitorio(streamError))) {
             if (fluxo) fluxo.fechar();
             // Conversa longa: encolher resolve, porque o peso é o histórico.

package/lib/repeticao.js

@@ -33,7 +33,12 @@
 'use strict';
 
 /** Tools cuja resposta é documento fixo — repetir é sempre desperdício. */
-const REFERENCIAS = new Set(['studio_manual', 'studio_spec']);
+/* O documento fixo que NÃO pode encolher na conversa. Eram o manual e a spec
+   do Estúdio antigo; o Estúdio novo não tem manual porque não tem formato a
+   decorar. Quem ocupa esse lugar é a PAUTA do diretor, escrita uma vez, que o
+   produtor relê enquanto monta as cenas — encolhê-la faz o modelo chamar o
+   diretor de novo, que é o laço que isto existe para evitar. */
+const REFERENCIAS = new Set(['planejar_producao', 'estudio_site']);
 
 /** Acima disto, duas buscas são a mesma busca. */
 const LIMITE_SEMELHANCA = 0.6;

package/lib/tools.js

@@ -429,8 +429,9 @@ async function despachar(name, args, ctx) {
                     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.',
+                            + 'Vídeo se faz no Estúdio: estudio_projeto (criar) → planejar_producao → estudio_plano → '
+                            + 'estudio_render. O render devolve o CAMINHO do arquivo — é esse o vídeo. '
+                            + 'Não monte vídeo com ffmpeg à mão.',
                     };
                 }
                 const filePath = resolveInProject(args.path, projectDir);
@@ -610,14 +611,38 @@ async function despachar(name, args, ctx) {
                    divergir do catálogo daqui, e ela se conserta lá. Mas a rede
                    é o que separa uma tarefa que se recupera de uma que morre
                    com o usuário esperando. */
-                return {
-                    ok: false,
-                    error: `A ferramenta "${name}" não existe.`,
-                    parecidas: catalogo.parecidasCom(name),
-                    comoResolver: 'chame uma das ferramentas que existem de verdade — as "parecidas" '
-                        + 'acima são as de nome mais próximo. Não invente nome de ferramenta, e não '
-                        + 'desista da tarefa por causa disto.',
-                };
+                {
+                    /* O CASO QUE ACONTECE DE VERDADE tem nome: o servidor
+                       está desatualizado e continua oferecendo o Estúdio
+                       antigo (studio_criar, studio_spec…). Visto ao vivo, e a
+                       reação do modelo foi a pior possível: chutou nomes de
+                       outro produto (`repo_browser.read_file`), tentou
+                       escrever um .mp4 com write_file, e desistiu com "parei
+                       sem concluir" — sem nunca dizer ao usuário qual era o
+                       problema.
+
+                       Então a resposta separa os dois casos. Para o Estúdio
+                       velho ela EXPLICA o que houve e manda diagnosticar em
+                       voz alta se as novas não estiverem na lista dele: um
+                       "o servidor está desatualizado" é acionável; um "parei
+                       sem concluir" não é. */
+                    const velhoEstudio = /^studio_/.test(String(name));
+                    return {
+                        ok: false,
+                        error: `A ferramenta "${name}" não existe.`,
+                        parecidas: catalogo.parecidasCom(name),
+                        comoResolver: velhoEstudio
+                            ? 'O Estúdio foi TROCADO: studio_* não existe mais. As ferramentas de hoje são '
+                              + 'planejar_producao, estudio_projeto, estudio_plano, estudio_midia, estudio_narrar, '
+                              + 'estudio_video, estudio_render e estudio_site. Use-as. '
+                              + 'Se ELAS não estiverem na sua lista de ferramentas, o servidor está desatualizado: '
+                              + 'PARE de tentar outros nomes e diga isso ao usuário em uma frase — é o que ele '
+                              + 'precisa saber para resolver.'
+                            : 'Chame uma das ferramentas que existem de verdade; as "parecidas" acima são as de '
+                              + 'nome mais próximo. NÃO invente nome de ferramenta e não tente variações — se '
+                              + 'nenhuma servir, diga ao usuário o que faltou, em vez de desistir calado.',
+                    };
+                }
         }
     }
 }

package/lib/ui.js

@@ -295,12 +295,18 @@ const ROTULOS = {
         desktop_drag:'Desktop·drag', desktop_type:'Desktop·type', desktop_key:'Desktop·key',
         desktop_scroll:'Desktop·scroll', desktop_size:'Desktop·size',
         desktop_double_click:'Desktop·2click', desktop_open_app:'Desktop·app',
-        studio_manual:'Estúdio·manual', studio_spec:'Estúdio·spec', studio_criar:'Estúdio·criar',
-        studio_ler:'Estúdio·ler', studio_atualizar:'Estúdio·ajustar', studio_listar:'Estúdio·lista',
-        studio_versoes:'Estúdio·histórico',
+        /* Os nomes do Estúdio ATUAL. Os antigos (studio_manual, studio_spec,
+           studio_criar…) saíram daqui de propósito: enquanto estavam, uma
+           chamada a ferramenta que não existe mais aparecia na tela com
+           rótulo bonito ("Estúdio·spec corte"), como se fosse trabalho
+           legítimo — e só a linha de baixo revelava que tinha falhado. */
+        planejar_producao:'Diretor', estudio_projeto:'Estúdio·projeto',
+        estudio_plano:'Estúdio·plano', estudio_narrar:'Estúdio·narração',
+        estudio_video:'Estúdio·vídeo', estudio_render:'Estúdio·render',
+        estudio_site:'Estúdio·marca',
         desktop_windows:'Desktop·janelas', desktop_focus:'Desktop·foco',
         desktop_elements:'Desktop·elementos', desktop_click_element:'Desktop·click',
-    studio_midia:'Estúdio·mídia', studio_analisar:'Estúdio·analisar', construir_app:'Construir',
+    estudio_midia:'Estúdio·mídia', construir_app:'Construir',
     remember_general:'Lembrar',
 };
 
@@ -343,6 +349,22 @@ function friendlyError(raw) {
         }
     } catch {}
 
+    /* FERRAMENTA QUE NÃO ESTÁ NA LISTA DO PEDIDO.
+       O provedor recusa a chamada e devolve, em inglês:
+       "tool call validation failed: attempted to call tool 'X' which was not
+       in request.tools". Isso saía cru na tela e a tarefa morria ali.
+
+       A causa é sempre a mesma e não é do usuário: o servidor declara um
+       conjunto de ferramentas e o cliente esperava outro. Então a frase diz o
+       que É — em português — e aponta para o que resolve. */
+    const foraDaLista = s.match(/attempted to call tool '([^']+)' which was not in request\.tools/i);
+    if (foraDaLista) {
+        return `O servidor não ofereceu a ferramenta "${foraDaLista[1]}" nesta chamada, `
+            + 'então ela foi recusada. Isso acontece quando o servidor está numa versão '
+            + 'anterior à do aplicativo. Confira em /status; se persistir, o servidor precisa '
+            + 'ser atualizado.';
+    }
+
     // Falta de saldo: nem bug, nem espera. O provedor diz quanto a conta paga,
     // e o servidor já refaz o pedido com esse teto — se ainda assim chegou aqui,
     // é porque nem o mínimo cabe.

package/lib/voz.js

@@ -125,7 +125,13 @@ function conferir() {
 
     const pip = falta.filter((f) => f.pacote).map((f) => f.pacote);
     const linhas = [];
-    if (pip.length) linhas.push(`${py} -m pip install ${pip.join(' ')}`);
+    /* O comando que a pessoa vai COPIAR precisa funcionar na máquina dela.
+       Mandar `pip install` seco é mandar ela bater na PEP 668 de novo,
+       exatamente no mesmo lugar onde o botão "Instalar agora?" já bateu. */
+    if (pip.length) {
+        linhas.push(`${py} -m pip install --user ${pip.join(' ')}`);
+        linhas.push(`(se recusar com "externally-managed-environment", acrescente --break-system-packages)`);
+    }
     if (falta.some((f) => f.modulo === 'sounddevice' && f.sistema)) {
         linhas.push(COMO_SISTEMA.portaudio[process.platform] || COMO_SISTEMA.portaudio.linux);
     }
@@ -146,16 +152,61 @@ function conferir() {
 }
 
 /** Instala o que dá para instalar com pip. O tkinter não passa por aqui. */
+/* AS TENTATIVAS, EM ORDEM — e por que uma só não serve.
+ *
+ * O Python do Homebrew e o do Debian/Ubuntu RECUSAM `pip install` no ambiente
+ * do sistema: é a PEP 668, "externally-managed-environment". Uma tentativa
+ * só, sem `--break-system-packages`, falha sempre nessas máquinas — e foi o
+ * que aconteceu com o dono, no Mac dele, ao aceitar "Instalar agora?".
+ *
+ * A ordem vai da menos invasiva para a mais: `--user` primeiro, que não toca
+ * no Python do sistema; a quebra do bloqueio só quando o resto falhou.
+ */
+const TENTATIVAS_PIP = [
+    (pacotes) => ['-m', 'pip', 'install', '--user', '--quiet', ...pacotes],
+    (pacotes) => ['-m', 'pip', 'install', '--user', '--quiet', '--break-system-packages', ...pacotes],
+    (pacotes) => ['-m', 'pip', 'install', '--quiet', ...pacotes],
+    (pacotes) => ['-m', 'pip', 'install', '--quiet', '--break-system-packages', ...pacotes],
+];
+
+/** A linha que interessa de um despejo do pip. */
+function porqueOPipFalhou(saida) {
+    const texto = String(saida || '').trim();
+    if (!texto) return '';
+    if (/externally-managed-environment/i.test(texto)) {
+        return 'o Python desta máquina não deixa instalar no ambiente do sistema (PEP 668)';
+    }
+    /* A linha que começa com "error:" é a que o pip escreveu para ser lida.
+       Cortar os últimos 400 caracteres — o que se fazia antes — pega o MEIO
+       de uma frase: o dono viu "não deu: n result in a broken Homebrew
+       installation", que não é português nem inglês. */
+    const erro = texto.split('\n').reverse().find((l) => /^\s*error:/i.test(l));
+    if (erro) return erro.replace(/^\s*error:\s*/i, '').trim().slice(0, 200);
+    const ultima = texto.split('\n').filter((l) => l.trim()).pop() || '';
+    return ultima.trim().slice(0, 200);
+}
+
 function instalar(py, pacotes, aoFalar = () => {}) {
     return new Promise((resolve) => {
         aoFalar(`instalando ${pacotes.join(', ')} (uma vez, alguns minutos)`);
-        const p = spawn(py, ['-m', 'pip', 'install', '--quiet', ...pacotes]);
-        let erro = '';
-        p.stderr.on('data', (d) => { erro += d.toString(); });
-        p.on('close', (code) => resolve(code === 0
-            ? { ok: true }
-            : { ok: false, error: erro.slice(-400).trim() || `pip saiu com ${code}` }));
-        p.on('error', (e) => resolve({ ok: false, error: e.message }));
+        let ultimoErro = '';
+
+        const tentar = (i) => {
+            if (i >= TENTATIVAS_PIP.length) {
+                return resolve({ ok: false, error: ultimoErro || 'o pip não conseguiu instalar' });
+            }
+            const p = spawn(py, TENTATIVAS_PIP[i](pacotes));
+            let saida = '';
+            p.stderr.on('data', (d) => { saida += d.toString(); });
+            p.stdout.on('data', (d) => { saida += d.toString(); });
+            p.on('close', (code) => {
+                if (code === 0) return resolve({ ok: true });
+                ultimoErro = porqueOPipFalhou(saida) || `pip saiu com ${code}`;
+                tentar(i + 1);
+            });
+            p.on('error', (e) => { ultimoErro = e.message; tentar(i + 1); });
+        };
+        tentar(0);
     });
 }
 
@@ -336,4 +387,4 @@ print(json.dumps(desperta.baixar_modelo()))
     });
 }
 
-module.exports = { conferir, instalar, abrir, conferirEspera, baixarEspera, python, COMO_FALAR, PASTA };
+module.exports = { conferir, instalar, porqueOPipFalhou, abrir, conferirEspera, baixarEspera, python, COMO_FALAR, PASTA };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "primocode",
-  "version": "9.2.0",
+  "version": "9.2.2",
   "description": "PrimoCode — agente de engenharia com IA e cursor próprio. Requer conta Conecta Primo AI (Premium ou Super). 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": {

package/studio/edge.py

@@ -120,9 +120,19 @@ def disponivel():
 def _rotina_instalar():
     global _instalando, _verificado
     try:
-        subprocess.run(
-            [sys.executable, "-m", "pip", "install", "--user", "--quiet", "edge-tts"],
-            stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL, timeout=180)
+        # As mesmas tentativas do narrar.py: `--user` sozinho é recusado pelo
+        # Python do Homebrew e do Debian/Ubuntu (PEP 668), e uma tentativa só
+        # falha sempre nessas máquinas — calada, porque a saída vai para o
+        # DEVNULL. A narração então cai na voz de reserva e o vídeo sai com
+        # outra voz, sem ninguém saber por quê.
+        for args in (["-m", "pip", "install", "--user", "--quiet", "edge-tts"],
+                     ["-m", "pip", "install", "--user", "--quiet", "--break-system-packages", "edge-tts"],
+                     ["-m", "pip", "install", "--quiet", "edge-tts"],
+                     ["-m", "pip", "install", "--quiet", "--break-system-packages", "edge-tts"]):
+            r = subprocess.run([sys.executable] + args,
+                               stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL, timeout=180)
+            if r.returncode == 0:
+                break
     except Exception as e:
         sys.stderr.write("[edge] pip install falhou: %s\n" % e)
     finally:

package/studio/pessoa.py

@@ -72,12 +72,27 @@ def faltando():
 
 
 def instalar(pacotes):
-    try:
-        subprocess.run([sys.executable, "-m", "pip", "install", "--quiet", *pacotes],
-                       capture_output=True, timeout=900, check=True)
-        return not faltando()
-    except Exception:
-        return False
+    """Traz os pacotes, tentando na ordem da menos invasiva para a mais.
+
+    Uma tentativa só não serve: o Python do Homebrew e o do Debian/Ubuntu
+    recusam instalar no ambiente do sistema (PEP 668,
+    "externally-managed-environment"), e nessas máquinas a instalação falharia
+    sempre — aqui, calada, porque a saída é capturada e o except engole.
+    """
+    tentativas = (
+        ["-m", "pip", "install", "--user", "--quiet", *pacotes],
+        ["-m", "pip", "install", "--user", "--quiet", "--break-system-packages", *pacotes],
+        ["-m", "pip", "install", "--quiet", *pacotes],
+        ["-m", "pip", "install", "--quiet", "--break-system-packages", *pacotes],
+    )
+    for args in tentativas:
+        try:
+            r = subprocess.run([sys.executable] + args, capture_output=True, timeout=900)
+            if r.returncode == 0 and not faltando():
+                return True
+        except Exception:
+            continue
+    return False
 
 
 def recortar(entrada, saida, suavizar=7, encolher=2, limiar=0.6):
@@ -176,7 +191,9 @@ def main():
 
     if args.comando == "conferir":
         saida = {"ok": not falta, "falta": falta,
-                 "comoResolver": f"{sys.executable} -m pip install " + " ".join(falta) if falta else None}
+                 "comoResolver": (f"{sys.executable} -m pip install --user " + " ".join(falta)
+                                  + ' (se recusar com "externally-managed-environment",'
+                                    " acrescente --break-system-packages)") if falta else None}
     else:
         if falta:
             # A instalação é pesada (o MediaPipe passa de 100 MB) e demora.