stripe-youtube

O que stripe-youtube faz?

A edição Stripe da skill de formato longo do Adnaan (adnaan-youtube): a mesma pipeline e o sistema de design v7 no board 16:9, com todas as cores extraídas de um único arquivo de marca. A marca padrão é Stripe (brand/stripe.json, escrita a partir da página de marca pública da Stripe: blurple #533AFD como destaque, slate #061B31 para discos e tinta, papel cool #EEF1F6, cartões brancos, strawberry apenas para dados). Outra empresa = outro arquivo de marca ($Y/brand.py init --edit-dir edit --brand acme.json); nada mais muda. Antes de tudo, veja assets/style/stripe_youtube_sheet.jpg (frames reais do primeiro vídeo feito com ela) e dê uma olhada em examples/stripe-v1/ (sua tabela de beats e cenas) e examples/yt-01-v7/. A direção de arte é vinculativa e está em references/style.md; capítulos, janelas e cadência estão em references/planning.md; a descrição está em references/description.md. (O visual mais antigo de marcador Greg Claro/Escuro é mantido apenas sob solicitação.)

Como a marca entra: edit/brand/brand.json → $Y/brand.py escreve brand.css (ele redireciona os tokens do runtime) → board.py o vincula após v7yt.css em cada cena que prepara, e talkcaps.py faz o mesmo para as sobreposições de legendas; o runtime (V.mintTo / V.charcoalTo) também lê os tokens, e as placas do compose seguem o arquivo. Cenas nunca digitam um hexadecimal. Logos que o arquivo de marca nomeia são obtidos do kit oficial para edit/logos/ (nunca redesenhados).

Esta skill é a irmã de formato longo de adnaan-reel e reutiliza seus helpers (transcrição, corte, verificação, capturas de página, buscadores de logo/foto/ícone, a pipeline de render/loudness, o kit SFX, pose da cabeça). Ela deve ser instalada em ~/.claude/skills/adnaan-reel. Execute cada helper com o ambiente desse projeto: uv run --project ~/.claude/skills/adnaan-reel python <helper> … — R=~/.claude/skills/adnaan-reel/helpers, Y=~/.claude/skills/stripe-youtube/helpers abaixo.

Como o formato longo é construído (por que difere dos reels)

Um reel transforma cada batida em uma cena HyperFrames completa. Um vídeo longo não pode (horas de renderização e cansativo de assistir). Aqui:

1. O corte ($R/render.py --base-only) → base.mp4: a câmera dele, cortada, 1920x1080, com a voz (construída em uma passagem com precisão de amostra — veja Anti-padrões, deriva de sincronia labial), então $Y/lookdowns.py segura um quadro sobre olhares para baixo.
2. Momentos desenhados são cenas HyperFrames ($Y/board.py): tela, mapa, board, prova (opaco, 3–10 s) e sobreposições de callout — tipicamente 25–45 por vídeo, construídas em paralelo por agentes. Legendas de fala são sobreposições geradas ($Y/talkcaps.py), uma por janela de fala em tela cheia.
3. Todo o resto é composto ($Y/compose.py): fala = base em tela cheia + legendas; tela = placa do board + gravação de tela dele (cortada com os mesmos intervalos, ampliada por $Y/zoomplan.py) + o cartão do apresentador; janelas de cena = a renderização + o cartão; sobreposições por cima; SFX + a trilha musical nivelada; −14 LUFS. ~40 s de composição por minuto de vídeo.

Princípios

1. O board é a base, ele está no cartão. ~70–85 % do tempo de execução é um layout de board com a câmera simples dele no cartão (ponto fixo, move-se apenas em um corte, anel de destaque); fala em tela cheia é a pontuação (introdução, opiniões, histórias, CTA). Sem matte por padrão — ele gosta do cartão simples.
2. Um visual, um arquivo de marca. Papel + grade + vinheta forte, a cor primária da marca como o ÚNICO destaque (Stripe blurple), sua cor escura para discos com glifos Phosphor brancos e tinta (Stripe slate), cartões brancos planos, traços vetoriais limpos, Inter Tight / Inter (a tipografia oficial da Stripe não é pública). A cor de dados (strawberry #E8435A) apenas para números. Sem marcador, sem Caveat, sem tons pastel, sem hexadecimal digitado em uma cena.
3. Fala é legendada, cada palavra. Janelas de fala em tela cheia carregam legendas cinéticas de cobertura total (branco, uma palavra heroica por frase no destaque claro da marca, coluna esquerda em uma parte calma do fundo dele). Janelas do board carregam as palavras dentro do design. O SRT ainda é entregue. Palavras na tela são palavras que ele diz.
4. Mostre a coisa real. Toda página, papel, post, estudo que ele nomeia aparece de verdade (faixa legível em um cartão branco, marca-texto com tom da marca na frase falada); toda ferramenta/empresa recebe seu logo oficial; pessoas recebem fotos reais. Nunca invente números, citações, telas.
5. Telas são o walkthrough. A gravação Cap dele em um cartão de janela, ampliada no que ele clica (seus zooms Cap vencem, depois aglomerados de clique, depois alvos manuais), callouts desenhados após o zoom pousar. Espera é cortada, nunca acelerada.
6. Duas aprovações, depois construa tudo. Esboço de capítulos → tabela de beats → piloto (2–3 cenas + as legendas no visual) → construir todos os momentos em paralelo → compor → auto-verificação → entregar. Autopiloto ("apenas faça") pula as esperas.
7. Nunca um board morto. Cada momento desenhado tem um objeto herói que atua a frase + 1–3 micro-animações; a câmera viaja; o quadro 0 de cada cena já mostra seu título ou objeto principal.
8. Som apoia a voz. SFX estrutural apenas (~1 a cada 30–60 s, kit v6 baixo e quente), uma trilha musical ducked calma ~5 dB abaixo da voz dele (ele não ouviria uma mais silenciosa), voz no topo, −14 LUFS.
9. Verifique antes de mostrar. Contagens de frames exatas, sincronia labial verificada em cada corte, cada limite de janela em uma folha, legendas lidas contra o corte, loudness medido. Ele nunca deve ser quem encontra um problema de sincronia ou nível.

Regras rígidas

1. Esboço aprovado, depois tabela de beats aprovada, antes de qualquer cena ser construída (a menos que em autopiloto).
2. As regras de corte do adnaan-reel se aplicam inalteradas: cortes em limites de palavras, cada corte de preenchimento e cada junção verificada com $R/verify_cuts.py (leia as flags ⚠ TAIL/HEAD), nunca renderize um EDL de teste em edit/, fades de 30 ms.
3. Comece dos cortes Cap dele (source/cap.json "trims"). Depois remova retakes: mantenha a ÚLTIMA take completa de cada linha, nunca costure uma linha de duas tentativas, descarte qualquer coisa que ele rejeite em voz alta ("não", "de novo", "esquece") e pegadinhas; verifique o final da sessão por um hook regravado. Encontre repetições transcrevendo cada intervalo mantido individualmente e depois cada junção com seus vizinhos — o whisper sobre o corte longo mescla duas takes da mesma linha em uma.
4. Sem ar morto: apare cada intervalo até a fala (piso de ruído + 7 dB, 0,07 s antes / 0,09 s depois) e divida pausas internas ≥ 0,22 s ($R/audio_env.py tighten --margin 7 --min-gap 0,22). Ele pediu duas vezes para cortar "todas as pausas" — os 0,3–0,9 s de ar que a primeira passagem manteve foram lidos como pausas.
5. Telas são cortadas com os MESMOS intervalos que a câmera (compose.py faz isso a partir de timeline.json).
6. Cenas: exatamente sua contagem de frames (board.py a predefine, board.py check verifica); o runtime (board.css/js, v7yt.css/js) está instalado, nunca editado por cena; uma mudança global de visual é feita UMA VEZ em templates/runtime/ → board.py runtime. Zona do cartão clara; quadro 0 não vazio.
7. Renderize apenas através de board.py render (agentes também, --only <id>): ele escolhe ProRes 4444 .mov para sobreposições (um .mov h264 é opaco — as janelas de fala mostravam papel em vez dele) e compartilha slots de renderização em toda a máquina. Nunca pkill renderizações — o pkill de um agente matou a renderização de todos os outros agentes.
8. Posições de callout vêm de compose.py where <out_t> <sx> <sy> , nunca adivinhadas.
9. Um sub-agente por cena (ou por família de cenas que compartilham um objeto, ex. a corrente), todos gerados em uma única mensagem; reveja os stills de cada cena conforme chegam, envie correções com SendMessage para o mesmo agente. Um objeto compartilhado tem UM ÚNICO dono que escreve o módulo compartilhado + anotações; outros agentes copiam, nunca bifurcam. Confie em timestamps de arquivo, não em relatórios.
10. Downloads através de $R/fetch.py, capturas através de $R/capture.py (registrados em credits.md); todas as saídas em <project>/edit/; nunca escreva dentro de um diretório de skill durante uma edição.
11. Verificação de espelho na câmera antes de cortar (aplique zoom em qualquer texto nas roupas/fundo dele em um still em resolução total).
12. Em loops de shell, ffmpeg recebe -nostdin (caso contrário, ele consome o stdin do loop).

Helpers

Helper	O que faz
$Y/cap.py find / info <p.cap> / ingest <p.cap> --edit-dir E	Projetos Cap (mais novo primeiro) → source/cam.mov, source/screen.mp4, source/cap.json (cliques, movimentos, cortes, zooms)
$R/transcribe.py source/cam.mov --edit-dir E --vocab "…"	Transcrição em nível de palavra → transcripts/cam.json (em cache)
$R/pack_transcripts.py · $R/audio_env.py · $R/verify_cuts.py · $R/timeline_view.py	Leia a take, aperte, verifique cada junção (adnaan-reel)
$R/headpose.py source/cam.mov --start 0 --end <s> > E/headpose_report.txt	Inclinação da cabeça sobre a take → intervalos de olhar para baixo
$R/render.py edl.json -o base.mp4 --base-only	O corte → base.mp4 + timeline.json (voz com precisão de amostra)
$Y/lookdowns.py --edit-dir E	Segura um quadro da câmera sobre olhares para baixo no início/fim das linhas; execute novamente após cada renderização base
$Y/sync_check.py --edit-dir E [--final final.mp4]	Sincronia labial por segmento (imagem vs voz vs fonte) e final vs base; sai com 1 se errado
$R/capture.py · $R/fetch.py logo/photo/icon/url/credits	Faixas de página legíveis, logos oficiais, fotos reais, ícones Phosphor, downloads, credits.md
$Y/board.py prepare/runtime/render/check --edit-dir E [--only ids]	Projetos de cena a partir de animations/scenes.json (runtime v7 + ícones + starter + assets + TASK.md); renderização com limite de slot; verificação de frame exato / alfa
$Y/talkcaps.py --edit-dir E [--dry-run]	Legendas de fala de cobertura total: uma sobreposição cNN_talk gerada por janela de fala (execute novamente após qualquer mudança de corte/cena)
$Y/compose.py plan / where <t> <sx> <sy> / render -o final.mp4 [--preview] [--only-window N] / sheet <video>	Tabela de janelas; coordenadas de callout; a composição (janelas + cartão + sobreposições + SFX + música nivelada + −14 LUFS); folha de limites
$Y/zoomplan.py	A câmera de zoom (biblioteca)
$Y/deliver.py srt / chapters / stills <video> t…	deliver/captions.srt, deliver/chapters.txt (validado para YouTube), stills de thumbnail
$Y/brand.py init / css / apply --edit-dir E [--brand x.json]	O arquivo de marca → brand.css → cada cena (board.py e talkcaps.py o chamam; apply reinstala manualmente)
$Y/review.py --edit-dir E <ids>	Folha de revisão por cena (5 quadros, contorno do cartão) → verify/review/<id>.jpg
$Y/inserts.py clip / splice / shift --edit-dir E	Clipes com seu próprio áudio em um board da marca → emendados com precisão de quadro na composição → SRT + capítulos deslocados

Starters (templates/scenes/): canvas, map, board, proof (opaco), callout_overlay, talk_overlay (transparente) e talk_captions (template do talkcaps.py). Cabeçalhos do runtime (board.js, v7yt.js) listam cada primitiva. Cenas de referência: examples/stripe-v1/ (o vídeo Stripe: tabela de beats, lista de cenas, módulos de corrente + cartão de marca + página) e examples/yt-01-v7/ (mapa de corrente + módulo compartilhado, barras de dados, página de prova, fluxo do board, legendas).

Layout

<project>/
└── edit/
    ├── project.md                 memória da sessão
    ├── source/ (cam.mov, screen.mp4, cap.json)        transcripts/ (cam.json bruto, CAM.json corrigido)
    ├── edl.json, base.mp4 (+ base_unfrozen.mp4), timeline.json, headpose_report.txt, layout.json
    ├── brand/ (brand.json, brand.css)   captures/ logos/ photos/ icons/ downloads/ music/ inserts/
    ├── animations/ (scenes.json, <id>/{hf/, TASK.md, render.mp4|mov, beats.json, qa/}, cNN_talk/ gerado)
    ├── compose/ (plates, screen_cut.mp4, windows/)   verify/
    └── final.mp4, deliver/ (captions.srt, chapters.txt, description.txt, thumb_*.png), credits.md

O processo

1. Retomar. Se edit/project.md existir, resuma a última sessão em uma linha e pergunte se deve continuar.
2. Entrada. Se ele não der caminho: $Y/cap.py find e confirme a gravação. Sem Cap: vincule o arquivo de câmera como source/cam.mov (gravações de tela como source/screen.mp4 em um relógio; um cap.json mínimo). Colete o script, links e qualquer coisa que ele queira mostrar. Marca: $Y/brand.py init --edit-dir edit (Stripe; --brand x.json para outra empresa), então busque os logos que o arquivo de marca nomeia de seu kit oficial para edit/logos/. Teste uma cena na marca antes de construir o resto.
3. Ingerir + ler. ffprobe; um still em resolução total para a verificação de espelho; $R/transcribe.py source/cam.mov --edit-dir edit --vocab "<cada nome do script/links>"; $R/pack_transcripts.py; $R/headpose.py sobre toda a take → headpose_report.txt (ele pede um quadro no primeiro olhar para baixo); $R/audio_env.py tighten.
4. Esboçar capítulos. Com o transcript e a intenção dele, escreva uma outline de capítulos (títulos + duração + o que é mostrado) em edit/project.md. Pare e mostre. Revise, ajuste. Autopiloto pula.
5. Tabela de beats. Escreva a tabela de beats do vídeo. Pare e mostre. Revise, ajuste. Autopiloto pula.
6. Piloto. Construa 2–3 cenas + legendas de fala (talkcaps.py) no visual. Mostre um still de cada. Ajuste o tom do visual ($Y/brand.py css --edit-dir edit ou edite templates/runtime/ → $Y/board.py runtime).
7. Construir todas as cenas em paralelo. Cada agente prepara suas cenas (board.py prepare + render --only <ids>, slot compartilhado) e as submete com $Y/review.py. O líder revisa os stills de revisão conforme chegam e corrige via SendMessage. Talkcaps.py legendas de fala (--dry-run primeiro).
8. Compor $Y/compose.py plan → render. Have o líder verificar timeline.json e compose/plates/ antes de executar.
9. Auto-verificação. Frame exato: base.mp4 vs final.mp4; sincronia labial sync_check.py; a folha de limites (compose.py sheet) vs o layout; legendas lidas no player; loudness −14 ± 1 LUFS.
10. Entregar final.mp4, srt, capítulos, stills, descrição, credits.md.

Anti-padrões que ele odeia

• Deriva de sincronia labial da renderização base: nunca renderize a base como um EDL editado; sempre $R/render.py --base-only (uma passagem). Executar render.py base2 a partir de uma timeline prévia dessincroniza em 1–2 quadros a cada 5 minutos porque a edição corta em limites de amostra que não correspondem aos quadros originais.
• Cenas com contagem de frames frouxa: board.py check falha se os frames renderizados diferirem do layout. 287 quadros != o layout de 12,5 s. Se isso acontecer, descarte o .mov e renderize novamente.
• SVG inline hexs: toda cor é um token de variável CSS. Se uma cena amostrar #e8435a (strawberry), ele não pode mudar para outra marca. Use var(--data).
• Esperar pela renderização: slots são compartilhados. Se um agente espera, ele deve verificar o diretório de saída a cada 10 s, não executar board.py render novamente.
• Cenas talk como boards: a sobreposição de fala é transparente; o fundo é a base (câmera cortada). Se compose.py mostrar papel em vez do apresentador, a sobreposição foi renderizada como h264 (opaco). Re-renderize como ProRes 4444.
• Corte de tela manual: compose.py lê timeline.json automaticamente. Quaisquer cortes manuais em source/screen.mp4 sem re-ingestão perdem a sincronia.
• pkill: um pkill de qualquer agente mata TODAS as renderizações em todos os projetos.
• Whisper take-fusão: transcreva cada faixa individualmente, depois verifique repetições nos limites. Se o transcript longo tiver a mesma linha duas vezes seguidas, uma delas é uma retake.

---

Veja o README de adnaan-reel para fluxo de instalação completo (~/.claude/skills/adnaan-reel/README.md).