primocode 9.2.1 → 9.2.3

package/README.md

@@ -1,4 +1,4 @@
-# PrimoCode v9.2.1
+# PrimoCode v9.2.3
 
 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.1
+ ▐▛███▜▌   Primo Code v9.2.3
 ▝▜█████▛▘  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/estudio/index.js

@@ -81,6 +81,31 @@ function rodarPython(script, args, { timeout = 20 * 60000 } = {}) {
 
 // ── estudio_projeto ──────────────────────────────────────────────────────
 
+/**
+ * A queixa quando o projeto não aparece — e ela muda conforme o motivo.
+ *
+ * "não achei o projeto 'undefined'" é o que o agente recebia ao chamar a
+ * ferramenta SEM id, e não ensina nada: ele não sabe se inventou o id, se o
+ * projeto sumiu, ou se esqueceu o argumento. Visto em produção — o modelo
+ * chamou `estudio_plano` sem id e ficou repetindo a chamada.
+ */
+function semProjeto(id) {
+    if (id == null || String(id).trim() === '') {
+        return {
+            ok: false,
+            error: 'faltou dizer em qual projeto (id).',
+            comoResolver: 'crie um com estudio_projeto acao:"criar" e use o id que ele devolve, '
+                + 'ou ache o existente com acao:"listar" / acao:"procurar".',
+        };
+    }
+    return {
+        ok: false,
+        error: `não achei o projeto "${id}".`,
+        comoResolver: 'liste com estudio_projeto acao:"listar" e use um id de lá — '
+            + 'o id é o nome da pasta (ex: "2026-09-22-anuncio-picpay"), não o título.',
+    };
+}
+
 async function ferramentaProjeto(args) {
     const acao = String(args.acao || 'listar').toLowerCase();
 
@@ -93,7 +118,7 @@ async function ferramentaProjeto(args) {
 
     if (acao === 'abrir' || acao === 'ler') {
         const p = projeto.ler(args.id);
-        if (!p) return { ok: false, error: `não achei o projeto "${args.id}". Use acao:"procurar".` };
+        if (!p) return semProjeto(args.id);
         const pl = projeto.lerPlano(args.id);
         return {
             ok: true, projeto: p,
@@ -142,7 +167,7 @@ function listarArquivos(pasta) {
 
 async function ferramentaPlano(args) {
     const p = projeto.ler(args.id);
-    if (!p) return { ok: false, error: `não achei o projeto "${args.id}".` };
+    if (!p) return semProjeto(args.id);
 
     if (args.voltarPara) return projeto.voltarPara(args.id, args.voltarPara);
 
@@ -193,7 +218,7 @@ async function ferramentaPlano(args) {
 async function ferramentaMidia(args) {
     const acao = String(args.acao || 'imagem').toLowerCase();
     const p = args.id ? projeto.ler(args.id) : null;
-    if (args.id && !p) return { ok: false, error: `não achei o projeto "${args.id}".` };
+    if (args.id && !p) return semProjeto(args.id);
 
     if (acao === 'fontes') {
         if (args.conferir) return assets.conferirFonte(args.conferir);
@@ -282,7 +307,7 @@ async function ferramentaNarrar(args) {
     if (args.vozes) return rodarPython('narrar.py', ['vozes'], { timeout: 30000 });
 
     const p = projeto.ler(args.id);
-    if (!p) return { ok: false, error: `não achei o projeto "${args.id}".` };
+    if (!p) return semProjeto(args.id);
     const texto = String(args.texto || '').trim();
     if (!texto) return { ok: false, error: 'não há texto para narrar.' };
 
@@ -313,7 +338,7 @@ async function ferramentaNarrar(args) {
 async function ferramentaVideo(args, ctx = {}) {
     const acao = String(args.acao || 'medir').toLowerCase();
     const p = projeto.ler(args.id);
-    if (!p) return { ok: false, error: `não achei o projeto "${args.id}".` };
+    if (!p) return semProjeto(args.id);
 
     const pronto = video.conferir();
     if (!pronto.ok) return pronto;
@@ -436,7 +461,7 @@ async function transcrever(p, alvo, ctx) {
 
 async function ferramentaRender(args, ctx = {}) {
     const p = projeto.ler(args.id);
-    if (!p) return { ok: false, error: `não achei o projeto "${args.id}".` };
+    if (!p) return semProjeto(args.id);
     const pl = projeto.lerPlano(args.id);
     if (!pl) return { ok: false, error: 'não há plano neste projeto.' };
 

package/lib/estudio/projeto.js

@@ -103,13 +103,38 @@ function lerJSON(arquivo, padrao = null) {
     try { return JSON.parse(fs.readFileSync(arquivo, 'utf8')); } catch { return padrao; }
 }
 
-const pastaDe = (id) => path.join(PROJETOS, id);
+/**
+ * A pasta de um projeto — ou null, quando o id não serve.
+ *
+ * ── POR QUE ISTO VALIDA, EM VEZ DE SÓ CONCATENAR ────────────────────────
+ * O `id` vem do MODELO, e o modelo erra de dois jeitos que doem aqui:
+ *
+ * 1. Não manda nada. Visto em produção: o agente chamou `estudio_plano` sem
+ *    `id`, o `path.join` recebeu `undefined` e a tool explodiu com
+ *    'The "path" argument must be of type string. Received undefined' — uma
+ *    mensagem que não fala de projeto nenhum, e que o agente não tem como
+ *    corrigir porque não diz o que faltou. A checagem de "achei o projeto?"
+ *    vinha DEPOIS, e nunca era alcançada.
+ *
+ * 2. Manda um id com caminho dentro ("../../etc/passwd", "/tmp/x"). O
+ *    `path.join` obedece: sobe de pasta e sai da casa dos projetos. O id de
+ *    um projeto é um nome de pasta, não um caminho — então tudo que tem
+ *    barra ou `..` é recusado, em vez de resolvido.
+ */
+function pastaDe(id) {
+    if (typeof id !== 'string' || !id.trim()) return null;
+    const limpo = id.trim();
+    if (limpo.includes('/') || limpo.includes('\\') || limpo.includes('..')) return null;
+    return path.join(PROJETOS, limpo);
+}
 
 /** O meta de um projeto, ou null. */
 function ler(id) {
-    const meta = lerJSON(path.join(pastaDe(id), 'projeto.json'));
+    const pasta = pastaDe(id);
+    if (!pasta) return null;
+    const meta = lerJSON(path.join(pasta, 'projeto.json'));
     if (!meta) return null;
-    return { ...meta, pasta: pastaDe(id) };
+    return { ...meta, pasta };
 }
 
 function salvar(id, mudancas) {
@@ -142,17 +167,21 @@ function listar({ limite = 50 } = {}) {
  * perde um caderno quando o processo morre no meio.
  */
 function anotar(id, tipo, texto, extra = {}) {
+    const pasta = pastaDe(id);
+    if (!pasta) return false;
     const linha = JSON.stringify({ quando: agora(), tipo, texto: String(texto || ''), ...extra });
     try {
-        fs.mkdirSync(pastaDe(id), { recursive: true });
-        fs.appendFileSync(path.join(pastaDe(id), 'caderno.jsonl'), linha + '\n', 'utf8');
+        fs.mkdirSync(pasta, { recursive: true });
+        fs.appendFileSync(path.join(pasta, 'caderno.jsonl'), linha + '\n', 'utf8');
         return true;
     } catch { return false; }
 }
 
 function caderno(id, { ultimas = 40 } = {}) {
+    const pasta = pastaDe(id);
+    if (!pasta) return [];
     let bruto = '';
-    try { bruto = fs.readFileSync(path.join(pastaDe(id), 'caderno.jsonl'), 'utf8'); } catch { return []; }
+    try { bruto = fs.readFileSync(path.join(pasta, 'caderno.jsonl'), 'utf8'); } catch { return []; }
     const linhas = bruto.split('\n').filter(Boolean).slice(-ultimas);
     return linhas.map((l) => { try { return JSON.parse(l); } catch { return null; } }).filter(Boolean);
 }
@@ -193,9 +222,11 @@ function procurar(texto, { limite = 5 } = {}) {
 
 // ── o plano ──────────────────────────────────────────────────────────────
 
-const planoDe = (id) => path.join(pastaDe(id), 'plano.json');
+// null quando o id não serve — e `lerJSON(null)` devolve null, que é o que
+// todo mundo aqui já sabe tratar.
+const planoDe = (id) => { const p = pastaDe(id); return p ? path.join(p, 'plano.json') : null; };
 
-function lerPlano(id) { return lerJSON(planoDe(id)); }
+function lerPlano(id) { const a = planoDe(id); return a ? lerJSON(a) : null; }
 
 /**
  * Grava o plano e guarda a versão anterior.
@@ -205,9 +236,11 @@ function lerPlano(id) { return lerJSON(planoDe(id)); }
  * nada é sobrescrito sem uma cópia ficar para trás.
  */
 function salvarPlano(id, plano, motivo = '') {
+    const pasta = pastaDe(id);
+    if (!pasta) return { ok: false, error: `Projeto "${id}" não existe.` };
     const anterior = lerPlano(id);
     if (anterior) {
-        const versoes = path.join(pastaDe(id), 'versoes');
+        const versoes = path.join(pasta, 'versoes');
         fs.mkdirSync(versoes, { recursive: true });
         const n = fs.readdirSync(versoes).filter((f) => f.endsWith('.json')).length + 1;
         escreverJSON(path.join(versoes, `${String(n).padStart(3, '0')}.json`), anterior);
@@ -218,12 +251,16 @@ function salvarPlano(id, plano, motivo = '') {
 }
 
 function versoes(id) {
-    const dir = path.join(pastaDe(id), 'versoes');
+    const pasta = pastaDe(id);
+    if (!pasta) return [];
+    const dir = path.join(pasta, 'versoes');
     try { return fs.readdirSync(dir).filter((f) => f.endsWith('.json')).sort(); } catch { return []; }
 }
 
 function voltarPara(id, versao) {
-    const arquivo = path.join(pastaDe(id), 'versoes', versao);
+    const pasta = pastaDe(id);
+    if (!pasta) return { ok: false, error: `Projeto "${id}" não existe.` };
+    const arquivo = path.join(pasta, 'versoes', String(versao || '').replace(/[^\w.-]+/g, ''));
     const plano = lerJSON(arquivo);
     if (!plano) return { ok: false, error: `Versão "${versao}" não existe.` };
     salvarPlano(id, plano, `voltou para a versão ${versao}`);
@@ -232,9 +269,11 @@ function voltarPara(id, versao) {
 
 /** Onde guardar uma mídia baixada, com nome que não colide. */
 function caminhoDeMidia(id, nome) {
+    const pasta = pastaDe(id);
+    if (!pasta) return null;
     const limpo = String(nome || 'arquivo').replace(/[^\w.-]+/g, '-').slice(-60);
     const marca = crypto.randomBytes(3).toString('hex');
-    return path.join(pastaDe(id), 'midia', `${marca}-${limpo}`);
+    return path.join(pasta, 'midia', `${marca}-${limpo}`);
 }
 
 module.exports = {

package/lib/ui.js

@@ -349,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.1",
+  "version": "9.2.3",
   "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.