@intelli-ia/easyedit 0.0.0-stage → 0.2.0

package/payload/skills/easyedit-log/SKILL.md

@@ -0,0 +1,46 @@
+---
+name: easyedit-log
+description: "Use para registrar no spec.md do vídeo o que foi adicionado, ajustado, alterado ou removido (Registro de mudanças), ou para alterar Status e gates do cabeçalho. Chamada por easyedit-build e easyedit-interviewer a cada mudança; use também quando o usuário disser 'anota que mudamos X'. Não edita a composição nem o render."
+---
+
+# Registrar mudanças e estado
+
+## Preparação obrigatória
+
+Antes de executar esta skill, carregue `$easyedit-setup`.
+
+## Modo de interação
+
+Modo de interação: `sem perguntas`. Registre apenas fatos já ocorridos ou confirmados na conversa.
+
+## Registrar uma mudança
+
+```bash
+node .claude/skills/easyedit-log/scripts/registrar.mjs \
+  --spec <spec.md> --tipo <adicionado|ajustado|alterado|removido> \
+  --o-que "<o que mudou, em uma frase>" --motivo "<por quê>" \
+  [--origem interno|cliente] [--afeta "RV-002, T-004"]
+```
+
+O script gera o próximo `CH-xxx`, acrescenta a linha na seção 12 e atualiza `Atualizado em`. Imprime o ID.
+
+- `adicionado`: algo novo entrou (cena, música, legenda).
+- `ajustado`: refinamento sem mudar a intenção (timing, cor, volume).
+- `alterado`: troca de decisão (outro estilo, outra música).
+- `removido`: algo saiu. Diga o que e por quê.
+
+Se a mudança altera um `RV` ou `AC`, edite também o Ato I e cite os IDs em `--afeta`.
+
+## Alterar estado
+
+```bash
+node .claude/skills/easyedit-log/scripts/campo.mjs <spec.md> "<Campo>" "<valor>"
+```
+
+Campos validados: `Status` (Draft, Defined, In Progress, Review, Completed), `Definition Gate` e `Delivery Gate` (Pending, Passed).
+
+## Limites
+
+- Uma linha por mudança, curta e específica. Não agrupe mudanças sem relação.
+- Não apague nem reescreva registros antigos; corrija com um novo `CH`.
+- Não use esta skill para aprovar um gate sem a confirmação correspondente.

package/payload/skills/easyedit-log/scripts/campo.mjs

@@ -0,0 +1,24 @@
+#!/usr/bin/env node
+// Altera um campo da tabela de cabeçalho do spec.md (Status, Definition Gate, Delivery Gate…).
+import { readFileSync, writeFileSync } from 'node:fs';
+
+const [spec, campo, ...resto] = process.argv.slice(2);
+const valor = resto.join(' ');
+const fail = (m) => { console.error(`erro: ${m}`); process.exit(1); };
+if (!spec || !campo || !valor) fail('uso: campo.mjs <spec.md> "<Campo>" "<valor>"');
+
+const PERMITIDOS = {
+  Status: ['Draft', 'Defined', 'In Progress', 'Review', 'Completed'],
+  'Definition Gate': ['Pending', 'Passed'],
+  'Delivery Gate': ['Pending', 'Passed'],
+  Vertical: ['trafego-meta', 'reels', 'a definir'],
+};
+if (PERMITIDOS[campo] && !PERMITIDOS[campo].includes(valor)) fail(`${campo} aceita: ${PERMITIDOS[campo].join(' | ')}`);
+
+const hoje = new Date().toISOString().slice(0, 10);
+const re = new RegExp(`^(\\| ${campo} \\| )[^|]*( \\|)$`, 'm');
+let texto = readFileSync(spec, 'utf8');
+if (!re.test(texto)) fail(`campo não encontrado no cabeçalho: ${campo}`);
+texto = texto.replace(re, `$1${valor}$2`).replace(/^(\| Atualizado em \| )[^|]*( \|)$/m, `$1${hoje}$2`);
+writeFileSync(spec, texto);
+console.log(`${campo}: ${valor}`);

package/payload/skills/easyedit-log/scripts/registrar.mjs

@@ -0,0 +1,34 @@
+#!/usr/bin/env node
+// Acrescenta uma linha ao Registro de mudanças (seção 12) de um spec.md e atualiza "Atualizado em".
+import { readFileSync, writeFileSync } from 'node:fs';
+
+const args = Object.fromEntries(
+  process.argv.slice(2).reduce((acc, a, i, all) => {
+    if (a.startsWith('--')) acc.push([a.slice(2), all[i + 1]]);
+    return acc;
+  }, []),
+);
+const fail = (m) => { console.error(`erro: ${m}`); process.exit(1); };
+const TIPOS = ['adicionado', 'ajustado', 'alterado', 'removido'];
+const ORIGENS = ['interno', 'cliente'];
+
+const { spec, tipo, quem = 'interno', afeta = '-' } = args;
+const oque = args['o-que'], motivo = args.motivo;
+if (!spec || !tipo || !oque || !motivo) fail('uso: --spec <spec.md> --tipo <adicionado|ajustado|alterado|removido> --o-que "…" --motivo "…" [--origem interno|cliente] [--afeta "RV-001, T-002"]');
+if (!TIPOS.includes(tipo)) fail(`tipo inválido: ${TIPOS.join(' | ')}`);
+const origem = args.origem ?? 'interno';
+if (!ORIGENS.includes(origem)) fail(`origem inválida: ${ORIGENS.join(' | ')}`);
+
+let texto = readFileSync(spec, 'utf8');
+const fim = '<!-- /easyedit:changes -->';
+if (!texto.includes(fim)) fail('bloco easyedit:changes não encontrado no spec');
+
+const ids = [...texto.matchAll(/\| CH-(\d{3}) \|/g)].map((m) => Number(m[1]));
+const id = `CH-${String((ids.length ? Math.max(...ids) : 0) + 1).padStart(3, '0')}`;
+const hoje = new Date().toISOString().slice(0, 10);
+const c = (s) => String(s).replaceAll('|', '/').replace(/\s*\n\s*/g, ' ');
+const linha = `| ${id} | ${hoje} | ${tipo} | ${c(oque)} | ${c(motivo)} | ${origem} | ${c(afeta)} |\n`;
+
+texto = texto.replace(fim, linha + fim).replace(/(\| Atualizado em \| )[^|]*( \|)/, `$1${hoje}$2`);
+writeFileSync(spec, texto);
+console.log(id);

