primocode 8.42.1 → 9.0.0

package/lib/voz.js

@@ -0,0 +1,239 @@
+/**
+ * voz.js — o lado Node do modo voz.
+ *
+ * O aplicativozinho da orb é Python (ver voz/primo_voz). O que mora aqui é a
+ * outra ponta: subir o processo, conversar com ele por JSON, e — a parte que
+ * importa — entregar cada pedido ao MESMO agente do terminal.
+ *
+ * ── POR QUE O CÉREBRO NÃO FOI PARA O PYTHON ──────────────────────────────
+ * O Jarvis mantinha uma sessão do Claude Code num processo filho e conversava
+ * por stream-json. Copiar aquele desenho aqui significaria uma segunda
+ * implementação do laço do agente, das quarenta ferramentas, do portão de
+ * permissão do computador e da corrente de conectores — em outra linguagem.
+ *
+ * Duas implementações do mesmo laço é a garantia de que uma delas está errada,
+ * e de que a correção de amanhã vai para só uma. Então o modo voz manda o
+ * texto para o `runAct` de sempre: as mesmas ferramentas, as mesmas skills, a
+ * mesma permissão, os mesmos conectores.
+ *
+ * ── O PEDIDO SAI DIFERENTE, E SÓ ISSO ────────────────────────────────────
+ * Uma resposta boa de ler é ruim de ouvir: lista com marcador, caminho de
+ * arquivo, bloco de código e trecho longo só funcionam para o olho. Então o
+ * pedido vai com uma instrução curta de FORMA — não de conteúdo. O agente
+ * continua fazendo o mesmo trabalho; ele só conta de outro jeito.
+ */
+
+'use strict';
+
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+const { spawn, execFileSync } = require('child_process');
+
+const PASTA = path.join(__dirname, '..', 'voz');
+
+/* A instrução de FORMA. Ela não muda o que o agente faz — muda como ele
+   conta. O que está proibido aqui é o que não existe em voz: marcador,
+   caminho, código, e parágrafo que ninguém segura de ouvido. */
+const COMO_FALAR = `[MODO VOZ] A sua resposta vai ser LIDA EM VOZ ALTA para a pessoa, e ela não vê tela nenhuma.
+
+Responda em no máximo 3 frases curtas, em português falado. Nada de lista com
+marcador, nada de caminho de arquivo, nada de bloco de código, nada de
+markdown — nada disso existe no ouvido de alguém.
+
+Diga o que você FEZ e o que mudou, não como. Se algo deu errado, diga em uma
+frase o que foi e o que você precisa.
+
+Faça o trabalho inteiro normalmente, com as ferramentas de sempre. O que muda
+é só o jeito de contar no fim.`;
+
+/** Onde está o Python 3. Mesmo problema do Estúdio, mesma cura. */
+function python() {
+    const nomes = process.platform === 'win32'
+        ? ['python', 'py', 'python3']
+        : ['python3', 'python', '/opt/homebrew/bin/python3', '/usr/local/bin/python3', '/usr/bin/python3'];
+    for (const n of nomes) {
+        try {
+            const v = execFileSync(n, ['--version'], { stdio: ['ignore', 'pipe', 'pipe'], timeout: 5000 }).toString();
+            if (/Python 3/.test(v)) return n;
+        } catch { /* próximo */ }
+    }
+    return null;
+}
+
+/**
+ * O que falta para o modo voz abrir — e QUAL é a falta.
+ *
+ * A distinção é a diferença entre um recado que resolve e um que faz a pessoa
+ * dar voltas. Dois casos não se resolvem com pip:
+ *
+ *   · `sounddevice` instalado, mas sem o PortAudio do sistema. O import
+ *     explode com "PortAudio library not found", e mandar `pip install
+ *     sounddevice` ali é mandar instalar o que já está instalado.
+ *   · `tkinter` vem com o Python, mas algumas distribuições Linux o separam
+ *     num pacote do sistema — e `pip install tkinter` não existe.
+ *
+ * Por isso a checagem lê a MENSAGEM do erro, e não só o fato de ter falhado.
+ */
+function faltando(py) {
+    const falta = [];
+    for (const [modulo, pacote] of [['numpy', 'numpy'], ['sounddevice', 'sounddevice'], ['tkinter', null]]) {
+        try {
+            execFileSync(py, ['-c', `import ${modulo}`], { stdio: ['ignore', 'pipe', 'pipe'], timeout: 20000 });
+        } catch (e) {
+            const saida = String((e.stderr || '') + (e.stdout || ''));
+            if (/portaudio/i.test(saida)) {
+                falta.push({ modulo, pacote: null, sistema: true, porque: 'o PortAudio, que é biblioteca do sistema' });
+            } else {
+                falta.push({ modulo, pacote });
+            }
+        }
+    }
+    return falta;
+}
+
+/** Como instalar uma biblioteca de sistema, neste sistema. */
+const COMO_SISTEMA = {
+    portaudio: {
+        darwin: 'brew install portaudio',
+        linux: 'sudo apt install libportaudio2   (ou o equivalente da sua distribuição)',
+        win32: 'no Windows ele vem junto com o sounddevice — reinstale com pip',
+    },
+    tkinter: {
+        darwin: 'brew install python-tk',
+        linux: 'sudo apt install python3-tk',
+        win32: 'reinstale o Python pelo python.org, marcando "tcl/tk"',
+    },
+};
+
+/**
+ * Confere o que é preciso, sem instalar nada.
+ *
+ * O tkinter é o caso especial: ele vem com o Python, mas em algumas
+ * distribuições Linux ele foi separado num pacote do SISTEMA — e `pip install
+ * tkinter` não existe. Dizer "instale com pip" ali seria mandar a pessoa a um
+ * lugar onde não há nada.
+ */
+function conferir() {
+    const py = python();
+    if (!py) {
+        return { ok: false, error: 'o modo voz precisa do Python 3, e não achei nenhum nesta máquina.',
+            comoResolver: 'instale em python.org e abra o terminal de novo' };
+    }
+    const falta = faltando(py);
+    if (!falta.length) return { ok: true, python: py };
+
+    const pip = falta.filter((f) => f.pacote).map((f) => f.pacote);
+    const linhas = [];
+    if (pip.length) linhas.push(`${py} -m pip install ${pip.join(' ')}`);
+    if (falta.some((f) => f.modulo === 'sounddevice' && f.sistema)) {
+        linhas.push(COMO_SISTEMA.portaudio[process.platform] || COMO_SISTEMA.portaudio.linux);
+    }
+    if (falta.some((f) => f.modulo === 'tkinter')) {
+        linhas.push(COMO_SISTEMA.tkinter[process.platform] || COMO_SISTEMA.tkinter.linux);
+    }
+
+    return {
+        ok: false,
+        python: py,
+        falta: falta.map((f) => f.modulo),
+        error: `falta o que o modo voz precisa: ${falta.map((f) => f.porque || f.modulo).join(', ')}`,
+        comoResolver: linhas.join('\n  '),
+        // Só o que o pip resolve entra no "instalar agora": oferecer instalar
+        // o que ele não instala é prometer o que não se cumpre.
+        instalavel: pip,
+    };
+}
+
+/** Instala o que dá para instalar com pip. O tkinter não passa por aqui. */
+function instalar(py, pacotes, aoFalar = () => {}) {
+    return new Promise((resolve) => {
+        aoFalar(`instalando ${pacotes.join(', ')} (uma vez, alguns minutos)`);
+        const p = spawn(py, ['-m', 'pip', 'install', '--quiet', ...pacotes]);
+        let erro = '';
+        p.stderr.on('data', (d) => { erro += d.toString(); });
+        p.on('close', (code) => resolve(code === 0
+            ? { ok: true }
+            : { ok: false, error: erro.slice(-400).trim() || `pip saiu com ${code}` }));
+        p.on('error', (e) => resolve({ ok: false, error: e.message }));
+    });
+}
+
+/**
+ * Abre o modo voz e fica de pé até a janela fechar.
+ *
+ * @param {object} op
+ * @param {string} op.python
+ * @param {string} op.servidor
+ * @param {string} op.token
+ * @param {string} op.voz
+ * @param {(texto:string)=>Promise<string>} op.pensar   o agente de verdade
+ * @param {(texto:string)=>void} op.mostrar             o que aparece no terminal
+ */
+function abrir({ python: py, servidor, token, voz, pensar, mostrar = () => {} }) {
+    return new Promise((resolve) => {
+        const p = spawn(py, ['-m', 'primo_voz'], {
+            cwd: PASTA,
+            env: {
+                ...process.env,
+                PYTHONPATH: PASTA,
+                PRIMOCODE_SERVER: servidor,
+                PRIMOCODE_TOKEN: token || '',
+                PRIMOCODE_VOZ: voz || 'antonio',
+                PYTHONUNBUFFERED: '1',
+            },
+        });
+
+        const manda = (obj) => {
+            try { p.stdin.write(JSON.stringify(obj) + '\n'); } catch { /* já fechou */ }
+        };
+
+        let buffer = '';
+        let ocupado = false;
+
+        p.stdout.on('data', async (d) => {
+            buffer += d.toString();
+            const linhas = buffer.split('\n');
+            buffer = linhas.pop();
+            for (const linha of linhas) {
+                if (!linha.trim()) continue;
+                let msg;
+                try { msg = JSON.parse(linha); } catch { continue; }
+
+                if (msg.tipo === 'fim') { try { p.kill(); } catch {} return; }
+                if (msg.tipo === 'erro') { mostrar(String(msg.texto || '')); continue; }
+                if (msg.tipo !== 'pedido') continue;
+
+                /* Um pedido por vez. A pessoa pode falar de novo enquanto ele
+                   trabalha — e dois agentes rodando ao mesmo tempo na mesma
+                   pasta é a receita para um escrever por cima do outro. */
+                if (ocupado) { manda({ tipo: 'resposta', texto: 'Ainda estou terminando o anterior.' }); continue; }
+                ocupado = true;
+
+                mostrar(String(msg.texto || ''));
+                manda({ tipo: 'estado', estado: 'pensando' });
+                try {
+                    const resposta = await pensar(String(msg.texto || ''));
+                    manda({ tipo: 'resposta', texto: resposta || 'Feito.' });
+                } catch (e) {
+                    manda({ tipo: 'erro', texto: `Não consegui: ${e.message}` });
+                } finally {
+                    ocupado = false;
+                }
+            }
+        });
+
+        // O Python fala com o terminal pela saída de ERRO, de propósito: o
+        // stdout inteiro é do protocolo, e uma linha solta ali quebraria a
+        // conversa entre os dois processos.
+        p.stderr.on('data', (d) => {
+            const texto = d.toString().trim();
+            if (texto) mostrar(texto, true);
+        });
+
+        p.on('close', () => resolve({ ok: true }));
+        p.on('error', (e) => resolve({ ok: false, error: e.message }));
+    });
+}
+
+module.exports = { conferir, instalar, abrir, python, COMO_FALAR, PASTA };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "primocode",
-  "version": "8.42.1",
+  "version": "9.0.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/modo.test.js && node test/pasta.test.js && node test/catalogo.test.js && node test/desktop.test.js && node test/effort.test.js && node test/claude-engine.test.js && node test/regressao.test.js && node test/memoria-conversa.test.js && node test/repeticao.test.js && node test/referencia.test.js && node test/parar.test.js && node test/continuar.test.js && node test/studio-spec.test.js && node test/studio-versoes.test.js && node test/voz.test.js && node test/editor.test.js && node test/estudio-projeto.test.js && node test/vocabulario.test.js && node test/video-export.test.js && node test/monotonia.test.js && node test/clipe.test.js && node test/midia-envio.test.js && node test/pausas.test.js && node test/fala-repetida.test.js && node test/trilha.test.js && node test/anuncio.test.js && node test/pipeline.test.js && node test/app.test.js && node test/elementos.test.js && node test/remotion.test.js && node test/aplicativo.test.js && node test/conta.test.mjs && node test/nuvem.test.js && node test/codex.test.js && node test/chaves.test.js && node test/prazo.test.js && node test/primeira-vez.test.js && node test/janela.test.js && node test/pareamento.test.js && node test/fala.test.js && node test/especialistas.test.js && node test/icone.test.js && node test/exportar.test.js && node test/ate-o-fim.test.js && node test/motion.test.js && node test/audio-marca.test.js && node test/diretor.test.js && node test/camera.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/skills.test.js && node test/estudio.test.js && node test/voz.test.js && node test/modo.test.js && node test/pasta.test.js && node test/catalogo.test.js && node test/desktop.test.js && node test/effort.test.js && node test/regressao.test.js && node test/memoria-conversa.test.js && node test/repeticao.test.js && node test/referencia.test.js && node test/parar.test.js && node test/continuar.test.js && node test/pipeline.test.js && node test/app.test.js && node test/aplicativo.test.js && node test/conta.test.mjs && node test/nuvem.test.js && node test/prazo.test.js && node test/primeira-vez.test.js && node test/janela.test.js && node test/pareamento.test.js && node test/fala.test.js && node test/especialistas.test.js && node test/empurrao.test.js"
   },
   "engines": {
     "node": ">=18.17.0"
@@ -29,6 +29,15 @@
     "lib/",
     "app/",
     "studio/",
-    "README.md"
+    "skills/",
+    "voz/",
+    "README.md",
+    "!**/__pycache__",
+    "!**/*.pyc",
+    "!**/*.pyo",
+    "!**/*.log",
+    "!studio/arquivos",
+    "!studio/midia",
+    "!studio/saida"
   ]
 }

