primocode 8.38.0 → 8.39.0

package/studio/arquivos/tela-motion-d6150.json

@@ -0,0 +1,135 @@
+{
+  "id": "tela-motion-d6150",
+  "ferramenta": "tela",
+  "titulo": "motion",
+  "doc": {
+    "tema": "meia-noite",
+    "largura": 1920,
+    "altura": 1080,
+    "cenas": [
+      {
+        "layout": "livre",
+        "duracao": 6,
+        "fundo": "aurora",
+        "elementos": [
+          {
+            "tipo": "forma",
+            "forma": "circulo",
+            "x": 1250,
+            "y": 120,
+            "l": 520,
+            "a": 520,
+            "preenchimento": "#ff5a36",
+            "opacidade": 0.9
+          },
+          {
+            "tipo": "forma",
+            "forma": "retangulo",
+            "material": "vidro",
+            "x": 120,
+            "y": 140,
+            "l": 860,
+            "a": 420,
+            "raio": 36,
+            "preenchimento": "#22d3ee"
+          },
+          {
+            "tipo": "texto",
+            "x": 170,
+            "y": 190,
+            "l": 760,
+            "a": 120,
+            "texto": "Liquid glass de verdade",
+            "tamanho": 74,
+            "peso": 750
+          },
+          {
+            "tipo": "texto",
+            "x": 170,
+            "y": 330,
+            "l": 760,
+            "a": 60,
+            "texto": "desfoca o que está atrás, bisel em cima",
+            "tamanho": 34,
+            "cor": "#bfe9f4"
+          },
+          {
+            "tipo": "texto",
+            "material": "vidro",
+            "x": 170,
+            "y": 430,
+            "l": 420,
+            "a": 70,
+            "texto": "pílula de vidro",
+            "tamanho": 32
+          },
+          {
+            "tipo": "icone",
+            "nome": "foguete",
+            "estilo": "app",
+            "x": 1130,
+            "y": 640,
+            "tamanho": 220,
+            "fundo": "#8b5cf6",
+            "som": "pop"
+          },
+          {
+            "tipo": "icone",
+            "nome": "raio",
+            "estilo": "vidro",
+            "x": 1400,
+            "y": 640,
+            "tamanho": 220,
+            "cor": "#ffb03a"
+          },
+          {
+            "tipo": "objeto3d",
+            "forma": "cubo",
+            "x": 620,
+            "y": 620,
+            "tamanho": 260,
+            "girar": 0,
+            "faces": [
+              "IA",
+              "3D",
+              "Motion",
+              "Vidro",
+              "Som",
+              "Marca"
+            ]
+          },
+          {
+            "tipo": "texto",
+            "x": 120,
+            "y": 700,
+            "l": 400,
+            "a": 100,
+            "texto": "chaves 3D",
+            "tamanho": 60,
+            "peso": 700,
+            "chaves": [
+              {
+                "t": 0,
+                "giroY": -60,
+                "opacidade": 0,
+                "x": -200
+              },
+              {
+                "t": 0.4,
+                "giroY": 0,
+                "opacidade": 1,
+                "x": 0
+              },
+              {
+                "t": 1,
+                "giroY": 20
+              }
+            ],
+            "suavizar": "elastico"
+          }
+        ]
+      }
+    ]
+  },
+  "atualizado": "2026-09-09T12:31:01+00:00"
+}

package/studio/edge.py

@@ -117,32 +117,81 @@ def disponivel():
     return _verificado
 
 
+# Por que a instalação falhava calada, e o vídeo saía com a voz do Google:
+# `pip install --user` é recusado pelo Python do sistema em Debian/Ubuntu e
+# no do Homebrew ("externally-managed-environment", PEP 668), e em máquina
+# sem pip o `-m pip` nem existe. Um `pip install` só, em segundo plano, com a
+# saída jogada fora, era exatamente a falha que ninguém vê. Agora são várias
+# tentativas, em ordem, e a última linha do erro de cada uma fica guardada
+# para o status contar o que houve.
+ESTRATEGIAS = [
+    ["-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"],
+]
+_ultimo_erro = ""
+_thread = None
+
+
 def _rotina_instalar():
-    global _instalando, _verificado
+    global _instalando, _verificado, _ultimo_erro
     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)