package/payload/skills/easyedit-novo/SKILL.md

@@ -0,0 +1,48 @@
+---
+name: easyedit-novo
+description: "Use quando o usuário pede para começar, criar ou iniciar um novo vídeo para um cliente, ou para adotar o EasyEdit num projeto de vídeo que já existe sem spec.md. Cria o projeto HyperFrames e o spec.md em Draft a partir do template e depois chama a entrevista. Para vídeo com spec existente use easyedit-interviewer; para executar use easyedit-build."
+---
+
+# Abrir um vídeo novo
+
+## Preparação obrigatória
+
+Antes de executar esta skill, carregue `$easyedit-setup`. Reutilize o cliente confirmado na conversa.
+
+## Modo de interação
+
+Modo de interação: `perguntas`, limitado ao necessário para criar o projeto (título do vídeo, proporção). O restante vai para a entrevista. Siga o contrato de perguntas de `.easyedit/Spec.md` (uma por vez, opções de 1 a 5).
+
+## Passos
+
+1. Defina o título e o mês (`AAAA-MM`, por padrão o atual). O nome da pasta será `AAAA-MM-<slug>`.
+2. Pergunte a **vertical**: `trafego-meta` (criativo para anúncio) ou `reels` (ainda sem playbook próprio; use o padrão geral). Escolha a proporção: `portrait` (1080x1920, Reels/TikTok/Shorts), `landscape` (1920x1080) ou `square`.
+3. Crie o projeto HyperFrames dentro de `projects/` do cliente. Se o usuário já trouxe um vídeo base, passe `--video <caminho>` e **não** use `raw/` como destino de escrita:
+
+```bash
+cd clientes/<cliente>/projects
+npx hyperframes init <AAAA-MM-slug> --non-interactive --resolution <preset> [--video <caminho>]
+```
+
+   Se o `init` for transcrever, faça a pergunta de autorização do modelo no formato do contrato: os modelos `.en` do whisper são só de inglês, então para português use `--language pt` com o modelo `large-v3`, ou `--skip-transcribe` e rode a transcrição depois.
+
+4. Crie o spec a partir do template:
+
+```bash
+node .claude/skills/easyedit-novo/scripts/novo_video.mjs \
+  --cliente <cliente> --title "<título>" [--slug <slug>] [--mes AAAA-MM] [--vertical trafego-meta|reels]
+```
+
+   O script imprime o caminho do `spec.md` e **cria `clientes/<cliente>/raw/<AAAA-MM-slug>/`**: é nessa pasta que a pessoa coloca todas as gravações do vídeo (quantas forem). Avise isso na resposta. Se a pasta já tinha sido criada pelo `init`, ele só adiciona o arquivo.
+
+5. Se já houver arquivos na pasta de raw, anuncie `$easyedit-takes` para inventariar e ordenar antes da entrevista. Preencha o cabeçalho e a seção 2 do spec com o que já foi respondido. Mantenha `Status: Draft` e `Definition Gate: Pending`.
+6. Anuncie `Transição automática: $easyedit-novo → $easyedit-interviewer — motivo: spec em Draft — resultado esperado: Ato I completo` e carregue a entrevista.
+
+## Modo retroativo
+
+Para um projeto existente sem spec: não rode o `init`. Crie só o `spec.md`, preencha o Ato I a partir do que o projeto já contém (`index.html`, `transcript.json`, `public/`, render em `output/`) e registre em `Suposições` que foi inferido. Marque as tarefas já visíveis como `Done`, com evidência quando houver. Confirme tudo com a pessoa antes de passar para `Defined`.
+
+## Limites
+
+- Não sobrescreva um `spec.md` existente.
+- Não crie cliente: se `clientes/<cliente>/` não existir, indique `scripts/novo-cliente.sh <nome>`.

package/payload/skills/easyedit-novo/scripts/novo_video.mjs

@@ -0,0 +1,43 @@
+#!/usr/bin/env node
+// Cria clientes/<cliente>/projects/<AAAA-MM-slug>/spec.md a partir de .easyedit/templates/Spec.md.
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
+import { dirname, join, resolve } from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const args = Object.fromEntries(
+  process.argv.slice(2).reduce((acc, a, i, all) => {
+    if (a.startsWith('--')) acc.push([a.slice(2), all[i + 1]]);
+    return acc;
+  }, []),
+);
+const fail = (m) => { console.error(`erro: ${m}`); process.exit(1); };
+
+const root = resolve(args.root ?? join(dirname(fileURLToPath(import.meta.url)), '../../../..'));
+const { cliente, title } = args;
+if (!cliente || !title) fail('uso: --cliente <kebab> --title "<nome do vídeo>" [--slug <kebab>] [--mes AAAA-MM] [--vertical trafego-meta|reels] [--root <raiz>]');
+
+const kebab = (s) => s.normalize('NFD').replace(/[̀-ͯ]/g, '').toLowerCase().replace(/[^a-z0-9]+/g, '-').replace(/^-+|-+$/g, '');
+const hoje = new Date().toISOString().slice(0, 10);
+const mes = args.mes ?? hoje.slice(0, 7);
+if (!/^\d{4}-\d{2}$/.test(mes)) fail('--mes deve ser AAAA-MM');
+const slug = `${mes}-${kebab(args.slug ?? title)}`;
+
+const clienteDir = join(root, 'clientes', cliente);
+if (!existsSync(clienteDir)) fail(`cliente não existe: ${clienteDir} (use scripts/novo-cliente.sh)`);
+const projeto = join(clienteDir, 'projects', slug);
+const specPath = join(projeto, 'spec.md');
+if (existsSync(specPath)) fail(`já existe: ${specPath}`);
+
+const modelo = join(root, '.easyedit/templates/Spec.md');
+if (!existsSync(modelo)) fail(`template ausente: ${modelo}`);
+
+const vertical = args.vertical ?? 'a definir';
+if (!['trafego-meta', 'reels', 'a definir'].includes(vertical)) fail('--vertical: trafego-meta | reels');
+mkdirSync(projeto, { recursive: true });
+mkdirSync(join(clienteDir, 'raw', slug), { recursive: true });
+const texto = readFileSync(modelo, 'utf8')
+  .replaceAll('{{TITULO}}', title).replaceAll('{{SLUG}}', slug)
+  .replaceAll('{{CLIENTE}}', cliente).replaceAll('{{VERTICAL}}', vertical).replaceAll('{{DATA}}', hoje);
+writeFileSync(specPath, texto);
+console.log(specPath);
+console.log(`coloque as gravações em: ${join(clienteDir, 'raw', slug)}`);

