@aksp/opencrew 1.8.0 → 1.9.0

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

@@ -1,28 +1,43 @@
 #!/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.
+// 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>…]" [--vai-publicar <canal>] [--ajuda]
+//   --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 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).
+// 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.
-// Spec: fase-u3a1-pasta-de-entrega.md (repositório do OpenCrew).
+// 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, 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 { 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)}.`,
@@ -30,7 +45,6 @@ const MSG = {
   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();
@@ -47,7 +61,9 @@ function erroDeChamada(raiz, args, pedidos) {
   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;
+  // 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. */
@@ -65,48 +81,57 @@ async function classificar(raiz, pedidos) {
 }
 
 /** Verifica na origem, separa por canal e monta tudo o que a entrega mostra; não escreve nada. */
-async function montar(raiz, args, itens) {
+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 pendencias = pendenciasPorPasta(raiz, itens, verificacao);
-  const presentes = new Set([...arquivos.map((a) => a.pasta), ...pendencias.keys()]);
+  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, pendencias,
+    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, leiame: montarLeiame(dados), relatorio: `${formatarRelatorio(verificacao)}\n` };
+  return { 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`,
-  ];
+/** 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 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)));
+  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;
   }
-  for (const linha of resumo(execucao, dados, itens.filter((i) => i.servico))) escrever(linha);
-  escrever(dados.pendencias.size ? 'ENTREGA:INCOMPLETA' : 'ENTREGA:OK');
+  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;
 }
 
@@ -138,4 +163,4 @@ export async function main(argv, { cwd = process.cwd(), escrever = (s) => proces
 
 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/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.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',
@@ -139,7 +123,8 @@ function resumir(arquivos, naoTexto, notas) {
  *   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
@@ -178,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