primocode 9.8.0-beta.8 → 9.8.0

package/lib/local/entrada.js

@@ -17,7 +17,7 @@
  *
  * ── A IDEIA ──────────────────────────────────────────────────────────────
  * Ninguém precisa das 45 ferramentas para fazer um slide. Quem pede um vídeo
- * não usa `desktop_click`; quem conserta um bug não usa `studio_criar`. Então
+ * não usa `desktop_click`; quem conserta um bug não usa `estudio_render`. Então
  * cada pedido leva só o que aquele pedido pode usar — ferramentas E seções do
  * prompt — e o que sobra do orçamento vira espaço para a conversa.
  *
@@ -74,10 +74,19 @@ const GRUPOS = [
     },
     {
         nome: 'estudio',
-        tools: ['studio_manual', 'studio_spec', 'studio_criar', 'studio_ler',
-            'studio_atualizar', 'studio_versoes', 'studio_listar', 'studio_midia'],
-        // O que o estúdio produz, e os apps que ele substitui.
-        gatilho: /\b(slides?|apresenta[çc][ãa]o|deck|v[íi]deo|reels?|anima[çc][ãa]o|post|banner|capa|thumbnail|arte|cartaz|logo|planilha|tabela|or[çc]amento|documento|relat[óo]rio|artigo|proposta|contrato|diagrama|fluxograma|organograma|mapa mental|narra[çc][ãa]o|trilha|est[úu]dio|canva|powerpoint|keynote|word|docs|excel|sheets|photoshop|figma|capcut|premiere|miro)\b/i,
+        tools: ['estudio_projeto', 'estudio_plano', 'estudio_midia', 'estudio_narrar',
+            'estudio_render', 'estudio_site', 'planejar_producao'],
+        // O que o estúdio produz, e os apps que ele substitui. Documento,
+        // planilha e PDF saíram: o Estúdio novo faz vídeo, slides e arte, e o
+        // resto é arquivo escrito com código.
+        gatilho: /\b(slides?|apresenta[çc][ãa]o|deck|v[íi]deo|reels?|anima[çc][ãa]o|motion|vinheta|teaser|an[úu]ncio|post|banner|capa|thumbnail|arte|cartaz|narra[çc][ãa]o|trilha|legenda|grava[çc][ãa]o|est[úu]dio|canva|powerpoint|keynote|photoshop|figma|capcut|premiere)\b/i,
+    },
+    {
+        /* A GRAVAÇÃO do usuário é outra ferramenta, e só entra quando o pedido
+           fala dela: "faz um vídeo" não precisa cortar silêncio de ninguém. */
+        nome: 'gravacao',
+        tools: ['estudio_video'],
+        gatilho: /\b(grava[çc][ãa]o|gravei|filmagem|filmei|meu v[íi]deo|edit\w* (o |a |meu |minha |esse |essa |este |esta )?(v[íi]deo|grava[çc][ãa]o)|\.mp4|\.mov|legendas?|cort(a|ar|e) (o )?sil[êe]ncio|recort(a|ar|e) (a )?pessoa|transcrev\w*|importa\w* (o )?v[íi]deo)\b/i,
     },
     {
         nome: 'navegador',
@@ -118,7 +127,7 @@ const GRUPOS = [
            quando o pedido fala do arquivo — é o que mantém o pedido de vídeo
            dentro do teto do minuto (medido: ela custa ~180 tokens). */
         nome: 'exportar',
-        tools: ['studio_exportar'],
+        tools: ['estudio_render'],
         gatilho: /\b(mp4|webm|baix[ae]r?|download|exporta\w*|salv[ae]r? (o )?v[íi]deo|arquivo (do|de) v[íi]deo|me manda o v[íi]deo|manda o arquivo|renderiza\w*)\b/i,
     },
     {
@@ -196,7 +205,8 @@ function jaAprendeu(messages) {
         if (m && m.role === 'tool' && nomePorId.has(m.tool_call_id)) feitas.add(nomePorId.get(m.tool_call_id));
     }
     const dispensaveis = new Set();
-    if (feitas.has('studio_spec') || feitas.has('studio_manual')) dispensaveis.add('estudio');
+    // O Estúdio novo não tem spec para ler: a seção dele é o único mapa do
+    // fluxo, e fica até o fim.
     if (feitas.has('pesquisar_referencia')) dispensaveis.add('pesquisa');
     return dispensaveis;
 }
@@ -253,7 +263,7 @@ function relatorio({ prompt, ferramentas, messages }) {
 // O CLI já protege as mesmas mensagens antes de mandar (lib/repeticao.js), mas
 // quem falava por último aqui era `caberNoTeto`, que não sabia disso e cortava
 // assim mesmo. Dois compactadores brigando, e o do servidor ganhava.
-const REFERENCIAS = new Set(['studio_manual', 'studio_spec']);
+const REFERENCIAS = new Set(['planejar_producao', 'estudio_site']);
 
 // Referência tem teto GENEROSO, não infinito.
 //

package/lib/local/motor-cli.js

@@ -37,7 +37,7 @@ function motorDe(id) {
 function perguntar(id, texto) {
     if (id === 'codex') return String(motorDe('codex').chamarCodex(texto) || '').trim();
     const claude = motorDe('claude-code');
-    const saida = execFileSync('claude', ['-p', '--output-format', 'json', ...claude.argsDoModelo()], {
+    const saida = execFileSync('claude', ['-p', '--output-format', 'json', ...claude.argsDoMotor()], {
         encoding: 'utf-8', timeout: 120000, input: texto, maxBuffer: 8 * 1024 * 1024, ...SEM_APARECER,
     });
     try { return String(JSON.parse(saida).result || '').trim(); } catch { return String(saida || '').trim(); }

package/lib/offline.js

@@ -0,0 +1,168 @@
+/**
+ * offline.js — o primocode-server rodando AQUI, no computador da pessoa.
+ *
+ *   "Como eu não tenho acesso ao Railway, enquanto isso eu posso testar com o
+ *    projeto rodando localmente, chamando as APIs pelo meu computador."
+ *   (24/09/2026)
+ *
+ * O /offline sobe o servidor da pasta primocode-server com as MESMAS chaves
+ * que o Render usa (coladas em ~/.primocode/servidor.env) e aponta o CLI para
+ * ele até a sessão acabar. É temporário: serve para testar o servidor novo
+ * antes de ele ir para produção.
+ *
+ * "Offline" é o nome que o pedido deu, e ele mente um pouco: as IAs continuam
+ * na internet. O que sai do caminho é o servidor de produção.
+ *
+ * ── O QUE NUNCA APARECE ──────────────────────────────────────────────────
+ * O valor de uma chave. Mostram-se só os NOMES das variáveis que o arquivo
+ * tem, o bastante para ver o que falta.
+ */
+
+'use strict';
+
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+const http = require('http');
+const { spawn } = require('child_process');
+
+const PORTA = Number(process.env.PRIMOCODE_OFFLINE_PORTA || 3190);
+const CASA = path.join(os.homedir(), '.primocode');
+const ARQUIVO_ENV = path.join(CASA, 'servidor.env');
+const ARQUIVO_LOG = path.join(CASA, 'servidor-local.log');
+
+// As variáveis que o primocode-server lê. As de chave vêm primeiro: sem pelo
+// menos uma delas, o servidor sobe mas não tem com quem falar.
+const CHAVES = ['GROQ_API_KEY', 'OPENROUTER_API_KEY', 'GEMINI_API_KEY', 'GOOGLE_API_KEY', 'COHERE_API_KEY', 'HF_TOKEN', 'HUGGINGFACE_API_KEY', 'PG_GATEWAY_API_KEY'];
+const OUTRAS = ['PG_GATEWAY_BASE_URL', 'CONECTA_API', 'PRIMOCODE_TOKEN', 'REQUIRE_TOKEN', 'RATE_LIMIT_PER_HOUR'];
+
+const MODELO_ENV = `# As chaves do primocode-server rodando no seu computador (/offline).
+# Copie do Render: o serviço primocode-server → Environment. Uma por linha,
+# NOME=valor, sem aspas. Este arquivo é só seu: não mande para ninguém.
+#
+${CHAVES.map((k) => `# ${k}=`).join('\n')}
+#
+${OUTRAS.map((k) => `# ${k}=`).join('\n')}
+`;
+
+/** Lê um .env simples: NOME=valor, # comenta, aspas em volta saem. */
+function lerEnv(texto) {
+    const env = {};
+    for (const linha of String(texto || '').split(/\r?\n/)) {
+        const m = linha.match(/^\s*(?:export\s+)?([A-Za-z_][A-Za-z0-9_]*)\s*=\s*(.*?)\s*$/);
+        if (!m) continue;
+        let valor = m[2];
+        if (/^(['"]).*\1$/.test(valor)) valor = valor.slice(1, -1);
+        if (valor) env[m[1]] = valor;
+    }
+    return env;
+}
+
+/** O arquivo de chaves: cria o modelo (vazio, 600) na primeira vez. */
+function prepararEnv(arquivo = ARQUIVO_ENV) {
+    let criado = false;
+    if (!fs.existsSync(arquivo)) {
+        fs.mkdirSync(path.dirname(arquivo), { recursive: true });
+        fs.writeFileSync(arquivo, MODELO_ENV, { mode: 0o600 });
+        criado = true;
+    }
+    const env = lerEnv(fs.readFileSync(arquivo, 'utf8'));
+    return { arquivo, criado, env, nomes: Object.keys(env), temChave: CHAVES.some((k) => env[k]) };
+}
+
+function ehServidor(dir) {
+    try {
+        const pkg = JSON.parse(fs.readFileSync(path.join(dir, 'package.json'), 'utf8'));
+        return pkg.name === 'primocode-server' && fs.existsSync(path.join(dir, 'server.js'));
+    } catch { return false; }
+}
+
+/** Onde está a pasta do primocode-server. A primeira que existir ganha. */
+function acharServidor({ pedido = '', raizCli = path.join(__dirname, '..') } = {}) {
+    const candidatos = [
+        pedido,
+        process.env.PRIMOCODE_SERVER_DIR,
+        path.join(raizCli, '..', 'primocode-server'),
+        path.join(os.homedir(), 'Primocode CLI', 'primocode-server'),
+        path.join(os.homedir(), 'primocode-server'),
+    ].filter(Boolean).map((p) => path.resolve(p.replace(/^~(?=$|\/)/, os.homedir())));
+    return candidatos.find(ehServidor) || null;
+}
+
+/** GET /health; devolve o JSON ou null. */
+function saude(url, espera = 1500) {
+    return new Promise((resolve) => {
+        const req = http.get(url + '/health', { timeout: espera }, (res) => {
+            let corpo = '';
+            res.on('data', (d) => { corpo += d; });
+            res.on('end', () => { try { resolve(JSON.parse(corpo)); } catch { resolve(null); } });
+        });
+        req.on('timeout', () => req.destroy());
+        req.on('error', () => resolve(null));
+    });
+}
+
+let filho = null;
+
+/**
+ * Sobe o servidor (ou reaproveita um que já responde na porta).
+ * Devolve { ok, url, versao, reaproveitado } ou { ok: false, error, comoResolver }.
+ */
+async function ligar({ dir, env = {}, porta = PORTA, log = ARQUIVO_LOG, prazo = 20000 } = {}) {
+    const url = `http://localhost:${porta}`;
+    const ja = await saude(url);
+    if (ja && ja.status === 'ok') return { ok: true, url, versao: ja.version, reaproveitado: true };
+    if (!dir) {
+        return {
+            ok: false,
+            error: 'Não achei a pasta do primocode-server.',
+            comoResolver: 'clone o repo ao lado do primocode, ou diga onde ele está: /offline ~/caminho/primocode-server',
+        };
+    }
+    if (!fs.existsSync(path.join(dir, 'node_modules'))) {
+        return {
+            ok: false,
+            error: `O servidor em ${dir} ainda não tem as dependências.`,
+            comoResolver: `rode uma vez: cd "${dir}" && npm install`,
+        };
+    }
+    fs.mkdirSync(path.dirname(log), { recursive: true });
+    const saida = fs.openSync(log, 'a');
+    filho = spawn(process.execPath, ['server.js'], {
+        cwd: dir,
+        env: { ...process.env, ...env, PORT: String(porta) },
+        stdio: ['ignore', saida, saida],
+    });
+    let morreu = null;
+    filho.on('exit', (codigo) => { morreu = codigo; filho = null; });
+
+    const fim = Date.now() + prazo;
+    while (Date.now() < fim) {
+        if (morreu !== null) {
+            return { ok: false, error: `O servidor fechou sozinho (código ${morreu}).`, comoResolver: `veja o fim de ${log}` };
+        }
+        const h = await saude(url);
+        if (h && h.status === 'ok') return { ok: true, url, versao: h.version, reaproveitado: false };
+        await new Promise((r) => setTimeout(r, 300));
+    }
+    desligar();
+    return { ok: false, error: `O servidor não respondeu em ${Math.round(prazo / 1000)}s.`, comoResolver: `veja o fim de ${log}` };
+}
+
+/** Desliga o servidor que ESTE processo subiu. Um reaproveitado fica de pé. */
+function desligar() {
+    if (!filho) return false;
+    try { filho.kill(); } catch {}
+    filho = null;
+    return true;
+}
+
+function ligado() { return Boolean(filho); }
+
+// O servidor não pode sobrar rodando quando o CLI fecha.
+process.on('exit', desligar);
+
+module.exports = {
+    PORTA, ARQUIVO_ENV, ARQUIVO_LOG, CHAVES,
+    lerEnv, prepararEnv, acharServidor, ehServidor, saude, ligar, desligar, ligado,
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "primocode",
-  "version": "9.8.0-beta.8",
+  "version": "9.8.0",
   "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/skills-de-fora.test.js && node test/skills-novas.test.js && node test/comandos.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/kits.test.js && node test/api-propria.test.js && node test/claude-engine.test.js && node test/codex.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/desfazer.test.js && node test/desfazer-git.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/app-janela.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 && node test/contexto.test.js && node test/perigo.test.js && node test/rapidez.test.js && node test/mascotes.test.js && node test/comandos-extra.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/skills-de-fora.test.js && node test/skills-novas.test.js && node test/comandos.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/claude-engine.test.js && node test/codex.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/desfazer.test.js && node test/desfazer-git.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/app-janela.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 && node test/contexto.test.js && node test/perigo.test.js && node test/rapidez.test.js && node test/mascotes.test.js && node test/comandos-extra.test.js && node test/offline.test.js && node test/edicao.test.js && node test/composicao.test.js && node test/acervo-site.test.js && node test/impacto.test.js && node test/cinema.test.js"
   },
   "engines": {
     "node": ">=18.17.0"
@@ -30,7 +30,6 @@
     "app/",
     "studio/",
     "skills/",
-    "kits/",
     "voz/",
     "README.md",
     "comandos/",

package/skills/design-de-verdade/SKILL.md

@@ -7,6 +7,8 @@ autor: adaptado de "frontend-design" (Anthropic, anthropics/skills, Apache-2.0
 Trabalhe como o diretor de arte de um estúdio conhecido por dar a cada cliente uma identidade que
 ninguém confunde. O cliente já recusou propostas com cara de modelo pronto.
 
+**Não existe modelo.** Toda página começa do zero, e nenhuma sai com a estrutura da anterior.
+
 **Comece pelo assunto.** O ramo, os materiais e o vocabulário do negócio são de onde vem a escolha
 visual. Um brinquedo para meninas de 8 anos e um painel de analista financeiro não se parecem em nada.
 Use o conteúdo real do pedido em tudo, e não texto genérico.

package/skills/motion-de-primeira/SKILL.md

@@ -1,7 +1,7 @@
 ---
 nome: Motion de primeira
 descricao: como um vídeo criado do zero deixa de parecer feito por máquina
-quando: vídeo, video, motion, animação, animacao, anúncio, anuncio, reels, teaser, abertura, comercial, propaganda, estúdio, estudio
+quando: vídeo, video, motion graphics, vídeo animado, video animado, anúncio, anuncio, reels, teaser, vinheta, comercial, propaganda, estúdio, estudio
 autor: PrimoCode
 ---
 Não existe template. Cada propriedade deste vídeo é uma decisão sua, e a

package/skills/site-com-motion/SKILL.md

@@ -0,0 +1,39 @@
+---
+nome: Site com motion
+descricao: movimento em site e landing que parece de estúdio, e não efeito jogado em tudo
+quando: motion, site animado, landing animada, página animada, pagina animada, animação no site, animações no site, animacao no site, com animação, com animacao, com animações, scroll, parallax, transição, transicao, microinteração, microinteracao, efeito, efeitos, gsap, hover, landing, landing page, página, pagina, site, one page
+autor: PrimoCode
+---
+Movimento em site serve para três coisas: **mostrar a ordem** (o que ler primeiro), **responder à
+pessoa** (clicou, passou o mouse, rolou) e **dar um momento memorável**. Fora disso, é ruído.
+
+**Planeje o movimento antes do código**, em três linhas:
+- o momento marcante: UMA coisa (a abertura se montando, o título que se desenha, o produto que gira
+  com o scroll);
+- como as seções entram: cada uma do jeito que o conteúdo pede, e não o mesmo fade em todas;
+- a resposta ao toque: botão, card, link, campo.
+
+**O que denuncia animação feita por IA:** fade subindo em toda seção; hover que aumenta todo card;
+tudo com a mesma duração; `transition: all`; texto piscando; nada que responda ao scroll.
+
+**Como se faz bem:**
+- **Tempo:** resposta ao toque em 120 a 200 ms. Entrada de elemento em 400 a 700 ms. O momento
+  marcante pode levar 1 a 1,5 s, uma vez só.
+- **Curva:** nada linear. Para entrar, `cubic-bezier(.2,.8,.2,1)`. Para sair, a curva ao contrário
+  e mais curta que a entrada.
+- **Cascata:** itens de uma lista entram com 40 a 80 ms de diferença, e não todos juntos.
+- **Scroll:** `IntersectionObserver` põe uma classe quando a seção aparece, e o CSS anima. Pra algo
+  que acompanha o scroll (parallax, barra de progresso, imagem que cresce), use
+  `animation-timeline: view()` e deixe a página parada onde isso não existe (`@supports`).
+- **Só `transform` e `opacity`.** Animar `top`, `width`, `height` ou `box-shadow` trava no celular.
+- **Troca de página ou de estado:** a View Transitions API (`document.startViewTransition`), com o
+  caminho sem animação quando o navegador não tiver.
+- **Biblioteca só se precisar.** CSS e um pouco de JS resolvem quase tudo. Timeline longa ou texto
+  que se quebra letra a letra: GSAP pelo CDN.
+
+**Obrigatório:** `@media (prefers-reduced-motion: reduce)` desliga o movimento grande e deixa só
+troca de cor e opacidade. O conteúdo aparece mesmo sem JS: esconda o elemento só depois que o script
+carregou (uma classe `js` no `<html>`).
+
+**Confira:** abra a página, role do topo ao fim, e pergunte se cada movimento tem um dos três
+motivos. O que não tiver, tire.

package/studio/narrar.py

@@ -200,19 +200,22 @@ def falar_edge(texto, saida, voz, ritmo, tom):
 
 def falar_elevenlabs(texto, saida, voz):
     """Só quando há chave. Sem ela, nem se tenta — e não é erro."""
-    chave = os.environ.get("ELEVENLABS_API_KEY", "").strip()
-    if not chave:
-        return None
+    # A chave mora na variável OU em ~/.primocode/elevenlabs.key — antes só a
+    # variável era lida, e a função chamada (elevenlabs.falar) nem existia:
+    # a ElevenLabs nunca narrou nada, mesmo com a chave no lugar.
     try:
         sys.path.insert(0, str(AQUI))
-        import elevenlabs  # o módulo que já existia no Studio
-        r = elevenlabs.falar(texto, str(saida), voz=voz, chave=chave)
-        if r and r.get("ok"):
-            r["motor"] = "elevenlabs"
-            return r
+        import elevenlabs
+        if not elevenlabs.configurado():
+            return None
+        dados, segundos = elevenlabs.sintetizar(texto, {"voz": voz})
+        if not dados:
+            return None
+        Path(saida).write_bytes(dados)
+        return {"ok": True, "arquivo": str(saida), "motor": "elevenlabs", "segundos": segundos,
+                "falas": [{"de": 0, "ate": segundos, "texto": texto}]}
     except Exception:
-        pass
-    return None
+        return None
 
 
 def comando_falar(args):
@@ -245,6 +248,97 @@ def comando_falar(args):
     return falar_edge(texto, args.saida, v["voz"], ritmo, tom)
 
 
+# ── o roteiro inteiro, com entonação por parte ─────────────────────────────
+# "A voz está sem entonação." (25/09/2026). Uma chamada só, com o texto todo,
+# sai no mesmo ritmo e no mesmo tom do começo ao fim. Aqui cada parte do
+# roteiro é falada com o registro dela — o gancho mais aceso, o número mais
+# devagar, o fecho mais alto — e as partes são costuradas com um respiro. O
+# tempo de CADA PALAVRA volta junto (WordBoundary do edge-tts): é o que
+# sincroniza a tipografia com a voz.
+REGISTRO = {
+    "gancho":   {"ritmo": "+6%",  "tom": "+3Hz", "respiro": 0.35},
+    "numero":   {"ritmo": "-7%",  "tom": "-1Hz", "respiro": 0.45},
+    "contraste": {"ritmo": "+2%", "tom": "+1Hz", "respiro": 0.4},
+    "lista":    {"ritmo": "+0%",  "tom": "+0Hz", "respiro": 0.35},
+    "citacao":  {"ritmo": "-10%", "tom": "-2Hz", "respiro": 0.5},
+    "cta":      {"ritmo": "+4%",  "tom": "+2Hz", "respiro": 0.2},
+    "normal":   {"ritmo": "+0%",  "tom": "+0Hz", "respiro": 0.3},
+}
+
+
+def _parte_edge(texto, voz, ritmo, tom, saida):
+    import asyncio
+    import edge_tts
+
+    async def rodar():
+        c = edge_tts.Communicate(texto, voz, rate=ritmo, pitch=tom, boundary="WordBoundary")
+        palavras = []
+        with open(saida, "wb") as fh:
+            async for ch in c.stream():
+                if ch["type"] == "audio":
+                    fh.write(ch["data"])
+                elif ch["type"] == "WordBoundary":
+                    de = ch["offset"] / 1e7
+                    palavras.append({"de": round(de, 3), "ate": round(de + ch["duration"] / 1e7, 3),
+                                     "texto": ch["text"]})
+        return palavras
+    return asyncio.run(rodar())
+
+
+def _duracao(arquivo):
+    r = subprocess.run(["ffprobe", "-v", "error", "-show_entries", "format=duration",
+                        "-of", "csv=p=0", str(arquivo)], capture_output=True, text=True, timeout=30)
+    try:
+        return float(r.stdout.strip())
+    except ValueError:
+        return 0.0
+
+
+def comando_roteiro(args):
+    partes = json.loads(Path(args.arquivo).read_text(encoding="utf-8"))
+    if not partes:
+        return {"ok": False, "error": "o roteiro veio vazio"}
+    if not edge_disponivel() and not instalar_edge():
+        return {"ok": False, "error": "a narração precisa do pacote edge-tts",
+                "comoResolver": f"{sys.executable} -m pip install edge-tts"}
+    v = voz_de(args.voz)
+    with tempfile.TemporaryDirectory() as tmp:
+        lista, trechos, palavras, t = [], [], [], 0.0
+        for i, parte in enumerate(partes):
+            texto = re.sub(r"\s+", " ", str(parte.get("texto") or "")).strip()
+            if not texto:
+                trechos.append({"de": round(t, 3), "ate": round(t, 3), "palavras": []})
+                continue
+            reg = REGISTRO.get(parte.get("registro") or "normal", REGISTRO["normal"])
+            mp3 = Path(tmp) / f"p{i:02d}.mp3"
+            try:
+                ps = _parte_edge(texto, v["voz"], reg["ritmo"], reg["tom"], mp3)
+            except Exception as e:
+                return {"ok": False, "error": f"a voz falhou na parte {i + 1}: {str(e)[:200]}"}
+            dur = _duracao(mp3)
+            wav = Path(tmp) / f"p{i:02d}.wav"
+            # Cada parte vira wav com o respiro no fim: costurar mp3 direto
+            # deixa um clique e um silêncio de enchimento entre as partes.
+            subprocess.run(["ffmpeg", "-y", "-loglevel", "error", "-i", str(mp3), "-af",
+                            f"apad=pad_dur={reg['respiro']}", "-ar", "44100", "-ac", "1", str(wav)],
+                           capture_output=True, timeout=60)
+            lista.append(wav)
+            ws = [{"de": round(t + w["de"], 3), "ate": round(t + w["ate"], 3), "texto": w["texto"]} for w in ps]
+            palavras += ws
+            trechos.append({"de": round(t, 3), "ate": round(t + dur, 3), "palavras": ws})
+            t += dur + reg["respiro"]
+        roteiro_txt = Path(tmp) / "lista.txt"
+        roteiro_txt.write_text("".join(f"file '{w}'\n" for w in lista), encoding="utf-8")
+        r = subprocess.run(["ffmpeg", "-y", "-loglevel", "error", "-f", "concat", "-safe", "0",
+                            "-i", str(roteiro_txt), "-af", "loudnorm=I=-14:TP=-1.5:LRA=9",
+                            "-c:a", "libmp3lame", "-q:a", "3", str(args.saida)],
+                           capture_output=True, timeout=180)
+        if r.returncode != 0:
+            return {"ok": False, "error": (r.stderr or b"").decode("utf-8", "ignore")[-300:]}
+    return {"ok": True, "arquivo": str(args.saida), "motor": "edge", "voz": v["voz"],
+            "segundos": round(t, 3), "partes": trechos, "palavras": palavras}
+
+
 def main():
     p = argparse.ArgumentParser(description="Narração do PrimoCode Studio")
     sub = p.add_subparsers(dest="comando", required=True)
@@ -258,11 +352,18 @@ def main():
     f.add_argument("--ritmo", default="")
     f.add_argument("--tom", default="")
 
+    r = sub.add_parser("roteiro")
+    r.add_argument("--arquivo", required=True)
+    r.add_argument("--saida", required=True)
+    r.add_argument("--voz", default="thalita")
+
     sub.add_parser("vozes")
 
     args = p.parse_args()
     if args.comando == "vozes":
         saida = {"ok": True, "vozes": VOZES, "estilos": list(ESTILOS.keys())}
+    elif args.comando == "roteiro":
+        saida = comando_roteiro(args)
     else:
         saida = comando_falar(args)
 

package/studio/rostos.py

@@ -0,0 +1,52 @@
+#!/usr/bin/env python3
+"""rostos.py — onde estão as pessoas em cada foto.
+
+    "Aparecem três homens ali, ela está cortada, não dá pra ver ninguém."
+    (25/09/2026)
+
+Foto deitada num vídeo em pé perde dois terços da largura. Recortar pelo
+centro corta as pessoas. Aqui se acha o retângulo que cobre todos os rostos
+da foto (MediaPipe, o mesmo do recorte da pessoa), e o vídeo enquadra nele —
+ou, quando os rostos não cabem no recorte, mostra a foto inteira.
+
+Uso:
+    python3 rostos.py foto1.webp foto2.jpg …
+Saída (JSON): {"ok": true, "fotos": {"foto1.webp": {"largura", "altura", "n",
+               "cx", "cy", "x0", "x1", "y0", "y1"}}}   (tudo de 0 a 1)
+"""
+
+import json
+import sys
+
+
+def main():
+    try:
+        import cv2
+        import mediapipe as mp
+    except Exception as e:  # sem as bibliotecas, ninguém é enquadrado — e não é erro
+        print(json.dumps({"ok": False, "error": f"sem mediapipe: {e}"}))
+        return
+    det = mp.solutions.face_detection.FaceDetection(model_selection=1, min_detection_confidence=0.45)
+    fotos = {}
+    for caminho in sys.argv[1:]:
+        img = cv2.imread(caminho)
+        if img is None:
+            continue
+        h, w = img.shape[:2]
+        r = det.process(cv2.cvtColor(img, cv2.COLOR_BGR2RGB))
+        caixas = []
+        for d in (r.detections or []):
+            b = d.location_data.relative_bounding_box
+            caixas.append((max(0, b.xmin), max(0, b.ymin), min(1, b.xmin + b.width), min(1, b.ymin + b.height)))
+        item = {"largura": w, "altura": h, "n": len(caixas)}
+        if caixas:
+            x0 = min(c[0] for c in caixas); y0 = min(c[1] for c in caixas)
+            x1 = max(c[2] for c in caixas); y1 = max(c[3] for c in caixas)
+            item.update({"x0": round(x0, 3), "y0": round(y0, 3), "x1": round(x1, 3), "y1": round(y1, 3),
+                         "cx": round((x0 + x1) / 2, 3), "cy": round((y0 + y1) / 2, 3)})
+        fotos[caminho] = item
+    print(json.dumps({"ok": True, "fotos": fotos}))
+
+
+if __name__ == "__main__":
+    main()