package/payload/skills/easyedit-progress/SKILL.md

@@ -0,0 +1,27 @@
+---
+name: easyedit-progress
+description: "Use quando o usuário pede o andamento, status ou panorama dos vídeos: quais estão em rascunho, em execução, em revisão ou entregues, por cliente. Lê os spec.md e resume estado, gates, requisitos, tarefas e mudanças. Somente leitura."
+---
+
+# Acompanhar o andamento
+
+## Modo de interação
+
+Modo de interação: `sem perguntas`. Somente leitura.
+
+## Passos
+
+1. Rode:
+
+```bash
+node .claude/skills/easyedit-progress/scripts/progress.mjs [--cliente <nome>] [--json]
+```
+
+2. Apresente um quadro por cliente com `Status`, gates, `RV`/`AC`, tarefas concluídas sobre o total e número de mudanças.
+3. Destaque o que pede ação: `Draft` parado, `Review` aguardando cliente, tarefas pendentes em `In Progress`, projetos `[sem spec]` (ofereça `$easyedit-novo` em modo retroativo).
+4. Para um vídeo específico, leia o `spec.md` e resuma as últimas mudanças da seção 12 e os feedbacks sem resposta da seção 13.
+
+## Limites
+
+- Não altere arquivos.
+- Os números vêm do `spec.md`; não estime nem complete lacunas.

package/payload/skills/easyedit-progress/scripts/progress.mjs

@@ -0,0 +1,39 @@
+#!/usr/bin/env node
+// Resume o estado dos vídeos: node progress.mjs [--cliente <nome>] [--json]
+import { existsSync, readdirSync, readFileSync } from 'node:fs';
+import { dirname, join, resolve } from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const argv = process.argv.slice(2);
+const flag = (n) => { const i = argv.indexOf(`--${n}`); return i < 0 ? undefined : argv[i + 1]; };
+const root = resolve(flag('root') ?? join(dirname(fileURLToPath(import.meta.url)), '../../../..'));
+const filtro = flag('cliente');
+const json = argv.includes('--json');
+
+const dirs = (p) => (existsSync(p) ? readdirSync(p, { withFileTypes: true }).filter((d) => d.isDirectory()).map((d) => d.name) : []);
+const campo = (t, n) => t.match(new RegExp(`^\\| ${n} \\| ([^|]*) \\|$`, 'm'))?.[1].trim() ?? '-';
+const linhas = (t, prefixo) => [...t.matchAll(new RegExp(`^\\| ${prefixo}-\\d{3} \\|.*$`, 'gm'))].map((m) => m[0]);
+
+const out = [];
+for (const cliente of dirs(join(root, 'clientes'))) {
+  if (filtro && cliente !== filtro) continue;
+  for (const video of dirs(join(root, 'clientes', cliente, 'projects'))) {
+    const spec = join(root, 'clientes', cliente, 'projects', video, 'spec.md');
+    if (!existsSync(spec)) { out.push({ cliente, video, status: 'sem spec' }); continue; }
+    const t = readFileSync(spec, 'utf8');
+    const tarefas = linhas(t, 'T');
+    out.push({
+      cliente, video, vertical: campo(t, 'Vertical'), status: campo(t, 'Status'),
+      definition: campo(t, 'Definition Gate'), delivery: campo(t, 'Delivery Gate'),
+      rv: linhas(t, 'RV').length, ac: linhas(t, 'AC').length,
+      tarefas: `${tarefas.filter((l) => /\| Done \|$/.test(l)).length}/${tarefas.filter((l) => !/\| Dropped \|$/.test(l)).length}`,
+      mudancas: linhas(t, 'CH').length,
+    });
+  }
+}
+
+if (json) console.log(JSON.stringify(out, null, 2));
+else if (!out.length) console.log('nenhum vídeo encontrado');
+else for (const v of out) console.log(v.status === 'sem spec'
+  ? `${v.cliente}/${v.video}  [sem spec]`
+  : `${v.cliente}/${v.video}  [${v.status}] ${v.vertical}  def:${v.definition} entrega:${v.delivery}  RV:${v.rv} AC:${v.ac}  tarefas:${v.tarefas}  mudanças:${v.mudancas}`);

package/payload/skills/easyedit-ritmo/SKILL.md

