@aksp/opencrew 1.7.1 → 1.9.0

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,166 @@
+#!/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; e copia o que está pronto para a pasta do
+// projeto que o usuário escolheu.
+// Uso (na pasta do projeto): node _opencrew/core/scripts/entregar.mjs --crew "crews/<crew>"
+//   --run "<id>" --arquivo "<caminho=formato>[,<caminho=formato>…]" [--destino "<pasta>"]
+//   [--lembrar-destino "<pasta>"|nao] [--aceitar-pendencias] [--vai-publicar <canal>] [--ajuda]
+//   --arquivo: a lista do verificador (o "=formato" é opcional); entra o que estiver nela e existir.
+//   --destino: pasta do projeto que recebe a cópia, só nesta chamada (vale sobre o crew.yaml).
+//   --lembrar-destino: grava a pasta (ou "nao") em `entrega.destino` do crew.yaml e já vale agora.
+//   --aceitar-pendencias: as pendências deste momento viram ressalvas ("entregar assim mesmo"); a
+//     ressalva vale enquanto a pendência dela existir: a que some sai do `ressalvas.json`.
+//   --vai-publicar: canal que a crew publica sozinha (pode repetir); o LEIA-ME avisa.
+// Grava em crews/<crew>/output/<run>/: a pasta `entrega/` (refeita do zero a cada chamada, montada
+// em `entrega.tmp/`), `verificacao-entrega.md`, `ressalvas.json` (as pendências aceitas que ainda
+// existem) e `copia.json` (o retrato do que foi copiado, para a comparação seguinte). Fora
+// dali, só o combinado: a cópia em `<destino>/<run>/` (nunca por cima do que já está lá; se a
+// entrega mudou, `<run>-reentrega-2`…) e, com --lembrar-destino, o crew.yaml (com crew.yaml.bak).
+// Última linha da saída (o runner lê esta linha): ENTREGA:OK (nenhuma pendência),
+// ENTREGA:COM_RESSALVA (toda pendência foi aceita) ou ENTREGA:INCOMPLETA (algum canal não está
+// pronto, o destino foi recusado ou uma 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.
+// Specs: fase-u3a1-pasta-de-entrega.md e fase-u3a2-entrega-no-projeto.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, canalDoFormato, ehCanal, ehDeServico } from './entrega/canais.mjs';
+import { MSG as DESTINO, escolherDestino, validarDestino } from './entrega/destino.mjs';
+import { MSG as COPIA, guardar } from './entrega/guardar.mjs';
+import { gravarEntrega } from './entrega/gravar.mjs';
+import { montarLeiame } from './entrega/leiame.mjs';
+import { lembrarDestino } from './entrega/lembrar.mjs';
+import { nomear } from './entrega/nomes.mjs';
+import { alertasDeTamanho, naoConferido, pendenciasPorPasta } from './entrega/pendencias.mjs';
+import { ARQUIVO as RESSALVAS, MSG as RESSALVA, gravarRessalvas, lerRessalvas, separarPendencias } from './entrega/ressalvas.mjs';
+import { resumo } from './entrega/resumo.mjs';
+import { separar } from './entrega/separar.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)}.`,
+};
+
+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)) };
+  // O destino a lembrar é validado antes de qualquer escrita: recusado, o crew.yaml fica intacto.
+  const lembrar = args.lembrarDestino == null ? null : validarDestino(raiz, args.lembrarDestino);
+  return lembrar?.tipo === 'recusado' ? { mensagem: DESTINO.recusado(lembrar.valor) } : 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, aceitas) {
+  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 todas = pendenciasPorPasta(raiz, itens, verificacao);
+  const presentes = new Set([...arquivos.map((a) => a.pasta), ...todas.keys()]);
+  const dados = {
+    crew: path.basename(path.resolve(raiz, args.crew)), run: args.run, arquivos, avisos,
+    ...separarPendencias(todas, aceitas, args.aceitar),
+    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, relatorio: `${formatarRelatorio(verificacao)}\n` };
+}
+
+/** O que a entrega grava, na ordem: crew.yaml, ressalvas, a cópia e, por último, `entrega/`. */
+async function gravarTudo(raiz, args, validos, pastas) {
+  const falhas = [args.lembrarDestino == null ? null : await lembrarDestino(raiz, pastas.crew, validarDestino(raiz, args.lembrarDestino))];
+  const lidas = await lerRessalvas(pastas.execucao);
+  const { dados, relatorio } = await montar(raiz, args, validos, lidas.aceitas);
+  // Ilegível, o arquivo fica como está — só um aceite novo o regrava.
+  if (!lidas.ilegivel || (args.aceitar && dados.ressalvas.size)) falhas.push(await gravarRessalvas(pastas.execucao, dados.ressalvas));
+  const copia = await guardar(raiz, await escolherDestino(raiz, pastas.crew, args), dados, pastas.execucao);
+  const leiame = montarLeiame({ ...dados, copiaEm: copia.pasta });
+  const daEntrega = await gravarEntrega(pastas.execucao, dados.arquivos, { leiame, relatorio });
+  const naoGravados = falhas.filter(Boolean).map((f) => COPIA.falhaDeEscrita(relativoAoProjeto(raiz, f)));
+  return { dados, copia, lidas, naoGravados, daEntrega: daEntrega && COPIA.falhaDeEscrita(relativoAoProjeto(raiz, daEntrega)) };
+}
+
+function linhaFinal(dados, incompleta) {
+  if (incompleta || dados.pendencias.size) return 'ENTREGA:INCOMPLETA';
+  return dados.ressalvas.size ? 'ENTREGA:COM_RESSALVA' : 'ENTREGA:OK';
+}
+
+async function entregar(raiz, args, itens, escrever) {
+  const execucao = relativoAoProjeto(raiz, path.join(args.crew, 'output', args.run));
+  const pastas = { crew: path.resolve(raiz, args.crew), execucao: path.resolve(raiz, execucao) };
+  const r = await gravarTudo(raiz, args, itens.filter((i) => !i.servico), pastas);
+  if (r.daEntrega) {
+    for (const linha of [...r.naoGravados, r.daEntrega]) escrever(linha);
+    escrever('ENTREGA:INCOMPLETA');
+    return 0;
+  }
+  const notas = [
+    ...(r.lidas.ilegivel ? [RESSALVA.ilegivel(`${execucao}/${RESSALVAS}`)] : []), ...r.dados.novas,
+    ...itens.filter((i) => i.servico).map((i) => MSG.deServico(i.rel)),
+  ];
+  for (const linha of resumo(execucao, r.dados, notas, [...r.naoGravados, ...r.copia.linhas])) escrever(linha);
+  escrever(linhaFinal(r.dados, r.copia.falhou || r.naoGravados.length > 0));
+  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/argumentos.mjs

@@ -1,12 +1,12 @@
 // Linha de comando do verificador: as opções, os itens `caminho=formato` e a linha de uso.
-// Spec: fase-r1-reparos-1-6-1.md, §3.
+// Specs: fase-r1-reparos-1-6-1.md, §3, e fase-u3a2-entrega-no-projeto.md, §3 (`--relatorio`).
 
 // Uma linha só, e sem o texto do status: em erro de uso a saída não tem linha de status.
-export const USO = 'Uso: node _opencrew/core/scripts/verificar.mjs --crew crews/<nome> --arquivo "<caminho=formato>[,<caminho=formato>…]" [--formato blog-post|blog-seo]'
+export const USO = 'Uso: node _opencrew/core/scripts/verificar.mjs --crew crews/<nome> --arquivo "<caminho=formato>[,<caminho=formato>…]" [--formato blog-post|blog-seo] [--relatorio "<caminho>"]'
   + ' — o "=formato" é opcional; o relatório termina em OK, BLOQUEADA ou AGUARDANDO_USUARIO; código de saída: 0 = verificou, 1 = erro de uso';
 
 /**
- * Opções da linha de comando: `{ crew, formato, arquivos }`. `--arquivo` repetido soma à lista, e
+ * Opções da linha de comando: `{ crew, formato, relatorio, arquivos }`. `--arquivo` repetido soma à lista, e
  * o que vem solto logo depois da lista (sem `--`) é mais um item dela: nenhum arquivo citado fica
  * sem verificação.
  */
@@ -14,7 +14,7 @@ export function lerArgs(argv) {
   const args = { arquivos: [] };
   let naLista = false;
   for (let i = 0; i < argv.length; i++) {
-    const opcao = argv[i].match(/^--(crew|arquivo|formato)$/)?.[1];
+    const opcao = argv[i].match(/^--(crew|arquivo|formato|relatorio)$/)?.[1];
     if (opcao && i + 1 < argv.length) {
       if (opcao === 'arquivo') args.arquivos.push(argv[++i]);
       else args[opcao] = argv[++i];

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

@@ -0,0 +1,26 @@
+// As entradas da lista do verificador: cada item com o formato declarado, uma vez só, e o nome
+// com que o arquivo aparece no relatório.
+import path from 'node:path';
+import { relativoAoProjeto } from '../comum.mjs';
+
+/** Item da lista → `{ arquivo, formato }`; só o objeto traz formato declarado. */
+export function normalizar(entrada) {
+  if (typeof entrada === 'string') return { arquivo: entrada, formato: null };
+  return { arquivo: entrada.arquivo, formato: entrada.formato || null };
+}
+
+/** O mesmo arquivo citado duas vezes, com o mesmo formato, é verificado (e contado) uma vez só. */
+export function semRepetidas(raiz, entradas) {
+  const vistas = new Set();
+  return entradas.filter((e) => {
+    const chave = `${path.resolve(raiz, e.arquivo)}|${e.formato ?? ''}`;
+    return !vistas.has(chave) && vistas.add(chave);
+  });
+}
+
+/** No relatório, o absoluto de dentro do projeto (também por link, junção ou nome curto) sai como o relativo. */
+export function nomeNoRelatorio(raiz, arquivo) {
+  const relativo = relativoAoProjeto(raiz, arquivo);
+  const comoEscrito = !path.isAbsolute(arquivo) && path.resolve(raiz, relativo) === path.resolve(raiz, arquivo);
+  return comoEscrito ? arquivo : relativo;
+}

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

@@ -0,0 +1,41 @@
+// O relatório do ciclo gravado pelo próprio verificador (`--relatorio`): só dentro de
+// `crews/<crew>/output/`, com nome `verificacao-*.md`, em pasta que já existe. O script não cria
+// pasta e não grava em nenhum outro lugar.
+// Spec: fase-u3a2-entrega-no-projeto.md, §3 e regra 35 (repositório do OpenCrew).
+import { existsSync, promises as fs, statSync } from 'node:fs';
+import path from 'node:path';
+import { realDentroDe } from '../comum.mjs';
+
+const emUmaLinha = (valor) => String(valor).replace(/\s+/g, ' ').trim().slice(0, 200);
+
+export const MSG = {
+  invalido: (valor) => `O relatório só pode ser gravado em crews/<crew>/output/, com nome verificacao-….md. Recebi: ${emUmaLinha(valor)}.`,
+  naoGravou: (caminho) => `⚠️ Não consegui gravar o relatório em ${caminho}.`,
+};
+
+const NOME = /^verificacao-.*\.md$/i;
+const ehPasta = (p) => existsSync(p) && statSync(p).isDirectory();
+
+/**
+ * Onde o relatório pode ser gravado: o caminho absoluto, ou null quando o valor está fora da regra
+ * (fora de `crews/<crew>/output/`, pelo texto ou pelo lugar real; outro nome; pasta que não existe).
+ */
+export function caminhoDoRelatorio(raiz, crew, valor) {
+  if (!String(valor).trim()) return null;
+  const saida = path.resolve(raiz, crew, 'output');
+  const alvo = path.resolve(raiz, valor);
+  const rel = path.relative(saida, alvo);
+  if (!rel || rel.startsWith('..') || path.isAbsolute(rel) || !NOME.test(path.basename(alvo))) return null;
+  const pasta = path.dirname(alvo);
+  return ehPasta(pasta) && realDentroDe(saida, pasta) ? alvo : null;
+}
+
+/** Grava o que o script imprime (o relatório e a quebra de linha do fim). @returns {Promise<boolean>} gravou? */
+export async function gravarRelatorio(alvo, relatorio) {
+  try {
+    await fs.writeFile(alvo, `${relatorio}\n`, 'utf8');
+    return true;
+  } catch {
+    return false;
+  }
+}

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/relatorio.mjs

@@ -1,7 +1,10 @@
 // Relatório do verificador em markdown (PT-BR). A última linha é o status que o runner lê.
-import { NAO_MEDIDO, NAO_VERIFICADO } from './regras.mjs';
+// [PREENCHER] sai como "A preencher", contado à parte: bloqueia como antes, mas só o usuário resolve
+// (fase-u3a2-entrega-no-projeto.md, regra 36). Sem [PREENCHER], o relatório é o de sempre.
+import { FALTA_INFO, NAO_MEDIDO, NAO_VERIFICADO } from './regras.mjs';
 
 const ROTULO = { bloqueio: '❌ Bloqueio', alerta: '⚠️ Alerta', ok: '✅ OK' };
+const A_PREENCHER = '✏️ A preencher';
 const plural = (n, um, varios) => `${n} ${n === 1 ? um : varios}`;
 const ehNaoMedido = (i) => i.item === NAO_MEDIDO || i.item === NAO_VERIFICADO;
 
@@ -14,7 +17,7 @@ function tabela(medidos) {
 /** "Não medido" e "Não verificado" começam por ⚠️ quando são alerta e por ⚪ quando não têm nível. */
 function linhaDoAchado(i) {
   if (ehNaoMedido(i)) return `- ${i.nivel === 'alerta' ? '⚠️' : '⚪'} ${i.item} — ${i.detalhe}`;
-  return `- ${ROTULO[i.nivel]} — ${i.item}: "${i.detalhe}"`;
+  return `- ${i.item === FALTA_INFO ? A_PREENCHER : ROTULO[i.nivel]} — ${i.item}: "${i.detalhe}"`;
 }
 
 function secaoDoArquivo(a) {
@@ -30,7 +33,11 @@ export function formatarRelatorio(r) {
   const naoTexto = r.naoTexto ?? [];
   const notas = [...r.notas];
   if (naoTexto.length) notas.push(`⚪ ${NAO_VERIFICADO} — não é texto (${naoTexto.length}): ${naoTexto.join(', ')}`);
-  const resumo = [plural(r.bloqueios, 'bloqueio', 'bloqueios'), plural(r.alertas, 'alerta', 'alertas'), plural(r.naoMedidos ?? 0, 'não medido', 'não medidos')];
+  const aPreencher = r.aPreencher ?? 0;
+  const resumo = [
+    plural(r.bloqueios - aPreencher, 'bloqueio', 'bloqueios'), ...(aPreencher ? [`${aPreencher} a preencher`] : []),
+    plural(r.alertas, 'alerta', 'alertas'), plural(r.naoMedidos ?? 0, 'não medido', 'não medidos'),
+  ];
   return [
     '## Verificação automática',
     '',

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

@@ -1,9 +1,10 @@
 #!/usr/bin/env node
 // Verificador automático do OpenCrew — mede o texto ANTES do revisor.
-// Uso: node _opencrew/core/scripts/verificar.mjs --crew crews/<nome> --arquivo "<caminho=formato>[,<caminho=formato>…]" [--formato blog-post|blog-seo]
+// Uso: node _opencrew/core/scripts/verificar.mjs --crew crews/<nome> --arquivo "<caminho=formato>[,<caminho=formato>…]" [--formato blog-post|blog-seo] [--relatorio "<caminho>"]
 //   caminho=formato: o formato declarado de cada arquivo (o `format:` do passo que o gerou); o
 //   "=formato" é opcional. --formato só escolhe os limites de blog do item sem "=formato" que tem
-//   título no frontmatter.
+//   título no frontmatter. --relatorio grava no arquivo dado (crews/<crew>/output/…/verificacao-*.md)
+//   exatamente o que o script imprime.
 // Os limites vêm do frontmatter `constraints:` dos best-practices (fonte única).
 // Última linha da saída (o runner lê esta linha): VERIFICACAO:OK, VERIFICACAO:BLOQUEADA ou
 // VERIFICACAO:AGUARDANDO_USUARIO (os únicos bloqueios são [PREENCHER], que só o usuário resolve).
@@ -11,19 +12,22 @@
 // obrigatória faltando, pasta sem `_opencrew/`, crew inexistente, crew ou caminho fora do
 // projeto, nenhum caminho da lista existe) ou erro que impediu a verificação inteira; com
 // código 1 não há linha VERIFICACAO:.
-// Specs: fase-u1-revisor-com-dentes.md, fase-r1-reparos-1-6-1.md e fase-r2-update-e-envio-seguros.md
-// (regra 23: "dentro do projeto" pelo texto ou pelo lugar real), no repositório do OpenCrew.
+// Specs: fase-u1-revisor-com-dentes.md, fase-r1-reparos-1-6-1.md, fase-r2-update-e-envio-seguros.md
+// (regra 23: "dentro do projeto" pelo texto ou pelo lugar real) e fase-u3a2-entrega-no-projeto.md
+// (regras 35 e 36), no repositório do OpenCrew.
 import { existsSync } from 'node:fs';
 import path from 'node:path';
 import { erroDeUso, ehPrincipal, relativoAoProjeto } from './comum.mjs';
 import { USO, lerArgs, lerItemDaLista } from './verificar/argumentos.mjs';
 import { lerItem } from './verificar/arquivos.mjs';
+import { nomeNoRelatorio, normalizar, semRepetidas } from './verificar/entradas.mjs';
 import { lerLimites, lerDominioDoSite, semFrontmatter } from './verificar/leitura.mjs';
 import { lerProibicoes } from './verificar/proibicoes.mjs';
 import { lerPecas } from './verificar/pecas.mjs';
 import { medirPecas } from './verificar/medicao.mjs';
 import { regrasGerais, temVariavel, item, FALTA_INFO, NAO_MEDIDO, NAO_VERIFICADO } from './verificar/regras.mjs';
 import { formatarRelatorio } from './verificar/relatorio.mjs';
+import { MSG as GRAVACAO, caminhoDoRelatorio, gravarRelatorio } from './verificar/gravacao.mjs';
 
 export { formatarRelatorio };
 
@@ -88,27 +92,6 @@ async function verificarArquivo({ arquivo, formato }, ctx, regraDeTeste) {
   return { itens, fecho: fechoDe(itens, medidas, formato) };
 }
 
-/** Item da lista → `{ arquivo, formato }`; só o objeto traz formato declarado. */
-function normalizar(entrada) {
-  if (typeof entrada === 'string') return { arquivo: entrada, formato: null };
-  return { arquivo: entrada.arquivo, formato: entrada.formato || null };
-}
-
-/** O mesmo arquivo citado duas vezes, com o mesmo formato, é verificado (e contado) uma vez só. */
-function semRepetidas(raiz, entradas) {
-  const vistas = new Set();
-  return entradas.filter((e) => {
-    const chave = `${path.resolve(raiz, e.arquivo)}|${e.formato ?? ''}`;
-    return !vistas.has(chave) && vistas.add(chave);
-  });
-}
-
-/** No relatório, o absoluto de dentro do projeto (também por link, junção ou nome curto) sai como o relativo. */
-function nomeNoRelatorio(raiz, arquivo) {
-  const relativo = relativoAoProjeto(raiz, arquivo);
-  const comoEscrito = !path.isAbsolute(arquivo) && path.resolve(raiz, relativo) === path.resolve(raiz, arquivo);
-  return comoEscrito ? arquivo : relativo;
-}
 
 function resumir(arquivos, naoTexto, notas) {
   const todos = arquivos.flatMap((a) => a.itens);
@@ -121,6 +104,7 @@ function resumir(arquivos, naoTexto, notas) {
     naoTexto,
     notas: [...notas],
     bloqueios: bloqueios.length,
+    aPreencher: bloqueios.length - reais,
     alertas: todos.filter((i) => i.nivel === 'alerta').length,
     naoMedidos: todos.filter((i) => i.item === NAO_MEDIDO || i.item === NAO_VERIFICADO).length,
     status: reais ? 'BLOQUEADA' : bloqueios.length ? 'AGUARDANDO_USUARIO' : 'OK',
@@ -135,20 +119,23 @@ 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 }`
+ * @returns {Promise<object>} `{ arquivos, naoTexto, notas, bloqueios, aPreencher, alertas, naoMedidos,
+ *   status }` · `aPreencher`: quantos dos `bloqueios` são [PREENCHER]
  *   · `arquivos`: `[{ arquivo, formato, itens, fecho }]`, só os de texto; cada item é
  *   `{ item, medido, limite, nivel, detalhe }`, com `nivel` bloqueio, alerta, ok ou null (linha
  *   "Não medido" sem nível); para a mesma entrada, arquivo + item + detalhe não mudam
  *   · `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) {
@@ -176,12 +163,17 @@ export async function main(argv, { cwd = process.cwd(), escrever = (s) => proces
     if (faltando.length) escrever(USO);
     return 1;
   }
+  const alvo = args.relatorio == null ? null : caminhoDoRelatorio(cwd, args.crew, args.relatorio);
+  if (args.relatorio != null && !alvo) return escrever(GRAVACAO.invalido(args.relatorio)) ?? 1;
   if (!caminhos.some((c) => existsSync(path.resolve(cwd, c)))) {
     for (const c of new Set(caminhos)) escrever(`Arquivo não encontrado: ${c}`);
     return 1;
   }
   try {
-    escrever(formatarRelatorio(await verificar({ raiz: cwd, crew: args.crew, arquivos, formato: args.formato || 'blog-post' })));
+    const relatorio = formatarRelatorio(await verificar({ raiz: cwd, crew: args.crew, arquivos, formato: args.formato || 'blog-post' }));
+    // O relatório sai na tela mesmo quando o arquivo não pôde ser gravado.
+    if (alvo && !(await gravarRelatorio(alvo, relatorio))) escrever(GRAVACAO.naoGravou(relativoAoProjeto(cwd, alvo)));
+    escrever(relatorio);
     return 0;
   } catch (erroGeral) {
     // Fora da lista de arquivos (memória da crew ou `company.md` ilegível): nada foi verificado.

package/templates/gitignore

@@ -1,3 +1,4 @@
+# gerenciado pelo OpenCrew: suas linhas ficam fora deste bloco
 node_modules/
 .env
 *.log