+        # Sem pip, primeiro o ensurepip — é o que o python.org e a Apple
+        # trazem para o caso.
+        try:
+            r = subprocess.run([sys.executable, "-m", "pip", "--version"],
+                               stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL, timeout=30)
+            if r.returncode != 0:
+                subprocess.run([sys.executable, "-m", "ensurepip", "--user", "--default-pip"],
+                               stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL, timeout=120)
+        except Exception:
+            pass
+        for args in ESTRATEGIAS:
+            try:
+                r = subprocess.run([sys.executable] + args, stdout=subprocess.DEVNULL,
+                                   stderr=subprocess.PIPE, timeout=240)
+            except Exception as e:
+                _ultimo_erro = str(e)[-200:]
+                continue
+            _verificado = None
+            if r.returncode == 0 and disponivel():
+                _ultimo_erro = ""
+                sys.stderr.write("[edge] edge-tts instalado (%s)\n" % " ".join(args[2:]))
+                return
+            _ultimo_erro = (r.stderr or b"").decode("utf-8", "replace").strip().splitlines()[-1:][0][-200:] \
+                if (r.stderr or b"").strip() else "pip devolveu %s" % r.returncode
+        sys.stderr.write("[edge] não consegui instalar o edge-tts: %s\n" % _ultimo_erro)
     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
+def instalar(esperar=0):
+    """Traz o pacote — em segundo plano por padrão; com `esperar` (segundos),
+    quem chamou fica aguardando até esse teto.
+
+    Esperar existe porque a narração de um vídeo NÃO pode sair pela voz de
+    reserva só porque o pip ainda estava rodando: quem pede voz agora e tem
+    internet merece a voz neural agora. Meio minuto de pip é menos ruim que
+    um vídeo inteiro com voz de robô."""
+    global _instalando, _thread
     if disponivel():
-        return
+        return True
     with _tranca:
-        if _instalando:
-            return
-        _instalando = True
-    threading.Thread(target=_rotina_instalar, daemon=True).start()
+        if not _instalando:
+            _instalando = True
+            _thread = threading.Thread(target=_rotina_instalar, daemon=True)
+            _thread.start()
+        t = _thread
+    if t and esperar:
+        t.join(esperar)
+    return disponivel()
+
+
+def ultimo_erro():
+    return _ultimo_erro
 
 
 def _dur_do_vtt(caminho):
@@ -215,6 +264,7 @@ def estado():
         "motor": "edge",
         "disponivel": disponivel(),
         "instalando": inst,
+        "erro": _ultimo_erro or None,
         "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/01-modelos.md

@@ -89,12 +89,22 @@ um elemento flutuando por cima do layout.
 // path SVG numa caixa 24×24 (string ou lista de strings), no traço da casa
 { "tipo":"icone", "nome":"raio", "tamanho":120, "cor":"#ffb03a" }
 { "tipo":"icone", "caminho":"M3 6h18l-2 10H5zM8 20h.01M16 20h.01", "tamanho":96 }
+// como OBJETO: estilo "app" (azulejo de aplicativo) ou "vidro" (liquid glass)
+{ "tipo":"icone", "nome":"foguete", "estilo":"app", "tamanho":200, "fundo":"#8b5cf6" }
 
 // FORMA
 { "tipo":"forma", "forma":"retangulo", "x":200,"y":200,"l":400,"a":220,
   "preenchimento":"#ff5a36", "raio":24, "rotacao":-4, "opacidade":0.9 }
 // forma: retangulo | circulo | triangulo | linha | seta
 
+// MATERIAL — em qualquer elemento: "vidro" é o liquid glass (desfoca o que
+// está atrás, bisel de luz, reflexo). Na forma, preenchimento vira a tinta.
+{ "tipo":"forma", "forma":"retangulo", "material":"vidro", "raio":32, "x":100,"y":100,"l":800,"a":400 }
+
+// SOM — no elemento, toca quando ele entra: whoosh | impacto | click | pop |
+// ding | subida | tique | brilho, ou {"arquivo":"/midia/x.mp3","volume":0.8}
+{ "tipo":"numeros", "itens":["+38% | em 12 meses"], "contar":true, "som":"ding" }
+
 // CÓDIGO
 { "tipo":"codigo", "texto":"npm install primocode" }
 