@@ -0,0 +1,42 @@
+---
+name: easyedit-ritmo
+description: "Use para eliminar respiros e pausas em vídeo falado, a pedido do usuário ou porque o perfil da vertical (por exemplo criativo de tráfego) exige ritmo sem pausa. Mede os intervalos entre palavras na transcrição, propõe a pausa máxima, gera os segmentos de corte e a transcrição com tempos remapeados. Não altera raw/. Para escolher o que inserir sobre a fala use easyedit-destaques."
+---
+
+# Cortar respiros
+
+## Preparação obrigatória
+
+Antes de executar esta skill, carregue `$easyedit-setup`.
+
+## Modo de interação
+
+Modo de interação: `sem perguntas`. Use a pausa máxima definida na seção 5 do spec (padrão: tráfego 0,3 s; Reels 0,5 s).
+
+## Passos
+
+0. Se o vídeo tem várias gravações, rode `$easyedit-takes` antes e use `transcript.takes.json` como `--transcript`: o script corta as pausas dentro de cada take e emenda na ordem; `cortes.json` traz o `arquivo` de cada segmento (um `<video>` por segmento, apontando para o arquivo de `raw/<slug>/`).
+1. Garanta uma transcrição de palavras (`transcript.json`, array `{text, start, end}`). Se não houver, rode `npx hyperframes transcribe <vídeo> --language pt --model large-v3` (pergunte antes de baixar o modelo; os `.en` não servem para português).
+2. Simule sem gravar e mostre o efeito:
+
+```bash
+node .claude/skills/easyedit-ritmo/scripts/pausas.mjs --transcript <transcript.json> --max-pausa 0.3 --dry
+```
+
+   Se os cortes forem poucos (o vídeo já estava apertado), diga isso e pare.
+3. Grave `cortes.json` e `transcript.cut.json` na pasta do projeto:
+
+```bash
+node .claude/skills/easyedit-ritmo/scripts/pausas.mjs --transcript <transcript.json> --max-pausa 0.3 --out <pasta-do-projeto>
+```
+
+4. Monte a composição emendando um clipe de vídeo por segmento de `cortes.json`, com `data-media-start = fonte_inicio`, `data-start = timeline_inicio` e `data-duration = duracao` (receita *Split / splice* de `/hyperframes-core`, `references/creator-editing-recipes.md`). O áudio acompanha cada clipe.
+5. Use `transcript.cut.json` para legendas e destaques: os tempos já estão na linha do tempo final.
+6. Confira nos snapshots as emendas: corte seco no meio de uma sílaba é defeito. Aumente `--ini`/`--fim` ou `--max-pausa` se necessário.
+7. Registre com `$easyedit-log` (`ajustado`, "pausas encurtadas para Xs, N cortes, de A s para B s").
+
+## Limites
+
+- Nunca altere `raw/`; o corte existe só na composição.
+- Faça este passo **antes** de `easyedit-destaques` e `easyedit-legendas`, para que tudo use a linha do tempo final.
+- Respiro que serve ao sentido (suspense, ênfase deliberada) não deve ser cortado: se a vertical permitir, sinalize e pergunte.

package/payload/skills/easyedit-ritmo/scripts/pausas.mjs

@@ -0,0 +1,73 @@
+#!/usr/bin/env node
+// Encurta pausas a partir de transcript.json (array [{text,start,end}]).
+// Gera cortes.json (segmentos de fonte para emendar com data-media-start) e transcript.cut.json (tempos remapeados).
+// uso: node pausas.mjs --transcript <transcript.json> [--max-pausa 0.3] [--ini 0.1] [--fim 0.25] [--duracao <s>] [--out <dir>] [--dry]
+import { readFileSync, writeFileSync } from 'node:fs';
+import { dirname, join, resolve } from 'node:path';
+
+const args = Object.fromEntries(process.argv.slice(2).reduce((a, x, i, all) => {
+  if (x.startsWith('--')) a.push([x.slice(2), x.startsWith('--dry') ? 'true' : all[i + 1]]);
+  return a;
+}, []));
+const fail = (m) => { console.error(`erro: ${m}`); process.exit(1); };
+if (!args.transcript) fail('uso: --transcript <transcript.json> [--max-pausa 0.3] [--ini 0.1] [--fim 0.25] [--duracao <s>] [--out <dir>] [--dry]');
+
+const maxPausa = Number(args['max-pausa'] ?? 0.3);
+const ini = Number(args.ini ?? 0.1);
+const fim = Number(args.fim ?? 0.25);
+const r = (n) => Math.round(n * 1000) / 1000;
+
+const palavras = JSON.parse(readFileSync(args.transcript, 'utf8'))
+  .filter((w) => Number.isFinite(w.start) && Number.isFinite(w.end));
+if (!palavras.length) fail('transcrição vazia');
+
+// Agrupa palavras consecutivas pelo take de origem (sem `take` = um único arquivo).
+const grupos = [];
+for (const w of palavras) {
+  const g = grupos.at(-1);
+  if (g && g.take === w.take) g.palavras.push(w); else grupos.push({ take: w.take, palavras: [w] });
+}
+const segmentos = [];
+let tl = 0;
+const cortadas = [];
+grupos.forEach((g, gi) => {
+  const ps = g.palavras;
+  const ultimo = gi === grupos.length - 1;
+  const fimGrupo = ps.at(-1).end + fim;
+  const limite = ultimo && args.duracao && !g.take ? Number(args.duracao) : fimGrupo;
+  const manter = [];
+  let abre = Math.max(0, ps[0].start - ini);
+  for (let i = 0; i < ps.length - 1; i++) {
+    const gap = ps[i + 1].start - ps[i].end;
+    if (gap > maxPausa) {
+      manter.push([abre, ps[i].end + maxPausa / 2]);
+      abre = ps[i + 1].start - maxPausa / 2;
+    }
+  }
+  manter.push([abre, Math.min(limite, fimGrupo)]);
+  const doGrupo = manter.map(([a, b]) => {
+    const s = { ...(g.take ? { arquivo: g.take } : {}), fonte_inicio: r(a), fonte_fim: r(b), timeline_inicio: r(tl), duracao: r(b - a) };
+    tl += b - a;
+    return s;
+  });
+  segmentos.push(...doGrupo);
+  for (const w of ps) {
+    const s = doGrupo.find((x) => w.start >= x.fonte_inicio - 1e-6 && w.start <= x.fonte_fim + 1e-6) ?? doGrupo.at(-1);
+    cortadas.push({ ...w, start: r(s.timeline_inicio + (w.start - s.fonte_inicio)), end: r(s.timeline_inicio + (w.end - s.fonte_inicio)) });
+  }
+});
+const duracao = r(grupos.reduce((acc, g) => acc + (g.palavras.at(-1).end + fim), 0));
+// cortes = lacunas removidas dentro de um mesmo arquivo
+const cortes = [];
+segmentos.slice(1).forEach((s, i) => {
+  const ant = segmentos[i];
+  if (ant.arquivo === s.arquivo) cortes.push({ ...(s.arquivo ? { arquivo: s.arquivo } : {}), de: ant.fonte_fim, ate: s.fonte_inicio, removido: r(s.fonte_inicio - ant.fonte_fim) });
+});
+
+const resumo = { max_pausa: maxPausa, duracao_original: duracao, duracao_final: r(tl), removido: r(duracao - tl), n_cortes: cortes.length, segmentos, cortes };
+console.log(`pausa máxima ${maxPausa}s · ${cortes.length} cortes · ${resumo.duracao_original}s → ${resumo.duracao_final}s · ${new Set(segmentos.map((s) => s.arquivo)).size} arquivo(s) (−${resumo.removido}s)`);
+if (args.dry === 'true') process.exit(0);
+const out = resolve(args.out ?? dirname(args.transcript));
+writeFileSync(join(out, 'cortes.json'), JSON.stringify(resumo, null, 2));
+writeFileSync(join(out, 'transcript.cut.json'), JSON.stringify(cortadas, null, 2));
+console.log(`gravado: ${join(out, 'cortes.json')} e transcript.cut.json`);

