npm - @daniellins/power-claude - Versions diffs - 0.16.3 - Mend

@daniellins/power-claude 0.16.3

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Potentially problematic release.

This version of @daniellins/power-claude might be problematic. Click here for more details.

Files changed (467) hide show

package/scripts/render-png.test.cjs ADDED Viewed

@@ -0,0 +1,307 @@
+#!/usr/bin/env node
+'use strict';
+/**
+ * render-png.test.cjs — suíte do script BLESSED que PRODUZ e VERIFICA o entregável de
+ * publicação antes do checkpoint. Story SF11.11 / ADR-025.
+ *
+ * O QUE ESTA SUÍTE PROVA (cada item é um AC com oráculo, nunca um relato):
+ *   (AC1) GENERICIDADE: o fonte não contém nome de pod nem de peça — o que é do pod vem por
+ *         argumento literal do `wf`.
+ *   (AC3) DIMENSÃO É IGUALDADE, NÃO LIMIAR: `dimensionMatches` só aceita `===` nos dois lados
+ *         (1 px de diferença bloqueia), e o fonte não tem `Math.abs`/`±`/`>=`/`<=` na comparação
+ *         de dimensão. Estático + comportamental — um sem o outro é teatro.
+ *   (AC4) CARDINALIDADE EXATA: `--expect N` bloqueia com N-1 e com N+1 (os dois lados).
+ *   (AC5) AS TRÊS CLASSES DE FALHA, EXERCITADAS PELO PROCESSO REAL (execFileSync do script,
+ *         não da função): (a) CHROME_BIN inválido ⇒ exit 3 sem fallback; (b) HTML que não
+ *         rende / PNG não escrito ⇒ exit 3; (c) dir escapando do runDir ⇒ exit 2. E: NENHUM
+ *         caminho faz o script sair 0 sem ter renderizado e medido.
+ *   (AC9) BLOCO NO ARTEFATO: upsert idempotente (re-verificação não duplica).
+ *
+ * As provas que EXIGEM Chrome real registram SKIP HONESTO onde ele não existe (e o CI não tem
+ * Chrome). A aritmética de IHDR, a cardinalidade e as classes 2/3 rodam sempre.
+ *
+ * Node >= 18. Exit 0/1.
+ */
+const fs = require('node:fs');
+const os = require('node:os');
+const path = require('node:path');
+const { spawnSync } = require('node:child_process');
+const rp = require('./veto-checks/render-png.cjs');
+const { probeChrome } = require('./veto-checks/render-gate.cjs');
+const SCRIPT = path.join(__dirname, 'veto-checks', 'render-png.cjs');
+const SRC = fs.readFileSync(SCRIPT, 'utf8');
+let passed = 0;
+const failures = [];
+function ok(cond, label) {
+  if (cond) { passed++; console.log(`[OK   ] ${label}`); } else { failures.push(label); console.error(`[FALHA] ${label}`); }
+}
+function skip(label) { console.log(`[SKIP ] ${label}`); }
+/** Monta um runDir sintético: <runDir>/artifacts/<step>.md + os HTMLs pedidos. */
+function makeRun(htmls, artifactText) {
+  const runDir = fs.mkdtempSync(path.join(os.tmpdir(), 'pc-render-png-'));
+  fs.mkdirSync(path.join(runDir, 'artifacts'), { recursive: true });
+  const artifact = path.join(runDir, 'artifacts', 'assembly.md');
+  fs.writeFileSync(artifact, artifactText || '## Pacote\nconteudo da etapa\n', 'utf8');
+  for (const [name, body] of Object.entries(htmls)) fs.writeFileSync(path.join(runDir, name), body, 'utf8');
+  return { runDir, artifact };
+}
+/** Roda o SCRIPT como processo (o mesmo caminho que o motor usa). Devolve {status, stderr}. */
+function run(artifact, args, env) {
+  const r = spawnSync(process.execPath, [SCRIPT, artifact, ...args], {
+    encoding: 'utf8', timeout: 240000, env: { ...process.env, ...(env || {}) },
+  });
+  return { status: r.status, stderr: (r.stderr || '').trim(), stdout: (r.stdout || '').trim() };
+}
+const pinned = (w, h) => `<!doctype html><html><head><meta charset="utf-8"><style>html,body{width:${w}px;height:${h}px;margin:0;background:#101820}</style></head><body></body></html>`;
+// ===========================================================================
+// (AC1) Genericidade — nenhum nome de pod/peça no fonte.
+// ===========================================================================
+console.log('--- (AC1) genericidade do script blessed ---');
+for (const termo of ['hn-carousel', 'capa', 'slide', 'cta', 'carousel', 'instagram']) {
+  const hits = (SRC.match(new RegExp(termo, 'gi')) || []).length;
+  ok(hits === 0, `fonte não cita "${termo}" (ocorrências: ${hits})`);
+}
+// ===========================================================================
+// (AC3) Dimensão: igualdade de inteiros lida do IHDR — estático + comportamental.
+// ===========================================================================
+console.log('\n--- (AC3) dimensão é igualdade, não limiar ---');
+// PNG mínimo real (1x1) para provar que a leitura é dos BYTES, não de metadado externo.
+const PNG_1x1 = Buffer.from(
+  'iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVR42mP8z8BQDwAEhQGAhKmMIQAAAABJRU5ErkJggg==',
+  'base64',
+);
+const d1 = rp.readPngDimensions(PNG_1x1);
+ok(d1.ok && d1.width === 1 && d1.height === 1, `readPngDimensions lê o IHDR real (${JSON.stringify(d1)})`);
+ok(rp.readPngDimensions(Buffer.from('nao sou png, nem de longe, tenho mais de 24 bytes')).ok === false,
+  'buffer sem assinatura PNG NÃO vira palpite de dimensão (ok:false)');
+ok(rp.readPngDimensions(Buffer.alloc(10)).ok === false, 'buffer curto demais para IHDR é recusado');
+// Um pixel de diferença BLOQUEIA — os dois eixos, os dois sentidos.
+ok(rp.dimensionMatches({ width: 1080, height: 1350 }, 1080, 1350) === true, 'dimensão exata PASSA');
+ok(rp.dimensionMatches({ width: 1080, height: 1349 }, 1080, 1350) === false, '1349 de altura BLOQUEIA (1 px a menos)');
+ok(rp.dimensionMatches({ width: 1080, height: 1351 }, 1080, 1350) === false, '1351 de altura BLOQUEIA (1 px a mais)');
+ok(rp.dimensionMatches({ width: 1079, height: 1350 }, 1080, 1350) === false, '1079 de largura BLOQUEIA');
+// Oráculo ESTÁTICO da ausência de limiar: a função de veredito de dimensão só usa `===`.
+const fnSrc = SRC.slice(SRC.indexOf('function dimensionMatches'), SRC.indexOf('function countMatches'));
+ok(!/Math\.abs|tolerance|toleranc|>=|<=|±|\bdelta\b/i.test(fnSrc),
+  `dimensionMatches não tem comparação frouxa (trecho: ${fnSrc.replace(/\s+/g, ' ').trim().slice(0, 120)})`);
+ok((fnSrc.match(/===/g) || []).length === 2, 'dimensionMatches compara os DOIS eixos com === (2 ocorrências)');
+// ===========================================================================
+// (AC4) Cardinalidade exata — os dois lados.
+// ===========================================================================
+console.log('\n--- (AC4) contagem exata (--expect) ---');
+ok(rp.countMatches(7, 7) === true, 'countMatches: 7 de 7 PASSA');
+ok(rp.countMatches(6, 7) === false, 'countMatches: 6 de 7 BLOQUEIA');
+ok(rp.countMatches(8, 7) === false, 'countMatches: 8 de 7 BLOQUEIA');
+{
+  const six = Object.fromEntries(Array.from({ length: 6 }, (_, i) => [`0${i + 1}-p.html`, pinned(1080, 1350)]));
+  const { runDir, artifact } = makeRun(six);
+  const r = run(artifact, ['--html-dir', '..', '--out-dir', '../png', '--width', '1080', '--height', '1350', '--expect', '7']);
+  ok(r.status === 1 && /encontrado\(s\) 6/.test(r.stderr), `6 HTMLs com --expect 7 ⇒ exit 1 nomeando a contagem (exit=${r.status}) — ${r.stderr.slice(0, 110)}`);
+  ok(!fs.existsSync(path.join(runDir, 'png')), 'contagem errada bloqueia ANTES de gastar render (png/ nem é criado)');
+  fs.rmSync(runDir, { recursive: true, force: true });
+}
+{
+  const eight = Object.fromEntries(Array.from({ length: 8 }, (_, i) => [`0${i + 1}-p.html`, pinned(1080, 1350)]));
+  const { runDir, artifact } = makeRun(eight);
+  const r = run(artifact, ['--html-dir', '..', '--out-dir', '../png', '--width', '1080', '--height', '1350', '--expect', '7']);
+  ok(r.status === 1 && /encontrado\(s\) 8/.test(r.stderr), `8 HTMLs com --expect 7 ⇒ exit 1 nomeando a contagem (exit=${r.status})`);
+  fs.rmSync(runDir, { recursive: true, force: true });
+}
+// ===========================================================================
+// (AC5c) Classe WIRING = exit 2 — uso inválido, dir fora do runDir, artefato ausente.
+// ===========================================================================
+console.log('\n--- (AC5c) classe wiring/uso ⇒ exit 2 ---');
+{
+  const { runDir, artifact } = makeRun({ '01-p.html': pinned(1080, 1350) });
+  const escapes = run(artifact, ['--html-dir', '../../..', '--out-dir', '../png', '--width', '1080', '--height', '1350', '--expect', '1']);
+  ok(escapes.status === 2 && /FORA do runDir/.test(escapes.stderr), `--html-dir fora do runDir ⇒ exit 2 (exit=${escapes.status})`);
+  const escapesOut = run(artifact, ['--html-dir', '..', '--out-dir', '../../fuga', '--width', '1080', '--height', '1350', '--expect', '1']);
+  ok(escapesOut.status === 2 && /FORA do runDir/.test(escapesOut.stderr), `--out-dir fora do runDir ⇒ exit 2 (exit=${escapesOut.status})`);
+  const semArg = run(artifact, ['--html-dir', '..', '--out-dir', '../png', '--width', '1080', '--height', '1350']);
+  ok(semArg.status === 2 && /--expect/.test(semArg.stderr), `--expect ausente ⇒ exit 2 (sem default silencioso) (exit=${semArg.status})`);
+  const argRuim = run(artifact, ['--html-dir', '..', '--out-dir', '../png', '--width', '108o', '--height', '1350', '--expect', '1']);
+  ok(argRuim.status === 2 && /--width/.test(argRuim.stderr), `--width não-inteiro ⇒ exit 2 (exit=${argRuim.status})`);
+  const dirInexistente = run(artifact, ['--html-dir', 'nao-existe', '--out-dir', '../png', '--width', '1080', '--height', '1350', '--expect', '1']);
+  ok(dirInexistente.status === 2 && /nao existe/.test(dirInexistente.stderr), `--html-dir inexistente ⇒ exit 2 (exit=${dirInexistente.status})`);
+  fs.rmSync(runDir, { recursive: true, force: true });
+}
+{
+  const r = run(path.join(os.tmpdir(), 'nao-ha-artefato-aqui-pc.md'), ['--html-dir', '..', '--out-dir', '../png', '--width', '1', '--height', '1', '--expect', '1']);
+  ok(r.status === 2 && /artefato nao encontrado/.test(r.stderr), `artefato inexistente ⇒ exit 2 (exit=${r.status})`);
+}
+ok(typeof rp.resolveWithin === 'function' && (() => {
+  try { rp.resolveWithin('/tmp/run', '/tmp/run/artifacts', '../../..', '--html-dir'); return false; } catch (e) { return e instanceof rp.UsageError; }
+})(), 'resolveWithin lança UsageError (classe 2) quando o arg escapa do runDir');
+// ===========================================================================
+// (AC5a) Classe DEPENDÊNCIA = exit 3 — Chrome ausente/inválido, SEM fallback.
+// ===========================================================================
+console.log('\n--- (AC5a) Chrome inválido ⇒ exit 3, fail-loud sem fallback ---');
+{
+  const { runDir, artifact } = makeRun({ '01-p.html': pinned(1080, 1350) });
+  const r = run(artifact, ['--html-dir', '..', '--out-dir', '../png', '--width', '1080', '--height', '1350', '--expect', '1'],
+    { CHROME_BIN: '/nao/existe/chrome-inexistente' });
+  ok(r.status === 3 && /Chrome nao encontrado/.test(r.stderr),
+    `CHROME_BIN inválido ⇒ exit 3 com mensagem acionável (exit=${r.status}) — ${r.stderr.slice(0, 120)}`);
+  ok(!fs.existsSync(path.join(runDir, 'png', '01-p.png')),
+    'CHROME_BIN inválido NÃO cai em outro navegador (nenhum PNG produzido) — sem fallback silencioso');
+  fs.rmSync(runDir, { recursive: true, force: true });
+}
+// ===========================================================================
+// (AC5b) Classe DEPENDÊNCIA = exit 3 — render que falha e render que não escreve o PNG.
+// Exercitada DETERMINISTICAMENTE, sem depender de Chrome: `CHROME_BIN` aponta para um
+// binário que existe (logo passa a sonda) e (i) sai != 0, ou (ii) sai 0 SEM escrever nada.
+// O caso (ii) é o mais perigoso dos dois — é exatamente o green-fake que a SF11.4b ensinou
+// a temer (o Chrome-snap na VPS saía 0 sem renderizar). Ele TEM que bloquear.
+// ===========================================================================
+console.log('\n--- (AC5b) render falho / PNG não escrito ⇒ exit 3 ---');
+if (!fs.existsSync('/usr/bin/false') || !fs.existsSync('/usr/bin/true')) {
+  skip('/usr/bin/{true,false} ausentes nesta máquina: provas determinísticas da classe 3 não rodaram');
+} else {
+  const a = makeRun({ '01-p.html': pinned(1080, 1350) });
+  const rFail = run(a.artifact, ['--html-dir', '..', '--out-dir', '../png', '--width', '1080', '--height', '1350', '--expect', '1'],
+    { CHROME_BIN: '/usr/bin/false' });
+  ok(rFail.status === 3 && /falha ao renderizar "01-p\.html"/.test(rFail.stderr),
+    `renderizador que sai != 0 ⇒ exit 3 nomeando o arquivo (exit=${rFail.status}) — ${rFail.stderr.slice(0, 130)}`);
+  fs.rmSync(a.runDir, { recursive: true, force: true });
+  const b = makeRun({ '01-p.html': pinned(1080, 1350) });
+  const rMudo = run(b.artifact, ['--html-dir', '..', '--out-dir', '../png', '--width', '1080', '--height', '1350', '--expect', '1'],
+    { CHROME_BIN: '/usr/bin/true' });
+  ok(rMudo.status === 3 && /NAO escreveu o PNG/.test(rMudo.stderr),
+    `renderizador que sai 0 SEM escrever o PNG ⇒ exit 3 (green-fake bloqueado) (exit=${rMudo.status}) — ${rMudo.stderr.slice(0, 130)}`);
+  fs.rmSync(b.runDir, { recursive: true, force: true });
+}
+// ===========================================================================
+// (AC5) Ausência de escape hatch — nenhum caminho de código sai 0 sem verificar.
+// ===========================================================================
+console.log('\n--- (AC5) sem escape hatch ---');
+const exits0 = SRC.match(/process\.exit\(0\)/g) || [];
+ok(exits0.length === 1, `existe UM único process.exit(0) no script (encontrados: ${exits0.length})`);
+const tail = SRC.slice(SRC.lastIndexOf('process.exit(0)') - 900, SRC.lastIndexOf('process.exit(0)'));
+ok(/render-png OK/.test(tail), 'o único exit 0 vem DEPOIS do laço de render+medida (linha de sucesso o precede)');
+ok(!/--skip|--bypass|--allow-|--no-verify|SKIP_|BYPASS_|PC_RENDER_/.test(SRC),
+  'não há flag nem env var de bypass no fonte (grep por --skip/--bypass/--allow-/--no-verify/SKIP_/BYPASS_)');
+// `skip`/`ignore` aparecem SÓ em contexto justificado: doutrina anti-skip e a opção `stdio` do
+// Node. Este teste falha se aparecerem em qualquer outro lugar.
+const suspeitas = SRC.split('\n').filter((l) => /\b(skip|bypass|ignore)\b/i.test(l))
+  .filter((l) => !/NUNCA skip-silencioso|degradacao silenciosa|stdio:/.test(l));
+ok(suspeitas.length === 0, `nenhuma ocorrência não-justificada de skip/bypass/ignore (suspeitas: ${suspeitas.join(' // ').slice(0, 160)})`);
+// ===========================================================================
+// (AC9) Bloco no artefato: upsert IDEMPOTENTE.
+// ===========================================================================
+console.log('\n--- (AC9) bloco delimitado, upsert idempotente ---');
+{
+  const bloco = rp.renderBlock({
+    rows: [{ png: '01-p.png', measured: { ok: true, width: 1080, height: 1350 }, sha256: 'abc123', verdict: 'OK' }],
+    width: 1080, height: 1350, outRel: 'png', chromeLabel: 'chrome-teste', failures: [],
+  });
+  const base = '## Pacote\nlinha original\n';
+  const um = rp.upsertBlock(base, bloco);
+  const dois = rp.upsertBlock(um, bloco);
+  const conta = (t, m) => (t.split(m).length - 1);
+  ok(conta(um, rp.BLOCK_BEGIN) === 1 && conta(dois, rp.BLOCK_BEGIN) === 1, 'o bloco não duplica na re-verificação (upsert)');
+  ok(dois === um, 'segunda escrita do MESMO bloco é byte-idêntica à primeira');
+  ok(um.includes('linha original'), 'o conteúdo original do artefato é preservado');
+  ok(!/[—–]/.test(bloco), 'o bloco não introduz travessão em/en-dash (não quebra o veto lexical de quem o consome)');
+  ok(/1080x1350/.test(bloco) && /abc123/.test(bloco), 'o bloco registra dimensão medida e sha256 por peça');
+}
+// ===========================================================================
+// (AC2/AC5b/AC3) Provas com Chrome REAL — caminho feliz, dimensão errada, HTML que não rende.
+// ===========================================================================
+console.log('\n--- (Chrome real) caminho feliz, dimensão errada, render falho ---');
+const chrome = probeChrome();
+if (!chrome) {
+  skip('Chrome ausente nesta máquina: provas de render real NÃO rodaram (nada foi presumido verde)');
+} else {
+  // Caminho feliz: 2 peças pinadas, dimensão exata ⇒ exit 0 + PNGs em disco + bloco no artefato.
+  const { runDir, artifact } = makeRun({ '01-p.html': pinned(1080, 1350), '02-p.html': pinned(1080, 1350) });
+  const r = run(artifact, ['--html-dir', '..', '--out-dir', '../png', '--width', '1080', '--height', '1350', '--expect', '2']);
+  const pngs = fs.existsSync(path.join(runDir, 'png')) ? fs.readdirSync(path.join(runDir, 'png')).sort() : [];
+  ok(r.status === 0, `caminho feliz ⇒ exit 0 (exit=${r.status}) — ${r.stderr.slice(0, 160)}`);
+  ok(pngs.join(',') === '01-p.png,02-p.png', `os PNGs existem em disco: [${pngs.join(', ')}]`);
+  const dims = pngs.map((f) => rp.readPngDimensions(fs.readFileSync(path.join(runDir, 'png', f))));
+  ok(dims.every((d) => d.ok && d.width === 1080 && d.height === 1350),
+    `todo PNG mede 1080x1350 por IHDR (${dims.map((d) => `${d.width}x${d.height}`).join(', ')})`);
+  const art = fs.readFileSync(artifact, 'utf8');
+  ok(art.includes(rp.BLOCK_BEGIN) && art.includes('01-p.png'), 'o artefato ganhou o bloco com as peças');
+  // Re-verificação (o motor reexecuta o veto a cada advance): NÃO duplica o bloco.
+  const r2 = run(artifact, ['--html-dir', '..', '--out-dir', '../png', '--width', '1080', '--height', '1350', '--expect', '2']);
+  const art2 = fs.readFileSync(artifact, 'utf8');
+  ok(r2.status === 0 && (art2.split(rp.BLOCK_BEGIN).length - 1) === 1, 'reexecução mantém exit 0 e UM bloco só');
+  fs.rmSync(runDir, { recursive: true, force: true });
+  // MEDIÇÃO QUE FALSIFICA A PREMISSA DO ADR-025 (registrada aqui, no código, e não só em prosa):
+  // a dimensão do PNG é ditada pelo `--window-size`, NÃO pelo CSS do documento. Este par de
+  // renders prova em disco que "plantar um HTML de altura diferente" NÃO produz PNG de altura
+  // diferente — logo aquele oráculo é inalcançável, e um teste que fingisse alcançá-lo seria
+  // fixture fabricada para passar (a armadilha que a doutrina da casa chama de teatro).
+  const alt = makeRun({ '01-p.html': pinned(1080, 2000), '02-p.html': pinned(900, 700) });
+  const ra = run(alt.artifact, ['--html-dir', '..', '--out-dir', '../png', '--width', '1080', '--height', '1350', '--expect', '2']);
+  const dAlt = ['01-p.png', '02-p.png'].map((f) => rp.readPngDimensions(fs.readFileSync(path.join(alt.runDir, 'png', f))));
+  ok(ra.status === 0 && dAlt.every((d) => d.width === 1080 && d.height === 1350),
+    `MEDIDO: HTML pinado a 1080x2000 e a 900x700 renderizam ambos ${dAlt.map((d) => `${d.width}x${d.height}`).join(' e ')} ` +
+    '— a moldura vem do --window-size, não do CSS (premissa do AC8 do ADR-025 FALSIFICADA)');
+  fs.rmSync(alt.runDir, { recursive: true, force: true });
+}
+// ===========================================================================
+// (AC3, comportamental) Dimensão errada ⇒ exit 1 NOMEANDO peça e medida.
+//
+// Dado o achado acima, a classe que esta checagem de fato defende é o RENDERIZADOR QUE
+// DESOBEDECE a moldura (escala dobrada/HiDPI, PNG truncado, binário que sai 0 escrevendo outra
+// coisa — a classe green-fake do chromium-snap, achado 1 do provisionamento da VPS). É ESSA
+// classe que o teste abaixo exercita, pelo processo real, com um renderizador de mentira que
+// escreve um PNG válido de tamanho errado. Roda sem Chrome, deterministicamente.
+// ===========================================================================
+console.log('\n--- (AC3 comportamental) renderizador que produz dimensão errada ⇒ exit 1 ---');
+{
+  const fake = fs.mkdtempSync(path.join(os.tmpdir(), 'pc-fake-chrome-'));
+  const fakeBin = path.join(fake, 'chrome-mentiroso');
+  fs.writeFileSync(fakeBin, `#!/bin/sh
+# Renderizador de mentira: escreve um PNG VALIDO, porem 1x1 - o tamanho que ninguem pediu.
+for a in "$@"; do
+  case "$a" in
+    --screenshot=*) printf '%s' '${PNG_1x1.toString('base64')}' | base64 -d > "\${a#--screenshot=}" ;;
+  esac
+done
+exit 0
+`, 'utf8');
+  fs.chmodSync(fakeBin, 0o755);
+  const bad = makeRun({ '01-p.html': pinned(1080, 1350), '02-p.html': pinned(1080, 1350) });
+  const rb = run(bad.artifact, ['--html-dir', '..', '--out-dir', '../png', '--width', '1080', '--height', '1350', '--expect', '2'],
+    { CHROME_BIN: fakeBin });
+  ok(rb.status === 1 && /01-p\.png/.test(rb.stderr) && /medido 1x1, exigido 1080x1350/.test(rb.stderr),
+    `PNG fora da moldura ⇒ exit 1 nomeando peça e dimensão medida (exit=${rb.status}) — ${rb.stderr.slice(0, 160)}`);
+  const artBad = fs.readFileSync(bad.artifact, 'utf8');
+  ok(/DIMENSAO ERRADA/.test(artBad) && /1x1/.test(artBad),
+    'o bloqueio por dimensão deixa o número medido no artefato (quem for consertar vê o valor)');
+  fs.rmSync(bad.runDir, { recursive: true, force: true });
+  fs.rmSync(fake, { recursive: true, force: true });
+}
+// ===========================================================================
+console.log(`\n${passed} prova(s) passaram; ${failures.length} falha(s).`);
+if (failures.length > 0) {
+  console.error(`RENDER-PNG SUITE FALHOU: ${failures.join(' | ')}`);
+  process.exit(1);
+}
+process.exit(0);

