@daniellins/power-claude 0.16.3

package/scripts/pod-export-postprocess.test.cjs

@@ -0,0 +1,558 @@
+#!/usr/bin/env node
+'use strict';
+/**
+ * pod-export-postprocess.test.cjs - suite do FIXER determinístico pré-veto (Story SF10.11, F6).
+ *
+ * HERMÉTICA: zero rede, zero modelo, zero subprocesso próprio. Usa o CONTADOR REAL do veto
+ * (`lexical-check.countMatches`), o VALIDADOR REAL de HTML (`html-valid.checkBalance`), o
+ * GERADOR REAL do bloco de medida (`phash-gate.renderMeasureBlock`) e as guardas REAIS de
+ * blessed (`validate-pod-workflow.checkCommandCheckSafety` + `pc-run-pod.evalVeto`) - nada de
+ * reimplementar oráculo dentro do teste.
+ *
+ * Cobre: AC1 (domínio = toolTrail de write_file, peça HTML inclusa), AC2 (forma + tabela
+ * declarada + extensibilidade), AC3 (idempotência/determinismo), AC4 (relatório estruturado),
+ * AC5 (veto como última linha / não-regressão), AC8 (no-op sobre o bloco de MEDIDA do phash-gate).
+ */
+
+const fs = require('node:fs');
+const os = require('node:os');
+const path = require('node:path');
+const crypto = require('node:crypto');
+
+const pp = require('./pod-export-postprocess.cjs');
+const lexical = require('./veto-checks/lexical-check.cjs');
+const htmlValid = require('./veto-checks/html-valid.cjs');
+const phash = require('./veto-checks/phash-gate.cjs');
+const vp = require('./validate-pod-workflow.cjs');
+const rp = require('./pc-run-pod.cjs');
+const { motorRels } = require('../installer/motor-scripts.js');
+
+const REPO_ROOT = path.resolve(__dirname, '..');
+const MODULE_PATH = path.join(__dirname, 'pod-export-postprocess.cjs');
+const MODULE_SRC = fs.readFileSync(MODULE_PATH, 'utf8');
+
+// Padrão do veto em produção (wf-hn-carousel / content-carousel): em-dash U+2014, en-dash U+2013.
+const VETO_PATTERN = '[\\u2014\\u2013]';
+const EM = '—';
+const EN = '–';
+
+let failures = 0;
+function assert(ok, msg) {
+  if (ok) console.log(`[OK   ] ${msg}`);
+  else { console.error(`[FALHA] ${msg}`); failures++; }
+}
+function tmpDir(label) { return fs.mkdtempSync(path.join(os.tmpdir(), `sf10.11-${label}-`)); }
+function sha(p) { return crypto.createHash('sha256').update(fs.readFileSync(p)).digest('hex'); }
+/** toolTrail no MESMO formato que `runPhase` produz (name/ok/arg). */
+function trailWrite(...rels) { return rels.map((r) => ({ name: 'write_file', ok: true, arg: r })); }
+function writeIn(runDir, rel, content) {
+  const abs = path.join(runDir, rel);
+  fs.mkdirSync(path.dirname(abs), { recursive: true });
+  fs.writeFileSync(abs, content, 'utf8');
+  return abs;
+}
+
+// ===========================================================================
+// AC2 - FORMA: in-process, zero-dep, síncrono, NÃO blessed, NÃO declarável.
+// ===========================================================================
+
+function formaTests() {
+  console.log('\n--- AC2: forma do post-processor (DF-SF10.11-2) ---');
+
+  assert(!MODULE_PATH.includes(`${path.sep}veto-checks${path.sep}`), 'o módulo NÃO vive em scripts/veto-checks/ (raiz blessed intocada)');
+
+  // NÃO é blessed: a raiz blessed é derivada por PREFIXO scripts/veto-checks/ (blessedVetoRels,
+  // pc-run-pod.cjs). Estar no manifesto de DISTRIBUIÇÃO (ADR-007) não confere blessed nenhum.
+  const rels = motorRels();
+  const blessed = rels.filter((r) => r.startsWith('scripts/veto-checks/'));
+  // A contagem é PINADA de propósito: script novo sob scripts/veto-checks/ tem que passar por
+  // uma decisão consciente aqui. SF11.11 subiu de 4 para 5 (render-png.cjs, ADR-025).
+  assert(!blessed.includes('scripts/veto-checks/pod-export-postprocess.cjs') && blessed.length === 5,
+    `o fixer NÃO está na raiz blessed (blessed segue com os 5 veto-checks: ${blessed.map((b) => path.basename(b)).join(', ')})`);
+  assert(rels.includes('scripts/pod-export-postprocess.cjs'),
+    'o fixer ESTÁ no manifesto ADR-007 como require-dependency do executor (invariantes 1/3 do teste-guarda) - distribuição, não bênção');
+
+  // NÃO é declarável em wf-*.yaml: as DUAS guardas reais recusam, estática e em runtime.
+  let staticRefused = false;
+  try { vp.checkCommandCheckSafety({ command: 'pod-export-postprocess.cjs' }); } catch (e) { staticRefused = e instanceof vp.Fail; }
+  assert(staticRefused, 'ESTÁTICO: validate-pod-workflow RECUSA um command_check que nomeie o fixer (fora da raiz blessed)');
+  const rt = rp.evalVeto({ type: 'command_check', command: 'pod-export-postprocess.cjs' }, '', path.join(REPO_ROOT, 'package.json'), { podRoot: REPO_ROOT, runDir: REPO_ROOT });
+  assert(rt.ok === false && /blessed/.test(rt.reason || ''), `RUNTIME: evalVeto RECUSA o fixer como command_check sem executá-lo (${rt.reason})`);
+
+  // Nenhum wf do repo o declara.
+  const wfHits = [];
+  const stack = [path.join(REPO_ROOT, 'pods'), path.join(REPO_ROOT, 'template')];
+  while (stack.length > 0) {
+    const d = stack.pop();
+    if (!fs.existsSync(d)) continue;
+    for (const e of fs.readdirSync(d, { withFileTypes: true })) {
+      const p = path.join(d, e.name);
+      if (e.isDirectory()) stack.push(p);
+      else if (/\.ya?ml$/.test(e.name) && fs.readFileSync(p, 'utf8').includes('pod-export-postprocess')) wfHits.push(p);
+    }
+  }
+  assert(wfHits.length === 0, `nenhum wf-*.yaml declara o fixer (encontrados: ${wfHits.length})`);
+
+  // Zero-dep, síncrono, sem shell, sem rede, sem catch cego.
+  const requires = [...MODULE_SRC.matchAll(/require\(\s*['"]([^'"]+)['"]\s*\)/g)].map((m) => m[1]);
+  assert(requires.every((r) => r === 'node:fs' || r === './pod-export-tools.cjs'),
+    `zero-dep: requires apenas builtins/irmão do export (${requires.join(', ')})`);
+  // A varredura de disciplina roda sobre o CÓDIGO, não sobre os comentários (o cabeçalho do módulo
+  // cita "child_process"/"rede" ao declarar o que NÃO faz; casar nisso seria falso-positivo).
+  const CODE = MODULE_SRC.replace(/\/\*[\s\S]*?\*\//g, '').split('\n').map((l) => l.replace(/(^|\s)\/\/.*$/, '')).join('\n');
+  assert(!/child_process|rede/.test(CODE) && /child_process/.test(MODULE_SRC),
+    'sanidade da varredura: os comentários foram removidos (o cabeçalho cita child_process; o código não)');
+  assert(!/execSync|execFileSync|\bspawn\w*\(|node:https?|node:net|node:dgram|\bfetch\(/.test(CODE),
+    'sem shell, sem child_process, sem rede no CÓDIGO: o fixer não pode chamar modelo nem processo (AC3)');
+  assert(!/\basync\b|\bawait\b|new Promise|\.then\(/.test(CODE), 'SÍNCRONO: nenhuma assincronia no módulo');
+  assert(!/catch\s*(\([^)]*\))?\s*\{\s*\}/.test(MODULE_SRC), 'nenhum `catch {}` cego sobrevive no fixer (fail-loud)');
+  assert((MODULE_SRC.match(/[—–]/g) || []).length === 0,
+    'o fonte do fixer não contém NENHUM literal em/en-dash (os padrões são escapes \\u2014/\\u2013)');
+}
+
+// ===========================================================================
+// AC2 - TABELA declarada + extensibilidade sem tocar o ponto de chamada.
+// ===========================================================================
+
+function tabelaTests() {
+  console.log('\n--- AC2: tabela declarada de substituição (DF-SF10.11-3) ---');
+
+  assert(pp.SUBSTITUTIONS.length === 2, `tabela tem exatamente as 2 entradas aprovadas pelo dono (tem ${pp.SUBSTITUTIONS.length})`);
+  assert(pp.SUBSTITUTIONS.every((r) => r.id && r.pattern instanceof RegExp && typeof r.replacement === 'string' && r.porque && r.veto_que_alivia),
+    'toda entrada declara { id, pattern, replacement, porque, veto_que_alivia } - tabela, não regex solta');
+
+  // As DUAS entradas do dono, na semântica exata aprovada.
+  assert(pp.fixText(`palavra ${EM} outra`).text === 'palavra, outra', 'entrada 1: em-dash ENTRE ESPAÇOS vira vírgula');
+  assert(pp.fixText(`de 2020${EN}2024`).text === 'de 2020-2024', 'entrada 2: en-dash ENTRE DÍGITOS vira hífen ASCII');
+
+  // Fronteira: o que NÃO está na tabela NÃO é tocado (o veto continua sendo quem bloqueia).
+  const foraDaTabela = `palavra${EM}colada e um travess${EM}o solto\n${EM} item de lista\ntexto ${EN} com en-dash em prosa`;
+  assert(pp.fixText(foraDaTabela).text === foraDaTabela,
+    'NADA fora da tabela é alterado (em-dash colado, início de linha, en-dash em prosa) - No Invention; o veto segue bloqueando');
+
+  // 2ª classe mecânica adicionável SEM mudar o ponto de chamada (a tabela é o parâmetro).
+  const run = tmpDir('tabela2');
+  writeIn(run, 'artifacts/x.md', 'reticencias… aqui');
+  const tabela2 = [...pp.SUBSTITUTIONS, { id: 'reticencias', classe: 'prosa', pattern: /…/gu, replacement: '...', porque: 'fixture de extensibilidade', veto_que_alivia: 'n/a' }];
+  const rep = pp.postProcessAttempt({ runDir: run, toolTrail: trailWrite('artifacts/x.md'), table: tabela2 });
+  assert(rep.changed && fs.readFileSync(path.join(run, 'artifacts/x.md'), 'utf8') === 'reticencias... aqui'
+    && rep.files[0].rules.some((r) => r.id === 'reticencias'),
+    'uma 2ª entrada de tabela é aplicada e reportada SEM nenhuma mudança no ponto de chamada (AC2)');
+}
+
+// ===========================================================================
+// AC1 - DOMÍNIO: toolTrail de write_file da tentativa (não o artefato verificado).
+// ===========================================================================
+
+function dominioTests() {
+  console.log('\n--- AC1: domínio = toolTrail de write_file da tentativa (DF-SF10.11-1) ---');
+
+  const trail = [
+    { name: 'write_file', ok: true, arg: 'artifacts/assembly.md' },
+    { name: 'write_file', ok: true, arg: 'pieces/01-capa.html' },
+    { name: 'write_file', ok: true, arg: 'artifacts/assembly.md' }, // reescrita: 1 vez só
+    { name: 'write_file', ok: false, arg: 'pieces/99-falhou.html' }, // escrita que FALHOU
+    { name: 'openrouter_image', ok: true, arg: 'assets/cover.png' }, // binário: fora
+    { name: 'read_image', ok: true, arg: 'inputs:ref.png' },
+    { name: 'http_fetch', ok: true, arg: 'https://news.ycombinator.com/x' },
+  ];
+  const rels = pp.writtenPathsFromTrail(trail);
+  assert(rels.length === 2 && rels[0] === 'artifacts/assembly.md' && rels[1] === 'pieces/01-capa.html',
+    `domínio = só write_file OK, sem duplicata (${rels.join(', ')}) - imagem/leitura/fetch ficam de fora por construção`);
+
+  // As 7 PEÇAS HTML entram; o binário de assets/ NÃO é tocado.
+  const run = tmpDir('dominio');
+  const pecas = [];
+  for (let i = 1; i <= 7; i++) {
+    const rel = `pieces/0${i}-peca.html`;
+    writeIn(run, rel, `<html><body><p>Slide ${i} ${EM} com travessao</p></body></html>`);
+    pecas.push(rel);
+  }
+  writeIn(run, 'artifacts/assembly.md', `## Pacote Final\n- resumo ${EM} do pacote\n`);
+  const pngBytes = Buffer.from([0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a]);
+  fs.mkdirSync(path.join(run, 'assets'), { recursive: true });
+  fs.writeFileSync(path.join(run, 'assets/cover.png'), pngBytes);
+  const pngShaBefore = sha(path.join(run, 'assets/cover.png'));
+
+  const trail2 = [...trailWrite(...pecas, 'artifacts/assembly.md'), { name: 'openrouter_image', ok: true, arg: 'assets/cover.png' }];
+  const rep = pp.postProcessAttempt({ runDir: run, toolTrail: trail2 });
+
+  const pecasLimpas = pecas.filter((rel) => lexical.countMatches(fs.readFileSync(path.join(run, rel), 'utf8'), VETO_PATTERN) === 0);
+  assert(pecasLimpas.length === 7, `AC1(i): as 7 PEÇAS HTML foram corrigidas - a classe que NENHUM veto do wf inspeciona hoje (limpas: ${pecasLimpas.length}/7)`);
+  assert(rep.files.length === 8 && rep.scanned === 8, `relatório cobre as 8 escritas da tentativa (7 peças + sumário): ${rep.files.length}`);
+  assert(sha(path.join(run, 'assets/cover.png')) === pngShaBefore, 'imagem de assets/ (openrouter_image) NÃO é tocada pelo fixer - domínio é write_file');
+}
+
+// ===========================================================================
+// AC1 - CORREÇÃO REAL: o contador do veto passa a ver 0; o HTML segue válido.
+// ===========================================================================
+
+function correcaoTests() {
+  console.log('\n--- AC1: correção real medida pelo oráculo do veto ---');
+
+  // (ii) sumário assembly.md dentro do limiar do lexical-check (--max 0) SEM intervenção do modelo.
+  const assemblyAntes = [
+    '## Slides Internos',
+    `- slide 1 ${EM} o gancho`,
+    `- slide 2 ${EM} o conflito`,
+    `- slide 3 ${EM} a virada de 2020${EN}2024`,
+    '## Slide CTA',
+    `Chamada final ${EM} forte.`,
+    '',
+    'confianca: alta',
+    '',
+  ].join('\n');
+  const run = tmpDir('correcao');
+  writeIn(run, 'artifacts/assembly.md', assemblyAntes);
+  assert(lexical.countMatches(assemblyAntes, VETO_PATTERN) === 5, `fixture: o veto contaria 5 ocorrências ANTES do fixer (${lexical.countMatches(assemblyAntes, VETO_PATTERN)})`);
+
+  pp.postProcessAttempt({ runDir: run, toolTrail: trailWrite('artifacts/assembly.md') });
+  const depois = fs.readFileSync(path.join(run, 'artifacts/assembly.md'), 'utf8');
+  assert(lexical.countMatches(depois, VETO_PATTERN) === 0,
+    'AC1(ii): o CONTADOR REAL do lexical-check vê 0 ocorrência depois do fixer (limiar --max 0 satisfeito sem retry)');
+  assert(depois.includes('- slide 1, o gancho') && depois.includes('a virada de 2020-2024'),
+    'a substituição preserva a leitura (vírgula na prosa, hífen no intervalo)');
+
+  // Peça HTML adversarial: travessão em ATRIBUTO, em <style> e em texto. O HTML segue válido.
+  const htmlAntes = [
+    '<!doctype html>',
+    '<html><head><style>',
+    `/* tema ${EM} cores da marca */`,
+    '.t { font-family: "Inter", sans-serif; }',
+    '</style></head>',
+    '<body>',
+    `<p data-nota="fonte ${EM} HN" title="ano 2020${EN}2024">Texto ${EM} do slide</p>`,
+    '<img src="../assets/cover.png" alt="capa">',
+    '</body></html>',
+  ].join('\n');
+  const run2 = tmpDir('html');
+  writeIn(run2, 'pieces/01-capa.html', htmlAntes);
+  assert(htmlValid.checkBalance(htmlAntes).ok, 'fixture HTML é válida ANTES do fixer (balanceamento real do html-valid)');
+  pp.postProcessAttempt({ runDir: run2, toolTrail: trailWrite('pieces/01-capa.html') });
+  const htmlDepois = fs.readFileSync(path.join(run2, 'pieces/01-capa.html'), 'utf8');
+  assert(lexical.countMatches(htmlDepois, VETO_PATTERN) === 0, 'peça HTML: 0 ocorrência depois (atributo, <style> e texto)');
+  assert(htmlValid.checkBalance(htmlDepois).ok, 'AC2/inércia sintática: o HTML continua VÁLIDO depois do fixer (html-valid real)');
+  assert(/data-nota="fonte, HN"/.test(htmlDepois) && /title="ano 2020-2024"/.test(htmlDepois),
+    'atributos seguem com aspas intactas: o caractere trocado é sintaticamente INERTE (nada de "normalizar aspas")');
+  assert(htmlDepois.includes('<img src="../assets/cover.png" alt="capa">'), 'markup não relacionado sai intacto');
+}
+
+// ===========================================================================
+// AC3 - IDEMPOTÊNCIA e DETERMINISMO.
+// ===========================================================================
+
+function idempotenciaTests() {
+  console.log('\n--- AC3: idempotência (fix(fix(x)) === fix(x)) e determinismo ---');
+
+  const corpus = [
+    `prosa ${EM} simples`,
+    `cadeia ${EM} de ${EM} tres ${EM} pedacos`,
+    `intervalo 1${EN}2${EN}3 e 2020${EN}2024`,
+    `dash duplo ${EM} ${EM} colados`,
+    `misto ${EM} com 1990${EN}1999 no meio ${EM} fim`,
+    `sem nada para corrigir`,
+    `${EM} inicio de linha e fim ${EM}`,
+    `<p class="a ${EM} b">html ${EM} inline</p>`,
+    '',
+  ];
+  let allIdem = true;
+  let allClean = true;
+  for (const s of corpus) {
+    const once = pp.fixText(s).text;
+    const twice = pp.fixText(once).text;
+    if (once !== twice) { allIdem = false; console.error(`   nao-idempotente: ${JSON.stringify(s)} -> ${JSON.stringify(once)} -> ${JSON.stringify(twice)}`); }
+    if (pp.applyTableOnce(once, pp.SUBSTITUTIONS).text !== once) allClean = false;
+  }
+  assert(allIdem, `fix(fix(x)) === fix(x) em ${corpus.length} entradas, cadeias e dashes adjacentes inclusos`);
+  assert(allClean, 'a saída é PONTO FIXO da tabela: mais uma passada não muda nada (idempotência estrutural, não acidente de regex)');
+
+  // Determinismo: mesma entrada, mesma saída, 3 vezes.
+  const alvo = corpus[4];
+  const s1 = pp.fixText(alvo).text; const s2 = pp.fixText(alvo).text; const s3 = pp.fixText(alvo).text;
+  assert(s1 === s2 && s2 === s3, 'determinístico: 3 execuções da mesma entrada dão byte a byte o mesmo resultado');
+
+  // Idempotência EM DISCO: 2ª passada sobre os mesmos arquivos não muda byte nenhum.
+  const run = tmpDir('idem');
+  writeIn(run, 'artifacts/assembly.md', `sumario ${EM} do pacote de 2020${EN}2024`);
+  writeIn(run, 'pieces/01-capa.html', `<p>capa ${EM} titulo</p>`);
+  const trail = trailWrite('artifacts/assembly.md', 'pieces/01-capa.html');
+  const r1 = pp.postProcessAttempt({ runDir: run, toolTrail: trail });
+  const shas = [sha(path.join(run, 'artifacts/assembly.md')), sha(path.join(run, 'pieces/01-capa.html'))];
+  const r2 = pp.postProcessAttempt({ runDir: run, toolTrail: trail });
+  assert(r1.changed && !r2.changed, 'em disco: 1ª passada corrige, 2ª passada não tem NADA a corrigir');
+  assert(shas[0] === sha(path.join(run, 'artifacts/assembly.md')) && shas[1] === sha(path.join(run, 'pieces/01-capa.html')),
+    'em disco: os sha256 dos arquivos são idênticos depois da 2ª passada (idempotência provada por hash)');
+
+  // Tabela SEM ponto fixo (substituição que volta a casar e cresce) FALHA ALTO, em vez de devolver
+  // um resultado que depende de quantas passadas rodaram.
+  const divergente = [{ id: 'cresce', pattern: /A/gu, replacement: 'AA', porque: 'fixture', veto_que_alivia: 'n/a' }];
+  let threw = null;
+  try { pp.fixText('A', { table: divergente }); } catch (e) { threw = e; }
+  assert(threw && /ponto fixo/.test(threw.message), 'tabela SEM ponto fixo (`A` -> `AA`) FALHA ALTO em MAX_FIX_PASSES, nunca devolve saída dependente do número de passadas');
+
+  // Par que se desfaz DENTRO da passada (A->B, B->A) é IDENTIDADE: estável e determinístico - o
+  // fixer só deixa de ajudar, e o veto continua sendo quem bloqueia (deriva fail-safe).
+  const parInverso = [
+    { id: 'a-para-b', pattern: /A/gu, replacement: 'B', porque: 'fixture', veto_que_alivia: 'n/a' },
+    { id: 'b-para-a', pattern: /B/gu, replacement: 'A', porque: 'fixture', veto_que_alivia: 'n/a' },
+  ];
+  const pi = pp.fixText('A', { table: parInverso });
+  assert(pi.text === 'A' && pi.changed === false && pp.fixText(pi.text, { table: parInverso }).text === 'A',
+    'par de entradas que se anulam na mesma passada é IDENTIDADE estável (não altera nada, não gira) - fail-safe: o veto segue bloqueando');
+}
+
+// ===========================================================================
+// AC4 - RELATÓRIO estruturado: evidência de auditoria E insumo da SF10.12.
+// ===========================================================================
+
+function relatorioTests() {
+  console.log('\n--- AC4: relatório estruturado (evidência + insumo da SF10.12) ---');
+
+  const run = tmpDir('relatorio');
+  writeIn(run, 'artifacts/assembly.md', `linha limpa\nlinha ${EM} suja\noutra 2020${EN}2024\n`);
+  writeIn(run, 'pieces/01-capa.html', '<p>nada a corrigir</p>');
+  const logs = [];
+  const rep = pp.postProcessAttempt({ runDir: run, toolTrail: trailWrite('artifacts/assembly.md', 'pieces/01-capa.html'), log: (m) => logs.push(m) });
+
+  assert(rep.changed === true && rep.scanned === 2 && rep.files.length === 1 && rep.totalReplacements === 2,
+    `relatório: scanned=2, 1 arquivo alterado, 2 substituições (${JSON.stringify({ s: rep.scanned, f: rep.files.length, t: rep.totalReplacements })})`);
+  const f = rep.files[0];
+  assert(f.path === 'artifacts/assembly.md' && f.rules.length === 2
+    && f.rules.some((r) => r.id === 'em-dash-entre-espacos' && r.count === 1)
+    && f.rules.some((r) => r.id === 'en-dash-entre-digitos' && r.count === 1),
+    'relatório diz QUAL entrada da tabela disparou e quantas vezes, por arquivo');
+  assert(f.diff.length === 2 && f.diff[0].line === 2 && /suja/.test(f.diff[0].before) && /, suja/.test(f.diff[0].after),
+    `diff MÍNIMO por linha, com número de linha e antes/depois (linhas no diff: ${f.diff.length})`);
+  assert(logs.some((l) => /\[fixer\]/.test(l) && /assembly\.md/.test(l)), 'AC4: NUNCA silencioso - a correção aparece no log do run');
+
+  // O diff é bounded: vira mensagem de modelo na SF10.12, não pode explodir o contexto.
+  const run2 = tmpDir('relatorio-cap');
+  const muitas = Array.from({ length: 40 }, (_, i) => `linha ${i} ${EM} suja`).join('\n');
+  writeIn(run2, 'artifacts/assembly.md', muitas);
+  const rep2 = pp.postProcessAttempt({ runDir: run2, toolTrail: trailWrite('artifacts/assembly.md') });
+  assert(rep2.files[0].diff.length === pp.MAX_DIFF_LINES_PER_FILE && rep2.files[0].diffTruncated === true,
+    `diff limitado a ${pp.MAX_DIFF_LINES_PER_FILE} linhas/arquivo com flag de truncamento (o relatório vira prompt na SF10.12)`);
+  assert(rep2.files[0].replacements === 40, 'a CONTAGEM permanece completa mesmo com o diff truncado (40 substituições)');
+
+  // Costura declarada para a SF10.12.
+  const msg = pp.renderFixMessage(rep);
+  assert(/artifacts\/assembly\.md/.test(msg) && /em-dash-entre-espacos/.test(msg) && /linha 2/.test(msg),
+    'renderFixMessage produz o bloco que a SF10.12 injeta na retomada da conversa (arquivo + regra + linha)');
+  assert(pp.renderFixMessage({ changed: false, files: [] }) === '', 'sem correção, não há mensagem (custo zero no caminho limpo)');
+}
+
+// ===========================================================================
+// AC5 - VETO CONTINUA SENDO A ÚLTIMA LINHA (não-regressão).
+// ===========================================================================
+
+function naoRegressaoTests() {
+  console.log('\n--- AC5: violação NÃO-mecânica passa incólume pelo fixer e segue para o veto ---');
+
+  const run = tmpDir('nao-mecanico');
+  // Artefato INCOMPLETO (falta seção/campo que o veto exige) e SEM classe mecânica.
+  const incompleto = '## Slides Internos\n- so um slide\n\nconfianca: talvez\n';
+  writeIn(run, 'artifacts/assembly.md', incompleto);
+  const shaAntes = sha(path.join(run, 'artifacts/assembly.md'));
+  const rep = pp.postProcessAttempt({ runDir: run, toolTrail: trailWrite('artifacts/assembly.md') });
+  assert(!rep.changed && rep.files.length === 0 && sha(path.join(run, 'artifacts/assembly.md')) === shaAntes,
+    'o fixer NÃO altera um artefato com violação não-mecânica (byte-idêntico) - nada de mascarar problema de conteúdo');
+
+  // E o veto REAL continua reprovando esse artefato (o fixer não é bypass).
+  const vetoCount = rp.evalVeto({ type: 'count_gte', field: 'Slides Internos', n: 5 }, incompleto, path.join(run, 'artifacts/assembly.md'), { podRoot: run, runDir: run });
+  const vetoField = rp.evalVeto({ type: 'field_matches', field: 'confianca', pattern: '^(alta|media|baixa)$' }, incompleto, path.join(run, 'artifacts/assembly.md'), { podRoot: run, runDir: run });
+  assert(vetoCount.ok === false && vetoField.ok === false,
+    'os vetos REAIS (count_gte, field_matches) seguem reprovando depois do fixer - o veto é a ÚLTIMA linha, sem regressão');
+
+  // Arquivo já limpo: incólume, e o fixer não inventa mudança nenhuma.
+  const run2 = tmpDir('limpo');
+  const limpo = '## Slides Internos\n- slide sem travessao, com virgula\n\nconfianca: alta\n';
+  writeIn(run2, 'artifacts/assembly.md', limpo);
+  const shaLimpo = sha(path.join(run2, 'artifacts/assembly.md'));
+  const rep2 = pp.postProcessAttempt({ runDir: run2, toolTrail: trailWrite('artifacts/assembly.md') });
+  assert(!rep2.changed && sha(path.join(run2, 'artifacts/assembly.md')) === shaLimpo, 'artefato SEM travessão nenhum passa incólume (nem reescrita, nem mtime falso de correção)');
+}
+
+// ===========================================================================
+// AC8 - NO-OP sobre o bloco de MEDIDA do phash-gate.
+// ===========================================================================
+
+function phashNoOpTests() {
+  console.log('\n--- AC8: no-op sobre o bloco de MEDIDA do phash-gate ---');
+
+  // Anti-deriva PERMANENTE: os delimitadores declarados no fixer são os do veto REAL.
+  const região = pp.PROTECTED_REGIONS.find((r) => r.id === 'phash-medida-similaridade');
+  assert(região && região.begin === phash.MEASURE_BEGIN && região.end === phash.MEASURE_END,
+    'os delimitadores protegidos são byte a byte os de phash-gate.cjs (deriva futura fica VERMELHA aqui)');
+
+  // Bloco REAL gerado pelo veto, ENVENENADO com a classe mecânica (hoje o gerador não emite token
+  // banido - NOTE-4; o envenenamento prova que a proteção é ESTRUTURAL, não sorte do conteúdo).
+  const blocoReal = phash.renderMeasureBlock({ status: 'ok', rows: [{ name: 'cover.png', nearestRef: 'ref.png', distance: 31 }] });
+  const blocoEnvenenado = blocoReal.replace('## Medida de similaridade', `## Medida ${EM} de similaridade (faixa 2020${EN}2024)`);
+  const artefato = phash.upsertMeasureBlock(`## Conformidade de Referencia\nEstilo inspirado ${EM} composicao propria.\n\nreferencia_copiada: nao\nconfianca: alta\n`, blocoEnvenenado);
+
+  const run = tmpDir('phash');
+  writeIn(run, 'artifacts/visuals.md', artefato);
+  const rep = pp.postProcessAttempt({ runDir: run, toolTrail: trailWrite('artifacts/visuals.md') });
+  const depois = fs.readFileSync(path.join(run, 'artifacts/visuals.md'), 'utf8');
+
+  const b = depois.indexOf(phash.MEASURE_BEGIN);
+  const e = depois.indexOf(phash.MEASURE_END);
+  const blocoDepois = depois.slice(b, e + phash.MEASURE_END.length);
+  assert(b >= 0 && e > b && blocoDepois === blocoEnvenenado,
+    'AC8: o bloco de MEDIDA sai BYTE-IDÊNTICO do fixer, mesmo contendo a classe mecânica que o fixer corrige fora dele');
+  assert(depois.includes('Estilo inspirado, composicao propria.') && rep.changed,
+    'a prosa FORA do bloco protegido continua sendo corrigida normalmente (a proteção é cirúrgica, não um opt-out do arquivo)');
+
+  // Marcador de INÍCIO sem FIM: protege até o fim do arquivo e AVISA (nunca silencioso). O veto
+  // segue verificando o arquivo inteiro, então isso não é caminho de evasão.
+  const run2 = tmpDir('phash-aberto');
+  writeIn(run2, 'artifacts/visuals.md', `prosa ${EM} corrigivel\n${phash.MEASURE_BEGIN}\nbloco ${EM} sem fim\n`);
+  const rep2 = pp.postProcessAttempt({ runDir: run2, toolTrail: trailWrite('artifacts/visuals.md') });
+  const d2 = fs.readFileSync(path.join(run2, 'artifacts/visuals.md'), 'utf8');
+  assert(d2.includes('prosa, corrigivel') && d2.includes(`bloco ${EM} sem fim`) && rep2.warnings.length === 1,
+    'marcador de início SEM fim: protege até o fim do arquivo e registra AVISO no relatório (nunca silencioso)');
+  assert(lexical.countMatches(d2, VETO_PATTERN) === 1, 'e o veto ainda VÊ o travessão escondido no bloco aberto (não há evasão: o veto lê o arquivo inteiro)');
+}
+
+// ===========================================================================
+// FAIL-LOUD e contenção herdada das tools.
+// ===========================================================================
+
+function failLoudTests() {
+  console.log('\n--- Fail-loud e contenção (DF-SF10.11-1) ---');
+
+  const run = tmpDir('failloud');
+
+  // Path do trail que sumiu do disco: ENOENT é o ÚNICO errno com tratamento sancionado, e ele PARA
+  // o run com mensagem acionável (nunca segue em frente).
+  let e1 = null;
+  try { pp.postProcessAttempt({ runDir: run, toolTrail: trailWrite('artifacts/sumiu.md') }); } catch (e) { e1 = e; }
+  assert(e1 && /NÃO existe em disco/.test(e1.message) && /sumiu\.md/.test(e1.message),
+    'path do toolTrail ausente em disco: FALHA ALTA com mensagem acionável (ENOENT sancionado, run PARA)');
+
+  // Qualquer outro errno sobe CRU (nada de catch-all disfarçado): diretório no lugar de arquivo.
+  fs.mkdirSync(path.join(run, 'artifacts', 'sou-um-dir.md'), { recursive: true });
+  let e2 = null;
+  try { pp.postProcessAttempt({ runDir: run, toolTrail: trailWrite('artifacts/sou-um-dir.md') }); } catch (e) { e2 = e; }
+  assert(e2 && e2.code === 'EISDIR', `errno não sancionado sobe CRU, preservando .code (${e2 && e2.code})`);
+
+  // Contenção herdada de confinedResolveWritable: traversal, path absoluto e inputs/ negados.
+  for (const [rel, label] of [['../escape.md', 'traversal'], ['/etc/passwd', 'path absoluto']]) {
+    let err = null;
+    try { pp.postProcessAttempt({ runDir: run, toolTrail: trailWrite(rel) }); } catch (e) { err = e; }
+    assert(err !== null, `${label} no trail é NEGADO antes de qualquer leitura/escrita`);
+  }
+  fs.mkdirSync(path.join(run, 'inputs'), { recursive: true });
+  fs.writeFileSync(path.join(run, 'inputs', 'ref.png'), Buffer.from([0x89, 0x50]));
+  const shaRef = sha(path.join(run, 'inputs', 'ref.png'));
+  let e3 = null;
+  try { pp.postProcessAttempt({ runDir: run, toolTrail: trailWrite('inputs/ref.png') }); } catch (e) { e3 = e; }
+  assert(e3 && /PROIBIDA/.test(e3.message) && sha(path.join(run, 'inputs', 'ref.png')) === shaRef,
+    'a REFERÊNCIA materializada em inputs/ é INALCANÇÁVEL pelo fixer (DF5-6 intacto, sem defesa nova)');
+
+  // runDir obrigatório.
+  let e4 = null;
+  try { pp.postProcessAttempt({ toolTrail: [] }); } catch (e) { e4 = e; }
+  assert(e4 && /runDir/.test(e4.message), 'runDir ausente: falha alta imediata');
+}
+
+// ===========================================================================
+// FIND-1 (débito Low do gate de QA da SF10.11, PAGO na SF10.12) — um path de `write_file`
+// SOBRESCRITO por `openrouter_image` na MESMA tentativa sai do domínio: binário jamais é lido
+// como UTF-8 nem regravado. O QA mediu a corrupção antes do conserto: 16B -> 21B, sha alterado.
+// ===========================================================================
+
+function find1BinarioTests() {
+  console.log('\n--- FIND-1: binário sobrescrito por openrouter_image sai do domínio do fixer ---');
+
+  const run = tmpDir('find1');
+  // Bytes que NÃO são UTF-8 válido: 0x89 'PNG' + 0xC3 solto + 0xFF/0xFE. Ler como utf8 e regravar
+  // trocaria cada byte inválido por U+FFFD (3 bytes), que é exatamente a perda que o QA mediu.
+  const pngBytes = Buffer.from([0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a, 0xc3, 0xff, 0xfe, 0x00, 0x01, 0x02, 0x03, 0x04]);
+  const abs = path.join(run, 'assets', 'cover.png');
+  fs.mkdirSync(path.dirname(abs), { recursive: true });
+  fs.writeFileSync(abs, pngBytes);
+  const shaAntes = sha(abs);
+  const bytesAntes = fs.statSync(abs).size;
+
+  // A tentativa: o modelo escreveu o path como TEXTO (write_file) e DEPOIS a imagem o sobrescreveu.
+  // Os dois eventos estão no MESMO toolTrail — é o cenário exato do achado.
+  const trail = [
+    { name: 'write_file', ok: true, arg: 'assets/cover.png' },
+    { name: 'write_file', ok: true, arg: 'artifacts/visuals.md' },
+    { name: 'openrouter_image', ok: true, arg: 'assets/cover.png' },
+  ];
+  writeIn(run, 'artifacts/visuals.md', `Capa gerada ${EM} referência inspirada, de 2020${EN}2024.`);
+
+  const logs = [];
+  const rep = pp.postProcessAttempt({ runDir: run, toolTrail: trail, log: (m) => logs.push(m) });
+
+  assert(sha(abs) === shaAntes && fs.statSync(abs).size === bytesAntes,
+    `FIND-1: o BINÁRIO saiu INTACTO (${bytesAntes}B, sha inalterado) — nada de 16B -> 21B com U+FFFD`);
+  assert(fs.readFileSync(abs).equals(pngBytes), 'FIND-1: bytes idênticos ao original, byte a byte (comparação de Buffer, não de string)');
+  assert(rep.skippedBinary.length === 1 && rep.skippedBinary[0] === 'assets/cover.png',
+    `FIND-1: o path pulado é NOMEADO no relatório (${JSON.stringify(rep.skippedBinary)})`);
+  assert(logs.some((l) => /assets\/cover\.png/.test(l) && /PULADO/.test(l)), 'FIND-1: a subtração do domínio NUNCA é silenciosa (log do run)');
+  assert(rep.scanned === 1 && rep.files.length === 1 && rep.files[0].path === 'artifacts/visuals.md' && rep.totalReplacements === 2,
+    `FIND-1: o arquivo de TEXTO da mesma tentativa continua sendo corrigido (scanned=${rep.scanned}, ${rep.totalReplacements} substituições)`);
+
+  // Evasão por GRAFIA: './assets/cover.png' e 'assets/cover.png' são o MESMO arquivo. A subtração é
+  // por path absoluto resolvido — comparação literal de string deixaria este vetor aberto.
+  const run2 = tmpDir('find1-grafia');
+  const abs2 = path.join(run2, 'assets', 'cover.png');
+  fs.mkdirSync(path.dirname(abs2), { recursive: true });
+  fs.writeFileSync(abs2, pngBytes);
+  const rep2 = pp.postProcessAttempt({
+    runDir: run2,
+    toolTrail: [
+      { name: 'write_file', ok: true, arg: './assets/cover.png' },
+      { name: 'openrouter_image', ok: true, arg: 'assets/./cover.png' },
+    ],
+  });
+  assert(fs.readFileSync(abs2).equals(pngBytes) && rep2.skippedBinary.length === 1,
+    'FIND-1: grafias diferentes do MESMO path não escapam da subtração (resolução absoluta, não string)');
+
+  // Contrapartida: imagem que FALHOU não gravou nada naquele path — subtrair por ela removeria do
+  // domínio um arquivo de TEXTO legítimo (o fixer deixaria de ajudar em silêncio).
+  const run3 = tmpDir('find1-falha');
+  writeIn(run3, 'artifacts/visuals.md', `texto ${EM} com travessão`);
+  const rep3 = pp.postProcessAttempt({
+    runDir: run3,
+    toolTrail: [
+      { name: 'write_file', ok: true, arg: 'artifacts/visuals.md' },
+      { name: 'openrouter_image', ok: false, arg: 'artifacts/visuals.md' },
+    ],
+  });
+  assert(rep3.changed === true && rep3.skippedBinary.length === 0,
+    'FIND-1: openrouter_image que FALHOU não subtrai o path (nada foi gravado por ela; o texto continua no domínio)');
+
+  // A função de domínio isolada: só imagens BEM-SUCEDIDAS, sem duplicata, na ordem de escrita.
+  const imgs = pp.imagePathsFromTrail([
+    { name: 'openrouter_image', ok: true, arg: 'a.png' },
+    { name: 'openrouter_image', ok: true, arg: 'a.png' },
+    { name: 'openrouter_image', ok: false, arg: 'b.png' },
+    { name: 'write_file', ok: true, arg: 'c.md' },
+  ]);
+  assert(imgs.length === 1 && imgs[0] === 'a.png', `imagePathsFromTrail: só imagens ok, deduplicadas (${JSON.stringify(imgs)})`);
+}
+
+// ---------------------------------------------------------------------------
+
+function main() {
+  console.log('POWER CLAUDE — fixer determinístico pré-veto do pod-export (SF10.11)\n');
+  formaTests();
+  tabelaTests();
+  dominioTests();
+  correcaoTests();
+  idempotenciaTests();
+  relatorioTests();
+  naoRegressaoTests();
+  phashNoOpTests();
+  failLoudTests();
+  find1BinarioTests();
+  if (failures > 0) { console.error(`\nSuíte FALHOU: ${failures} violação(ões).`); process.exit(1); }
+  console.log('\nSuíte verde.');
+  process.exit(0);
+}
+
+main();