package/payload/skills/easyedit-setup/SKILL.md

@@ -0,0 +1,31 @@
+---
+name: easyedit-setup
+description: "Carregue antes de qualquer outra skill easyedit-*: resolve a raiz do repositório, o cliente e o vídeo (projeto) alvo, e lê o contexto obrigatório (CLAUDE.md global e do cliente, .easyedit/TOOLS.md, .easyedit/Spec.md, spec.md do vídeo). Use também quando o usuário disser 'vamos trabalhar no vídeo X' sem dizer o que fazer. Não cria nem edita nada."
+---
+
+# Preparar o contexto do vídeo
+
+## Modo de interação
+
+Modo de interação: `sem perguntas`, exceto para desambiguar cliente ou vídeo quando houver mais de um candidato.
+
+## Passos
+
+1. Confirme a raiz: o diretório que contém `.easyedit/` e `clientes/`. Se não existir, pare e avise.
+2. Resolva o **cliente** (`clientes/<cliente>/`) pelo pedido do usuário ou pelo diretório atual. Se houver mais de um candidato, pergunte.
+3. Resolva o **vídeo** (`clientes/<cliente>/projects/<AAAA-MM-slug>/`). Sem vídeo indicado, rode `node .claude/skills/easyedit-progress/scripts/progress.mjs --cliente <cliente>` e peça a escolha, ou encaminhe para `$easyedit-novo` se for um vídeo novo.
+4. Leia, nesta ordem, só o que existir:
+   - `CLAUDE.md` da raiz e `clientes/<cliente>/CLAUDE.md` (marca, tom, preferências);
+   - `.easyedit/Spec.md` (contrato, estados, perguntas) e `.easyedit/TOOLS.md` (ferramentas);
+   - `projects/<vídeo>/spec.md`.
+5. Rode `npx hyperframes doctor` apenas quando a tarefa for renderizar ou transcrever e o ambiente ainda não tiver sido conferido na conversa.
+6. Informe em uma linha: cliente, vídeo, vertical, `Status` e gates, e quantos arquivos há em `raw/<slug>/`. Se o `CLAUDE.md` do cliente estiver com campos em branco, sinalize que a entrevista deve preenchê-los.
+
+## Continuar sem pedir permissão
+
+Depois de informar o contexto, **não pergunte "posso começar?"**. Anuncie a transição e carregue a skill do próximo passo conforme o estado: sem spec → `$easyedit-novo`; `Draft` → `$easyedit-interviewer`; `Defined`/`In Progress`/`Review` → `$easyedit-build`. Se a tarefa pedida for outra (status, registro), siga esse pedido. Pendências do contexto (por exemplo, `CLAUDE.md` em branco, arquivo solto em `raw/`) entram como perguntas da etapa seguinte, no formato do contrato, uma por vez.
+
+## Limites
+
+- Não edite `raw/`, não crie arquivos e não avance estado.
+- Se o vídeo não tiver `spec.md` (projeto anterior ao EasyEdit), não o crie aqui: ofereça `$easyedit-novo` em modo retroativo.

package/payload/skills/easyedit-split-broll/SKILL.md

