@aksp/opencrew 1.7.0 → 1.8.0

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

@@ -0,0 +1,99 @@
+// 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.
+// Spec: fase-u3a1-pasta-de-entrega.md, §4 (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.';
+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.
+ * @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
+ * @returns {string[]}
+ */
+export function passosDe(pasta, arquivos, comPendencia = false) {
+  const passos = doQuadro(pasta, arquivos);
+  return comPendencia && passos.length ? [ANTES_DE_POSTAR, ...passos] : passos;
+}

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

@@ -0,0 +1,87 @@
+// 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.
+// Spec: fase-u3a1-pasta-de-entrega.md, regras 17, 19, 20 e 34 (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));
+
+/**
+ * Pendências por pasta da entrega (canal ou `outros`), na ordem da lista.
+ * @returns {Map<string, string[]>} só as pastas que têm pendência
+ */
+export function pendenciasPorPasta(raiz, itens, r) {
+  const mapa = new Map();
+  const somar = (item, linha) => mapa.set(item.canal ?? OUTROS, [...(mapa.get(item.canal ?? OUTROS) ?? []), linha]);
+  for (const item of itens) {
+    if (item.tipo !== 'arquivo') somar(item, MSG.naoEncontrei(item.rel));
+    for (const i of resultadoDe(raiz, r, item)?.itens ?? []) if (i.nivel === 'bloqueio') somar(item, linhaDoItem(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.
+ */
+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(MSG.alerta(`${a.pasta}/${a.nome}`, medido, limite));
+  }
+  return alertas;
+}

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

@@ -0,0 +1,103 @@
+// 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).
+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.`,
+  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) };
+  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 });
+  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, 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;
+}

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

@@ -0,0 +1,95 @@
+// Texto da entrega: o que sai do markdown num arquivo para colar, o que é bloco de serviço e as
+// seções de rótulo de um corpo. As expressões rodam linha a linha, sobre texto do usuário.
+// Spec: fase-u3a-entrega-por-canal.md, regra 6, citada pela fatia 1 (repositório do OpenCrew).
+import { rotuloDe } from '../verificar/secoes.mjs';
+import { semBom } from '../verificar/leitura.mjs';
+
+/** Sem o BOM e com LF. */
+export const emLf = (texto) => semBom(texto).replace(/\r\n?/g, '\n');
+
+/** Texto em markdown que vai para um arquivo: aparado, com uma quebra de linha no fim. */
+export function fecharMd(texto) {
+  const aparado = texto.trim();
+  return aparado ? `${aparado}\n` : '';
+}
+
+/** Texto para colar: sem espaço no fim das linhas, sem linhas em branco seguidas, aparado. */
+export const fechar = (texto) => fecharMd(texto.replace(/[ \t]+$/gm, '').replace(/\n{3,}/g, '\n\n'));
+
+/** Sem os comentários HTML (`<!-- … -->`); o que não fecha fica como está. */
+export function semComentarios(texto) {
+  let saida = '';
+  let i = 0;
+  for (;;) {
+    const abre = texto.indexOf('<!--', i);
+    const fecha = abre < 0 ? -1 : texto.indexOf('-->', abre + 4);
+    if (fecha < 0) return saida + texto.slice(i);
+    saida += texto.slice(i, abre);
+    i = fecha + 3;
+  }
+}
+
+/** Rótulo de bloco de serviço: termina em `NOTES`, `NOTE` ou `CHECKLIST`, ou é `FORMAT`. */
+export const ehServico = (rotulo) => rotulo === 'FORMAT' || /(?:^|\s)(?:NOTES?|CHECKLIST)$/.test(rotulo);
+
+/**
+ * Corpo sem os blocos de serviço: os comentários HTML e as seções de rótulo de serviço, cada uma
+ * até o próximo rótulo. As outras linhas de rótulo ficam.
+ */
+export function semServico(corpo) {
+  const linhas = [];
+  let fora = false;
+  for (const linha of semComentarios(corpo).split('\n')) {
+    const rotulo = rotuloDe(linha);
+    if (rotulo) fora = ehServico(rotulo);
+    if (!fora) linhas.push(linha);
+  }
+  return linhas.join('\n');
+}
+
+/** As seções de rótulo de um corpo, na ordem: `[{ rotulo, texto }]`; antes do primeiro, `rotulo` null. */
+export function secoesDeRotulo(corpo) {
+  const secoes = [{ rotulo: null, linhas: [] }];
+  for (const linha of corpo.split('\n')) {
+    const rotulo = rotuloDe(linha);
+    if (rotulo) secoes.push({ rotulo, linhas: [] });
+    else secoes.at(-1).linhas.push(linha);
+  }
+  return secoes.map((s) => ({ rotulo: s.rotulo, texto: s.linhas.join('\n').trim() }));
+}
+
+// O que nunca perde marcador: URL, e-mail, @usuário e #hashtag. Fica guardado enquanto a linha é
+// limpa e volta depois, igual.
+const PROTEGIDO = /(?:https?:\/\/|www\.|wa\.me\/)[^\s*]+|[\p{L}\p{N}._%+-]+@[\p{L}\p{N}-]+(?:\.[\p{L}\p{N}-]+)+|(?<![\p{L}\p{N}_])[@#][\p{L}\p{N}_]+/gu;
+const [ABRE, FECHA] = [String.fromCharCode(0xe000), String.fromCharCode(0xe001)];
+const GUARDADO = new RegExp(`${ABRE}(\\d+)${FECHA}`, 'g');
+const LINK = /\[([^\]\n]+)\]\(\s*([^)\s]+)(?:\s+"[^"\n]*")?\s*\)/g;
+// O marcador só sai em par e colado ao texto que marca; nunca no meio de palavra.
+const NEGRITO = /\*\*(?=[^\s*])([^\n]+?)(?<=[^\s*])\*\*/g;
+const MARCADORES = [
+  NEGRITO,
+  /(?<![\p{L}\p{N}_])__(?=[^\s_])([^\n]+?)(?<=[^\s_])__(?![\p{L}\p{N}_])/gu,
+  /(?<![\p{L}\p{N}*])\*(?=[^\s*])([^*\n]+?)(?<=[^\s*])\*(?![\p{L}\p{N}*])/gu,
+  /(?<![\p{L}\p{N}_])_(?=[^\s_])([^_\n]+?)(?<=[^\s_])_(?![\p{L}\p{N}_])/gu,
+];
+
+/** `[texto](url)` vira `texto: url` (ou só a URL); negrito e itálico saem. No WhatsApp, `**x**` vira `*x*`. */
+function limparLinha(linha, whatsapp) {
+  const guardados = [];
+  const comLinks = linha.replace(LINK, (_, texto, url) => (texto.trim() === url ? url : `${texto}: ${url}`));
+  const mascarada = comLinks.replace(PROTEGIDO, (achado) => `${ABRE}${guardados.push(achado) - 1}${FECHA}`);
+  const limpa = whatsapp ? mascarada.replace(NEGRITO, '*$1*') : MARCADORES.reduce((t, rx) => t.replace(rx, '$1'), mascarada);
+  return limpa.replace(GUARDADO, (_, n) => guardados[Number(n)]);
+}
+
+/**
+ * Texto pronto para colar: as mesmas palavras, na mesma ordem, sem as linhas de rótulo, sem a
+ * linha `---`, sem os `#` de título e sem a sintaxe de negrito, itálico e link. Marcador de lista
+ * e citação ficam.
+ * @param {string} texto
+ * @param {{ whatsapp?: boolean }} [opcoes] no WhatsApp, `*x*` e `_x_` ficam e `**x**` vira `*x*`
+ */
+export function paraColar(texto, { whatsapp = false } = {}) {
+  const linhas = emLf(texto).split('\n').filter((linha) => linha.trim() !== '---' && !rotuloDe(linha));
+  return fechar(linhas.map((linha) => limparLinha(linha.replace(/^#{1,6}\s+/, ''), whatsapp)).join('\n'));
+}

package/templates/_opencrew/core/scripts/entregar.mjs

@@ -0,0 +1,141 @@
+#!/usr/bin/env node
+// Entrega de uma execução: separa os arquivos aprovados por canal, com texto pronto para colar e
+// um LEIA-ME que diz o que fazer com cada arquivo.
+// Uso (na pasta do projeto): node _opencrew/core/scripts/entregar.mjs --crew "crews/<crew>"
+//   --run "<id>" --arquivo "<caminho=formato>[,<caminho=formato>…]" [--vai-publicar <canal>] [--ajuda]
+//   --arquivo: a lista do verificador (o "=formato" é opcional); entra o que estiver nela e existir.
+//   --vai-publicar: canal que a crew publica sozinha (pode repetir); o LEIA-ME avisa.
+// Grava só em crews/<crew>/output/<run>/: a pasta `entrega/` (refeita do zero a cada chamada,
+// montada em `entrega.tmp/`) e, ao lado, `verificacao-entrega.md`.
+// Última linha da saída (o runner lê esta linha): ENTREGA:OK (nenhuma pendência) ou
+// ENTREGA:INCOMPLETA (algum canal não está pronto, ou a gravação falhou).
+// Código de saída: 0 sempre que a linha ENTREGA: sai, e em --ajuda · 1 = erro de uso ou erro que
+// impediu a entrega inteira; com código 1 não há linha ENTREGA: e nada é escrito.
+// Spec: fase-u3a1-pasta-de-entrega.md (repositório do OpenCrew).
+import { existsSync, readdirSync, statSync } from 'node:fs';
+import path from 'node:path';
+import { MSG as COMUM, erroDeUso, ehPrincipal, relativoAoProjeto } from './comum.mjs';
+import { formatarRelatorio, verificar } from './verificar.mjs';
+import { USO, lerArgs, lerLista, limpar, runValido } from './entrega/argumentos.mjs';
+import { CANAIS, OUTROS, canalDoFormato, ehCanal, ehDeServico } from './entrega/canais.mjs';
+import { separar } from './entrega/separar.mjs';
+import { nomear } from './entrega/nomes.mjs';
+import { alertasDeTamanho, frasesDePendencia, naoConferido, pendenciasPorPasta } from './entrega/pendencias.mjs';
+import { TEXTO, montarLeiame } from './entrega/leiame.mjs';
+import { gravarEntrega } from './entrega/gravar.mjs';
+
+const MSG = {
+  desconhecida: (opcao) => `Opção desconhecida: ${limpar(opcao)}.`,
+  semExecucao: (run, lista) => `Execução não encontrada: ${limpar(run)}. Execuções desta crew: ${lista.join(', ') || 'nenhuma'}.`,
+  nenhumArquivo: 'Nenhum arquivo da lista foi encontrado.',
+  deServico: (arquivo) => `${arquivo} é arquivo de serviço e não entra na entrega.`,
+  semCanal: (canal) => `Canal não encontrado nesta entrega: ${limpar(canal)}.`,
+  falhaDeEscrita: (arquivo) => `Não consegui gravar ${arquivo}. Feche o arquivo, ou espere a sincronização da pasta, e rode de novo.`,
+};
+
+const ehPasta = (p) => existsSync(p) && statSync(p).isDirectory();
+const tipoNoDisco = (p) => (!existsSync(p) ? 'ausente' : statSync(p).isDirectory() ? 'pasta' : 'arquivo');
+const execucoes = (saida) => (ehPasta(saida) ? readdirSync(saida, { withFileTypes: true }).filter((e) => e.isDirectory()).map((e) => e.name).sort() : []);
+
+/** Erro de uso, na ordem da §6: `{ mensagem, comUso }`, ou null quando a chamada está certa. */
+function erroDeChamada(raiz, args, pedidos) {
+  if (args.desconhecida) return { mensagem: MSG.desconhecida(args.desconhecida), comUso: true };
+  const faltando = [['--crew', args.crew], ['--run', args.run], ['--arquivo', pedidos.length]].filter(([, v]) => !v).map(([opcao]) => opcao);
+  const comum = erroDeUso({ raiz, faltando, crew: args.crew, caminhos: pedidos.map((p) => p.arquivo) });
+  if (comum) return { mensagem: comum, comUso: faltando.length > 0 };
+  const crew = path.resolve(raiz, args.crew);
+  if (!existsSync(path.join(crew, 'crew.yaml'))) return { mensagem: COMUM.crewNaoEncontrada(args.crew) };
+  const saida = path.join(crew, 'output');
+  if (!runValido(args.run) || !ehPasta(path.join(saida, args.run))) return { mensagem: MSG.semExecucao(args.run, execucoes(saida)) };
+  return null;
+}
+
+/** Cada item da lista, uma vez: onde fica, se existe, se é de serviço e qual é o canal do formato. */
+async function classificar(raiz, pedidos) {
+  const itens = [];
+  const vistos = new Set();
+  for (const { arquivo, formato } of pedidos) {
+    const abs = path.resolve(raiz, arquivo);
+    if (vistos.has(`${abs}|${formato ?? ''}`)) continue;
+    vistos.add(`${abs}|${formato ?? ''}`);
+    const rel = relativoAoProjeto(raiz, arquivo);
+    itens.push({ arquivo, formato, abs, rel, tipo: tipoNoDisco(abs), servico: ehDeServico(rel), canal: await canalDoFormato(raiz, formato) });
+  }
+  return itens;
+}
+
+/** Verifica na origem, separa por canal e monta tudo o que a entrega mostra; não escreve nada. */
+async function montar(raiz, args, itens) {
+  const arquivosDaLista = itens.map((i) => (i.formato ? { arquivo: i.arquivo, formato: i.formato } : i.arquivo));
+  const verificacao = await verificar({ raiz, crew: args.crew, arquivos: arquivosDaLista, semPadraoDeBlog: true });
+  const { arquivos, avisos } = nomear(await separar(itens));
+  const pendencias = pendenciasPorPasta(raiz, itens, verificacao);
+  const presentes = new Set([...arquivos.map((a) => a.pasta), ...pendencias.keys()]);
+  const dados = {
+    crew: path.basename(path.resolve(raiz, args.crew)), run: args.run, arquivos, avisos, pendencias,
+    pastas: Object.keys(CANAIS).filter((c) => presentes.has(c)),
+    alertas: await alertasDeTamanho(raiz, itens, arquivos, verificacao),
+    naoConferido: naoConferido(raiz, itens, verificacao),
+    vaiPublicar: args.vaiPublicar,
+  };
+  return { dados, leiame: montarLeiame(dados), relatorio: `${formatarRelatorio(verificacao)}\n` };
+}
+
+/** O resumo da tela: a pasta, a situação de cada canal, o que falta, os avisos e o LEIA-ME. */
+function resumo(execucao, { crew, run, pastas, pendencias, avisos, alertas }, deServico) {
+  const comPendencia = [...pastas, OUTROS].filter((p) => pendencias.has(p));
+  const notas = [...alertas, ...deServico.map((i) => MSG.deServico(i.rel)), ...avisos.map((a) => a.tela ?? a.texto)];
+  return [
+    `Entrega da execução ${run} da crew ${crew}`,
+    `Pasta: ${execucao}/entrega`,
+    ...pastas.map((p) => `- ${CANAIS[p]}: ${pendencias.has(p) ? TEXTO.naoPronto : TEXTO.pronto}`),
+    ...frasesDePendencia(comPendencia, pendencias).flatMap((frase, i) => [frase, ...pendencias.get(comPendencia[i]).map((l) => `- ${l}`)]),
+    ...(notas.length ? ['Avisos:', ...notas.map((l) => `- ${l}`)] : []),
+    `LEIA-ME: ${execucao}/entrega/LEIA-ME.md`,
+  ];
+}
+
+async function entregar(raiz, args, itens, escrever) {
+  const validos = itens.filter((i) => !i.servico);
+  const execucao = relativoAoProjeto(raiz, path.join(args.crew, 'output', args.run));
+  const { dados, leiame, relatorio } = await montar(raiz, args, validos);
+  const falha = await gravarEntrega(path.resolve(raiz, execucao), dados.arquivos, { leiame, relatorio });
+  if (falha) {
+    escrever(MSG.falhaDeEscrita(relativoAoProjeto(raiz, falha)));
+    escrever('ENTREGA:INCOMPLETA');
+    return 0;
+  }
+  for (const linha of resumo(execucao, dados, itens.filter((i) => i.servico))) escrever(linha);
+  escrever(dados.pendencias.size ? 'ENTREGA:INCOMPLETA' : 'ENTREGA:OK');
+  return 0;
+}
+
+/**
+ * @param {string[]} argv
+ * @param {object} [deps] `cwd` (a pasta do projeto) e `escrever`
+ * @returns {Promise<number>} 0 = a linha `ENTREGA:` saiu (ou `--ajuda`) · 1 = erro de uso, ou erro
+ *   que impediu a entrega inteira (uma linha em PT-BR, sem linha `ENTREGA:`, nada escrito)
+ */
+export async function main(argv, { cwd = process.cwd(), escrever = (s) => process.stdout.write(`${s}\n`) } = {}) {
+  const args = lerArgs(argv);
+  const sair = (...linhas) => linhas.forEach((l) => escrever(l)) ?? 1;
+  if (args.ajuda) return sair(USO) && 0;
+  const pedidos = lerLista(args.arquivos);
+  const erro = erroDeChamada(cwd, args, pedidos);
+  if (erro) return sair(erro.mensagem, ...(erro.comUso ? [USO] : []));
+  try {
+    const itens = await classificar(cwd, pedidos);
+    const validos = itens.filter((i) => !i.servico);
+    if (!validos.some((i) => i.tipo === 'arquivo')) return sair(MSG.nenhumArquivo);
+    const canais = new Set(validos.map((i) => i.canal));
+    const fora = args.vaiPublicar.find((canal) => !ehCanal(canal) || !canais.has(canal));
+    if (fora !== undefined) return sair(MSG.semCanal(fora));
+    return await entregar(cwd, args, itens, escrever);
+  } catch (erroGeral) {
+    return sair(`Não consegui montar a entrega: ${limpar(erroGeral?.message ?? erroGeral)}`);
+  }
+}
+
+if (ehPrincipal(import.meta.url)) {
+  main(process.argv.slice(2)).then((code) => { process.exitCode = code; });
+}

package/templates/_opencrew/core/scripts/verificar/pecas.mjs

@@ -12,7 +12,7 @@ export const FORMATOS_DA_TABELA = [...BLOG, 'instagram-feed', 'linkedin-post', '
 const FORMATO_DA_PECA = { legenda: 'instagram-feed', slides: 'instagram-feed', post: 'linkedin-post', tweet: 'twitter-post' };
 // O que cada rótulo faz, por formato declarado. Sem formato declarado valem todos: os
 // inconfundíveis abrem peça e os outros só se juntam a uma peça já aberta.
-const ROTULOS = {
+export const ROTULOS = {
   'instagram-feed': { CAPTION: 'legenda', SLIDES: 'slides', HASHTAGS: 'hashtags' },
   'linkedin-post': { HOOK: 'post', BODY: 'parte', INSIGHTS: 'parte', CTA: 'parte', HASHTAGS: 'hashtags' },
   'twitter-post': { TWEET: 'tweet' },
@@ -159,8 +159,8 @@ function fechar(entradas) {
  * Lê as peças de um texto, na ordem em que aparecem.
  * @param {string} texto conteúdo de um arquivo `.md` ou `.txt`, já sem o BOM
  * @param {string|null} [formato] formato declarado (`caminho=formato`); null = sem formato declarado
- * @param {{ formatoDeBlog?: string }} [opcoes] sem formato declarado, o formato em que o título do
- *   frontmatter é medido (`--formato`)
+ * @param {{ formatoDeBlog?: string|null }} [opcoes] sem formato declarado, o formato em que o
+ *   título do frontmatter é medido (`--formato`); null = não é peça (a entrega chama assim)
  * @returns {object[]} peças `{ tipo, formato, texto, origem, cabecalho, ordem }`
  *   · `tipo`: titulo, meta, legenda, hashtags, slides, post ou tweet
  *   · `formato`: o formato cujo limite vale para a peça
@@ -180,7 +180,7 @@ export function lerPecas(texto, formato = null, { formatoDeBlog = 'blog-post' }
   if (BLOG.includes(tabela)) pecasDoBlog(e, texto, trechos, tabela, true);
   else {
     // Fora da tabela os rótulos não são lidos; sem formato declarado, título no frontmatter é blog.
-    if (formato == null) pecasDoBlog(e, texto, trechos, formatoDeBlog, false);
+    if (formato == null && formatoDeBlog) pecasDoBlog(e, texto, trechos, formatoDeBlog, false);
     const rotulos = tabela ? ROTULOS[tabela] : formato == null ? TODOS_OS_ROTULOS : {};
     for (const trecho of trechos) pecasDoTrecho(e, trecho, rotulos);
     pecaDoArquivoInteiro(e, marcas);

package/templates/_opencrew/core/scripts/verificar/secoes.mjs

@@ -110,18 +110,36 @@ function abrir(trechos, trecho) {
   return trechos.at(-1);
 }
 
+/**
+ * Peças a que algum cabeçalho de baixo do cabeçalho de nível 1 da posição `i` é candidato; a
+ * seção dele vai até o próximo de nível 1 ou até um rótulo.
+ */
+function tiposSobOTitulo(marcas, i, formato) {
+  const tipos = new Set();
+  let pilha = [marcas[i]];
+  for (let j = i + 1; j < marcas.length && !marcas[j].rotulo && marcas[j].nivel !== 1; j++) {
+    if (!marcas[j].nivel) continue;
+    pilha = pilha.filter((c) => c.nivel < marcas[j].nivel);
+    for (const tipo of candidaturas(marcas[j].norm, pilha.map((c) => c.norm), formato)) tipos.add(tipo);
+    pilha.push(marcas[j]);
+  }
+  return tipos;
+}
+
 /**
  * Percorre as marcas e devolve os trechos, na ordem do texto: `{ rotulo, linhas }` para cada
  * linha de rótulo e `{ titulo, tipos, canal, linhas }` para cada cabeçalho candidato a peça
  * (`canal`: na seção de hashtags, o formato do canal que o cabeçalho cita; senão null).
  * A seção de cabeçalho vai até o próximo cabeçalho do mesmo nível ou acima, ou até um rótulo; a
  * de rótulo, até o próximo rótulo ou até um cabeçalho candidato (regra 2).
+ * O cabeçalho de nível 1 que tem, abaixo dele, outro candidato à mesma peça é o título do
+ * arquivo: não abre essa peça (fase-u3a1-pasta-de-entrega.md, regra 4).
  */
 export function lerTrechos(marcas, formato) {
   const trechos = [];
   let pilha = []; // cabeçalhos abertos, do mais externo ao mais interno
   let rotulo = null; // seção de rótulo aberta
-  for (const m of marcas) {
+  for (const [i, m] of marcas.entries()) {
     if (m.rotulo) {
       pilha = [];
       rotulo = abrir(trechos, { rotulo: m.rotulo });
@@ -129,7 +147,9 @@ export function lerTrechos(marcas, formato) {
     }
     if (m.nivel) {
       pilha = pilha.filter((c) => c.nivel < m.nivel);
-      const tipos = candidaturas(m.norm, pilha.map((c) => c.norm), formato);
+      const todos = candidaturas(m.norm, pilha.map((c) => c.norm), formato);
+      const abaixo = m.nivel === 1 && todos.length ? tiposSobOTitulo(marcas, i, formato) : null;
+      const tipos = abaixo ? todos.filter((tipo) => !abaixo.has(tipo)) : todos;
       const canal = tipos[0] === 'hashtags' ? canalDe(m.norm) : null;
       const trecho = tipos.length ? abrir(trechos, { titulo: m.titulo, tipos, canal }) : null;
       pilha.push({ nivel: m.nivel, norm: m.norm, trecho });

package/templates/_opencrew/core/scripts/verificar.mjs

@@ -135,6 +135,8 @@ function resumir(arquivos, naoTexto, notas) {
  * @param {Array<string|{ arquivo: string, formato?: string }>} o.arquivos caminho (sem formato
  *   declarado) ou `{ arquivo, formato }` (formato declarado)
  * @param {string} [o.formato] limites de blog do item sem formato declarado que tem título no frontmatter
+ * @param {boolean} [o.semPadraoDeBlog] só a entrega passa true: no item sem formato declarado, o
+ *   título do frontmatter não é medido como blog (fase-u3a1-pasta-de-entrega.md, regra 17)
  * @param {Function} [o.regraDeTeste] SÓ PARA TESTE: regra extra, chamada com `{ arquivo, formato,
  *   texto }` em cada arquivo de texto; serve para simular uma regra que lança erro
  * @returns {Promise<object>} `{ arquivos, naoTexto, notas, bloqueios, alertas, naoMedidos, status }`
@@ -144,11 +146,11 @@ function resumir(arquivos, naoTexto, notas) {
  *   · `naoTexto`: caminhos que não são texto · `naoMedidos`: linhas "Não medido"/"Não verificado"
  *   · `status`: OK, BLOQUEADA ou AGUARDANDO_USUARIO
  */
-export async function verificar({ raiz, crew, arquivos, formato = 'blog-post', regraDeTeste }) {
+export async function verificar({ raiz, crew, arquivos, formato = 'blog-post', semPadraoDeBlog = false, regraDeTeste }) {
   const entradas = semRepetidas(raiz, arquivos.map(normalizar));
   const erro = erroDeUso({ raiz, crew, caminhos: entradas.map((e) => e.arquivo) });
   if (erro) throw new Error(erro);
-  const ctx = await prepararContexto(raiz, crew, formato);
+  const ctx = await prepararContexto(raiz, crew, semPadraoDeBlog ? null : formato);
   const resultado = [];
   const naoTexto = [];
   for (const entrada of entradas) {