primocode 8.21.0 → 8.22.1

package/lib/act.js

@@ -349,6 +349,12 @@ async function runAct(userPrompt, opts) {
     // Quem já foi chamado, e quantas vezes. Ver lib/repeticao.js.
     const jaChamado = repeticao.novo();
     let voltasEmFalso = 0;
+    // Pesquisas que voltaram de mãos vazias. A partir da terceira, a tool
+    // para de rodar e devolve ORDEM DE SEGUIR: sem isto o agente entrava em
+    // ciclo — buscava, não achava, lia "tente outra consulta", buscava de
+    // novo — até a cota do minuto acabar e o modelo responder vazio. Foi
+    // assim que "crie um vídeo para a tostudy" morreu sem entregar nada.
+    let pesquisasSecas = 0;
     let rodadasParadas = 0;
 
     const messages = [];
@@ -515,9 +521,22 @@ async function runAct(userPrompt, opts) {
             // o modelo grátis engasgando. Cair direto no "parei sem concluir"
             // jogava a tarefa fora quando repetir a MESMA rodada quase sempre
             // resolve — visto em produção no primeiro pedido de vídeo.
-            if (!finalText && respostasVazias < 2 && !PARAR) {
+            if (!finalText && respostasVazias < 3 && !PARAR) {
                 respostasVazias++;
                 if (!subagent) console.log(ident(profundidade) + c.dim('  ⎿ o modelo respondeu vazio — tentando de novo'));
+                // Repetir o MESMO contexto costuma produzir o mesmo vazio: se
+                // o turno anterior já engasgou, o que falta é um empurrão
+                // curto e concreto. A partir da segunda vez, entra um pedido
+                // explícito de fechamento — barato em tokens (é justamente
+                // quando a cota está no fim) e suficiente para o modelo
+                // escrever a resposta ou chamar finish.
+                if (respostasVazias >= 2) {
+                    messages.push({
+                        role: 'user',
+                        content: 'Sua última resposta veio vazia. Não pesquise mais nem explique o processo: '
+                            + 'faça agora a entrega pedida com o que você já tem e finalize.',
+                    });
+                }
                 iteration--;
                 continue;
             }
@@ -616,6 +635,22 @@ async function runAct(userPrompt, opts) {
                 temPasta = true;
             }
 
+            if (tc.name === 'pesquisar_referencia' && pesquisasSecas >= 3) {
+                voltasEmFalso++;
+                console.log(ident(profundidade) + actionHeader(tc.name, tc.arguments));
+                console.log(ident(profundidade) + c.muted('  ⎿ ') + c.warn('3 pesquisas sem resultado — siga com o que já tem'));
+                messages.push({
+                    role: 'tool',
+                    tool_call_id: tc.id,
+                    content: 'PARE DE PESQUISAR. Três buscas seguidas não trouxeram fonte nenhuma; '
+                        + 'mais uma vai gastar a cota e devolver o mesmo nada. FAÇA AGORA a entrega '
+                        + 'pedida com o que você já sabe. Se faltar um fato específico (número, data, '
+                        + 'preço, nome de pessoa), NÃO invente: escreva a peça sem ele e avise o '
+                        + 'usuário no final, em uma linha, o que não deu para confirmar.',
+                });
+                continue;
+            }
+
             algoRodou = true;
             console.log(ident(profundidade) + actionHeader(tc.name, tc.arguments));
             const result = await tools.execute(tc.name, tc.arguments, { projectDir: pastaAtual });
@@ -626,6 +661,11 @@ async function runAct(userPrompt, opts) {
             // não corrige um teste quebrado noutro lugar; antes isto zerava
             // a lista inteira e o agente conseguia dizer "concluído" com uma
             // falha real ainda pendente.
+            if (tc.name === 'pesquisar_referencia') {
+                if (result && result.ok === false) pesquisasSecas++;
+                else pesquisasSecas = 0;      // achou fonte: o ciclo se rompeu
+            }
+
             if (result && result.ok === false) {
                 falhasPendentes.push({
                     tool: tc.name,

package/lib/referencia.js

@@ -244,21 +244,116 @@ function relevante(cand, palavras) {
  * Foi o que salvou este caso — parisgroup.ai abre e tem o texto todo, enquanto
  * DuckDuckGo devolvia 202 e o Bing devolvia Paris, a cidade.
  *
- * Só dispara quando a consulta tem DUAS PALAVRAS COM INICIAL MAIÚSCULA
- * seguidas, que é como se escreve nome de empresa. "react hooks tutorial" não
- * dispara; "Paris Group" dispara.
+ * Reconhece nome de DUAS palavras com maiúscula ("Paris Group") e também de
+ * UMA palavra, mesmo em minúscula — que é como as pessoas digitam no meio de
+ * uma frase. Exigir duas maiúsculas custou caro: para "crie um vídeo para a
+ * tostudy, plataforma de aprendizagem com IA" a função devolvia lista vazia,
+ * o buscador não conhecia o nome, a pesquisa falhava — e o agente repetia
+ * buscas até a tarefa morrer, com tostudy.ai no ar o tempo todo.
  */
+
+// Palavras que aparecem em qualquer pedido e NUNCA são o nome da marca. Sem
+// esta peneira o chute viraria plataforma.com, aprendizagem.com, video.com.
+const NAO_E_MARCA = new Set([
+    'plataforma', 'plataformas', 'empresa', 'startup', 'site', 'oficial', 'aplicativo', 'app',
+    'aprendizagem', 'aprendizado', 'ensino', 'educacao', 'educacional', 'curso', 'cursos', 'escola',
+    'video', 'videos', 'reels', 'anuncio', 'campanha', 'marketing', 'institucional', 'apresentacao',
+    'inteligencia', 'artificial', 'brasil', 'brasileira', 'sobre', 'para', 'como', 'uma', 'que',
+    'crie', 'criar', 'faca', 'fazer', 'quero', 'preciso', 'estudo', 'estudos', 'tecnologia',
+    'software', 'sistema', 'servico', 'servicos', 'produto', 'produtos', 'negocio', 'digital',
+    'documentacao', 'tutorial', 'exemplo', 'exemplos', 'guia', 'referencia',
+]);
+
+function _slug(txt) {
+    return String(txt || '').normalize('NFD').replace(/[̀-ͯ]/g, '')
+        .toLowerCase().replace(/[^a-z0-9]/g, '');
+}
+
 function sitesProvaveis(consulta) {
-    const nome = /\b([A-ZÀ-Ý][\w\u00C0-\u024F]{1,})\s+([A-ZÀ-Ý][\w\u00C0-\u024F]{1,})\b/.exec(String(consulta || ''));
-    if (!nome) return [];
-    const slug = `${nome[1]}${nome[2]}`
-        .normalize('NFD').replace(/[\u0300-\u036f]/g, '').toLowerCase().replace(/[^a-z0-9]/g, '');
-    if (slug.length < 5) return [];
-    return ['com', 'ai', 'com.br', 'io', 'co'].map((tld) => ({
-        titulo: `${nome[1]} ${nome[2]} — site oficial`,
-        url: `https://www.${slug}.${tld}`,
-        nota: 'site provável da empresa',
+    const texto = String(consulta || '');
+    const marcas = [];
+
+    // Entre aspas é a forma de a pessoa dizer "o nome é ESTE". Vem primeiro.
+    const citado = /["“'”]([^"“'”]{3,40})["“'”]/.exec(texto);
+    if (citado) marcas.push({ rotulo: citado[1].trim(), slug: _slug(citado[1]) });
+
+    const duplo = /\b([A-ZÀ-Ý][\wÀ-ɏ]{1,})\s+([A-ZÀ-Ý][\wÀ-ɏ]{1,})\b/.exec(texto);
+    if (duplo) marcas.push({ rotulo: `${duplo[1]} ${duplo[2]}`, slug: _slug(duplo[1] + duplo[2]) });
+
+    // Marca de UMA palavra só é chutada quando a consulta dá SINAL de que
+    // fala de um negócio ("plataforma", "empresa", "app", "site"...) ou põe o
+    // nome entre aspas. Sem essa exigência, "react hooks tutorial" viraria
+    // react.com e "como fazer um bolo" viraria fazer.com — dez buscas
+    // inúteis para cada pesquisa técnica.
+    const SINAL_DE_MARCA = /\b(plataforma|empresa|startup|site|marca|neg[óo]cio|produto|servi[çc]o|app|aplicativo|institucional|cliente|fabricante|loja|ag[êe]ncia|ecommerce|e-commerce|saas)\b/i;
+    const temSinal = SINAL_DE_MARCA.test(texto) || !!citado;
+    if (temSinal) {
+        const util = (bruto) => {
+            const s = _slug(bruto);
+            return (s.length >= 4 && s.length <= 24 && !NAO_E_MARCA.has(s) && !/^\d+$/.test(s)) ? s : null;
+        };
+        // O nome vem quase sempre depois de artigo ou preposição: "um mouse
+        // DA multilaser", "vídeo para A tostudy". Pegar simplesmente a
+        // primeira palavra não-genérica escolhia o verbo do pedido
+        // ("anunciar") e chutava anunciar.ai.
+        const depoisDeArtigo = [...texto.matchAll(/\b(?:d[aeo]s?|[ao]|n[ao]s?|à)\s+([A-Za-zÀ-ÿ][\wÀ-ÿ-]{3,23})\b/gi)];
+        for (const m of depoisDeArtigo) {
+            const s = util(m[1]);
+            if (s) { marcas.push({ rotulo: m[1], slug: s }); break; }
+        }
+        // Só quando o artigo não entregou nada: senão o verbo do pedido
+        // ("anunciar") entraria junto e gastaria dez sondas à toa.
+        if (!marcas.length) {
+            for (const bruto of texto.split(/[\s,.;:!?()]+/)) {
+                const s = util(bruto);
+                if (s) { marcas.push({ rotulo: bruto, slug: s }); break; }
+            }
+        }
+    }
+
+    const vistos = new Set();
+    const saida = [];
+    for (const m of marcas.slice(0, 2)) {
+        if (!m.slug || m.slug.length < 4 || vistos.has(m.slug)) continue;
+        vistos.add(m.slug);
+        for (const tld of ['ai', 'com', 'com.br', 'io', 'co']) {
+            // Com e sem "www": um resolve onde o outro não, e quem decide é a
+            // hospedagem. Como estes candidatos passam pela sonda antes de
+            // entrar na fila de leitura, tentar os dois não custa vaga.
+            saida.push({ titulo: `${m.rotulo} — site oficial`, url: `https://${m.slug}.${tld}`, nota: 'site provável da empresa' });
+            saida.push({ titulo: `${m.rotulo} — site oficial`, url: `https://www.${m.slug}.${tld}`, nota: 'site provável da empresa' });
+        }
+    }
+    return saida;
+}
+
+/**
+ * Sonda os domínios chutados e devolve só os que responderam, com o HTML já
+ * na mão. Sem isto, dez chutes entrariam na fila de leitura e expulsariam os
+ * resultados de verdade do buscador — e a maioria deles nem existe.
+ */
+async function chutesVivos(chutes, limite = 2) {
+    if (!chutes.length) return { vivos: [], html: new Map() };
+    // 12 s, não 6: a sonda roda em paralelo e a home de uma empresa hoje pesa
+    // centenas de KB. Com 6 s o site CERTO chegava atrasado, era descartado
+    // como morto, e a pesquisa falhava com o site no ar — medido.
+    const respostas = await Promise.all(chutes.slice(0, 12).map(async (c) => {
+        const html = await pegar(c.url, { timeout: 12000 });
+        return html && html.length > 500 ? { cand: c, html } : null;
     }));
+    const vivos = [];
+    const html = new Map();
+    const dominios = new Set();
+    for (const r of respostas.filter(Boolean)) {
+        // www.x.ai e x.ai são o mesmo site: vale o primeiro que respondeu.
+        const raiz = r.cand.url.replace(/^https?:\/\/(www\.)?/, '').replace(/\/$/, '');
+        if (dominios.has(raiz)) continue;
+        dominios.add(raiz);
+        vivos.push(r.cand);
+        html.set(r.cand.url, r.html);
+        if (vivos.length >= limite) break;
+    }
+    return { vivos, html };
 }
 
 // Links que não são referência de nada — resultado de busca sujo.
@@ -460,7 +555,17 @@ async function pesquisar({ consulta, paginas = 3 }) {
     // O site provável da empresa vai NA FRENTE: quando a consulta nomeia um
     // negócio, o site dele é a melhor fonte que existe, e não depende de
     // buscador nenhum estar de bom humor.
-    const chutes = sitesProvaveis(termo);
+    // Os chutes de domínio são SONDADOS antes de entrar na fila: só os que
+    // respondem ocupam vaga. São dez palpites (5 TLDs x com/sem www) e a
+    // maioria não existe — enfileirar todos expulsaria os resultados reais
+    // do buscador. A sonda roda em paralelo e o HTML já volta aproveitado.
+    const palpites = sitesProvaveis(termo);
+    const { vivos, html: htmlChutes } = await chutesVivos(palpites);
+    // A sonda ORDENA, não faz porteiro. Ela é uma corrida contra o relógio
+    // contra home pesada e rede lenta, e perdê-la não pode significar perder
+    // o site certo: quando nada responde a tempo, os primeiros palpites vão
+    // para a fila mesmo assim e o laço de leitura tenta de novo, sem pressa.
+    const chutes = vivos.length ? vivos : palpites.slice(0, 3);
     const palavras = palavrasDaConsulta(termo);
     const brutos = [...chutes, ...web, ...so, ...docsConhecidas(termo)];
 
@@ -481,7 +586,15 @@ async function pesquisar({ consulta, paginas = 3 }) {
             provavelCausa: descartados
                 ? `Vieram ${descartados} link(s), mas nenhum era sobre "${termo}" — o buscador não achou o assunto e devolveu página aleatória. Fonte errada é pior que fonte nenhuma, então foram descartadas.`
                 : 'Os buscadores costumam recusar chamadas automáticas (bloqueio ou limite por excesso de buscas seguidas), e não a sua conexão.',
-            comoCorrigir: 'Tente OUTRA consulta, mais curta e específica. Se souber o site do assunto, vá direto nele com browser_open + browser_read — é o caminho mais confiável para fato de empresa.',
+            // "Tente outra consulta" era um convite ao ciclo: o agente
+            // reformulava a busca, falhava igual, e repetia até a cota acabar.
+            // A ordem agora é explícita — no máximo UMA nova tentativa, e por
+            // um caminho DIFERENTE (o site direto), senão segue sem a fonte.
+            comoCorrigir: 'NÃO repita esta busca com outras palavras — o buscador não conhece o assunto e '
+                + 'vai devolver o mesmo nada. Se souber (ou conseguir deduzir) o site, tente UMA vez '
+                + 'browser_open + browser_read nele. Se também não abrir, SIGA COM A TAREFA usando o que '
+                + 'você já sabe e avise ao usuário, no final, qual fato não deu para confirmar. Nunca invente '
+                + 'dado sobre empresa, número, data, preço ou pessoa.',
         };
     }
 
@@ -491,7 +604,9 @@ async function pesquisar({ consulta, paginas = 3 }) {
     const chutesLidos = [];
     for (const cand of candidatos) {
         if (lidas.length >= paginas) break;
-        const html = await pegar(cand.url);
+        // A sonda já baixou o HTML dos chutes: reaproveita em vez de pedir
+        // a mesma página duas vezes.
+        const html = htmlChutes.get(cand.url) || await pegar(cand.url);
         if (!html) continue;
         const texto = textoDe(html);
         if (texto.length < 200) continue;
@@ -502,7 +617,17 @@ async function pesquisar({ consulta, paginas = 3 }) {
         // da página, sim. Sem esta prova o agente escreveria sobre a errada.
         const ehChute = cand.nota === 'site provável da empresa';
         if (ehChute) {
-            const nota = quantoBate({ titulo: texto.slice(0, 4000), url: cand.url }, palavras);
+            let nota = quantoBate({ titulo: texto.slice(0, 4000), url: cand.url }, palavras);
+            // O NOME DA MARCA no domínio, confirmado no texto da página, já é
+            // prova — e é a prova mais forte que existe. Exigir duas palavras
+            // genéricas da consulta ("plataforma", "aprendizagem") reprovava o
+            // site certo: tostudy.ai abria, dizia "ToStudy" na primeira linha,
+            // e mesmo assim era descartado por não repetir o vocabulário do
+            // pedido. O agente então repetia buscas até a tarefa morrer.
+            const marca = (cand.url.match(/^https?:\/\/(?:www\.)?([a-z0-9-]+)\./i) || [])[1] || '';
+            const textoLimpo = texto.slice(0, 8000).normalize('NFD')
+                .replace(/[\u0300-\u036f]/g, '').toLowerCase().replace(/[^a-z0-9]/g, '');
+            if (marca.length >= 4 && textoLimpo.includes(marca.toLowerCase())) nota = Math.max(nota, 2);
             if (nota < Math.min(2, palavras.length)) continue;
             // Passar não basta: entre dois domínios do MESMO nome, fica o que
             // fala mais do assunto. parisgroup.ai e parisgroup.co os dois
@@ -532,8 +657,10 @@ async function pesquisar({ consulta, paginas = 3 }) {
             error: 'achei os links mas não consegui abrir nenhum',
             consulta: termo,
             links: candidatos.map((c) => c.url),
-            comoCorrigir: 'Tente browser_open + browser_read num desses links, ou pesquise com outras palavras. '
-                + 'Se nada abrir, diga ao usuário que não conseguiu confirmar os fatos — NUNCA invente dado sobre empresa, data, preço ou pessoa.',
+            comoCorrigir: 'Tente browser_open + browser_read num desses links — UMA vez. Não refaça a busca '
+                + 'com outras palavras: os links são estes mesmos. Se nada abrir, SIGA COM A TAREFA e diga ao '
+                + 'usuário, no final, que não conseguiu confirmar os fatos — NUNCA invente dado sobre empresa, '
+                + 'data, preço ou pessoa.',
         };
     }
 

package/lib/studio.js

@@ -42,7 +42,7 @@ const BASE = `http://127.0.0.1:${PORTA}`;
 // voz.py é módulo do servidor, não enfeite: sem ele o server.py não importa
 // e o Studio inteiro deixa de subir. Todo arquivo .py do Studio precisa
 // entrar aqui.
-const COPIAVEIS = new Set(['server.py', 'voz.py', 'elevenlabs.py', 'web', 'ferramentas', 'README.md', 'PRIMOCODE.md']);
+const COPIAVEIS = new Set(['server.py', 'voz.py', 'elevenlabs.py', 'edge.py', 'web', 'ferramentas', 'README.md', 'PRIMOCODE.md']);
 
 /**
  * Onde está o Python 3 desta máquina.

package/package.json

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

package/studio/edge.py

@@ -0,0 +1,221 @@
+"""Narração neural grátis, via Edge TTS (vozes online da Microsoft).
+
+── POR QUE ESTE MOTOR EXISTE ─────────────────────────────────────────────
+A corrente de voz tinha um buraco entre o ElevenLabs (premium, com chave e
+cota) e o Google (uma voz só, robótica). No meio ficava o Piper — neural e
+offline, mas que baixa 90 MB e, em Mac ARM, vinha com binário x86 e travava.
+Quando o Piper não sobe, a narração caía direto no Google e o vídeo saía com
+voz de robô.
+
+O Edge TTS preenche esse buraco: são as MESMAS vozes neurais do serviço da
+Microsoft (Antonio, Francisca, Thalita em pt-BR), de graça, SEM chave e SEM
+conta. Precisa de internet — mas quem está gerando vídeo já está online. A
+qualidade fica logo abaixo do ElevenLabs e muito acima do Google.
+
+── COMO ENTRA NA CORRENTE ────────────────────────────────────────────────
+1. ELEVENLABS  premium, se houver chave com crédito.
+2. EDGE TTS    neural, grátis, sem chave.        ← ESTE
+3. PIPER       neural, offline, ilimitado.
+4. VOICEBOX    se o app estiver instalado.
+5. GOOGLE      última reserva; nunca fica mudo.
+
+── SÍNTESE ───────────────────────────────────────────────────────────────
+Rodamos o edge-tts por SUBPROCESSO (`python3 -m edge_tts`), não pela API
+async: o servidor do Studio é stdlib síncrono, e enfiar um event loop dentro
+de uma thread dele é fonte de travamento. O subprocesso é isolado, tem
+timeout de verdade, e devolve o MP3 pronto.
+
+A DURAÇÃO sai das legendas que o próprio edge-tts escreve (`--write-subtitles`):
+o último timestamp do VTT é o fim da fala, medido — não estimado. Com isso a
+cena sabe quanto dura de fato e a linha do tempo fica determinística.
+
+O pacote `edge-tts` não vem no PrimoCode (é pip, não stdlib). Se faltar, este
+motor se declara indisponível e a corrente segue para o Piper — nada trava.
+`instalar()` tenta trazê-lo em segundo plano, uma vez, sem bloquear ninguém.
+"""
+
+import os
+import re
+import subprocess
+import sys
+import tempfile
+import threading
+
+# Catálogo pt-BR do Edge. Só três vozes existem no serviço da Microsoft para
+# português do Brasil; não há por que inventar mais. A padrão é a Antonio,
+# masculina e de locução, que é o registro de abertura de vídeo — a mesma
+# lógica da voz grave padrão do Piper.
+CATALOGO = [
+    {"id": "antonio",   "voz": "pt-BR-AntonioNeural",           "nome": "Antonio",   "genero": "m", "padrao": True},
+    {"id": "francisca", "voz": "pt-BR-FranciscaNeural",         "nome": "Francisca", "genero": "f"},
+    {"id": "thalita",   "voz": "pt-BR-ThalitaMultilingualNeural","nome": "Thalita",  "genero": "f"},
+]
+POR_ID = {v["id"]: v for v in CATALOGO}
+PADRAO = next(v["voz"] for v in CATALOGO if v.get("padrao"))
+
+# Apelidos: as vozes do ElevenLabs que o usuário talvez peça no documento
+# mapeiam para o timbre mais próximo aqui, para o mesmo documento render
+# igual com qualquer motor ativo. Masculinas → Antonio; femininas → Francisca.
+APELIDOS = {
+    "brian": "pt-BR-AntonioNeural", "daniel": "pt-BR-AntonioNeural",
+    "adam": "pt-BR-AntonioNeural",  "bill": "pt-BR-AntonioNeural",
+    "liam": "pt-BR-AntonioNeural",  "jeff": "pt-BR-AntonioNeural",
+    "cadu": "pt-BR-AntonioNeural",  "edresson": "pt-BR-AntonioNeural",
+    "faber": "pt-BR-AntonioNeural",
+    "sarah": "pt-BR-FranciscaNeural", "alice": "pt-BR-FranciscaNeural",
+}
+
+_verificado = None          # cache do disponivel(): None = ainda não checou
+_instalando = False
+_tranca = threading.Lock()
+
+
+def _voz_de(voz_cfg):
+    """Resolve o id/nome pedido no documento para um nome de voz do Edge."""
+    pedido = ""
+    if isinstance(voz_cfg, dict):
+        pedido = str(voz_cfg.get("voz") or "").strip()
+    elif isinstance(voz_cfg, str):
+        pedido = voz_cfg.strip()
+    if not pedido:
+        return PADRAO
+    baixo = pedido.lower()
+    if baixo in POR_ID:
+        return POR_ID[baixo]["voz"]
+    if baixo in APELIDOS:
+        return APELIDOS[baixo]
+    # Nome cru do Edge ("pt-BR-...Neural") passa direto.
+    if re.match(r"^[a-z]{2}-[A-Z]{2}-\w+$", pedido):
+        return pedido
+    return PADRAO
+
+
+def _taxa(velocidade):
+    """velocidade do documento (1.0 = normal) vira o --rate do edge (+N%)."""
+    try:
+        v = float(velocidade)
+    except (TypeError, ValueError):
+        v = 1.0
+    v = max(0.5, min(2.0, v))
+    pct = int(round((v - 1.0) * 100))
+    return ("+%d%%" % pct) if pct >= 0 else ("%d%%" % pct)
+
+
+def disponivel():
+    """O edge-tts está utilizável nesta máquina? Resultado é cacheado: a
+    checagem roda o CLI e não vale repetir a cada narração."""
+    global _verificado
+    if _verificado is not None:
+        return _verificado
+    try:
+        r = subprocess.run(
+            [sys.executable, "-m", "edge_tts", "--help"],
+            stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL, timeout=20)
+        _verificado = (r.returncode == 0)
+    except Exception:
+        _verificado = False
+    return _verificado
+
+
+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)
+    except Exception as e:
+        sys.stderr.write("[edge] pip install falhou: %s\n" % e)
+    finally:
+        _verificado = None          # força nova checagem
+        with _tranca:
+            _instalando = False
+
+
+def instalar():
+    """Tenta trazer o pacote em segundo plano, uma vez. Não bloqueia: quem
+    pediu narração agora ouve o próximo motor da corrente, e a partir da
+    próxima vez o Edge já responde."""
+    global _instalando
+    if disponivel():
+        return
+    with _tranca:
+        if _instalando:
+            return
+        _instalando = True
+    threading.Thread(target=_rotina_instalar, daemon=True).start()
+
+
+def _dur_do_vtt(caminho):
+    """Último timestamp do VTT = fim da fala, em segundos. Medido, não
+    estimado. Formato do edge-tts: `HH:MM:SS,mmm --> HH:MM:SS,mmm`."""
+    try:
+        with open(caminho, "r", encoding="utf-8") as fh:
+            texto = fh.read()
+    except OSError:
+        return None
+    fins = re.findall(r"-->\s*(\d\d):(\d\d):(\d\d)[,.](\d\d\d)", texto)
+    if not fins:
+        return None
+    h, m, s, ms = fins[-1]
+    return int(h) * 3600 + int(m) * 60 + int(s) + int(ms) / 1000.0
+
+
+def sintetizar(texto, voz_cfg=None, timeout=90):
+    """O texto vira (mp3_bytes, duracao_em_s). Devolve (None, None) quando o
+    Edge não está disponível ou falha — e NUNCA levanta exceção, para a
+    corrente de voz cair no motor seguinte sem tratamento especial."""
+    if not disponivel():
+        instalar()
+        return None, None
+
+    # Uma fala por vez: quebras viram uma frase só, com respiro de pontuação.
+    limpo = re.sub(r"\s+", " ", str(texto or "")).strip()
+    if not limpo:
+        return None, None
+
+    grave = bool(isinstance(voz_cfg, dict) and voz_cfg.get("grave"))
+    velocidade = (voz_cfg.get("velocidade") if isinstance(voz_cfg, dict) else None) or 1.0
+    voz = _voz_de(voz_cfg)
+    taxa = _taxa(velocidade)
+
+    pasta = tempfile.mkdtemp(prefix="primo-edge-")
+    try:
+        mp3 = os.path.join(pasta, "voz.mp3")
+        vtt = os.path.join(pasta, "voz.vtt")
+        try:
+            r = subprocess.run(
+                [sys.executable, "-m", "edge_tts",
+                 "--voice", voz, "--rate", taxa, "--text", limpo,
+                 "--write-media", mp3, "--write-subtitles", vtt],
+                stdout=subprocess.DEVNULL, stderr=subprocess.PIPE, timeout=timeout)
+        except subprocess.TimeoutExpired:
+            sys.stderr.write("[edge] tempo esgotado (%ss)\n" % timeout)
+            return None, None
+        if r.returncode != 0 or not os.path.exists(mp3) or os.path.getsize(mp3) < 800:
+            msg = (r.stderr or b"").decode("utf-8", "replace")[-200:]
+            sys.stderr.write("[edge] síntese falhou: %s\n" % msg)
+            return None, None
+        with open(mp3, "rb") as fh:
+            dados = fh.read()
+        dur = _dur_do_vtt(vtt)
+        return dados, (round(dur, 2) if dur else None)
+    except Exception as e:
+        sys.stderr.write("[edge] erro inesperado: %s\n" % e)
+        return None, None
+    finally:
+        import shutil
+        shutil.rmtree(pasta, ignore_errors=True)
+
+
+def estado():
+    """O que a interface mostra sobre este motor."""
+    with _tranca:
+        inst = _instalando
+    return {
+        "motor": "edge",
+        "disponivel": disponivel(),
+        "instalando": inst,
+        "precisa_internet": True,
+        "vozes": [{"id": v["id"], "nome": v["nome"], "genero": v["genero"],
+                   "padrao": bool(v.get("padrao"))} for v in CATALOGO],
+    }

package/studio/ferramentas/corte.md

@@ -152,8 +152,22 @@ sociais) · `sarah` e `alice` (femininas). Também aceita um voice_id cru do
 ElevenLabs — é assim que a voz clonada do próprio usuário entra. Consulte
 `GET /api/voz/status` para saber o que está ativo nesta máquina.
 
-A síntese é neural e roda na máquina do usuário — offline, sem limite. As
-vozes pt-BR, com a frequência de cada uma medida (menor = mais grave):
+**A corrente de voz, em ordem de qualidade** (cada motor cai no seguinte
+quando não responde — a narração nunca fica muda):
+
+1. **ElevenLabs** — premium, se houver chave com crédito.
+2. **Edge TTS** — vozes neurais da Microsoft, **grátis e sem chave**, só
+   pede internet. É a melhor voz gratuita: `antonio` (masculina, de locução
+   — **a padrão gratuita**), `francisca` e `thalita` (femininas). Instala-se
+   sozinho na primeira vez (`pip install edge-tts`, ~1 min) e, enquanto isso,
+   a narração sai por outro motor. Não há por que citar "voz de robô": com
+   internet, o padrão já é voz neural de gente.
+3. **Piper** — neural e **offline**, sem limite (detalhado abaixo).
+4. **Voicebox** — se o app estiver instalado (voz clonável).
+5. **Google** — última reserva, robótica, mas responde sempre.
+
+O **Piper** roda na máquina do usuário — offline, sem limite. As vozes
+pt-BR, com a frequência de cada uma medida (menor = mais grave):
 
 | id | timbre | Hz |
 |---|---|---|

package/studio/server.py

@@ -86,6 +86,31 @@ except Exception as _e:
 
     elevenlabs_lib = _SemEleven()
 
+try:
+    import edge as edge_lib  # noqa: E402
+except Exception as _e:
+    sys.stderr.write("[voz] edge indisponível (%s)\n" % _e)
+
+    class _SemEdge:
+        @staticmethod
+        def disponivel():
+            return False
+
+        @staticmethod
+        def sintetizar(*a, **k):
+            return None, None
+
+        @staticmethod
+        def instalar():
+            return None
+
+        @staticmethod
+        def estado():
+            return {"motor": "edge", "disponivel": False, "vozes": [],
+                    "erro": "módulo indisponível"}
+
+    edge_lib = _SemEdge()
+
 WEB = os.path.join(RAIZ, "web")
 ARQUIVOS = os.path.join(RAIZ, "arquivos")
 FERRAMENTAS = os.path.join(RAIZ, "ferramentas")
@@ -378,27 +403,50 @@ def _assinatura_voz(texto, voz):
     return hashlib.sha1(corpo.encode("utf-8")).hexdigest()[:10]
 
 
+def _google_tts(texto, idioma="pt-BR"):
+    """Google Translate TTS em MP3, no nível do módulo, para o pré-render
+    também ter o mesmo piso do endpoint: uma voz que responde sempre. Robótica,
+    mas garante que NENHUMA cena fique sem áudio. Devolve b"" se falhar."""
+    try:
+        pedacos = []
+        for t in _picar(texto, 190):
+            url = "https://translate.google.com/translate_tts?" + urlencode({
+                "ie": "UTF-8", "q": t, "tl": idioma, "client": "tw-ob", "total": 1, "idx": 0,
+            })
+            req = urllib.request.Request(url, headers={
+                "User-Agent": "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) "
+                              "AppleWebKit/537.36 (KHTML, like Gecko) Chrome/122.0 Safari/537.36",
+                "Referer": "https://translate.google.com/",
+            })
+            with urllib.request.urlopen(req, timeout=20) as r:
+                pedacos.append(r.read())
+        return b"".join(pedacos)
+    except Exception as e:
+        sys.stderr.write("[voz] Google TTS falhou: %s\n" % e)
+        return b""
+
+
 def _gravar_narracao(arq_id):
     """Sintetiza a narração de cada cena e guarda em midia/."""
     try:
-        # Com o ElevenLabs configurado não há o que esperar: a síntese é
-        # imediata e o Piper vira só a reserva do dia sem internet.
-        if not elevenlabs_lib.configurado():
-            # Esperar o motor: são minutos, mas ninguém está esperando na
-            # frente da tela — e o resultado é a diferença entre voz de gente
-            # e voz de robô no vídeo que a pessoa vai apresentar.
+        # Com ElevenLabs (chave) ou Edge (grátis, neural, sem download) já há
+        # voz de gente na hora — não se espera o Piper. Só quando NENHUM dos
+        # dois responde vale aguardar o Piper baixar, porque a alternativa é
+        # o Google, que soa a robô no vídeo que a pessoa vai apresentar.
+        if not elevenlabs_lib.configurado() and not edge_lib.disponivel():
+            edge_lib.instalar()          # tenta trazer o Edge em paralelo
             for _ in range(120):
-                if voz_lib.pronta():
+                if voz_lib.pronta() or edge_lib.disponivel():
                     break
                 # Máquina onde o Piper nunca vai rodar (binário de outra
                 # arquitetura): esperar 10 minutos aqui era esperar por nada.
                 if voz_lib.bloqueado():
-                    sys.stderr.write("[voz] motor neural bloqueado: %s\n" % voz_lib.bloqueado())
-                    return
+                    sys.stderr.write("[voz] Piper bloqueado: %s\n" % voz_lib.bloqueado())
+                    break
                 voz_lib.instalar()
                 time.sleep(5)
-            if not voz_lib.pronta():
-                return
+            # Nem Piper nem Edge subiram: ainda assim seguimos — o Google, lá
+            # embaixo na síntese, garante que nenhuma cena fique sem áudio.
 
         a = ler(arq_id)
         if not a:
@@ -422,12 +470,25 @@ def _gravar_narracao(arq_id):
             if c.get("narracaoAudio") and not c.get("narracaoVoz"):
                 continue
             audio, ext, dur = None, ".wav", None
-            # ElevenLabs primeiro, quando há chave: é a voz que o usuário
-            # aprovou. O MP3 dele é CBR — a duração sai do tamanho.
+            # A CORRENTE, na ordem de qualidade. Cada motor cai no seguinte
+            # quando não devolve áudio — e o Google, no fim, garante que a
+            # cena nunca fique muda. É o que faz o pré-render nunca parar.
+
+            # 1) ElevenLabs: a voz que o usuário aprovou. MP3 CBR — a duração
+            #    do módulo já vem medida.
             if elevenlabs_lib.configurado():
                 audio, dur = elevenlabs_lib.sintetizar(texto, voz)
                 if audio:
                     ext = ".mp3"
+
+            # 2) Edge TTS: neural, grátis, sem chave. MP3, duração medida pelo
+            #    VTT que o próprio edge escreve.
+            if not audio and edge_lib.disponivel():
+                dados, edur = edge_lib.sintetizar(texto, voz)
+                if dados:
+                    audio, dur, ext = dados, edur, ".mp3"
+
+            # 3) Piper: neural e offline, quando baixado e compatível. WAV.
             if not audio:
                 try:
                     audio = voz_lib.sintetizar(
@@ -435,10 +496,19 @@ def _gravar_narracao(arq_id):
                         grave=bool(voz.get("grave")),
                         velocidade=float(voz.get("velocidade") or 1))
                 except Exception as e:
-                    sys.stderr.write("[voz] cena %d falhou: %s\n" % (i + 1, e))
-                    continue
+                    sys.stderr.write("[voz] Piper cena %d falhou: %s\n" % (i + 1, e))
+                    audio = None
                 if audio:
-                    dur = _duracao_wav(audio)
+                    dur, ext = _duracao_wav(audio), ".wav"
+
+            # 4) Google: última reserva. Robótica, mas responde. MP3 — a
+            #    duração sai do tamanho (CBR de 24 kbps ≈ 3000 bytes/s).
+            if not audio:
+                dados = _google_tts(texto)
+                if dados:
+                    audio, ext = dados, ".mp3"
+                    dur = round(len(dados) / 3000.0, 2)
+
             if not audio:
                 continue
             nome = "narr-%s-%d-%s%s" % (arq_id[:28], i + 1, assinatura, ext)
@@ -1057,10 +1127,22 @@ class Handler(SimpleHTTPRequestHandler):
             elif motor == "elevenlabs":
                 return self.js({"erro": "ElevenLabs não devolveu áudio — chave válida? cota?"}, 502)
 
+        # 0.5) Edge TTS: neural, grátis, sem chave. Entra logo depois do
+        #      ElevenLabs porque é a melhor voz gratuita da corrente — vozes
+        #      da Microsoft, muito acima do Google. Precisa de internet.
+        if not audio and motor in ("", "edge"):
+            dados, _ = edge_lib.sintetizar(texto, {"voz": voz_pedida,
+                                                   "grave": grave, "velocidade": velocidade})
+            if dados:
+                audio = dados
+                tipo = "audio/mpeg"
+            elif motor == "edge":
+                return self.js({"erro": "Edge TTS não devolveu áudio — sem internet ou pacote ausente?"}, 502)
+
         # 1) Piper: o motor local. Se ainda não baixou, começa a baixar agora
         #    e segue para o próximo — quem pediu narração hoje ouve o Google,
         #    e a partir da próxima já é voz de verdade.
-        if not audio and motor not in ("google", "voicebox", "elevenlabs"):
+        if not audio and motor not in ("google", "voicebox", "elevenlabs", "edge"):
             try:
                 if voz_lib.pronta(voz_pedida or None):
                     audio = voz_lib.sintetizar(texto, voz_pedida or None,
@@ -1125,6 +1207,7 @@ class Handler(SimpleHTTPRequestHandler):
                 vozes = []
         return self.js({
             "elevenlabs": elevenlabs_lib.estado(),
+            "edge": edge_lib.estado(),
             "piper": voz_lib.estado(),
             "voicebox": {"ativo": vivo, "vozes": vozes, "site": "https://voicebox.sh"},
             "google": {"ativo": True},

package/studio/web/js/render.js

@@ -178,25 +178,43 @@ function aplicarChaves(no, e, ctx) {
     return _numero(a.t, 0) - _numero(b.t, 0);
   });
 
+  // Um campo OMITIDO numa chave herda o valor da chave anterior — não pula
+  // para um padrão fixo. Sem isto, uma chave que só mexe em `opacidade`
+  // zerava a `escala` implícita: o elemento nascia com scale(0) e sumia da
+  // tela, e a animação parecia "bugada e atrasada". Herdar é o que a pessoa
+  // espera: "o que eu não toquei, fica como estava". O primeiro valor de
+  // cada campo, quando nem a primeira chave o declara, é o neutro (escala e
+  // opacidade em 1, deslocamento e giro em 0) — nunca zero para escala.
+  var NEUTRO = { x: 0, y: 0, escala: 1, giro: 0, opacidade: 1, desfoque: 0 };
+  var CAMPOS = ["x", "y", "escala", "giro", "opacidade", "desfoque"];
+  var herdado = {};
+  CAMPOS.forEach(function (c) {
+    // semente: primeiro valor declarado em qualquer chave, senão o neutro.
+    for (var i = 0; i < chaves.length; i++) {
+      if (typeof chaves[i][c] === "number" && isFinite(chaves[i][c])) { herdado[c] = chaves[i][c]; return; }
+    }
+    herdado[c] = NEUTRO[c];
+  });
+
   var nome = "ch" + (++_nChave);
   var passos = chaves.map(function (k) {
+    CAMPOS.forEach(function (c) {
+      if (typeof k[c] === "number" && isFinite(k[c])) herdado[c] = k[c];
+    });
     var pct = Math.max(0, Math.min(1, _numero(k.t, 0))) * 100;
     var mov = [];
     // x e y de uma chave são DESLOCAMENTO a partir de onde o elemento está.
     // Assim a chave continua valendo se a pessoa arrastar o elemento no
     // palco depois — o contrário obrigaria a refazer todas as chaves.
-    var dx = _numero(k.x, 0), dy = _numero(k.y, 0);
+    var dx = herdado.x, dy = herdado.y;
     if (dx || dy) mov.push("translate(" + dx + "px," + dy + "px)");
-    var esc = _numero(k.escala, 1);
-    if (esc !== 1) mov.push("scale(" + esc + ")");
-    var giro = _numero(k.giro, 0);
-    if (giro) mov.push("rotate(" + giro + "deg)");
+    if (herdado.escala !== 1) mov.push("scale(" + herdado.escala + ")");
+    if (herdado.giro) mov.push("rotate(" + herdado.giro + "deg)");
 
     var linhas = ["transform:" + (mov.length ? mov.join(" ") : "none")];
-    var op = _numero(k.opacidade, 1);
-    linhas.push("opacity:" + op);
-    if (typeof k.desfoque === "number" && k.desfoque > 0) {
-      linhas.push("filter:blur(" + k.desfoque + "px)");
+    linhas.push("opacity:" + herdado.opacidade);
+    if (herdado.desfoque > 0) {
+      linhas.push("filter:blur(" + herdado.desfoque + "px)");
     }
     return pct.toFixed(3) + "%{" + linhas.join(";") + "}";
   }).join("");