@@ -186,8 +196,16 @@ completa em segundos (`0` deixa parado no `angulo` dado), `inclinar` levanta
 ou baixa a câmera, `cores` pinta face a face.
 
 Aceita `chaves` como qualquer elemento: dá para o cubo atravessar a cena
-girando. Use **um** por cena — dois objetos girando disputam o olho. Uma cena com tema diferente no meio cria respiro —
-use uma vez, não cinco.
+girando. Use **um** por cena — dois objetos girando disputam o olho.
+
+### Chaves de animação (motion)
+
+`chaves` em qualquer elemento: instantes de `t` 0 a 1 com `x`, `y`
+(deslocamento), `escala`, `escalaX`, `escalaY`, `giro`, **`giroX`, `giroY`,
+`prof`** (3D: vira em profundidade, aproxima da câmera), `opacidade`,
+`desfoque`. No elemento: `suavizar` (`suave` · `linear` · `entrada` · `saida`
+· `elastico` · `salto` · `degrau`), `repetir`, `vaiEVolta`. A spec do Corte
+tem os exemplos.
 
 ### Mídia do computador
 

package/studio/ferramentas/corte.md

@@ -181,9 +181,37 @@ narração, e uma disputa com quem fala em qualquer outro caso.
 `src` vem de `POST /api/midia` (upload) ou é uma URL direta de áudio.
 `inicio` pula os primeiros segundos da faixa.
 
+### Música da internet, com licença (`buscar_audio`)
+
+Uma faixa de verdade, tocada por gente, sem o usuário ter arquivo nenhum:
+`buscar_audio` procura no Openverse (Jamendo, Freesound, Wikimedia — licenças
+Creative Commons que permitem uso, inclusive comercial), **baixa** a melhor e
+devolve a URL `/midia/…` pronta:
+
+```
+buscar_audio { "consulta": "upbeat corporate", "duracao": 30 }
+→ url "/midia/corporate-succes-8c2911.mp3", licenca "CC BY-SA",
+  credito "Corporate Succes — Arkadii Kaplan (CC BY-SA 3.0, via jamendo)"
+```
+
+```json
+"trilha": { "tipo": "arquivo", "src": "/midia/corporate-succes-8c2911.mp3", "volume": 0.55, "repetir": true }
+```
+
+Consulta **em inglês**, pelo clima: `upbeat corporate`, `calm piano`, `epic
+cinematic`, `lofi chill`, `acoustic warm`. `duracao` é a do vídeo, para a faixa
+combinar. Para efeitos, `"tipo": "efeito"` (`whoosh`, `click`, `ding`,
+`swoosh`, `pop`) — a URL vai em `som: {"arquivo": …}`.
+
+**O crédito faz parte da peça.** Licença `CC BY`/`BY-SA` pede o crédito: ponha
+a linha `credito` da resposta na assinatura ou numa legenda pequena da última
+cena. `CC0` e domínio público não pedem nada. A resposta diz qual é o caso.
+Quando a busca não acha nada, use a trilha **gerada** — nunca um "parecido"
+de YouTube.
+
 **Não baixe áudio de YouTube, Spotify ou similares** — quebra os termos dessas
-plataformas e o direito autoral da faixa. Use música do próprio usuário, faixa
-livre de direitos, ou uma das trilhas geradas acima.
+plataformas e o direito autoral da faixa. Use `buscar_audio`, música do próprio
+usuário ou uma das trilhas geradas acima.
 
 ---
 
