@aksp/opencrew 1.8.0 → 1.9.0

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

@@ -1,17 +1,22 @@
-// O LEIA-ME.md da entrega: títulos fixos, na ordem da spec; seção sem conteúdo não aparece.
-// Arquivo da entrega é citado com caminho relativo à pasta do LEIA-ME; o de origem, relativo ao
-// projeto. Sem hora: as mesmas entradas geram os mesmos bytes. PT-BR fixo.
-// Spec: fase-u3a1-pasta-de-entrega.md, §4 e §6 (repositório do OpenCrew).
+// O LEIA-ME.md da entrega e o da cópia: títulos fixos, na ordem da spec; seção sem conteúdo não
+// aparece. Arquivo da entrega é citado com caminho relativo à pasta do LEIA-ME; o de origem,
+// relativo ao projeto. Sem hora: as mesmas entradas geram os mesmos bytes. PT-BR fixo.
+// Specs: fase-u3a1-pasta-de-entrega.md, §4 e §6, e fase-u3a2-entrega-no-projeto.md, §4 e §6
+// (ressalvas, a cópia e "Sobre esta pasta"), no repositório do OpenCrew.
 import { CANAIS, EDITAVEIS, OUTROS } from './canais.mjs';
 import { frasesDePendencia } from './pendencias.mjs';
 import { passosDe } from './passos.mjs';
 
 export const TEXTO = {
   vaiPublicar: 'Esta crew publica este canal sozinha. Antes de postar à mão, confira se já saiu.',
-  pdf: 'Abra o arquivo que você quer (por exemplo, o artigo do blog) no navegador ou no editor de texto e use Imprimir → Salvar como PDF.',
+  pdf: 'Abra o arquivo que você quer no navegador ou no editor de texto e use Imprimir → Salvar como PDF.',
   semCanal: 'sem canal de publicação; está aqui para você usar como quiser.',
   sobre: 'Esta pasta é refeita a cada entrega e fica fora do git: o que você editar aqui se perde. Para guardar, copie a pasta para outro lugar do projeto.',
+  sobreComCopia: (pasta) => `Esta pasta é refeita a cada entrega e fica fora do git: o que você editar aqui se perde. A cópia para guardar está em \`${pasta}\`.`,
+  sobreDaCopia: (run) => `Esta é a cópia da entrega da execução ${run}. Ela não é refeita: pode editar e guardar. Se a entrega mudar, a versão nova vai para outra pasta, ao lado desta.`,
+  comRessalva: 'Entregue com ressalva:',
   pronto: 'Pronto',
+  prontoComRessalva: 'Pronto, com ressalva',
   naoPronto: 'Não está pronto',
 };
 
@@ -19,6 +24,12 @@ const lista = (linhas) => linhas.map((l) => `- ${l}`).join('\n');
 const bloco = (titulo, linhas) => (linhas.length ? [`${titulo}\n${lista(linhas)}`] : []);
 const secao = (titulo, partes) => (partes.length ? [`## ${titulo}\n\n${partes.join('\n\n')}`] : []);
 