package/scripts/smoke-isolation.test.cjs ADDED Viewed

@@ -0,0 +1,100 @@
+#!/usr/bin/env node
+'use strict';
+/**
+ * smoke-isolation.test.cjs — regressão do fix SF7.7 (AC2): `smoke-pod-workflow.cjs` isola
+ * a memória do pod-alvo em TODA execução, não só `--sweep`. Prova que rodar o smoke
+ * NÃO-sweep contra um pod real deixa `memory/learnings.jsonl` (e `learnings.consolidated.md`)
+ * BYTE-INTOCADO — fecha os 2 incidentes reais (OBS-MOTOR-1 do gate SF7.5; contaminação do
+ * pre-push do pc-devops no hn-carousel), cuja causa-raiz era o `cfg` do `main()` sem
+ * `memoryPodDir` → o runner escrevia em `memoryPodDir || podRoot` = a memória REAL.
+ *
+ * Prova negativa (mesma classe de forge.test.cjs): sha256 + tamanho antes == depois.
+ * O pod-alvo é uma CÓPIA em tmpdir do fixture canary (memória semeada com conteúdo próprio),
+ * para não depender da memória gitignored do canary nem poluir nada versionado.
+ *
+ * Node >= 18. Exit 0/1.
+ */
+const fs = require('node:fs');
+const os = require('node:os');
+const path = require('node:path');
+const crypto = require('node:crypto');
+const { spawnSync } = require('node:child_process');
+const REPO_ROOT = path.resolve(__dirname, '..');
+const CANARY = path.join(REPO_ROOT, 'scripts', '__fixtures__', 'smoke-canary');
+const SMOKE = path.join(REPO_ROOT, 'scripts', 'smoke-pod-workflow.cjs');
+let passed = 0;
+const failures = [];
+function ok(cond, label) {
+  if (cond) { passed++; console.log(`[OK   ] ${label}`); }
+  else { failures.push(label); console.error(`[FALHA] ${label}`); }
+}
+const sha = (p) => crypto.createHash('sha256').update(fs.readFileSync(p)).digest('hex');
+// --- Monta um pod-alvo REAL isolado (cópia do canary) com memória semeada própria. ---
+const podDir = fs.mkdtempSync(path.join(os.tmpdir(), 'sf77-pod-'));
+// SF11.2/DF-SF11.2-4: `agents/` entra na cópia — o runner resolve e VERIFICA
+// `agents/<step.agent>.md` antes de despachar; pod sem eles é `leitura_obrigatoria_ausente`.
+for (const sub of ['workflows', 'templates', 'agents']) {
+  fs.cpSync(path.join(CANARY, sub), path.join(podDir, sub), { recursive: true });
+}
+// SF8.3 (fix latente de checkout limpo): `__fixtures__/**/memory/` é gitignorado e,
+// desde a SF7.7 (isolamento incondicional), o smoke NÃO recria esse dir — a cópia
+// dele só funcionava em working dirs com resíduo pré-SF7.7. O baseline é SEMEADO
+// logo abaixo de qualquer forma; basta criar o dir vazio (worktree/CI-safe).
+fs.mkdirSync(path.join(podDir, 'memory'), { recursive: true });
+const jsonl = path.join(podDir, 'memory', 'learnings.jsonl');
+const consolidated = path.join(podDir, 'memory', 'learnings.consolidated.md');
+// Semeia conteúdo conhecido (sobrescreve a cópia, garantindo baseline determinística).
+fs.writeFileSync(jsonl, '{"seed":"baseline-sf7.7","ts":"fixo"}\n', 'utf8');
+fs.writeFileSync(consolidated, '# consolidado semeado SF7.7\n- item fixo\n', 'utf8');
+const before = { jsonl: sha(jsonl), consolidated: sha(consolidated), size: fs.statSync(jsonl).size };
+// --- SNAPSHOT de higiene, ANTES de qualquer spawnSync (SF13.9). ---
+// A asserção de resíduo é por DELTA: só reprova `pc-smoke-mem-*` que ESTA
+// execução criou. Varrer o `os.tmpdir()` inteiro (o que estava aqui até a
+// SF13.9) derrubava a suíte por resíduo de OUTRA execução que não chegou a
+// limpar — leitura SUPERADA, não repetir: custou 4 rodadas de investigação num
+// único dia, todas contornadas com `TMPDIR` isolado, por falso alarme.
+// O que o delta NÃO afrouxa: vazamento genuíno desta execução continua
+// reprovando (é a única coisa que esta asserção existe para pegar).
+const tmpdirAntes = new Set(
+  fs.readdirSync(os.tmpdir()).filter((n) => n.startsWith('pc-smoke-mem-')),
+);
+// --- Roda o smoke NÃO-sweep (as 4 provas) via CLI real contra o pod copiado. ---
+const wf = path.join(podDir, 'workflows', 'wf-canary.yaml');
+const res = spawnSync('node', [SMOKE, wf, '--pod-root', podDir], { encoding: 'utf8' });
+ok(res.status === 0, `smoke não-sweep roda verde (exit ${res.status}) — ${(res.stdout || '').trim().split('\n').pop()}`);
+const after = { jsonl: sha(jsonl), consolidated: sha(consolidated), size: fs.statSync(jsonl).size };
+// --- AC2: memória BYTE-INTOCADA (o coração do fix). ---
+ok(before.jsonl === after.jsonl, `learnings.jsonl BYTE-INTOCADO após smoke não-sweep (sha ${before.jsonl.slice(0, 12)}… == ${after.jsonl.slice(0, 12)}…; ${after.size} bytes)`);
+ok(before.consolidated === after.consolidated, 'learnings.consolidated.md BYTE-INTOCADO após smoke não-sweep');
+ok(before.size === after.size, `tamanho de learnings.jsonl inalterado (${before.size} == ${after.size})`);
+// --- Higiene: nenhum pc-smoke-mem-* NOVO (cleanup em finally). Delta contra o
+//     snapshot capturado antes do primeiro spawn — resíduo alheio é ignorado,
+//     vazamento desta execução reprova. ---
+const tmpdirDepois = fs.readdirSync(os.tmpdir()).filter((n) => n.startsWith('pc-smoke-mem-'));
+const leftover = tmpdirDepois.filter((n) => !tmpdirAntes.has(n));
+ok(leftover.length === 0, `cleanup: zero tmpdirs pc-smoke-mem-* NOVOS nesta execução (encontrados: ${leftover.length}; preexistentes ignorados: ${tmpdirAntes.size})`);
+// --- Também nos modos de injeção (compartilham o mesmo cfg do main). ---
+const resInj = spawnSync('node', [SMOKE, wf, '--pod-root', podDir, '--inject-veto-violation'], { encoding: 'utf8' });
+ok(resInj.status === 0 && sha(jsonl) === before.jsonl,
+  'modo --inject-veto-violation também isola a memória (byte-intocada)');
+// limpeza best-effort do pod temporário do teste.
+try { fs.rmSync(podDir, { recursive: true, force: true }); } catch { /* ok */ }
+if (failures.length > 0) {
+  console.error(`\nSuíte de isolamento de memória do smoke FALHOU: ${failures.length} de ${passed + failures.length}.`);
+  process.exit(1);
+}
+console.log(`\n${passed} asserções verdes. Smoke isola a memória do pod incondicionalmente (SF7.7).`);
+process.exit(0);