@daniellins/power-claude 0.16.3

package/scripts/pod-memory.test.cjs

@@ -0,0 +1,951 @@
+#!/usr/bin/env node
+'use strict';
+/**
+ * pod-memory.test.cjs — suíte própria NÃO-FAKE-GREEN do motor de memória (Story SF2.1).
+ *
+ * Prova em código, com pods sintéticos em diretório temporário, cada garantia
+ * categórica do ADR-003 / SPEC §G1 — não "relata sucesso", exercita o pior caso:
+ *   AC1  append grava JSON válido append-only (não reescreve linhas anteriores).
+ *   AC2  append REJEITA `tier: "critical"` sem `attributed_by` válido / enum inválido.
+ *   AC3  consolidate NUNCA excede top-N=30 (centenas de entradas).
+ *   AC4  consolidate NUNCA excede o budget de ~1.500 tokens (poda por score).
+ *   AC5  CRITICAL NUNCA despejado — sobrevive a >M rotação + poda do top-N.
+ *   AC6  teto de pins ≤10 força needsCuration; 11º não aceito silenciosamente.
+ *   AC7  conflito determinístico e reprodutível (mesmo input → mesmo vencedor).
+ *   AC8  promoção por contagem + obsolete rebaixa/arquiva.
+ *   AC9  rotação além de M=500 arquiva (não deleta) sem remover fonte de pin.
+ *   AC10 getConsolidatedForBrief só lê o consolidado — nunca o .jsonl (inspeção do
+ *        código-fonte da função + prova de comportamento).
+ *   +    idempotência de consolidate (rodar 2x → mesmo resultado).
+ *
+ * Node >= 18, sem dependências externas. Padrão de forge.test.cjs/pc-run-pod.test.cjs.
+ */
+
+const fs = require('node:fs');
+const os = require('node:os');
+const path = require('node:path');
+
+const mem = require('../scripts/pod-memory.cjs');
+const {
+  append, consolidate, rotate, getConsolidatedForBrief,
+  memoryPaths, detectConflicts, mergeEntries,
+  TOP_N, ROTATE_M, TOKEN_BUDGET, PIN_CAP,
+} = mem;
+
+const results = [];
+function check(label, cond, detail) {
+  results.push({ label, ok: Boolean(cond), detail: detail || '' });
+}
+
+function tmpRoot(name) {
+  return fs.mkdtempSync(path.join(os.tmpdir(), `podmem-${name}-`));
+}
+
+// entrada normal sintética com ts explícito (evita colisão de Date.now())
+function normalEntry(i, extra = {}) {
+  return {
+    id: `n${i}`,
+    ts: 1_700_000_000_000 + i * 1000,
+    trigger: `trigger-${i}`,
+    recommendation: `recomendação número ${i}`,
+    evidence: { count: 1 },
+    tier: 'normal',
+    source_run_id: `run-${i}`,
+    ...extra,
+  };
+}
+
+// ───────────────────────────────────────────────────────────────────────────
+// AC1 — append grava JSON válido, append-only.
+// ───────────────────────────────────────────────────────────────────────────
+{
+  const root = tmpRoot('ac1');
+  append('p', normalEntry(1), { root });
+  const rawPath = memoryPaths('p', { root }).raw;
+  const firstLine = fs.readFileSync(rawPath, 'utf8').trim();
+  append('p', normalEntry(2), { root });
+  const lines = fs.readFileSync(rawPath, 'utf8').split('\n').filter(Boolean);
+  check('AC1 append grava 1 linha JSON parseável', (() => { try { JSON.parse(firstLine); return true; } catch { return false; } })());
+  check('AC1 append-only: 2 linhas após 2 appends', lines.length === 2, `${lines.length} linhas`);
+  check('AC1 append-only: 1ª linha inalterada após 2º append', lines[0] === firstLine);
+  fs.rmSync(root, { recursive: true, force: true });
+}
+
+// ───────────────────────────────────────────────────────────────────────────
+// AC2 — append REJEITA critical sem atribuição válida (trava ii).
+// ───────────────────────────────────────────────────────────────────────────
+{
+  const root = tmpRoot('ac2');
+  const rawPath = memoryPaths('p', { root }).raw;
+  let rejectedNoAttr = false;
+  try { append('p', { trigger: 't', recommendation: 'r', tier: 'critical' }, { root }); }
+  catch { rejectedNoAttr = true; }
+  let rejectedBadEnum = false;
+  try { append('p', { trigger: 't', recommendation: 'r', tier: 'critical', attributed_by: 'agent' }, { root }); }
+  catch { rejectedBadEnum = true; }
+  // controle positivo: critical COM atribuição válida é aceito
+  const okHuman = append('p', { trigger: 't', recommendation: 'r', tier: 'critical', attributed_by: 'human' }, { root });
+  check('AC2 rejeita critical sem attributed_by', rejectedNoAttr);
+  check('AC2 rejeita critical com enum inválido ("agent")', rejectedBadEnum);
+  check('AC2 nada gravado nas 2 rejeições (só a válida)', fs.existsSync(rawPath) && fs.readFileSync(rawPath, 'utf8').split('\n').filter(Boolean).length === 1);
+  check('AC2 aceita critical com attributed_by="human"', okHuman && okHuman.ok === true);
+  fs.rmSync(root, { recursive: true, force: true });
+}
+
+// ───────────────────────────────────────────────────────────────────────────
+// AC3 — consolidate nunca excede top-N=30 (centenas de entradas).
+// ───────────────────────────────────────────────────────────────────────────
+{
+  const root = tmpRoot('ac3');
+  for (let i = 0; i < 300; i++) append('p', normalEntry(i), { root });
+  const r = consolidate('p', { root });
+  check('AC3 topNCount ≤ 30 com 300 entradas', r.topNCount <= TOP_N, `topNCount=${r.topNCount}`);
+  // conta bullets da seção top-N no .md gerado
+  const md = fs.readFileSync(memoryPaths('p', { root }).consolidated, 'utf8');
+  const topSection = md.split('## Heurísticas (top-N)')[1] || '';
+  const bullets = topSection.split('\n').filter((l) => l.startsWith('- ')).length;
+  check('AC3 bullets do consolidado ≤ 30', bullets <= TOP_N, `${bullets} bullets`);
+  fs.rmSync(root, { recursive: true, force: true });
+}
+
+// ───────────────────────────────────────────────────────────────────────────
+// AC4 — consolidate nunca excede o budget de tokens (~1.500), poda por score.
+// ───────────────────────────────────────────────────────────────────────────
+{
+  const root = tmpRoot('ac4');
+  // recomendações longas: 30 * ~400 chars ≈ 12k chars ≈ 3k tokens >> 1500.
+  const longText = 'x'.repeat(400);
+  for (let i = 0; i < 40; i++) {
+    append('p', normalEntry(i, { recommendation: `${longText}-${i}` }), { root });
+  }
+  const r = consolidate('p', { root });
+  const md = fs.readFileSync(memoryPaths('p', { root }).consolidated, 'utf8');
+  const estTokens = Math.ceil(Buffer.byteLength(md, 'utf8') / 4);
+  check('AC4 tokens do .md ≤ budget (~1500)', estTokens <= TOKEN_BUDGET, `~${estTokens} tokens`);
+  check('AC4 poda por budget reduziu abaixo do top-N (< 30)', r.topNCount < TOP_N, `topNCount=${r.topNCount}`);
+  check('AC4 r.tokens reportado ≤ budget', r.tokens <= TOKEN_BUDGET, `r.tokens=${r.tokens}`);
+  fs.rmSync(root, { recursive: true, force: true });
+}
+
+// ───────────────────────────────────────────────────────────────────────────
+// AC5 — CRITICAL nunca despejado por rotação (>M) nem por poda do top-N.
+// ───────────────────────────────────────────────────────────────────────────
+{
+  const root = tmpRoot('ac5');
+  // 1 CRITICAL ANTIGO (ts mais baixo de todos) + M+50 normais mais novos.
+  append('p', {
+    id: 'crit-old', ts: 1, trigger: 'operação destrutiva',
+    recommendation: 'nunca rode rm -rf sem confirmação humana',
+    tier: 'critical', attributed_by: 'human', evidence: { count: 1 },
+  }, { root });
+  const total = ROTATE_M + 50;
+  for (let i = 0; i < total; i++) append('p', normalEntry(i), { root });
+
+  const c1 = consolidate('p', { root });
+  const rot = rotate('p', { root });
+  const c2 = consolidate('p', { root });
+  const md = fs.readFileSync(memoryPaths('p', { root }).consolidated, 'utf8');
+  const rawAfter = fs.readFileSync(memoryPaths('p', { root }).raw, 'utf8');
+
+  check('AC5 rotação ocorreu (>M)', rot.rotated > 0, `rotated=${rot.rotated}`);
+  check('AC5 CRITICAL pinado presente no .md pós rotação+poda', md.includes('rm -rf sem confirmação'));
+  check('AC5 seção "## CRITICAL (pinado)" existe', md.includes('## CRITICAL (pinado)'));
+  check('AC5 entrada-fonte do CRITICAL NÃO removida do log cru por rotação', rawAfter.includes('crit-old'));
+  check('AC5 pinnedCount=1 antes e depois', c1.pinnedCount === 1 && c2.pinnedCount === 1, `${c1.pinnedCount}/${c2.pinnedCount}`);
+  // e o CRITICAL não conta contra o teto do top-N: 30 normais ainda cabem.
+  check('AC5 top-N normal preenchido em paralelo ao pin', c2.topNCount === TOP_N, `topNCount=${c2.topNCount}`);
+  fs.rmSync(root, { recursive: true, force: true });
+}
+
+// ───────────────────────────────────────────────────────────────────────────
+// AC6 — teto de pins ≤10 força needsCuration; 11º não aceito silenciosamente.
+// ───────────────────────────────────────────────────────────────────────────
+{
+  const root = tmpRoot('ac6');
+  for (let i = 0; i < 11; i++) {
+    append('p', {
+      id: `crit-${i}`, ts: 1000 + i, trigger: `dano-irreversível-${i}`,
+      recommendation: `trava crítica ${i}`, tier: 'critical',
+      attributed_by: i % 2 === 0 ? 'human' : 'deterministic_rule', evidence: { count: 1 },
+    }, { root });
+  }
+  const r = consolidate('p', { root });
+  const md = fs.readFileSync(memoryPaths('p', { root }).consolidated, 'utf8');
+  // L2 fix: asserção LIMPA se a seção de pins sumir (não crash/TypeError).
+  const critParts = md.split('## CRITICAL (pinado)');
+  check('AC6 seção "## CRITICAL (pinado)" presente (não sumiu)', critParts.length >= 2, `partes=${critParts.length}`);
+  const critSection = critParts.length >= 2 ? critParts[1].split('## Heurísticas')[0] : '';
+  const pinBullets = critSection.split('\n').filter((l) => l.startsWith('- ')).length;
+  check('AC6 needsCuration=true com 11 pins', r.needsCuration === true);
+  check('AC6 pinnedCount travado em 10 (não 11)', r.pinnedCount === PIN_CAP, `pinnedCount=${r.pinnedCount}`);
+  check('AC6 overflow tem exatamente o excedente (1)', r.overflow.length === 1, `overflow=${r.overflow.length}`);
+  check('AC6 .md escreve no máximo 10 pins', pinBullets === PIN_CAP, `${pinBullets} pins no .md`);
+  // o 11º (overflow) NÃO está escrito como pin, mas SEGUE no log cru (não descartado)
+  const overflowId = r.overflow[0].id;
+  const overflowRec = r.overflow[0].recommendation;
+  check('AC6 11º pin não escrito no .md como pin permanente', !md.includes(overflowRec) || md.split(overflowRec).length - 1 === 0);
+  check('AC6 11º pin retido no log cru (não descartado)', fs.readFileSync(memoryPaths('p', { root }).raw, 'utf8').includes(overflowId));
+  fs.rmSync(root, { recursive: true, force: true });
+}
+
+// ───────────────────────────────────────────────────────────────────────────
+// AC7 — conflito determinístico e reprodutível.
+// ───────────────────────────────────────────────────────────────────────────
+{
+  const root = tmpRoot('ac7');
+  // par de negação limpo, mesmo trigger, evidência decide o vencedor.
+  const A = { id: 'A', ts: 100, trigger: 'deploy sexta', recommendation: 'usar cache', evidence: { count: 5 }, tier: 'normal' };
+  const B = { id: 'B', ts: 200, trigger: 'deploy sexta', recommendation: 'não usar cache', evidence: { count: 2 }, tier: 'normal' };
+  append('p', A, { root });
+  append('p', B, { root });
+
+  // reprodutibilidade: detectConflicts direto, 2x, mesmo vencedor/perdedor.
+  const merged = mergeEntries([A, B]);
+  const d1 = detectConflicts(merged);
+  const d2 = detectConflicts(mergeEntries([A, B]));
+  check('AC7 exatamente 1 conflito detectado', d1.conflicts.length === 1, `${d1.conflicts.length}`);
+  check('AC7 vencedor = maior evidência (A, count=5)', d1.conflicts[0].winner_id === 'A', d1.conflicts[0].winner_id);
+  check('AC7 perdedor = B', d1.conflicts[0].loser_id === 'B', d1.conflicts[0].loser_id);
+  check('AC7 reprodutível: run 2 = mesmo vencedor/perdedor', d2.conflicts[0].winner_id === d1.conflicts[0].winner_id && d2.conflicts[0].loser_id === d1.conflicts[0].loser_id);
+
+  // via consolidate: perdedora fora do consolidado, conflito registrado auditável.
+  consolidate('p', { root });
+  const md = fs.readFileSync(memoryPaths('p', { root }).consolidated, 'utf8');
+  const conflictsFile = memoryPaths('p', { root }).conflicts;
+  check('AC7 perdedora rebaixada (fora do consolidado)', !md.includes('não usar cache'));
+  check('AC7 vencedora presente no consolidado', md.includes('usar cache'));
+  check('AC7 conflito registrado de forma auditável (conflicts.jsonl)', fs.existsSync(conflictsFile) && fs.readFileSync(conflictsFile, 'utf8').includes('"loser_id":"B"'));
+
+  // desempate por contradicts EXPLÍCITO cruzando cores diferentes.
+  const C = { id: 'C', ts: 300, trigger: 'x', recommendation: 'faça alpha', evidence: { count: 1 }, tier: 'normal' };
+  const D = { id: 'D', ts: 400, trigger: 'y', recommendation: 'faça beta', evidence: { count: 9 }, tier: 'normal', contradicts: 'C' };
+  const dExplicit = detectConflicts(mergeEntries([C, D]));
+  check('AC7 contradicts explícito detecta conflito cross-trigger', dExplicit.conflicts.length === 1 && dExplicit.conflicts[0].winner_id === 'D');
+  fs.rmSync(root, { recursive: true, force: true });
+}
+
+// ───────────────────────────────────────────────────────────────────────────
+// H1 (regressão do gate QA) — CRITICAL NÃO é despejado por conflito com NORMAL.
+// Reproduz o ATAQUE1 do gate: 1 CRITICAL curado por humano ('nunca fazer deploy
+// sexta') + 1 NORMAL oposto de MAIOR evidência ('fazer deploy sexta', count=10).
+// SPEC §G1(e): CRITICAL só perde para OUTRO CRITICAL; aqui o pin PERMANECE, o
+// NORMAL é rebaixado, o conflito é registrado e needsCuration é sinalizado.
+// ───────────────────────────────────────────────────────────────────────────
+{
+  const root = tmpRoot('h1');
+  append('p', {
+    id: 'crit-deploy', ts: 100, trigger: 'deploy sexta',
+    recommendation: 'nunca fazer deploy sexta', tier: 'critical',
+    attributed_by: 'human', evidence: { count: 1 },
+  }, { root });
+  append('p', {
+    id: 'norm-deploy', ts: 200, trigger: 'deploy sexta',
+    recommendation: 'fazer deploy sexta', tier: 'normal', evidence: { count: 10 },
+  }, { root });
+  const r = consolidate('p', { root });
+  const md = fs.readFileSync(memoryPaths('p', { root }).consolidated, 'utf8');
+  const conflictsFile = memoryPaths('p', { root }).conflicts;
+  const conflictsTxt = fs.existsSync(conflictsFile) ? fs.readFileSync(conflictsFile, 'utf8') : '';
+
+  check('H1 CRITICAL NÃO despejado por NORMAL de maior evidência (pinnedCount=1)', r.pinnedCount === 1, `pinnedCount=${r.pinnedCount}`);
+  check('H1 seção "## CRITICAL (pinado)" presente no .md', md.includes('## CRITICAL (pinado)'));
+  check('H1 recomendação crítica permanece no consolidado', md.includes('nunca fazer deploy sexta'));
+  check('H1 NORMAL oposto é rebaixado (fora do consolidado)', !md.includes('- **[deploy sexta]** fazer deploy sexta'));
+  check('H1 conflito registrado (both_critical=false, resolution critical-protected)', conflictsTxt.includes('"both_critical":false') && conflictsTxt.includes('critical-protected'));
+  check('H1 needsCuration sinalizado (resolução é curadoria humana, não automática)', r.needsCuration === true);
+  check('H1 NORMAL perdedor NÃO removido do log cru (arquivado, nunca deletado)', fs.readFileSync(memoryPaths('p', { root }).raw, 'utf8').includes('norm-deploy'));
+
+  // controle: crit-vs-crit CONTINUA resolvendo por evidência (via legítima da SPEC).
+  // par de negação limpo (mesmo núcleo, polaridade oposta) → conflito real.
+  const cc1 = { id: 'c1', ts: 100, trigger: 'g', recommendation: 'usar cache', tier: 'critical', attributed_by: 'human', evidence: { count: 2 } };
+  const cc2 = { id: 'c2', ts: 200, trigger: 'g', recommendation: 'não usar cache', tier: 'critical', attributed_by: 'human', evidence: { count: 9 } };
+  const root2 = tmpRoot('h1cc');
+  append('p', cc1, { root: root2 });
+  append('p', cc2, { root: root2 });
+  const rcc = consolidate('p', { root: root2 });
+  const dcc = detectConflicts(mergeEntries([cc1, cc2]));
+  check('H1 crit-vs-crit resolve por evidência (winner=c2, both_critical=true)', dcc.conflicts.length === 1 && dcc.conflicts[0].winner_id === 'c2' && dcc.conflicts[0].both_critical === true);
+  check('H1 crit-vs-crit deixa 1 pin sobrevivente', rcc.pinnedCount === 1, `pinnedCount=${rcc.pinnedCount}`);
+  fs.rmSync(root, { recursive: true, force: true });
+  fs.rmSync(root2, { recursive: true, force: true });
+}
+
+// ───────────────────────────────────────────────────────────────────────────
+// AC8 — promoção por contagem + obsolete rebaixa/arquiva.
+// ───────────────────────────────────────────────────────────────────────────
+{
+  const root = tmpRoot('ac8');
+  // heurística FREQUENTE (3 ocorrências) deve ranquear acima de uma rara, mesmo
+  // com ts mais antigo — freq domina.
+  for (let k = 0; k < 3; k++) {
+    append('p', { id: `freq-${k}`, ts: 100 + k, trigger: 'padrão-A', recommendation: 'aplique A', evidence: { count: 1 }, tier: 'normal' }, { root });
+  }
+  append('p', { id: 'rare', ts: 9999, trigger: 'padrão-B', recommendation: 'aplique B raro', evidence: { count: 1 }, tier: 'normal' }, { root });
+  consolidate('p', { root });
+  const md = fs.readFileSync(memoryPaths('p', { root }).consolidated, 'utf8');
+  const idxFreq = md.indexOf('aplique A');
+  const idxRare = md.indexOf('aplique B raro');
+  check('AC8 heurística confirmada 3x aparece', idxFreq >= 0);
+  check('AC8 promoção por contagem: frequente ranqueia acima da rara', idxFreq >= 0 && idxFreq < idxRare, `freq@${idxFreq} rare@${idxRare}`);
+
+  // obsolete: mesma heurística marcada obsolete (ts mais novo) some do consolidado.
+  const root2 = tmpRoot('ac8b');
+  append('p', { id: 'o1', ts: 100, trigger: 'padrão-X', recommendation: 'faça X', evidence: { count: 1 }, tier: 'normal' }, { root: root2 });
+  append('p', { id: 'o2', ts: 200, trigger: 'padrão-X', recommendation: 'faça X', evidence: { count: 1 }, tier: 'normal', obsolete: true }, { root: root2 });
+  consolidate('p', { root: root2 });
+  const md2 = fs.readFileSync(memoryPaths('p', { root: root2 }).consolidated, 'utf8');
+  check('AC8 entrada obsolete rebaixada (fora do consolidado)', !md2.includes('faça X'));
+  fs.rmSync(root, { recursive: true, force: true });
+  fs.rmSync(root2, { recursive: true, force: true });
+}
+
+// ───────────────────────────────────────────────────────────────────────────
+// AC9 — rotação além de M=500 arquiva (não deleta) sem remover fonte de pin.
+// ───────────────────────────────────────────────────────────────────────────
+{
+  const root = tmpRoot('ac9');
+  const total = ROTATE_M + 30;
+  for (let i = 0; i < total; i++) append('p', normalEntry(i), { root });
+  const rawBefore = fs.readFileSync(memoryPaths('p', { root }).raw, 'utf8').split('\n').filter(Boolean).length;
+  const rot = rotate('p', { root });
+  const paths = memoryPaths('p', { root });
+  const rawAfter = fs.readFileSync(paths.raw, 'utf8').split('\n').filter(Boolean).length;
+  const archiveFiles = fs.existsSync(paths.archiveDir) ? fs.readdirSync(paths.archiveDir).filter((f) => /^learnings-.*\.jsonl$/.test(f)) : [];
+  const archivedCount = archiveFiles.length ? fs.readFileSync(path.join(paths.archiveDir, archiveFiles[0]), 'utf8').split('\n').filter(Boolean).length : 0;
+  check('AC9 log cru truncado a M=500', rawAfter === ROTATE_M, `rawAfter=${rawAfter}`);
+  check('AC9 excedente arquivado (não deletado): before = after + arquivado', rawBefore === rawAfter + archivedCount, `${rawBefore} = ${rawAfter} + ${archivedCount}`);
+  check('AC9 arquivo de archive criado', archiveFiles.length === 1, archiveFiles.join(','));
+  // idempotência da rotação: rodar de novo com ≤M não rotaciona.
+  const rot2 = rotate('p', { root });
+  check('AC9 rotação idempotente (2ª chamada não rotaciona)', rot2.rotated === 0, `rotated2=${rot2.rotated}`);
+  void rot;
+  fs.rmSync(root, { recursive: true, force: true });
+}
+
+// ───────────────────────────────────────────────────────────────────────────
+// AC10 — getConsolidatedForBrief só lê o consolidado, nunca o .jsonl.
+// ───────────────────────────────────────────────────────────────────────────
+{
+  const src = getConsolidatedForBrief.toString();
+  check('AC10 corpo de getConsolidatedForBrief NÃO referencia .jsonl', !/jsonl/i.test(src));
+  check('AC10 corpo referencia o consolidado', /consolidated/i.test(src));
+
+  // prova de comportamento: com log cru cheio e consolidado curado distinto,
+  // a função retorna o CONSOLIDADO, não o conteúdo do cru.
+  const root = tmpRoot('ac10');
+  append('p', normalEntry(1, { recommendation: 'SEGREDO-DO-CRU' }), { root });
+  consolidate('p', { root });
+  const brief = getConsolidatedForBrief('p', { root });
+  check('AC10 retorna conteúdo do consolidado (.md header)', brief.includes('Memória consolidada'));
+  // (a recomendação aparece no consolidado por curadoria — mas via .md, não via
+  //  leitura do .jsonl; provamos que a ausência do consolidado retorna vazio)
+  const root2 = tmpRoot('ac10b');
+  append('p', normalEntry(1), { root: root2 }); // só cru, sem consolidar
+  check('AC10 sem consolidado gerado → retorna "" (não lê o cru)', getConsolidatedForBrief('p', { root: root2 }) === '');
+  fs.rmSync(root, { recursive: true, force: true });
+  fs.rmSync(root2, { recursive: true, force: true });
+}
+
+// ───────────────────────────────────────────────────────────────────────────
+// IDEMPOTÊNCIA — consolidate 2x sem novas entradas produz o mesmo .md.
+// ───────────────────────────────────────────────────────────────────────────
+{
+  const root = tmpRoot('idem');
+  for (let i = 0; i < 50; i++) append('p', normalEntry(i), { root });
+  append('p', { id: 'A', ts: 100, trigger: 'g', recommendation: 'usar cache', evidence: { count: 5 }, tier: 'normal' }, { root });
+  append('p', { id: 'B', ts: 200, trigger: 'g', recommendation: 'não usar cache', evidence: { count: 2 }, tier: 'normal' }, { root });
+  consolidate('p', { root });
+  const md1 = fs.readFileSync(memoryPaths('p', { root }).consolidated, 'utf8');
+  // M1 fix: comparar BYTES de conflicts.jsonl, não só contagem de linhas.
+  const conf1 = fs.readFileSync(memoryPaths('p', { root }).conflicts);
+  consolidate('p', { root });
+  const md2 = fs.readFileSync(memoryPaths('p', { root }).consolidated, 'utf8');
+  const conf2 = fs.readFileSync(memoryPaths('p', { root }).conflicts);
+  const conf1Lines = conf1.toString('utf8').split('\n').filter(Boolean).length;
+  check('IDEM consolidado idêntico em 2 execuções', md1 === md2);
+  check('IDEM conflicts.jsonl byte-idêntico em 2 execuções (M1: ts determinístico)', conf1.equals(conf2), `sha1=${require('node:crypto').createHash('sha1').update(conf1).digest('hex').slice(0, 8)} vs ${require('node:crypto').createHash('sha1').update(conf2).digest('hex').slice(0, 8)}`);
+  check('IDEM conflicts.jsonl não duplica (1 conflito)', conf1Lines === 1, `${conf1Lines} linhas`);
+  fs.rmSync(root, { recursive: true, force: true });
+}
+
+// ───────────────────────────────────────────────────────────────────────────
+// L3 (regressão do gate QA) — conflicts.jsonl PRESERVA histórico após as fontes
+// de um conflito antigo saírem do log cru (rotação). Um consolidate posterior com
+// OUTRO conflito não pode sobrescrever/perder o registro antigo (§G1 "registrado").
+// ───────────────────────────────────────────────────────────────────────────
+{
+  const root = tmpRoot('l3');
+  const paths = memoryPaths('p', { root });
+  append('p', { id: 'A', ts: 100, trigger: 'g1', recommendation: 'usar cache', evidence: { count: 5 }, tier: 'normal' }, { root });
+  append('p', { id: 'B', ts: 200, trigger: 'g1', recommendation: 'não usar cache', evidence: { count: 2 }, tier: 'normal' }, { root });
+  consolidate('p', { root });
+  const afterFirst = fs.readFileSync(paths.conflicts, 'utf8');
+  check('L3 conflito A/B registrado', afterFirst.includes('"loser_id":"B"'));
+
+  // simula rotação: as fontes A e B saem do log cru; entra um NOVO conflito C/D.
+  fs.writeFileSync(paths.raw,
+    `${JSON.stringify({ id: 'C', ts: 300, trigger: 'g2', recommendation: 'fazer deploy', evidence: { count: 3 }, tier: 'normal' })}\n` +
+    `${JSON.stringify({ id: 'D', ts: 400, trigger: 'g2', recommendation: 'não fazer deploy', evidence: { count: 1 }, tier: 'normal' })}\n`);
+  consolidate('p', { root });
+  const afterSecond = fs.readFileSync(paths.conflicts, 'utf8');
+  check('L3 registro antigo A/B PRESERVADO pós-rotação das fontes', afterSecond.includes('"loser_id":"B"'));
+  check('L3 novo conflito C/D também registrado', afterSecond.includes('"loser_id":"D"'));
+  fs.rmSync(root, { recursive: true, force: true });
+}
+
+// ───────────────────────────────────────────────────────────────────────────
+// SF7.6 / QA CONCERNS-1 — heurística ENDURECIDA sobrevive à rotação (>M flood).
+// AC3 "nunca removida do log": a heurística-fonte E o registro type:"hardening"
+// são protegidos da rotação; sem eles a anotação 🔒 do consolidado desaparece.
+// Kill-test coberto: sabotar isProtected (TYPE_HARDENING/hardenedRefKeys) na
+// rotate() torna estas verificações VERMELHAS.
+// ───────────────────────────────────────────────────────────────────────────
+{
+  const root = tmpRoot('hardrot');
+  // heurística com ts MUITO ANTIGO = candidata natural nº 1 da rotação; o registro
+  // de hardening não tem `ts` (ordena como 0) = candidato ainda mais antigo — ambos
+  // só sobrevivem se a PROTEÇÃO existir.
+  const hardSrc = {
+    id: 'HARD1',
+    ts: 1_600_000_000_000,
+    trigger: 'travessoes no texto final',
+    recommendation: 'nunca usar travessao; prefira virgula ou dois-pontos',
+    evidence: { count: 2 },
+    tier: 'normal',
+  };
+  append('p', hardSrc, { root });
+  mem.appendHardening('p', {
+    ref: mem.dedupKey(hardSrc),
+    target: {
+      workflowId: 'wf-x',
+      step: 's1',
+      assertion: { type: 'command_check', command: 'lexical-check.cjs', args: ['--max', '0'] },
+    },
+    approved_by: 'daniel',
+    timestamp: '2026-07-29T00:00:00Z',
+  }, { root });
+  // flood: > ROTATE_M entradas mais novas forçam rotação real
+  const total = ROTATE_M + 40;
+  for (let i = 0; i < total; i++) append('p', normalEntry(i), { root });
+  const rot = rotate('p', { root });
+  check('SF7.6 flood > M dispara rotação real (excedente arquivado)', rot.rotated > 0, `rotated=${rot.rotated}`);
+  const rawAfter = fs.readFileSync(memoryPaths('p', { root }).raw, 'utf8');
+  check('SF7.6 heurística-fonte ENDURECIDA sobrevive à rotação (nunca removida do log)',
+    rawAfter.includes('"id":"HARD1"'));
+  check('SF7.6 registro type:"hardening" sobrevive à rotação (marca de auditoria)',
+    rawAfter.includes('"type":"hardening"') && rawAfter.includes(`"ref":${JSON.stringify(mem.dedupKey(hardSrc))}`));
+  consolidate('p', { root });
+  const md = getConsolidatedForBrief('p', { root });
+  // SF11.4/ADR-022 (DF-SF11.4-1): o consolidado mantém a REFERÊNCIA AGREGADA; o detalhe
+  // íntegro (asserção, aprovador, momento) migrou para memory/learnings.hardened.md.
+  // A garantia de SF7.6 não muda — a trilha continua intacta pós-rotação, mudou ONDE.
+  const detail = fs.readFileSync(memoryPaths('p', { root }).hardenedDetail, 'utf8');
+  check('SF7.6 🔒 segue no consolidado PÓS-rotação (referência agregada intacta)',
+    md.includes('## Endurecidas (🔒 → enforcement)') &&
+    md.includes('veto command_check em s1 (1)') &&
+    md.includes('memory/learnings.hardened.md'));
+  check('SF11.4 detalhe íntegro da endurecida vive na trilha auditável PÓS-rotação',
+    detail.includes('🔒 **[travessoes no texto final]**') &&
+    detail.includes('endurecida → veto command_check em s1') &&
+    detail.includes('por daniel, 2026-07-29T00:00:00Z'));
+  check('SF11.4 o artefato INJETADO não carrega mais o texto da endurecida (só a referência)',
+    !md.includes('nunca usar travessao; prefira virgula ou dois-pontos'));
+  check('SF7.6 endurecida segue FORA do top-N ativo pós-rotação',
+    !md.split('## Endurecidas')[0].includes('**[travessoes no texto final]**'));
+  fs.rmSync(root, { recursive: true, force: true });
+}
+
+// ───────────────────────────────────────────────────────────────────────────
+// SF8.3 — ok_pattern FORA do ranking do top-N; log cru intacto; kill-test
+// automatizado (cópia sabotada do motor prova que a fixture exercita a exclusão).
+// Evidência de campo (triagem 2026-07-29): 26/122 entradas, slot #1 (x10/x9/x7).
+// ───────────────────────────────────────────────────────────────────────────
+{
+  const root = tmpRoot('okpat');
+  const T0 = 1_700_000_000_000;
+  // heurísticas REAIS (ocorrências menores que o ok_pattern — o caso de campo)
+  append('p', { id: 'real1a', ts: T0 + 1000, trigger: 'falha de veto no editorial', recommendation: 'sempre validar a contagem de secoes antes de entregar', evidence: { count: 2 } }, { root });
+  append('p', { id: 'real1b', ts: T0 + 2000, trigger: 'falha de veto no editorial', recommendation: 'sempre validar a contagem de secoes antes de entregar', evidence: { count: 1 } }, { root });
+  append('p', { id: 'real2', ts: T0 + 1500, trigger: 'timeout de api externa', recommendation: 'configurar retry com backoff exponencial', evidence: { count: 1 } }, { root });
+  // ok_pattern TIPADO na origem (buildOkLearning pós-SF8.3) ×10 — mesmo dedupKey,
+  // ts MAIS RECENTES: sem a exclusão, freq×recency o colocaria disparado em 1º.
+  for (let i = 0; i < 10; i++) {
+    append('p', { id: `ok-t${i}`, ts: T0 + 10_000 + i * 1000, type: mem.TYPE_OK_PATTERN, trigger: 'workflow "wf-x" completou sem bloqueio', recommendation: 'caminho seguido (3 etapa(s) verificadas em disco) é válido; repetir a sequência', evidence: { steps_done: 3 }, tier: 'normal' }, { root });
+  }
+  // ok_pattern LEGADO (entrada de campo pré-SF8.3: SEM `type`, assinatura do produtor) ×5
+  for (let i = 0; i < 5; i++) {
+    append('p', { id: `ok-l${i}`, ts: T0 + 30_000 + i * 1000, trigger: 'workflow "wf-y" completou sem bloqueio', recommendation: 'caminho seguido (2 etapa(s) verificadas em disco) é válido; repetir a sequência', evidence: { steps_done: 2 }, tier: 'normal' }, { root });
+  }
+  const rawPath = memoryPaths('p', { root }).raw;
+  const linesBefore = fs.readFileSync(rawPath, 'utf8').split('\n').filter(Boolean);
+  check('SF8.3 log cru recebeu TODAS as entradas (18: 3 reais + 10 tipadas + 5 legadas)', linesBefore.length === 18, `linhas=${linesBefore.length}`);
+  check('SF8.3 append preservou o campo type na linha crua', linesBefore.some((l) => l.includes('"type":"ok_pattern"')));
+
+  const res = consolidate('p', { root });
+  const md = getConsolidatedForBrief('p', { root });
+  const topSection = md.split('## Heurísticas (top-N)')[1] || '';
+  const firstBullet = (topSection.split('\n').find((l) => l.startsWith('- ')) || '');
+  check('SF8.3 consolidado SEM ok_pattern (tipado E legado) no top-N', !md.includes('completou sem bloqueio'));
+  check('SF8.3 slot #1 do top-N é heurística REAL (a que o ok_pattern ocupava)', firstBullet.includes('falha de veto no editorial'), firstBullet);
+  check('SF8.3 heurísticas reais presentes (nada além de ok_pattern excluído)', md.includes('timeout de api externa') && res.topNCount === 2);
+  check('SF8.3 okPatternCount reportado pela consolidação', res.okPatternCount === 15, `okPatternCount=${res.okPatternCount}`);
+  const linesAfter = fs.readFileSync(rawPath, 'utf8').split('\n').filter(Boolean);
+  check('SF8.3 log cru INTACTO após consolidação (18 linhas, byte-idênticas)', linesAfter.length === 18 && linesAfter.join('\n') === linesBefore.join('\n'));
+
+  // ── KILL-TEST AUTOMATIZADO (AC5): cópia SABOTADA do motor, exclusão desligada ──
+  // Prova que a fixture exercita o MECANISMO: sem a exclusão, a MESMA memória
+  // consolida com o ok_pattern de volta ao slot #1 (as asserções acima ficariam
+  // vermelhas). Sabota as DUAS vias (type e assinatura legada).
+  const srcPath = path.join(__dirname, 'pod-memory.cjs');
+  const src = fs.readFileSync(srcPath, 'utf8');
+  const sab1 = src.replace("const TYPE_OK_PATTERN = 'ok_pattern';", "const TYPE_OK_PATTERN = '__sabotado__';");
+  check('SF8.3 kill-test: sabotagem da via `type` aplicou', sab1 !== src);
+  const sab2 = sab1.replace('const OK_PATTERN_LEGACY_RE = /^workflow ".+" completou sem bloqueio$/;', 'const OK_PATTERN_LEGACY_RE = /$^/;');
+  check('SF8.3 kill-test: sabotagem da via legada aplicou', sab2 !== sab1);
+  const sabPath = path.join(root, 'pod-memory-sabotada.cjs');
+  fs.writeFileSync(sabPath, sab2);
+  const sabotada = require(sabPath);
+  // mesma memória, pod-cópia isolado (não sobrescreve o consolidado correto de 'p')
+  const p2mem = memoryPaths('p2', { root });
+  fs.mkdirSync(p2mem.dir, { recursive: true });
+  fs.copyFileSync(rawPath, p2mem.raw);
+  sabotada.consolidate('p2', { root });
+  const mdSab = fs.readFileSync(p2mem.consolidated, 'utf8');
+  const topSab = mdSab.split('## Heurísticas (top-N)')[1] || '';
+  const firstSab = (topSab.split('\n').find((l) => l.startsWith('- ')) || '');
+  check('SF8.3 kill-test: SEM a exclusão o ok_pattern VOLTA ao consolidado', mdSab.includes('completou sem bloqueio'));
+  check('SF8.3 kill-test: e retoma o slot #1 (x10) — a fixture ficaria vermelha', firstSab.includes('completou sem bloqueio') && firstSab.includes('(x10)'), firstSab);
+  fs.rmSync(root, { recursive: true, force: true });
+}
+
+// ───────────────────────────────────────────────────────────────────────────
+// SF10.10 / ADR-012 Adendo (DF-SF10.10-1) — UNIÃO DISCRIMINADA por `target.kind`.
+// AC1  alvo `knowledge` = {pod,kind,file,sha_before,sha_after}, SEM diff embutido;
+//      renderConsolidated ganha ramo com linha fixa e curta.
+// AC11 retrocompat: registro LEGADO sem `kind` continua tratado como `veto` —
+//      mesma validação byte a byte, mesma linha no consolidado, mesma demoção,
+//      sem migração e sem reescrita do log.
+// +    `kind` desconhecido FALHA LOUD (nunca degrada para o ramo `veto`).
+// ───────────────────────────────────────────────────────────────────────────
+{
+  const root = tmpRoot('kind');
+  const kSrc = {
+    id: 'K1', ts: 1_700_000_100_000,
+    trigger: 'slides sem riqueza grafica',
+    recommendation: 'usar blocos visuais com hierarquia tipografica',
+    evidence: { count: 2 }, tier: 'normal',
+  };
+  append('p', kSrc, { root });
+  const SHA_A = 'a'.repeat(64);
+  const SHA_B = 'b'.repeat(64);
+
+  // ── validação por RAMO ────────────────────────────────────────────────────
+  const throwsWith = (fn, re) => {
+    try { fn(); return false; } catch (e) { return re.test(e.message); }
+  };
+  check('SF10.10 kind desconhecido ⇒ THROW fail-loud (nunca cai no ramo veto)',
+    throwsWith(() => mem.appendHardening('p', {
+      ref: mem.dedupKey(kSrc), approved_by: 'daniel',
+      target: { kind: 'assertion_magica', file: 'x.md', sha_before: SHA_A, sha_after: SHA_B },
+    }, { root }), /kind desconhecido/));
+  check('SF10.10 kind "knowledge" sem `file` ⇒ THROW',
+    throwsWith(() => mem.appendHardening('p', {
+      ref: mem.dedupKey(kSrc), approved_by: 'daniel',
+      target: { kind: 'knowledge', sha_before: SHA_A, sha_after: SHA_B },
+    }, { root }), /exige `file`/));
+  check('SF10.10 kind "knowledge" com path traversal em `file` ⇒ THROW (marca de auditoria, não caminho)',
+    throwsWith(() => mem.appendHardening('p', {
+      ref: mem.dedupKey(kSrc), approved_by: 'daniel',
+      target: { kind: 'knowledge', file: '../../etc/passwd.md', sha_before: SHA_A, sha_after: SHA_B },
+    }, { root }), /nome SIMPLES sob knowledge\//));
+  check('SF10.10 kind "knowledge" com sha inválido ⇒ THROW (sha256 hex de 64)',
+    throwsWith(() => mem.appendHardening('p', {
+      ref: mem.dedupKey(kSrc), approved_by: 'daniel',
+      target: { kind: 'knowledge', file: 'slides-html.md', sha_before: 'nope', sha_after: SHA_B },
+    }, { root }), /sha256 hex de 64/));
+  check('SF10.10 kind "knowledge" sem approved_by ⇒ THROW (aprovação humana obrigatória nos DOIS alvos)',
+    throwsWith(() => mem.appendHardening('p', {
+      ref: mem.dedupKey(kSrc),
+      target: { kind: 'knowledge', file: 'slides-html.md', sha_before: SHA_A, sha_after: SHA_B },
+    }, { root }), /`approved_by` é obrigatório/));
+  check('SF10.10 ramo veto INALTERADO: target sem workflowId/step/assertion ⇒ THROW com a mensagem de ADR-012',
+    throwsWith(() => mem.appendHardening('p', {
+      ref: mem.dedupKey(kSrc), approved_by: 'daniel', target: { pod: 'p' },
+    }, { root }), /exige \{ workflowId, step, assertion:\{type,\.\.\.\} \}/));
+
+  // ── registro do alvo novo: forma FIXA, sem diff ───────────────────────────
+  const { record } = mem.appendHardening('p', {
+    ref: mem.dedupKey(kSrc),
+    target: { kind: 'knowledge', file: 'slides-html.md', sha_before: SHA_A, sha_after: SHA_B },
+    approved_by: 'daniel',
+    timestamp: '2026-08-01T00:00:00.000Z',
+  }, { root });
+  check('SF10.10 registro knowledge = {pod,kind,file,sha_before,sha_after} e NADA além (sem diff embutido)',
+    record.target.kind === 'knowledge' && record.target.pod === 'p' &&
+    record.target.file === 'slides-html.md' &&
+    record.target.sha_before === SHA_A && record.target.sha_after === SHA_B &&
+    Object.keys(record.target).sort().join(',') === 'file,kind,pod,sha_after,sha_before',
+    JSON.stringify(record.target));
+  check('SF10.10 registro knowledge não carrega `diff` nem trecho de prosa',
+    !JSON.stringify(record).includes('diff'));
+
+  const res = consolidate('p', { root });
+  const md = getConsolidatedForBrief('p', { root });
+  check('SF10.10 consolidate NÃO lança com registro kind:"knowledge" (o defeito de maior raio de dano)',
+    res.hardenedCount === 1);
+  // SF11.4/DF-SF11.4-1: a linha detalhada continua existindo, BYTE A BYTE — só mudou de
+  // artefato (saiu do injetado, foi para a trilha auditável). No consolidado fica a
+  // referência agregada com o alvo nomeado e a contagem.
+  const detailK = fs.readFileSync(memoryPaths('p', { root }).hardenedDetail, 'utf8');
+  check('SF10.10 linha 🔒 do alvo knowledge é fixa e curta (sem diff/trecho/contagem) — agora na trilha auditável',
+    detailK.includes('- 🔒 **[slides sem riqueza grafica]** usar blocos visuais com hierarquia tipografica — endurecida → knowledge/slides-html.md _(por daniel, 2026-08-01T00:00:00.000Z)_'),
+    detailK);
+  check('SF11.4 consolidado cita o alvo AGREGADO e a trilha, sem o texto da endurecida',
+    md.includes('knowledge/slides-html.md (1)') &&
+    md.includes('memory/learnings.hardened.md') &&
+    !md.includes('usar blocos visuais com hierarquia tipografica'),
+    md);
+  check('SF10.10 heurística com alvo knowledge DEMOVIDA do top-N ativo (mesma regra do alvo veto)',
+    !md.split('## Endurecidas')[0].includes('**[slides sem riqueza grafica]**'));
+
+  // ── QA/F3: fail-loud SIMÉTRICO — `knowledge` malformado LANÇA, como o `veto` ──
+  // Antes: um registro editado à mão sem `file` renderizava calado "knowledge/undefined"
+  // num artefato ORÇADO que entra no bundle do export, enquanto o ramo irmão lançava.
+  {
+    const r2 = tmpRoot('kindmal');
+    const src = {
+      id: 'M1', ts: 1_700_000_400_000, trigger: 'trigger malformado',
+      recommendation: 'recomendacao malformada', evidence: { count: 1 }, tier: 'normal',
+    };
+    append('p', src, { root: r2 });
+    const plant = (target) => {
+      fs.appendFileSync(memoryPaths('p', { root: r2 }).raw, `${JSON.stringify({
+        type: 'hardening', ref: mem.dedupKey(src), target, approved_by: 'daniel',
+        timestamp: '2026-08-01T00:00:00.000Z',
+      })}\n`);
+    };
+    const consolidateThrows = (re) => {
+      try { consolidate('p', { root: r2 }); return false; } catch (e) { return re.test(e.message); }
+    };
+    const rawBase = fs.readFileSync(memoryPaths('p', { root: r2 }).raw, 'utf8');
+    for (const [label, target] of [
+      ['sem `file`', { kind: 'knowledge' }],
+      ['`file` não-string', { kind: 'knowledge', file: 42 }],
+      ['`file` com traversal', { kind: 'knowledge', file: '../../../etc/passwd' }],
+    ]) {
+      fs.writeFileSync(memoryPaths('p', { root: r2 }).raw, rawBase);
+      plant(target);
+      check(`SF10.10/F3 kind "knowledge" ${label} ⇒ consolidate LANÇA (nunca renderiza calado)`,
+        consolidateThrows(/kind "knowledge" malformado/));
+    }
+    fs.writeFileSync(memoryPaths('p', { root: r2 }).raw, rawBase);
+    plant({ kind: 'knowledge', file: 'ok.md', sha_before: 'a'.repeat(64), sha_after: 'b'.repeat(64) });
+    check('SF10.10/F3 registro BEM-FORMADO segue renderizando normalmente (a simetria não quebra o caminho feliz)',
+      consolidate('p', { root: r2 }).hardenedCount === 1 &&
+      getConsolidatedForBrief('p', { root: r2 }).includes('knowledge/ok.md (1)') &&
+      fs.readFileSync(memoryPaths('p', { root: r2 }).hardenedDetail, 'utf8')
+        .includes('endurecida → knowledge/ok.md'));
+    fs.rmSync(r2, { recursive: true, force: true });
+  }
+
+  // ── AC11: registro LEGADO (sem `kind`) segue tratado como `veto` ───────────
+  const legacySrc = {
+    id: 'L1', ts: 1_700_000_200_000,
+    trigger: 'travessoes no texto final',
+    recommendation: 'nunca usar travessao; prefira virgula',
+    evidence: { count: 3 }, tier: 'normal',
+  };
+  append('p', legacySrc, { root });
+  // escrito DIRETO no log (sem passar por appendHardening), no formato pré-SF10.10
+  fs.appendFileSync(memoryPaths('p', { root }).raw, `${JSON.stringify({
+    type: 'hardening',
+    ref: mem.dedupKey(legacySrc),
+    target: { pod: 'p', workflowId: 'wf-x', step: 's1', assertion: { type: 'command_check', command: 'lexical-check.cjs' } },
+    approved_by: 'daniel',
+    timestamp: '2026-07-28T00:00:00.000Z',
+  })}\n`);
+  const res2 = consolidate('p', { root });
+  const md2 = getConsolidatedForBrief('p', { root });
+  const detail2 = fs.readFileSync(memoryPaths('p', { root }).hardenedDetail, 'utf8');
+  check('SF10.10/AC11 registro LEGADO sem `kind` é tratado como veto (linha idêntica à de SF7.6, na trilha auditável)',
+    detail2.includes('- 🔒 **[travessoes no texto final]** nunca usar travessao; prefira virgula — endurecida → veto command_check em s1 _(por daniel, 2026-07-28T00:00:00.000Z)_'),
+    detail2);
+  check('SF10.10/AC11 legado e alvo novo COEXISTEM no mesmo consolidado (sem migração do log)',
+    res2.hardenedCount === 2 && md2.includes('knowledge/slides-html.md (1)') &&
+    md2.includes('veto command_check em s1 (1)'));
+  check('SF10.10/AC11 legado também DEMOVIDO do top-N (comportamento de SF7.6 preservado)',
+    !md2.split('## Endurecidas')[0].includes('**[travessoes no texto final]**'));
+  check('SF10.10/AC11 log cru NÃO foi reescrito (registro legado permanece sem `kind`)',
+    fs.readFileSync(memoryPaths('p', { root }).raw, 'utf8')
+      .split('\n').filter(Boolean)
+      .some((l) => l.includes('"type":"hardening"') && l.includes('"workflowId"') && !l.includes('"kind"')));
+
+  // ── DF-SF10.10-3: listCandidates = diferença de conjuntos, READ-ONLY ──────
+  append('p', {
+    id: 'C1', ts: 1_700_000_300_000, trigger: 'api externa lenta',
+    recommendation: 'usar timeout explicito', evidence: { count: 1 }, tier: 'normal',
+  }, { root });
+  consolidate('p', { root });
+  const rawBytes = fs.readFileSync(memoryPaths('p', { root }).raw, 'utf8');
+  const mdBytes = fs.readFileSync(memoryPaths('p', { root }).consolidated, 'utf8');
+  const cands = mem.listCandidates('p', { root });
+  check('SF10.10/AC4 listCandidates lista SÓ as consolidadas sem registro de hardening',
+    cands.length === 1 && cands[0].trigger === 'api externa lenta',
+    JSON.stringify(cands));
+  check('SF10.10/AC4 candidato traz occurrences e o id da última entrada-fonte (colável em --learning)',
+    cands[0].occurrences === 1 && cands[0].last_id === 'C1' && cands[0].section === 'top-n');
+  check('SF10.10/AC4 listCandidates é READ-ONLY (log e consolidado byte-idênticos após a chamada)',
+    fs.readFileSync(memoryPaths('p', { root }).raw, 'utf8') === rawBytes &&
+    fs.readFileSync(memoryPaths('p', { root }).consolidated, 'utf8') === mdBytes);
+  check('SF10.10/AC4 listCandidates é determinística (2 chamadas ⇒ mesmo resultado)',
+    JSON.stringify(mem.listCandidates('p', { root })) === JSON.stringify(cands));
+  check('SF10.10/AC4 listCandidates NÃO classifica conteúdo vs mecanizável (sem oráculo — DF-SF10.10-3)',
+    !Object.keys(cands[0]).some((k) => /kind|tipo|class|mecaniz|conteudo|conteúdo/i.test(k)),
+    Object.keys(cands[0]).join(','));
+
+  fs.rmSync(root, { recursive: true, force: true });
+}
+
+// ═══════════════════════════════════════════════════════════════════════════
+// SF11.4b / ADR-023 — ADMISSÃO ÚNICA e ALVO DE CUSTO ACEITO PELO DONO
+//
+// O defeito que estas verificações fecham (ADR-023 §C2, medido no pod real): com os
+// DOIS canos ativos, 13 heurísticas ficavam fora do brief e o mecanismo anunciava 1.
+// Por isso NENHUMA verificação aqui aceita "evicted > 0": o oráculo é IGUALDADE EXATA
+// contra uma contagem INDEPENDENTE, lida do ARTEFATO renderizado (quais triggers
+// entraram no consolidado), nunca do próprio `evicted`. Um teste que só exigisse
+// "anunciou algo" passaria com o defeito dentro.
+// ═══════════════════════════════════════════════════════════════════════════
+
+/** Heurística de tamanho REAL (distribuição medida do hn-carousel: ~150-230 B). */
+function sizedEntry(i) {
+  return {
+    id: `S${i}`,
+    ts: 1_700_000_000_000 + i * 1000,
+    trigger: `situacao de campo numero ${i} do pod em producao`,
+    recommendation: `recomendacao verificavel numero ${i} com tamanho realista de heuristica ` +
+      'de campo produzida por rodada real do pod, com objeto e acao explicitos no texto',
+    evidence: { count: 1 },
+    tier: 'normal',
+  };
+}
+
+/** Contagem INDEPENDENTE: quantas do pool NÃO aparecem no artefato renderizado. */
+function absentFromArtifact(mdText, poolSize) {
+  let absent = 0;
+  for (let i = 0; i < poolSize; i++) {
+    if (!mdText.includes(`**[${sizedEntry(i).trigger}]**`)) absent += 1;
+  }
+  return absent;
+}
+
+function writePodSpec(root, pod, spec) {
+  const dir = path.join(root, pod);
+  fs.mkdirSync(dir, { recursive: true });
+  fs.writeFileSync(path.join(dir, 'pod-spec.json'), JSON.stringify(spec, null, 2));
+}
+
+// ── AC2 — réplica do C2: pool 42, os DOIS cortes ativos, o número BATE ──────
+{
+  const root = tmpRoot('sf114b-c2');
+  const POOL = 42;
+  for (let i = 0; i < POOL; i++) append('c2', sizedEntry(i), { root });
+  const r = consolidate('c2', { root });
+  const md = fs.readFileSync(memoryPaths('c2', { root }).consolidated, 'utf8');
+  const absent = absentFromArtifact(md, POOL);
+  const byTopN = r.evicted.filter((e) => e.reason === 'top_n').length;
+  const byBudget = r.evicted.filter((e) => e.reason === 'budget').length;
+
+  check('SF11.4b/AC2 os DOIS cortes estão ativos na fixture (senão o teste não exercita C2)',
+    byTopN > 0 && byBudget > 0, `top_n=${byTopN} budget=${byBudget} ranked=${r.topNCount}`);
+  check(`SF11.4b/AC2 evicted.length (${r.evicted.length}) == ausentes do consolidado (${absent}) — IGUALDADE EXATA, contagem independente do artefato`,
+    r.evicted.length === absent, `ranked=${r.topNCount} pool=${POOL}`);
+  check('SF11.4b/AC2 conservação: ranked + evicted == pool ativo (nada fora da contabilidade)',
+    r.topNCount + r.evicted.length === POOL, `${r.topNCount}+${r.evicted.length} vs ${POOL}`);
+  check('SF11.4b/AC2 pré-story o número seria SUB-RELATADO: só o cano do orçamento anunciaria',
+    byBudget < r.evicted.length, `anunciaria ${byBudget} com ${r.evicted.length} fora`);
+  check('SF11.4b/AC1 toda não-admissão tem reason ∈ {top_n, budget} e trigger/recommendation/score',
+    r.evicted.every((e) => (e.reason === 'top_n' || e.reason === 'budget') &&
+      typeof e.trigger === 'string' && typeof e.recommendation === 'string' && typeof e.score === 'number'),
+    JSON.stringify(r.evicted[0]));
+  check('SF11.4b/AC1 nenhuma evicted está no artefato e nenhuma ranked está fora dele (reason descreve o REAL)',
+    r.evicted.every((e) => !md.includes(`**[${e.trigger}]**`)));
+  // invariante de ORDEM entre as duas vias: o corte por custo tira a CAUDA de `ranked`
+  // (scores mais altos que os do excedente do teto de atenção). Se um dia isso inverter,
+  // a admissão deixou de ser única — passou a haver duas ordenações.
+  check('SF11.4b/AC1 ordem: todo score cortado por custo ≥ todo score cortado por atenção',
+    Math.min(...r.evicted.filter((e) => e.reason === 'budget').map((e) => e.score)) >=
+    Math.max(...r.evicted.filter((e) => e.reason === 'top_n').map((e) => e.score)),
+    JSON.stringify(r.evicted.map((e) => [e.reason, e.score])));
+  check('SF11.4b/AC2 substância preservada: TODA evicted permanece no log cru (poda ≠ deleção)',
+    (() => { const raw = fs.readFileSync(memoryPaths('c2', { root }).raw, 'utf8'); return r.evicted.every((e) => raw.includes(e.trigger)); })());
+  const ledger = mem.formatEvictionLedger('c2', r);
+  check(`SF11.4b/AC4 ledger reporta o TOTAL (${r.evicted.length}) antes da quebra, e a quebra soma o total`,
+    ledger.startsWith(`[memory] AVISO: ${r.evicted.length} heurística(s) NÃO entraram`) &&
+    ledger.includes(`${byTopN} por teto de atenção TOP_N=${TOP_N}`) &&
+    ledger.includes(`${byBudget} por teto de custo ${TOKEN_BUDGET} tok`), ledger);
+  check('SF11.4b/AC4 ledger declara a unidade do custo (ceil(bytes UTF-8/4)) — lição UTF-16×UTF-8 da SF11.2',
+    /tokens = ceil\(bytes UTF-8 \/ 4\)/.test(ledger), ledger);
+  fs.rmSync(root, { recursive: true, force: true });
+}
+
+// ── AC3 — needsCuration liga TAMBÉM pela via do teto de atenção ─────────────
+{
+  const root = tmpRoot('sf114b-topn');
+  // entradas CURTAS: o pool passa de TOP_N sem chegar perto do orçamento — o cenário em
+  // que, pré-story, 6 heurísticas sumiam com needsCuration=false e folga de teto ociosa.
+  for (let i = 0; i < 36; i++) {
+    append('t', { id: `C${i}`, ts: 1_700_000_000_000 + i * 1000, trigger: `gatilho curto ${i}`, recommendation: `faca ${i}`, evidence: { count: 1 }, tier: 'normal' }, { root });
+  }
+  const r = consolidate('t', { root });
+  check('SF11.4b/AC3 needsCuration=true por TOP_N puro (pré-story era false — ADR-023 §C1)',
+    r.needsCuration === true && r.evicted.length === 6 &&
+    r.evicted.every((e) => e.reason === 'top_n'), JSON.stringify({ n: r.needsCuration, ev: r.evicted.length }));
+  check('SF11.4b/AC3 e a folga de orçamento ficava OCIOSA enquanto isso (corte não era de custo)',
+    r.tokens < TOKEN_BUDGET, `tokens=${r.tokens} teto=${TOKEN_BUDGET}`);
+  fs.rmSync(root, { recursive: true, force: true });
+}
+
+// ── AC6/AC9 — memoryCost efetivo = min(alvo, TOKEN_BUDGET); ausência inalterada
+{
+  const root = tmpRoot('sf114b-alvo');
+  const POOL = 42;
+  for (let i = 0; i < POOL; i++) append('alvo', sizedEntry(i), { root });
+  const semAlvo = consolidate('alvo', { root });
+  check('SF11.4b/AC9 pod SEM memoryCost: teto efetivo = TOKEN_BUDGET (opt-in, ausência não é defeito)',
+    semAlvo.tokenBudget === TOKEN_BUDGET && semAlvo.memoryCost === null, JSON.stringify({ b: semAlvo.tokenBudget, m: semAlvo.memoryCost }));
+
+  writePodSpec(root, 'alvo', { pod: 'alvo', memoryCost: { artifactTokens: 900, perRunTokens: 2700, steps: 3, acceptedBy: 'daniel', acceptedAt: '2026-08-03' } });
+  const comAlvo = consolidate('alvo', { root });
+  const mdAlvo = fs.readFileSync(memoryPaths('alvo', { root }).consolidated, 'utf8');
+  check('SF11.4b/AC6 teto efetivo = min(900, 1500) = 900 — MEDIDO por execução, não lido do JSON',
+    comAlvo.tokenBudget === 900 && comAlvo.memoryCost.artifactTokens === 900, JSON.stringify(comAlvo.tokenBudget));
+  check(`SF11.4b/AC6 o artefato real respeita o alvo (${comAlvo.tokens} ≤ 900) e é MENOR que sem alvo (${semAlvo.tokens})`,
+    comAlvo.tokens <= 900 && comAlvo.tokens < semAlvo.tokens);
+  check('SF11.4b/AC6 apertar o alvo aumenta o que sai — e TODO o aumento tem causa registrada',
+    comAlvo.evicted.length > semAlvo.evicted.length &&
+    comAlvo.topNCount + comAlvo.evicted.length === POOL &&
+    comAlvo.evicted.length === absentFromArtifact(mdAlvo, POOL),
+    `${comAlvo.evicted.length} vs ${semAlvo.evicted.length}`);
+  const ledgerAlvo = mem.formatEvictionLedger('alvo', comAlvo);
+  check('SF11.4b/AC4 com alvo declarado o ledger nomeia "alvo de custo" e o custo/rodada (steps do manifesto)',
+    /por alvo de custo 900 tok/.test(ledgerAlvo) && /× 3 etapa\(s\) =/.test(ledgerAlvo), ledgerAlvo);
+  fs.rmSync(root, { recursive: true, force: true });
+}
+
+// ── AC8 — fail-loud de forma: malformado LANÇA, nunca degrada para 1.500 ────
+{
+  const root = tmpRoot('sf114b-failloud');
+  for (let i = 0; i < 5; i++) append('f', sizedEntry(i), { root });
+  const malformados = [
+    ['artifactTokens string', { artifactTokens: '900', acceptedBy: 'daniel' }],
+    ['artifactTokens zero', { artifactTokens: 0, acceptedBy: 'daniel' }],
+    ['artifactTokens negativo', { artifactTokens: -5, acceptedBy: 'daniel' }],
+    ['artifactTokens fracionário', { artifactTokens: 900.5, acceptedBy: 'daniel' }],
+    ['artifactTokens acima do teto do framework', { artifactTokens: 1501, acceptedBy: 'daniel' }],
+    ['artifactTokens ausente', { acceptedBy: 'daniel' }],
+    ['null como valor', { artifactTokens: null, acceptedBy: 'daniel' }],
+    ['memoryCost não-objeto', 900],
+    ['memoryCost array', [900]],
+    ['acceptedBy ausente (alvo sem dono = limiar inventado, DF4-5)', { artifactTokens: 900 }],
+    ['acceptedBy vazio', { artifactTokens: 900, acceptedBy: '   ' }],
+    ['steps inválido', { artifactTokens: 900, acceptedBy: 'daniel', steps: 0 }],
+  ];
+  for (const [label, memoryCost] of malformados) {
+    writePodSpec(root, 'f', { pod: 'f', memoryCost });
+    let threw = false; let msg = '';
+    try { consolidate('f', { root }); } catch (e) { threw = true; msg = e.message; }
+    check(`SF11.4b/AC8 fail-loud: ${label} ⇒ LANÇA com mensagem acionável (nunca cai para ${TOKEN_BUDGET})`,
+      threw && /malformado/.test(msg) && /pod-spec\.json/.test(msg) && /ADR-023/.test(msg), msg.slice(0, 200));
+  }
+  // JSON quebrado no manifesto também é ruidoso — nunca silencioso
+  fs.writeFileSync(path.join(root, 'f', 'pod-spec.json'), '{ "pod": "f", ');
+  let threwJson = false;
+  try { consolidate('f', { root }); } catch { threwJson = true; }
+  check('SF11.4b/AC8 pod-spec.json ilegível como JSON ⇒ LANÇA (manifesto corrompido não silencia a trava)', threwJson);
+
+  // ── DF-SF11.4b-7 (Emenda 1 ao ADR-023) — "tolerante à ausência" tem UMA só forma ──
+  // O par abaixo é UM contrato, não dois casos soltos: manifesto ILEGÍVEL (aqui o path
+  // virou diretório ⇒ EISDIR, o vetor 30/30 do harness do pc-qa) é alvo DESCONHECIDO e
+  // LANÇA; manifesto INEXISTENTE (ENOENT) continua sendo ausência legítima e devolve o
+  // teto do framework sem ruído. Se só o primeiro fosse testado, o fix poderia ter
+  // matado o opt-in dos 13 pods sem manifesto e a suíte não veria.
+  const specPathF = path.join(root, 'f', 'pod-spec.json');
+  fs.rmSync(specPathF, { force: true });
+  fs.mkdirSync(specPathF, { recursive: true });
+  let threwDir = false; let msgDir = '';
+  try { consolidate('f', { root }); } catch (e) { threwDir = true; msgDir = e.message; }
+  check('SF11.4b/DF-7 pod-spec.json ILEGÍVEL (path é diretório ⇒ EISDIR) ⇒ LANÇA citando path e errno — NÃO degrada para 1.500',
+    threwDir && /EISDIR/.test(msgDir) && /pod-spec\.json/.test(msgDir) && /ADR-023 DF-SF11\.4b-7/.test(msgDir), msgDir.slice(0, 240));
+  check('SF11.4b/DF-7 e é falha de LEITURA, classe própria — não se disfarça de parse nem de "malformado"',
+    threwDir && /não pôde ser lido/.test(msgDir) && !/malformado/.test(msgDir), msgDir.slice(0, 160));
+  fs.rmSync(specPathF, { recursive: true, force: true });
+
+  let semSpec = null; let threwAbsent = false;
+  try { semSpec = consolidate('f', { root }); } catch { threwAbsent = true; }
+  check('SF11.4b/DF-7 pod-spec.json INEXISTENTE (ENOENT) segue sendo ausência legítima: teto 1.500, sem lançar (opt-in intacto)',
+    !threwAbsent && semSpec && semSpec.memoryCost === null && semSpec.tokenBudget === TOKEN_BUDGET,
+    JSON.stringify({ threwAbsent, mc: semSpec && semSpec.memoryCost, b: semSpec && semSpec.tokenBudget }));
+  check('SF11.4b/DF-7 readMemoryCost direto: manifesto ausente ⇒ null (a única forma de ausência)',
+    mem.readMemoryCost('f', { root }) === null);
+
+  // e o caminho feliz segue funcionando (a rigidez não quebra quem declara certo)
+  writePodSpec(root, 'f', { pod: 'f', memoryCost: { artifactTokens: 1500, acceptedBy: 'daniel' } });
+  const okRes = consolidate('f', { root });
+  check('SF11.4b/AC8 alvo bem-formado no limite (=TOKEN_BUDGET) é aceito', okRes.tokenBudget === 1500);
+  fs.rmSync(root, { recursive: true, force: true });
+}
+
+// ── AC9 — os pods do repositório sem memoryCost seguem no teto de hoje ──────
+{
+  const repoPods = path.join(__dirname, '..', 'template', 'pods');
+  if (fs.existsSync(repoPods)) {
+    const semCampo = fs.readdirSync(repoPods, { withFileTypes: true })
+      .filter((d) => d.isDirectory())
+      .filter((d) => fs.existsSync(path.join(repoPods, d.name, 'pod-spec.json')))
+      .filter((d) => {
+        const spec = JSON.parse(fs.readFileSync(path.join(repoPods, d.name, 'pod-spec.json'), 'utf8'));
+        return spec.memoryCost == null;
+      })
+      .map((d) => d.name);
+    const comCampo = fs.readdirSync(repoPods, { withFileTypes: true })
+      .filter((d) => d.isDirectory() && fs.existsSync(path.join(repoPods, d.name, 'pod-spec.json')))
+      .filter((d) => JSON.parse(fs.readFileSync(path.join(repoPods, d.name, 'pod-spec.json'), 'utf8')).memoryCost != null);
+    check(`SF11.4b/AC9 nenhum pod-template ganhou memoryCost nesta story (opt-in por pod) — ${semCampo.length} sem campo`,
+      comCampo.length === 0, comCampo.map((d) => d.name).join(','));
+    for (const p of semCampo) {
+      check(`SF11.4b/AC9 ${p}: teto efetivo permanece ${TOKEN_BUDGET} (comportamento de hoje, inalterado)`,
+        mem.effectiveTokenBudget(p, { podDir: path.join(repoPods, p) }).tokens === TOKEN_BUDGET);
+    }
+  }
+}
+
+// ── AC10 — contrato preservado: assinatura e getConsolidatedForBrief ────────
+{
+  const root = tmpRoot('sf114b-contrato');
+  for (let i = 0; i < 42; i++) append('k', sizedEntry(i), { root });
+  const r = consolidate('k', { root });
+  check('SF11.4b/AC10 consolidate() mantém a assinatura (pod, opts com default) e todos os campos de SF11.4',
+    consolidate.length === 1 &&
+    ['pinnedCount', 'topNCount', 'tokens', 'needsCuration', 'overflow', 'evicted', 'conflicts', 'hardenedCount', 'okPatternCount']
+      .every((k) => k in r), `arity=${consolidate.length} keys=${Object.keys(r).join(',')}`);
+  check('SF11.4b/AC10 getConsolidatedForBrief continua lendo UM arquivo (o consolidado), sem novo parâmetro',
+    getConsolidatedForBrief.length === 1 &&
+    getConsolidatedForBrief('k', { root }) === fs.readFileSync(memoryPaths('k', { root }).consolidated, 'utf8'));
+  fs.rmSync(root, { recursive: true, force: true });
+}
+
+// ───────────────────────────────────────────────────────────────────────────
+// Relatório.
+// ───────────────────────────────────────────────────────────────────────────
+console.log('POWER CLAUDE — pod-memory (motor de memória do pod, SF2.1)\n');
+const failures = results.filter((r) => !r.ok);
+for (const r of results) {
+  console.log(`[${r.ok ? 'OK   ' : 'FALHA'}] ${r.label}${r.ok ? '' : ` — ${r.detail}`}`);
+}
+console.log(`\n${results.length - failures.length}/${results.length} verificações passaram.`);
+if (failures.length > 0) {
+  console.error('\nSUÍTE FALHOU.');
+  process.exit(1);
+}
+process.exit(0);