@@ -0,0 +1,37 @@
+---
+name: easyedit-split-broll
+description: "Use para montar vídeo de fala com b-roll em tela dividida na horizontal (duas faixas, uma em cima e outra embaixo, por exemplo pessoa falando de um lado e b-roll do outro) em canvas 9:16, escolhendo e sincronizando o b-roll com a fala. Respeita as zonas cinzentas. Para destaques pontuais em tela cheia use easyedit-destaques."
+---
+
+# Tela dividida com b-roll
+
+## Preparação obrigatória
+
+Antes de executar esta skill, carregue `$easyedit-setup` e `$easyedit-zonas-seguras`. Carregue `/hyperframes-core` antes de escrever o HTML.
+
+## Modo de interação
+
+Modo de interação: `sem perguntas`. Dúvida de estilo volta para `$easyedit-interviewer`.
+
+## Layout
+
+Canvas 1080x1920 dividido em duas faixas empilhadas:
+
+- **Padrão:** fala em cima, b-roll embaixo. Ao decidir, lembre que o rodapé (35%) é coberto pela interface: o b-roll pode ocupar a faixa inferior inteira, mas **nada informativo dentro dele** (texto, rosto, produto) pode ficar nos 672 px de baixo.
+- A **linha de divisão** e o assunto principal de cada faixa ficam dentro da área útil (y 269–1248). Na prática, divida próximo de y ≈ 960 e enquadre o rosto e o b-roll para que o essencial caia acima de y = 1248.
+- Referência de estrutura: `~/.agents/skills/talking-head-recut/references/layouts/split.html` e `stack.html`, adaptando proporções e zonas.
+
+## Passos
+
+1. Parta do plano de `$easyedit-destaques` (tempos e materiais). Cada trecho de b-roll cobre a frase da fala correspondente.
+2. Tire o b-roll de `assets/broll/` (imagens viram vídeo com movimento sutil via `/hyperframes-keyframes`, por exemplo Ken Burns). Material faltante: `/media-use` ou pedido ao cliente.
+3. Troque b-roll a cada 2–4 s; mantenha a faixa da fala contínua para o áudio ficar sincronizado.
+4. Recorte cada mídia com `object-fit: cover` e o ponto focal ajustado, sem deformar.
+5. Anime a entrada e a troca de b-roll com movimento curto (`/hyperframes-animation`); transição entre trechos rápida, sem fade longo.
+6. Registre cada faixa e o assunto principal (rosto, produto) em `elementos.json` e valide com `$easyedit-zonas-seguras`, dê `npx hyperframes check`, tire snapshots e registre com `$easyedit-log`.
+
+## Limites
+
+- A faixa de fala não pode ficar vazia nem congelar.
+- **Rostos no b-roll também contam**: um b-roll com crianças ou pessoas na faixa de baixo cai nos 35% do rodapé e é erro do verificador. Escolha ou reenquadre o b-roll para que o rosto fique acima de y = 1248, ou use a faixa de baixo só para planos sem rosto.
+- Não use b-roll cuja origem ou direito de uso seja desconhecido.

package/payload/skills/easyedit-takes/SKILL.md

@@ -0,0 +1,52 @@
+---
+name: easyedit-takes
+description: "Use quando um vídeo (criativo) chega em várias gravações separadas na pasta do vídeo: inventaria os arquivos, define a ordem cronológica (numeração do nome e data de geração), transcreve cada take, identifica repetições e refações, escolhe o melhor trecho, e prepara a sequência para corte e colagem. Rode antes de easyedit-ritmo. Com um único arquivo bruto, pule esta skill."
+---
+
+# Ordenar e juntar as gravações
+
+## Preparação obrigatória
+
+Antes de executar esta skill, carregue `$easyedit-setup`.
+
+## Modo de interação
+
+Modo de interação: `perguntas`, só quando a ordem for ambígua, quando houver refações com escolha subjetiva ou quando os formatos divergirem. Siga o `Contrato de perguntas (uma por vez)` de `.easyedit/Spec.md`: **uma pergunta por mensagem**, em múltipla escolha de 1 a 5 (1–3 opções técnicas, 4 gerar outras opções, 5 avançar sem responder). Ordem de perguntas: ordem dos takes, depois autorização do modelo de transcrição, depois descartes de refação.
+
+## Onde ficam os arquivos
+
+A pessoa coloca todas as gravações do vídeo em **`clientes/<cliente>/raw/<AAAA-MM-slug>/`**, com o mesmo nome da pasta do projeto. Nunca edite esses arquivos. Se houver arquivos soltos em `raw/`, pergunte a qual vídeo pertencem antes de mover; mover é ação sensível.
+
+## Passos
+
+1. **Inventariar e ordenar:**
+
+```bash
+node .claude/skills/easyedit-takes/scripts/takes.mjs listar \
+  --pasta clientes/<cliente>/raw/<slug> --out clientes/<cliente>/projects/<slug>
+```
+
+   Gera `takes.json` com duração, resolução, fps, rotação, áudio e data de criação (metadado do arquivo; se ausente, do sistema de arquivos). Regra de ordem:
+   - nomes numerados (`take 1`, `01-`, `IMG_0175`) → ordem natural do nome;
+   - nomes sem número → data de criação;
+   - **se nome e data divergirem, a confiança é `baixa`**: pergunte a ordem (1. por nome, 2. por data, 3. deixar o conteúdo decidir, transcrevendo tudo e propondo a ordem pelo roteiro; 4 e 5 como no contrato; sugestão: 3 quando a divergência for grande). Ajuste `ordem` em `takes.json`.
+2. **Transcrever cada take** (se o modelo não estiver baixado, pergunte: 1. baixar `large-v3` (~3 GB, melhor para português) (sugestão), 2. usar um modelo menor, 3. pular a transcrição; 4 e 5 como no contrato; use `--language pt` com `large-v3`, os modelos `.en` são só de inglês) e guarde em `projects/<slug>/takes/<nome-sem-extensão>.transcript.json`.
+3. **Entender a sequência pelo conteúdo.** Leia as transcrições na ordem e confira com o roteiro da seção 4 do spec: abertura, desenvolvimento, CTA. Aponte o que não bate (take fora de lugar, parte do roteiro sem gravação).
+4. **Refações:** quando a mesma frase aparece em mais de um take, ou há começo falso, gagueira ou erro no meio:
+   - proponha a melhor versão (a mais completa e fluente, em regra a última) e mostre a tabela *take · trecho · motivo*;
+   - com a aprovação, marque `usar: false` no take descartado ou o intervalo `[de, ate]` em `descartar` do take (tempos da fonte, em segundos).
+5. **Montar a transcrição unificada** na ordem final:
+
+```bash
+node .claude/skills/easyedit-takes/scripts/takes.mjs montar --out clientes/<cliente>/projects/<slug>
+```
+
+   Gera `transcript.takes.json`, com cada palavra marcada com o `take` de origem e os tempos da fonte. Passe-o para `$easyedit-ritmo` (`--transcript transcript.takes.json`), que corta as pausas **dentro** de cada take e emenda os segmentos na ordem.
+6. **Normalizar a junção:** se os takes tiverem resolução, fps ou rotação diferentes, a composição usa o canvas definido na seção 2 do spec e enquadra cada clipe com `object-fit` e foco ajustados. Níveis de áudio diferentes: `npx hyperframes normalize-audio` entre takes. Procure saltos de enquadramento, luz e som entre takes e proponha *punch-in* (`/hyperframes-keyframes`) ou b-roll para mascarar a emenda.
+7. Registre na seção 3 do spec a tabela dos takes (ordem, arquivo, duração, uso) e, com `$easyedit-log`, cada descarte e a ordem escolhida (`ajustado`).
+
+## Limites
+
+- Nunca altere, renomeie ou apague arquivos em `raw/`.
+- Não invente a ordem: quando houver conflito, a pessoa decide.
+- Não descarte um take sem mostrar o motivo e obter a aprovação.

