@aksp/opencrew 1.7.1 → 1.9.0

package/templates/_opencrew/core/scripts/entrega/longas.mjs

@@ -0,0 +1,109 @@
+// Peças que o leitor do verificador não lê: blog (`seo.txt` e `artigo.md`), e-mail (assunto,
+// prévia e corpo), mensagem de WhatsApp e os tweets de uma thread (`TWEET n/N`).
+// Recebem o texto do arquivo, sem BOM e com LF. Spec: fase-u3a1-pasta-de-entrega.md, §4.
+import { lerFrontmatter, semAcento, semFrontmatter } from '../verificar/leitura.mjs';
+import { lerPecas } from '../verificar/pecas.mjs';
+import { rotuloDe } from '../verificar/secoes.mjs';
+import { fecharMd, paraColar, secoesDeRotulo, semServico } from './texto.mjs';
+
+const parte = (nome, ext, texto) => ({ nome, sufixo: '', ext, tipo: nome, texto });
+const TITULO = /^#{1,6}\s+(.*)$/s;
+const palavra = (formas) => new RegExp(`(?<![\\p{L}\\p{N}])(?:${formas})(?![\\p{L}\\p{N}])`, 'u');
+
+// ── Blog ─────────────────────────────────────────────────────────────────────────────────────
+const FORA_DO_ARTIGO = new Set(['TITLE', 'TITLE TAG', 'META DESCRIPTION', 'TARGET KEYWORD']);
+const emUmaLinha = (valor) => String(valor).replace(/\s+/g, ' ').trim();
+
+/** Palavra-chave: do frontmatter; senão, o que vem depois de `Primary:` em `=== TARGET KEYWORD ===`. */
+function palavraChave(fm, secoes) {
+  const doRotulo = secoes.find((s) => s.rotulo === 'TARGET KEYWORD')?.texto.match(/Primary:[ \t]*([^|\n]+)/i)?.[1];
+  return [fm.palavra_chave, fm.keyword, doRotulo].find((v) => v != null && typeof v !== 'object' && String(v).trim());
+}
+
+/** @returns {object[]} uma unidade com `seo.txt` (só as linhas que existem) e `artigo.md` */
+export function pecasDoBlog(texto, formato) {
+  const fm = lerFrontmatter(texto) ?? {};
+  const secoes = secoesDeRotulo(semServico(semFrontmatter(texto)));
+  const lida = (tipo) => lerPecas(texto, formato).find((p) => p.tipo === tipo)?.texto;
+  const campos = [['Título', lida('titulo')], ['Meta description', lida('meta')], ['Palavra-chave', palavraChave(fm, secoes)], ['Slug', typeof fm.slug === 'object' ? null : fm.slug]];
+  const seo = campos.filter(([, v]) => v != null && emUmaLinha(v)).map(([campo, v]) => `${campo}: ${emUmaLinha(v)}\n`).join('');
+  const artigo = secoes.filter((s) => !FORA_DO_ARTIGO.has(s.rotulo) && s.texto).map((s) => s.texto).join('\n\n');
+  return [{ tipo: 'blog', partes: [parte('seo', 'txt', seo), parte('artigo', 'md', fecharMd(artigo))] }];
+}
+
+// ── E-mail ───────────────────────────────────────────────────────────────────────────────────
+const DO_ROTULO = { 'SUBJECT LINE': 'assunto', 'PREVIEW TEXT': 'previa' };
+const DO_CABECALHO = [['assunto', palavra('assuntos?|subject')], ['previa', palavra('previas?|preview')], ['corpo', /^(?:corpo|body)(?![\p{L}\p{N}])/u]];
+
+/** O que a linha abre: assunto, prévia ou corpo (linha de rótulo ou cabeçalho que nomeia); senão null. */
+function papelDaLinha(linha) {
+  const rotulo = rotuloDe(linha);
+  if (rotulo) return DO_ROTULO[rotulo] ?? 'corpo';
+  const h = linha.match(TITULO);
+  return h ? DO_CABECALHO.find(([, rx]) => rx.test(semAcento(h[1]).trim()))?.[0] ?? null : null;
+}
+
+/** Tira do fim das linhas o cabeçalho que vem logo antes de um assunto: é o título do bloco. */
+function tituloPendente(linhas) {
+  let fim = linhas.length;
+  while (fim && !linhas[fim - 1].trim()) fim--;
+  const h = fim ? linhas[fim - 1].match(TITULO) : null;
+  if (!h) return null;
+  linhas.length = fim - 1;
+  return h[1].trim();
+}
+
+/** Os e-mails do corpo, na ordem: cada assunto abre um. `[{ titulo, assunto, previa, corpo }]` (linhas). */
+function lerEmails(corpo) {
+  const novo = () => ({ titulo: null, assunto: [], previa: [], corpo: [] });
+  const emails = [novo()];
+  let alvo = 'corpo';
+  for (const linha of corpo.split('\n')) {
+    const papel = papelDaLinha(linha);
+    if (papel === 'assunto') {
+      const titulo = tituloPendente(emails.at(-1).corpo);
+      if (emails.at(-1).assunto.length) emails.push(novo());
+      emails.at(-1).titulo = titulo;
+    }
+    if (papel) alvo = papel;
+    else if (TITULO.test(linha) && alvo !== 'corpo') alvo = 'corpo'; // outro cabeçalho: é conteúdo
+    if (!papel) emails.at(-1)[alvo].push(linha);
+  }
+  return emails;
+}
+
+/** @returns {object[]} uma unidade por e-mail, com `assunto.txt`, `previa.txt` e `corpo.md` */
+export function pecasDoEmail(texto) {
+  const emails = lerEmails(semServico(semFrontmatter(texto)));
+  return emails.map((e) => ({
+    tipo: 'email',
+    titulo: e.titulo,
+    partes: [
+      parte('assunto', 'txt', paraColar(e.assunto.join('\n'))),
+      parte('previa', 'txt', paraColar(e.previa.join('\n'))),
+      parte('corpo', 'md', fecharMd(e.corpo.join('\n'))),
+    ],
+  }));
+}
+
+// ── WhatsApp ─────────────────────────────────────────────────────────────────────────────────
+/** @returns {object[]} uma unidade: os textos das seções, na ordem, separados por uma linha em branco */
+export function pecasDoWhatsapp(texto) {
+  const textos = secoesDeRotulo(semServico(semFrontmatter(texto))).map((s) => s.texto).filter(Boolean);
+  return [{ tipo: 'mensagem', partes: [parte('mensagem', 'txt', paraColar(textos.join('\n\n'), { whatsapp: true }))] }];
+}
+
+// ── Thread ───────────────────────────────────────────────────────────────────────────────────
+const TWEET_N = /^[\s*_#>-]{0,8}TWEET\s{1,3}\d{1,3}\s{0,3}\/\s{0,3}(?:\d{1,3}|N)(?![\p{L}\p{N}])/iu;
+
+/** Texto de cada bloco iniciado por `TWEET n/N` (sem essa linha), até o próximo bloco, rótulo ou cabeçalho. */
+export function tweetsDaThread(corpo) {
+  const blocos = [];
+  let atual = null;
+  for (const linha of corpo.split('\n')) {
+    if (TWEET_N.test(linha)) blocos.push((atual = []));
+    else if (rotuloDe(linha) || TITULO.test(linha)) atual = null;
+    else atual?.push(linha);
+  }
+  return blocos.map((b) => b.join('\n').trim()).filter(Boolean);
+}

package/templates/_opencrew/core/scripts/entrega/nomes.mjs

@@ -0,0 +1,78 @@
+// Nome de cada arquivo da entrega: peças do mesmo tipo no mesmo canal são numeradas; cópia cujo
+// nome já existe na pasta ganha o prefixo `2-`, `3-`. Nenhum arquivo é gravado por cima de outro.
+// Spec: fase-u3a-entrega-por-canal.md, regras 7 e 8, citadas pela fatia 1 (repositório do OpenCrew).
+
+export const MSG = {
+  mesmoNome: (arquivo, novo) => `${arquivo} tem o mesmo nome de outro e foi guardado como ${novo}.`,
+};
+
+const chave = (pasta, nome) => `${pasta}/${nome.toLowerCase()}`;
+
+/** Arquivos das unidades: `post.txt` quando há uma só no canal; `post-1.txt`, `post-1-comentario.txt`… com várias. */
+function nomearUnidades(unidades) {
+  const total = {};
+  for (const u of unidades) total[`${u.pasta}|${u.tipo}`] = (total[`${u.pasta}|${u.tipo}`] ?? 0) + 1;
+  const vez = {};
+  return unidades.flatMap((u) => {
+    const grupo = `${u.pasta}|${u.tipo}`;
+    vez[grupo] = (vez[grupo] ?? 0) + 1;
+    const numero = total[grupo] > 1 ? `-${vez[grupo]}` : '';
+    return u.partes.map((parte) => ({
+      pasta: u.pasta, nome: `${parte.nome}${numero}${parte.sufixo}.${parte.ext}`, tipo: parte.tipo, texto: parte.texto,
+      origem: u.origem, formato: u.formato, titulo: numero ? u.titulo ?? null : null, numerado: Boolean(numero), ordem: u.ordem, total: u.total,
+    }));
+  });
+}
+
+/** Cópias agrupadas por pasta da entrega e, dentro dela, por pasta de origem, na ordem da lista. */
+function grupos(copias) {
+  const porChave = new Map();
+  for (const c of copias) {
+    const id = `${c.pasta}|${c.pastaDeOrigem}`;
+    if (!porChave.has(id)) porChave.set(id, { pasta: c.pasta, copias: [] });
+    // O mesmo arquivo listado duas vezes para a mesma pasta é uma cópia só.
+    if (!porChave.get(id).copias.some((outra) => outra.nome === c.nome)) porChave.get(id).copias.push(c);
+  }
+  return [...porChave.values()];
+}
+
+/** O menor prefixo, a partir de `n-`, com que nenhum nome do grupo bate com um nome já usado. */
+function prefixoLivre(grupo, usados, n) {
+  while (grupo.copias.some((c) => usados.has(chave(grupo.pasta, `${n}-${c.nome}`)))) n += 1;
+  return n;
+}
+
+/**
+ * Cópias com o nome original. Quando um arquivo chegaria a uma pasta onde já há outro com esse
+ * nome, todos os que vêm da mesma pasta de origem ganham o prefixo (`2-`; os da pasta seguinte,
+ * `3-`). O aviso sai para cada arquivo cujo nome batia.
+ */
+function nomearCopias(copias, usados) {
+  const arquivos = [];
+  const avisos = [];
+  const proximo = {};
+  for (const grupo of grupos(copias)) {
+    const bate = (c) => usados.has(chave(grupo.pasta, c.nome));
+    const n = grupo.copias.some(bate) ? prefixoLivre(grupo, usados, proximo[grupo.pasta] ?? 2) : null;
+    if (n) proximo[grupo.pasta] = n + 1;
+    for (const c of grupo.copias) {
+      const nome = n ? `${n}-${c.nome}` : c.nome;
+      if (n && bate(c)) avisos.push({ pasta: c.pasta, texto: MSG.mesmoNome(c.origem, nome) });
+      arquivos.push({ ...c, nome });
+    }
+    for (const a of arquivos.slice(-grupo.copias.length)) usados.add(chave(a.pasta, a.nome));
+  }
+  return { arquivos, avisos };
+}
+
+/**
+ * @param {{ unidades: object[], copias: object[], avisos: object[] }} produtos o que `separar` devolve
+ * @returns {{ arquivos: object[], avisos: object[] }} `arquivos`: `{ pasta, nome, tipo, origem,
+ *   texto | de, … }`, na ordem da lista (as peças antes das cópias), sem dois com o mesmo caminho
+ */
+export function nomear({ unidades, copias, avisos }) {
+  const gerados = nomearUnidades(unidades);
+  const usados = new Set(gerados.map((a) => chave(a.pasta, a.nome)));
+  const copiados = nomearCopias(copias, usados);
+  return { arquivos: [...gerados, ...copiados.arquivos], avisos: [...avisos, ...copiados.avisos] };
+}

package/templates/_opencrew/core/scripts/entrega/passos.mjs

@@ -0,0 +1,104 @@
+// Os passos de cada canal no LEIA-ME: o quadro "Passos por canal" da spec, guardado como dado.
+// O texto é literal (aprovado com a spec): não reescreva aqui sem mudar a spec.
+// Specs: fase-u3a1-pasta-de-entrega.md, §4, e fase-u3a2-entrega-no-projeto.md, §4 (o primeiro
+// passo do canal com ressalva), no repositório do OpenCrew.
+
+/** O primeiro passo do canal que não está pronto (ajuste da execução real). */
+export const ANTES_DE_POSTAR = 'Antes de postar, resolva o que está em Pendências. Corrija no arquivo de origem e peça para montar a entrega de novo: o que você mudar nesta pasta se perde.';
+/** O primeiro passo do canal entregue com ressalva. */
+export const CONFIRA_AS_RESSALVAS = 'Antes de postar, confira as ressalvas em "Antes de usar".';
+const MARKDOWN = 'Este texto está em markdown: se o seu editor não aceitar, ajuste títulos, negrito e links depois de colar.';
+
+// Cada passo: [o que o faz aparecer, o texto]. null = sempre que o canal tem arquivo; um tipo de
+// arquivo = só quando a entrega tem arquivo desse tipo no canal; `tipo:um` e `tipo:varios` = só
+// quando a peça é uma só, ou quando é numerada. `{arquivo}`: uma linha por arquivo. `{campos}`:
+// os campos que o `seo.txt` daquela entrega tem.
+const PASSOS = {
+  instagram: [
+    [null, 'No computador, abra instagram.com e comece uma publicação nova. Pelo celular, mande os arquivos para ele antes.'],
+    ['imagem', 'Escolha as imagens na ordem dos nomes dos arquivos.'],
+    ['legenda', 'Abra `instagram/legenda.txt`, copie tudo e cole no campo da legenda. As hashtags já estão no fim.'],
+    [null, 'Confira a prévia e publique.'],
+    ['texto', '`instagram/{arquivo}` é para ler e produzir (gravar ou montar os slides): não é texto para colar.'],
+  ],
+  linkedin: [
+    [null, 'No computador, abra linkedin.com e comece uma publicação.'],
+    ['post', 'Abra `linkedin/post.txt`, copie tudo e cole.'],
+    ['imagem', 'Anexe as imagens na ordem dos nomes dos arquivos.'],
+    [null, 'Confira e publique.'],
+    ['comentario', 'Depois de publicar, abra `linkedin/post-comentario.txt`, copie e cole como primeiro comentário.'],
+    ['roteiro', 'Para o artigo, escolha escrever um artigo no LinkedIn e cole o texto de `linkedin/{arquivo}`, seção por seção.'],
+  ],
+  blog: [
+    [null, 'Abra o editor do seu blog e crie um post novo.'],
+    ['seo', 'Abra `blog/seo.txt` e copie cada linha para o campo de mesmo nome ({campos}).'],
+    ['artigo', 'Abra `blog/artigo.md`, copie tudo e cole no corpo do post.'],
+    ['artigo', MARKDOWN],
+    [null, 'Confira a prévia e publique.'],
+  ],
+  email: [
+    [null, 'Abra a sua ferramenta de e-mail e crie uma mensagem nova.'],
+    ['assunto', 'Copie o texto de `email/assunto.txt` para o campo do assunto.'],
+    ['previa', 'Copie o texto de `email/previa.txt` para o campo de prévia (a linha que aparece ao lado do assunto).'],
+    ['corpo', 'Abra `email/corpo.md`, copie tudo e cole no corpo.'],
+    ['corpo', MARKDOWN],
+    [null, 'Envie um teste para você antes de enviar para a lista.'],
+  ],
+  whatsapp: [
+    [null, 'No computador, abra o WhatsApp Web ou o aplicativo. Pelo celular, mande o arquivo para ele antes.'],
+    ['mensagem', 'Abra `whatsapp/mensagem.txt`, copie tudo e cole na conversa ou na lista de transmissão.'],
+    [null, 'Se o texto tiver `{{…}}`, troque pelo dado real, ou confira se a sua ferramenta de envio faz a troca.'],
+    [null, 'Envie primeiro para você, para ver como ficou.'],
+  ],
+  twitter: [
+    [null, 'No computador, abra x.com e comece uma publicação.'],
+    ['tweet:um', 'Abra `twitter/tweet.txt`, copie tudo e cole.'],
+    ['tweet:varios', 'Para a sequência, cole `twitter/tweet-1.txt`, acrescente outra publicação e cole o arquivo seguinte, na ordem dos números.'],
+    ['imagem', 'Anexe as imagens.'],
+    [null, 'Confira e publique.'],
+  ],
+  youtube: [['roteiro', '`youtube/{arquivo}` é o roteiro para gravar: não é texto para colar.']],
+};
+// "texto": o roteiro e o arquivo que foi inteiro (carrossel em texto, peça não encontrada).
+const TIPOS = { texto: ['roteiro', 'inteiro'] };
+
+/** Com várias peças, o passo cita os arquivos numerados no lugar do nome sem número. */
+function citar(texto, pasta, achados) {
+  if (!achados[0].numerado) return texto;
+  const lista = achados.map((a) => `\`${pasta}/${a.nome}\``).join(', ');
+  return texto.replace(new RegExp(`\`${pasta}/[^\`]+\``), lista);
+}
+
+/** Os campos que os arquivos têm (`Título: …` → "título"), cada um uma vez, na ordem das linhas. */
+function camposDe(achados) {
+  const linhas = achados.flatMap((a) => (a.texto ?? '').split('\n')).filter((l) => l.includes(':'));
+  return [...new Set(linhas.map((l) => l.slice(0, l.indexOf(':')).toLowerCase()))].join(', ');
+}
+
+/** Os passos do quadro, só os que citam arquivo que existe nesse canal, na ordem do quadro. */
+function doQuadro(pasta, arquivos) {
+  if (!arquivos.length) return [];
+  return (PASSOS[pasta] ?? []).flatMap(([condicao, texto]) => {
+    if (!condicao) return [texto];
+    const [tipo, quantos] = condicao.split(':');
+    const achados = arquivos.filter((a) => (TIPOS[tipo] ?? [tipo]).includes(a.tipo));
+    if (!achados.length) return [];
+    if (quantos) return Boolean(achados[0].numerado) === (quantos === 'varios') ? [texto] : [];
+    if (texto.includes('{arquivo}')) return achados.map((a) => texto.replace('{arquivo}', a.nome));
+    return [citar(texto, pasta, achados).replace('{campos}', camposDe(achados))];
+  });
+}
+
+/**
+ * Os passos de um canal. No canal que não está pronto, o primeiro manda resolver as pendências; no
+ * que foi entregue com ressalva, manda conferir as ressalvas.
+ * @param {string} pasta a pasta do canal
+ * @param {object[]} arquivos os arquivos da entrega nessa pasta: `{ nome, tipo, numerado, texto }`
+ * @param {boolean} [comPendencia] o canal tem pendência · @param {boolean} [comRessalva] tem ressalva
+ * @returns {string[]}
+ */
+export function passosDe(pasta, arquivos, comPendencia = false, comRessalva = false) {
+  const passos = doQuadro(pasta, arquivos);
+  const antes = comPendencia ? ANTES_DE_POSTAR : comRessalva ? CONFIRA_AS_RESSALVAS : null;
+  return antes && passos.length ? [antes, ...passos] : passos;
+}

package/templates/_opencrew/core/scripts/entrega/pendencias.mjs

@@ -0,0 +1,97 @@
+// O que a verificação diz da entrega: as pendências de cada canal (bloqueio, [PREENCHER], item
+// que não existe), o que não foi conferido e o alerta de tamanho do texto entregue.
+// Specs: fase-u3a1-pasta-de-entrega.md, regras 17, 19, 20 e 34, e fase-u3a2-entrega-no-projeto.md,
+// regra 18: a chave de cada pendência, que a faz virar ressalva (repositório do OpenCrew).
+import path from 'node:path';
+import { lerLimites } from '../verificar/leitura.mjs';
+import { contar, FALTA_INFO, NAO_MEDIDO, NAO_VERIFICADO } from '../verificar/regras.mjs';
+import { OUTROS, nomeDaPasta } from './canais.mjs';
+
+export const MSG = {
+  naoEncontrei: (arquivo) => `Não encontrei ${arquivo}.`,
+  naoPronto: (canal, n) => `${canal} não está pronto: ${n} ${n === 1 ? 'pendência' : 'pendências'}.`,
+  alerta: (arquivo, n, limite) => `ALERTA: \`${arquivo}\` tem ${n} caracteres; o limite é ${limite}. Encurte antes de publicar.`,
+};
+/** A lista fixa do que o script nunca confere. */
+export const NUNCA_CONFERIDO = ['Links e fatos citados no texto.', 'Texto dentro das imagens.', 'Aparência final em cada rede.'];
+
+const ehNaoMedido = (i) => i.item === NAO_MEDIDO || i.item === NAO_VERIFICADO;
+const origem = (arquivo) => `origem: \`${arquivo}\``;
+
+/** Uma linha de pendência ou de alerta, com o trecho (ou a medida) e o arquivo de origem. */
+function linhaDoItem(i, arquivo) {
+  if (i.item === FALTA_INFO) return `Falta preencher "${i.detalhe}" — ${origem(arquivo)}`;
+  if (ehNaoMedido(i)) return `${i.item} — ${i.detalhe} — ${origem(arquivo)}`;
+  if (i.medido != null) return `${i.item}: ${i.medido} (${i.minimo ? 'mínimo' : 'limite'} ${i.limite}) — ${origem(arquivo)}`;
+  return `${i.item}: "${i.detalhe}" — ${origem(arquivo)}`;
+}
+
+/** O resultado do verificador para um item da lista (só os arquivos de texto têm). */
+const resultadoDe = (raiz, r, item) => r.arquivos.find((a) => path.resolve(raiz, a.arquivo) === item.abs && (a.formato ?? null) === (item.formato ?? null));
+
+/** A pendência de um bloqueio: a linha, a chave que a identifica e, em [PREENCHER], o trecho pedido. */
+function doBloqueio(i, arquivo) {
+  const trecho = i.medido != null ? `${i.medido}/${i.limite}` : String(i.detalhe ?? '');
+  return { linha: linhaDoItem(i, arquivo), chave: { arquivo, item: i.item, trecho }, preencher: i.item === FALTA_INFO ? i.detalhe : null };
+}
+
+/**
+ * Pendências por pasta da entrega (canal ou `outros`), na ordem da lista.
+ * @returns {Map<string, object[]>} só as pastas que têm pendência: `{ linha, chave, preencher }` —
+ *   `chave`: `{ arquivo, item, trecho }` (em bloqueio de medida, o trecho é `medido/limite`); null
+ *   no arquivo que não existe, que nunca vira ressalva
+ */
+export function pendenciasPorPasta(raiz, itens, r) {
+  const mapa = new Map();
+  const somar = (item, p) => mapa.set(item.canal ?? OUTROS, [...(mapa.get(item.canal ?? OUTROS) ?? []), p]);
+  for (const item of itens) {
+    if (item.tipo !== 'arquivo') somar(item, { linha: MSG.naoEncontrei(item.rel), chave: null, preencher: null });
+    for (const i of resultadoDe(raiz, r, item)?.itens ?? []) if (i.nivel === 'bloqueio') somar(item, doBloqueio(i, item.rel));
+  }
+  return mapa;
+}
+
+/** As frases "{canal} não está pronto: {n} pendências.", na ordem das pastas dadas. */
+export const frasesDePendencia = (pastas, pendencias) => pastas.filter((p) => pendencias.has(p)).map((p) => MSG.naoPronto(nomeDaPasta(p), pendencias.get(p).length));
+
+/** O que não foi conferido: alertas, "não medido", "não verificado" e a lista fixa. Não muda o final. */
+export function naoConferido(raiz, itens, r) {
+  const linhas = [];
+  for (const item of itens.filter((i) => i.tipo === 'arquivo')) {
+    for (const i of resultadoDe(raiz, r, item)?.itens ?? []) {
+      if (i.nivel === 'alerta' || ehNaoMedido(i)) linhas.push(linhaDoItem(i, item.rel));
+    }
+  }
+  if (r.naoTexto.length) linhas.push(`${NAO_VERIFICADO} — não é texto: ${r.naoTexto.join(', ')}`);
+  return [...linhas, ...NUNCA_CONFERIDO];
+}
+
+const LIMITE = { legenda: 'caption_max_chars', post: 'post_max_chars', tweet: 'tweet_max_chars' };
+const NOME_NO_RELATORIO = { legenda: 'Legenda Instagram', post: 'Post LinkedIn', tweet: 'Tweet' };
+const NUMERADA = { legenda: 'legenda', post: 'post', tweet: 'Tweet' };
+
+/** O verificador já bloqueou, no arquivo de origem, o tamanho desta mesma peça? */
+function jaApontada(itensDaOrigem, a) {
+  const doTipo = itensDaOrigem.filter((i) => i.nivel === 'bloqueio' && i.item.startsWith(NOME_NO_RELATORIO[a.tipo]) && i.item.endsWith('caracteres'));
+  if (a.total < 2) return doTipo.length > 0;
+  const numero = new RegExp(`${NUMERADA[a.tipo]} ${a.ordem}(?!\\d)`);
+  return doTipo.some((i) => numero.test(i.item));
+}
+
+/**
+ * Regra 34: cada `legenda*.txt`, `post*.txt` (não o comentário) e `tweet*.txt` gerado é contado
+ * como o verificador conta e comparado com o limite do formato do item. Passou: um ALERTA — mas
+ * só quando o verificador não apontou a mesma peça. Não é pendência.
+ * @returns {Promise<{ pasta: string, texto: string }[]>}
+ */
+export async function alertasDeTamanho(raiz, itens, arquivos, r) {
+  const alertas = [];
+  for (const a of arquivos.filter((x) => LIMITE[x.tipo] && x.texto)) {
+    const limite = (await lerLimites(raiz, a.formato)).limites?.[LIMITE[a.tipo]];
+    const medido = contar(a.texto);
+    const item = itens.find((i) => i.rel === a.origem && i.formato === a.formato);
+    const daOrigem = (item && resultadoDe(raiz, r, item)?.itens) ?? [];
+    if (typeof limite === 'number' && medido > limite && !jaApontada(daOrigem, a)) alertas.push({ pasta: a.pasta, texto: MSG.alerta(`${a.pasta}/${a.nome}`, medido, limite) });
+  }
+  return alertas;
+}

package/templates/_opencrew/core/scripts/entrega/ressalvas.mjs

@@ -0,0 +1,78 @@
+// Ressalvas: as pendências que o usuário aceitou ("entregar assim mesmo"). Ficam em
+// `crews/<crew>/output/<run>/ressalvas.json` e valem para as entregas seguintes da execução,
+// enquanto a pendência existir sem interrupção (mesmo arquivo de origem, item e trecho): a cada
+// entrega o arquivo é regravado só com as que ainda valem, e a pendência que some e volta é nova.
+// Spec: fase-u3a2-entrega-no-projeto.md, §4 e regras 18 e 19 (repositório do OpenCrew).
+import { promises as fs } from 'node:fs';
+import path from 'node:path';
+
+export const ARQUIVO = 'ressalvas.json';
+export const MSG = {
+  ilegivel: (arquivo) => `Não consegui ler ${arquivo}. Segui sem ele.`,
+  nova: (item) => `Há pendência nova, que você ainda não aceitou: ${item}.`,
+};
+
+const CAMPOS = ['arquivo', 'item', 'trecho'];
+const ehRessalva = (r) => r != null && typeof r === 'object' && CAMPOS.every((c) => typeof r[c] === 'string');
+const mesma = (a, b) => CAMPOS.every((c) => a[c] === b[c]);
+
+/**
+ * As ressalvas já aceitas nesta execução. Arquivo que não existe: nenhuma. Arquivo que não é o
+ * JSON esperado vale como vazio, com `ilegivel: true` (o resumo avisa); ele não é apagado.
+ * @returns {Promise<{ aceitas: object[], ilegivel: boolean }>} `aceitas`: `{ arquivo, item, trecho }`
+ */
+export async function lerRessalvas(execucao) {
+  let texto;
+  try {
+    texto = await fs.readFile(path.join(execucao, ARQUIVO), 'utf8');
+  } catch (erro) {
+    return { aceitas: [], ilegivel: erro.code !== 'ENOENT' };
+  }
+  try {
+    const lista = JSON.parse(texto)?.ressalvas;
+    if (Array.isArray(lista) && lista.every(ehRessalva)) return { aceitas: lista, ilegivel: false };
+  } catch { /* não é JSON: cai no retorno abaixo */ }
+  return { aceitas: [], ilegivel: true };
+}
+
+/**
+ * Separa as pendências em aceitas (ressalvas) e não aceitas. Pendência sem chave (arquivo que não
+ * existe) nunca é aceita.
+ * @param {Map<string, object[]>} todas por pasta: `{ linha, chave, preencher }`
+ * @param {object[]} aceitas o que `lerRessalvas` leu · @param {boolean} aceitarTudo `--aceitar-pendencias`
+ * @returns {{ pendencias: Map<string, string[]>, ressalvas: Map<string, object[]>, novas: string[] }}
+ *   `novas`: o aviso de cada pendência que apareceu depois de um aceite
+ */
+export function separarPendencias(todas, aceitas, aceitarTudo) {
+  const [pendencias, ressalvas, novas] = [new Map(), new Map(), new Set()];
+  const somar = (mapa, pasta, valor) => mapa.set(pasta, [...(mapa.get(pasta) ?? []), valor]);
+  for (const [pasta, lista] of todas) {
+    for (const p of lista) {
+      const aceita = Boolean(p.chave) && (aceitarTudo || aceitas.some((a) => mesma(a, p.chave)));
+      if (aceita) somar(ressalvas, pasta, p);
+      else somar(pendencias, pasta, p.linha);
+      if (!aceita && p.chave && aceitas.length) novas.add(MSG.nova(p.chave.item));
+    }
+  }
+  return { pendencias, ressalvas, novas: [...novas] };
+}
+
+/**
+ * Regrava `ressalvas.json` com as ressalvas deste momento: a que não corresponde mais a uma
+ * pendência sai. Sem nenhuma, o arquivo que existe fica com a lista vazia e o que não existe não é
+ * criado; com o mesmo conteúdo, nada é gravado.
+ * @returns {Promise<string|null>} null quando está gravado; senão, o arquivo que não foi gravado
+ */
+export async function gravarRessalvas(execucao, ressalvas) {
+  const lista = [...ressalvas.values()].flat().map((r) => r.chave);
+  const arquivo = path.join(execucao, ARQUIVO);
+  const texto = `${JSON.stringify({ ressalvas: lista }, null, 2)}\n`;
+  try {
+    const atual = await fs.readFile(arquivo, 'utf8').catch(() => null);
+    if (atual == null && !lista.length) return null;
+    if (atual !== texto) await fs.writeFile(arquivo, texto, 'utf8');
+    return null;
+  } catch {
+    return arquivo;
+  }
+}

package/templates/_opencrew/core/scripts/entrega/resumo.mjs

@@ -0,0 +1,29 @@
+// O resumo que o `entregar.mjs` mostra na tela: a pasta, a situação de cada canal, o que falta, os
+// avisos, a cópia e o LEIA-ME. O runner mostra essas linhas ao usuário como vieram.
+// Specs: fase-u3a1-pasta-de-entrega.md, §4, e fase-u3a2-entrega-no-projeto.md, §4 e §6 (a linha
+// `Cópia:` e a situação "Pronto, com ressalva"), no repositório do OpenCrew.
+import { CANAIS, OUTROS } from './canais.mjs';
+import { situacaoDe } from './leiame.mjs';
+import { frasesDePendencia } from './pendencias.mjs';
+
+/**
+ * @param {string} execucao a pasta da execução, relativa ao projeto
+ * @param {object} dados os dados da entrega (os do LEIA-ME)
+ * @param {string[]} notas o que sai em "Avisos:" antes dos avisos dos arquivos
+ * @param {string[]} daCopia as linhas da cópia (ou da gravação que falhou), antes da linha do LEIA-ME
+ * @returns {string[]} as linhas do resumo, sem a linha `ENTREGA:`
+ */
+export function resumo(execucao, dados, notas, daCopia) {
+  const { crew, run, pastas, pendencias, avisos, alertas } = dados;
+  const comPendencia = [...pastas, OUTROS].filter((p) => pendencias.has(p));
+  const avisar = [...alertas.map((a) => a.texto), ...notas, ...avisos.map((a) => a.tela ?? a.texto)];
+  return [
+    `Entrega da execução ${run} da crew ${crew}`,
+    `Pasta: ${execucao}/entrega`,
+    ...pastas.map((p) => `- ${CANAIS[p]}: ${situacaoDe(dados, p)}`),
+    ...frasesDePendencia(comPendencia, pendencias).flatMap((frase, i) => [frase, ...pendencias.get(comPendencia[i]).map((l) => `- ${l}`)]),
+    ...(avisar.length ? ['Avisos:', ...avisar.map((l) => `- ${l}`)] : []),
+    ...daCopia,
+    `LEIA-ME: ${execucao}/entrega/LEIA-ME.md`,
+  ];
+}

package/templates/_opencrew/core/scripts/entrega/retrato.mjs

@@ -0,0 +1,42 @@
+// O retrato da cópia: o que o script copiou para cada pasta de cópia (caminho → hash), guardado em
+// `crews/<crew>/output/<run>/copia.json`. É com ele que a entrega seguinte é comparada: assim, o
+// que o usuário editar na cópia nunca vira "a entrega mudou". Arquivo de serviço do script.
+// Spec: fase-u3a2-entrega-no-projeto.md, regra 14 (repositório do OpenCrew).
+import { promises as fs } from 'node:fs';
+import path from 'node:path';
+
+export const ARQUIVO = 'copia.json';
+
+const ehObjeto = (v) => v != null && typeof v === 'object' && !Array.isArray(v);
+const ehRetrato = (v) => ehObjeto(v) && Object.values(v).every((hash) => typeof hash === 'string');
+
+/**
+ * Os retratos desta execução, por pasta de cópia (relativa ao projeto, com `/`). Arquivo que não
+ * existe (cópia feita por versão anterior) ou que não é o JSON esperado: nenhum retrato — a
+ * comparação volta a ser com os arquivos da pasta.
+ * @returns {Promise<Record<string, Record<string, string>>>}
+ */
+export async function lerRetratos(execucao) {
+  try {
+    const copias = JSON.parse(await fs.readFile(path.join(execucao, ARQUIVO), 'utf8'))?.copias;
+    return ehObjeto(copias) && Object.values(copias).every(ehRetrato) ? copias : {};
+  } catch {
+    return {};
+  }
+}
+
+/**
+ * Regrava `copia.json` com os retratos dados; com o mesmo conteúdo, nada é gravado.
+ * @returns {Promise<string|null>} null quando está gravado; senão, o arquivo que não foi gravado
+ */
+export async function gravarRetratos(execucao, copias) {
+  const arquivo = path.join(execucao, ARQUIVO);
+  const texto = `${JSON.stringify({ copias }, null, 2)}\n`;
+  try {
+    const atual = await fs.readFile(arquivo, 'utf8').catch(() => null);
+    if (atual !== texto) await fs.writeFile(arquivo, texto, 'utf8');
+    return null;
+  } catch {
+    return arquivo;
+  }
+}

package/templates/_opencrew/core/scripts/entrega/separar.mjs

@@ -0,0 +1,106 @@
+// Separa os itens da lista em produtos da entrega: peças que viram arquivo próprio (unidades),
+// cópias com o nome original e avisos. Não escreve nada: quem grava é `gravar.mjs`.
+// Spec: fase-u3a1-pasta-de-entrega.md, §4 e regras 4, 8, 9 e 11 (repositório do OpenCrew). O
+// `doCanal` da cópia é da fase-u3a2-entrega-no-projeto.md, regra 14: o editável segue o canal dele.
+import path from 'node:path';
+import { lerItem } from '../verificar/arquivos.mjs';
+import { semFrontmatter } from '../verificar/leitura.mjs';
+import { EDITAVEIS, OUTROS } from './canais.mjs';
+import { avisoDeFora, blocosFora } from './fora.mjs';
+import { PRINCIPAL, hashtagsSoltas, pecasDoLeitor } from './leitor.mjs';
+import { pecasDoBlog, pecasDoEmail, pecasDoWhatsapp, tweetsDaThread } from './longas.mjs';
+import { emLf, fecharMd, paraColar, semServico } from './texto.mjs';
+
+export const MSG = {
+  // Só no resumo da tela: no LEIA-ME, a linha do arquivo em "Outros arquivos" já diz.
+  semCanal: (arquivo) => `${arquivo} não tem canal conhecido. Está em \`outros/\`.`,
+  semPeca: (peca, arquivo) => `Não encontrei ${peca} em ${arquivo}. Confira antes de colar.`,
+  legendaInteira: (arquivo) => `Não encontrei a legenda marcada em ${arquivo}: usei o texto inteiro. Confira antes de colar.`,
+  outroCanal: (arquivo, cabecalho) => `${arquivo} tem uma seção de outro canal (${cabecalho}) que não foi separada. Ela continua no arquivo de origem.`,
+};
+
+const IMAGEM = new Set(['.png', '.jpg', '.jpeg']);
+const HTML = new Set(['.html', '.htm']);
+const DITA = { legenda: 'a legenda', post: 'o post', tweet: 'o tweet', blog: 'o artigo', email: 'o e-mail', mensagem: 'a mensagem' };
+const LONGAS = {
+  'blog-post': ['blog', pecasDoBlog], 'blog-seo': ['blog', pecasDoBlog],
+  'email-newsletter': ['email', pecasDoEmail], 'email-sales': ['email', pecasDoEmail],
+  'whatsapp-broadcast': ['mensagem', pecasDoWhatsapp],
+};
+
+const extensao = (item) => path.extname(item.abs).toLowerCase();
+const semExtensao = (item) => item.abs.slice(0, item.abs.length - path.extname(item.abs).length).toLowerCase();
+const ehImagem = (item) => IMAGEM.has(extensao(item));
+
+/** HTML editável: tem na lista uma imagem de mesmo nome, na mesma pasta. */
+const ehEditavel = (item, itens) => HTML.has(extensao(item)) && itens.some((i) => i.tipo === 'arquivo' && ehImagem(i) && semExtensao(i) === semExtensao(item));
+
+/** Cópia com o nome original: `de` (os mesmos bytes do arquivo) ou `texto` (o corpo tratado). */
+function copia(item, pasta, tipo, texto = null) {
+  const base = { pasta, nome: path.basename(item.abs), tipo, origem: item.rel, pastaDeOrigem: path.dirname(item.abs), doCanal: item.canal ?? OUTROS };
+  return texto ? { ...base, texto } : { ...base, de: item.abs };
+}
+
+/** Tweets de uma thread escrita em blocos `TWEET n/N`; as hashtags soltas vão no fim do primeiro. */
+function daThread(corpo) {
+  const tweets = tweetsDaThread(corpo);
+  const soltas = tweets.length ? hashtagsSoltas(corpo) : [];
+  const unidades = tweets.map((t, i) => {
+    const texto = paraColar(i === 0 && soltas.length ? `${t}\n\n${soltas.join(' ')}` : t);
+    return { tipo: 'tweet', ordem: i + 1, total: tweets.length, partes: [{ nome: 'tweet', sufixo: '', ext: 'txt', tipo: 'tweet', texto }] };
+  });
+  return { unidades, temSlides: false, outros: [] };
+}
+
+/** As unidades de um arquivo de texto, pelo formato dele; `tipo`: a peça que não pode faltar; `fora`: os blocos que não entram. */
+function lerUnidades(texto, formato) {
+  if (LONGAS[formato]) return { tipo: LONGAS[formato][0], unidades: LONGAS[formato][1](texto, formato), temSlides: false, outros: [], fora: blocosFora(texto) };
+  const corpo = semServico(semFrontmatter(texto));
+  const thread = formato === 'twitter-thread' ? daThread(corpo) : null;
+  if (thread?.unidades.length) return { tipo: PRINCIPAL[formato], ...thread, fora: blocosFora(texto) };
+  return { tipo: PRINCIPAL[formato], ...pecasDoLeitor(corpo, formato), fora: blocosFora(texto, formato) };
+}
+
+/** Arquivo `.md` ou `.txt` de um formato com peças: as unidades, ou o arquivo inteiro, com aviso. */
+function separarPecas(item, texto, itens, p) {
+  const { tipo, unidades, temSlides, outros, fora } = lerUnidades(texto, item.formato);
+  const comArquivo = unidades.map((u) => ({ ...u, partes: u.partes.filter((parte) => parte.texto) })).filter((u) => u.partes.length);
+  for (const u of comArquivo) p.unidades.push({ ...u, pasta: item.canal, origem: item.rel, formato: item.formato });
+  if (comArquivo.some((u) => u.inteiro)) p.avisos.push({ pasta: item.canal, texto: MSG.legendaInteira(item.rel) });
+  for (const cabecalho of outros) p.avisos.push({ pasta: item.canal, texto: MSG.outroCanal(item.rel, cabecalho) });
+  const semImagem = !itens.some((i) => i.tipo === 'arquivo' && ehImagem(i) && i.formato === item.formato);
+  if (!comArquivo.length) p.avisos.push({ pasta: item.canal, texto: MSG.semPeca(DITA[tipo], item.rel) });
+  // O arquivo que vai inteiro leva todos os blocos: só há o que avisar quando ele não vai.
+  if (!comArquivo.length || (temSlides && semImagem)) p.copias.push(copia(item, item.canal, 'inteiro'));
+  else p.avisos.push(...avisoDeFora(item, fora));
+}
+
+/** Um item que existe → os produtos dele. */
+async function separarItem(item, itens, p) {
+  if (ehEditavel(item, itens)) return p.copias.push(copia(item, EDITAVEIS, 'editavel'));
+  if (!item.canal) {
+    p.avisos.push({ pasta: OUTROS, tela: MSG.semCanal(item.rel) });
+    return p.copias.push(copia(item, OUTROS, 'copia'));
+  }
+  const lido = ['.md', '.txt'].includes(extensao(item)) ? await lerItem(item.abs) : null;
+  if (lido?.tipo !== 'texto') return p.copias.push(copia(item, item.canal, ehImagem(item) ? 'imagem' : 'copia'));
+  const texto = emLf(lido.texto);
+  if (LONGAS[item.formato] || PRINCIPAL[item.formato]) return separarPecas(item, texto, itens, p);
+  // Roteiro ou artigo: o corpo, sem frontmatter e sem blocos de serviço; as linhas de rótulo ficam.
+  p.avisos.push(...avisoDeFora(item, blocosFora(texto)));
+  return p.copias.push(copia(item, item.canal, 'roteiro', fecharMd(semServico(semFrontmatter(texto)))));
+}
+
+/**
+ * @param {object[]} itens os itens da lista, já sem os arquivos de serviço:
+ *   `{ abs, rel, formato, canal, tipo }` (`tipo`: arquivo, pasta ou ausente)
+ * @returns {Promise<{ unidades: object[], copias: object[], avisos: object[] }>}
+ *   · `unidades`: `{ pasta, tipo, titulo, origem, formato, ordem, total, partes }`
+ *   · `copias`: `{ pasta, nome, tipo, origem, pastaDeOrigem, doCanal, de | texto }`
+ *   · `avisos`: `{ pasta, texto, tela }` (`tela`: o texto do resumo da tela; sem `texto`, só sai lá)
+ */
+export async function separar(itens) {
+  const produtos = { unidades: [], copias: [], avisos: [] };
+  for (const item of itens.filter((i) => i.tipo === 'arquivo')) await separarItem(item, itens, produtos);
+  return produtos;
+}