primocode 9.7.0 → 9.8.0-beta.1

package/lib/local/provedor.js

@@ -0,0 +1,151 @@
+/**
+ * provedor.js — a chave da própria pessoa, e com qual IA ela fala.
+ *
+ *   "Fica batendo no limite. Coloca um comando /provider onde você seleciona
+ *    se é Gemini, ChatGPT etc., cola a key e ela roda local com a key
+ *    configurada." (23/09/2026)
+ *
+ * Com um provedor configurado (/api), o agente fala DIRETO com a API dele, daqui da
+ * máquina (lib/local/motor.js). O servidor e a cota compartilhada saem do
+ * caminho: o limite passa a ser o da conta da pessoa.
+ *
+ * ── ONDE A CHAVE MORA ────────────────────────────────────────────────────
+ * Em `~/.primocode/provedor.json`, permissão 600. Não no config.json: esse é
+ * o arquivo que alguém abre para conferir um ajuste ou cola num chamado.
+ *
+ * ── O QUE NUNCA APARECE ──────────────────────────────────────────────────
+ * A chave inteira — nem ao listar, nem num erro. Mostra-se o começo e o fim,
+ * o bastante para reconhecer qual é.
+ *
+ * Todos falam o formato de chat da OpenAI (/chat/completions, tools, stream):
+ * é o que Gemini, Claude, Groq, OpenRouter e DeepSeek aceitam também. Um
+ * cliente só, e o provedor é só o endereço, o modelo e a chave.
+ */
+
+'use strict';
+
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+
+const ARQUIVO = () => path.join(os.homedir(), '.primocode', 'provedor.json');
+
+/* A ordem é a do menu. `modelos` é a preferência: ao colar a chave, fica o
+   primeiro que a conta da pessoa de fato tem (a lista vem da própria API). */
+const PROVEDORES = {
+    gemini: {
+        nome: 'Gemini (Google)',
+        base: 'https://generativelanguage.googleapis.com/v1beta/openai',
+        modelos: ['gemini-2.5-flash', 'gemini-2.5-pro', 'gemini-2.0-flash'],
+        onde: 'https://aistudio.google.com/apikey',
+        dica: 'tem plano grátis',
+    },
+    chatgpt: {
+        nome: 'ChatGPT (OpenAI)',
+        base: 'https://api.openai.com/v1',
+        modelos: ['gpt-5-mini', 'gpt-5', 'gpt-4.1-mini', 'gpt-4o-mini'],
+        onde: 'https://platform.openai.com/api-keys',
+        dica: 'pago por uso',
+    },
+    claude: {
+        nome: 'Claude (Anthropic)',
+        base: 'https://api.anthropic.com/v1',
+        modelos: ['claude-sonnet-5', 'claude-haiku-4-5-20251001', 'claude-opus-5-5'],
+        onde: 'https://console.anthropic.com/settings/keys',
+        dica: 'pago por uso',
+    },
+    groq: {
+        nome: 'Groq',
+        base: 'https://api.groq.com/openai/v1',
+        modelos: ['openai/gpt-oss-120b', 'llama-3.3-70b-versatile', 'openai/gpt-oss-20b'],
+        onde: 'https://console.groq.com/keys',
+        dica: 'tem plano grátis, muito rápido',
+    },
+    openrouter: {
+        nome: 'OpenRouter',
+        base: 'https://openrouter.ai/api/v1',
+        modelos: ['openai/gpt-oss-120b', 'google/gemini-2.5-flash', 'anthropic/claude-sonnet-5'],
+        onde: 'https://openrouter.ai/keys',
+        dica: 'vários modelos numa chave só',
+    },
+    deepseek: {
+        nome: 'DeepSeek',
+        base: 'https://api.deepseek.com/v1',
+        modelos: ['deepseek-chat'],
+        onde: 'https://platform.deepseek.com/api_keys',
+        dica: 'barato',
+    },
+};
+
+/** A chave, irreconhecível para quem olha por cima do ombro. */
+function mascarar(chave) {
+    const k = String(chave || '');
+    if (k.length <= 10) return '••••';
+    return `${k.slice(0, 4)}…${k.slice(-4)}`;
+}
+
+let cache = null;
+let cacheMtime = 0;
+
+/** O provedor configurado, ou null (= segue pelo servidor, como sempre). */
+function atual() {
+    if (process.env.PRIMOCODE_SEM_PROVEDOR === '1') return null;
+    let st;
+    try { st = fs.statSync(ARQUIVO()); } catch { cache = null; return null; }
+    if (cache && st.mtimeMs === cacheMtime) return cache;
+    try {
+        const j = JSON.parse(fs.readFileSync(ARQUIVO(), 'utf8'));
+        const p = PROVEDORES[j.provedor];
+        cache = p && j.chave ? { id: j.provedor, nome: p.nome, base: j.base || p.base, modelo: j.modelo || p.modelos[0], chave: j.chave } : null;
+    } catch { cache = null; }
+    cacheMtime = st.mtimeMs;
+    return cache;
+}
+
+function salvar({ provedor, chave, modelo }) {
+    if (!PROVEDORES[provedor]) throw new Error(`provedor desconhecido: ${provedor}`);
+    const arq = ARQUIVO();
+    fs.mkdirSync(path.dirname(arq), { recursive: true });
+    fs.writeFileSync(arq, JSON.stringify({ provedor, chave: String(chave).trim(), modelo }, null, 2), { mode: 0o600 });
+    try { fs.chmodSync(arq, 0o600); } catch { /* Windows */ }
+    cache = null;
+    return atual();
+}
+
+function trocarModelo(modelo) {
+    const a = atual();
+    if (!a) return null;
+    return salvar({ provedor: a.id, chave: a.chave, modelo });
+}
+
+function desligar() {
+    try { fs.unlinkSync(ARQUIVO()); } catch { /* já não havia */ }
+    cache = null;
+}
+
+/** A chave colada serve? Pergunta a lista de modelos à própria API. */
+async function conferir(provedor, chave, { buscar = fetch } = {}) {
+    const p = PROVEDORES[provedor];
+    let r;
+    try {
+        r = await buscar(`${p.base}/models`, {
+            headers: { Authorization: `Bearer ${String(chave).trim()}` },
+            signal: AbortSignal.timeout(15000),
+        });
+    } catch (e) {
+        return { ok: false, error: `não consegui falar com ${p.nome}: ${e.message}` };
+    }
+    if (r.status === 401 || r.status === 403) return { ok: false, error: `${p.nome} recusou a chave (${r.status}). Confira se copiou inteira.` };
+    if (!r.ok) return { ok: false, error: `${p.nome} respondeu ${r.status} ao conferir a chave.` };
+    let lista = [];
+    try {
+        const j = await r.json();
+        lista = (j.data || j.models || []).map((m) => String(m.id || m.name || '').replace(/^models\//, '')).filter(Boolean);
+    } catch { /* sem lista: fica a preferência */ }
+    // Nenhum da preferência na lista (ou lista vazia): fica o primeiro dela, e
+    // `/api modelo <nome>` troca.
+    const modelo = p.modelos.find((m) => lista.includes(m)) || p.modelos[0];
+    return { ok: true, modelo, disponiveis: lista };
+}
+
+module.exports = { PROVEDORES, ARQUIVO, mascarar, atual, salvar, trocarModelo, desligar, conferir };

package/lib/nome-projeto.js

@@ -0,0 +1,97 @@
+/**
+ * nome-projeto.js — quem dá nome à pasta é quem entendeu o pedido.
+ *
+ *   "Quero que ele dê nome às pastas que criar. Ele escolhe o nome, ele
+ *    entendeu o contexto, ele analisa os outros projetos." (23/09/2026)
+ *
+ * O nome saía de `deriveProjectName`: cortar as palavras de abertura da frase
+ * e ficar com até quatro. Funciona para "crie um jogo de carro", e erra tudo
+ * que não começa assim — "aquela ideia do cardápio que falei, bora fazer" vira
+ * `aquela-ideia-do-cardapio`. Quem sabe o que está sendo feito é o modelo.
+ *
+ * ── COMO ─────────────────────────────────────────────────────────────────
+ * Uma pergunta curta ao modelo, com o pedido e os nomes das pastas que já
+ * existem, para ele seguir o mesmo jeito (idioma, tamanho, prefixo). Ela
+ * roda em PARALELO com o trabalho: a pasta só nasce na primeira escrita, e
+ * até lá a resposta já chegou. Se não chegou, ou veio lixo, vale o nome de
+ * antes — nome pior é melhor que pasta nenhuma.
+ *
+ * Puro, menos `escolher`, que recebe quem pergunta de fora (teste sem rede).
+ */
+
+'use strict';
+
+const { slugify } = require('./config.js');
+
+// Nome que não diz nada: o modelo devolveu isso, é como não ter respondido.
+const GENERICOS = new Set(['projeto', 'project', 'app', 'site', 'novo', 'teste', 'test', 'meu-projeto', 'my-project']);
+const TEMPO_MAXIMO_MS = 8000;
+
+/** O jeito das pastas que a pessoa já tem, para o modelo seguir. */
+function convencao(nomes) {
+    const lista = (nomes || []).filter((n) => n && !n.startsWith('.'));
+    if (!lista.length) return null;
+    const hifen = lista.filter((n) => n.includes('-')).length;
+    const sublinhado = lista.filter((n) => n.includes('_')).length;
+    const separador = sublinhado > hifen ? '_' : '-';
+    const palavras = lista.map((n) => n.split(/[-_]/).length);
+    const media = Math.round(palavras.reduce((a, b) => a + b, 0) / palavras.length);
+    return { separador, palavras: Math.min(4, Math.max(1, media)), exemplos: lista.slice(0, 12) };
+}
+
+/** A pergunta. Curta: vai numa chamada à parte, e cada token conta. */
+function pergunta(pedido, nomes) {
+    const c = convencao(nomes);
+    const jeito = c
+        ? `Pastas que a pessoa já tem: ${c.exemplos.join(', ')}. Siga o mesmo jeito (idioma, tamanho, separador "${c.separador}"), `
+          + 'e NÃO repita um nome que já existe.'
+        : 'Use kebab-case em português, de 1 a 3 palavras.';
+    return 'Dê um nome curto para a pasta do projeto deste pedido. O nome diz O QUE é '
+        + '(ex.: site-padaria, jogo-de-carro, loja-roupas), nunca o que a pessoa pediu para fazer. '
+        + `${jeito} Responda SÓ com o nome, sem aspas e sem explicação.\n\nPEDIDO: ${String(pedido || '').slice(0, 600)}`;
+}
+
+/** Limpa a resposta do modelo. Devolve null quando não dá para confiar nela. */
+function limpar(resposta, nomes) {
+    const primeira = String(resposta || '').trim().split('\n')[0]
+        .replace(/^[`"'*\s]+|[`"'*.\s]+$/g, '')
+        .replace(/^(nome|pasta)\s*:\s*/i, '');
+    if (!primeira || primeira.length > 60 || primeira.split(/\s+/).length > 5) return null;
+    const c = convencao(nomes);
+    let nome = slugify(primeira).split('-').filter(Boolean).slice(0, 4).join('-');
+    if (!nome || GENERICOS.has(nome)) return null;
+    if (c && c.separador === '_') nome = nome.replace(/-/g, '_');
+    return semColisao(nome, nomes);
+}
+
+/** Nome que já existe ganha -2, -3… — escrever na pasta de outro projeto é pior que um sufixo. */
+function semColisao(nome, nomes) {
+    const tomados = new Set((nomes || []).map((n) => String(n).toLowerCase()));
+    if (!tomados.has(nome)) return nome;
+    for (let i = 2; i < 100; i++) {
+        const outro = `${nome}-${i}`;
+        if (!tomados.has(outro)) return outro;
+    }
+    return `${nome}-${Date.now()}`;
+}
+
+/**
+ * Pergunta o nome ao modelo. Nunca rejeita: sem resposta boa a tempo,
+ * devolve null e quem chamou fica com o nome de antes.
+ *
+ * `perguntar(texto)` → Promise<string> é quem fala com o servidor.
+ */
+async function escolher({ pedido, nomes, perguntar, tempo = TEMPO_MAXIMO_MS }) {
+    let relogio;
+    const estourou = new Promise((r) => { relogio = setTimeout(() => r(null), tempo); });
+    try {
+        const resposta = await Promise.race([perguntar(pergunta(pedido, nomes)), estourou]);
+        return resposta == null ? null : limpar(resposta, nomes);
+    } catch {
+        return null;
+    } finally {
+        clearTimeout(relogio);
+    }
+}
+
+module.exports = { convencao, pergunta, limpar, semColisao, escolher, GENERICOS };

package/lib/repeticao.js

@@ -83,8 +83,61 @@ function consultaDe(nome, args) {
     return String(a.consulta || a.query || '');
 }
 
+/* ── A ÉPOCA: repetir depois de mudar algo não é repetir ────────────────
+ * Medido: "edita o arquivo → roda npm test → edita → roda npm test". O
+ * segundo `npm test` tinha os mesmos argumentos do primeiro e era barrado —
+ * o agente nunca via se o conserto funcionou, ficava três voltas sem rodar
+ * nada e morria com "peça em partes". O mesmo com reler um arquivo depois de
+ * editá-lo, ou tirar outra foto da tela depois de clicar.
+ *
+ * Então olhar o mundo (ler, listar, rodar teste, fotografar a tela) vale por
+ * ÉPOCA: cada mudança de verdade (escrever, editar, clicar, rodar um comando
+ * que não é só de leitura) abre uma época nova, e a mesma leitura volta a
+ * valer. O laço de verdade — a mesma chamada sem nada mudar no meio — segue
+ * barrado. Pesquisa na web e documento de referência não dependem do disco:
+ * ficam fora da época. */
+const OBSERVAM = new Set(['read_file', 'list_dir', 'glob', 'grep', 'browser_read', 'browser_screenshot',
+    'desktop_screenshot', 'desktop_size', 'desktop_windows', 'desktop_elements']);
+const NAO_MUDAM = new Set(['write_todos', 'remember_general', 'pesquisar_referencia', ...REFERENCIAS]);
+const SHELL_SO_LEITURA = /^\s*(ls|cat|head|tail|pwd|echo|grep|rg|find|wc|tree|stat|file|which|type|du|df|env|printenv|date|git\s+(status|log|diff|show|branch|remote))\b[^;&|>]*$/;
+
+function comandoDe(args) {
+    return String((args && (args.command || args.comando)) || '');
+}
+
+/** Só olha: ler de novo depois de uma mudança é trabalho, não laço. */
+function observa(nome, args) {
+    if (OBSERVAM.has(nome)) return true;
+    return nome === 'run_shell' && SHELL_SO_LEITURA.test(comandoDe(args));
+}
+
+/** Muda o mundo: abre uma época nova. */
+function muda(nome, args) {
+    return !observa(nome, args) && !NAO_MUDAM.has(nome);
+}
+
 function novo() {
-    return { vistos: new Map(), buscas: [] };
+    return { vistos: new Map(), buscas: [], epoca: 0, epocaDaMudanca: 0, ultimaMudanca: null, olhouDesde: false };
+}
+
+/**
+ * Avisa que a chamada RODOU. Quem chama faz isto depois de executar (e não
+ * de barrar): é o que abre a época nova.
+ *
+ * A mesma mudança repetida sem olhar nada no meio (escrever o mesmo conteúdo
+ * no mesmo arquivo, clicar no mesmo ponto às cegas) não abre época e é
+ * barrada já na segunda vez — senão o laço de escrita passaria livre.
+ */
+function executou(registro, nome, args) {
+    if (observa(nome, args)) { registro.olhouDesde = true; return; }
+    if (!muda(nome, args)) return;
+    const chave = assinatura(nome, args);
+    if (chave !== registro.ultimaMudanca || registro.olhouDesde) {
+        registro.epocaDaMudanca = registro.epoca;
+        registro.epoca++;
+    }
+    registro.ultimaMudanca = chave;
+    registro.olhouDesde = false;
 }
 
 /**
@@ -94,8 +147,14 @@ function novo() {
  * NÃO deve executar a tool: manda o `aviso` de volta como resultado.
  */
 function ver(registro, nome, args) {
-    const chave = assinatura(nome, args);
     const busca = consultaDe(nome, args);
+    const foraDaEpoca = busca !== null || REFERENCIAS.has(nome);
+    const base = assinatura(nome, args);
+    // A mesma mudança logo em seguida, sem olhar nada no meio, conta na época
+    // em que a primeira rodou — senão ela mesma abriria a porta da segunda.
+    const epoca = (base === registro.ultimaMudanca && !registro.olhouDesde)
+        ? registro.epocaDaMudanca : (registro.epoca || 0);
+    const chave = base + (foraDaEpoca ? '' : `@${epoca}`);
 
     let vezes = (registro.vistos.get(chave) || 0) + 1;
     let parecidaCom = null;
@@ -123,14 +182,15 @@ function ver(registro, nome, args) {
 function aviso(nome, vezes, parecidaCom) {
     const oQue = parecidaCom
         ? `Você já pesquisou isto: "${parecidaCom}". A busca de agora é a mesma coisa com outras palavras, e traria as mesmas fontes.`
-        : `Você já chamou ${nome} com estes mesmos argumentos.`;
+        : `Você já chamou ${nome} com estes mesmos argumentos, e nada mudou desde então.`;
 
     if (vezes === 2) {
         return `${oQue} O resultado está na conversa acima — role para cima e use o que já tem. `
             + 'Não chame esta tool de novo com os mesmos argumentos.';
     }
     return `${oQue} Esta é a ${vezes}ª vez, e a tool NÃO foi executada. PARE de repetir: `
-        + 'com o que você já tem, produza AGORA o resultado que o usuário pediu (crie o arquivo, o documento, o vídeo). '
+        + 'com o que você já tem, produza AGORA o resultado que o usuário pediu (crie o arquivo, o documento, o vídeo), '
+        + 'ou tente OUTRO caminho (outra ferramenta, outro arquivo, outro comando). '
         + 'Se algo realmente impede, chame finish e diga ao usuário o que faltou.';
 }
 
@@ -187,5 +247,5 @@ function referenciasNaConversa(messages) {
 module.exports = {
     REFERENCIAS, LIMITE_SEMELHANCA,
     normalizar, palavras, semelhanca, assinatura, consultaDe,
-    novo, ver, chamadasPorId, referenciasNaConversa,
+    novo, ver, executou, observa, muda, chamadasPorId, referenciasNaConversa,
 };

package/lib/tools.js

@@ -22,10 +22,24 @@ const cursor = require('./cursor');
  * ação acontece de verdade, e a pessoa VÊ a seta dele indo até lá, clicando,
  * digitando. Sem o cursor (outro sistema, ou o Python não subiu), vale o
  * caminho antigo do desktop.js. */
+/* Sem o cursor, a ação vai pelo caminho antigo, que NÃO aparece na tela. Isso
+   era calado: a pessoa via o terminal dizer "ok" e nada se mexer. Agora sai
+   uma linha, uma vez por sessão, dizendo por quê — e o modelo recebe o
+   mesmo aviso junto do resultado, para contar em vez de fingir. */
+let avisouSemCursor = false;
+function semCursorVisivel(resultado, motivo) {
+    const aviso = `o cursor do Primo não abriu (${motivo || 'motivo desconhecido'}): a ação roda, mas não aparece na tela`;
+    if (!avisouSemCursor) {
+        avisouSemCursor = true;
+        try { console.log(require('./ui.js').c.warn(`  ⎿ ${aviso}`)); } catch { /* sem tela */ }
+    }
+    return resultado && typeof resultado === 'object' ? { ...resultado, avisoCursor: aviso } : resultado;
+}
+
 async function peloCursor(cmd, args, reserva) {
     if (!cursor.disponivel()) return reserva();
     const r = await cursor.mandar(cmd, args);
-    if (r.semCursor) return reserva();
+    if (r.semCursor) return semCursorVisivel(await reserva(), r.error);
     if (!r.ok) return { ok: false, error: r.error || 'o cursor não conseguiu', ...(r.permissao === false ? { permissao: false } : {}) };
     return { ok: true };
 }

package/lib/voz.js

@@ -62,6 +62,12 @@ ${DICA_COMPUTADOR}
 Faça o trabalho inteiro normalmente, com as ferramentas de sempre. O que muda
 é só o jeito de contar no fim.`;
 
+/* A forma da resposta de CONVERSA por voz ("oi", "tudo bem?", "o que você
+   faz?"). Sem ferramenta e sem memória de tarefa: um "oi" ia para o agente
+   inteiro, com a lista das tarefas antigas e a ordem de mexer no cursor, e
+   ele respondia falando delas — "eu mandei oi e ele respondeu nada a ver". */
+const COMO_CONVERSAR = `[MODO VOZ] A sua resposta vai ser LIDA EM VOZ ALTA. Responda ao que a pessoa acabou de dizer, e só a isso, em uma ou duas frases curtas, em português falado, sem markdown. Não puxe assunto de tarefa antiga. Se for só um cumprimento, cumprimente de volta e pergunte o que ela quer fazer.`;
+
 /** Onde está o Python 3. Mesmo problema do Estúdio, mesma cura. */
 function python() {
     const nomes = process.platform === 'win32'
@@ -575,4 +581,4 @@ async function preparar(aoFalar = () => {}) {
     return { ok: true, python: py, esperando, avisos };
 }
 
-module.exports = { DICA_COMPUTADOR, conferir, instalar, preparar, porqueOPipFalhou, abrir, conferirEspera, baixarEspera, python, COMO_FALAR, PASTA };
+module.exports = { DICA_COMPUTADOR, COMO_CONVERSAR, conferir, instalar, preparar, porqueOPipFalhou, abrir, conferirEspera, baixarEspera, python, COMO_FALAR, PASTA };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "primocode",
-  "version": "9.7.0",
+  "version": "9.8.0-beta.1",
   "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": {
@@ -8,7 +8,7 @@
   },
   "scripts": {
     "start": "node bin/primocode.js",
-    "test": "node test/tools.test.js && node test/ui.test.js && node test/entrada.test.js && node test/transparencia.test.js && node test/permissao.test.js && node test/compatibilidade.test.js && node test/skills.test.js && node test/estudio.test.js && node test/voz.test.js && node test/modo.test.js && node test/pasta.test.js && node test/projeto.test.js && node test/conferir.test.js && node test/catalogo.test.js && node test/desktop.test.js && node test/effort.test.js && node test/regressao.test.js && node test/memoria-conversa.test.js && node test/repeticao.test.js && node test/referencia.test.js && node test/parar.test.js && node test/continuar.test.js && node test/pipeline.test.js && node test/app.test.js && node test/aplicativo.test.js && node test/conta.test.mjs && node test/nuvem.test.js && node test/prazo.test.js && node test/primeira-vez.test.js && node test/janela.test.js && node test/fala.test.js && node test/especialistas.test.js && node test/empurrao.test.js && node test/terminal-novo.test.js && node test/markdown.test.js && node test/coerencia.test.js"
+    "test": "node test/tools.test.js && node test/ui.test.js && node test/entrada.test.js && node test/transparencia.test.js && node test/permissao.test.js && node test/compatibilidade.test.js && node test/skills.test.js && node test/estudio.test.js && node test/voz.test.js && node test/voz-conversa.test.js && node test/modo.test.js && node test/pasta.test.js && node test/projeto.test.js && node test/nome-projeto.test.js && node test/api-propria.test.js && node test/conferir.test.js && node test/catalogo.test.js && node test/desktop.test.js && node test/seta.test.js && node test/effort.test.js && node test/regressao.test.js && node test/memoria-conversa.test.js && node test/repeticao.test.js && node test/autonomia.test.js && node test/referencia.test.js && node test/parar.test.js && node test/continuar.test.js && node test/pipeline.test.js && node test/app.test.js && node test/aplicativo.test.js && node test/conta.test.mjs && node test/nuvem.test.js && node test/prazo.test.js && node test/primeira-vez.test.js && node test/janela.test.js && node test/fala.test.js && node test/especialistas.test.js && node test/empurrao.test.js && node test/terminal-novo.test.js && node test/markdown.test.js && node test/coerencia.test.js"
   },
   "engines": {
     "node": ">=18.17.0"

package/voz/primo_voz/__main__.py

@@ -243,8 +243,10 @@ class Voz:
                 continue
 
             self.orb.mudar(estado="pensando")
-            texto = self._transcrever(wav)
-            if not texto or len(texto.strip()) < 2:
+            # O servidor também transcreve com Whisper: a mesma limpeza vale.
+            texto = transcrever.limpar(self._transcrever(wav))
+            if not texto:
+                self.orb.mudar(estado="esperando")
                 continue
 
             falar_para_o_node({"tipo": "pedido", "texto": texto})

package/voz/primo_voz/transcrever.py

@@ -74,13 +74,49 @@ def aquecer() -> None:
     threading.Thread(target=_ir, daemon=True).start()
 
 
+# ── O QUE O WHISPER INVENTA ─────────────────────────────────────────────
+# Treinado em legenda de vídeo, ele "ouve" no ruído o fim de um vídeo do
+# YouTube. Essas frases chegavam ao agente como pedido, e ele respondia a
+# elas: "eu mandei oi e ele respondeu nada a ver" (23/09/2026).
+ALUCINACOES = (
+    "obrigado por assistir", "obrigada por assistir", "obrigado pela atenção",
+    "legendas pela comunidade", "amara.org", "inscreva-se", "se inscreva",
+    "deixe seu like", "ative o sininho", "até o próximo vídeo", "até a próxima",
+    "legendado por", "legenda por", "tradução e legendas", "transcrição por",
+    "www.", ".com.br",
+)
+# Acima disto o próprio Whisper acha que não havia fala no trecho.
+SEM_FALA = 0.6
+# Abaixo disto a confiança média é baixa demais para virar pedido.
+CONFIANCA_MINIMA = -1.0
+
+
+def limpar(texto: str) -> str:
+    """Tira a frase inventada. Devolve "" quando não sobra pedido."""
+    t = " ".join(str(texto or "").split())
+    baixo = t.lower()
+    if any(frase in baixo for frase in ALUCINACOES):
+        return ""
+    # Só pontuação ou uma letra solta não é pedido.
+    if len("".join(ch for ch in t if ch.isalnum())) < 2:
+        return ""
+    return t
+
+
+def aproveitavel(segmento) -> bool:
+    """O segmento tem fala de verdade, pelo que o próprio Whisper mediu?"""
+    sem_fala = getattr(segmento, "no_speech_prob", 0.0) or 0.0
+    confianca = getattr(segmento, "avg_logprob", 0.0) or 0.0
+    return not (sem_fala > SEM_FALA and confianca < CONFIANCA_MINIMA)
+
+
 def transcrever(wav: Path, idioma: str = "pt") -> str:
     modelo = carregar()
     # vad_filter corta o silêncio das pontas: sem ele, o Whisper às vezes
     # "ouve" uma frase inteira inventada no silêncio ("Obrigado por assistir").
     segmentos, _ = modelo.transcribe(str(wav), language=idioma, beam_size=5,
                                      vad_filter=True, condition_on_previous_text=False)
-    return " ".join(s.text.strip() for s in segmentos).strip()
+    return limpar(" ".join(s.text.strip() for s in segmentos if aproveitavel(s)))
 
 
 def main() -> int: