iron-edge 1.2.0 → 2.0.0

package/skills/gate/SKILL.md

@@ -0,0 +1,318 @@
+---
+name: gate
+description: Quality gate de aprovação duplicada. Audita qualquer entregável — arte, carrossel, story, LP, site, sistema, script, migration, pipeline de dados, PDF, proposta, contrato, vídeo, relatório, README, ADR, runbook, PR — com um painel de auditores independentes ANTES de virar entrega, commit, PR, merge, deploy ou publicação. Dispara quando você escreve "gate", "audita isso", "roda o gate", quando termina algo que vai sair da sua máquina, ou antes de apresentar como pronto. "gate ciclo <pasta>" (ou "gate lote <pasta>") audita um conjunto.
+---
+
+# Gate — aprovação duplicada
+
+Você produz, o gate barra, nada sai sem parecer com **zero BLOQUEADOR**.
+
+A premissa é o princípio dos quatro olhos: quem escreveu não consegue auditar o que escreveu, porque audita a intenção em vez do resultado. O auditor tem que chegar sem saber o que você quis fazer.
+
+## 0. Quando dispara
+
+| Gatilho | Ação |
+|---|---|
+| "gate", "audita isso", "roda o gate" | Auditar a peça citada, ou a última produzida na sessão. Sem perguntar nada |
+| Terminou algo que VAI SAIR (cliente, publicação, PR, merge, deploy, outra pessoa) | Rodar o gate ANTES de apresentar como pronto |
+| Terminou algo local/experimental | Oferecer em uma linha: "Pronto. Rodo o gate?" |
+| "gate ciclo \<pasta\>" ou "gate lote \<pasta ou lista\>" | Modo lote, seção 7 |
+| "libera sem gate" | Válvula de escape, seção 8 |
+
+## 1. Faixas
+
+- **VAI SAIR** (cliente externo, publicação, PR, merge, deploy, entrega para outra pessoa — qualquer coisa que outro humano vai ler, ver ou rodar): painel completo, 2 a 3 lentes — **mais uma** se a lente CONVENÇÃO se aplicar (a peça entra num sistema que já existe), e mais um painel inteiro se a peça for mista (seção 3, passo 1).
+- **LOCAL** (uso próprio, rascunho, experimento, spike que você vai jogar fora): só a lente ★ do painel.
+
+Em dúvida, pergunte em uma linha. Peça de cliente e código que toca dado de produção **nunca** rodam na faixa LOCAL.
+
+*Vocabulário anterior desta skill, mantido só para leitura de pareceres antigos e de agentes com versão velha: **CLIENTE-FINAL** = VAI SAIR · **INTERNO** = LOCAL.*
+
+**Peça que SOBE de faixa no meio do ciclo** (o rascunho LOCAL virou entrega): a faixa nova recomeça em **rodada 1** e o contador de ciclos zera. A lente que nunca rodou não herda aprovação de rodada nenhuma — audita como rodada 1 dela, e não entra "de graça". Dita assim porque a tentação oposta é somar as rodadas antigas e chegar no teto sem nunca ter rodado o painel completo.
+
+⛔ **DESCER de faixa não zera nada, e não afrouxa o painel.** Peça que reprovou e está esperando escalar não vira LOCAL para ganhar ciclos novos: o contador continua de onde estava e a **escalada pendente continua pendente**. Vale para toda descida, inclusive a de boa-fé no meio do ciclo: **o painel que audita a rodada seguinte é sempre o da faixa MAIS RIGOROSA entre a antiga e a nova** — descer nunca reduz o número de lentes de uma peça que já estava sob painel completo. Sem isso, a fuga volta pela outra porta: em vez de zerar o contador, reclassifica e ganha auditoria mais fraca. Toda mudança de faixa vai registrada no parecer, no campo próprio do template (seção 6), com de-para, motivo e data. Mesma lógica da guarda da reentrada por fonte (seção 6), escrita aqui de novo porque é a mesma fuga por outra porta: sob prazo, reclassificar a peça é mais fácil do que consertá-la.
+
+### ⚖️ Dimensionamento: o custo da auditoria tem que caber no tamanho da peça
+
+A faixa diz SE audita. Isto diz QUANTO. Ignorar esta seção é o erro que fez uma legenda de 10 linhas custar **13 minutos de auditoria para 1 minuto de escrita** (caso real, 09/08/2026).
+
+| Tipo de entrega | Verificação | Custo-alvo |
+|---|---|---|
+| **Texto curto** (legenda, mensagem, story escrito, bio, e-mail, commit message) | **SEM painel.** Quem produziu confere cada dado contra a fonte por script/grep e **cola a evidência da conferência** no lugar do parecer. Continua valendo o anti-vício de IA e a checagem de fato | ~1 min |
+| **Variação de peça já aprovada** (story a partir do feed, redimensionamento, troca de data, mesma função com outro parâmetro) | **1 lente só, no risco NOVO daquele formato.** Não remedir o que já foi medido na peça irmã com as mesmas cores e a mesma copy | ~2 min |
+| **Peça visual nova, PDF, site, sistema, pipeline, proposta, documento técnico** | Painel completo da seção 5 | sem teto |
+
+**A distinção que decide:** separar **defeito invisível** de **defeito verificável**.
+- **Invisível** (contraste, safe zone, crop do grid, dedo a mais em foto de IA, emenda de gradiente, exceção engolida, race condition): o olho não pega e quem produziu tem viés. **Exige painel.**
+- **Verificável** (telefone, endereço, data, preço, nome, registro profissional, nome de flag, caminho de arquivo): confere-se contra a fonte em segundos. **Não exige painel, exige conferência.**
+
+⛔ **Não abrir rodada 2 para confirmar correção de fato verificável.** Se o achado foi "faltou o andar no endereço", quem produziu insere, confere contra a fonte, cola a evidência e libera. Rodada 2 existe para achado que precisa de olho independente, não para alguém confirmar que você digitou certo.
+
+⚠️ **Regra boa aplicada sem proporção vira burocracia, e burocracia faz abandonar a regra inteira quando o prazo aperta.** Dimensionar é o que mantém o gate vivo.
+
+## 2. Regras duras (invioláveis)
+
+1. **Auditor nunca é quem produziu.** Cada lente roda num subagente NOVO, contexto limpo, que recebe só os insumos e nunca o seu raciocínio. Se você contar a intenção, ele audita a intenção.
+2. **Quatro insumos:** a peça + o contexto (briefing, copy, issue, ticket, requisito) + as convenções (brandkit/skill da marca, ou README, ADR, CONTRIBUTING, config do linter) + a versão/peça anterior do mesmo ciclo. **Um quinto, quando a peça tem origem de dados:** uma amostra representativa para rodar contra (com nulo, com campo ausente, e vazia) — sem ela o auditor tem que inventar o próprio dado sem saber que devia, e os três casos de execução obrigatória logo abaixo não acontecem. **Insumo faltando NÃO trava:** audita assim mesmo e registra a ausência como achado IMPORTANTE.
+3. **Anti-carimbo:** todo auditor lista os 3 piores defeitos ANTES de emitir qualquer veredito.
+4. **Classificação:** BLOQUEADOR (impede sair) / IMPORTANTE (corrigir antes de sair) / POLIMENTO (opcional). Sempre com evidência concreta (arquivo, linha, comando, saída real, cor, medida) e correção sugerida.
+5. **Só BLOQUEADOR trava.** A nota de 0 a 10 informa, nunca decide.
+6. **Máximo 2 CICLOS** de corrige-e-reaudita — **1 ciclo = corrigir + reauditar só as lentes reprovadas**. A rodada 1 é a auditoria original; ciclo 1 → rodada 2; ciclo 2 → rodada 3. **Se a rodada 3 reprovar, pare e escale, com o diff das 3 tentativas.** Conte CICLO, não rodada: a redação antiga ("máximo 2 rodadas... na terceira, pare") admitia duas leituras opostas quando a rodada 2 reprovava, e a leitura conveniente é sempre a que quem corrigiu quer.
+7. **O gate aponta, você corrige.** Auditor não edita arquivo nenhum.
+8. **Preflight antes do painel** (seção 4). O que a toolchain pega de graça não gasta token de auditor.
+9. **Auditor roda em modelo mais barato** que a sessão quando o Agent tool aceitar `model` (sonnet como padrão; haiku para lente mecânica). Nunca subir de modelo para auditar.
+10. **Tudo vira parecer**, inclusive quando você pula o gate.
+
+### Âncoras de calibração (anti-viés — incluir SEMPRE no prompt de cada auditor)
+
+⚠️ **Existem DUAS listas, e usar a errada desarma o gate.** Peça visual, documento, vídeo e relatório usam a **lista A**. Site, app, script, automação, migration, pipeline e documento técnico usam a **lista B**. Escolher pelo tipo da peça, e no prompt do auditor mandar SÓ a lista que vale. Peça mista (LP com formulário, dashboard, runbook com script) leva as duas.
+
+**LISTA A — peça visual, documento, vídeo, relatório.**
+BLOQUEADOR só quando se encaixa em pelo menos um destes:
+(a) fato errado contra a fonte — preço, nome, data, promessa, capacidade;
+(b) violação objetiva de brandkit — cor, fonte ou logo errados, identidade de outra marca;
+(c) ilegibilidade real — par TEXTO × FUNDO IMEDIATO abaixo de 3:1 (texto grande) ou 4.5:1 (normal). ⚠️ Medir o par certo: texto claro sobre objeto escuro é contraste BOM; variação do fundo atrás do texto NÃO é defeito de legibilidade;
+(d) o produto ou a promessa central não aparece na peça;
+(e) erro de português;
+(f) quase-clone (distância aHash ≤6) de peça já publicada — comparar contra as peças-irmãs do lote **e contra a que está NO AR** (o preflight só enxerga o lote; a peça publicada precisa ser buscada);
+(g) elemento gráfico cobrindo ou cortando logo ou texto de forma que impeça a leitura.
+
+**LISTA B — código, sistema, script, automação, migration, pipeline, documento técnico.**
+BLOQUEADOR só quando se encaixa em pelo menos um destes:
+(a) o código está errado: produz resultado incorreto, corrompe estado, perde dado;
+(b) quebra em entrada plausível: **nulo em campo que existe**, string vazia, zero, negativo, duplicado, fora de ordem, acento, volume 10x. ⚠️ **Nulo em campo que existe, campo ausente e origem sem nenhum registro são três casos diferentes** — checar separadamente, e o terceiro é o que sai plausível: job sem a pasta de origem gerou resultado vazio com `EXIT CODE: 0` e zero linha de stderr, indistinguível de um dia real sem movimento (caso real de auditoria);
+(b2) **data ou hora sem fuso declarado** onde o corte do dia decide o resultado — `date.today()`, `datetime.now()`, `new Date()` em job diário, recorte de período, agendamento ou nome de arquivo por data. Máquina em fuso diferente do negócio grava no dia errado e o dado sai plausível. **Ponto cego confirmado do painel:** num caso real (17/08/2026), duas lentes independentes acharam 3 bloqueadores numa cobaia e nenhuma das duas levantou o `date.today()`;
+(b3) **parâmetro que entra em caminho de arquivo sem validação** — `../` no nome do destino escreve fora da pasta e sobrescreve arquivo de terceiro;
+(c) segredo, credencial ou dado pessoal exposto no código, no log ou no traceback. Vale também para **credencial declarada no fonte com valor de placeholder**: o defeito é o padrão, não o conteúdo da string, porque é exatamente por ali que o valor verdadeiro entra depois. ⚠️ **Placeholder é BLOQUEADOR na lente, não na consolidação.** Medido em caso real (17/08/2026): o auditor reconheceu que o padrão era o defeito, escreveu isso no parecer, e mesmo assim classificou como IMPORTANTE — quem promoveu foi o consolidador. Gate que depende da consolidação para chegar na severidade certa falha quando a consolidação está apressada, e ninguém percebe, porque o veredito final sai igual. Ao encontrar `DB_PASSWORD = "troque_aqui"`, `api_key = "xxx"` ou equivalente, escreva BLOQUEADOR sem procurar atenuante: "é só exemplo", "é ambiente local", "está claramente marcado" e "o valor é falso" não rebaixam nenhum destes;
+(d) não é idempotente onde precisa ser: rodar duas vezes produz resultado diferente do de rodar uma;
+(e) falha em silêncio: engole exceção, retorna vazio sem erro, ou reporta sucesso sem ter feito;
+(f) o teste que existe passa mesmo com o defeito presente, ou não testa o que diz testar;
+(g) rota, endpoint ou tabela sem autenticação, ou com permissão mais ampla que a necessária;
+(h) erro de português em texto que outra pessoa lê;
+(i) **migration, carga ou DDL sem caminho de volta** — sem down-script, sem rollback, ou que não pode ser aplicada duas vezes. Está aqui, e não só dentro do painel de pipeline, porque a severidade tem que estar onde o auditor procura severidade: pendurada só no painel, ela dependia de quem lesse inferir pela regra do fim desta seção.
+
+**Se não se encaixa em nenhum item da lista aplicável: no máximo IMPORTANTE.**
+
+⚠️ **Três casos só aparecem RODANDO, e onde a peça tem origem de dados a execução é OBRIGATÓRIA, em qualquer lente:** nulo em campo que existe, campo ausente, e origem sem nenhum registro (pasta vazia, tabela vazia, arquivo que não está lá). O prefixo comum permite escrever "não validado, análise por leitura" — **nestes três isso não é neutro: é achado IMPORTANTE de cobertura, e vai no parecer com esse nome.** Está aqui nas âncoras, e não dentro de uma lente, porque valer só para uma lente foi o defeito. **Origem de dados é qualquer entrada externa ao processo** — arquivo, tabela, pasta, API, fila de mensagem, webhook, variável de ambiente, parâmetro de linha de comando, stdin. A definição é funcional de propósito: lista fechada convida a dizer "isso não é nenhum dos quatro, então não preciso rodar", e é por aí que a exigência se esvazia. Só não se aplica quando **não há entrada externa nenhuma** — peça 100% autocontida.
+
+**Gosto não é defeito.** "Enquadramento podia ser melhor", "podia ter mais da cor da marca", "texto podia ser maior", "eu teria estruturado diferente", "esse nome podia ser melhor", "faltou um comentário": sem violar os critérios acima, é POLIMENTO. Preferência de estilo que o linter do projeto não reclama é POLIMENTO.
+
+⚠️ **Contraste: o falso positivo mais comum do painel.** Amostrar pixel solto na borda da letra mede o **halo de anti-aliasing**, não o fundo, e devolve número catastrófico numa peça legível (caso real: dois auditores acusaram 2,17:1 e 3,60:1 onde a medição correta deu 6,2-8,5:1). Medir **núcleo da letra × anel de fundo imediato**: máscara do texto erodida, e como fundo o anel entre dilatação de 9px e de 3px — nunca o pixel colado no glifo. **Antes de reportar contraste como BLOQUEADOR, remedir.** Antes de mandar mexer no design por contraste, remedir de novo.
+
+**Nota ancorada:** 9-10 = sai já · 7-8 = sai depois dos polimentos · 5-6 = IMPORTANTE aberto · 4 ou menos = BLOQUEADOR aberto. O veredito binário decide; a nota só comunica.
+
+**Rodada 2 ou mais:** julgar APENAS (1) se os bloqueadores anteriores foram resolvidos, (2) defeitos NOVOS introduzidos pela correção que se enquadrem nos critérios acima e (3) defeito que já existia e **nunca foi avaliado por auditor nenhum** — nesse caso rotular no parecer como `achado tardio` **e provar a ausência, citando onde ela está**: "não consta em nenhum parecer anterior, o trecho X nunca foi mencionado". Rótulo sem essa citação não vale, porque ninguém consegue distinguir "ninguém olhou" de "olharam e deixaram passar", e é por essa fresta que promoção de severidade entra vestida de achado novo. É proibido endurecer critério entre rodadas, promover severidade de achado antigo, ou reabrir ponto já dado como resolvido. *(Exceção: reentrada por fonte, seção 6 — ela volta rotulada como rodada 1 e esta proibição não a alcança.)*
+
+⚠️ **Por que o item (3) existe, e por que ele não abre a porteira.** Sem ele, um defeito real que a rodada 1 deixou passar ficava sem ninguém com mandato para levantá-lo: não é bloqueador antigo sendo reconferido, não é defeito novo da correção, e a reentrada por fonte não socorre porque só vale para peça **já aprovada**. Auditor roda em modelo mais barato de propósito (regra 9), então deixar passar é esperado, não excepcional. O que continua barrado é o resto: **"eu agora acho que aquilo era pior" é promoção de severidade e segue proibido**, gosto segue POLIMENTO, e achado tardio só é BLOQUEADOR se se encaixar na lista aplicável. O que impede ciclo infinito é o teto da regra 6, não a mordaça do auditor: se a rodada 3 reprovar por achado tardio, escala e um humano decide.
+
+⚠️ **Padrão observado (caso real, 09/08/2026):** o auditor confirmou que o único BLOQUEADOR estava resolvido e mesmo assim deu REPROVADO, usando como motivo um achado **IMPORTANTE** ainda aberto. A crítica de mérito dele era boa; o veredito era indevido. **Auditor com achado editorial válido tende a usar o veredito para forçar a correção.** Ao consolidar: se zero bloqueador sobrou, o veredito é LIBERADO com o IMPORTANTE registrado, mesmo que a lente tenha escrito REPROVADO. Aplicar a correção quando ela for boa e barata, sem gastar rodada por isso.
+
+### ⭐ A lente que quase todo gate esquece: conflito entre correções
+
+Roda em quem produziu, ANTES de aplicar as correções de uma rodada — **não é subagente**. Existe porque **corrigir é editar, e editar é produzir**: o padrão observado desde 31/07/2026 é que a rodada 1 pega defeito de quem produziu e a rodada 2 pega defeito que a correção criou.
+
+Duas perguntas, as duas obrigatórias, porque a primeira sozinha não segura.
+
+1. **A correção de um achado desfaz a de outro?** Quando duas lentes puxam para lados opostos, atender as duas ao pé da letra é a armadilha: a segunda correção reintroduz o que a primeira tinha removido, e na reauditoria cada lente confirma só o próprio achado e ambas aprovam. Havendo conflito, escolha explicitamente qual princípio vence, escreva no parecer por quê, e registre o que foi sacrificado. Não tente satisfazer os dois.
+
+2. **Ao estreitar uma rede de segurança larga, o que ela cobria por acidente?** Vale para `except` genérico, validação ampla, permissão folgada, retry que engolia tudo, `try` em volta de bloco grande. Liste cada caso que a rede segurava sem ser o alvo da correção e confirme **para onde cada um vai agora**.
+
+⚠️ **As duas respostas vão ESCRITAS no parecer, antes de reauditar.** Sem isso, esta é a única checagem do gate que ninguém de fora consegue conferir — e a regra dura nº 1 diz justamente que quem produziu não audita o que produziu. O campo `lente ⭐:` do parecer (seção 6) é obrigatório em toda rodada que veio depois de uma correção; 2 a 4 linhas bastam, e "nenhuma rede foi estreitada" é resposta válida quando for verdade. **CADA auditor da reauditoria recebe esse texto como insumo e DEVE dizer, em uma linha, se concorda com ele ou o contesta** — cada lente responde por si, não vale uma consolidar pelas outras — não é faculdade dele, é item do parecer. É o que transforma a lente ⭐ de autodeclaração em algo auditável, e sem essa obrigação o campo vira carimbo que só quem escreveu leu. Peça de texto curto que nunca abriu rodada de correção não gera campo nenhum: a lente ⭐ só existe onde houve correção.
+
+⚠️ **A pergunta 1 pode estar respondida certa e o resultado ainda ser um bloqueador novo.** Aconteceu num caso real (17/08/2026): as três correções da rodada 1 atuavam em pontos diferentes e de fato não colidiam, e ainda assim estreitar o `except Exception` deixou o laço descoberto — JSON válido com topo não iterável passou a derrubar a função inteira e **perder junto os arquivos válidos já contados**. Antes, o mesmo input perdia só um arquivo, em silêncio, mas gravava o resto: a correção abriu defeito pior que o original. A pergunta 2 nasceu daí. É a família do padrão de sempre virada do avesso: não é "o documento pede a ação e não pede a verificação", é **a checagem existe, é feita, e faz a pergunta incompleta**.
+
+## 3. Fluxo (a ordem, ponta a ponta)
+
+1. **Identificar** a peça, o tipo (extensão/pasta: visual, documento, vídeo, relatório, código, pipeline, documento técnico) e a faixa.
+   ⚠️ **Os tipos não são exclusivos, e tratá-los como exclusivos apaga checagem em silêncio.** Peça que é código **e** pipeline (script que lê arquivo e grava em banco, serviço com migration junto) roda os **DOIS** painéis, nunca escolhe um: caminho de volta de migration, schema drift, chave duplicada, particionamento e custo/escala moram no painel PIPELINE DE DADOS e não aparecem em lugar nenhum se você classificar como "é um script". Rodar os dois custa mais, e esse custo está decidido: a lente que nunca rodou não entra aprovada. **Não repita a lente que já cobriu o mesmo conteúdo** — ★ ADVERSARIAL e ★ CORREÇÃO DO DADO olham coisas diferentes e rodam as duas; USUÁRIO-ZERO roda uma vez só.
+   ⚠️ **Peça de N arquivos continua sendo UMA peça.** Carrossel de 5 slides, componente com 3 arquivos, migration com up e down: os N caminhos vão juntos em `{PEÇA}`, numa rodada só por lente — é o que permite a lente enxergar a inconsistência ENTRE os arquivos. Isso **não** é o modo lote da seção 7, que é para peças **diferentes** auditadas no mesmo dia.
+2. **Reunir os insumos** (regra dura 2: quatro, mais a amostra de dados quando a peça tem origem de dados). Peça: o arquivo ou o diff. Contexto: briefing, issue, ticket, ou o que foi pedido. Convenções: brandkit/skill da marca, ou README, ADR, CONTRIBUTING, config do linter. Anterior: a peça mais recente do mesmo ciclo, o `git log`/`git diff` da versão anterior, ou o último parecer em `_auditoria/`. **Amostra:** quando a peça lê entrada externa, monte e entregue ao auditor um dado de teste que contenha nulo em campo que existe, um registro com campo ausente, e o caso vazio — quem monta é quem dispara o painel, não o auditor, e sem isso os três casos de execução obrigatória da seção 2 não acontecem. Insumo que faltar vira achado IMPORTANTE e o gate segue.
+3. **Preflight** (seção 4). Achado dele entra direto no parecer, sem gastar auditor.
+4. **Disparar o painel EM PARALELO**: uma única mensagem com N chamadas de subagente (`subagent_type: general-purpose`), cada uma com o prefixo comum mais a lente mais a lista de âncoras que vale mais os caminhos reais. **Some a lente CONVENÇÃO sempre que a peça entra num sistema que já existe** — ela é obrigatória nesse caso e é a que se esquece, porque não pertence a nenhum painel. Nunca em sequência quando dá para paralelizar, e nunca no próprio turno quando dá para isolar.
+5. **Consolidar**: remover achado duplicado, agrupar por severidade, decidir o veredito (zero BLOQUEADOR = LIBERADO).
+6. **Gravar** o parecer e a linha do ledger (seção 6). Se os hooks opcionais da seção 10 estiverem ativados, limpar o flag: `rm -f /tmp/gate-dirty-*`.
+7. Se REPROVADO, **nesta ordem**: (a) **planejar** as correções, sem escrever ainda; (b) **passar a lente ⭐** sobre o plano e escrevê-la no parecer; (c) **aplicar**; (d) **reauditar** só as lentes reprovadas, mandando o texto da ⭐ como insumo — teto de 2 ciclos (regra 6).
+   A ordem é esta e não outra: a lente ⭐ pergunta se uma correção desfaz a outra, e essa pergunta não tem resposta depois que as duas já estão no disco. Duas saídas, escritas para você não ficar num beco: **correção de fato verificável** (o preço errado, o andar do endereço) não gera campo ⭐ nenhum nem abre rodada 2 — é a seção 1 que manda, confere contra a fonte e libera; e **correção que mudou de forma enquanto era escrita** volta para a lente ⭐ sobre o que foi de fato aplicado, antes de reauditar.
+
+## 4. Preflight (roda antes do painel, é de graça)
+
+**Caminho padrão, sem depender de nada instalado.** Use o que o projeto já tem, na ordem, e pare no primeiro que falhar:
+
+1. **Typecheck / compilação:** `tsc --noEmit`, `mypy`, `cargo check`, o que o projeto usar.
+2. **Lint:** `ruff`, `eslint`, `black --check`, conforme o projeto.
+3. **Teste:** a suíte existente. ⚠️ **Se não existir suíte, registrar como achado IMPORTANTE ("peça sem teste automatizado") e seguir.** Isso tem que ser mecânico porque **ausência não aparece em lente nenhuma**: as lentes leem o que está escrito, e teste que não existe é justamente o que não está lá para ser lido. Caso real (11/08/2026): dois auditores independentes pegaram 6 de 6 defeitos plantados numa cobaia e os dois deixaram passar o "sem teste automatizado".
+4. **Segredo:** varredura por padrão de chave, token, senha e URL com credencial nos arquivos alterados — `git diff --name-only` diz quais são. Fora de repositório, varra todos os arquivos que você está entregando.
+5. **Diff limpo:** o que está sendo auditado é o que está no disco? `git status --porcelain` e `git diff --stat`: saída vazia é o que você quer. Se houver alteração não salva ou não commitada relevante, diga qual. Fora de repositório, confira data de modificação contra a hora da última edição.
+
+Nunca instalar ferramenta nova para o preflight. Se a toolchain não existir no projeto, registre e vá para o painel.
+
+**Opcional, para peça visual:** se houver Python com PIL na máquina, `python3 <pasta-desta-skill>/preflight.py <peça> [pasta-do-ciclo]` (no Windows o binário costuma ser `python` ou `py -3`) faz de graça o que a lente pagaria caro: hash da peça, dimensões, detecção de quase-clone por hash perceptual dentro do lote, e conferência dos assets. Ele é **opcional**: falhou, não existe, ou não há Python? Registra no parecer e segue direto para o painel — o caminho dos 5 passos acima continua valendo.
+
+⚠️ **Peça de N arquivos: rode uma vez por arquivo** (o segundo argumento é que recebe a pasta do ciclo). E **os arquivos da própria peça aparecem como `[SUSPEITA] QUASE-CLONE`, o que é esperado e não é achado**: slide-irmão de um carrossel bem-feito tem a mesma grade, a mesma paleta e o mesmo template de propósito. O item (f) da lista A é sobre peça **diferente** — as irmãs do lote e a que está no ar —, nunca sobre os pedaços da mesma peça. Confira a origem de cada suspeita antes de registrar qualquer coisa.
+
+## 5. Painéis (prompts inline, não dependem de agente nenhum)
+
+Prefixo comum a TODO auditor, preenchendo com os caminhos reais:
+
+> Você é auditor independente do gate. Você NÃO produziu esta peça e NÃO deve editá-la, só emitir parecer. Leia os insumos: peça {PEÇA}, contexto/briefing/requisito {CONTEXTO}, convenções {CONVENÇÕES: brandkit, ou README, ADR, CONTRIBUTING, config do linter}, versão/peça anterior {ANTERIOR} e, quando a peça lê entrada externa, a amostra de teste {AMOSTRA: dado com nulo em campo que existe, dado com campo ausente, e o caso vazio}. Se algum faltar, registre como IMPORTANTE e siga. Liste os 3 PIORES defeitos ANTES de qualquer veredito. Depois: achados classificados BLOQUEADOR/IMPORTANTE/POLIMENTO, cada um com evidência concreta e correção sugerida; veredito da sua lente (APROVADO/REPROVADO); nota 0-10. Sem elogio de cortesia — se estiver bom, diga curto e aprove. Se você testou alguma coisa de fato, diga o que rodou e o que saiu; se não testou, escreva "não validado, análise por leitura" em vez de afirmar que testou.
+
+Mandar junto **só a lista de âncoras que vale** para o tipo da peça (seção 2). Peça de N arquivos: os N caminhos vão juntos em `{PEÇA}`, uma rodada por lente (seção 3, passo 1).
+
+### DESIGN (arte, carrossel, story, LP visual) — âncoras lista A
+- ★ **MARCA**: paleta, tipografia, logo e textura assinatura contra o brandkit; reconhecimento em 1 segundo; quase-clone da peça anterior; tom visual (a marca do cliente, nunca a de quem produziu, em peça de cliente).
+- **TÉCNICA**: contraste WCAG dos textos sobre o fundo real (medir como manda a seção 2 — remedir antes de acusar); legibilidade em thumbnail (~160px); hierarquia (onde o olho pousa primeiro); emendas de foto e de gradiente; cheiro de template ou de IA. **Crop do grid**: numa peça 4:5 (1080×1350) o Instagram exibe 1:1 no perfil e corta **135px em cima e 135px embaixo** — logo, CTA e qualquer texto essencial têm que caber entre y135 e y1215. Elemento essencial fora dessa faixa é BLOQUEADOR por (g). **Safe zone de story** (1080×1920): a interface do aplicativo cobre cerca de **250px no topo e 250px na base** — nada essencial ali, e o CTA nunca no rodapé absoluto.
+- **BRIEF/VENDA**: a imagem entrega a promessa da copy? (vende a sala e não mostra a sala); a objeção nº 1 do público está tratada?; CTA único e coerente com o funil; preços e dados conferidos contra a fonte.
+
+### VÍDEO (reel, ad, story) — âncoras lista A
+- ★ **HOOK/ROTEIRO**: os 3 segundos iniciais seguram?; promessa contra o corte final; CTA; duração contra o canal.
+- **MARCA/TÉCNICA**: logo, legendas (sincronia e ortografia), proporção e formato, áudio; extrair frames com `ffmpeg -i <v> -vf fps=1/3` quando precisar ver.
+
+### RELATÓRIO (performance, financeiro) — âncoras lista A
+- ★ **DADOS**: números conferidos contra a fonte crua (export, API, planilha); as somas fecham; períodos corretos.
+- **CLAREZA**: quem lê entende sem tradução?; a decisão recomendada está explícita?; zero jargão vazio.
+
+### DOCUMENTO (PDF, proposta, contrato, apostila) — âncoras lista A
+- ★ **FATOS**: todo número, preço, nome, data e promessa conferido contra a fonte (contrato, sistema, memória do projeto).
+- **FORMA**: fundo e identidade corretos (do cliente, não de quem produziu); anti-vícios de IA (travessão, "não é X, é Y", negação dramática); ortografia; paginação (rodapé que vira página órfã).
+
+### DOCUMENTO TÉCNICO (README, ADR, runbook, relatório técnico) — âncoras lista B
+- ★ **FATOS**: todo comando, caminho, versão, número e afirmação técnica conferido contra a realidade. Comando que não existe mais, flag renomeada, caminho que mudou.
+- **FORMA**: quem vai ler consegue executar sem perguntar nada? Ortografia. E a regra que vale para todo runbook: **onde o documento PEDE, ele deveria VERIFICAR**. Instrução que depende de a pessoa lembrar é instrução que falha; procure toda instrução que poderia virar checagem.
+
+### CÓDIGO / SISTEMA (site, app, script, serviço, API, CLI, automação, infraestrutura como código) — âncoras lista B
+- ★ **ADVERSARIAL**: o que quebra. Bugs, estado inconsistente, **segredo exposto no código — inclusive com valor de placeholder, que é BLOQUEADOR pelo item (c) e não IMPORTANTE**, input malicioso, permissão furada, exceção engolida, retry que duplica efeito. **Edge case, um por um, sem agrupar em "edge cases"**: nulo em campo que existe, string vazia, zero, negativo, duplicado, acento e emoji, texto longo demais, lista vazia, concorrência, **data/hora sem fuso** (item b2), **parâmetro em caminho de arquivo sem validação** (item b3), e o mesmo request duas vezes. Testar cada um contra o código, não citar a lista. Em Terraform e config de infra: recurso que o `apply` destrói e recria em vez de alterar, permissão mais ampla do que a necessária, e estado que não é o que o código diz.
+  ⚠️ Os **três casos de execução obrigatória** das âncoras (nulo em campo que existe, campo ausente, origem sem nenhum registro) valem aqui inteiros. Foi exatamente um deles que passou por duas lentes lendo código e só apareceu quando alguém rodou em pasta vazia e viu código de saída zero com stderr vazio.
+- **USUÁRIO-ZERO**: percorrer o fluxo real de ponta a ponta, rodando ou abrindo de verdade quando possível, e reportar onde trava, engana ou confunde quem não escreveu aquilo.
+
+### PIPELINE DE DADOS (DAG, job, transformação, migration) — âncoras lista B
+- ★ **CORREÇÃO DO DADO**: idempotência (rodar duas vezes dá o mesmo resultado?); reprocessamento de janela passada; schema drift e campo novo ou removido na origem; **nulo em campo que existe** — e são três casos distintos, não um: campo ausente é schema drift, origem sem linhas é origem vazia, e este terceiro é o campo presente com valor NULL, que quebra `float()`, `.isoformat()` e todo acesso que presume valor; chave duplicada; registro que chega atrasado; fuso horário e data de corte; particionamento; o que acontece quando a origem vem vazia — **os três são de execução obrigatória pelas âncoras da seção 2, e aqui mais do que em qualquer lugar: job que bate em tabela ou pasta vazia é o cenário mais comum de pipeline, e é justamente o que passa em leitura**; **migration sem caminho de volta** (sem down-script, sem rollback, ou que não pode ser aplicada duas vezes).
+- **CUSTO E ESCALA**: full scan onde daria para particionar; shuffle desnecessário; o que explode quando o volume dobra; job sem timeout e sem limite; leitura repetida do mesmo dado.
+
+### CONVENÇÃO (lente extra, obrigatória quando a peça entra num sistema que já existe)
+- **CONVENÇÃO**: a peça segue o padrão que o projeto já estabeleceu (nomenclatura, estrutura de pasta, formato de log, tratamento de erro, índice, link, grade visual)? Peça correta que ignora a convenção do sistema é regressão silenciosa: funciona sozinha e apodrece o conjunto.
+
+## 6. Parecer
+
+Salvar em `<pasta-da-peça>/_auditoria/AAAA-MM-DD-gate-<slug>.md`. Rodadas seguintes acrescentam no mesmo arquivo.
+
+```
+# GATE — <peça> — AAAA-MM-DD — Rodada 1 — faixa VAI SAIR
+sha256: <o hash da peça, gerado DEPOIS da última correção. macOS/Linux: shasum -a 256 arquivo · Windows: Get-FileHash -Algorithm SHA256 arquivo>
+fonte: <âncora do que a peça descreve — git rev-parse --short HEAD, data do export, versão do schema, versão do brandkit, contrato consultado. "N/A — autocontida" só se a peça não referenciar repositório, dataset, config, preço ou versão de terceiro. Na dúvida, não é autocontida. Peça sem controle de versão que lê pasta ou banco externo NÃO é autocontida: ancore no que ela toca — "pasta /dados/entrada em AAAA-MM-DD, schema da tabela X versão N" — e registre a ausência de VCS como achado IMPORTANTE de convenção>
+Preflight: <código: typecheck ok · lint 2 avisos · teste 1 falha  |  visual: 1080x1350 ok · 1,2 MB · quase-clone dist 14/64 vs slide-2>
+Painel: adversarial ✗ · usuário-zero ✓ — VEREDITO: REPROVADO · nota 3/10
+mudança de faixa: <só quando houve. de LOCAL → VAI SAIR (ou o contrário), motivo, data. Subiu: rodada 1 nova e contador zerado. Desceu: contador segue, escalada pendente segue, e o painel é o da faixa mais rigorosa>
+lente ⭐: <obrigatório da rodada 2 em diante. (1) alguma correção desfaz outra? qual princípio venceu e o que foi sacrificado. (2) que rede de segurança larga foi estreitada, o que ela cobria por acidente, e para onde cada caso vai agora. "Nenhuma rede estreitada" é resposta válida quando for verdade>
+lente ⭐ — resposta de cada auditor: <obrigatório na mesma rodada em que o campo acima existe, UMA LINHA POR LENTE, com o nome da lente: concorda ou contesta o texto acima, e por quê. Sem este bloco preenchido lente a lente, a rodada não fecha: é o que tira a ⭐ da autodeclaração. Não vale uma lente responder pelas outras>
+
+| Sev | Lente | Achado | Evidência | Correção |
+|-----|-------|--------|-----------|----------|
+
+PRÓXIMA AÇÃO: <corrigir X e reauditar a lente Y, ou LIBERADO>
+```
+
+Ledger central em `~/.claude/gate/ledger.csv`, criando com cabeçalho se não existir. Colunas:
+`data,peca,tipo,faixa,rodada,bloqueadores,importantes,veredito,bypass`
+
+Criar-se-não-existe e acrescentar, idempotente (rodar duas vezes não duplica o cabeçalho):
+
+```bash
+# macOS / Linux
+L=~/.claude/gate/ledger.csv; mkdir -p "$(dirname "$L")"
+[ -s "$L" ] || echo 'data,peca,tipo,faixa,rodada,bloqueadores,importantes,veredito,bypass' > "$L"
+echo '2026-01-31,minha-peca,codigo,VAI SAIR,1,0,2,LIBERADO,nao' >> "$L"
+```
+
+```powershell
+# Windows (PowerShell). Em cmd.exe o "~" não expande: use %USERPROFILE%\.claude\gate\ledger.csv
+$L = "$env:USERPROFILE\.claude\gate\ledger.csv"
+New-Item -ItemType Directory -Force -Path (Split-Path $L) | Out-Null
+if (-not (Test-Path $L)) { 'data,peca,tipo,faixa,rodada,bloqueadores,importantes,veredito,bypass' | Set-Content $L }
+Add-Content $L '2026-01-31,minha-peca,codigo,VAI SAIR,1,0,2,LIBERADO,nao'
+```
+
+**O ledger não tem coluna para a lente ⭐, e isso é decisão, não esquecimento.** Acrescentar coluna quebraria a leitura das linhas antigas, e o ganho seria só consulta agregada ("em quantos ciclos houve conflito de correção"). Consequência assumida: essa pergunta só se responde varrendo os pareceres, um por um. Se um dia o volume justificar, a mudança é coluna nova com valor vazio nas linhas velhas — e aí o schema muda de uma vez, documentado aqui.
+
+**O hash sai no fim, nunca no meio.** Gerar antes da última correção registra uma versão que não é a que saiu, e aí o re-gate acusa retoque que não houve e ninguém consegue provar qual versão foi usada.
+
+**Re-gate por hash:** antes de usar ou enviar uma peça já aprovada, confira o hash contra o do parecer. Mudou significa que a peça foi retocada, e ela reentra no gate.
+
+**Re-gate pela fonte** (o hash não cobre isto): confira também a **fonte** atual contra a do parecer. O hash prova que a **peça** não mudou; não prova que o **mundo que ela descreve** continua igual. Um diagnóstico aprovado sobre um repositório que andou 8 commits tem hash idêntico e fatos vencidos, inclusive quando um dos commits implementou uma fatia do próprio documento. Peça igual + fonte diferente não reprova sozinho, mas obriga a reconferir os fatos antes de usar, e a lente ★ FATOS reentra.
+
+⚠️ **Isto não é "reabrir ponto resolvido" e não conta para o teto de 2 ciclos.** A proibição da regra de rodada 2+ vale dentro do ciclo corrige-e-reaudita: lá o achado é o mesmo e mudaria só o critério. Aqui o achado é novo, porque o mundo mudou depois do parecer. Reverificação de fato ≠ reabertura de achado, e o auditor da reentrada recebe a peça como rodada 1.
+
+⛔ **E só vale para peça APROVADA.** Peça que está no meio do ciclo, ou que reprovou na rodada 3 e está esperando escalar, **não** pode ser rotulada como reentrada para zerar o contador. Está escrito na negativa de propósito: sob prazo, essa é a saída mais tentadora do documento inteiro.
+
+**Como rotular, e isso não é detalhe:** no cabeçalho do parecer e no ledger, escreva `Rodada 1 (reentrada por fonte, AAAA-MM-DD)`. O parecer continua no mesmo arquivo, então a tentação é numerar em sequência ("Rodada 3") — e aí a regra de rodada 2+ volta a valer sobre o auditor, que é exatamente o que este parágrafo existe para impedir.
+
+⚠️ **É em documento que isso dói.** Código e pipeline avisam sozinhos: se o mundo muda, o teste quebra e alguém percebe. Documento envelhece em silêncio — nada quebra, nada avisa, e a próxima pessoa executa em cima de uma descrição que já não vale.
+
+**Calibração:** se quase tudo passa de primeira nas últimas 10 peças, ou se mais de 20% dos achados são descartados, a rubrica está frouxa ou chata demais. Diga, e ela é recalibrada.
+
+## 7. Modo lote / ciclo
+
+`gate ciclo <pasta>` ou `gate lote <pasta ou lista de arquivos>` — auditar um conjunto de uma vez:
+1. Cada peça roda seu painel normal, em ondas de no máximo 8 auditores simultâneos.
+2. Mais uma lente **CONJUNTO** (um subagente que recebe TODAS as peças) procurando o que só aparece no agregado: quase-clone entre peças, deriva de identidade dentro do ciclo, duplicação entre arquivos, inconsistência de padrão dentro do lote, a mesma correção aplicada de jeitos diferentes em lugares diferentes, buracos contra o calendário ou o escopo planejado, repetição de ângulo.
+3. Parecer consolidado do ciclo em `<pasta>/_auditoria/`.
+
+## 8. Válvula de escape
+
+"libera sem gate", e só o dono da peça pode dizer isso: grava parecer de uma linha (`LIBERADO SEM GATE por ordem do dono — <motivo, se houver>`), grava a linha no ledger com `bypass=sim`, e — **se os hooks opcionais da seção 10 estiverem ativados** — limpa o flag com `rm -f /tmp/gate-dirty-*`, igual ao passo 6 da seção 3. Depois segue. Sem discussão, com rastro.
+
+⚠️ **A limpeza no bypass não é detalhe:** sem ela, quem ativou o hook e usa a válvula fica com a sessão marcada como suja para sempre, o encerramento continua bloqueado, e a saída que a pessoa vai achar é desativar o hook — ou seja, a válvula de escape do gate viraria a porta de saída do enforcement inteiro.
+
+## 9. Degradações (nunca abortar por falta de peça)
+
+- **Sem subagente disponível:** rodar as lentes em sequência no próprio turno. O gate degradado é melhor que gate nenhum, e por isso esta degradação continua permitida — mas **ela quebra a regra dura nº 1 para o painel inteiro**, não só para a lente ⭐: quem produziu passa a auditar o que produziu, e audita a intenção em vez do resultado. Então **é obrigatório declarar isso no parecer**, na linha `isolamento: comprometido — sem subagente, painel rodou no turno de quem produziu`. Sem essa linha, um parecer feito sem auditor nenhum fica indistinguível de um feito com auditor de verdade, e é o parecer que serve de prova depois. Achado que sobreviver a um painel degradado vale menos, e quem ler precisa saber disso.
+- **Toolchain do projeto inexistente, ou `preflight.py` falhando** (sem Python, sem PIL): registrar no parecer e ir direto para o painel.
+- **Sem brandkit, briefing, README ou convenção escrita:** regra dura 2 — registra como IMPORTANTE, não trava, e audita a peça isolada.
+
+## 10. Garantia dura, OPCIONAL (hooks)
+
+**Enforcement honesto, em uma frase:** o único bloqueio real deste gate é o hook — e ele **não vem ativado**. Todo o resto deste documento é instrução de prompt, ou seja, **depende de você lembrar de rodar o gate.** Pela régua deste próprio documento, isso é o defeito que a lente DOCUMENTO TÉCNICO manda procurar: instrução que depende de lembrar.
+
+Os dois scripts **viajam junto com esta skill**, inertes, na pasta `hooks/` ao lado deste arquivo — depois de instalada, `~/.claude/skills/gate/hooks/`:
+
+| Arquivo | Evento | O que faz |
+|---|---|---|
+| `gate-dirty.sh` | `PostToolUse` em `Write` ou `Edit` | marca a sessão como suja ao escrever entregável (`touch /tmp/gate-dirty-<sessão>`). Cobre mídia e documento (`.png .jpg .jpeg .webp .svg .pdf .html .htm .mp4 .mov`) **e** código, pipeline e documento técnico (`.py .js .jsx .ts .tsx .sql .yaml .yml .json .sh .md`). Ignora parecer, config, scratchpad, memória, diário, `node_modules`, `.git` e pastas de build — a lista de exclusão roda ANTES da de extensão, senão `.md` de memória dispararia o tempo todo e o hook acabaria desativado |
+| `gate-stop.sh` | `Stop` | barra o encerramento **uma** vez se a sessão está suja e sem parecer; anti-loop por `stop_hook_active` |
+
+O flag é removido ao fechar o parecer (passo 6 da seção 3) ou no bypass (seção 8).
+
+⚠️ **Os dois dependem de `python3` para ler o JSON do evento, e falham ABERTO de propósito:** sem Python, as variáveis saem vazias e o script sai por `exit 0` — o gate perde o enforcement, e nunca o contrário, que travaria o encerramento de toda sessão sem saída. Verifique você mesmo antes de confiar: `bash -n` nos dois, e um evento de mentira por `stdin`.
+
+**Ativação — acréscimo ao `settings.json`, nunca substituição.** O arquivo é seu e provavelmente já tem hooks de outras coisas. São dois casos, e o errado apaga configuração em silêncio:
+
+- **Se `~/.claude/settings.json` NÃO tem bloco `hooks`:** cole o bloco inteiro abaixo como uma chave nova do objeto raiz.
+- **Se JÁ tem:** não cole a chave `hooks` nem substitua o array `PostToolUse` inteiro. **acrescente aos arrays que já estão lá**, preservando o que existe — é este objeto que entra em `PostToolUse`:
+
+  ```json
+  {"matcher": "Write|Edit", "hooks": [{"type": "command", "command": "bash ~/.claude/skills/gate/hooks/gate-dirty.sh"}]}
+  ```
+
+  e este em `Stop` (criando o array só se ele ainda não existir):
+
+  ```json
+  {"hooks": [{"type": "command", "command": "bash ~/.claude/skills/gate/hooks/gate-stop.sh"}]}
+  ```
+
+```json
+"hooks": {
+  "PostToolUse": [{"matcher": "Write|Edit", "hooks": [{"type": "command", "command": "bash ~/.claude/skills/gate/hooks/gate-dirty.sh"}]}],
+  "Stop": [{"hooks": [{"type": "command", "command": "bash ~/.claude/skills/gate/hooks/gate-stop.sh"}]}]
+}
+```
+
+⚠️ **Ativar SÓ depois de testar em sessão descartável**, porque hook mal configurado trava o encerramento de TODA sessão. Antes de editar, copie o `settings.json`. O teste passou quando os **quatro** acontecerem, nesta ordem: (1) numa sessão nova, escrever um arquivo de entregável cria `/tmp/gate-dirty-*`; (2) tentar encerrar sem parecer é bloqueado UMA vez, com mensagem legível; (3) fechar um parecer, ou dar bypass, apaga o flag e o encerramento passa; (4) **os hooks que já existiam antes continuam disparando** — rode uma ação que acione cada um deles e confirme. O passo 4 existe porque os três primeiros passam mesmo que o merge tenha apagado a configuração anterior, e essa perda acontece fora da sessão descartável. Falhou qualquer um dos quatro: restaure a cópia do `settings.json` antes de fechar a sessão.
+
+⛔ **Eles não rodam em Windows corporativo com política gerenciada**, porque dependem de shell script — nessa máquina o gate segue dependendo da memória de quem opera, e essa é a consequência honesta.
+
+**Mitigação sem hook:** amarrar o gate a um momento que já existe no seu fluxo, em vez de a uma lembrança. Antes de apresentar como pronto, ou antes de abrir PR, são os candidatos naturais, porque já são paradas conscientes. Se valer o enforcement duro e portável, o caminho é um hook de `pre-commit` do próprio git, que não depende do shell da máquina.
+
+## 11. Fase 2 (não fazer sem o dono pedir)
+
+- **Kit de primeira rodada:** arquivo de colagem com esta skill embutida + uma peça de exemplo propositalmente defeituosa + o resultado esperado ("deve sair REPROVADO com 2 bloqueadores"), para quem instala VER o gate funcionar em vez de ler que ele funciona.
+- **Plugin com os hooks já montados**, só como caminho avançado para quem usa git — nunca como o caminho padrão de instalação.
+- **Dashboard do ledger**, no painel interno de quem opera: aprovação de primeira, ciclos por peça, bloqueadores por tipo.

package/skills/gate/hooks/gate-dirty.sh

@@ -0,0 +1,40 @@
+#!/bin/bash
+# Gate — PostToolUse (Write|Edit): marca a sessao como "suja" quando um entregavel e escrito.
+# OPCIONAL: nao faz nada ate voce registra-lo no settings.json (secao 10 da SKILL.md).
+# Silencioso. O flag e limpo pela skill gate ao fechar o parecer (ou no "libera sem gate").
+# Sem python3 na maquina, as variaveis saem vazias e o script sai por exit 0: falha ABERTA.
+INPUT=$(cat)
+FP=$(printf '%s' "$INPUT" | python3 -c 'import sys,json; d=json.load(sys.stdin); print((d.get("tool_input") or {}).get("file_path",""))' 2>/dev/null)
+SID=$(printf '%s' "$INPUT" | python3 -c 'import sys,json; print(json.load(sys.stdin).get("session_id",""))' 2>/dev/null)
+[ -z "$FP" ] && exit 0
+[ -z "$SID" ] && exit 0
+
+# O session_id vem de fora e entra num caminho de arquivo. Sem esta guarda, um
+# valor como "sub/../fora/PWNED" escreve fora do namespace /tmp/gate-dirty-*
+# (path traversal confirmado por execucao no gate de 22/08/2026). E o item (b3)
+# das ancoras da propria skill: parametro em caminho de arquivo sem validacao.
+# Valor invalido sai por exit 0 e NAO marca: falha ABERTA, igual ao resto.
+case "$SID" in
+  *[!A-Za-z0-9_-]*) exit 0 ;;
+esac
+
+# nunca marcar: parecer, config, scratchpad, memoria, diario, dependencia, build
+# (a exclusao vem ANTES da lista de extensoes de proposito: .md de memoria e de
+#  diario sao o ruido que faria o hook disparar o tempo todo e ser desativado)
+case "$FP" in
+  *_auditoria*|*/.claude/*|*scratchpad*|*/memory/*|*/memoria/*|*historico.md|\
+  */node_modules/*|*/.git/*|*/dist/*|*/build/*|*/.next/*|*/venv/*|*/__pycache__/*)
+    exit 0 ;;
+esac
+
+# extensoes de entregavel — cobrem os tipos que o painel da skill audita:
+# peca visual e midia, documento, codigo, pipeline e documento tecnico
+case "$FP" in
+  *.png|*.jpg|*.jpeg|*.webp|*.svg|*.pdf|*.html|*.htm|*.mp4|*.mov|\
+  *.py|*.js|*.jsx|*.ts|*.tsx|*.sql|*.yaml|*.yml|*.json|*.sh|*.md)
+    # o destino nao pode ser symlink: com um session_id valido, um link
+    # pre-criado faria o touch seguir pra fora do namespace (TOCTOU).
+    [ -L "/tmp/gate-dirty-$SID" ] && exit 0
+    touch "/tmp/gate-dirty-$SID" ;;
+esac
+exit 0

package/skills/gate/hooks/gate-stop.sh

@@ -0,0 +1,31 @@
+#!/bin/bash
+# Gate — Stop: bloqueia o encerramento UMA vez se a sessao tocou entregavel sem auditar.
+# OPCIONAL: nao faz nada ate voce registra-lo no settings.json (secao 10 da SKILL.md).
+# Anti-loop: com stop_hook_active=true (ja estamos num bloqueio), libera sempre.
+# Sem python3 na maquina, as variaveis saem vazias e o script sai por exit 0: falha ABERTA
+# (o gate deixa de bloquear; nunca o contrario, que travaria o encerramento pra sempre).
+INPUT=$(cat)
+ACTIVE=$(printf '%s' "$INPUT" | python3 -c 'import sys,json; print(str(json.load(sys.stdin).get("stop_hook_active", False)).lower())' 2>/dev/null)
+SID=$(printf '%s' "$INPUT" | python3 -c 'import sys,json; print(json.load(sys.stdin).get("session_id",""))' 2>/dev/null)
+
+[ "$ACTIVE" = "true" ] && exit 0
+[ -z "$SID" ] && exit 0
+
+# O session_id vem de fora e entra num caminho de arquivo. Sem esta guarda, um
+# valor como "sub/../fora/PWNED" escreve fora do namespace /tmp/gate-dirty-*
+# (path traversal confirmado por execucao no gate de 22/08/2026). E o item (b3)
+# das ancoras da propria skill: parametro em caminho de arquivo sem validacao.
+# Valor invalido sai por exit 0 e NAO marca: falha ABERTA, igual ao resto.
+case "$SID" in
+  *[!A-Za-z0-9_-]*) exit 0 ;;
+esac
+
+# mesma guarda do gate-dirty: link no lugar do flag nao vale como flag.
+[ -L "/tmp/gate-dirty-$SID" ] && exit 0
+if [ -f "/tmp/gate-dirty-$SID" ]; then
+  cat <<'JSON'
+{"decision":"block","reason":"Gate: entregavel criado ou alterado nesta sessao sem auditoria. Rode a skill gate na peca (fechar o parecer remove o flag) ou, se o dono mandou 'libera sem gate', registre o bypass no ledger e remova /tmp/gate-dirty-<session_id>."}
+JSON
+  exit 0
+fi
+exit 0

package/skills/gate/preflight.py

@@ -0,0 +1,132 @@
+#!/usr/bin/env python3
+"""Gate — preflight determinístico OPCIONAL (roda ANTES do painel de auditores).
+
+OPCIONAL de propósito: exige Python 3 e, para imagem, Pillow. Se não existir,
+falhar ou não houver Python na máquina, registre no parecer e siga direto para o
+painel — o caminho em texto da seção 4 da SKILL.md continua valendo sozinho.
+
+Uso: python3 preflight.py <peça> [pasta-do-ciclo]
+
+Checa de graça o que não precisa de LLM:
+- sha256 da peça (vai no parecer)
+- imagem: dimensões vs formatos padrão de feed, modo de cor, peso
+- quase-clone: hash perceptual (aHash) contra as outras imagens do ciclo
+- html: assets locais referenciados que não existem
+- pdf: peso
+
+Saída: linhas [OK] / [AVISO] / [SUSPEITA] / [ERRO] pra colar no parecer.
+"""
+import sys, os, glob, hashlib, re, warnings
+
+warnings.filterwarnings("ignore")
+
+FEED_SIZES = {(1080, 1350), (1080, 1920), (1080, 1080), (1920, 1080), (1200, 630)}
+IMG_EXTS = (".png", ".jpg", ".jpeg", ".webp")
+
+
+def sha256(path):
+    h = hashlib.sha256()
+    with open(path, "rb") as f:
+        for chunk in iter(lambda: f.read(1 << 20), b""):
+            h.update(chunk)
+    return h.hexdigest()
+
+
+def ahash(im, size=8):
+    im = im.convert("L").resize((size, size))
+    px = list(im.getdata())
+    avg = sum(px) / len(px)
+    return "".join("1" if p > avg else "0" for p in px)
+
+
+def hamming(a, b):
+    return sum(x != y for x, y in zip(a, b))
+
+
+def check_image(path, ciclo_dir, out):
+    try:
+        from PIL import Image
+    except ImportError:
+        out.append("[AVISO] PIL/Pillow ausente — checks de imagem pulados (painel cobre)")
+        return
+    im = Image.open(path)
+    w, h = im.size
+    if (w, h) in FEED_SIZES:
+        out.append(f"[OK] dimensões {w}x{h} (formato padrão)")
+    else:
+        out.append(f"[AVISO] dimensões {w}x{h} fora dos formatos padrão de feed {sorted(FEED_SIZES)}")
+    if im.mode == "CMYK":
+        out.append("[AVISO] modo CMYK — Instagram/web espera RGB")
+    mb = os.path.getsize(path) / 1e6
+    out.append(f"[OK] peso {mb:.1f} MB" if mb < 8 else f"[AVISO] peso {mb:.1f} MB (>8MB, Instagram pode recomprimir feio)")
+
+    # quase-clone contra as outras imagens do ciclo
+    if ciclo_dir and os.path.isdir(ciclo_dir):
+        mine = ahash(im)
+        alvo = os.path.realpath(path)
+        for other in sorted(glob.glob(os.path.join(ciclo_dir, "**", "*.*"), recursive=True)):
+            if not other.lower().endswith(IMG_EXTS):
+                continue
+            if os.path.realpath(other) == alvo or "_auditoria" in other:
+                continue
+            try:
+                d = hamming(mine, ahash(Image.open(other)))
+            except Exception:
+                continue
+            if d <= 6:
+                out.append(f"[SUSPEITA] QUASE-CLONE FORTE (dist {d}/64) vs {other}")
+            elif d <= 12:
+                out.append(f"[SUSPEITA] composição muito parecida (dist {d}/64) vs {other}")
+
+
+def check_html(path, out):
+    html = open(path, encoding="utf-8", errors="ignore").read()
+    base = os.path.dirname(os.path.abspath(path))
+    faltando = []
+    for ref in re.findall(r'(?:src|href)=["\']([^"\']+)["\']', html):
+        if ref.startswith(("http", "//", "#", "data:", "mailto:", "tel:")):
+            continue
+        if not os.path.exists(os.path.join(base, ref.split("?")[0])):
+            faltando.append(ref)
+    if faltando:
+        out.append(f"[AVISO] assets locais inexistentes: {faltando[:10]}")
+    else:
+        out.append("[OK] todos os assets locais existem")
+
+
+def main():
+    if len(sys.argv) < 2:
+        print("uso: preflight.py <peça> [pasta-do-ciclo]")
+        sys.exit(1)
+    path = sys.argv[1]
+    ciclo = sys.argv[2] if len(sys.argv) > 2 else os.path.dirname(os.path.abspath(path))
+    out = []
+    if not os.path.exists(path):
+        print(f"[ERRO] peça não existe: {path}")
+        sys.exit(1)
+    # Uma PASTA é a leitura mais natural de "a peça" para quem tem um carrossel,
+    # e era a que quebrava com traceback cru. Sai com mensagem legível e exit 1:
+    # trocar traceback por texto NÃO pode virar trocar falha por silêncio.
+    if os.path.isdir(path):
+        print(f"[ERRO] a peça é uma pasta: {path} — rode uma vez por arquivo "
+              f"(o segundo argumento é que recebe a pasta do ciclo)")
+        sys.exit(1)
+    ext = os.path.splitext(path)[1].lower()
+    try:
+        out.append(f"sha256: {sha256(path)}")
+        if ext in IMG_EXTS:
+            check_image(path, ciclo, out)
+        elif ext in (".html", ".htm"):
+            check_html(path, out)
+        elif ext == ".pdf":
+            mb = os.path.getsize(path) / 1e6
+            out.append(f"[OK] PDF {mb:.1f} MB" if mb < 15 else f"[AVISO] PDF {mb:.1f} MB (pesado pra WhatsApp/email)")
+        else:
+            out.append(f"[OK] extensão {ext}: sem checks mecânicos, direto pro painel")
+    except Exception as e:
+        out.append(f"[ERRO] preflight falhou ({e}) — seguir pro painel mesmo assim")
+    print("\n".join(out))
+
+
+if __name__ == "__main__":
+    main()

package/skills/lp-cinematico/SKILL.md

@@ -1,3 +1,8 @@
+---
+name: lp-cinematico
+description: Gera landing page cinematográfica premium (Vite + React + TypeScript + Tailwind v4), com vídeo em scroll-scrub no hero, efeito liquid-glass e seções editoriais. Use quando o usuário pedir landing page, LP, site de produto, página de vendas, site institucional de alto padrão visual, ou falar em scroll-scrub, parallax de vídeo ou página estilo Apple e Stripe.
+---
+
 # MEGA-PROMPT TEMPLATE — One-Shot Cinematic Landing Page (Video Scroll-Scrub)
 
 > Fill every `{{PLACEHOLDER}}` below, then paste the whole document into your generating model (Lovable, v0, Cursor, Claude, etc.) as a SINGLE prompt. Do NOT split it. The model must produce a working Vite app in one shot.

package/skills/roteiro-video/SKILL.md

@@ -1,3 +1,8 @@
+---
+name: roteiro-video
+description: Escreve roteiro de vídeo curto (Reels, TikTok, Shorts) e longo (YouTube) com estrutura de retenção e conversão: gancho, corpo e CTA. Use quando o usuário pedir roteiro de vídeo, script de Reels, ideia de Shorts, gancho de abertura, estrutura de um vídeo, o que falar na câmera, roteiro de YouTube ou roteiro para gravar em campo.
+---
+
 # Skill: Roteiro de Vídeo — Iron Edge
 
 > Gera roteiros de vídeo curto (Reels, TikTok, YouTube Shorts) e vídeo longo (YouTube) com estrutura comprovada de retenção e conversão.