@@ -242,6 +270,15 @@ número, botão, detalhe, o cartão — e libera o fundo `"marca"`:
 "tema": "claro"
 ```
 
+**De onde vêm a cor e a logo: do site da empresa.** Antes de escrever a peça,
+chame `marca_da_empresa { "nome": "PicPay" }` (ou `"site": "https://…"`). Ela
+lê o site, baixa a logo para o estúdio e devolve `marca: {cor, logo}` pronta
+para colar, mais a paleta, as fontes e a frase da empresa. Não chute cor de
+marca nem peça o arquivo ao usuário antes de tentar isso — a logo está no
+site. Só quando a tool não achar (site montado por JavaScript, sem logo
+baixável) é que se pede o arquivo (`studio_midia`) ou se assina com o nome em
+texto.
+
 Tema CLARO na maioria dos anúncios de marca. O escuro é para a cena de
 produto e para a vitrine; o resto da peça respira no branco.
 
@@ -423,11 +460,38 @@ cena e a série ganha movimento sem esforço. `opcoes` marca a alternativa
 `certa` com ✓ (não escreva o ✓ no texto: ele vem sozinho). Alternativa faz o
 espectador pensar antes da resposta, e pensar é o que segura alguém no vídeo.
 
-### Vidro
+### Vidro — o liquid glass, em qualquer elemento
+
+`"material": "vidro"` em **qualquer** elemento: texto vira pílula de vidro,
+`forma` vira painel, `imagem` ganha moldura, `lista`/`cartoes`/`numeros`
+ganham fundo. É vidro de verdade: **desfoca o que está atrás** (o fundo
+`aurora`, a foto, o círculo colorido), tem o bisel de luz em cima e a sombra
+embaixo, e o reflexo diagonal atravessa devagar durante a cena.
 
-`"estilo": "vidro"` em `cartoes` dá painel translúcido com bisel de luz em
-cima e sombra embaixo — o "liquid glass". Funciona em tema escuro; em tema
-claro use os cartões normais.
+```json
+{ "tipo": "forma", "forma": "retangulo", "material": "vidro", "raio": 36,
+  "x": 120, "y": 140, "l": 860, "a": 420, "preenchimento": "#22d3ee" }
+{ "tipo": "texto", "material": "vidro", "texto": "pílula de vidro", "tamanho": 32 }
+```
+
+Na forma, `preenchimento` vira a **tinta** do vidro (fraca) — não pinta o
+fundo. `raio` arredonda (padrão 28). **Ponha algo atrás**: vidro sobre fundo
+liso é só um retângulo claro; sobre `aurora`, `brilho`, uma foto ou uma forma
+colorida, é o efeito. `"estilo": "vidro"` em `cartoes` continua valendo.
+
+### Ícone como objeto (`estilo: "app"` / `"vidro"`)
+
+```json
+{ "tipo": "icone", "nome": "foguete", "estilo": "app",   "tamanho": 220, "fundo": "#8b5cf6" }
+{ "tipo": "icone", "nome": "raio",    "estilo": "vidro", "tamanho": 220, "cor": "#ffb03a" }
+```
+
+`app` é o azulejo de aplicativo: gradiente da cor, brilho na metade de cima,
+sombra colorida embaixo, o traço branco. `vidro` é o mesmo azulejo em liquid
+glass. `fundo` pinta o azulejo (sem ele, a cor do tema). Um ícone de traço
+sozinho é sinal; no azulejo vira **coisa** — é o que se usa para "o app", "o
+produto", "o recurso" numa cena de lançamento. Combina com `som: "pop"` na
+entrada e com `chaves` de `giroY` para ele virar ao pousar.
 
 ---
 
@@ -647,11 +711,33 @@ Para controlar:
 
 ```json
 "sfx": false                  // no documento: desliga todos os efeitos
