@daniellins/power-claude 0.16.3

package/scripts/harden-knowledge.test.cjs

@@ -0,0 +1,612 @@
+#!/usr/bin/env node
+'use strict';
+/**
+ * harden-knowledge.test.cjs — fixture PONTA-A-PONTA do 2º alvo de promoção do
+ * `*harden-learning`: KNOWLEDGE CANÔNICO (Story SF10.10, ADR-012 Adendo SF10.10).
+ *
+ * Pod-fixture: `template/pods/content-carousel` (EXPORT-CAPAZ — tem pins em
+ * exports/content-carousel/pins.json), copiado para tmp. Nada do repo é mutado.
+ *
+ * O que esta suíte prova (e o que ela NÃO prova):
+ *   PROVA (máquina): aprovação obrigatória; precondição de knowledge DECLARADO no wf;
+ *     recusa de path traversal e de criação de arquivo novo; CONFINAMENTO de escrita a
+ *     3 paths com rollback; scanClone verde sobre o alvo; paridade de `per_file_sha`
+ *     divergindo SÓ nas 2 chaves esperadas; `export_check:"n/a"` DECLARADO em pod sem
+ *     pins; recusa+rollback por estouro de TOKEN_BUDGET; marcação append-only + 🔒.
+ *   NÃO PROVA (e diz isso na cara): que a prosa promovida ficou MELHOR. Não existe
+ *     oráculo de máquina para isso — o único portão de qualidade é `--approved-by`
+ *     (DF-SF10.10-2 item 6). A suíte verifica que essa frase aparece no --help e na
+ *     saída do comando, não que ela seja dispensável.
+ *
+ * Node >= 18, sem dependências externas. 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 podMemory = require('./pod-memory.cjs');
+const { confinementViolations, perFileShaDiff, snapshotDir, declaredKnowledge, QUALITY_NOTICE } =
+  require('./forge-harden-learning.cjs');
+
+const REPO = path.resolve(__dirname, '..');
+const HARDEN = path.join(REPO, 'scripts', 'forge-harden-learning.cjs');
+const FIXTURE_POD = path.join(REPO, 'template', 'pods', 'content-carousel');
+const POD = 'content-carousel';
+const KFILE = 'slides-html.md';
+
+let passed = 0;
+const failures = [];
+function ok(label, cond, extra) {
+  if (cond) { passed++; console.log(`[OK   ] ${label}`); }
+  else { failures.push(label); console.log(`[FALHA] ${label}${extra ? `\n        ${String(extra).slice(0, 500)}` : ''}`); }
+}
+function sh(args) {
+  return spawnSync(process.execPath, args, { encoding: 'utf8', cwd: REPO });
+}
+function sha256(buf) {
+  return crypto.createHash('sha256').update(buf).digest('hex');
+}
+
+const TRIGGER = 'slides internos sem riqueza grafica';
+const RECOMMENDATION = 'usar blocos visuais com hierarquia tipografica em vez de texto corrido';
+
+/** Pod temporário + memória com a heurística consolidada. Devolve o id da entrada. */
+function makePod(label, { seed = true } = {}) {
+  const tmp = fs.mkdtempSync(path.join(os.tmpdir(), `sf10.10-${label}-`));
+  const podDir = path.join(tmp, POD);
+  fs.cpSync(FIXTURE_POD, podDir, { recursive: true });
+  fs.rmSync(path.join(podDir, 'memory'), { recursive: true, force: true });
+  fs.mkdirSync(path.join(podDir, 'memory'), { recursive: true });
+  let learningId = null;
+  if (seed) {
+    const e = podMemory.append(POD, {
+      id: 'SRC-1', ts: 1_700_000_000_000, trigger: TRIGGER, recommendation: RECOMMENDATION,
+      evidence: { count: 2 }, tier: 'normal',
+    }, { podDir });
+    podMemory.consolidate(POD, { podDir });
+    learningId = e.entry.id;
+  }
+  const newContent = path.join(tmp, 'novo-knowledge.md');
+  fs.writeFileSync(newContent,
+    '# Slides HTML (promovido)\n\n## Hierarquia\n\nBlocos visuais com hierarquia tipografica, ' +
+    'numero-heroi por slide e respiro entre secoes.\n');
+  return { tmp, podDir, learningId, newContent };
+}
+
+const promoteArgs = (podDir, learningId, contentPath, extra = []) => [
+  HARDEN, podDir, '--target-type', 'knowledge',
+  '--learning', learningId, '--file', KFILE, '--content', contentPath,
+  ...extra,
+];
+
+// ═══════════════════════════════════════════════════════════════════════════
+// 1. Invariantes PUROS (testáveis sem tocar disco de pod)
+// ═══════════════════════════════════════════════════════════════════════════
+console.log('\n--- 1. Invariantes puros (confinamento, paridade de compilação, wf) ---');
+{
+  const before = new Map([
+    ['knowledge/slides-html.md', Buffer.from('a')],
+    ['workflows/wf-x.yaml', Buffer.from('wf')],
+    ['memory/learnings.jsonl', Buffer.from('{}')],
+    ['memory/learnings.consolidated.md', Buffer.from('# md')],
+  ]);
+  const ALLOWED = ['knowledge/slides-html.md', 'memory/learnings.jsonl', 'memory/learnings.consolidated.md'];
+
+  const okCase = new Map(before);
+  okCase.set('knowledge/slides-html.md', Buffer.from('b'));
+  okCase.set('memory/learnings.jsonl', Buffer.from('{}{}'));
+  okCase.set('memory/learnings.consolidated.md', Buffer.from('# md2'));
+  ok('confinamento: mudança nos 3 paths permitidos ⇒ ZERO violação',
+    confinementViolations(before, okCase, ALLOWED).length === 0);
+
+  const badEdit = new Map(okCase);
+  badEdit.set('workflows/wf-x.yaml', Buffer.from('wf-alterado'));
+  ok('confinamento: escrita no wf (fora do trio) ⇒ violação nomeada',
+    confinementViolations(before, badEdit, ALLOWED).join() === '~ workflows/wf-x.yaml');
+
+  const badNew = new Map(okCase);
+  badNew.set('agents/novo.md', Buffer.from('x'));
+  ok('confinamento: arquivo CRIADO fora do trio ⇒ violação',
+    confinementViolations(before, badNew, ALLOWED).join() === '+ agents/novo.md');
+
+  const badDel = new Map(okCase);
+  badDel.delete('workflows/wf-x.yaml');
+  ok('confinamento: arquivo REMOVIDO fora do trio ⇒ violação',
+    confinementViolations(before, badDel, ALLOWED).join() === '- workflows/wf-x.yaml');
+
+  ok('paridade: per_file_sha idêntico ⇒ nenhuma chave divergente',
+    perFileShaDiff({ per_file_sha: { a: '1' } }, { per_file_sha: { a: '1' } }).length === 0);
+  ok('paridade: chave alterada + chave nova ⇒ ambas listadas, ordenadas',
+    perFileShaDiff({ per_file_sha: { a: '1', b: '2' } }, { per_file_sha: { a: '9', b: '2', c: '3' } }).join() === 'a,c');
+
+  const declared = declaredKnowledge(path.join(FIXTURE_POD, 'workflows', `wf-${POD}.yaml`));
+  ok('wf: declaredKnowledge lê os knowledge declarados nas etapas do workflow real',
+    declared.has(KFILE) && declared.has('image-generation.md') && !declared.has('inexistente.md'),
+    [...declared].join(','));
+}
+
+// ═══════════════════════════════════════════════════════════════════════════
+// 2. Recusas (nada aplicado, exit 2) — cada uma com o pod BYTE-IDÊNTICO depois
+// ═══════════════════════════════════════════════════════════════════════════
+console.log('\n--- 2. Recusas: aprovação, declaração no wf, traversal, criação, no-op ---');
+{
+  const { tmp, podDir, learningId, newContent } = makePod('recusas');
+  const snapBefore = snapshotDir(podDir);
+  const intact = (label) => {
+    const now = snapshotDir(podDir);
+    ok(`${label}: pod BYTE-IDÊNTICO (nada aplicado)`,
+      confinementViolations(snapBefore, now, []).length === 0,
+      confinementViolations(snapBefore, now, []).join(', '));
+  };
+
+  const noApproval = sh(promoteArgs(podDir, learningId, newContent));
+  ok('sem --approved-by: recusa exit 2', noApproval.status === 2, noApproval.stderr);
+  ok('sem --approved-by: a recusa REPETE que o único portão de qualidade é a revisão humana',
+    noApproval.stderr.includes('--approved-by') && noApproval.stderr.includes(QUALITY_NOTICE), noApproval.stderr);
+  intact('sem --approved-by');
+
+  const notDeclared = sh([HARDEN, podDir, '--target-type', 'knowledge', '--learning', learningId,
+    '--file', 'dono.example.yaml.md', '--content', newContent, '--approved-by', 'daniel']);
+  ok('AC9 knowledge NÃO declarado no wf: recusa exit 2 citando os declarados',
+    notDeclared.status === 2 && /não está declarado em knowledge:/.test(notDeclared.stderr) &&
+    notDeclared.stderr.includes('DEBT-SF10.10-C'), notDeclared.stderr);
+  intact('knowledge não declarado');
+
+  for (const evil of ['../../../etc/passwd.md', 'knowledge/../../fora.md', '/tmp/absoluto.md', 'sub/dir.md']) {
+    const trav = sh([HARDEN, podDir, '--target-type', 'knowledge', '--learning', learningId,
+      '--file', evil, '--content', newContent, '--approved-by', 'daniel']);
+    ok(`path traversal em --file (${evil}): recusa exit 2 antes de qualquer escrita`,
+      trav.status === 2 && /nome SIMPLES sob knowledge\/|resolveu para fora/.test(trav.stderr), trav.stderr);
+  }
+  intact('path traversal');
+
+  const create = sh([HARDEN, podDir, '--target-type', 'knowledge', '--learning', learningId,
+    '--file', 'ainda-nao-existe.md', '--content', newContent, '--approved-by', 'daniel']);
+  ok('criar knowledge NOVO (não declarado/inexistente): recusa exit 2 (Escopo OUT, DEBT-SF10.10-C)',
+    create.status === 2, create.stderr);
+
+  const same = path.join(tmp, 'igual.md');
+  fs.copyFileSync(path.join(podDir, 'knowledge', KFILE), same);
+  const noop = sh(promoteArgs(podDir, learningId, same, ['--approved-by', 'daniel']));
+  ok('--content byte-idêntico ao alvo: recusa exit 2 (não há mudança a registrar)',
+    noop.status === 2 && /BYTE-IDÊNTICO/.test(noop.stderr), noop.stderr);
+  intact('--content idêntico');
+
+  const badLearning = sh(promoteArgs(podDir, 'nao-existe', newContent, ['--approved-by', 'daniel']));
+  ok('--learning inexistente: recusa exit 2', badLearning.status === 2, badLearning.stderr);
+  intact('--learning inexistente');
+
+  const badType = sh([HARDEN, podDir, '--target-type', 'assertion_magica', '--approved-by', 'daniel']);
+  ok('--target-type desconhecido: erro de uso exit 1 (nunca silencioso, nunca vira "veto")',
+    badType.status === 1 && /desconhecido/.test(badType.stderr), badType.stderr);
+
+  fs.rmSync(tmp, { recursive: true, force: true });
+}
+
+// ═══════════════════════════════════════════════════════════════════════════
+// 3. Promoção aprovada em pod EXPORT-CAPAZ (o caminho completo, AC2/AC3/AC6)
+// ═══════════════════════════════════════════════════════════════════════════
+console.log('\n--- 3. Promoção aprovada (pod export-capaz): confinamento + scanClone + per_file_sha ---');
+{
+  const { tmp, podDir, learningId, newContent } = makePod('promocao');
+  const memPaths = podMemory.memoryPaths(POD, { podDir });
+  const rawBefore = fs.readFileSync(memPaths.raw, 'utf8').split('\n').filter(Boolean);
+  const snapBefore = snapshotDir(podDir);
+  const shaBefore = sha256(fs.readFileSync(path.join(podDir, 'knowledge', KFILE)));
+  const shaAfter = sha256(fs.readFileSync(newContent));
+
+  const r = sh(promoteArgs(podDir, learningId, newContent, ['--approved-by', 'daniel']));
+  ok(`promoção aprovada: exit 0 (${r.status})`, r.status === 0, `${r.stdout}${r.stderr}`);
+
+  ok('knowledge-alvo recebeu EXATAMENTE o conteúdo proposto pelo humano',
+    fs.readFileSync(path.join(podDir, 'knowledge', KFILE)).equals(fs.readFileSync(newContent)));
+
+  // SF11.4/DF-SF11.4-1: a trilha auditável (memory/learnings.hardened.md) é escrita por
+  // `consolidate` dentro da promoção — entra no confinamento permitido (sem isso a
+  // promoção reprovaria contra si mesma).
+  const violations = confinementViolations(snapBefore, snapshotDir(podDir),
+    [`knowledge/${KFILE}`, 'memory/learnings.jsonl', 'memory/learnings.consolidated.md',
+      podMemory.HARDENED_DETAIL_REL]);
+  ok('AC3 CONFINAMENTO real: só os 4 paths permitidos mudaram sob o podDir',
+    violations.length === 0, violations.join(', '));
+
+  const raw = fs.readFileSync(memPaths.raw, 'utf8').split('\n').filter(Boolean);
+  ok('AC6 append-only: linhas anteriores INTACTAS + 1 registro de hardening',
+    raw.length === rawBefore.length + 1 && raw.slice(0, rawBefore.length).join('\n') === rawBefore.join('\n'));
+  const rec = JSON.parse(raw[raw.length - 1]);
+  ok('AC1 registro = {type:hardening, ref, target:{pod,kind,file,sha_before,sha_after}, approved_by, timestamp}',
+    rec.type === 'hardening' && rec.ref === `${podMemory.normalizeText(TRIGGER)}||${podMemory.normalizeText(RECOMMENDATION)}` &&
+    rec.target.kind === 'knowledge' && rec.target.file === KFILE &&
+    rec.target.sha_before === shaBefore && rec.target.sha_after === shaAfter &&
+    rec.approved_by === 'daniel' && typeof rec.timestamp === 'string',
+    JSON.stringify(rec));
+  // O `ref` é a dedupKey da HEURÍSTICA (contrato de SF7.6) — o que não pode aparecer
+  // é o CONTEÚDO do knowledge: registro de tamanho fixo, diff no git (DF-SF10.10-1).
+  ok('AC1 registro SEM diff e SEM trecho do knowledge (tamanho fixo: 2 shas + 1 nome)',
+    !JSON.stringify(rec).includes('diff') && !JSON.stringify(rec).includes('numero-heroi') &&
+    JSON.stringify(rec).length <= rec.ref.length + 350, // overhead FIXO: 2 shas + nome + aprovador + ts
+    JSON.stringify(rec));
+
+  const md = fs.readFileSync(memPaths.consolidated, 'utf8');
+  const detail = fs.readFileSync(memPaths.hardenedDetail, 'utf8');
+  ok('SF11.4 trilha auditável: 🔒 endurecida → knowledge/<file>, linha fixa e curta (fora do brief)',
+    detail.includes(`🔒 **[${TRIGGER}]**`) && detail.includes(`endurecida → knowledge/${KFILE}`) &&
+    detail.includes('(por daniel,'), detail);
+  ok('SF11.4 consolidado injetado cita só a REFERÊNCIA agregada (alvo + contagem + trilha)',
+    md.includes(`knowledge/${KFILE} (1)`) && md.includes(podMemory.HARDENED_DETAIL_REL) &&
+    !md.includes(RECOMMENDATION), md);
+  ok('consolidado: heurística DEMOVIDA do top-N ativo',
+    !md.split('## Endurecidas')[0].includes(`**[${TRIGGER}]**`));
+
+  ok('AC3(v) paridade de compilação: per_file_sha divergiu SOMENTE nas 2 chaves esperadas',
+    r.stdout.includes(`per_file_sha divergiu SOMENTE em knowledge/${KFILE}, memory/learnings.consolidated.md`),
+    r.stdout);
+  ok('AC3(v) export_check declarado como "ok" no relatório', /export_check: ok/.test(r.stdout), r.stdout);
+  ok('AC3(ii) a AUSÊNCIA do smoke "depois" é DECLARADA com o motivo (verde por construção)',
+    /sem smoke "depois": omitido POR DECISÃO/.test(r.stdout) && /VERDE POR CONSTRUÇÃO/.test(r.stdout), r.stdout);
+  ok('AC3(vi) a saída diz, sem eufemismo, que o único portão de qualidade é --approved-by',
+    r.stdout.includes(QUALITY_NOTICE), r.stdout);
+  ok('relatório aponta o git para o diff (registro não o embute)',
+    /git diff --/.test(r.stdout), r.stdout);
+
+  // idempotência: repetir recusa (já endurecida)
+  const again = sh(promoteArgs(podDir, learningId, newContent, ['--approved-by', 'daniel']));
+  ok('re-promover a mesma heurística: recusa exit 2 (já endurecida 🔒)', again.status === 2, again.stderr);
+
+  fs.rmSync(tmp, { recursive: true, force: true });
+}
+
+// ═══════════════════════════════════════════════════════════════════════════
+// 4. scanClone como PÓS-CONDIÇÃO: prosa que encarna um mind ⇒ rollback
+// ═══════════════════════════════════════════════════════════════════════════
+console.log('\n--- 4. Pós-condição de proveniência (validate-no-clone regras 1-3) ---');
+{
+  const { tmp, podDir, learningId } = makePod('clone');
+  const snapBefore = snapshotDir(podDir);
+  const evil = path.join(tmp, 'clone.md');
+  // Regra 2 (persona com token da denylist derivada de validate-branding): assumir a
+  // persona de um mind é FAIL mesmo com citação — "citar ≠ encarnar".
+  fs.writeFileSync(evil, '# Slides\n\nVocê é o alan nicolas e escreve exatamente como ele.\n');
+  const r = sh(promoteArgs(podDir, learningId, evil, ['--approved-by', 'daniel']));
+  ok('scanClone vermelho no knowledge promovido ⇒ recusa exit 2 + ROLLBACK',
+    r.status === 2 && /validate-no-clone/.test(r.stderr) && /ROLLBACK aplicado/.test(r.stderr), r.stderr);
+  const after = snapshotDir(podDir);
+  ok('rollback do scanClone: pod BYTE-IDÊNTICO (knowledge, log e consolidado restaurados)',
+    confinementViolations(snapBefore, after, []).length === 0,
+    confinementViolations(snapBefore, after, []).join(', '));
+  ok('rollback do scanClone: NENHUM registro de hardening ficou no log',
+    !fs.readFileSync(podMemory.memoryPaths(POD, { podDir }).raw, 'utf8').includes('"type":"hardening"'));
+  fs.rmSync(tmp, { recursive: true, force: true });
+}
+
+// ═══════════════════════════════════════════════════════════════════════════
+// 5. (SF11.4/DF-SF11.4-4, SUPERSEDE AC10/DF-SF10.10-6) o gate mede EVICTION,
+//    não `tokens > TOKEN_BUDGET`. Motivo: `computeConsolidation` normaliza `tokens`
+//    ANTES de qualquer chamador — o gate antigo só era alcançável com `ranked` já
+//    ZERADO, isto é, depois que 100% da memória ativa tinha sido apagada em silêncio
+//    (ADR-022 §C4). O gate novo recusa quando a consolidação DESCARTA heurística.
+//    ALCANÇABILIDADE PROVADA AQUI: a fixture monta o estado e o comando recusa.
+// ═══════════════════════════════════════════════════════════════════════════
+console.log('\n--- 5. DF-SF11.4-4: promoção que descartaria heurística ⇒ recusa + rollback ---');
+{
+  const { tmp, podDir, learningId, newContent } = makePod('budget');
+  const memPaths = podMemory.memoryPaths(POD, { podDir });
+  const baseLog = fs.readFileSync(memPaths.raw, 'utf8');
+  const B = podMemory.TOKEN_BUDGET;
+
+  // Enche o POOL ATIVO (heurísticas NÃO endurecidas, que é o que a poda por orçamento
+  // corta) até o consolidado não caber no teto. `ts` mais ANTIGO que o da heurística-alvo
+  // ⇒ recência menor ⇒ a cauda podada são as de enchimento, e o alvo segue curado.
+  const lines = [baseLog.trim()];
+  for (let i = 0; i < 34; i++) {
+    lines.push(JSON.stringify({
+      id: `F${i}`,
+      ts: 1_600_000_000_000 + i * 1000,
+      trigger: `heuristica de enchimento numero ${i} do consolidado`,
+      recommendation: `recomendacao de enchimento ${i} — ${'texto de enchimento com tamanho realista '.repeat(4)}`,
+      evidence: { count: 1 },
+      tier: 'normal',
+    }));
+  }
+  fs.writeFileSync(memPaths.raw, `${lines.join('\n')}\n`);
+  const pre = podMemory.consolidate(POD, { podDir });
+  ok(`fixture: estado com poda por orçamento ATIVA (${pre.evicted.length} descartada(s), ${pre.tokens}/${B})`,
+    pre.evicted.length > 0 && pre.tokens <= B, JSON.stringify({ evicted: pre.evicted.length, tokens: pre.tokens }));
+  ok('fixture: a poda FALA — needsCuration ligado pelo descarte (não fica false como antes)',
+    pre.needsCuration === true);
+  ok('fixture: heurística-alvo ainda presente no consolidado curado',
+    fs.readFileSync(memPaths.consolidated, 'utf8').includes(`**[${TRIGGER}]**`));
+
+  const snapBefore = snapshotDir(podDir);
+  const r = sh(promoteArgs(podDir, learningId, newContent, ['--approved-by', 'daniel']));
+  ok('DF-SF11.4-4 promoção que descartaria heurística: recusa exit 2 NOMEANDO o que sairia',
+    r.status === 2 && /DESCARTARIA \d+ heurística\(s\) do consolidado por (alvo|teto) de custo/.test(r.stderr) &&
+    /heuristica de enchimento numero/.test(r.stderr) && /cure o consolidado/.test(r.stderr), r.stderr);
+  // SF11.4b/DF-SF11.4b-1: recusar por CUSTO e relatar por custo apenas seria o
+  // sub-relato de C2 pela porta dos fundos — a mesma saída traz o LEDGER com o TOTAL das
+  // duas vias. (O gate continua medindo só `reason:'budget'`: promover nunca CAUSA corte
+  // por teto de atenção, porque a endurecida sai do pool que compete por slot.)
+  ok('SF11.4b/AC4 a mesma recusa traz o LEDGER com o TOTAL não-admitido e a quebra por causa',
+    /\[memory\] AVISO: \d+ heurística\(s\) NÃO entraram no consolidado/.test(r.stderr) &&
+    /por teto de atenção TOP_N=30/.test(r.stderr) && /de custo \d+ tok/.test(r.stderr), r.stderr);
+  ok('SF11.4b/AC4 o total do ledger ≥ o número que motivou a recusa (nunca um subconjunto anunciado como tudo)',
+    Number((r.stderr.match(/AVISO: (\d+) heurística/) || [])[1]) >=
+    Number((r.stderr.match(/DESCARTARIA (\d+) heurística/) || [])[1]), r.stderr.slice(0, 300));
+  const after = snapshotDir(podDir);
+  ok('DF-SF11.4-4 ROLLBACK completo: knowledge, log cru e consolidado byte-idênticos',
+    confinementViolations(snapBefore, after, []).length === 0,
+    confinementViolations(snapBefore, after, []).join(', '));
+  ok('DF-SF11.4-4 nenhum registro do alvo knowledge sobrou no log',
+    !fs.readFileSync(memPaths.raw, 'utf8').includes('"kind":"knowledge"'));
+  ok('DF-SF11.4-4 o gate antigo (tokens > BUDGET) NÃO teria disparado neste estado — por isso ele foi supersedido',
+    pre.tokens <= B);
+
+  fs.rmSync(tmp, { recursive: true, force: true });
+}
+
+// ═══════════════════════════════════════════════════════════════════════════
+// 5-bis. (SF11.4/DF-SF11.4-5) unicidade de hardening por `dedupKey`, não por string
+//    do render nem por `trigger` apenas. Entregue JUNTO de DF-SF11.4-1 por
+//    obrigação: aquele remove do consolidado exatamente a string que a checagem
+//    antiga procurava (`🔒 **[trigger]**`) — separar as duas criaria REGRESSÃO
+//    SILENCIOSA (dupla promoção da mesma heurística, sem recusa).
+// ═══════════════════════════════════════════════════════════════════════════
+console.log('\n--- 5-bis. DF-SF11.4-5: unicidade por dedupKey (trigger + recommendation) ---');
+{
+  const { tmp, podDir, learningId, newContent } = makePod('dedupkey');
+  const memPaths = podMemory.memoryPaths(POD, { podDir });
+
+  // (i) NÃO-REGRESSÃO: re-promover a MESMA heurística continua recusado — agora por
+  //     `hardenedRefs.has(dedupKey(entry))`, e não por string do artefato renderizado.
+  const first = sh(promoteArgs(podDir, learningId, newContent, ['--approved-by', 'daniel']));
+  ok('DF-SF11.4-5 (i) 1ª promoção aplica (exit 0)', first.status === 0, `${first.stdout}${first.stderr}`);
+  // conteúdo DIFERENTE do já aplicado: isola a recusa por "já endurecida" (com o mesmo
+  // conteúdo, a recusa viria antes, por --content byte-idêntico).
+  const outroContent = path.join(tmp, 'outro-knowledge.md');
+  fs.writeFileSync(outroContent,
+    '# Slides HTML (promovido de novo)\n\n## Hierarquia\n\nBlocos visuais com hierarquia tipografica e respiro.\n');
+  const again = sh(promoteArgs(podDir, learningId, outroContent, ['--approved-by', 'daniel']));
+  ok('DF-SF11.4-5 (i) re-promover a MESMA heurística: recusa exit 2 citando a ref (dedupKey)',
+    again.status === 2 && /já está endurecido/.test(again.stderr) && /ref "/.test(again.stderr), again.stderr);
+
+  // (ii) CASO REAL DA SESSÃO 2026-08-01/02: duas heurísticas DISTINTAS com o MESMO
+  //      trigger. Antes, a segunda era recusada por "já endurecido" (checagem por
+  //      trigger apenas) e o contorno em produção foi RENOMEAR o trigger
+  //      ("compor a capa" → "titular capa"). Agora ambas podem ser promovidas.
+  const irma = podMemory.append(POD, {
+    id: 'SRC-2', ts: 1_700_000_500_000,
+    trigger: TRIGGER, // MESMO trigger da já endurecida
+    recommendation: 'reservar respiro no topo da peca para o titulo nao encostar na borda',
+    evidence: { count: 2 }, tier: 'normal',
+  }, { podDir });
+  podMemory.consolidate(POD, { podDir });
+  ok('DF-SF11.4-5 (ii) fixture: a irmã (mesmo trigger, recommendation distinta) está curada',
+    fs.readFileSync(memPaths.consolidated, 'utf8').includes('reservar respiro no topo da peca'));
+  const content2 = path.join(tmp, 'novo-knowledge-2.md');
+  fs.writeFileSync(content2,
+    '# Slides HTML (promovido 2)\n\n## Hierarquia\n\nBlocos visuais com hierarquia tipografica.\n\n' +
+    '## Respiro\n\nReservar respiro no topo da peca para o titulo nao encostar na borda.\n');
+  const second = sh(promoteArgs(podDir, irma.entry.id, content2, ['--approved-by', 'daniel']));
+  ok('DF-SF11.4-5 (ii) heurística DISTINTA com o MESMO trigger é promovida (exit 0) — sem renomear nada',
+    second.status === 0, `${second.stdout}${second.stderr}`);
+  const detail = fs.readFileSync(memPaths.hardenedDetail, 'utf8');
+  ok('DF-SF11.4-5 (ii) as DUAS endurecidas convivem na trilha, com o mesmo trigger',
+    detail.split('\n').filter((l) => l.includes(`🔒 **[${TRIGGER}]**`)).length === 2, detail);
+  ok('DF-SF11.4-5 (ii) a referência agregada contabiliza as duas',
+    fs.readFileSync(memPaths.consolidated, 'utf8').includes(`knowledge/${KFILE} (2)`));
+
+  fs.rmSync(tmp, { recursive: true, force: true });
+}
+
+// ═══════════════════════════════════════════════════════════════════════════
+// 6. Pod SEM pins ⇒ export_check "n/a" DECLARADO (nunca pulado em silêncio)
+// ═══════════════════════════════════════════════════════════════════════════
+console.log('\n--- 6. Pod não export-capaz: export_check "n/a" declarado (DEBT-SF10.10-E) ---');
+{
+  const { tmp, podDir, learningId, newContent } = makePod('nopins');
+  // renomeia o pod (spec + wf + smoke) para um nome SEM pins em exports/
+  const alias = 'carousel-sem-pins';
+  const spec = JSON.parse(fs.readFileSync(path.join(podDir, 'pod-spec.json'), 'utf8'));
+  spec.pod = alias;
+  fs.writeFileSync(path.join(podDir, 'pod-spec.json'), `${JSON.stringify(spec, null, 2)}\n`);
+  fs.renameSync(path.join(podDir, 'memory'), path.join(podDir, 'memory-old'));
+  fs.renameSync(path.join(podDir, 'memory-old'), path.join(podDir, 'memory')); // no-op: memória é por podDir
+  ok('fixture: pod renomeado sem pins em exports/',
+    !fs.existsSync(path.join(REPO, 'exports', alias, 'pins.json')) && !fs.existsSync(path.join(podDir, 'pins.json')));
+
+  const r = sh([HARDEN, podDir, '--target-type', 'knowledge', '--learning', learningId,
+    '--file', KFILE, '--content', newContent, '--approved-by', 'daniel']);
+  ok(`promoção em pod sem pins: exit 0 (${r.status})`, r.status === 0, `${r.stdout}${r.stderr}`);
+  ok('AC3(v) export_check "n/a" DECLARADO no relatório, com o motivo e o débito',
+    /export_check: n\/a/.test(r.stdout) && /pins\.json/.test(r.stdout) && /DEBT-SF10\.10-E/.test(r.stdout), r.stdout);
+  ok('pod sem pins: promoção ainda registra 🔒 (referência no consolidado + detalhe na trilha)',
+    fs.readFileSync(path.join(podDir, 'memory', 'learnings.consolidated.md'), 'utf8')
+      .includes(`knowledge/${KFILE} (1)`) &&
+    fs.readFileSync(path.join(podDir, 'memory', podMemory.HARDENED_DETAIL_FILE), 'utf8')
+      .includes(`endurecida → knowledge/${KFILE}`));
+  fs.rmSync(tmp, { recursive: true, force: true });
+}
+
+// ═══════════════════════════════════════════════════════════════════════════
+// 7. --list-candidates (AC4): read-only, exit 0, nunca promove, nunca classifica
+// ═══════════════════════════════════════════════════════════════════════════
+console.log('\n--- 7. --list-candidates: detecção read-only (DF-SF10.10-3) ---');
+{
+  const { tmp, podDir, learningId, newContent } = makePod('list');
+  podMemory.append(POD, {
+    id: 'SRC-2', ts: 1_700_000_500_000, trigger: 'api do hn instavel',
+    recommendation: 'usar timeout explicito e retry', evidence: { count: 1 }, tier: 'normal',
+  }, { podDir });
+  podMemory.consolidate(POD, { podDir });
+  const snapBefore = snapshotDir(podDir);
+
+  const l1 = sh([HARDEN, podDir, '--list-candidates']);
+  ok('--list-candidates: exit 0', l1.status === 0, `${l1.stdout}${l1.stderr}`);
+  ok('--list-candidates: lista as 2 heurísticas consolidadas com o id colável em --learning',
+    l1.stdout.includes(`**[${TRIGGER}]**`) && l1.stdout.includes('**[api do hn instavel]**') &&
+    l1.stdout.includes('--learning SRC-1') && l1.stdout.includes('--learning SRC-2'), l1.stdout);
+  ok('--list-candidates: declara que NÃO classifica conteúdo vs mecanizável (sem oráculo)',
+    /não há oráculo|NÃO classifica/i.test(l1.stdout), l1.stdout);
+  ok('--list-candidates: READ-ONLY (pod byte-idêntico depois)',
+    confinementViolations(snapBefore, snapshotDir(podDir), []).length === 0);
+
+  // depois de promover uma, ela SAI da lista (diferença de conjuntos, verificável)
+  const p = sh(promoteArgs(podDir, learningId, newContent, ['--approved-by', 'daniel']));
+  ok('setup: promoção auxiliar exit 0', p.status === 0, `${p.stdout}${p.stderr}`);
+  const l2 = sh([HARDEN, podDir, '--list-candidates']);
+  ok('--list-candidates: heurística ENDURECIDA sai da lista; a outra permanece',
+    l2.status === 0 && !l2.stdout.includes(`**[${TRIGGER}]**`) && l2.stdout.includes('**[api do hn instavel]**'),
+    l2.stdout);
+  ok('--list-candidates: exit 0 mesmo sem memória (nunca falha)',
+    sh([HARDEN, path.join(REPO, 'template', 'pods', 'content-carousel'), '--list-candidates']).status === 0);
+
+  fs.rmSync(tmp, { recursive: true, force: true });
+}
+
+// ═══════════════════════════════════════════════════════════════════════════
+// 9. QA/F1 — SYMLINK não fura a prova de confinamento
+//    O guard lexical (`path.resolve`) não enxerga link: sem o guard de realpath, um
+//    knowledge/<file> apontando para fora do pod fazia a promoção sair exit 0 dizendo
+//    "confinamento OK" e SOBRESCREVER o arquivo externo — o diff é cego a links
+//    (Dirent de symlink não é isFile()). Mesmo padrão de guard do Guard B de
+//    command_check (pc-run-pod.cjs) e do confineToRunDir (pod-export-ui.cjs, SF10.9).
+// ═══════════════════════════════════════════════════════════════════════════
+console.log('\n--- 9. QA/F1: symlink no knowledge-alvo ⇒ recusa antes de escrever ---');
+{
+  const { tmp, podDir, learningId, newContent } = makePod('symlink');
+  const outside = path.join(tmp, 'FORA-DO-POD.md');
+  const target = path.join(podDir, 'knowledge', KFILE);
+  fs.copyFileSync(target, outside);           // o arquivo externo guarda o conteúdo real
+  const outsideBefore = fs.readFileSync(outside);
+  fs.rmSync(target);
+  fs.symlinkSync(outside, target);            // knowledge/slides-html.md → fora do pod
+  ok('fixture: knowledge-alvo é um symlink para fora do podDir', fs.lstatSync(target).isSymbolicLink());
+
+  const snapBefore = snapshotDir(podDir);
+  const r = sh(promoteArgs(podDir, learningId, newContent, ['--approved-by', 'daniel']));
+  ok('F1 promoção através de symlink: RECUSA exit 2 (não exit 0 com "confinamento OK")',
+    r.status === 2, `status=${r.status}\n${r.stdout}${r.stderr}`);
+  ok('F1 a recusa nomeia o realpath e o motivo (escrita cairia fora do pod / diff cego)',
+    /realpath/.test(r.stderr) && /FORA/i.test(r.stderr), r.stderr);
+  ok('F1 o arquivo FORA do pod continua BYTE-IDÊNTICO (nada vazou para fora do podDir)',
+    fs.readFileSync(outside).equals(outsideBefore));
+  ok('F1 nenhum registro de hardening foi gravado',
+    !fs.readFileSync(podMemory.memoryPaths(POD, { podDir }).raw, 'utf8').includes('"type":"hardening"'));
+  ok('F1 pod inalterado (o symlink segue lá, nada foi escrito)',
+    confinementViolations(snapBefore, snapshotDir(podDir), []).length === 0);
+  ok('F1 snapshotDir REGISTRA o symlink (antes era invisível: Dirent de link não é isFile())',
+    [...snapBefore.keys()].includes(`knowledge/${KFILE}`) &&
+    snapBefore.get(`knowledge/${KFILE}`).toString().startsWith('symlink → '),
+    [...snapBefore.keys()].filter((k) => k.startsWith('knowledge/')).join(','));
+
+  // link criado DENTRO do pod agora conta como mudança para o diff de confinamento
+  const snapA = snapshotDir(podDir);
+  fs.symlinkSync(outside, path.join(podDir, 'knowledge', 'LINK-NOVO.md'));
+  ok('F1 symlink CRIADO sob o podDir vira violação de confinamento (antes: invisível)',
+    confinementViolations(snapA, snapshotDir(podDir), []).join() === '+ knowledge/LINK-NOVO.md',
+    confinementViolations(snapA, snapshotDir(podDir), []).join());
+
+  fs.rmSync(tmp, { recursive: true, force: true });
+}
+
+// ═══════════════════════════════════════════════════════════════════════════
+// 10. QA/F2 — a GUARDA de confinamento (o wiring, não a função pura) tem que MORRER
+//     se removida. Padrão de kill-test já usado no repo (pod-memory.test.cjs SF8.3):
+//     roda uma cópia do motor REAL com UMA escrita extra injetada fora do trio. Como a
+//     cópia é derivada do arquivo em disco a cada execução, remover a guarda do motor
+//     real deixa esta verificação VERMELHA.
+// ═══════════════════════════════════════════════════════════════════════════
+console.log('\n--- 10. QA/F2: guarda de confinamento morre sob mutação (teste negativo real) ---');
+{
+  const { tmp, podDir, learningId, newContent } = makePod('confin');
+  const src = fs.readFileSync(HARDEN, 'utf8');
+  const anchor = '  fs.writeFileSync(targetAbs, newContent);';
+  ok('F2 âncora da aplicação do conteúdo encontrada no motor', src.includes(anchor));
+  // injeta UMA escrita fora do trio permitido (o vetor que o QA usou por injeção)
+  const injected = src.replace(anchor,
+    `${anchor}\n  fs.writeFileSync(path.join(podDir, 'INTRUSO.md'), 'escrita fora do trio permitido\\n');`);
+  ok('F2 injeção aplicada (motor com escrita fora do trio)', injected !== src);
+  const sabPath = path.join(tmp, 'forge-harden-learning-intruso.cjs');
+  // A cópia vive em tmp: reaponta os require relativos E o REPO_ROOT para o repo real —
+  // sem isso a cópia recusaria por "baseline vermelho" (motivo ERRADO) e a verificação de
+  // exit 2 seria VACUOSA. A asserção seguinte (mensagem do confinamento) é o que impede isso.
+  const rooted = injected
+    .replace(/require\('\.\//g, `require('${path.join(REPO, 'scripts')}/`)
+    .replace("const REPO_ROOT = path.resolve(__dirname, '..');", `const REPO_ROOT = ${JSON.stringify(REPO)};`);
+  ok('F2 cópia reancorada no repo real (senão o exit 2 seria por baseline, não pela guarda)',
+    rooted.includes(`const REPO_ROOT = ${JSON.stringify(REPO)};`));
+  fs.writeFileSync(sabPath, rooted);
+
+  const snapBefore = snapshotDir(podDir);
+  const r = spawnSync(process.execPath, [sabPath, podDir, '--target-type', 'knowledge',
+    '--learning', learningId, '--file', KFILE, '--content', newContent, '--approved-by', 'daniel'],
+  { encoding: 'utf8', cwd: REPO });
+  ok('F2 escrita fora do trio ⇒ a GUARDA dispara: exit 2 (se a guarda for removida, isto vira exit 0)',
+    r.status === 2, `status=${r.status}\n${r.stdout}${r.stderr}`);
+  ok('F2 a recusa nomeia o confinamento e o path intruso, e diz ROLLBACK',
+    /confinamento permitido/.test(r.stderr) && /INTRUSO\.md/.test(r.stderr) && /ROLLBACK aplicado/.test(r.stderr),
+    r.stderr);
+  const after = snapshotDir(podDir);
+  ok('F2 ROLLBACK: o arquivo intruso foi REMOVIDO e o pod voltou byte a byte',
+    !fs.existsSync(path.join(podDir, 'INTRUSO.md')) &&
+    confinementViolations(snapBefore, after, []).length === 0,
+    confinementViolations(snapBefore, after, []).join(', '));
+  ok('F2 ROLLBACK: nenhum registro de hardening ficou no log',
+    !fs.readFileSync(podMemory.memoryPaths(POD, { podDir }).raw, 'utf8').includes('"type":"hardening"'));
+
+  fs.rmSync(tmp, { recursive: true, force: true });
+}
+
+// ═══════════════════════════════════════════════════════════════════════════
+// 11. QA/F2 — a GUARDA de paridade de compilação também tem rota negativa REAL:
+//     knowledge declarado em `knowledge_exclude:` é editável (AC9 aceita), mas o
+//     compilador NÃO o inclui em per_file_sha ⇒ a promoção muda um arquivo que o
+//     bundle do export não vê. A guarda pega isso e faz rollback.
+// ═══════════════════════════════════════════════════════════════════════════
+console.log('\n--- 11. QA/F2: paridade per_file_sha — knowledge excluído do bundle ⇒ rollback ---');
+{
+  const { tmp, podDir, learningId, newContent } = makePod('paridade');
+  const excluded = 'nota-interna.md';
+  fs.writeFileSync(path.join(podDir, 'knowledge', excluded), '# Nota interna\n\nTexto original.\n');
+  const wfPath = path.join(podDir, 'workflows', `wf-${POD}.yaml`);
+  fs.writeFileSync(wfPath, `knowledge_exclude: [${excluded}]\n${fs.readFileSync(wfPath, 'utf8')}`);
+  ok('fixture: knowledge declarado só em knowledge_exclude (fora do bundle do export)',
+    declaredKnowledge(wfPath).has(excluded));
+
+  const snapBefore = snapshotDir(podDir);
+  const r = sh([HARDEN, podDir, '--target-type', 'knowledge', '--learning', learningId,
+    '--file', excluded, '--content', newContent, '--approved-by', 'daniel']);
+  ok('F2 paridade: arquivo ausente do per_file_sha ⇒ recusa exit 2 + ROLLBACK',
+    r.status === 2 && /per_file_sha NÃO registrou mudança/.test(r.stderr) && /ROLLBACK aplicado/.test(r.stderr),
+    `status=${r.status}\n${r.stderr}`);
+  ok('F2 paridade: rollback byte a byte (knowledge excluído restaurado, log limpo)',
+    confinementViolations(snapBefore, snapshotDir(podDir), []).length === 0 &&
+    !fs.readFileSync(podMemory.memoryPaths(POD, { podDir }).raw, 'utf8').includes('"type":"hardening"'),
+    confinementViolations(snapBefore, snapshotDir(podDir), []).join(', '));
+
+  fs.rmSync(tmp, { recursive: true, force: true });
+}
+
+// ═══════════════════════════════════════════════════════════════════════════
+// 8. --help carrega a fronteira de qualidade (AC3 vi)
+// ═══════════════════════════════════════════════════════════════════════════
+console.log('\n--- 8. --help ---');
+{
+  const h = sh([HARDEN, '--help']);
+  ok('--help: exit 0 e documenta os dois alvos + a detecção',
+    h.status === 0 && /--target-type knowledge/.test(h.stdout) && /--list-candidates/.test(h.stdout), h.stdout);
+  ok('--help: declara literalmente que o único portão de qualidade é --approved-by',
+    h.stdout.includes(QUALITY_NOTICE), h.stdout);
+}
+
+console.log(`\n${passed}/${passed + failures.length} verificações passaram.`);
+if (failures.length) {
+  console.error('\nSUÍTE SF10.10 (alvo knowledge) FALHOU:');
+  for (const f of failures) console.error(`  - ${f}`);
+  process.exit(1);
+}
+console.log('Alvo knowledge verde: confinamento + proveniência + paridade de compilação provados; qualidade da prosa segue sendo humana (--approved-by).');
+process.exit(0);