@aksp/opencrew 1.7.1 → 1.9.0

package/templates/_opencrew/core/prompts/export.prompt.md

@@ -1,59 +1,16 @@
-# Export — Multi-Format Output
+# Export — Tables to CSV
 
-You are the opencrew Export agent. Your role is to transform pipeline outputs from markdown into the requested delivery format. You do NOT create content or make editorial decisions — you transform existing, approved content.
+You are the opencrew Export agent. Your role is to transform the tables of a pipeline output from markdown into CSV. You do NOT create content or make editorial decisions — you transform existing, approved content.
 
 ## Context Loading
 
 Before starting, read:
 - The input file specified by the step's `inputFile` field — this is the source content to export
-- The step's `format:` field — this determines the target output format
+- The step's `format:` field — `csv` is the only export format
 
 ---
 
-## Supported Formats
-
-### PDF (`format: pdf`)
-
-Transform markdown content into a PDF file using Playwright (already available in the project).
-
-**Process:**
-1. Read the full input markdown file
-2. Convert markdown to clean HTML:
-   - Use semantic HTML5 tags (`<article>`, `<section>`, `<h1>`-`<h6>`, `<p>`, `<ul>`, `<ol>`, `<blockquote>`)
-   - Preserve the original heading hierarchy
-   - Convert markdown tables to HTML tables with basic styling
-   - Wrap code blocks in `<pre><code>` with monospace font
-   - Handle bold, italic, links, and lists
-3. Wrap in a minimal HTML document with print-friendly CSS:
-   ```html
-   <!DOCTYPE html>
-   <html lang="pt-BR">
-   <head>
-     <meta charset="UTF-8">
-     <style>
-       @page { margin: 2cm; size: A4; }
-       body { font-family: 'Segoe UI', system-ui, sans-serif; font-size: 12pt; line-height: 1.6; color: #1a1a1a; }
-       h1 { font-size: 22pt; margin-top: 0; }
-       h2 { font-size: 16pt; border-bottom: 1px solid #ddd; padding-bottom: 4pt; }
-       h3 { font-size: 13pt; }
-       table { border-collapse: collapse; width: 100%; margin: 12pt 0; }
-       th, td { border: 1px solid #ddd; padding: 6pt 8pt; text-align: left; }
-       th { background: #f5f5f5; }
-       code { font-family: 'Cascadia Code', 'Fira Code', monospace; font-size: 10pt; background: #f0f0f0; padding: 1pt 4pt; border-radius: 3pt; }
-       pre code { display: block; padding: 8pt 12pt; overflow-x: auto; }
-       blockquote { border-left: 3pt solid #ccc; margin-left: 0; padding-left: 12pt; color: #555; }
-     </style>
-   </head>
-   <body>{content}</body>
-   </html>
-   ```
-4. Write the HTML to a temporary file: `crews/{crew-name}/output/{run_id}/export/temp.html`
-5. Use Playwright to render the HTML as PDF:
-   ```bash
-   npx playwright open --viewport=1240,1754 "crews/{crew-name}/output/{run_id}/export/temp.html"
-   ```
-   Then use the print-to-PDF functionality.
-6. Save the PDF to the step's `outputFile` path
+## Supported Format
 
 ### CSV / Excel (`format: csv`)
 
@@ -84,50 +41,17 @@ Keyword,Intent,Volume,Competition
 "product adoption",Informational,Low,Low
 ```
 
-### Formatted Social Post (`format: formatted-post`)
-
-Transform markdown content into a platform-ready post with proper formatting.
-
-**Process:**
-1. Read the full input markdown file
-2. Extract the post content: caption/hook, body, CTA, hashtags
-3. Format for the specified platform (from step metadata or crew context):
-   - **LinkedIn**: Preserve line breaks, use minimal emoji, 1-2 relevant hashtags at end
-   - **Twitter/X**: Condense to character limit, thread format if needed, hashtag strategy
-   - **Instagram**: Format caption with line breaks, group hashtags (3-5 max), emoji placement
-4. Output as clean text with platform-specific formatting notes:
-   ```markdown
-   # Formatted Post — {platform}
-
-   **Caption:**
-   {formatted caption text}
-
-   **Hashtags:**
-   {hashtag list}
-
-   **Formatting notes:**
-   - Line breaks: {count} intentional breaks
-   - Character count: {N}
-   - Best posting time: {recommendation based on crew context}
-   ```
-
----
-
 ## Smart Recommendations
 
-- **Multiple outputs from same content**: If the crew produces one piece of content that needs to go to multiple platforms, batch the exports. Export the same source to all required formats in sequence.
-- **PDF quality**: The print CSS is minimal but functional. For brand-specific PDFs (logos, custom fonts, color schemes), the user should use a design template (via `template-designer` skill).
+- **Text for each channel**: the delivery folder of the run already has the text of each channel ready to paste, and its `LEIA-ME.md` — this prompt does not format posts.
 - **CSV structure**: The CSV export extracts ALL tables from the source. If the source has one main data table, it produces one clean CSV. If it has many, they're separated by `# Table:` headers.
 
 ## Limitations
 