package/skills/acessibilidade/SKILL.md

@@ -0,0 +1,28 @@
+---
+nome: Acessibilidade
+descricao: interface que funciona para quem não usa mouse nem enxerga a tela
+quando: acessibilidade, acessível, acessivel, a11y, aria, teclado, leitor de tela, contraste, semântica, semantica, html
+autor: PrimoCode
+---
+Acessibilidade não é uma camada que se adiciona no fim. É como o HTML é
+escrito.
+
+**HTML semântico primeiro**: `button` para ação, `a` para navegação, `header`,
+`nav`, `main`, `section`, `label`. Uma `div` com `onclick` não recebe foco,
+não responde ao Enter e não existe para um leitor de tela. ARIA só entra
+quando o elemento certo não existe — `aria-label` num `button` de ícone, sim;
+`role="button"` numa `div`, não.
+
+**Teclado**: dá para percorrer a página inteira com Tab, na ordem visual, e o
+foco é VISÍVEL (`:focus-visible` com contorno de verdade — nunca
+`outline: none` sem substituto). Modal prende o foco dentro e volta ao botão
+que o abriu no Esc.
+
+**Contraste**: 4.5:1 em texto normal, 3:1 em texto grande e em borda de
+controle. Cinza-claro sobre branco é a falha mais comum.
+
+**Imagem** tem `alt` que descreve a função, não o arquivo. Decorativa leva
+`alt=""`.
+
+**Formulário**: todo campo com `label` ligado, erro em texto (não só em
+vermelho) e ligado ao campo por `aria-describedby`.

package/skills/api-que-nao-quebra/SKILL.md

@@ -0,0 +1,27 @@
+---
+nome: API que não quebra
+descricao: rotas, validação, erro e segurança em servidor
+quando: api, rota, rotas, endpoint, servidor, backend, express, fastapi, flask, django, rest, webhook, autenticação, autenticacao, token, banco de dados
+autor: PrimoCode
+---
+Leia o que já existe (rotas, modelos, como o projeto trata erro e
+configuração) e siga o padrão dele. Um projeto com dois padrões é pior que um
+projeto com um padrão ruim.
+
+**Valide na borda.** Toda entrada: tipo, tamanho, faixa. O erro responde com o
+código HTTP certo e uma mensagem que diz o que corrigir — "Bad Request" não
+diz nada a ninguém.
+
+**Nunca**: segredo no código (vai para variável de ambiente, com o
+`.env.example` atualizado); entrada do usuário concatenada em SQL, comando de
+shell ou caminho de arquivo; catch vazio; dado pessoal no log.
+
+**Separe** rota, regra de negócio e acesso a dados. A rota lê e responde; ela
+não sabe fazer conta.
+
+**Pense no que falha**: rede fora, disco cheio, campo ausente, mesmo pedido
+chegando duas vezes. Uma rota que só funciona com o caminho feliz não está
+pronta.
+
+Antes de terminar, suba o servidor e mostre uma requisição respondendo de
+verdade — com o corpo da resposta, não só o status.

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

@@ -0,0 +1,29 @@
+---
+nome: Depurar de verdade
+descricao: achar a causa do defeito em vez de tentar consertos no escuro
+quando: bug, erro, defeito, quebrado, não funciona, nao funciona, falha, corrigir, consertar, debug, depurar, travando
+autor: PrimoCode
+---
+Não conserte antes de reproduzir. Conserto sem reprodução é chute, e chute que
+"parece ter resolvido" esconde o defeito para ele voltar depois.
+
+**A ordem**:
+
+1. **Reproduza.** Qual entrada, qual passo, o que aconteceu, o que deveria ter
+   acontecido. Se não reproduz, o defeito não está onde você acha.
+2. **Leia o erro inteiro.** A primeira linha diz o sintoma; a pilha diz o
+   lugar. A linha que importa costuma ser a primeira que é do PROJETO, não da
+   biblioteca.
+3. **Isole.** Metade de cada vez: o dado está errado ao entrar ou ao sair?
+   Antes ou depois desta função? Cada medição corta o espaço de busca pela
+   metade.
+4. **Entenda a causa.** "Adicionei um try/catch e parou de aparecer" não é
+   causa, é mordaça.
+5. **Conserte** o menor pedaço possível, e **prove** rodando a reprodução do
+   passo 1.
+
+Se o projeto tem teste, escreva PRIMEIRO o que falha, depois a correção,
+depois veja-o passar. Assim o defeito não volta sem ninguém ver.
+
+Quando a suspeita for de ambiente (versão, variável, caminho), confira em vez
+de supor: rode `--version`, imprima a variável, liste a pasta.

package/skills/editar-meu-video/SKILL.md

@@ -0,0 +1,59 @@
+---
+nome: Editar o vídeo gravado
+descricao: como tratar uma gravação do usuário sem estragar o ritmo dela
+quando: gravei, gravação, gravacao, meu vídeo, meu video, editar, edição, edicao, corte, legenda, legendas, b-roll, broll
+autor: PrimoCode
+---
+O vídeo é da pessoa. Ela apareceu, falou e errou — o seu trabalho é tirar o
+que atrapalha, não refazer o que ela fez.
+
+## A ordem que funciona
+
+1. `estudio_video acao:"importar"` — o original entra na pasta do projeto, e
+   fica intocado. Nunca escreva por cima do arquivo dela.
+2. `acao:"medir"` — duração, tamanho, fps. Enquadramento vertical e
+   horizontal mudam tudo o que vem depois.
+3. `acao:"legendas"` — a transcrição com tempo. Ela serve para duas coisas: a
+   legenda em si e saber DO QUE ela está falando em cada instante, que é o
+   que decide onde entra apoio.
+4. `acao:"cortar-silencio"` — depois de ler, não antes.
+5. O plano, com a gravação como elemento de vídeo.
+
+## Corte de silêncio
+
+Pausa curta é fala, não erro. Corte só o que passa de ~0,6s, e deixe respiro
+nas pontas (~0,18s). O padrão já faz isso; mexer nele é decisão, não ajuste.
+
+Depois do corte, ASSISTA: peça quadros (`acao:"quadro"`) em alguns pontos de
+emenda. Corte que fica bom no papel e ruim no ouvido é o normal, não a
+exceção.
+
+## Legenda
+
+A legenda tem estilo — fonte, peso, cor, contorno, posição, animação. Ela não
+é uma linha branca no rodapé por obrigação.
+
+Regras que valem: no máximo 5 ou 6 palavras por vez; posição alta o bastante
+para não ser coberta pela interface do aplicativo onde o vídeo vai; contorno
+ou sombra, porque o fundo muda; e nunca cobrindo o rosto de quem fala.
+
+## B-roll
+
+Quando ela cita uma coisa concreta, essa coisa aparece — e ela some da tela
+por 1 a 3 segundos. Depois volta. É isso que dá ritmo a vídeo falado.
+
+Busque a imagem pelo que ela DISSE naquele instante (você tem os tempos da
+transcrição). Volte sempre antes de a frase acabar.
+
+## Troca de fundo
+
+`acao:"recortar-pessoa"` devolve a pessoa com fundo transparente. Ponha uma
+imagem relacionada ao assunto atrás — não uma textura decorativa.
+
+O recorte erra na borda do cabelo. Se ficar com cara de adesivo, aumente o
+`suavizar` e o `encolher` antes de desistir.
+
+## O que contar para ela
+
+Diga quantos segundos saíram e quantos cortes foram feitos. É fala dela que
+sumiu do vídeo — ela tem o direito de saber, e de discordar.

package/skills/escrever-em-portugues/SKILL.md

@@ -0,0 +1,28 @@
+---
+nome: Escrever em português
+descricao: texto de produto que soa como gente, não como manual traduzido
+quando: texto, copy, escrever, redação, redacao, mensagem, microcopy, erro, aviso, botão, botao, e-mail, email, post, legenda
+autor: PrimoCode
+---
+Escreva como alguém que conhece o assunto falaria com um colega — em português
+do Brasil, não em inglês traduzido.
+
+**O que denuncia tradução**: "Nós fornecemos soluções", "Clique aqui para",
+"Oops! Algo deu errado", voz passiva em tudo, "seu/sua" em toda frase,
+gerúndio de call center ("vou estar enviando").
+
+**Mensagem de erro** diz três coisas, nesta ordem: o que aconteceu, por que, e
+o que fazer agora. "Erro 500" não é nenhuma das três. Sem culpar a pessoa: "o
+e-mail precisa de @" e não "você digitou errado".
+
+**Botão** é um verbo que descreve o resultado: "Salvar alterações", "Enviar
+pedido" — nunca "OK", "Enviar" solto ou "Clique aqui".
+
+**Frase curta.** Se precisou de vírgula para respirar duas vezes, são duas
+frases. Corte advérbio ("simplesmente", "basicamente", "rapidamente") e
+superlativo sem número.
+
+Número concreto vence adjetivo: "responde em 2 segundos" vale mais que
+"ultrarrápido".
+
+Não use emoji para dar emoção a um texto que não tem nenhuma.

package/skills/git-limpo/SKILL.md