package/payload/skills/easyedit-takes/scripts/takes.mjs

@@ -0,0 +1,73 @@
+#!/usr/bin/env node
+// Inventaria e ordena as gravações (takes) de um vídeo e monta a transcrição unificada.
+//   node takes.mjs listar --pasta <raw/slug> --out <projects/slug>
+//   node takes.mjs montar --out <projects/slug>
+import { execFileSync } from 'node:child_process';
+import { existsSync, readdirSync, readFileSync, statSync, writeFileSync } from 'node:fs';
+import { basename, extname, join, resolve } from 'node:path';
+
+const [cmd, ...rest] = process.argv.slice(2);
+const args = Object.fromEntries(rest.reduce((a, x, i, all) => (x.startsWith('--') ? [...a, [x.slice(2), all[i + 1]]] : a), []));
+const fail = (m) => { console.error(`erro: ${m}`); process.exit(1); };
+const EXT = new Set(['.mp4', '.mov', '.m4v', '.webm', '.mkv', '.mp3', '.wav', '.m4a']);
+const r = (n) => Math.round(n * 1000) / 1000;
+
+if (cmd === 'listar') {
+  if (!args.pasta || !args.out) fail('uso: listar --pasta <raw/slug> --out <projects/slug>');
+  const pasta = resolve(args.pasta);
+  if (!existsSync(pasta)) fail(`pasta não existe: ${pasta}`);
+  const arquivos = readdirSync(pasta).filter((f) => !f.startsWith('.') && EXT.has(extname(f).toLowerCase()));
+  if (!arquivos.length) fail('nenhum arquivo de mídia na pasta');
+
+  const itens = arquivos.map((arquivo) => {
+    const caminho = join(pasta, arquivo);
+    const j = JSON.parse(execFileSync('ffprobe', ['-v', 'error', '-print_format', 'json', '-show_format', '-show_streams', caminho]).toString());
+    const v = j.streams.find((s) => s.codec_type === 'video');
+    const a = j.streams.find((s) => s.codec_type === 'audio');
+    const [num, den] = (v?.avg_frame_rate ?? '0/1').split('/').map(Number);
+    const rot = Number(v?.side_data_list?.find((d) => d.rotation !== undefined)?.rotation ?? v?.tags?.rotate ?? 0);
+    const st = statSync(caminho);
+    const tag = j.format?.tags?.creation_time ?? v?.tags?.creation_time;
+    return {
+      arquivo, duracao: r(Number(j.format.duration)),
+      largura: v?.width ?? null, altura: v?.height ?? null, fps: den ? r(num / den) : null, rotacao: rot,
+      audio: Boolean(a), video: Boolean(v),
+      criado_em: tag ?? st.birthtime.toISOString(), criado_em_origem: tag ? 'metadado' : 'sistema de arquivos',
+      modificado_em: st.mtime.toISOString(),
+    };
+  });
+
+  const porNome = [...itens].sort((x, y) => x.arquivo.localeCompare(y.arquivo, 'pt', { numeric: true }));
+  const porData = [...itens].sort((x, y) => x.criado_em.localeCompare(y.criado_em));
+  const todosComNumero = itens.every((i) => /\d/.test(i.arquivo));
+  const mesmaOrdem = porNome.every((x, i) => x.arquivo === porData[i].arquivo);
+  const regra = mesmaOrdem ? 'nome e data concordam' : todosComNumero ? 'nome (numeração), data diverge' : 'data de criação (nomes sem numeração)';
+  const ordenado = mesmaOrdem || !todosComNumero ? (mesmaOrdem ? porNome : porData) : porNome;
+
+  const takes = ordenado.map((t, i) => ({ ordem: i + 1, usar: true, descartar: [], ...t }));
+  const saida = { pasta, regra_de_ordem: regra, confianca: mesmaOrdem ? 'alta' : 'baixa', diverge: !mesmaOrdem, takes };
+  writeFileSync(join(resolve(args.out), 'takes.json'), JSON.stringify(saida, null, 2));
+  console.log(`${takes.length} takes · ordem: ${regra} · confiança ${saida.confianca}`);
+  for (const t of takes) console.log(`${String(t.ordem).padStart(2)}. ${t.arquivo}  ${t.duracao}s  ${t.largura}x${t.altura}@${t.fps}${t.rotacao ? ` rot${t.rotacao}` : ''}  ${t.audio ? '' : '[sem áudio] '}${t.criado_em.slice(0, 19)} (${t.criado_em_origem})`);
+  if (saida.diverge) console.log('\nATENÇÃO: ordem por nome ≠ ordem por data. Confirme com a pessoa e ajuste "ordem" em takes.json.');
+  const res = new Set(takes.map((t) => `${t.rotacao % 180 ? t.altura : t.largura}x${t.rotacao % 180 ? t.largura : t.altura}@${t.fps}`));
+  if (res.size > 1) console.log(`ATENÇÃO: takes com formatos diferentes (${[...res].join(', ')}). Normalizar na montagem.`);
+} else if (cmd === 'montar') {
+  if (!args.out) fail('uso: montar --out <projects/slug>');
+  const out = resolve(args.out);
+  const { takes } = JSON.parse(readFileSync(join(out, 'takes.json'), 'utf8'));
+  const palavras = [];
+  const faltando = [];
+  for (const t of [...takes].sort((a, b) => a.ordem - b.ordem)) {
+    if (!t.usar) continue;
+    const f = join(out, 'takes', `${basename(t.arquivo, extname(t.arquivo))}.transcript.json`);
+    if (!existsSync(f)) { faltando.push(f); continue; }
+    for (const w of JSON.parse(readFileSync(f, 'utf8'))) {
+      if ((t.descartar ?? []).some(([de, ate]) => w.start >= de && w.end <= ate)) continue;
+      palavras.push({ ...w, take: t.arquivo });
+    }
+  }
+  if (faltando.length) fail(`transcrições ausentes:\n${faltando.join('\n')}`);
+  writeFileSync(join(out, 'transcript.takes.json'), JSON.stringify(palavras, null, 2));
+  console.log(`${palavras.length} palavras de ${new Set(palavras.map((p) => p.take)).size} takes → transcript.takes.json`);
+} else fail('comandos: listar | montar');