-- PDF export uses Playwright's built-in print-to-PDF. Complex layouts (multi-column, absolute positioning) may not render correctly.
 - CSV export is from markdown tables only — it does not parse JSON, YAML, or unstructured data.
-- Formatted posts assume the content was written for the target platform. Cross-platform adaptation (e.g., blog → Twitter thread) should be done by a content agent before export.
 
 ## Error Handling
 
 - If the input file is missing → **ERROR**: stop, inform the user
 - If the input file has no extractable content for the target format (e.g., CSV requested but no tables found) → warn the user, save a note in the output file
-- If Playwright is unavailable for PDF export → fall back to saving the HTML file as the output, inform the user
 - **Never fabricate content — only transform what exists in the input file**

package/templates/_opencrew/core/runner.pipeline.md

@@ -283,19 +283,17 @@ Before executing any step that references an agent:
    - Apply Voice Guidance (vocabulary always/never use, tone rules)
 5. **Inject format context**: Check if the current step's frontmatter contains a `format:` field.
    If present:
-   a. **Export formats** — if format is one of `pdf`, `csv`, or `formatted-post`:
-      - Read `_opencrew/core/prompts/export.prompt.md`
-      - Parse the YAML frontmatter to extract the `name` field
-      - Extract the Markdown body (everything after the YAML frontmatter closing `---`)
-      - Append to the agent's context, before skill instructions:
-        ```
-        --- EXPORT FORMAT: {format} ---
-
-        {export.prompt.md markdown body}
-        ```
-      - The agent must follow the export process for the specified format — read the input file,
-        transform the content, and write the output file in the target format.
-      - Skip the best-practices lookup below for export formats.
+   a. **Export format** — if format is `csv`:
+      - Read `_opencrew/core/prompts/export.prompt.md` and append its Markdown body to the agent's
+        context, before skill instructions, under the line `--- EXPORT FORMAT: csv ---`
+      - The agent must follow the export process — read the input file, transform the content,
+        and write the output file in the target format. Skip the best-practices lookup below.
+   a2. **`pdf` or `formatted-post`** (a step of an old crew) — neither is generated any more. Say
+      `O formato "{id}" não é mais gerado. O passo segue sem ele e grava o texto em markdown. Para ter um PDF, use Imprimir → Salvar como PDF.`
+      (`{id}` = the format) and run it as a common step, with no format injection. For `pdf`, the
+      agent writes markdown and the `outputFile` is used with the extension `.md`: that is the
+      path that goes to `caminho.mjs` (`saida`, `conferir`) and that the next steps read (their
+      `inputFile`, too) — no `.pdf` is created.
    b. **Content formats** — otherwise, read `_opencrew/best-practices.local/{format}.md` (the user's
       own version, never touched by `update`) if it exists, else `_opencrew/core/best-practices/{format}.md`
       (e.g., `_opencrew/core/best-practices/instagram-feed.md`)
