@daniellins/power-claude 0.16.3

package/scripts/pod-memory-note.test.cjs

@@ -0,0 +1,452 @@
+#!/usr/bin/env node
+'use strict';
+/**
+ * pod-memory-note.test.cjs — Story SF11.5 / ADR-020 §Revisão 3 (`DF-SF10.21-15..19`).
+ *
+ * O QUE ESTA SUÍTE PROVA (por EXECUÇÃO real do script, nunca por leitura de código):
+ *   AC1  O invocador existe, exporta função pura testável, e NÃO importa o motor
+ *        (`pc-run-pod.cjs`); quando o SHA-base está disponível, o `git diff` do motor
+ *        é conferido aqui também.
+ *   AC2  A mensagem NUNCA viaja por argv: o MESMO texto (aspas duplas, aspas simples,
+ *        acentos e quebra de linha REAL) chega byte a byte ao log cru pelos dois canais
+ *        legítimos (`--file` e stdin) — e toda flag de texto livre é ERRO DE USO.
+ *   AC4  `attributed_by` é a string literal "human" (ENUM), NUNCA nome próprio, NUNCA
+ *        null. Kill-test junto: omitir o campo cairia em `null` em SILÊNCIO.
+ *   AC5  `approve` com comentário → UMA linha nova, correta; `approve` sem comentário →
+ *        ZERO linhas novas (prova por CONTAGEM antes/depois, não por parsing).
+ *   AC6  `revise` captura igual — o caso de maior valor (hoje o motor não grava nada).
+ *   AC7  Dois vereditos na MESMA etapa produzem `trigger`s distinguíveis.
+ *   AC8  Comentário que força poda ANUNCIA o que saiu, medido contra o teto REAL do
+ *        `hn-carousel` (900 tok, `acceptedBy: "Alexa Exemplo"`), com contraprova de que
+ *        sem estouro nenhum aviso é impresso.
+ *
+ * Node >= 18, sem dependências externas.
+ */
+
+const fs = require('node:fs');
+const os = require('node:os');
+const path = require('node:path');
+const { spawnSync } = require('node:child_process');
+
+const podMemory = require('./pod-memory.cjs');
+const note = require('./pod-memory-note.cjs');
+
+const SCRIPT = path.join(__dirname, 'pod-memory-note.cjs');
+const REPO_ROOT = path.resolve(__dirname, '..');
+// SHA de origem da branch desta story (Dev Notes da SF11.5). Conferido só quando o objeto
+// existe no clone — o resultado do teste nunca depende do histórico local estar completo.
+const BASE_SHA = '27e1546';
+
+const failures = [];
+let passed = 0;
+function ok(label, cond, extra) {
+  if (cond) { passed += 1; console.log(`[OK   ] ${label}`); return; }
+  failures.push(label);
+  console.log(`[FALHA] ${label}${extra ? ` — ${String(extra).slice(0, 600)}` : ''}`);
+}
+
+// ── Fixtures ────────────────────────────────────────────────────────────────
+function tmpPod(label, { podSpec } = {}) {
+  const tmp = fs.mkdtempSync(path.join(os.tmpdir(), `sf11.5-${label}-`));
+  const podDir = path.join(tmp, 'hn-carousel');
+  fs.mkdirSync(path.join(podDir, 'memory'), { recursive: true });
+  fs.mkdirSync(path.join(podDir, 'workflows'), { recursive: true });
+  if (podSpec) fs.writeFileSync(path.join(podDir, 'pod-spec.json'), JSON.stringify(podSpec, null, 2));
+  const statePath = path.join(tmp, 'state.json');
+  const state = {
+    pod: 'hn-carousel',
+    workflow: 'wf-hn-carousel',
+    run_id: '2026-08-03T10-00-00Z-sf115',
+    mode: 'interactive',
+    steps: {
+      digest: { status: 'done' },
+      visuals: { status: 'done' },
+      assembly: { status: 'awaiting_approval' },
+    },
+    updated_at: new Date().toISOString(),
+  };
+  fs.writeFileSync(statePath, JSON.stringify(state, null, 2));
+  // `podRootFor` é derivação PURA de path: o wf não precisa existir para o teste do
+  // invocador (ele não valida workflow — zero acoplamento ao motor).
+  const wfPath = path.join(podDir, 'workflows', 'wf-hn-carousel.yaml');
+  return { tmp, podDir, statePath, wfPath, state };
+}
+
+/** `memoryCost` REAL do hn-carousel (`second-brain/pods/hn-carousel/pod-spec.json`, SF11.4b/ADR-023). */
+const REAL_MEMORY_COST = {
+  artifactTokens: 900,
+  perRunTokens: 2700,
+  steps: 3,
+  acceptedBy: 'Alexa Exemplo',
+  acceptedAt: '2026-08-03',
+};
+
+function rawPath(podDir) {
+  return podMemory.memoryPaths('hn-carousel', { podDir }).raw;
+}
+function countLines(podDir) {
+  const p = rawPath(podDir);
+  if (!fs.existsSync(p)) return 0;
+  return fs.readFileSync(p, 'utf8').split('\n').filter((l) => l.trim()).length;
+}
+function readRecords(podDir) {
+  const p = rawPath(podDir);
+  if (!fs.existsSync(p)) return [];
+  return fs.readFileSync(p, 'utf8').split('\n').filter((l) => l.trim()).map((l) => JSON.parse(l));
+}
+
+function runCli(args, { input } = {}) {
+  return spawnSync(process.execPath, [SCRIPT, ...args], {
+    encoding: 'utf8',
+    cwd: REPO_ROOT,
+    input: input === undefined ? '' : input, // stdin SEMPRE pipe (nunca TTY) no teste
+  });
+}
+
+// Texto do dono: aspas duplas, aspas simples, acentos e QUEBRA DE LINHA real — o conteúdo
+// que quebraria num heredoc/echo e que argv exporia em `ps`.
+const OWNER_TEXT =
+  'A capa está "fraca": o título some no fundo e não dá pra ler no feed.\n' +
+  "Refaça com contraste alto e mantenha a assinatura do Daniel no CTA (regra que já valeu na rodada passada).";
+
+// ═══════════════════════════════════════════════════════════════════════════
+// AC1 — invocador fino, função pura, motor intocado
+// ═══════════════════════════════════════════════════════════════════════════
+console.log('--- AC1/DF-SF10.21-15: invocador fino, sem acoplamento ao motor ---');
+{
+  ok('exporta função PURA testável (buildNoteEntry), não só CLI',
+    typeof note.buildNoteEntry === 'function' && typeof note.noteCheckpointComment === 'function');
+
+  const src = fs.readFileSync(SCRIPT, 'utf8');
+  const requires = [...src.matchAll(/require\(\s*['"]([^'"]+)['"]\s*\)/g)].map((m) => m[1]);
+  ok(`NÃO importa pc-run-pod.cjs (requires: ${requires.join(', ')})`,
+    !requires.some((r) => r.includes('pc-run-pod')));
+
+  // Função pura: monta a entrada sem tocar em disco.
+  const e = note.buildNoteEntry({
+    step: 'assembly', verdict: 'approve', message: OWNER_TEXT, runId: 'run-1',
+  });
+  ok('buildNoteEntry é pura (sem I/O) e devolve o contrato de append',
+    e.trigger && e.recommendation === OWNER_TEXT && e.tier === 'normal' && e.source_run_id === 'run-1');
+
+  // ── EMENDA SF11.10/ADR-024 `DF-SF11.10-10` ────────────────────────────────
+  // Este bloco afirmava `git diff <BASE_SHA> -- scripts/pc-run-pod.cjs` VAZIO. Isso era
+  // verdade sobre o diff DAQUELA story e virou, sem querer, uma afirmação sobre TODA story
+  // futura ("o motor nunca muda") — o que a SF11.5 nunca provou nem podia provar. A SF11.10
+  // tocou o motor conscientemente (gate de texto condicionado ao ritmo: `isBlocking(step,
+  // mode)` + 2 chamadores + conjunto fechado de `mode` + `capabilityGaps`), com justificativa
+  // PRÓPRIA e enumeração exaustiva no ADR-024 — não herdada da permissão da SF11.2.
+  //
+  // O que a SF11.5 de fato protegia, e continua protegido aqui: o mecanismo de comentário de
+  // checkpoint é INVOCADOR FINO — nem ele conhece o motor (asserção acima), nem o motor
+  // conhece ele. A checagem passa a ser exatamente essa propriedade, que é um invariante VIVO
+  // (falseável a qualquer momento), em vez de um congelamento de arquivo que qualquer evolução
+  // legítima do motor derruba. Ganha-se em verdade; perde-se a auditabilidade barata do "diff
+  // vazio" — perda declarada no `DF-SF11.10-10`, cujo contrapeso é a enumeração no ADR.
+  const ACOPLAMENTO = ['pod-memory-note', 'noteCheckpointComment', 'buildNoteEntry', 'checkpoint-note'];
+  const motorSrc = fs.readFileSync(path.join(REPO_ROOT, 'scripts', 'pc-run-pod.cjs'), 'utf8');
+  const vazados = ACOPLAMENTO.filter((n) => motorSrc.includes(n));
+  ok('o MOTOR não conhece o invocador de comentário (zero acoplamento na volta) — SF11.5 preservada sob ADR-024',
+    vazados.length === 0, `vazou no motor: ${vazados.join(', ')}`);
+
+  // E o diff do motor desde o SHA-base, quando existe no clone, não pode ter INTRODUZIDO
+  // acoplamento nenhum — a evolução do motor é permitida, contaminá-lo com o mecanismo não.
+  const has = spawnSync('git', ['rev-parse', '--verify', `${BASE_SHA}^{commit}`], { cwd: REPO_ROOT, encoding: 'utf8' });
+  if (has.status === 0) {
+    const d = spawnSync('git', ['diff', BASE_SHA, '--', 'scripts/pc-run-pod.cjs'], { cwd: REPO_ROOT, encoding: 'utf8' });
+    const sujo = ACOPLAMENTO.filter((n) => d.stdout.includes(n));
+    ok(`git diff ${BASE_SHA} -- scripts/pc-run-pod.cjs não introduz acoplamento ao invocador`,
+      d.status === 0 && sujo.length === 0, `citações no diff: ${sujo.join(', ')}`);
+  } else {
+    console.log(`[SKIP ] git diff ${BASE_SHA} -- scripts/pc-run-pod.cjs (SHA-base ausente neste clone; conferido no Dev Agent Record)`);
+  }
+}
+
+// ═══════════════════════════════════════════════════════════════════════════
+// AC2 — a mensagem NUNCA vai por argv: --file e stdin, byte a byte
+// ═══════════════════════════════════════════════════════════════════════════
+console.log('\n--- AC2/DF-SF10.21-15: mensagem por arquivo e por stdin, verbatim ---');
+{
+  // (a) --file — com \n final no arquivo (artefato de escrita), que NÃO pode virar conteúdo
+  const A = tmpPod('file');
+  const msgFile = path.join(A.tmp, 'comentario.txt');
+  fs.writeFileSync(msgFile, `${OWNER_TEXT}\n`);
+  const rA = runCli(['--state', A.statePath, '--workflow-file', A.wfPath,
+    '--step', 'assembly', '--verdict', 'approve', '--file', msgFile]);
+  ok(`--file: exit 0 (stderr: ${rA.stderr.trim().slice(0, 120)})`, rA.status === 0, rA.stderr);
+  const recA = readRecords(A.podDir)[0];
+  ok('--file: recommendation bate BYTE A BYTE com o texto do dono (aspas + \\n reais)',
+    recA && Buffer.compare(Buffer.from(recA.recommendation, 'utf8'), Buffer.from(OWNER_TEXT, 'utf8')) === 0,
+    JSON.stringify(recA && recA.recommendation));
+  ok('--file: a quebra de linha real sobreviveu (não virou espaço nem \\\\n literal)',
+    recA && recA.recommendation.includes('\n') && recA.recommendation.split('\n').length === 2);
+  ok('--file: as aspas duplas sobreviveram íntegras',
+    recA && recA.recommendation.includes('"fraca"'));
+
+  // (b) stdin — MESMO texto, canal diferente
+  const B = tmpPod('stdin');
+  const rB = runCli(['--state', B.statePath, '--workflow-file', B.wfPath,
+    '--step', 'assembly', '--verdict', 'approve'], { input: OWNER_TEXT });
+  ok(`stdin: exit 0 (stderr: ${rB.stderr.trim().slice(0, 120)})`, rB.status === 0, rB.stderr);
+  const recB = readRecords(B.podDir)[0];
+  ok('stdin: recommendation bate BYTE A BYTE com o texto do dono',
+    recB && Buffer.compare(Buffer.from(recB.recommendation, 'utf8'), Buffer.from(OWNER_TEXT, 'utf8')) === 0,
+    JSON.stringify(recB && recB.recommendation));
+  ok('os DOIS canais produzem a MESMA recommendation (o canal não altera o conteúdo)',
+    recA && recB && recA.recommendation === recB.recommendation);
+
+  // (c) sem --file e sem stdin (input vazio) → ERRO DE USO, nunca entrada fabricada
+  const C = tmpPod('vazio');
+  const before = countLines(C.podDir);
+  const rC = runCli(['--state', C.statePath, '--workflow-file', C.wfPath,
+    '--step', 'assembly', '--verdict', 'approve'], { input: '' });
+  ok(`sem --file e sem stdin: exit 2 (uso), não 0 — recebido ${rC.status}`, rC.status === 2, rC.stderr);
+  ok('sem --file e sem stdin: ZERO linhas gravadas (nada fabricado)', countLines(C.podDir) === before);
+  ok('a mensagem de erro é acionável (diz o que fazer)',
+    /--file/.test(rC.stderr) && /(vazia|stdin)/i.test(rC.stderr), rC.stderr);
+
+  // (d) flags de texto livre são RECUSADAS por nome (não aceitas-e-ignoradas)
+  const D = tmpPod('argv');
+  for (const flag of ['--message', '--comment', '--note', '-m']) {
+    const r = runCli(['--state', D.statePath, '--workflow-file', D.wfPath,
+      '--step', 'assembly', '--verdict', 'approve', flag, OWNER_TEXT]);
+    ok(`"${flag}" é ERRO DE USO explícito (exit 2) e nada é gravado`,
+      r.status === 2 && countLines(D.podDir) === 0 && /argv/i.test(r.stderr), `${r.status} ${r.stderr}`);
+  }
+  // (e) posicional/flag desconhecida também não é porta de entrada de texto
+  const rPos = runCli(['--state', D.statePath, '--workflow-file', D.wfPath,
+    '--step', 'assembly', '--verdict', 'approve', OWNER_TEXT]);
+  ok('texto posicional é recusado (exit 2), não tratado como mensagem',
+    rPos.status === 2 && countLines(D.podDir) === 0, `${rPos.status} ${rPos.stderr}`);
+}
+
+// ═══════════════════════════════════════════════════════════════════════════
+// AC4 — attributed_by === "human" (ENUM), nunca nome próprio, nunca null
+// ═══════════════════════════════════════════════════════════════════════════
+console.log('\n--- AC4/DF-SF10.21-16: attributed_by é o ENUM "human" ---');
+{
+  const F = tmpPod('attr', { podSpec: { pod: 'hn-carousel', memoryCost: REAL_MEMORY_COST } });
+  const msgFile = path.join(F.tmp, 'c.txt');
+  fs.writeFileSync(msgFile, 'Aprovado: a capa ficou legível no feed e o CTA fecha com autoridade.');
+  const r = runCli(['--state', F.statePath, '--workflow-file', F.wfPath,
+    '--step', 'assembly', '--verdict', 'approve', '--file', msgFile]);
+  ok(`grava com pod-spec real presente (exit 0) — stderr: ${r.stderr.trim().slice(0, 120)}`, r.status === 0, r.stderr);
+  const rec = readRecords(F.podDir)[0];
+  ok('attributed_by === "human" (comparação de string EXATA)', rec && rec.attributed_by === 'human',
+    JSON.stringify(rec && rec.attributed_by));
+  ok('attributed_by NÃO é null (o default silencioso de tier normal não pegou)',
+    rec && rec.attributed_by !== null && rec.attributed_by !== undefined);
+
+  // CAMPO DIFERENTE, PROPÓSITO DIFERENTE: `attributed_by` (enum de proveniência) NÃO é
+  // `pod-spec.json → memoryCost.acceptedBy` (atribuição NOMINAL do dono, SF11.4b).
+  const spec = JSON.parse(fs.readFileSync(path.join(F.podDir, 'pod-spec.json'), 'utf8'));
+  ok('acceptedBy nominal é "Alexa Exemplo" e NÃO vaza para attributed_by',
+    spec.memoryCost.acceptedBy === 'Alexa Exemplo' && rec.attributed_by !== spec.memoryCost.acceptedBy);
+  ok('attributed_by pertence ao ENUM fechado VALID_ATTRIBUTION do pod-memory',
+    ['human', 'deterministic_rule'].includes(rec.attributed_by));
+
+  // KILL-TEST do footgun: OMITIR o campo cai em null EM SILÊNCIO (pod-memory.cjs, o
+  // default só é cobrado em `critical`). É por isso que o literal é fixado no invocador.
+  const G = tmpPod('footgun');
+  const semAttr = note.buildNoteEntry({ step: 'assembly', verdict: 'approve', message: 'x', runId: 'r' });
+  delete semAttr.attributed_by;
+  const w = podMemory.append('hn-carousel', semAttr, { podDir: G.podDir });
+  ok('KILL-TEST: sem o literal fixado, append aceitaria attributed_by=null EM SILÊNCIO',
+    w.entry.attributed_by === null, JSON.stringify(w.entry.attributed_by));
+}
+
+// ═══════════════════════════════════════════════════════════════════════════
+// AC5 — approve com comentário → 1 linha; sem comentário → ZERO (por CONTAGEM)
+// ═══════════════════════════════════════════════════════════════════════════
+console.log('\n--- AC5/DF-SF10.21-16,-17: com comentário grava; silêncio não vira learning ---');
+{
+  // A: comentário não-vazio
+  const A = tmpPod('ac5a');
+  const before = countLines(A.podDir);
+  const f = path.join(A.tmp, 'c.txt');
+  fs.writeFileSync(f, OWNER_TEXT);
+  const r = runCli(['--state', A.statePath, '--workflow-file', A.wfPath,
+    '--step', 'assembly', '--verdict', 'approve', '--file', f]);
+  const after = countLines(A.podDir);
+  ok(`approve com comentário: UMA linha nova (${before} → ${after})`, r.status === 0 && after === before + 1, r.stderr);
+  const rec = readRecords(A.podDir)[after - 1];
+  ok('tier === "normal"', rec.tier === 'normal');
+  ok('attributed_by === "human"', rec.attributed_by === 'human');
+  ok(`source_run_id === run_id do state ("${A.state.run_id}")`, rec.source_run_id === A.state.run_id);
+  ok(`trigger DETERMINÍSTICO: ${JSON.stringify(rec.trigger)}`,
+    rec.trigger === 'checkpoint "assembly" aprovado pelo dono');
+  ok('trigger NÃO é fabricado do texto do comentário (nenhuma palavra do comentário nele)',
+    !/capa|contraste|feed|título/i.test(rec.trigger));
+  ok('recommendation === comentário VERBATIM', rec.recommendation === OWNER_TEXT);
+  ok('evidence liga a decisão à etapa e ao run (auditoria)',
+    rec.evidence && rec.evidence.step === 'assembly' && rec.evidence.verdict === 'approve'
+      && rec.evidence.run_id === A.state.run_id, JSON.stringify(rec.evidence));
+
+  // B: comentário vazio / só espaço → ZERO linhas novas (prova por CONTAGEM)
+  const B = tmpPod('ac5b');
+  fs.writeFileSync(rawPath(B.podDir), `${JSON.stringify({ id: 'x', ts: 1, trigger: 't', recommendation: 'r', tier: 'normal' })}\n`);
+  const b0 = countLines(B.podDir);
+  const vazio = path.join(B.tmp, 'vazio.txt');
+  fs.writeFileSync(vazio, '   \n\t\n  ');
+  const rb = runCli(['--state', B.statePath, '--workflow-file', B.wfPath,
+    '--step', 'assembly', '--verdict', 'approve', '--file', vazio]);
+  const b1 = countLines(B.podDir);
+  ok(`silêncio (--file só com espaço): ZERO linhas novas (${b0} → ${b1})`, b1 === b0, rb.stderr);
+  ok('silêncio: exit não-zero (chamada errada, não entrada fabricada)', rb.status !== 0, String(rb.status));
+  const rb2 = runCli(['--state', B.statePath, '--workflow-file', B.wfPath,
+    '--step', 'assembly', '--verdict', 'approve'], { input: '  \n ' });
+  ok(`silêncio (stdin só com espaço): ZERO linhas novas (${b0} → ${countLines(B.podDir)})`,
+    countLines(B.podDir) === b0, rb2.stderr);
+  ok('a biblioteca trata silêncio como "nada a gravar" (appended:false), sem exceção',
+    note.noteCheckpointComment({ pod: 'hn-carousel', podDir: B.podDir, step: 'assembly',
+      verdict: 'approve', message: '   ', runId: 'r' }).appended === false);
+}
+
+// ═══════════════════════════════════════════════════════════════════════════
+// AC6 — revise também captura (o caso de MAIOR valor: hoje o motor não grava nada)
+// ═══════════════════════════════════════════════════════════════════════════
+console.log('\n--- AC6/DF-SF10.21-18: revise captura fora do motor ---');
+{
+  const R = tmpPod('revise');
+  const f = path.join(R.tmp, 'c.txt');
+  const REPROVA = 'Reprovado mesmo passando em todos os vetos: o slide 3 repete o ângulo do slide 1.\nO carrossel perde ritmo no meio.';
+  fs.writeFileSync(f, `${REPROVA}\n`);
+  const before = countLines(R.podDir);
+  const r = runCli(['--state', R.statePath, '--workflow-file', R.wfPath,
+    '--step', 'assembly', '--verdict', 'revise', '--file', f]);
+  const after = countLines(R.podDir);
+  ok(`revise com comentário: UMA linha nova (${before} → ${after})`, r.status === 0 && after === before + 1, r.stderr);
+  const rec = readRecords(R.podDir)[after - 1];
+  ok('revise: recommendation VERBATIM (o porquê da reprovação sobrevive)', rec.recommendation === REPROVA);
+  ok('revise: tier normal + attributed_by "human" + source_run_id do state',
+    rec.tier === 'normal' && rec.attributed_by === 'human' && rec.source_run_id === R.state.run_id);
+  ok(`revise: trigger determinístico ${JSON.stringify(rec.trigger)}`,
+    rec.trigger === 'checkpoint "assembly" revisado pelo dono');
+
+  // A captura acontece INTEIRAMENTE fora do motor: nenhum byte de pc-run-pod.cjs é lido,
+  // importado ou executado por este caminho (só o state.json que ele já escreveu).
+  const runnerSrc = fs.readFileSync(path.join(__dirname, 'pc-run-pod.cjs'), 'utf8');
+  ok('pc-run-pod.cjs continua SEM chamar pod-memory-note (o vão é fechado fora do motor)',
+    !runnerSrc.includes('pod-memory-note'));
+  const iRevise = runnerSrc.indexOf('function revise(ctx, stepId)');
+  const iAbort = runnerSrc.indexOf('function abort(', iRevise);
+  const reviseBody = runnerSrc.slice(iRevise, iAbort);
+  ok('revise() do motor continua sem gravar aprendizado por si (nenhum recordLearning/podMemory no corpo)',
+    iRevise > 0 && iAbort > iRevise && !/recordLearning|podMemory/.test(reviseBody),
+    reviseBody.slice(0, 200));
+}
+
+// ═══════════════════════════════════════════════════════════════════════════
+// AC7 — mesma etapa, dois vereditos, triggers distinguíveis
+// ═══════════════════════════════════════════════════════════════════════════
+console.log('\n--- AC7: auditoria distingue aprovado de reprovado sem ler o texto livre ---');
+{
+  const T = tmpPod('ac7');
+  const f1 = path.join(T.tmp, 'a.txt');
+  const f2 = path.join(T.tmp, 'b.txt');
+  // MESMO texto nos dois: a distinção NÃO pode depender do conteúdo do comentário.
+  fs.writeFileSync(f1, 'Comentário idêntico nos dois vereditos, de propósito.');
+  fs.writeFileSync(f2, 'Comentário idêntico nos dois vereditos, de propósito.');
+  const r1 = runCli(['--state', T.statePath, '--workflow-file', T.wfPath, '--step', 'assembly', '--verdict', 'approve', '--file', f1]);
+  const r2 = runCli(['--state', T.statePath, '--workflow-file', T.wfPath, '--step', 'assembly', '--verdict', 'revise', '--file', f2]);
+  ok('as duas chamadas gravaram (exit 0)', r1.status === 0 && r2.status === 0, `${r1.stderr}${r2.stderr}`);
+  const recs = readRecords(T.podDir);
+  ok(`duas linhas (${recs.length})`, recs.length === 2);
+  ok(`triggers DIFERENTES: ${JSON.stringify(recs.map((x) => x.trigger))}`, recs[0].trigger !== recs[1].trigger);
+  ok('mesmo com recommendation IDÊNTICA, o veredito é auditável por campo estruturado',
+    recs[0].recommendation === recs[1].recommendation
+      && recs[0].evidence.verdict === 'approve' && recs[1].evidence.verdict === 'revise');
+}
+
+// ═══════════════════════════════════════════════════════════════════════════
+// AC8 — eviction forçada por comentário é ANUNCIADA, contra o teto REAL (900 tok)
+// ═══════════════════════════════════════════════════════════════════════════
+console.log('\n--- AC8/ADR-021 DF-SF11.2-3: o comentário que empurra a cauda para fora ANUNCIA ---');
+{
+  const E = tmpPod('eviction', { podSpec: { pod: 'hn-carousel', memoryCost: REAL_MEMORY_COST } });
+  const bulky = (i) => JSON.stringify({
+    id: `H${i}`, ts: 1_700_000_000_000 + i * 1000,
+    trigger: `heuristica de campo numero ${i} da rodada de producao`,
+    recommendation: `recomendacao verificavel numero ${i} — ${'texto com tamanho realista de heuristica de campo '.repeat(2)}`,
+    evidence: { count: 1 }, tier: 'normal',
+  });
+  const seedTo = (n) => fs.writeFileSync(rawPath(E.podDir),
+    `${Array.from({ length: n }, (_, i) => bulky(i)).join('\n')}\n`);
+
+  // Encontra o MAIOR pool que ainda cabe no alvo de 900 tok SEM podar nada — o comentário
+  // do dono é então o ÚNICO responsável pelo estouro (a prova exige causalidade, não
+  // "havia poda desde antes").
+  let n = 1;
+  let pre;
+  for (; n < 200; n++) {
+    seedTo(n);
+    pre = podMemory.consolidate('hn-carousel', { podDir: E.podDir });
+    if (pre.evicted.length > 0) { n -= 1; break; }
+  }
+  seedTo(n);
+  pre = podMemory.consolidate('hn-carousel', { podDir: E.podDir });
+  ok(`estado inicial NÃO poda nada: ${n} heurísticas, ${pre.tokens} tok de ${pre.tokenBudget} (alvo do pod)`,
+    pre.evicted.length === 0, JSON.stringify({ evicted: pre.evicted.length, tokens: pre.tokens }));
+  ok('o teto medido é o ALVO REAL do hn-carousel (900), não o teto do framework (1500)',
+    pre.tokenBudget === 900 && pre.memoryCost && pre.memoryCost.acceptedBy === 'Alexa Exemplo',
+    JSON.stringify({ budget: pre.tokenBudget, cost: pre.memoryCost }));
+
+  const f = path.join(E.tmp, 'c.txt');
+  fs.writeFileSync(f, `${OWNER_TEXT}\n`);
+  const before = countLines(E.podDir);
+  const r = runCli(['--state', E.statePath, '--workflow-file', E.wfPath,
+    '--step', 'assembly', '--verdict', 'revise', '--file', f]);
+  ok(`comentário gravado mesmo estourando o alvo (${before} → ${countLines(E.podDir)} linhas, exit ${r.status})`,
+    r.status === 0 && countLines(E.podDir) === before + 1, r.stderr);
+  ok(`o PRÓPRIO script imprime o aviso de poda em stderr: ${JSON.stringify(r.stderr.split('\n')[0].slice(0, 160))}`,
+    /^\[memory\] AVISO: \d+ heurística\(s\) NÃO entraram no consolidado/.test(r.stderr.trim()), r.stderr);
+  ok('o aviso NOMEIA a causa e o alvo real do pod (900 tok), não um teto inventado',
+    /alvo de custo 900 tok/.test(r.stderr), r.stderr);
+  ok('o aviso NOMEIA o que saiu (a curadoria sabe o que recuperar)',
+    /heuristica de campo numero/.test(r.stderr), r.stderr);
+  ok('o log cru continua íntegro (nada foi apagado — só deixou de ser injetado)',
+    countLines(E.podDir) === n + 1);
+
+  // CONTRAPROVA: sem estouro, nenhum aviso é impresso (o aviso não é decorativo).
+  const Q = tmpPod('sem-eviction', { podSpec: { pod: 'hn-carousel', memoryCost: REAL_MEMORY_COST } });
+  const fq = path.join(Q.tmp, 'c.txt');
+  fs.writeFileSync(fq, 'Aprovado sem ressalvas.');
+  const rq = runCli(['--state', Q.statePath, '--workflow-file', Q.wfPath,
+    '--step', 'assembly', '--verdict', 'approve', '--file', fq]);
+  ok('memória folgada: NENHUM aviso de poda (contraprova do sinal)',
+    rq.status === 0 && !/AVISO/.test(rq.stderr), rq.stderr);
+}
+
+// ═══════════════════════════════════════════════════════════════════════════
+// Robustez de uso (superfície que o gate ataca)
+// ═══════════════════════════════════════════════════════════════════════════
+console.log('\n--- Robustez: veredito inválido, etapa inexistente, tier deliberado ---');
+{
+  const S = tmpPod('robustez');
+  const f = path.join(S.tmp, 'c.txt');
+  fs.writeFileSync(f, 'Texto qualquer do dono.');
+  const base = ['--state', S.statePath, '--workflow-file', S.wfPath, '--file', f];
+
+  const rv = runCli([...base, '--step', 'assembly', '--verdict', 'aprovar']);
+  ok('veredito fora do enum é recusado (exit 2) e nada é gravado',
+    rv.status === 2 && countLines(S.podDir) === 0, `${rv.status} ${rv.stderr}`);
+
+  const rs = runCli([...base, '--step', 'inexistente', '--verdict', 'approve']);
+  ok('etapa que não existe no run é recusada (exit 2) e nada é gravado',
+    rs.status === 2 && countLines(S.podDir) === 0, `${rs.status} ${rs.stderr}`);
+
+  const rc = runCli([...base, '--step', 'assembly', '--verdict', 'approve', '--tier', 'critical']);
+  const recs = readRecords(S.podDir);
+  ok('--tier critical é ATO DELIBERADO e é aceito com attributed_by "human"',
+    rc.status === 0 && recs.length === 1 && recs[0].tier === 'critical' && recs[0].attributed_by === 'human',
+    `${rc.status} ${rc.stderr}`);
+  ok('sem --tier, o default é normal (critical nunca entra por engano)',
+    note.buildNoteEntry({ step: 'a', verdict: 'approve', message: 'x' }).tier === 'normal');
+}
+
+// ═══════════════════════════════════════════════════════════════════════════
+console.log(`\n${failures.length === 0 ? 'OK' : 'FALHA'} — ${passed} asserções passaram, ${failures.length} falharam`);
+if (failures.length > 0) {
+  for (const f of failures) console.log(`  - ${f}`);
+  process.exit(1);
+}