package/payload/skills/easyedit-vertical-trafego/SKILL.md

@@ -0,0 +1,55 @@
+---
+name: easyedit-vertical-trafego
+description: "Use quando o vídeo é um criativo para anúncio de tráfego pago na Meta (Instagram/Facebook Ads): define o perfil da vertical no spec (requisitos e aceites padrão) e orquestra as skills de takes, ritmo, destaques, tela dividida, legendas e zonas seguras com foco em conversão. Aplica-se quando o campo Vertical do spec é trafego-meta. Para Reels orgânico (ainda não implementado), não use."
+---
+
+# Vertical · Criativo para tráfego na Meta
+
+## Preparação obrigatória
+
+Antes de executar esta skill, carregue `$easyedit-setup`. Leia [references/playbook.md](references/playbook.md).
+
+## Modo de interação
+
+Modo de interação: `perguntas` na fase de especificação (uma por vez, só o que o playbook não responde, sempre em múltipla escolha de 1 a 5); `sem perguntas` na execução.
+
+## Na especificação (chamada pelo `$easyedit-interviewer`)
+
+1. Marque `Vertical: trafego-meta` no cabeçalho do spec.
+2. **Não pergunte nem fixe meta de duração**: ela é livre (ver o playbook). Pergunte, **uma por vez** e nesta ordem de prioridade (contrato de perguntas do `.easyedit/Spec.md`), só o que muda o criativo: **oferta e público**, **CTA único** e destino, **gancho** (dor/promessa), **provas** disponíveis, **placements** (só Stories/Reels ou também feed 4:5), **quantas variantes de gancho**, restrições do setor.
+3. Preencha os padrões, para a pessoa confirmar ou alterar:
+
+| Item | Padrão |
+| --- | --- |
+| Formato | 1080x1920, 30 fps; variante 4:5 se houver feed |
+| Duração | Livre: sem mínimo, máximo ou meta de tempo; a duração final é só registrada |
+| RV | Gancho na fala e no visual nos primeiros 3 s |
+| RV | A ideia é concisa do gancho ao CTA: cada cena tem uma função no argumento (gancho, problema, solução, prova, CTA), sem digressão nem repetição |
+| RV | Legenda em 100% da fala |
+| RV | Nenhum texto, rosto, produto, logo ou CTA nas zonas cinzentas |
+| RV | Pausa entre palavras ≤ 0,3 s |
+| RV | CTA falado e escrito, com quadro final |
+| RV | Destaque visual a cada 2–4 s |
+| RV | Música sob a voz, sem competir |
+| AC | Concisão: a tabela de cenas da seção 4 mapeia cada trecho a uma função; trecho sem função é cortado ou justificado por escrito |
+| AC | Cada RV acima com ao menos um critério observável (por exemplo, `verificar_zonas.mjs` com 0 erros e `check` das 4 zonas sem erro; `pausas.mjs` com `max-pausa 0.3`) |
+
+4. Passe os itens do checklist de conformidade do playbook para a seção 8 como pendências a validar com o cliente.
+
+## Na execução (chamada pelo `$easyedit-build`)
+
+Ordem de trabalho:
+
+1. `$easyedit-takes` quando houver mais de um arquivo bruto.
+2. `$easyedit-ritmo` com `--max-pausa 0.3`.
+3. `$easyedit-destaques` com densidade de 2–4 s, e aprovação do plano.
+4. `$easyedit-split-broll` para a base da tela dividida; `$easyedit-legendas` para a legenda.
+5. Áudio (`/hyperframes-audio`): voz clara, música baixa, ducking.
+6. `$easyedit-zonas-seguras` (as três verificações): `check --caption-zone` ×4 sem erro, `elementos.json` completo e `verificar_zonas.mjs` sobre um render `-q draft` com **0 erros** (rostos, logo, produto, CTA e texto dentro da área útil) e avisos avaliados nos quadros anotados.
+7. Renderize `<slug>-hookA-v1.mp4` (e as demais variantes), `-q delivery`, 30 fps. Confira com `ffprobe`.
+8. Verifique os AC da vertical um a um e registre as evidências; diga o que não foi possível verificar.
+
+## Limites
+
+- Os padrões numéricos são ponto de partida; calibre com resultado de campanha e registre a mudança.
+- O checklist de conformidade é alerta. Quem decide a publicação é a pessoa e o cliente.