@@ -0,0 +1,28 @@
+---
+nome: Git limpo
+descricao: commit, branch e histórico que alguém consegue ler depois
+quando: git, commit, commitar, branch, pull request, pr, merge, histórico, historico, versionar
+autor: PrimoCode
+---
+O histórico é documentação. Quem vai lê-lo é você daqui a seis meses,
+procurando por que uma linha existe.
+
+**Commit**: um assunto por commit. A primeira linha diz o que MUDA no
+comportamento, no imperativo e sem ponto final ("corrige o cálculo do frete
+para pedido sem CEP"). O corpo diz POR QUE — o que estava errado e o que se
+tentou antes. O código já mostra o que foi feito; o que ele não mostra é o
+motivo.
+
+**Nunca** commite: segredo, chave, `.env`, `node_modules`, pasta de build,
+arquivo de editor. Confira com `git status` antes, e com `git diff --staged`
+antes de fechar.
+
+**Antes de commitar**, rode o que o projeto roda (lint, teste). Commit que
+quebra a build custa o tempo de todo mundo que der pull.
+
+**Branch** com nome que diz o assunto, não o seu nome.
+
+**Pull request**: título que é a frase do commit; corpo com o que muda, por
+que, e como conferir. Se o projeto tem template de PR, siga o template.
+
+Nunca reescreva histórico que já foi empurrado e que outra pessoa pode ter.

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

@@ -0,0 +1,62 @@
+---
+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
+autor: PrimoCode
+---
+Não existe template. Cada propriedade deste vídeo é uma decisão sua, e a
+primeira decisão é **não repetir o vídeo anterior**.
+
+## O que denuncia vídeo feito por IA
+
+Não faça nada disto, em nenhum vídeo:
+
+- gradiente roxo-para-azul (o mais reconhecível de todos), e gradiente de duas
+  cores que não têm relação com o assunto;
+- tudo centralizado, do primeiro ao último quadro;
+- uma fonte só, em todos os tamanhos;
+- texto que aparece com `opacidade 0→1` e mais nada, cena após cena;
+- ícone genérico flutuando ao lado de cada frase;
+- tempo igual em todas as cenas;
+- transição igual entre todas.
+
+## O que separa motion bom de slide animado
+
+**A câmera existe.** Zoom, pan e dolly são da CENA, não do elemento. Um zoom
+lento de 1.0 para 1.08 ao longo de uma cena dá vida a um quadro parado — e
+quase nenhum vídeo automático faz isso.
+
+**Nada entra do nada.** Um elemento entra vindo de algum lugar (de baixo, de
+trás, de fora do quadro), com `saida` ou `elastico` na suavização. Movimento
+linear é a assinatura da máquina: no mundo físico nada começa e para na mesma
+velocidade.
+
+**Profundidade.** Camadas que se movem em velocidades diferentes (parallax)
+custam duas linhas e mudam a cena inteira: fundo devagar, meio médio, frente
+rápido. Com `perspectiva` na cena, `rotacaoX`/`rotacaoY`/`z` viram 3D de
+verdade.
+
+**Ritmo.** Cena de informação simples: 1,5 a 2,5s. Cena com frase para ler: 3
+a 4s. Fecho: 2s. Variar a duração é o que cria ritmo; repetir cria sono.
+
+**Silêncio visual.** Um quadro com uma frase e mais nada vale mais que um com
+seis elementos. Espaço vazio é composição, não desperdício.
+
+## Cor e tipo
+
+Escolha a paleta a partir do ASSUNTO, e escreva os valores. Três a cinco
+cores: uma dominante, uma de destaque, neutros com viés da dominante. Se a
+marca existe, leia o site dela com `estudio_site` e use as cores medidas —
+não as que você imagina que ela usa.
+
+Duas fontes, no máximo: uma de display para o que grita, uma neutra para o
+que se lê. `estudio_midia acao:"fontes"` mostra um leque grande — sair do
+Inter/Montserrat é metade do trabalho de não parecer genérico.
+
+## Antes de renderizar
+
+- Todo `src` aponta para arquivo que existe na pasta (baixe antes).
+- Os tempos das cenas batem com os tempos MEDIDOS da narração.
+- Nenhuma cena tem a mesma composição da anterior.
+- Leia o seu próprio plano e pergunte: em que este vídeo é diferente do
+  último que eu fiz? Se não houver resposta, refaça antes de renderizar.

package/skills/pagina-que-converte/SKILL.md

@@ -0,0 +1,28 @@
+---
+nome: Página que converte
+descricao: estrutura e acabamento de landing page, site e página de venda
+quando: landing, landing page, site, página, pagina, home, hero, seção, secao, cta, conversão, conversao, vendas, institucional
+autor: PrimoCode
+---
+Uma página que converte tem ordem, não mais elementos.
+
+**A ordem que funciona**: promessa clara em até 8 palavras → uma linha que
+explica para quem é → prova (número real, print, nome de cliente) → o que a
+pessoa ganha, em 3 blocos → objeção respondida → um único pedido de ação,
+repetido no fim.
+
+**Um CTA por página.** Dois pedidos de ação competem entre si e a pessoa não
+faz nenhum.
+
+**O que denuncia página genérica** — não faça nada disto:
+gradiente roxo-para-azul no fundo, tudo centralizado do topo ao rodapé,
+sombra em todo cartão, emoji no lugar de ícone, "Bem-vindo ao nosso site",
+"Soluções inovadoras", texto de exemplo em qualquer lugar.
+
+**Acabamento**: escala de espaço consistente (4/8/12/16/24/32/48), no máximo
+dois pesos de fonte, contraste de 4.5:1 no texto, botão com hover e
+focus-visible, largura de leitura entre 60 e 75 caracteres. Funciona de 360px
+a 1440px sem rolagem horizontal.
+
+Escreva o texto de verdade, sobre o assunto de verdade. Uma página bonita com
+texto vazio não convence ninguém.

package/skills/performance-web/SKILL.md

@@ -0,0 +1,28 @@
+---
+nome: Performance web
+descricao: página que carrega rápido de verdade, não no papel
+quando: performance, lento, lenta, rápido, rapido, otimizar, otimização, otimizacao, carregamento, lighthouse, bundle, imagem, imagens
+autor: PrimoCode
+---
+Meça antes de otimizar. Otimizar por palpite muda código sem mudar o tempo.
+
+**O que quase sempre é o culpado, nesta ordem**: imagem gigante servida em
+tamanho de tela cheia; fonte externa bloqueando a renderização; JavaScript que
+roda antes de a página aparecer; biblioteca inteira importada para usar uma
+função.
+
+**Imagem**: dimensione para o tamanho em que aparece, use formato moderno
+(WebP/AVIF), declare `width` e `height` no HTML (sem isso a página pula
+enquanto carrega) e `loading="lazy"` no que está abaixo da dobra.
+
+**Fonte**: `font-display: swap`, e prefira a fonte do sistema quando a marca
+não exige outra. Uma fonte externa custa uma conexão e um bloqueio.
+
+**JavaScript**: nada que não seja necessário para a primeira tela. `defer` no
+que puder esperar. Antes de adicionar uma biblioteca, escreva a função — três
+linhas suas custam menos que 40 KB de dependência.
+
+**CSS**: evite seletor que força recálculo em rolagem; anime só `transform` e
+`opacity`.
+
+Prove com número: o tamanho do que é baixado antes e depois.

package/skills/revisao-antes-de-entregar/SKILL.md

@@ -0,0 +1,27 @@
+---
+nome: Revisão antes de entregar
+descricao: confere o próprio trabalho antes de dizer que acabou
+quando: pronto, terminar, entregar, finalizar, revisar, conferir, testar, verificar
+autor: PrimoCode
+---
+Antes de dizer que terminou, PROVE. A mentira mais comum de um agente é
+"pronto" sem prova, e ela custa a confiança inteira.
+
+O que conta como prova, por tipo de entrega:
+
+- **Página HTML**: abra com `browser_open` e leia o console. Erro no console é
+  tarefa inacabada, mesmo que a página pareça certa. Confira que o texto
+  aparece de verdade — página em branco por TypeError na primeira linha
+  responde 200 e tem título.
+- **Código com teste**: rode o comando de teste do projeto e mostre a saída
+  real. Nunca escreva "os testes passam" sem a saída na mão.
+- **Código sem teste**: execute o caminho principal uma vez. Se não dá para
+  executar, diga isso em vez de afirmar que funciona.
+- **Arquivo de configuração**: leia de volta o que escreveu.
+
+Releia o seu próprio diff antes de terminar, procurando o que você mesmo
+quebraria: caminho que não existe, promessa sem await, variável que só existe
+num dos ramos, texto de exemplo esquecido.
+
+Se algo ficou por fazer, diga em UMA linha o que foi e por quê. Entregar 90%
+dizendo a verdade vale mais que entregar 90% dizendo 100%.