@daniellins/power-claude 0.16.3

package/scripts/pod-export-postprocess.cjs

@@ -0,0 +1,427 @@
+'use strict';
+/**
+ * pod-export-postprocess.cjs - FIXER determinístico PRÉ-VETO do pod-export (Story SF10.11, F6).
+ *
+ * ┌─ O QUE FAZ ────────────────────────────────────────────────────────────────────────────┐
+ * │ Normaliza classes puramente MECÂNICAS (tabela declarada de substituição) em TODOS os    │
+ * │ arquivos que o agente escreveu com `write_file` NA TENTATIVA CORRENTE, ANTES de         │
+ * │ `motor.advance` (verifyStep/evalVeto) rodar. É o ÚLTIMO ESCRITOR ANTES DE TODA          │
+ * │ VERIFICAÇÃO - nunca um bypass: o veto continua rodando depois, com a última palavra.    │
+ * └────────────────────────────────────────────────────────────────────────────────────────┘
+ *
+ * ┌─ O QUE NÃO É (decidido por desenho, ADR-018 Adendo F6-a / `DF-SF10.11-2`) ──────────────┐
+ * │ NÃO vive em `scripts/veto-checks/`; NÃO é BLESSED; NÃO é declarável em `command_check`  │
+ * │ nem em nenhum `wf-*.yaml`; NÃO toca o motor compartilhado (`pc-run-pod.cjs` e           │
+ * │ `validate-pod-workflow.cjs` ficam byte-idênticos). É um módulo in-process do EXPORT,    │
+ * │ importado só por `pod-export-executor.cjs`. Pôr um MUTADOR na raiz blessed estenderia a │
+ * │ superfície de "verificar" para "reescrever" em todos os pods, por ganho zero.           │
+ * └────────────────────────────────────────────────────────────────────────────────────────┘
+ *
+ * ORDEM VINCULANTE no laço (`DF-SF10.11+12-1`), por tentativa dentro de `drive`:
+ *   1. runPhase      -> o modelo escreve via write_file; devolve toolTrail
+ *   2. FIXER (aqui)  -> sobre os paths de write_file DESTA tentativa; determinístico, idempotente
+ *   3. motor.advance -> veto REAL (motor INTOCADO, última linha)
+ *   4. se reprovar   -> correção guiada (SF10.12) consome o relatório deste fixer e volta ao 1
+ * O fixer roda em TODA tentativa, inclusive as pós-edição: a edição pode reintroduzir a classe
+ * mecânica, e a uniformidade do laço é o que dispensa um "segundo hook".
+ *
+ * DOMÍNIO (`DF-SF10.11-1`): os paths de `write_file` bem-sucedidos do `toolTrail` da tentativa -
+ * NÃO o artefato verificado. Deliberado: o `lexical-check` do `wf-hn-carousel` mede só
+ * `artifacts/assembly.md` (um SUMÁRIO), enquanto a copy publicada vive nas 7 peças HTML, que
+ * nenhuma assertion inspeciona (`DF-SF10.11+12-0(a)`). Um fixer escopado ao artefato verificado
+ * consertaria a MÉTRICA sem consertar o PRODUTO. Sem glob e sem varredura de diretório (a classe
+ * de erro do `listImages`, `NOTE-1` do gate de SF10.8): só o que ESTE agente escreveu NESTA
+ * tentativa. A resolução passa por `tools.confinedResolveWritable`, então `inputs/` (referência
+ * materializada) e o `.provenance.json` (irmão do runDir) são INALCANÇÁVEIS por construção.
+ *
+ * SUBTRAÇÃO DO DOMÍNIO (FIND-1, débito Low do gate de QA da SF10.11, pago na SF10.12): um path que
+ * `openrouter_image` gravou COM SUCESSO na MESMA tentativa sai do domínio, mesmo estando no trail de
+ * `write_file`. As duas tools compartilham o espaço de nomes do runDir; ler binário como UTF-8 e
+ * regravar corrompe (o QA mediu 16B -> 21B com sha alterado). A subtração compara paths ABSOLUTOS
+ * resolvidos - nunca strings -, então grafias diferentes do mesmo arquivo não escapam. Nada de
+ * heurística por extensão ou por magic bytes: o que decide é a TOOL que escreveu por último.
+ *
+ * DISCIPLINA DE FORMA (herdada de ADR-011): zero-dep, SÍNCRONO, determinístico, IDEMPOTENTE
+ * (`fix(fix(x)) === fix(x)`), sem rede, sem shell, sem `child_process`, sem `catch` cego.
+ *
+ * NOTA DE AUTORIA: este arquivo NÃO contém literais em-dash/en-dash em lugar nenhum (nem em
+ * comentário) - os padrões são escritos como escapes `\u2014`/`\u2013`. O módulo que remove o
+ * caractere não o carrega.
+ *
+ * Node >= 18 (lookbehind de regex). Story SF10.11; ADR-018 Adendo F6-a.
+ */
+
+const fs = require('node:fs');
+const tools = require('./pod-export-tools.cjs');
+
+// ---------------------------------------------------------------------------
+// TABELA DECLARADA DE SUBSTITUIÇÃO (`DF-SF10.11-3`).
+// ---------------------------------------------------------------------------
+
+/**
+ * REGRA DE AUTORIA - LEIA ANTES DE ACRESCENTAR UMA ENTRADA:
+ *
+ * 1. A tabela NÃO é derivada do detector do veto. `lexical-check.cjs` recebe `--pattern "[..]"`:
+ *    um detector diz O QUE é proibido, nunca COM O QUE substituir. A substituição é conhecimento
+ *    de VOZ DO DONO, autorada e aprovada por ele (No Invention). Inverter o detector seria
+ *    inventar semântica.
+ * 2. Uma entrada só entra se o caractere for SINTATICAMENTE INERTE em TODOS os tipos de arquivo
+ *    que a fase produz (Markdown, HTML, CSS, JS). U+2014 e U+2013 são inertes em qualquer posição
+ *    dos quatro. "Normalizar aspas", por contraste, QUEBRARIA atributo HTML e está PROIBIDO sem
+ *    escopo por tipo de arquivo. Esta restrição é o que impede a tabela de virar um vetor de
+ *    corrupção conforme cresce.
+ * 3. A deriva fixer<->veto é FAIL-SAFE por construção: se alguém mudar `voz.lexico_proibido` e os
+ *    args do veto sem atualizar esta tabela, o fixer apenas deixa de ajudar e O VETO VOLTA A
+ *    BLOQUEAR. Nenhum caminho de deriva produz verde indevido. A golden rule de autoria
+ *    (`carousel-builder.md`: editar voz e args juntos) estende-se a esta tabela.
+ * 4. O ponto de chamada NÃO muda ao acrescentar uma entrada: `postProcessAttempt` itera a tabela.
+ *    Regra nova = uma entrada aqui + a decisão do dono registrada. Nunca uma story de infra nova.
+ *
+ * Entradas aprovadas pelo dono (Daniel) em 2026-08-01, story SF10.11 (nenhuma outra substituição
+ * entra sem NOVA decisão dele).
+ */
+const SUBSTITUTIONS = [
+  {
+    id: 'em-dash-entre-espacos',
+    classe: 'prosa',
+    // U+2014 cercado por espaço horizontal dos DOIS lados, entre não-espaços. Os lookarounds são
+    // de largura zero de propósito: cadeias (`a - b - c`) convergem numa passada só.
+    pattern: /(?<=\S)[ \t\u00A0]+\u2014[ \t\u00A0]+(?=\S)/gu,
+    replacement: ', ',
+    porque: 'em-dash entre espaços é o "tell" de IA na prosa; a voz do dono usa vírgula (decisão do dono, SF10.11).',
+    veto_que_alivia: 'lexical-check.cjs --pattern "[\\u2014\\u2013]" --max 0',
+  },
+  {
+    id: 'en-dash-entre-digitos',
+    classe: 'intervalos numéricos',
+    // U+2013 ENTRE dígitos (ex.: 2020-2024, com en-dash). Lookbehind/lookahead de largura zero: cadeias
+    // (`1-2-3` encadeados) convergem numa passada só.
+    pattern: /(?<=\d)\u2013(?=\d)/gu,
+    replacement: '-',
+    porque: 'intervalo numérico com en-dash é o mesmo "tell"; hífen ASCII preserva a leitura (decisão do dono, SF10.11).',
+    veto_que_alivia: 'lexical-check.cjs --pattern "[\\u2014\\u2013]" --max 0',
+  },
+];
+
+// ---------------------------------------------------------------------------
+// REGIÕES PROTEGIDAS (AC8 / `DF-SF10.11-3`) - o fixer é NO-OP dentro delas.
+// ---------------------------------------------------------------------------
+
+/**
+ * Blocos que o FRAMEWORK escreve dentro de um artefato e que o fixer NUNCA pode tocar.
+ *
+ * Caso vigente: o bloco de MEDIDA do `phash-gate.cjs`, que o veto de pHash grava em
+ * `artifacts/visuals.md` - o mesmo artefato sobre o qual este fixer roda DEPOIS. Hoje o bloco é
+ * gerado por código e não emite token banido (`NOTE-4` do gate de SF10.8), então a proteção é
+ * no-op de fato; ela existe para que continue sendo no-op quando a tabela crescer.
+ *
+ * Os delimitadores são DECLARADOS aqui (e não importados de `phash-gate.cjs`) para não arrastar um
+ * veto blessed que spawna Chrome para dentro do grafo de require do executor. A cópia literal é
+ * amarrada por ASSERÇÃO PERMANENTE na suíte (`pod-export-postprocess.test.cjs`), que compara estas
+ * constantes com `phash.MEASURE_BEGIN`/`MEASURE_END`: qualquer deriva fica VERMELHA, nunca muda.
+ *
+ * Marcador de início SEM fim: a região é protegida até o fim do arquivo e um AVISO é registrado no
+ * relatório (nunca silencioso). Conservador quanto a corrupção; seguro quanto a evasão, porque o
+ * veto roda depois sobre o arquivo INTEIRO - um artefato que "escondesse" texto dentro do marcador
+ * continuaria sendo bloqueado pelo `lexical-check`.
+ */
+const PROTECTED_REGIONS = [
+  {
+    id: 'phash-medida-similaridade',
+    begin: '<!-- pc:medida-similaridade:inicio -->',
+    end: '<!-- pc:medida-similaridade:fim -->',
+    porque: 'bloco de MEDIDA escrito pelo veto phash-gate.cjs no artefato que ele verifica (AC8/NOTE-4 de SF10.8).',
+  },
+];
+
+// Tetos DECLARADOS (o relatório vira mensagem de correção na SF10.12: precisa ser limitado).
+const MAX_FIX_PASSES = 8;            // convergência da tabela; estourar = tabela oscilante = FALHA ALTA.
+const MAX_DIFF_LINES_PER_FILE = 20;  // linhas de diff por arquivo no relatório.
+const MAX_DIFF_LINE_CHARS = 200;     // recorte de cada linha do diff.
+
+// ---------------------------------------------------------------------------
+// Núcleo de texto (puro, sem I/O).
+// ---------------------------------------------------------------------------
+
+/** Clone da regex por uso: nunca compartilhar `lastIndex` entre chamadas. */
+function freshRe(rule) {
+  return new RegExp(rule.pattern.source, rule.pattern.flags);
+}
+
+function countMatches(text, rule) {
+  const m = text.match(freshRe(rule));
+  return m ? m.length : 0;
+}
+
+/**
+ * Uma passada da tabela sobre um trecho NÃO protegido. Só contabiliza a regra que de fato mudou o
+ * texto (uma substituição idêntica ao original não é uma correção).
+ */
+function applyTableOnce(text, table) {
+  let out = text;
+  const hits = [];
+  for (const rule of table) {
+    const before = out;
+    const n = countMatches(before, rule);
+    if (n === 0) continue;
+    out = before.replace(freshRe(rule), rule.replacement);
+    if (out !== before) hits.push({ id: rule.id, count: n });
+  }
+  return { text: out, hits };
+}
+
+/**
+ * Parte o texto em segmentos alternando protegido/não-protegido. Genérico em N regiões e em N
+ * ocorrências de cada uma.
+ */
+function splitProtected(text, regions) {
+  let segs = [{ text, protected: false }];
+  const warnings = [];
+  for (const r of regions) {
+    const next = [];
+    for (const seg of segs) {
+      if (seg.protected) { next.push(seg); continue; }
+      let rest = seg.text;
+      for (;;) {
+        const b = rest.indexOf(r.begin);
+        if (b < 0) { next.push({ text: rest, protected: false }); break; }
+        const e = rest.indexOf(r.end, b + r.begin.length);
+        if (e < 0) {
+          warnings.push(`região protegida "${r.id}": marcador de INÍCIO sem marcador de FIM; protegido até o fim do arquivo (o veto segue verificando o arquivo inteiro)`);
+          next.push({ text: rest.slice(0, b), protected: false });
+          next.push({ text: rest.slice(b), protected: true });
+          break;
+        }
+        const end = e + r.end.length;
+        next.push({ text: rest.slice(0, b), protected: false });
+        next.push({ text: rest.slice(b, end), protected: true });
+        rest = rest.slice(end);
+      }
+    }
+    segs = next;
+  }
+  return { segs, warnings };
+}
+
+/**
+ * Aplica a tabela até o PONTO FIXO, fora das regiões protegidas.
+ *
+ * A idempotência (`fix(fix(x)) === fix(x)`) é ESTRUTURAL, não um acidente feliz de cada regex:
+ * a função só devolve um texto sobre o qual mais uma passada da tabela não muda nada. Vale para as
+ * duas entradas de hoje e para qualquer entrada futura. Tabela que NUNCA alcança ponto fixo (uma
+ * entrada cuja substituição volta a casar e CRESCE, ex.: `A` -> `AA`) estoura `MAX_FIX_PASSES` e
+ * FALHA ALTO - nunca fica girando nem devolve resultado dependente de quantas passadas rodaram.
+ * (Um par que se desfaz DENTRO da mesma passada, `A`->`B` e `B`->`A`, é identidade: a passada
+ * inteira não muda nada, o resultado é estável e o veto continua sendo quem bloqueia.)
+ *
+ * @returns {{ text: string, changed: boolean, rules: Array<{id:string,count:number}>, replacements: number, warnings: string[] }}
+ */
+function fixText(text, { table = SUBSTITUTIONS, protectedRegions = PROTECTED_REGIONS } = {}) {
+  if (typeof text !== 'string') throw new Error('pod-export-postprocess.fixText: `text` precisa ser string');
+  const { segs, warnings } = splitProtected(text, protectedRegions);
+  const counts = new Map();
+  const out = segs.map((seg) => {
+    if (seg.protected) return seg.text;
+    let cur = seg.text;
+    for (let pass = 1; pass <= MAX_FIX_PASSES; pass++) {
+      const step = applyTableOnce(cur, table);
+      if (step.text === cur) return cur; // ponto fixo
+      for (const h of step.hits) counts.set(h.id, (counts.get(h.id) || 0) + h.count);
+      cur = step.text;
+    }
+    if (applyTableOnce(cur, table).text !== cur) {
+      throw new Error(
+        `pod-export-postprocess: a tabela de substituição NÃO alcançou ponto fixo em ${MAX_FIX_PASSES} passadas - ` +
+        'há entrada cuja substituição volta a casar consigo mesma (ex.: `A` -> `AA`). Corrija a tabela; ' +
+        'o run PARA aqui (um fixer cujo resultado depende do número de passadas é pior que nenhum fixer).',
+      );
+    }
+    return cur;
+  }).join('');
+  const rules = [...counts.entries()].map(([id, count]) => ({ id, count }));
+  const replacements = rules.reduce((a, r) => a + r.count, 0);
+  return { text: out, changed: out !== text, rules, replacements, warnings };
+}
+
+function clip(line) {
+  const s = line === undefined ? '' : line;
+  return s.length > MAX_DIFF_LINE_CHARS ? `${s.slice(0, MAX_DIFF_LINE_CHARS)}[...]` : s;
+}
+
+/** Diff MÍNIMO por linha (só o que mudou), limitado - vira mensagem de modelo na SF10.12. */
+function lineDiff(before, after) {
+  const A = before.split('\n');
+  const B = after.split('\n');
+  const lines = [];
+  let truncated = false;
+  const n = Math.max(A.length, B.length);
+  for (let i = 0; i < n; i++) {
+    if (A[i] === B[i]) continue;
+    if (lines.length >= MAX_DIFF_LINES_PER_FILE) { truncated = true; break; }
+    lines.push({ line: i + 1, before: clip(A[i]), after: clip(B[i]) });
+  }
+  return { lines, truncated };
+}
+
+// ---------------------------------------------------------------------------
+// Domínio + I/O (o mínimo, síncrono).
+// ---------------------------------------------------------------------------
+
+/**
+ * Domínio do fixer (`DF-SF10.11-1`): paths de `write_file` BEM-SUCEDIDOS da tentativa, sem
+ * duplicatas e na ordem de escrita. `openrouter_image` (binário), `read_image` e `http_fetch`
+ * ficam de fora por construção - não é `write_file`.
+ */
+function writtenPathsFromTrail(toolTrail) {
+  const seen = new Set();
+  const out = [];
+  for (const t of toolTrail || []) {
+    if (!t || t.name !== 'write_file' || t.ok !== true) continue;
+    const rel = typeof t.arg === 'string' ? t.arg.trim() : '';
+    if (rel === '' || seen.has(rel)) continue;
+    seen.add(rel);
+    out.push(rel);
+  }
+  return out;
+}
+
+/**
+ * FIND-1 (gate de QA da SF10.11, débito Low pago na SF10.12): paths que `openrouter_image` gravou
+ * COM SUCESSO nesta tentativa. Conteúdo BINÁRIO - ler como UTF-8 e regravar corrompe (medido pelo
+ * QA: 16B -> 21B, sha alterado, bytes inválidos virando U+FFFD).
+ *
+ * Existe porque `write_file` e `openrouter_image` compartilham o MESMO espaço de nomes dentro do
+ * runDir: um path escrito como texto e DEPOIS sobrescrito por uma imagem continua no trail de
+ * `write_file`, e o domínio de `DF-SF10.11-1` o alcançaria. A subtração é por path ABSOLUTO
+ * resolvido (em `postProcessAttempt`), nunca por comparação de string: `./assets/x.png` e
+ * `assets/x.png` são o mesmo arquivo e uma comparação literal deixaria a evasão aberta.
+ *
+ * Só `ok === true`: `openrouterImage` resolve o path e só grava DEPOIS de a API responder
+ * (`pod-export-tools.cjs`), então uma chamada falha não deixou binário naquele path - subtrair por
+ * ela removeria do domínio um arquivo de TEXTO legítimo, que é a perda oposta (o fixer deixaria de
+ * ajudar em silêncio).
+ */
+function imagePathsFromTrail(toolTrail) {
+  const seen = new Set();
+  const out = [];
+  for (const t of toolTrail || []) {
+    if (!t || t.name !== 'openrouter_image' || t.ok !== true) continue;
+    const rel = typeof t.arg === 'string' ? t.arg.trim() : '';
+    if (rel === '' || seen.has(rel)) continue;
+    seen.add(rel);
+    out.push(rel);
+  }
+  return out;
+}
+
+/**
+ * Lê, corrige e REESCREVE um arquivo do domínio. Fail-loud sem `catch` cego: `ENOENT` é o ÚNICO
+ * errno com tratamento SANCIONADO (vira mensagem acionável e PARA o run - sumiço entre a escrita e
+ * o fix é impossível pelas tools atuais, logo é sinal de bug); qualquer outro errno sobe cru.
+ */
+function fixFile(absPath, relPath, opts) {
+  let before;
+  try {
+    before = fs.readFileSync(absPath, 'utf8');
+  } catch (e) {
+    if (e.code === 'ENOENT') {
+      throw new Error(
+        `pod-export-postprocess: "${relPath}" está no toolTrail de write_file da tentativa mas NÃO existe ` +
+        `em disco (${absPath}). As tools do export não removem arquivo: isso é sinal de BUG, e o run PARA ` +
+        'aqui em vez de verificar um estado que ninguém sabe descrever (DF-SF10.11-1).',
+      );
+    }
+    throw e;
+  }
+  const r = fixText(before, opts);
+  if (!r.changed) return { path: relPath, changed: false, replacements: 0, rules: [], diff: [], diffTruncated: false, warnings: r.warnings };
+  fs.writeFileSync(absPath, r.text, 'utf8');
+  const d = lineDiff(before, r.text);
+  return { path: relPath, changed: true, replacements: r.replacements, rules: r.rules, diff: d.lines, diffTruncated: d.truncated, warnings: r.warnings };
+}
+
+/**
+ * PASSO 2 do laço (`DF-SF10.11+12-1`): corrige TODOS os arquivos escritos na tentativa, ANTES de
+ * `motor.advance`. Chamado por `execPhase` em `pod-export-executor.cjs`.
+ *
+ * @returns relatório ESTRUTURADO (AC4) - evidência de auditoria E insumo da mensagem de correção
+ *          da SF10.12 (`DF-SF10.12-1(ii)`), nunca só log:
+ *   { changed, scanned, totalReplacements, files: [{ path, replacements, rules[], diff[], diffTruncated }],
+ *     warnings[], skippedBinary[] }
+ *   `scanned` conta os arquivos de TEXTO efetivamente lidos (o domínio MENOS `skippedBinary`);
+ *   `skippedBinary` nomeia os paths que uma imagem sobrescreveu nesta tentativa (FIND-1) - nunca
+ *   silencioso, pelo mesmo princípio dos `warnings`.
+ */
+function postProcessAttempt({ runDir, toolTrail, log = () => {}, table = SUBSTITUTIONS, protectedRegions = PROTECTED_REGIONS }) {
+  if (!runDir) throw new Error('pod-export-postprocess: `runDir` é obrigatório');
+  const rels = writtenPathsFromTrail(toolTrail);
+  // FIND-1: o domínio de texto MENOS os arquivos que uma imagem sobrescreveu nesta tentativa.
+  // Comparação por path ABSOLUTO resolvido pela MESMA função que as tools usam para gravar - é o
+  // que torna a subtração imune a grafias diferentes do mesmo arquivo.
+  const binaryAbs = new Set(imagePathsFromTrail(toolTrail).map((rel) => tools.confinedResolveWritable(runDir, rel)));
+  const files = [];
+  const warnings = [];
+  const skippedBinary = [];
+  let totalReplacements = 0;
+  for (const rel of rels) {
+    // Herda a contenção das tools (traversal, path absoluto e escrita sob `inputs/` já negados).
+    const abs = tools.confinedResolveWritable(runDir, rel);
+    if (binaryAbs.has(abs)) { skippedBinary.push(rel); continue; } // FIND-1 - nunca ler binário como UTF-8.
+    const r = fixFile(abs, rel, { table, protectedRegions });
+    for (const w of r.warnings) warnings.push(`${rel}: ${w}`);
+    if (!r.changed) continue;
+    files.push({ path: r.path, replacements: r.replacements, rules: r.rules, diff: r.diff, diffTruncated: r.diffTruncated });
+    totalReplacements += r.replacements;
+  }
+  const report = { changed: files.length > 0, scanned: rels.length - skippedBinary.length, totalReplacements, files, warnings, skippedBinary };
+  // AC4 - NUNCA silencioso: o que mudou, em que arquivo e por qual entrada da tabela.
+  if (report.changed) {
+    for (const f of files) {
+      log(`  [fixer] ${f.path}: ${f.replacements} substituição(ões) [${f.rules.map((x) => `${x.id}x${x.count}`).join(', ')}]`);
+    }
+  } else if (report.scanned > 0) {
+    log(`  [fixer] nada a corrigir em ${report.scanned} arquivo(s) escrito(s) nesta tentativa`);
+  }
+  // FIND-1 - a subtração do domínio é AUDITÁVEL: o operador vê que o arquivo existiu no trail de
+  // write_file e foi deixado intacto de propósito, em vez de sumir do relatório sem explicação.
+  for (const p of skippedBinary) log(`  [fixer] ${p}: PULADO (sobrescrito por openrouter_image nesta tentativa; binário nunca é lido como UTF-8)`);
+  for (const w of warnings) log(`  [fixer] AVISO: ${w}`);
+  return report;
+}
+
+/**
+ * COSTURA DECLARADA PARA A SF10.12 (`DF-SF10.12-1(ii)`): renderiza o relatório como bloco de texto
+ * para a mensagem que retoma a conversa depois do veto reprovar - o modelo precisa saber o que o
+ * fixer já mudou no arquivo que ele está vendo, senão reescreve por cima. Produção passa a chamar
+ * isto na SF10.12; aqui ele nasce testado, junto do relatório que o alimenta (AC4).
+ */
+function renderFixMessage(report) {
+  if (!report || !report.changed) return '';
+  const L = ['## Correções mecânicas JÁ APLICADAS por código (não as desfaça)'];
+  L.push('Um pós-processador determinístico normalizou os arquivos abaixo DEPOIS da sua escrita e ANTES da verificação.');
+  L.push('O texto em disco é o "depois". Mantenha essa forma ao editar.');
+  for (const f of report.files) {
+    L.push('', `### ${f.path} (${f.replacements} substituição(ões): ${f.rules.map((r) => r.id).join(', ')})`);
+    for (const d of f.diff) L.push(`- linha ${d.line}: "${d.before}" -> "${d.after}"`);
+    if (f.diffTruncated) L.push(`- (diff truncado em ${MAX_DIFF_LINES_PER_FILE} linhas)`);
+  }
+  return L.join('\n');
+}
+
+module.exports = {
+  SUBSTITUTIONS,
+  PROTECTED_REGIONS,
+  MAX_FIX_PASSES,
+  MAX_DIFF_LINES_PER_FILE,
+  MAX_DIFF_LINE_CHARS,
+  fixText,
+  applyTableOnce,
+  splitProtected,
+  lineDiff,
+  countMatches,
+  writtenPathsFromTrail,
+  imagePathsFromTrail,
+  fixFile,
+  postProcessAttempt,
+  renderFixMessage,
+};