@@ -500,6 +498,7 @@ root the one-line command of each moment and read the last line (`CAMINHO:OK {pa
      is empty → this check never fires (legacy behavior).
 
 0b. **Escritório** — if it is on, run `passo`, or `checkpoint` when the step is a checkpoint (see "Escritório" above).
+0c. **Entrega** — before the first step that publishes or sends, once the final approval was given, run the delivery (see "Entrega" below).
 
 1. **Pre-Step Input Validation** — MANDATORY. If the step's frontmatter declares an `inputFile`, the input comes from the `entrada` action, never from a path you build: validate that the input exists before executing the step. Run the `entrada` command (Output Path Transformation) with the `inputFile` as declared:
    - `CAMINHO:OK {path}` → that path is the step's input (the newest version that has the file): read the input from it and execute the step.
@@ -668,10 +667,10 @@ When a step has `on_reject: {step-id}` (a review step):
    the `format:` of the step that generated that file; a step with no `format:`, with an export
    format (`pdf`, `csv`, `formatted-post`) or with one outside `[a-z0-9-]+` goes without `=formato`:
    ```bash
-   node _opencrew/core/scripts/verificar.mjs --crew "crews/{name}" --arquivo "{path1}={format1},{path2},…"
+   node _opencrew/core/scripts/verificar.mjs --crew "crews/{name}" --arquivo "{path1}={format1},{path2},…" --relatorio "crews/{name}/output/{run_id}/verificacao-ciclo-{N}.md"
    ```
-   Save the full output to `crews/{name}/output/{run_id}/verificacao-ciclo-{N}.md` and inject it
-   into the reviewer's context as `--- VERIFICAÇÃO AUTOMÁTICA ---`. The reviewer must copy the
+   The script writes its report to that file (`{N}` = the cycle; do not save it yourself). Inject
+   the output into the reviewer's context as `--- VERIFICAÇÃO AUTOMÁTICA ---`. The reviewer must copy the
    measured values from it (see best-practices `review.md`). If the checker did not run (no Node,
    an error, or no `VERIFICACAO:` status line), tell the user, continue with the normal review and
    repeat it at the final approval: "⚠️ A verificação automática não rodou: {motivo}".
@@ -694,11 +693,12 @@ When a step has `on_reject: {step-id}` (a review step):
    {any other status} A revisão não aprovou o texto depois de {N} ciclos. Motivo: {parecer resumido}
 
    1. Corrigir eu mesmo (eu edito o texto e você verifica de novo)
-   2. Aceitar assim mesmo
+   2. Aceitar assim mesmo (fica registrado na entrega)
    3. Abortar
    ```
 5. **Final approval checkpoint** (the checkpoint after the review): show the summary of the last
-   report — `Verificação automática: {N} bloqueios, {M} alertas, {Z} não medidos` — plus the list
+   report — `Verificação automática: {N} bloqueios, {M} alertas, {Z} não medidos`, with
+   `{P} a preencher` right after the blocks when the report counts any — plus the list
    of alerts and the {Z} items not measured or not verified (the `Não medido` and `Não verificado`
    lines under each file, not the "não é texto" line of **Notas**), one per line as
    `{arquivo} — {motivo}`, then the lines under `**Notas:**` in that report, as they are written,
@@ -706,7 +706,8 @@ When a step has `on_reject: {step-id}` (a review step):
    every file left unchecked by the safe-name rule. List the same way every file the path script
    did not check (see Output Path Transformation). If the approved
    text still contains `[PREENCHER: …]`, ask the user for each missing piece of real information
-   and write it into the text before approving.
+   and write it into the text before approving. If the user does not have it, do not insist and
+   never invent: keep the `[PREENCHER]`, say `Sem problema: deixo [PREENCHER: {o que falta}] no texto. Na entrega você escolhe entre preencher depois e entregar assim mesmo, com ressalva.` and go on.
 
 ### Step Execution Order (Summary)
 
@@ -715,6 +716,7 @@ For reference, the complete execution order for each pipeline step is:
 ```
 0. Agent deselection check (skip step if its agent was deselected)
 0b. Escritório command (passo or checkpoint) — only if it is on
+0c. Entrega (delivery script) — only before the first step that publishes or sends
 1. Pre-Step Input Validation (script gate: `entrada`)
 2. Read step file
 3. Check execution mode and execute (subagent / inline / checkpoint)
@@ -724,10 +726,18 @@ For reference, the complete execution order for each pipeline step is:
 
 Steps 1 and 4 are binary script gates. If either fails, the pipeline does NOT advance — the user is consulted.
 
+### Entrega
+
+One script turns the approved files into `crews/{name}/output/{run_id}/entrega/` (a folder per channel, text ready to paste, a `LEIA-ME.md`) and copies what is ready to the folder of the project the user chose. Read `_opencrew/core/prompts/entrega.prompt.md` and follow it: how to build `{lista}`, when to add `--vai-publicar`, what to do with `ENTREGA:OK`, `ENTREGA:COM_RESSALVA` and `ENTREGA:INCOMPLETA`, the question about the folder of the project that keeps a copy (asked once per crew) and what to do with a script that did not run.
+
+- **Command** — from the project root, by the safe-name rule (nome seguro), everything between double quotes: `node _opencrew/core/scripts/entregar.mjs --crew "crews/{name}" --run "{run_id}" --arquivo "{lista}"`
+- **When** — once, after the final approval, immediately before the first step that publishes or sends (`side_effects: irreversible`, in the step or in the agent's skill); with no such step, after the last step. Always before the end-of-run command of the Escritório. If the irreversible step comes before the final approval (a crew built by an old version), the delivery runs at the end.
+- **Crew with no final approval checkpoint** — same moments, and show `Esta crew não tem aprovação final: confira os arquivos antes de usar.` **Never** for a run that was rejected, aborted before the final approval or left with no approved file.
+- The output of the script is the final summary of the run: show it as it came; if the run stops later, at an irreversible step, show it before stopping. After "Edit this content" changes an approved file, run it again.
+
 ### After Pipeline Completion
 
-1. Save final output to `crews/{name}/output/{run_id}/{filename}.md`
-   (The run folder was created during initialization — no separate date subfolder needed)
+1. **Entrega** — if the delivery has not run in this run, run it now (see "Entrega" above).
 1b. **Escritório** — if it is on, run `concluir` (see "Escritório" above).
 
 2. **Update crew memory** — write to BOTH files:
@@ -828,8 +838,7 @@ Steps 1 and 4 are binary script gates. If either fails, the pipeline does NOT ad
    ```
    ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
    ✅ Pipeline complete!
-   📁 Run folder: crews/{name}/output/{run_id}/
-   📄 Output saved to: {output path}
+   📁 Delivery: crews/{name}/output/{run_id}/entrega/ — start with LEIA-ME.md
    ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
 
    What would you like to do?

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

@@ -0,0 +1,50 @@
+// Linha de comando do `entregar.mjs`: as opções, a lista `caminho=formato` e a linha de uso.
+// Specs: fase-u3a1-pasta-de-entrega.md, §3 e §6, e fase-u3a2-entrega-no-projeto.md, §3
+// (repositório do OpenCrew).
+import { lerItemDaLista } from '../verificar/argumentos.mjs';
+
+export const USO = 'Uso: 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]';
+
+const OPCAO = /^--(crew|run|arquivo|vai-publicar|destino|lembrar-destino)(?:=(.*))?$/s;
+const CHAVE = { 'lembrar-destino': 'lembrarDestino' };
+
+/** Texto que veio da linha de comando e volta numa mensagem: uma linha só, até 200 caracteres. */
+export const limpar = (valor) => String(valor).replace(/\s+/g, ' ').trim().slice(0, 200);
+
+function guardar(args, nome, valor) {
+  if (nome === 'arquivo') args.arquivos.push(valor);
+  else if (nome === 'vai-publicar') args.vaiPublicar.push(valor.trim().toLowerCase());
+  else args[CHAVE[nome] ?? nome] = valor;
+}
+
+/**
+ * `argv` → `{ crew, run, arquivos, vaiPublicar, destino, lembrarDestino, aceitar, ajuda,
+ * desconhecida }`. Opção vale como `--nome valor` e `--nome=valor`. `--arquivo` e `--vai-publicar`
+ * repetidos somam, e o que vem solto logo depois da lista é mais um item dela. `destino` e
+ * `lembrarDestino` ficam sem valor (undefined) quando a opção não veio. `desconhecida`: a primeira
+ * opção que o script não conhece, ou null.
+ */
+export function lerArgs(argv) {
+  const args = { arquivos: [], vaiPublicar: [], aceitar: false, ajuda: false, desconhecida: null };
+  let naLista = false;
+  for (let i = 0; i < argv.length; i++) {
+    const [, nome, colado] = argv[i].match(OPCAO) ?? [];
+    const solto = !nome && !argv[i].startsWith('--');
+    if (nome) guardar(args, nome, colado ?? (i + 1 < argv.length && !argv[i + 1].startsWith('--') ? argv[++i] : ''));
+    else if (argv[i] === '--ajuda') args.ajuda = true;
+    else if (argv[i] === '--aceitar-pendencias') args.aceitar = true;
+    else if (solto && naLista) args.arquivos.push(argv[i]);
+    else args.desconhecida ??= argv[i];
+    naLista = nome ? nome === 'arquivo' : solto && naLista;
+  }
+  return args;
+}
+
+/** A lista de `--arquivo` → `[{ arquivo, formato }]` (`formato` null quando não veio `=formato`). */
+export function lerLista(arquivos) {
+  const textos = arquivos.join(',').split(',').map((s) => s.trim()).filter(Boolean);
+  return textos.map(lerItemDaLista).map((i) => (typeof i === 'string' ? { arquivo: i, formato: null } : i));
+}
+
+/** O `--run` é um segmento só: sem `/`, `\` nem `..`. */
+export const runValido = (run) => !/[\\/]/.test(run) && run !== '..' && run !== '.';

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

@@ -0,0 +1,53 @@
+// Canais da entrega: a pasta de cada formato (o `platform:` do best-practice), os nomes que o
+// LEIA-ME mostra e o que nunca entra numa entrega.
+// Spec: fase-u3a1-pasta-de-entrega.md, regras 1 e 3 (repositório do OpenCrew).
+import { existsSync } from 'node:fs';
+import path from 'node:path';
+import { lerFrontmatter, lerTexto } from '../verificar/leitura.mjs';
+
+/** Pasta do canal → nome no LEIA-ME, na ordem em que as seções aparecem. */
+export const CANAIS = { instagram: 'Instagram', linkedin: 'LinkedIn', blog: 'Blog', email: 'E-mail', whatsapp: 'WhatsApp', twitter: 'X/Twitter', youtube: 'YouTube' };
+export const OUTROS = 'outros';
+export const EDITAVEIS = 'editaveis';
+export const ehCanal = (pasta) => Object.hasOwn(CANAIS, pasta);
+/** Como a pasta é chamada numa mensagem: o nome do canal, ou `outros/`. */
+export const nomeDaPasta = (pasta) => CANAIS[pasta] ?? `${pasta}/`;
+
+async function plataformaEm(raiz, pasta, formato) {
+  const arquivo = path.join(raiz, '_opencrew', ...pasta, `${formato}.md`);
+  if (!existsSync(arquivo)) return null;
+  const valor = lerFrontmatter(await lerTexto(arquivo))?.platform;
+  return typeof valor === 'string' && valor.trim() ? valor.trim().toLowerCase() : null;
+}
+
+/**
+ * Canal de um formato: o `platform:` de `_opencrew/best-practices.local/<formato>.md`, quando o
+ * arquivo o declara; senão, o do core. Sem formato, sem best-practice, sem `platform:` ou com
+ * plataforma que não é uma das sete pastas: null (o arquivo vai para `outros/`).
+ */
+export async function canalDoFormato(raiz, formato) {
+  if (!formato || !/^[a-z0-9-]+$/.test(formato)) return null;
+  const local = await plataformaEm(raiz, ['best-practices.local'], formato);
+  const plataforma = local ?? (await plataformaEm(raiz, ['core', 'best-practices'], formato));
+  return plataforma && ehCanal(plataforma) ? plataforma : null;
+}
+
+const PASTAS_DE_SERVICO = new Set(['entrega', 'entrega.tmp', 'export']);
+
+/**
+ * Arquivo de serviço nunca entra, mesmo listado: `verificacao-*.md`, `ressalvas.json` (as
+ * pendências aceitas, fase-u3a2-entrega-no-projeto.md, regra 18), `publicado.json`, o que está
+ * em `entrega/`, `entrega.tmp/` ou `export/` de uma execução e o `caption.txt` direto na pasta
+ * da execução (é ali que o publicador o grava; dentro de uma pasta `vN` ele é saída de passo).
+ * E o `copia.json` direto na pasta da execução: o retrato do que foi copiado (mesma spec, regra 14).
+ * @param {string} rel caminho relativo ao projeto, com `/`
+ */
+export function ehDeServico(rel) {
+  const partes = rel.toLowerCase().split('/');
+  const nome = partes.at(-1);
+  if (/^verificacao-.*\.md$/.test(nome) || nome === 'publicado.json' || nome === 'ressalvas.json') return true;
+  const naSaida = partes[0] === 'crews' && partes[2] === 'output';
+  if (!naSaida) return false;
+  if (partes.slice(4, -1).some((p) => PASTAS_DE_SERVICO.has(p))) return true;
+  return (nome === 'caption.txt' || nome === 'copia.json') && partes.length === 5;
+}

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

@@ -0,0 +1,104 @@
+// Comparação entre o que a entrega copiaria agora e a cópia que já está no destino: é ela que
+// decide se nada muda, se só há arquivos a acrescentar ou se a entrega vai para outra pasta.
+// Com o retrato do que foi copiado (`copia.json`, ver `retrato.mjs`), a comparação é com ele: o que o
+// usuário fez na cópia depois não conta. Sem retrato, é com os arquivos da pasta.
+// Este módulo só lê. Spec: fase-u3a2-entrega-no-projeto.md, regra 14 (repositório do OpenCrew).
+import { createHash } from 'node:crypto';
+import { promises as fs } from 'node:fs';
+import path from 'node:path';
+
+// Em texto, CRLF e LF são o mesmo conteúdo (o editor ou a sincronização trocam); o resto, byte a byte.
+const DE_TEXTO = new Set(['.txt', '.md', '.html', '.htm', '.csv', '.json']);
+export const emLf = (texto) => texto.replace(/\r\n/g, '\n');
+
+/** Os bytes que um arquivo da entrega tem: o texto gerado, ou os do arquivo de origem. */
+export const bytesDe = async (a) => (a.texto != null ? Buffer.from(a.texto, 'utf8') : fs.readFile(a.de));
+
+const ehTexto = (nome) => DE_TEXTO.has(path.extname(nome).toLowerCase());
+const mesmoConteudo = (nome, a, b) => a.equals(b) || (ehTexto(nome) && emLf(a.toString('utf8')) === emLf(b.toString('utf8')));
+
+/** Os arquivos sob uma pasta, com o prefixo dado e `/`; pasta que não existe: nenhum. */
+async function listar(pasta, prefixo) {
+  const entradas = await fs.readdir(pasta, { withFileTypes: true }).catch(() => []);
+  const achados = [];
+  for (const e of entradas) {
+    if (e.isDirectory()) achados.push(...(await listar(path.join(pasta, e.name), `${prefixo}${e.name}/`)));
+    else achados.push(`${prefixo}${e.name}`);
+  }
+  return achados;
+}
+
+const REENTREGA = '-reentrega-';
+
+/** 1 para `<run>`, N para `<run>-reentrega-N` (N ≥ 2), 0 para qualquer outro nome. */
+function numeroDe(nome, run) {
+  if (nome === run) return 1;
+  const n = nome.startsWith(`${run}${REENTREGA}`) ? nome.slice(run.length + REENTREGA.length) : '';
+  return /^[1-9]\d*$/.test(n) && Number(n) >= 2 ? Number(n) : 0;
+}
+
+/**
+ * As pastas desta execução no destino, da mais antiga para a mais nova: `<run>` é a 1 e
+ * `<run>-reentrega-N` é a N. Só pastas: arquivo com um desses nomes não conta.
+ * @returns {Promise<{ n: number, nome: string }[]>}
+ */
+export async function pastasDaExecucao(destino, run) {
+  const entradas = await fs.readdir(destino, { withFileTypes: true }).catch(() => []);
+  const pastas = entradas.filter((e) => e.isDirectory()).map((e) => ({ n: numeroDe(e.name, run), nome: e.name }));
+  return pastas.filter((p) => p.n).sort((a, b) => a.n - b.n);
+}
+
+const hashDe = (nome, bytes) => createHash('sha1').update(ehTexto(nome) ? emLf(bytes.toString('utf8')) : bytes).digest('hex');
+
+/** O retrato de uma lista de arquivos da entrega: `{ 'pasta/nome': hash }` (em texto, sem contar CRLF/LF). */
+export async function retratoDe(arquivos) {
+  const retrato = {};
+  for (const a of arquivos) retrato[`${a.pasta}/${a.nome}`] = hashDe(a.nome, await bytesDe(a));
+  return retrato;
+}
+
+/**
+ * A mesma pergunta de `oQueFalta`, respondida pelo retrato do que foi copiado para a pasta. O que
+ * o usuário editou, apagou ou acrescentou na cópia não é diferença. Arquivo novo cujo lugar já
+ * está ocupado só conta como copiado quando o conteúdo é o mesmo; senão, é diferença.
+ */
+async function contraORetrato(pasta, esperados, canais, ignorar, retrato) {
+  const saiu = (rel) => canais.has(rel.split('/')[0]) && !ignorar.has(rel) && !esperados.has(rel);
+  if (Object.keys(retrato).some(saiu)) return null;
+  const faltam = [];
+  for (const [rel, a] of esperados) {
+    const bytes = await bytesDe(a);
+    if (Object.hasOwn(retrato, rel)) {
+      if (retrato[rel] !== hashDe(rel, bytes)) return null;
+      continue;
+    }
+    const noDisco = await fs.readFile(path.join(pasta, rel)).catch(() => null);
+    if (noDisco == null) faltam.push(a);
+    else if (!mesmoConteudo(rel, noDisco, bytes)) return null;
+  }
+  return faltam;
+}
+
+/**
+ * Compara os arquivos que seriam copiados agora com uma pasta de cópia. Só as pastas de canal que
+ * seriam copiadas agora são olhadas: a raiz da cópia e as outras pastas ficam de fora.
+ * @param {string} pasta a cópia, absoluta · @param {object[]} arquivos `{ pasta, nome, texto | de }`
+ * @param {Set<string>} ignorar `pasta/nome` do que a entrega tem mas não copia agora
+ * @param {object|null} [retrato] o retrato do que foi copiado para esta pasta; null = comparar com os arquivos
+ * @returns {Promise<null | object[]>} null = diferente (arquivo que mudou, saiu ou está a mais);
+ *   senão, os arquivos que faltam na cópia (nenhum = igual)
+ */
+export async function oQueFalta(pasta, arquivos, ignorar, retrato = null) {
+  const esperados = new Map(arquivos.map((a) => [`${a.pasta}/${a.nome}`, a]));
+  if (retrato) return contraORetrato(pasta, esperados, new Set(arquivos.map((a) => a.pasta)), ignorar, retrato);
+  const faltam = new Map(esperados);
+  for (const canal of new Set(arquivos.map((a) => a.pasta))) {
+    for (const rel of await listar(path.join(pasta, canal), `${canal}/`)) {
+      if (ignorar.has(rel)) continue;
+      const a = esperados.get(rel);
+      if (!a || !mesmoConteudo(rel, await fs.readFile(path.join(pasta, rel)), await bytesDe(a))) return null;
+      faltam.delete(rel);
+    }
+  }
+  return [...faltam.values()];
+}

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

@@ -0,0 +1,138 @@
+// A cópia da entrega para a pasta do projeto que o usuário escolheu: uma pasta por execução
+// (`<destino>/<run_id>/`). Nada é sobrescrito, menos o `LEIA-ME.md` da cópia, que é do script.
+// Pasta nova é montada em `<pasta>.tmp/`, ao lado, e renomeada no fim: nada fica pela metade.
+// O script só apaga o temporário que ele mesmo criou. O que o usuário edita na cópia fica: a
+// entrega seguinte é comparada com o retrato do que foi copiado (`retrato.mjs`), não com a pasta.
+// Spec: fase-u3a2-entrega-no-projeto.md, regras 14 e 15 (repositório do OpenCrew).
+import { constants, existsSync, promises as fs } from 'node:fs';
+import path from 'node:path';
+import { emLf, oQueFalta, pastasDaExecucao } from './comparar.mjs';
+
+export const AVISO = (pasta) => `Há uma entrega mais nova desta execução em \`${pasta}\`.`;
+const AVISO_ANTERIOR = /^Há uma entrega mais nova desta execução em `[^`\n]*`\.\r?\n\r?\n/;
+const LEIAME = 'LEIA-ME.md';
+const apagar = (pasta) => fs.rm(pasta, { recursive: true, force: true, maxRetries: 3 });
+const ehPasta = async (p) => fs.stat(p).then((s) => s.isDirectory(), () => false);
+
+/** Grava um arquivo que ainda não existe ali: se existir, falha (nunca por cima). */
+async function gravarNovo(alvo, a) {
+  await fs.mkdir(path.dirname(alvo), { recursive: true });
+  if (a.texto != null) await fs.writeFile(alvo, a.texto, { encoding: 'utf8', flag: 'wx' });
+  else await fs.copyFile(a.de, alvo, constants.COPYFILE_EXCL);
+}
+
+/** Monta a pasta nova no temporário e a põe no lugar; em falha, o temporário some. */
+async function montar(pasta, arquivos, leiame, em) {
+  const tmp = `${pasta}.tmp`;
+  if (await ehPasta(tmp)) await apagar(tmp); // sobra de uma chamada interrompida
+  await fs.mkdir(tmp);
+  try {
+    for (const a of arquivos) {
+      em.alvo = path.join(pasta, a.pasta, a.nome);
+      await gravarNovo(path.join(tmp, a.pasta, a.nome), a);
+    }
+    em.alvo = path.join(pasta, LEIAME);
+    await fs.writeFile(path.join(tmp, LEIAME), leiame, 'utf8');
+    em.alvo = pasta;
+    await fs.rename(tmp, pasta);
+  } catch (erro) {
+    await apagar(tmp).catch(() => {});
+    throw erro;
+  }
+}
+
+/** A pasta mais alta do caminho que ainda não existe (é a que o script cria); null quando todas existem. */
+function primeiraQueFalta(pasta) {
+  let falta = null;
+  for (let p = pasta; !existsSync(p); p = path.dirname(p)) falta = p;
+  return falta;
+}
+
+/** Desfaz as pastas vazias que esta chamada criou, de `pasta` até `criada`. */
+async function desfazer(criada, pasta) {
+  for (let p = pasta; ; p = path.dirname(p)) {
+    await fs.rmdir(p);
+    if (p === criada) return;
+  }
+}
+
+/** Cria `pasta` com a entrega inteira. @returns {Promise<boolean>} o destino precisou ser criado? */
+async function criar(pasta, arquivos, leiame, em) {
+  em.alvo = pasta;
+  if (existsSync(pasta)) throw new Error('já existe um arquivo com o nome da pasta');
+  const destino = path.dirname(pasta);
+  const criada = primeiraQueFalta(destino);
+  try {
+    await fs.mkdir(destino, { recursive: true });
+    await montar(pasta, arquivos, leiame, em);
+  } catch (erro) {
+    if (criada) await desfazer(criada, destino).catch(() => {});
+    throw erro;
+  }
+  return Boolean(criada);
+}
+
+/** O LEIA-ME da cópia é regravado quando muda (CRLF no lugar de LF não é mudança), sempre por último. */
+async function regravarLeiame(pasta, leiame, em) {
+  em.alvo = path.join(pasta, LEIAME);
+  const atual = await fs.readFile(em.alvo, 'utf8').catch(() => null);
+  if (atual == null || emLf(atual) !== leiame) await fs.writeFile(em.alvo, leiame, 'utf8');
+}
+
+/** As pastas anteriores ganham, na primeira linha do LEIA-ME, o aviso da pasta nova (um só). */
+async function avisarAnteriores(destino, anteriores, pastaNova, em) {
+  for (const { nome } of anteriores) {
+    em.alvo = path.join(destino, nome, LEIAME);
+    const atual = await fs.readFile(em.alvo, 'utf8').catch(() => null);
+    if (atual != null) await fs.writeFile(em.alvo, `${AVISO(pastaNova)}\n\n${atual.replace(AVISO_ANTERIOR, '')}`, 'utf8');
+  }
+}
+
+/** O LEIA-ME da pasta número `n` (1 = `<run>`; N = `<run>-reentrega-N`): um texto fixo, ou quem o monta. */
+const leiameDe = (leiame, n) => (typeof leiame === 'function' ? leiame(n) : leiame);
+
+/**
+ * Completa a pasta mais nova com o que falta, ou cria a pasta de reentrega quando algo mudou. A
+ * comparação é com o retrato do que foi copiado para ela; sem retrato, com os arquivos dela.
+ */
+async function atualizar({ destino, run, arquivos, ignorar, leiame, retratos }, existentes, em) {
+  const ultima = existentes.at(-1);
+  const pasta = path.join(destino.abs, ultima.nome);
+  const faltam = await oQueFalta(pasta, arquivos, ignorar, retratos?.[`${destino.rel}/${ultima.nome}`] ?? null);
+  if (!faltam) {
+    const nome = `${run}-reentrega-${ultima.n + 1}`;
+    await criar(path.join(destino.abs, nome), arquivos, leiameDe(leiame, ultima.n + 1), em);
+    await avisarAnteriores(destino.abs, existentes, `${destino.rel}/${nome}`, em);
+    return { tipo: 'reentrega', pasta: `${destino.rel}/${nome}` };
+  }
+  for (const a of faltam) {
+    em.alvo = path.join(pasta, a.pasta, a.nome);
+    await gravarNovo(em.alvo, a);
+  }
+  await regravarLeiame(pasta, leiameDe(leiame, ultima.n), em);
+  return { tipo: faltam.length ? 'completada' : 'igual', pasta: `${destino.rel}/${ultima.nome}`, novos: faltam.length };
+}
+
+/**
+ * Copia para o destino o que está pronto.
+ * @param {object} o
+ * @param {{ rel: string, abs: string }} o.destino a pasta escolhida, já validada · @param {string} o.run
+ * @param {object[]} o.arquivos o que é copiado agora: `{ pasta, nome, texto | de }`
+ * @param {Set<string>} o.ignorar `pasta/nome` do que a entrega tem e não é copiado agora
+ * @param {string|function(number): string} o.leiame o LEIA-ME da cópia, ou quem o monta para a pasta número N
+ * @param {object} [o.retratos] por pasta de cópia (relativa ao projeto), o retrato do que foi copiado
+ * @returns {Promise<object>} `{ tipo, pasta, novos, criouDestino }` — `tipo`: nova, igual,
+ *   completada ou reentrega; `pasta`: relativa ao projeto · ou `{ tipo: 'falha', arquivo }`, com o
+ *   caminho absoluto que não pôde ser gravado
+ */
+export async function copiar(o) {
+  const em = { alvo: o.destino.abs };
+  try {
+    const existentes = await pastasDaExecucao(o.destino.abs, o.run);
+    if (existentes.length) return await atualizar(o, existentes, em);
+    const criouDestino = await criar(path.join(o.destino.abs, o.run), o.arquivos, leiameDe(o.leiame, 1), em);
+    return { tipo: 'nova', pasta: `${o.destino.rel}/${o.run}`, criouDestino };
+  } catch {
+    return { tipo: 'falha', arquivo: em.alvo };
+  }
+}