+/** A situação de um canal: uma só. Pendência não aceita vale sobre a ressalva. */
+export function situacaoDe(d, pasta) {
+  if (d.pendencias.has(pasta)) return TEXTO.naoPronto;
+  return d.ressalvas.has(pasta) ? TEXTO.prontoComRessalva : TEXTO.pronto;
+}
+
 /** Uma linha por arquivo entregue: o caminho na entrega, o título do bloco (se houver) e a origem. */
 function linhaDoArquivo(a) {
   const titulo = a.titulo ? ` — ${a.titulo}` : '';
@@ -28,22 +39,35 @@ function linhaDoArquivo(a) {
 /** Os avisos de uma pasta que o LEIA-ME mostra (o que só vai para a tela não tem `texto`). */
 const avisosDe = (d, pasta) => d.avisos.filter((a) => a.pasta === pasta && a.texto).map((a) => a.texto);
 
-/** `## Antes de usar`: os alertas de tamanho e, por canal que não está pronto, o que falta. */
+/** A linha de uma ressalva; a de [PREENCHER] cita os arquivos entregues daquela origem que têm o trecho. */
+function linhaDaRessalva(d, r) {
+  const temOTrecho = (a) => a.origem === r.chave.arquivo && a.texto?.includes('[PREENCHER') && a.texto.includes(r.preencher);
+  const onde = r.preencher ? d.arquivos.filter(temOTrecho).map((a) => `\`${a.pasta}/${a.nome}\``) : [];
+  return `${r.linha}${onde.length ? ` — está em ${onde.join(', ')}` : ''}`;
+}
+
+/** `## Antes de usar`: as ressalvas, os alertas de tamanho e, por canal que não está pronto, o que falta. */
 function antesDeUsar(d) {
+  const ressalvas = [...d.ressalvas.values()].flat().map((r) => linhaDaRessalva(d, r));
   const pastas = [...d.pastas, OUTROS].filter((p) => d.pendencias.has(p));
   const frases = frasesDePendencia(pastas, d.pendencias);
   const faltas = pastas.map((p, i) => `- ${frases[i]}\n${d.pendencias.get(p).map((l) => `  - ${l}`).join('\n')}`);
-  return secao('Antes de usar', [[...d.alertas.map((a) => `- ${a}`), ...faltas].join('\n')].filter(Boolean));
+  // Na cópia, o alerta de um arquivo que não foi copiado não aparece: ele cita um arquivo que não está lá.
+  const alertas = d.alertas.filter((a) => !d.ehCopia || !d.pendencias.has(a.pasta)).map((a) => `- ${a.texto}`);
+  return secao('Antes de usar', [...bloco(TEXTO.comRessalva, ressalvas), [...alertas, ...faltas].join('\n')].filter(Boolean));
 }
 
 /** `## {Canal}`: o aviso de publicação, a situação, os arquivos, as pendências, os avisos e os passos. */
 function secaoDoCanal(d, pasta) {
-  const arquivos = d.arquivos.filter((a) => a.pasta === pasta);
   const pendencias = d.pendencias.get(pasta) ?? [];
-  const passos = passosDe(pasta, arquivos, pendencias.length > 0).map((p, i) => `${i + 1}. ${p}`);
+  const situacao = `Situação: ${situacaoDe(d, pasta)}`;
+  // Na cópia, o canal que não foi copiado traz só a situação e o que falta.
+  if (d.ehCopia && pendencias.length) return secao(CANAIS[pasta], [situacao, ...bloco('Pendências:', pendencias)]);
+  const arquivos = d.arquivos.filter((a) => a.pasta === pasta);
+  const passos = passosDe(pasta, arquivos, pendencias.length > 0, d.ressalvas.has(pasta)).map((p, i) => `${i + 1}. ${p}`);
   return secao(CANAIS[pasta], [
     ...(d.vaiPublicar.includes(pasta) ? [TEXTO.vaiPublicar] : []),
-    `Situação: ${pendencias.length ? TEXTO.naoPronto : TEXTO.pronto}`,
+    situacao,
     ...bloco('Arquivos:', arquivos.map(linhaDoArquivo)),
     ...bloco('Pendências:', pendencias),
     ...bloco('Atenção:', avisosDe(d, pasta)),
@@ -59,31 +83,43 @@ function secaoDaPasta(d, pasta, titulo) {
   return secao(titulo, [
     ...(arquivos.length ? [lista(arquivos)] : []),
     ...bloco('Pendências:', pendencias),
-    ...bloco('Atenção:', avisosDe(d, pasta)),
+    ...(d.ehCopia && pendencias.length ? [] : bloco('Atenção:', avisosDe(d, pasta))),
   ]);
 }
 
+/** `## Sobre esta pasta`: o que é a pasta da entrega (com a cópia, onde ela está) ou o que é a cópia. */
+function sobre(d) {
+  if (d.ehCopia) return TEXTO.sobreDaCopia(d.run);
+  return d.copiaEm ? TEXTO.sobreComCopia(d.copiaEm) : TEXTO.sobre;
+}
+
 /**
  * @param {object} d
  * @param {string} d.crew nome da crew · @param {string} d.run id da execução
  * @param {string[]} d.pastas os canais presentes, na ordem das seções
- * @param {object[]} d.arquivos `{ pasta, nome, tipo, origem, titulo, numerado }`
+ * @param {object[]} d.arquivos `{ pasta, nome, tipo, origem, titulo, numerado }` — no LEIA-ME da
+ *   cópia, só os que foram copiados
  * @param {object[]} d.avisos `{ pasta, texto, tela }` (`tela`: como o aviso sai no resumo da tela)
- * @param {Map<string, string[]>} d.pendencias por pasta · @param {string[]} d.alertas regra 34
+ * @param {Map<string, string[]>} d.pendencias por pasta, as não aceitas
+ * @param {Map<string, object[]>} d.ressalvas por pasta, as aceitas: `{ linha, chave, preencher }`
+ * @param {object[]} d.alertas regra 34: `{ pasta, texto }`
  * @param {string[]} d.naoConferido · @param {string[]} d.vaiPublicar canais que a crew publica
+ * @param {string|null} [d.copiaEm] a pasta da cópia, relativa ao projeto, quando ela foi feita
+ * @param {boolean} [d.ehCopia] é o LEIA-ME da cópia: todo arquivo citado existe nela
+ * @param {number} [d.reentrega] na cópia, o número da pasta: de 2 em diante, o título diz `(reentrega N)`
  * @returns {string} o LEIA-ME, em UTF-8 sem BOM e com LF
  */
 export function montarLeiame(d) {
   const temMd = d.arquivos.some((a) => a.nome.toLowerCase().endsWith('.md'));
   const partes = [
-    `# Entrega — ${d.crew} — ${d.run}`,
+    `# Entrega — ${d.crew} — ${d.run}${d.reentrega > 1 ? ` (reentrega ${d.reentrega})` : ''}`,
     ...antesDeUsar(d),
     ...d.pastas.flatMap((pasta) => secaoDoCanal(d, pasta)),
     ...secaoDaPasta(d, OUTROS, 'Outros arquivos'),
     ...secaoDaPasta(d, EDITAVEIS, 'Editáveis'),
     ...secao('O que não foi conferido', [lista(d.naoConferido)]),
     ...(temMd ? secao('Para ter um PDF', [TEXTO.pdf]) : []),
-    ...secao('Sobre esta pasta', [TEXTO.sobre]),
+    ...secao('Sobre esta pasta', [sobre(d)]),
   ];
   return `${partes.join('\n\n')}\n`;
-}
+}

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

@@ -1,8 +1,9 @@
 // Peças que vêm do leitor do verificador (`lerPecas`): legenda, post e tweet, cada um com as
 // suas hashtags no fim — e o primeiro comentário do LinkedIn, que sai do texto do post.
-// Spec: fase-u3a1-pasta-de-entrega.md, §4 e regra 4 (repositório do OpenCrew).
+// Spec: fase-u3a1-pasta-de-entrega.md, §4 e regra 4 (repositório do OpenCrew). A legenda sem
+// marcador (o arquivo que é só o texto) é da fase-u3a2-entrega-no-projeto.md, §4.
 import { semAcento } from '../verificar/leitura.mjs';
-import { lerPecas, listarHashtags } from '../verificar/pecas.mjs';
+import { contarSlides, lerPecas, listarHashtags } from '../verificar/pecas.mjs';
 import { lerTrechos, marcar, rotuloDe } from '../verificar/secoes.mjs';
 import { paraColar } from './texto.mjs';
 
@@ -93,6 +94,17 @@ function distribuir(marcas, comentarios) {
   return marcas.map((numeros) => (numeros.length ? numeros : sobras.splice(0, 1)).map((n) => comentarios[n]).join('\n\n'));
 }
 
+/**
+ * Arquivo de `instagram-feed` que é só o texto (sem rótulo, sem cabeçalho e sem linha "Slide N"): o
+ * corpo inteiro é a legenda, como o leitor do verificador já faz com o post e com o tweet. A
+ * unidade sai com `inteiro: true`, para o aviso.
+ */
+function legendaInteira(corpo) {
+  const soTexto = corpo.trim() && !contarSlides(corpo) && !marcar(corpo).some((m) => m.rotulo || m.nivel);
+  if (!soTexto) return [];
+  return [{ tipo: 'legenda', titulo: null, ordem: 1, total: 1, inteiro: true, partes: [{ nome: 'legenda', sufixo: '', ext: 'txt', tipo: 'legenda', texto: paraColar(corpo) }] }];
+}
+
 /**
  * Lê as peças do formato num corpo já sem frontmatter e sem blocos de serviço.
  * @returns {{ unidades: object[], temSlides: boolean, outros: string[] }} `unidades`: uma por
@@ -116,5 +128,6 @@ export function pecasDoLeitor(corpoOriginal, formato) {
     return { tipo, titulo: titulos[i], ordem: i + 1, total: principais.length, partes };
   });
   const outros = pecas.filter((p) => p.formato !== tabela && p.tipo !== 'hashtags' && p.cabecalho).map((p) => p.cabecalho);
-  return { unidades, temSlides: pecas.some((p) => p.formato === tabela && p.tipo === 'slides'), outros: [...new Set(outros)] };
+  const achadas = unidades.length || tipo !== 'legenda' ? unidades : legendaInteira(corpo);
+  return { unidades: achadas, temSlides: pecas.some((p) => p.formato === tabela && p.tipo === 'slides'), outros: [...new Set(outros)] };
 }

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

@@ -0,0 +1,65 @@
+// `--lembrar-destino`: grava `entrega.destino` no `crew.yaml`, sem mexer em nenhuma outra linha, e
+// deixa ao lado a cópia do arquivo anterior (`crew.yaml.bak`; se já existe, `.bak-<data-hora>`).
+// É o único arquivo fora da execução e do destino que a entrega escreve.
+// Spec: fase-u3a2-entrega-no-projeto.md, regra 16 (repositório do OpenCrew).
+import { constants, existsSync, promises as fs } from 'node:fs';
+import path from 'node:path';
+import { blocoDaEntrega, destinoDoTexto, validarDestino } from './destino.mjs';
+
+const FIM = /\r?\n$/;
+const fimDe = (linha) => linha.match(FIM)?.[0] ?? '';
+const recuoDe = (linha) => linha.match(/^[ \t]*/)[0];
+
+/** O que já está gravado é o mesmo destino? (`Não` e `nao` são o mesmo "não"; `a\b` e `a/b`, a mesma pasta) */
+function jaGravado(raiz, texto, destino) {
+  const escrito = destinoDoTexto(texto);
+  if (escrito == null) return false;
+  const atual = validarDestino(raiz, escrito);
+  return atual.tipo === destino.tipo && atual.rel === destino.rel;
+}
+
+/** Troca a linha de `destino:` (e a lista que vinha embaixo dela, se havia) pela linha nova. */
+function trocar(linhas, bloco, linhaNova, eol) {
+  const i = bloco.destino;
+  let fim = i + 1;
+  while (fim < bloco.fim && linhas[fim].trim() && recuoDe(linhas[fim]).length > bloco.recuo.length) fim += 1;
+  linhas.splice(i, fim - i, `${linhaNova}${fimDe(linhas[i]) || eol}`);
+}
+
+/** O texto do `crew.yaml` com `entrega.destino: valor`; as outras linhas ficam como estavam, byte a byte. */
+export function comDestino(texto, valor) {
+  const eol = texto.includes('\r\n') ? '\r\n' : '\n';
+  const linhas = texto.split(/(?<=\n)/);
+  const bloco = blocoDaEntrega(linhas);
+  const escrito = valor === 'nao' ? 'nao' : JSON.stringify(valor);
+  if (bloco && bloco.destino >= 0) trocar(linhas, bloco, `${bloco.recuo}destino: ${escrito}`, eol);
+  else if (bloco) {
+    if (!fimDe(linhas[bloco.inicio])) linhas[bloco.inicio] += eol;
+    linhas.splice(bloco.inicio + 1, 0, `${bloco.recuo}destino: ${escrito}${eol}`);
+  } else {
+    if (linhas.length && !fimDe(linhas.at(-1))) linhas.push(eol);
+    linhas.push(`entrega:${eol}`, `  destino: ${escrito}${eol}`);
+  }
+  return linhas.join('');
+}
+
+const nomeDaCopia = (arquivo) => (existsSync(`${arquivo}.bak`) ? `${arquivo}.bak-${new Date().toISOString().replace(/[:.]/g, '-')}` : `${arquivo}.bak`);
+
+/**
+ * Grava o destino no `crew.yaml`. Valor igual ao gravado: nada é regravado (nem cópia nova).
+ * @param {string} raiz pasta do projeto · @param {string} crew pasta da crew, absoluta
+ * @param {object} destino o que `validarDestino` devolveu: `nao` ou `pasta`
+ * @returns {Promise<string|null>} null quando está gravado; senão, o arquivo que não foi gravado
+ */
+export async function lembrarDestino(raiz, crew, destino) {
+  const arquivo = path.join(crew, 'crew.yaml');
+  try {
+    const antes = await fs.readFile(arquivo, 'utf8');
+    if (jaGravado(raiz, antes, destino)) return null;
+    await fs.copyFile(arquivo, nomeDaCopia(arquivo), constants.COPYFILE_EXCL);
+    await fs.writeFile(arquivo, comDestino(antes, destino.tipo === 'nao' ? 'nao' : destino.rel), 'utf8');
+    return null;
+  } catch {
+    return arquivo;
+  }
+}

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

@@ -1,9 +1,12 @@
 // 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).
+// Specs: fase-u3a1-pasta-de-entrega.md, §4, e fase-u3a2-entrega-no-projeto.md, §4 (o primeiro
+// passo do canal com ressalva), no repositório do OpenCrew.
 
 /** O primeiro passo do canal que não está pronto (ajuste da execução real). */
 export const ANTES_DE_POSTAR = 'Antes de postar, resolva o que está em Pendências. Corrija no arquivo de origem e peça para montar a entrega de novo: o que você mudar nesta pasta se perde.';
+/** O primeiro passo do canal entregue com ressalva. */
+export const CONFIRA_AS_RESSALVAS = 'Antes de postar, confira as ressalvas em "Antes de usar".';
 const MARKDOWN = 'Este texto está em markdown: se o seu editor não aceitar, ajuste títulos, negrito e links depois de colar.';
 
 // Cada passo: [o que o faz aparecer, o texto]. null = sempre que o canal tem arquivo; um tipo de
@@ -87,13 +90,15 @@ function doQuadro(pasta, arquivos) {
 }
 
 /**
- * Os passos de um canal. No canal que não está pronto, o primeiro manda resolver as pendências.
+ * Os passos de um canal. No canal que não está pronto, o primeiro manda resolver as pendências; no
+ * que foi entregue com ressalva, manda conferir as ressalvas.
  * @param {string} pasta a pasta do canal
  * @param {object[]} arquivos os arquivos da entrega nessa pasta: `{ nome, tipo, numerado, texto }`
- * @param {boolean} [comPendencia] o canal tem pendência
+ * @param {boolean} [comPendencia] o canal tem pendência · @param {boolean} [comRessalva] tem ressalva
  * @returns {string[]}
  */
-export function passosDe(pasta, arquivos, comPendencia = false) {
+export function passosDe(pasta, arquivos, comPendencia = false, comRessalva = false) {
   const passos = doQuadro(pasta, arquivos);
-  return comPendencia && passos.length ? [ANTES_DE_POSTAR, ...passos] : passos;
+  const antes = comPendencia ? ANTES_DE_POSTAR : comRessalva ? CONFIRA_AS_RESSALVAS : null;
+  return antes && passos.length ? [antes, ...passos] : passos;
 }

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

@@ -1,6 +1,7 @@
 // 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).
+// Specs: fase-u3a1-pasta-de-entrega.md, regras 17, 19, 20 e 34, e fase-u3a2-entrega-no-projeto.md,
+// regra 18: a chave de cada pendência, que a faz virar ressalva (repositório do OpenCrew).
 import path from 'node:path';
 import { lerLimites } from '../verificar/leitura.mjs';
 import { contar, FALTA_INFO, NAO_MEDIDO, NAO_VERIFICADO } from '../verificar/regras.mjs';
@@ -28,16 +29,24 @@ function linhaDoItem(i, arquivo) {
 /** O resultado do verificador para um item da lista (só os arquivos de texto têm). */
 const resultadoDe = (raiz, r, item) => r.arquivos.find((a) => path.resolve(raiz, a.arquivo) === item.abs && (a.formato ?? null) === (item.formato ?? null));
 
+/** A pendência de um bloqueio: a linha, a chave que a identifica e, em [PREENCHER], o trecho pedido. */
+function doBloqueio(i, arquivo) {
+  const trecho = i.medido != null ? `${i.medido}/${i.limite}` : String(i.detalhe ?? '');
+  return { linha: linhaDoItem(i, arquivo), chave: { arquivo, item: i.item, trecho }, preencher: i.item === FALTA_INFO ? i.detalhe : null };
+}
+
 /**
  * Pendências por pasta da entrega (canal ou `outros`), na ordem da lista.
- * @returns {Map<string, string[]>} só as pastas que têm pendência
+ * @returns {Map<string, object[]>} só as pastas que têm pendência: `{ linha, chave, preencher }` —
+ *   `chave`: `{ arquivo, item, trecho }` (em bloqueio de medida, o trecho é `medido/limite`); null
+ *   no arquivo que não existe, que nunca vira ressalva
  */
 export function pendenciasPorPasta(raiz, itens, r) {
   const mapa = new Map();
-  const somar = (item, linha) => mapa.set(item.canal ?? OUTROS, [...(mapa.get(item.canal ?? OUTROS) ?? []), linha]);
+  const somar = (item, p) => mapa.set(item.canal ?? OUTROS, [...(mapa.get(item.canal ?? OUTROS) ?? []), p]);
   for (const item of itens) {
-    if (item.tipo !== 'arquivo') somar(item, MSG.naoEncontrei(item.rel));
-    for (const i of resultadoDe(raiz, r, item)?.itens ?? []) if (i.nivel === 'bloqueio') somar(item, linhaDoItem(i, item.rel));
+    if (item.tipo !== 'arquivo') somar(item, { linha: MSG.naoEncontrei(item.rel), chave: null, preencher: null });
+    for (const i of resultadoDe(raiz, r, item)?.itens ?? []) if (i.nivel === 'bloqueio') somar(item, doBloqueio(i, item.rel));
   }
   return mapa;
 }
@@ -73,6 +82,7 @@ function jaApontada(itensDaOrigem, a) {
  * Regra 34: cada `legenda*.txt`, `post*.txt` (não o comentário) e `tweet*.txt` gerado é contado
  * como o verificador conta e comparado com o limite do formato do item. Passou: um ALERTA — mas
  * só quando o verificador não apontou a mesma peça. Não é pendência.
+ * @returns {Promise<{ pasta: string, texto: string }[]>}
  */
 export async function alertasDeTamanho(raiz, itens, arquivos, r) {
   const alertas = [];
@@ -81,7 +91,7 @@ export async function alertasDeTamanho(raiz, itens, arquivos, r) {
     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));
+    if (typeof limite === 'number' && medido > limite && !jaApontada(daOrigem, a)) alertas.push({ pasta: a.pasta, texto: MSG.alerta(`${a.pasta}/${a.nome}`, medido, limite) });
   }
   return alertas;
 }

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

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

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

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

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

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

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

@@ -1,6 +1,7 @@
 // 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).
+// Spec: fase-u3a1-pasta-de-entrega.md, §4 e regras 4, 8, 9 e 11 (repositório do OpenCrew). O
+// `doCanal` da cópia é da fase-u3a2-entrega-no-projeto.md, regra 14: o editável segue o canal dele.
 import path from 'node:path';
 import { lerItem } from '../verificar/arquivos.mjs';
 import { semFrontmatter } from '../verificar/leitura.mjs';
@@ -14,6 +15,7 @@ export const MSG = {
   // Só no resumo da tela: no LEIA-ME, a linha do arquivo em "Outros arquivos" já diz.
   semCanal: (arquivo) => `${arquivo} não tem canal conhecido. Está em \`outros/\`.`,
   semPeca: (peca, arquivo) => `Não encontrei ${peca} em ${arquivo}. Confira antes de colar.`,
+  legendaInteira: (arquivo) => `Não encontrei a legenda marcada em ${arquivo}: usei o texto inteiro. Confira antes de colar.`,
   outroCanal: (arquivo, cabecalho) => `${arquivo} tem uma seção de outro canal (${cabecalho}) que não foi separada. Ela continua no arquivo de origem.`,
 };
 
@@ -35,7 +37,7 @@ const ehEditavel = (item, itens) => HTML.has(extensao(item)) && itens.some((i) =
 
 /** 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) };
+  const base = { pasta, nome: path.basename(item.abs), tipo, origem: item.rel, pastaDeOrigem: path.dirname(item.abs), doCanal: item.canal ?? OUTROS };
   return texto ? { ...base, texto } : { ...base, de: item.abs };
 }
 
@@ -64,6 +66,7 @@ function separarPecas(item, texto, itens, p) {
   const { tipo, unidades, temSlides, outros, fora } = lerUnidades(texto, item.formato);
   const comArquivo = unidades.map((u) => ({ ...u, partes: u.partes.filter((parte) => parte.texto) })).filter((u) => u.partes.length);
   for (const u of comArquivo) p.unidades.push({ ...u, pasta: item.canal, origem: item.rel, formato: item.formato });
+  if (comArquivo.some((u) => u.inteiro)) p.avisos.push({ pasta: item.canal, texto: MSG.legendaInteira(item.rel) });
   for (const cabecalho of outros) p.avisos.push({ pasta: item.canal, texto: MSG.outroCanal(item.rel, cabecalho) });
   const semImagem = !itens.some((i) => i.tipo === 'arquivo' && ehImagem(i) && i.formato === item.formato);
   if (!comArquivo.length) p.avisos.push({ pasta: item.canal, texto: MSG.semPeca(DITA[tipo], item.rel) });
@@ -93,7 +96,7 @@ async function separarItem(item, itens, p) {
  *   `{ 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 }`
+ *   · `copias`: `{ pasta, nome, tipo, origem, pastaDeOrigem, doCanal, de | texto }`
  *   · `avisos`: `{ pasta, texto, tela }` (`tela`: o texto do resumo da tela; sem `texto`, só sai lá)
  */
 export async function separar(itens) {