-{ "transicao": "deslizar", "sfx": "impacto" }   // na cena: força um efeito
+{ "transicao": "deslizar", "som": "impacto" }   // na cena: força um efeito
 ```
 
-Valores por cena: `"whoosh"` · `"impacto"` · `"click"` · `"nenhum"`.
-O padrão (sem declarar nada) já é o certo para a maioria dos vídeos.
+Valores: `"whoosh"` · `"impacto"` · `"click"` · `"pop"` · `"ding"` ·
+`"subida"` · `"tique"` · `"brilho"` · `"nenhum"`. (`sfx` na cena ainda vale;
+`som` é o nome novo, o mesmo dos elementos.)
+
+### Som por elemento — o que faz motion soar motion
+
+`"som"` num **elemento** toca no instante em que ele entra (o mesmo atraso da
+animação de entrada). É a diferença entre um slide animado e uma peça de
+motion: o número faz **ding** ao aparecer, o ícone faz **pop** ao pousar, a
+barra sobe com a **subida** (o riser) e o texto final chega com **brilho**.
+
+```json
+{ "tipo": "numeros", "itens": ["+38% | em 12 meses"], "contar": true, "som": "ding" }
+{ "tipo": "icone", "nome": "foguete", "estilo": "app", "som": "pop" }
+{ "tipo": "texto", "texto": "Agora.", "som": { "arquivo": "/midia/little-whoosh-3.mp3", "volume": 0.8 } }
+{ "tipo": "texto", "texto": "3, 2, 1", "som": { "nome": "tique", "em": 1.5 } }
+```
+
+`som` aceita o nome, ou `{ "arquivo": "/midia/…", "volume": 0–1 }` para um
+efeito baixado com `buscar_audio` (tipo `"efeito"`) ou enviado pelo usuário;
+`"em"` (segundos na cena) força o instante. O arquivo entra no mesmo grafo da
+trilha, então vai junto para o MP4. Regra: **um som por ideia, não por
+elemento** — três ou quatro por vídeo; tudo apitando é ruído, e a narração
+tem de continuar por cima.
 
 ---
 
@@ -684,8 +770,32 @@ Campos de uma chave, todos opcionais: `x` e `y` (**deslocamento** em pixels a
 partir de onde o elemento está — não é posição absoluta), `escala` (1 = tamanho
 normal), `giro` (graus), `opacidade` (0 a 1) e `desfoque` (pixels).
 
-No elemento: `"repetir": true` roda sem parar, e `"suavizar": false` dá
-movimento constante em vez de acelerar e frear.
+**Em 3D:** `giroY` e `giroX` (graus — o elemento vira em profundidade, como um
+cartão girando na mão), `prof` (pixels — aproxima ou afasta da câmera) e
+`escalaX`/`escalaY` (achatar num eixo só: a gota que pousa e se espalha).
+
+```json
+{ "tipo": "icone", "nome": "foguete", "estilo": "app", "tamanho": 220,
+  "chaves": [
+    { "t": 0,   "giroY": -90, "prof": -400, "opacidade": 0 },
+    { "t": 0.35, "giroY": 0,  "prof": 0,    "opacidade": 1 },
+    { "t": 1,   "giroY": 12 }
+  ], "suavizar": "elastico", "som": "pop" }
+```
+
+**A curva** (`suavizar`, no elemento): `"suave"` (padrão) · `"linear"` ·
+`"entrada"` (acelera) · `"saida"` (freia) · `"elastico"` (passa do ponto e
+volta — o pouso de app) · `"salto"` (recua, dispara e assenta) · `"degrau"`
+(quadro a quadro, stop-motion). Aceita também um `cubic-bezier(…)` cru.
+`"repetir": true` roda sem parar; com `"vaiEVolta": true` ele vai e volta em
+vez de recomeçar — é a levitação de um objeto.
+
+Um exemplo de cada coisa que motion pede — **entrar de lado, respirar, sair**:
+
+```json
+"chaves": [ { "t": 0, "x": -300, "opacidade": 0 }, { "t": 0.2, "x": 0, "opacidade": 1 },
+            { "t": 0.85, "x": 0, "opacidade": 1 }, { "t": 1, "x": 120, "opacidade": 0 } ]
+```
 
 Duas chaves já bastam. Quem tem `chaves` ignora `anim` — as duas disputariam o
 mesmo movimento, e a chave é mais específica. Use em **um ou dois** elementos

package/studio/ferramentas/tela.md

@@ -61,6 +61,27 @@ você controla cada `x`, `y`, `l`, `a` em pixels da tela.
 `globo` `chave` `presente` `sino` `mapa` `dinheiro` `crescimento` `grafico` `balao`
 `pasta` `livro` `play2` `check` `imagem` `codigo` `tabela` `lista`
 
+## Vidro e ícone-objeto
+
+`"material": "vidro"` em qualquer elemento é o liquid glass: painel
+translúcido que **desfoca o que está atrás**, com bisel de luz em cima e
+reflexo diagonal. Precisa de algo atrás (gradiente, forma colorida, foto) para
+aparecer. Na forma, `preenchimento` vira a tinta do vidro.
+
+```json
+{ "tipo": "forma", "forma": "retangulo", "material": "vidro", "raio": 32,
+  "x": 86, "y": 300, "l": 908, "a": 380, "preenchimento": "#ff5a36" }
+```
+
+`"estilo": "app"` no ícone faz o azulejo de aplicativo (gradiente da cor,
+brilho, sombra, traço branco); `"estilo": "vidro"` faz o mesmo azulejo em
+vidro. `fundo` pinta o azulejo. É o ícone de produto para capa e post de
+lançamento:
+
+```json
+{ "tipo": "icone", "nome": "foguete", "estilo": "app", "x": 86, "y": 120, "tamanho": 200, "fundo": "#8b5cf6" }
+```
+
 ## Várias artes no mesmo arquivo
 
 Cada item de `cenas` é uma prancha independente. Um carrossel de Instagram é um

package/studio/server.py

@@ -374,11 +374,21 @@ def preparar_voz(doc):
     Com o ElevenLabs configurado, não há nada para baixar: a síntese é
     imediata e os 90 MB do Piper ficam para o dia em que faltarem chave ou
     internet."""
-    if _tem_narracao(doc) and not elevenlabs_lib.configurado() and not voz_lib.pronta():
+    if _tem_narracao(doc) and not elevenlabs_lib.configurado():
+        # O Edge (pip, segundos) e o Piper (90 MB, minutos) começam JUNTOS.
+        # Antes só o Piper era preparado aqui, e o Edge — a melhor voz grátis —
+        # só era instalado quando a primeira cena já estava pedindo áudio: a
+        # narração caía no Google enquanto o pip rodava, e o dono ouviu a
+        # voz de robô no vídeo inteiro.
         try:
-            voz_lib.instalar()
+            edge_lib.instalar()
         except Exception:
             pass
+        if not voz_lib.pronta():
+            try:
+                voz_lib.instalar()
+            except Exception:
+                pass
 
 
 # ------------------------------------------------------- narração em arquivo --
@@ -474,6 +484,7 @@ def _gravar_narracao(arq_id):
             if c.get("narracaoAudio") and not c.get("narracaoVoz"):
                 continue
             audio, ext, dur = None, ".wav", None
+            motor_usado = None
             # 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.
@@ -483,14 +494,19 @@ def _gravar_narracao(arq_id):
             if elevenlabs_lib.configurado():
                 audio, dur = elevenlabs_lib.sintetizar(texto, voz)
                 if audio:
-                    ext = ".mp3"
+                    ext, motor_usado = ".mp3", "elevenlabs"
 
             # 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"
+            #    VTT que o próprio edge escreve. Ninguém está olhando este
+            #    laço: se o pip ainda roda, espera por ele (até 2 min) — é de
+            #    graça, e é o que separa voz de gente de voz de robô.
+            if not audio:
+                if not edge_lib.disponivel():
+                    edge_lib.instalar(esperar=120)
+                if edge_lib.disponivel():
+                    dados, edur = edge_lib.sintetizar(texto, voz)
+                    if dados:
+                        audio, dur, ext, motor_usado = dados, edur, ".mp3", "edge"
 
             # 3) Piper: neural e offline, quando baixado e compatível. WAV.
             if not audio:
@@ -503,15 +519,19 @@ def _gravar_narracao(arq_id):
                     sys.stderr.write("[voz] Piper cena %d falhou: %s\n" % (i + 1, e))
                     audio = None
                 if audio:
-                    dur, ext = _duracao_wav(audio), ".wav"
+                    dur, ext, motor_usado = _duracao_wav(audio), ".wav", "piper"
 
             # 4) Google: última reserva. Robótica, mas responde. MP3 — a
             #    duração sai do tamanho (CBR de 24 kbps ≈ 3000 bytes/s).
+            #    Vai MARCADA na cena (`narracaoMotor`): o agente lê e avisa a
+            #    pessoa, em vez de ela descobrir ouvindo.
             if not audio:
                 dados = _google_tts(texto)
                 if dados:
-                    audio, ext = dados, ".mp3"
+                    audio, ext, motor_usado = dados, ".mp3", "google"
                     dur = round(len(dados) / 3000.0, 2)
+                    sys.stderr.write("[voz] RESERVA na cena %d: Google (edge-tts: %s)\n"
+                                     % (i + 1, edge_lib.ultimo_erro() or "não instalado"))
 
             if not audio:
                 continue
@@ -520,6 +540,7 @@ def _gravar_narracao(arq_id):
                 fh.write(audio)
             c["narracaoAudio"] = "/midia/" + nome
             c["narracaoVoz"] = assinatura
+            c["narracaoMotor"] = motor_usado
             # A duração medida vai junto: com ela o player sabe quanto a cena
             # REALMENTE dura (a fala inteira + respiro) e a linha do tempo
             # vira determinística — sem ela, o relógio congela na beirada da
@@ -540,6 +561,8 @@ def _gravar_narracao(arq_id):
                             and cenas[i].get("narracao") == c.get("narracao"):
                         cenas[i]["narracaoAudio"] = c["narracaoAudio"]
                         cenas[i]["narracaoVoz"] = c["narracaoVoz"]
+                        if c.get("narracaoMotor"):
+                            cenas[i]["narracaoMotor"] = c["narracaoMotor"]
                         if c.get("narracaoDur"):
                             cenas[i]["narracaoDur"] = c["narracaoDur"]
                 gravar(atual)
@@ -1473,6 +1496,11 @@ class Handler(SimpleHTTPRequestHandler):
         #      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"):
+            # Pacote ainda não instalado? ESPERA o pip (até 60 s) em vez de
+            # cair para o Google. Quem pediu voz tem internet — é o que o Edge
+            # precisa — e meio minuto é menos ruim que a voz de robô no vídeo.
+            if not edge_lib.disponivel():
+                edge_lib.instalar(esperar=60)
             dados, _ = edge_lib.sintetizar(texto, {"voz": voz_pedida,
                                                    "grave": grave, "velocidade": velocidade})
             if dados:
@@ -1505,17 +1533,25 @@ class Handler(SimpleHTTPRequestHandler):
             except Exception as e:
                 sys.stderr.write("[voz] Voicebox falhou (%s); indo de Google\n" % e)
                 audio = b""
-        # 3) Google: uma voz só, mas responde sempre.
+        # 3) Google: uma voz só, mas responde sempre. É a EXCEÇÃO, e vai
+        #    marcada: o cabeçalho diz qual motor falou, para o player e o
+        #    agente saberem que a voz saiu pela reserva — em vez de a pessoa
+        #    descobrir ouvindo.
+        motor_usado = "elevenlabs" if (audio and tipo == "audio/mpeg" and elevenlabs_lib.configurado()) else \
+            ("edge" if audio and tipo == "audio/mpeg" else ("piper" if audio and tipo == "audio/wav" else "voicebox" if audio else "google"))
         if not audio:
             tipo = "audio/mpeg"
             try:
                 audio = b"".join(self._trecho_de_voz(t, idioma) for t in _picar(texto, 190))
             except Exception as e:                  # rede, bloqueio, mudança do serviço
                 return self.js({"erro": "voz indisponível: %s" % e}, 502)
+            sys.stderr.write("[voz] RESERVA: a narração saiu pelo Google (edge-tts: %s)\n"
+                             % (edge_lib.ultimo_erro() or "não instalado"))
         if not audio:
             return self.js({"erro": "voz não devolveu áudio"}, 502)
 
         self.send_response(200)
+        self.send_header("X-Voz-Motor", motor_usado)
         self.send_header("Content-Type", tipo)
         self.send_header("Content-Length", str(len(audio)))
         self.send_header("Cache-Control", "no-store")

package/studio/studio.log

@@ -0,0 +1,28 @@
+[studio] 2026-09-09T12:28:40+00:00 — iniciando na porta 7797
+
+  ██  PrimoCode Studio
+  ────────────────────────────────────────────────────────
+  Estúdio          http://localhost:7797
+  Manual da IA     http://localhost:7797/api/manual
+  Ferramentas      Prisma, Tela, Prosa, Grade, Corte, Traço
+  ────────────────────────────────────────────────────────
+  Ctrl+C para parar
+
+  GET /api/arquivos
+  POST /api/arquivos
+  GET /api/arquivos/tela-motion-3ecaa
+  GET /api/voz/status
+[studio] 2026-09-09T12:31:01+00:00 — iniciando na porta 7797
+
+  ██  PrimoCode Studio
+  ────────────────────────────────────────────────────────
+  Estúdio          http://localhost:7797
+  Manual da IA     http://localhost:7797/api/manual
+  Ferramentas      Prisma, Tela, Prosa, Grade, Corte, Traço
+  ────────────────────────────────────────────────────────
+  Ctrl+C para parar
+
+  GET /api/arquivos
+  POST /api/arquivos
+  GET /api/arquivos/tela-motion-d6150
+  GET /api/voz/status