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

@daniellins/power-claude 0.16.3

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

Potentially problematic release.

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

Files changed (467) hide show

package/scripts/pod-export-ui.test.cjs ADDED Viewed

@@ -0,0 +1,301 @@
+#!/usr/bin/env node
+'use strict';
+/**
+ * pod-export-ui.test.cjs — SMOKE HERMÉTICO da UI web de checkpoint (Story SF10.5, F3).
+ *
+ * NÃO exige VPS/nginx/rede externa. Sobe o servidor `node:http` em 127.0.0.1:0 (porta efêmera) e
+ * exercita o fluxo real (login → seletor → lista → checkpoint → approve/reject) com o backend de
+ * approve INJETADO (sem spawn do executor) OU o `approveRun` REAL de SF10.4 (que RECUSA antes de
+ * qualquer spawn) para o teste adversarial de bypass. Cobre os 11 ACs testáveis sem VPS + os 3
+ * pontos de segurança que o /security-review ataca:
+ *   (S1) Preview XSS   — as peças são renderizadas em <iframe sandbox> (sem allow-same-origin +
+ *                        allow-scripts) e servidas por /preview com CSP `sandbox; script-src 'none'`,
+ *                        sem Set-Cookie; traversal e acesso anônimo RECUSADOS.
+ *   (S2) UI ≠ gate     — POST /approve forjado (operador não-aprovador / sem segredo / segredo
+ *                        errado) é RECUSADO pelo backend REAL (approveRun de SF10.4), UI devolve
+ *                        erro GENÉRICO (sem oracle). A UI nunca é a única barreira.
+ *   (S3) CSRF/sessão   — cookie HMAC não-forjável (corpo adulterado/expirado/chave errada → null),
+ *                        SameSite=Strict+HttpOnly, verificação de Origin e token CSRF nas ações.
+ */
+const http = require('node:http');
+const fs = require('node:fs');
+const os = require('node:os');
+const path = require('node:path');
+const ui = require('./pod-export-ui.cjs');
+const svc = require('./pod-export-service.cjs');
+let failures = 0;
+function assert(ok, msg) { if (ok) console.log(`[OK   ] ${msg}`); else { console.error(`[FALHA] ${msg}`); failures++; } }
+function tmpDir(label) { return fs.mkdtempSync(path.join(os.tmpdir(), `sf10.5-${label}-`)); }
+const SESSION_KEY = 'k'.repeat(48); // >=32 ch
+const TEAM_SECRET = 'senha-da-equipe';
+const APPROVER_SECRET = 'segredo-do-aprovador';
+// ---------------------------------------------------------------------------
+// Fixture: queue com um run em awaiting/ + runDir com peças HTML, + identities + hashes.
+// ---------------------------------------------------------------------------
+function makeFixture() {
+  const root = tmpDir('fix');
+  const queueDir = path.join(root, 'queue');
+  const runsRoot = path.join(root, 'runs');
+  const bundleDir = path.join(root, 'bundle');
+  fs.mkdirSync(bundleDir, { recursive: true });
+  // workflow.yaml com criteria do checkpoint (para checkpointCriterion).
+  fs.writeFileSync(path.join(bundleDir, 'workflow.yaml'),
+    'steps:\n  - id: montagem\n    checkpoint: { blocking: true, criteria: "7 peças: capa + 5 + CTA" }\n');
+  // fila: um run pausado em awaiting/.
+  const dirs = svc.ensureQueue(queueDir);
+  const runId = 'pex-hn-carousel-2026';
+  fs.writeFileSync(path.join(dirs.awaiting, `${runId}.json`), JSON.stringify({ pod: 'hn-carousel', started_by: 'bob' }));
+  fs.writeFileSync(path.join(dirs.awaiting, `${runId}.result.json`), JSON.stringify({ runId, kind: 'awaiting', started_by: 'bob', awaiting: 'montagem', at: '2026-07-31T10:00:00Z' }));
+  // runDir com state.json (para findStateByRunId) + uma peça HTML HOSTIL (script/onerror).
+  const runDir = path.join(runsRoot, 'hn-carousel', 'wf', runId);
+  fs.mkdirSync(path.join(runDir, 'pieces'), { recursive: true });
+  fs.writeFileSync(path.join(runDir, 'state.json'), JSON.stringify({ run_id: runId, steps: {} }));
+  fs.writeFileSync(path.join(runDir, 'pieces', '1-capa.html'), '<html><body><script>window.top.location="http://evil"</script><img src=x onerror="document.cookie">CAPA</body></html>');
+  fs.writeFileSync(path.join(runDir, 'pieces', '7-cta.html'), '<html><body>CTA</body></html>');
+  // identities: daniel = aprovador, alice = não.
+  const identitiesFile = path.join(root, 'identities.json');
+  fs.writeFileSync(identitiesFile, JSON.stringify({ identities: [{ id: 'daniel', label: 'Daniel', is_approver: true }, { id: 'alice', label: 'Alice' }] }));
+  const cfg = ui.loadUiConfig({
+    PODEXPORT_QUEUE_DIR: queueDir,
+    PODEXPORT_RUNS_DIR: runsRoot,
+    PODEXPORT_BUNDLE_DIR: bundleDir,
+    PODEXPORT_IDENTITIES: identitiesFile,
+    PODEXPORT_UI_TEAM_HASH: svc.hashApproverSecret(TEAM_SECRET),
+    PODEXPORT_UI_SESSION_KEY: SESSION_KEY,
+    PODEXPORT_APPROVER_SECRET_HASH: svc.hashApproverSecret(APPROVER_SECRET),
+    PODEXPORT_UI_INSECURE: '1', // sem Secure para o cliente de teste em http.
+  });
+  // O approveRun real lê PODEXPORT_IDENTITIES do env (loadIdentities), então exponha no process.env.
+  process.env.PODEXPORT_IDENTITIES = identitiesFile;
+  return { cfg, runId, root };
+}
+// ---------------------------------------------------------------------------
+// Cliente HTTP mínimo.
+// ---------------------------------------------------------------------------
+function request(server, { method = 'GET', pathUrl = '/', cookie, body, origin } = {}) {
+  const { port } = server.address();
+  return new Promise((resolve, reject) => {
+    const headers = {};
+    if (cookie) headers.Cookie = cookie;
+    if (body != null) { headers['Content-Type'] = 'application/x-www-form-urlencoded'; headers['Content-Length'] = Buffer.byteLength(body); }
+    if (origin !== null) headers.Origin = origin || `http://127.0.0.1:${port}`;
+    const req = http.request({ host: '127.0.0.1', port, method, path: pathUrl, headers }, (res) => {
+      let data = ''; res.on('data', (c) => { data += c; });
+      res.on('end', () => resolve({ status: res.statusCode, headers: res.headers, body: data }));
+    });
+    req.on('error', reject);
+    if (body != null) req.write(body);
+    req.end();
+  });
+}
+function cookieFrom(res) {
+  const sc = res.headers['set-cookie'];
+  if (!sc) return null;
+  const m = String(sc[0]).match(/pex_ui=([^;]*)/);
+  return m ? `pex_ui=${m[1]}` : null;
+}
+function sidFrom(cookie) {
+  const token = cookie.replace('pex_ui=', '');
+  const payload = ui.verifySession(token, SESSION_KEY);
+  return payload && payload.sid;
+}
+function form(obj) { return new URLSearchParams(obj).toString(); }
+// ===========================================================================
+// UNIT — cripto de sessão/CSRF (S3), confinamento (S1), fila.
+// ===========================================================================
+function unitTests() {
+  console.log('\n--- UNIT: sessão/CSRF/confinamento/fila ---');
+  const t = ui.signSession({ sid: 'abc', operator: 'daniel', exp: Date.now() + 1000 }, SESSION_KEY);
+  assert(ui.verifySession(t, SESSION_KEY).operator === 'daniel', 'sessão válida decodifica o operador');
+  assert(ui.verifySession(t, 'chave-errada-de-32-chars-1234567890') === null, 'sessão com CHAVE errada → null (não-forjável)');
+  const idx = t.lastIndexOf('.');
+  const tampered = `${t.slice(0, idx - 4)}AAAA${t.slice(idx)}`;
+  assert(ui.verifySession(tampered, SESSION_KEY) === null, 'corpo ADULTERADO (mesma assinatura) → null');
+  const expired = ui.signSession({ sid: 'x', operator: null, exp: Date.now() - 1 }, SESSION_KEY);
+  assert(ui.verifySession(expired, SESSION_KEY) === null, 'sessão EXPIRADA → null');
+  assert(ui.verifyCsrf(ui.csrfToken('sid1', SESSION_KEY), 'sid1', SESSION_KEY), 'CSRF token válido casa');
+  assert(!ui.verifyCsrf(ui.csrfToken('sid1', SESSION_KEY), 'sid2', SESSION_KEY), 'CSRF de outro sid NÃO casa');
+  assert(!ui.verifyCsrf('', 'sid1', SESSION_KEY), 'CSRF vazio → false');
+  // Confinamento de path (anti-traversal no preview).
+  const rd = tmpDir('rd');
+  assert(ui.confineToRunDir(rd, 'pieces/1.html') !== null, 'path relativo legítimo confina OK');
+  assert(ui.confineToRunDir(rd, '../../etc/passwd') === null, 'traversal ../../ → RECUSADO');
+  const absTry = ui.confineToRunDir(rd, '/etc/passwd');
+  assert(absTry === null || absTry.startsWith(path.resolve(rd) + path.sep), 'path absoluto NUNCA escapa o runDir (confinado, não /etc/passwd real)');
+  assert(ui.confineToRunDir(rd, 'a/../../b') === null, 'traversal disfarçada a/../../b → RECUSADO');
+  assert(!ui.safeRunId('../x'), 'runId com .. → inválido');
+  assert(ui.safeRunId('pex-abc-123'), 'runId legítimo → válido');
+  // Rate limiter.
+  const rl = ui.createRateLimiter(2, 1000);
+  assert(rl.check('a', 0).allowed && rl.check('a', 1).allowed && !rl.check('a', 2).allowed, 'rate-limit barra a 3ª tentativa na janela');
+  // escapeHtml (anti-XSS na própria UI).
+  assert(ui.escapeHtml('<script>&"') === '&lt;script&gt;&amp;&quot;', 'escapeHtml neutraliza < > & "');
+  // listCheckpoints lê awaiting/ do disco.
+  const { cfg } = makeFixture();
+  const list = ui.listCheckpoints(cfg);
+  assert(list.length === 1 && list[0].pod === 'hn-carousel' && list[0].startedBy === 'bob', 'listCheckpoints lê awaiting/ (pod+started_by do disco)');
+  // rejectRun move awaiting→blocked com motivo.
+  const rej = ui.rejectRun(cfg, list[0].runId, { reason: 'fora do brand', rejectedBy: 'alice' });
+  assert(rej.ok && rej.kind === 'blocked', 'rejectRun move o run para blocked/');
+  const blockedRes = JSON.parse(fs.readFileSync(path.join(cfg.queueDir, 'blocked', `${list[0].runId}.result.json`), 'utf8'));
+  assert(blockedRes.rejected === true && blockedRes.reason === 'fora do brand' && blockedRes.rejected_by === 'alice', 'reject grava motivo+quem rejeitou');
+  assert(ui.listCheckpoints(cfg).length === 0, 'run rejeitado some de awaiting/');
+}
+// ===========================================================================
+// HTTP — fluxo real + adversarial. approveRun REAL de SF10.4 (recusa pré-spawn).
+// ===========================================================================
+async function httpTests() {
+  console.log('\n--- HTTP: login/seletor/lista/checkpoint/preview/approve/reject ---');
+  const { cfg, runId } = makeFixture();
+  const approveSpy = [];
+  // approveFn stub SÓ para o caminho de SUCESSO (evita spawn); denials usam o REAL abaixo.
+  const server = ui.createServer(cfg, {
+    approveRun: async (c, id, deps) => {
+      approveSpy.push({ id, asId: deps.asId, secret: deps.approverSecret });
+      // Delega ao REAL para HONRAR o gate (recusa não-aprovador/sem-segredo/segredo-errado).
+      return svc.approveRun(c, id, { ...deps, spawn: () => { const e = require('events').EventEmitter; const ch = new e(); process.nextTick(() => { ch.emit('exit', 0); }); ch.stdout = new e(); return ch; } });
+    },
+  });
+  await new Promise((r) => server.listen(0, '127.0.0.1', r));
+  // AC1 — acesso exige login: GET / sem cookie → redireciona /login.
+  let res = await request(server, { pathUrl: '/' });
+  assert(res.status === 303 && res.headers.location === '/login', 'GET / sem sessão → redirect /login (AC1)');
+  // Login errado → 401 genérico (sem distinguir).
+  res = await request(server, { method: 'POST', pathUrl: '/login', body: form({ password: 'errada' }) });
+  assert(res.status === 401 && /Senha incorreta/.test(res.body) && !res.headers['set-cookie'], 'senha errada → 401 genérico, sem cookie');
+  // Login certo → cookie HttpOnly + SameSite=Strict.
+  res = await request(server, { method: 'POST', pathUrl: '/login', body: form({ password: TEAM_SECRET }) });
+  const cookie = cookieFrom(res);
+  const sc = String(res.headers['set-cookie'][0]);
+  assert(res.status === 303 && cookie, 'login correto → 303 + cookie de sessão (AC1)');
+  assert(/HttpOnly/.test(sc) && /SameSite=Strict/.test(sc), 'cookie é HttpOnly + SameSite=Strict (S3/CSRF)');
+  const sid = sidFrom(cookie);
+  // Logado mas sem operador → GET / mostra o SELETOR (AC2).
+  res = await request(server, { pathUrl: '/', cookie });
+  assert(res.status === 200 && /Quem está usando/.test(res.body) && /Daniel/.test(res.body) && /Alice/.test(res.body), 'sem operador → seletor lista identidades de SF10.4 (AC2)');
+  // Seletor sem CSRF → 403 (S3).
+  res = await request(server, { method: 'POST', pathUrl: '/operator', cookie, body: form({ operator: 'alice' }) });
+  assert(res.status === 403, 'POST /operator sem token CSRF → 403 (S3)');
+  // Seletor com CSRF válido → grava operador.
+  const csrf = ui.csrfToken(sid, SESSION_KEY);
+  res = await request(server, { method: 'POST', pathUrl: '/operator', cookie, body: form({ operator: 'alice', _csrf: csrf }) });
+  const cookieAlice = cookieFrom(res) || cookie;
+  assert(res.status === 303, 'POST /operator com CSRF → 303 (operador atribuído, AC2)');
+  // Lista de checkpoints mostra o run em awaiting/ (AC3).
+  res = await request(server, { pathUrl: '/', cookie: cookieAlice });
+  assert(res.status === 200 && /hn-carousel/.test(res.body) && /Operando como/.test(res.body), 'lista mostra run awaiting/ + operador (AC3)');
+  // Tela de checkpoint: iframe SANDBOX + critério em destaque (AC3/S1).
+  res = await request(server, { pathUrl: `/checkpoint?run=${runId}`, cookie: cookieAlice });
+  assert(res.status === 200 && /7 peças: capa/.test(res.body), 'checkpoint mostra o CRITÉRIO em destaque (AC3)');
+  const iframeTags = res.body.match(/<iframe[^>]*>/g) || [];
+  assert(iframeTags.length >= 1 && iframeTags.every((t) => /sandbox/.test(t) && !/allow-same-origin/.test(t) && !/allow-scripts/.test(t)),
+    'preview em <iframe sandbox> SEM allow-same-origin/allow-scripts (S1 preview XSS)');
+  // Operador alice (não-aprovador): SEM form de aprovar, COM aviso honesto (DF3-3).
+  assert(/Aprovação restrita/.test(res.body) && !/name="secret"/.test(res.body), 'não-aprovador: aviso honesto, sem campo de segredo (AC4/DF3-3)');
+  // /preview: sandbox-CSP, nosniff, SEM Set-Cookie (S1).
+  const sidAlice = sidFrom(cookieAlice);
+  res = await request(server, { pathUrl: `/preview/${runId}/pieces/1-capa.html`, cookie: cookieAlice });
+  assert(res.status === 200 && /sandbox/.test(res.headers['content-security-policy']) && /script-src 'none'/.test(res.headers['content-security-policy']),
+    '/preview serve a peça com CSP sandbox + script-src none (S1)');
+  assert(res.headers['x-content-type-options'] === 'nosniff' && !res.headers['set-cookie'], '/preview: nosniff e NUNCA Set-Cookie (S1)');
+  assert(/CAPA/.test(res.body), '/preview devolve o HTML da peça (conteúdo neutralizado pelo sandbox, não executa)');
+  // /preview traversal → recusado (S1).
+  res = await request(server, { pathUrl: `/preview/${runId}/..%2f..%2f..%2fstate.json`, cookie: cookieAlice });
+  assert(res.status === 400, '/preview com traversal → RECUSADO (S1)');
+  // /preview sem sessão → 403 (não vaza conteúdo do run).
+  res = await request(server, { pathUrl: `/preview/${runId}/pieces/1-capa.html` });
+  assert(res.status === 403, '/preview sem sessão → 403 (S1)');
+  // ---- ADVERSARIAL (S2): backend é o gate, não a UI ----
+  // (a) operador NÃO-aprovador (alice) forja POST /approve com CSRF válido → backend RECUSA.
+  res = await request(server, { method: 'POST', pathUrl: '/approve', cookie: cookieAlice, body: form({ run: runId, secret: APPROVER_SECRET, _csrf: ui.csrfToken(sidAlice, SESSION_KEY) }) });
+  assert(res.status === 403 && /Não foi possível aprovar/.test(res.body), 'alice (não-aprovador) com segredo CERTO → RECUSADO pelo backend, erro genérico (S2/AC4)');
+  assert(ui.listCheckpoints(cfg).length === 1, 'run continua em awaiting/ após approve recusado (nada aprovado)');
+  // Troca para daniel (aprovador).
+  res = await request(server, { method: 'POST', pathUrl: '/operator', cookie: cookieAlice, body: form({ operator: 'daniel', _csrf: ui.csrfToken(sidAlice, SESSION_KEY) }) });
+  const cookieDaniel = cookieFrom(res) || cookieAlice;
+  const sidDaniel = sidFrom(cookieDaniel);
+  const csrfDaniel = ui.csrfToken(sidDaniel, SESSION_KEY);
+  // (b) daniel SEM segredo → RECUSADO.
+  res = await request(server, { method: 'POST', pathUrl: '/approve', cookie: cookieDaniel, body: form({ run: runId, secret: '', _csrf: csrfDaniel }) });
+  assert(res.status === 403 && /Não foi possível aprovar/.test(res.body), 'daniel SEM segredo → RECUSADO (S2/AC4)');
+  // (c) daniel com segredo ERRADO → RECUSADO.
+  res = await request(server, { method: 'POST', pathUrl: '/approve', cookie: cookieDaniel, body: form({ run: runId, secret: 'chute-errado', _csrf: csrfDaniel }) });
+  assert(res.status === 403 && /Não foi possível aprovar/.test(res.body), 'daniel com segredo ERRADO → RECUSADO (S2/AC4)');
+  // Tela do aprovador: mostra o form de segredo com a frase obrigatória (DF3-4).
+  res = await request(server, { pathUrl: `/checkpoint?run=${runId}`, cookie: cookieDaniel });
+  assert(/name="secret"/.test(res.body) && /não autoriza sozinho/.test(res.body), 'aprovador: form de segredo + "não autoriza sozinho" (DF3-4)');
+  // (d) daniel com segredo CERTO → APROVADO (via stub spawn; backend autoriza).
+  res = await request(server, { method: 'POST', pathUrl: '/approve', cookie: cookieDaniel, body: form({ run: runId, secret: APPROVER_SECRET, _csrf: csrfDaniel }) });
+  assert(res.status === 303 && /flash=approved/.test(res.headers.location), 'daniel com segredo CERTO → aprovado (backend autoriza; UI só repassa)');
+  assert(approveSpy.some((c) => c.asId === 'daniel' && c.secret === APPROVER_SECRET), 'UI repassou asId=operador + segredo ao approveRun (não decide sozinha, S2)');
+  // Origin de outra origem numa ação de estado → recusado (defesa em profundidade além do SameSite).
+  res = await request(server, { method: 'POST', pathUrl: '/reject', cookie: cookieDaniel, origin: 'http://evil.example', body: form({ run: runId, reason: 'x', _csrf: csrfDaniel }) });
+  assert(res.status === 403, 'POST com Origin cross-site → 403 (CSRF defesa em profundidade, S3)');
+  // Reject legítimo (com CSRF+Origin) devolve o run com motivo (AC).
+  res = await request(server, { method: 'POST', pathUrl: '/reject', cookie: cookieDaniel, body: form({ run: runId, reason: 'capa é cópia', _csrf: csrfDaniel }) });
+  assert(res.status === 303 && /flash=rejected/.test(res.headers.location), 'reject com motivo → 303 (run devolvido)');
+  // Health sem auth.
+  res = await request(server, { pathUrl: '/health' });
+  assert(res.status === 200 && res.body === 'ok', '/health responde sem auth');
+  await new Promise((r) => server.close(r));
+}
+// ===========================================================================
+// DIRETO no backend (SF10.4): o gate independe da UI (recusa pré-spawn, sem rede).
+// ===========================================================================
+async function backendGateTests() {
+  console.log('\n--- BACKEND: approveRun de SF10.4 é o gate real (independe da UI) ---');
+  const { cfg } = makeFixture();
+  const hash = svc.hashApproverSecret(APPROVER_SECRET);
+  const base = { env: process.env, approverSecretHash: hash, identitiesFile: cfg.identitiesFile };
+  let r = await svc.approveRun(cfg, 'qualquer', { ...base, asId: 'alice', approverSecret: APPROVER_SECRET });
+  assert(r.denied && r.code === 3, 'chamada DIRETA: alice (não-aprovador) + segredo certo → RECUSADO (pré-spawn)');
+  r = await svc.approveRun(cfg, 'qualquer', { ...base, asId: 'daniel', approverSecret: '' });
+  assert(r.denied, 'chamada DIRETA: daniel sem segredo → RECUSADO');
+  r = await svc.approveRun(cfg, 'qualquer', { ...base, asId: 'daniel', approverSecret: 'errado' });
+  assert(r.denied, 'chamada DIRETA: daniel segredo errado → RECUSADO');
+  assert(!/segredo/i.test(JSON.stringify(r).replace(/segredo do aprovador (inválido|ausente)/gi, '')), 'razão de recusa nunca contém o valor do segredo');
+}
+// ---------------------------------------------------------------------------
+(async () => {
+  unitTests();
+  await httpTests();
+  await backendGateTests();
+  console.log(`\n${failures === 0 ? '[SUCESSO]' : '[FALHOU]'} pod-export-ui: ${failures} falha(s).`);
+  process.exit(failures === 0 ? 0 : 1);
+})().catch((e) => { console.error('[ERRO NO TESTE]', e); process.exit(1); });

package/scripts/pod-memory-budget.test.cjs ADDED Viewed

@@ -0,0 +1,309 @@
+#!/usr/bin/env node
+'use strict';
+/**
+ * pod-memory-budget.test.cjs — Story SF11.4 / ADR-022 (DF-SF11.4-1, -2, -3).
+ *
+ * O QUE ESTA SUÍTE PROVA (por execução, nunca por leitura de código):
+ *   AC4  A poda por orçamento FALA: `consolidate()` devolve `evicted` não-vazio,
+ *        `needsCuration === true`, e o RUNNER emite a linha "[memory] AVISO: ..." em
+ *        STDERR nomeando o que saiu. Kill-test junto: com o `evicted` sabotado (código
+ *        pré-SF11.4), a poda volta a ser silenciosa e as asserções ficariam VERMELHAS —
+ *        prova de que a fixture exercita o mecanismo, e não o relato dele.
+ *   AC5  CONTRAPROVA da tabela de 8 promoções do ADR-022 §C4: promovendo heurísticas
+ *        uma a uma sob o código NOVO, `ranked` NÃO caminha para zero e nenhum passo
+ *        descarta em silêncio (sob o código antigo, 8 promoções zeravam a memória ativa
+ *        com `needsCuration:false` em todos os passos).
+ *   AC10 A trilha auditável é append-only DE VERDADE: linha já escrita sobrevive mesmo
+ *        quando o registro-fonte some do log cru.
+ *
+ * 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 mem = require('./pod-memory.cjs');
+const { consolidate, memoryPaths, TOKEN_BUDGET, TOP_N } = mem;
+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, 400)}` : ''}`);
+}
+function tmpPod(label) {
+  const tmp = fs.mkdtempSync(path.join(os.tmpdir(), `sf11.4-${label}-`));
+  const podDir = path.join(tmp, 'p');
+  fs.mkdirSync(path.join(podDir, 'memory'), { recursive: true });
+  return { tmp, podDir };
+}
+/** Heurística longa e determinística — o pool estoura o teto com ~30 delas. */
+function bulky(i, ts) {
+  return {
+    id: `F${i}`,
+    ts,
+    trigger: `heuristica de campo numero ${i} da rodada de producao`,
+    recommendation: `recomendacao verificavel numero ${i} — ${'texto com tamanho realista de heuristica de campo '.repeat(3)}`,
+    evidence: { count: 1 },
+    tier: 'normal',
+  };
+}
+/** Log cru com N heurísticas (ts crescente ⇒ as de índice BAIXO são a cauda podada). */
+function seedPool(podDir, n) {
+  const lines = [];
+  for (let i = 0; i < n; i++) lines.push(JSON.stringify(bulky(i, 1_700_000_000_000 + i * 1000)));
+  fs.writeFileSync(memoryPaths('p', { podDir }).raw, `${lines.join('\n')}\n`);
+}
+// ═══════════════════════════════════════════════════════════════════════════
+// AC4 (parte 1) — o CONTRATO: `evicted` + `needsCuration` na biblioteca
+// ═══════════════════════════════════════════════════════════════════════════
+console.log('--- AC4/DF-SF11.4-2: a poda por orçamento devolve o que descartou ---');
+{
+  const { tmp, podDir } = tmpPod('contrato');
+  seedPool(podDir, 34);
+  const r = consolidate('p', { podDir });
+  ok(`poda ocorreu e é NOMEADA: evicted=${r.evicted.length} (antes deste conserto: nenhum canal)`,
+    Array.isArray(r.evicted) && r.evicted.length > 0, JSON.stringify(r).slice(0, 300));
+  ok('needsCuration LIGA por poda de orçamento (antes era calculado ANTES do while e ficava false)',
+    r.needsCuration === true);
+  ok('o teto continua respeitado (DF-SF11.4-3: poda não foi removida)',
+    r.tokens <= TOKEN_BUDGET, `tokens=${r.tokens}`);
+  ok('cada item de evicted traz trigger/recommendation/score (curadoria sabe O QUE recuperar)',
+    r.evicted.every((e) => typeof e.trigger === 'string' && typeof e.recommendation === 'string' &&
+      typeof e.score === 'number'), JSON.stringify(r.evicted[0]));
+  // a poda corta a CAUDA por score — as descartadas são as de menor score, nunca o topo
+  const md = fs.readFileSync(memoryPaths('p', { podDir }).consolidated, 'utf8');
+  ok('o descartado NÃO está no consolidado e o mantido está (evicted descreve o artefato real)',
+    r.evicted.every((e) => !md.includes(`**[${e.trigger}]**`)) &&
+    md.includes(`**[${bulky(33, 0).trigger}]**`));
+  // SF11.4b/ADR-023 (DF-SF11.4b-1): a conservação passou a ser contra o POOL, não contra
+  // `min(TOP_N, pool)`. Sob a admissão única não existe mais "excedente do TOP_N" fora da
+  // contabilidade: o que o teto de atenção corta entra em `evicted` com `reason:'top_n'`.
+  // Esta linha, no estado SF11.4, provava o defeito de C2 sem perceber — ela fechava a
+  // conta em 30 ignorando exatamente as heurísticas que sumiam caladas.
+  ok('conservação: ranked + evicted = POOL ATIVO — nada some fora da contabilidade',
+    r.topNCount + r.evicted.length === 34,
+    `${r.topNCount} + ${r.evicted.length} (pool 34)`);
+  ok('toda não-admissão tem CAUSA registrada (reason top_n|budget), nenhuma sem classificação',
+    r.evicted.every((e) => e.reason === 'top_n' || e.reason === 'budget'),
+    JSON.stringify(r.evicted.map((e) => e.reason)));
+  // o log cru NUNCA perde a heurística descartada (a substância fica, a injeção sai)
+  const raw = fs.readFileSync(memoryPaths('p', { podDir }).raw, 'utf8');
+  ok('heurística descartada do consolidado PERMANECE no log cru (poda ≠ deleção)',
+    r.evicted.every((e) => raw.includes(e.trigger)));
+  // idempotência: consolidar 2x devolve o mesmo descarte (determinístico)
+  const r2 = consolidate('p', { podDir });
+  ok('determinismo: 2ª consolidação descarta exatamente o mesmo conjunto',
+    JSON.stringify(r2.evicted) === JSON.stringify(r.evicted));
+  fs.rmSync(tmp, { recursive: true, force: true });
+}
+// ═══════════════════════════════════════════════════════════════════════════
+// AC4 (parte 2) — o CANAL: o RUNNER emite o aviso em STDERR (+ kill-test)
+// ═══════════════════════════════════════════════════════════════════════════
+console.log('\n--- AC4: pc-run-pod NÃO descarta mais o retorno de consolidate() ---');
+{
+  const { tmp, podDir } = tmpPod('runner');
+  seedPool(podDir, 34);
+  // Child process: usa o RUNNER REAL (recordLearning), captura stderr de verdade.
+  const child = path.join(tmp, 'run-record.cjs');
+  fs.writeFileSync(child, `
+const runner = require(${JSON.stringify(path.join(__dirname, 'pc-run-pod.cjs'))});
+const podDir = ${JSON.stringify(podDir)};
+const ctx = { state: { pod: 'p' }, podRoot: podDir, memoryPodDir: podDir };
+runner.recordLearning(ctx, {
+  id: 'NOVA', ts: 1_700_000_900_000,
+  trigger: 'aprendizado novo da rodada de producao',
+  recommendation: 'esta heuristica nova entra no consolidado e empurra a cauda para fora do orcamento',
+  evidence: { count: 1 }, tier: 'normal',
+}, { forceConsolidate: true });
+`);
+  const res = spawnSync(process.execPath, [child], { encoding: 'utf8' });
+  ok('runner: recordLearning completa (memória é auxiliar; o aviso não derruba o run)',
+    res.status === 0, res.stderr);
+  // SF11.4b/DF-SF11.4b-1: a linha virou LEDGER — total primeiro, quebra por causa depois.
+  ok('runner: STDERR traz "[memory] AVISO: N heurística(s) NÃO entraram no consolidado"',
+    /\[memory\] AVISO: \d+ heurística\(s\) NÃO entraram no consolidado do pod "p"/.test(res.stderr),
+    res.stderr);
+  ok('runner: a linha traz a QUEBRA por causa (teto de atenção · custo)',
+    /por teto de atenção TOP_N=30/.test(res.stderr) && /de custo \d+ tok/.test(res.stderr), res.stderr);
+  ok('runner: o aviso NOMEIA a heurística que saiu (não é aviso genérico)',
+    /"heuristica de campo numero \d+ da rodada de producao"/.test(res.stderr), res.stderr);
+  ok('runner: o aviso aponta a AÇÃO de curadoria (harden-learning / obsolete)',
+    /cure o consolidado/.test(res.stderr) && /harden-learning/.test(res.stderr), res.stderr);
+  // ── KILL-TEST: com o `evicted` sabotado (código pré-SF11.4), o canal emudece ──
+  // SF11.4b/DF-SF11.4b-1: a âncora migrou para o ponto ÚNICO de registro de não-admissão
+  // (`drop` em `admit`) — sabotá-lo emudece as DUAS vias de uma vez, que é exatamente o
+  // estado pré-SF11.4 (poda por orçamento calada) somado ao pré-SF11.4b (TOP_N mudo).
+  const memSrc = fs.readFileSync(path.join(__dirname, 'pod-memory.cjs'), 'utf8');
+  const anchor = `  const drop = (entry, reason) => {
+    evicted.push({`;
+  ok('kill-test: âncora do registro de não-admissão encontrada em admit()',
+    memSrc.includes(anchor));
+  const sabotaged = memSrc.replace(anchor, `  const drop = (entry, reason) => {
+    void entry; void reason; if (false) evicted.push({`);
+  const sabPath = path.join(tmp, 'pod-memory-sabotada.cjs');
+  fs.writeFileSync(sabPath, sabotaged);
+  const childKill = path.join(tmp, 'run-record-kill.cjs');
+  fs.writeFileSync(childKill, `
+const Module = require('node:module');
+const memPath = require.resolve(${JSON.stringify(path.join(__dirname, 'pod-memory.cjs'))});
+const sab = require(${JSON.stringify(sabPath)});
+require.cache[memPath] = { id: memPath, filename: memPath, loaded: true, exports: sab };
+const runner = require(${JSON.stringify(path.join(__dirname, 'pc-run-pod.cjs'))});
+void Module;
+const podDir = ${JSON.stringify(podDir)};
+const ctx = { state: { pod: 'p' }, podRoot: podDir, memoryPodDir: podDir };
+runner.recordLearning(ctx, {
+  id: 'NOVA2', ts: 1_700_000_950_000,
+  trigger: 'outro aprendizado novo da rodada',
+  recommendation: 'com o evicted sabotado a poda volta a ser silenciosa — nenhum canal acende',
+  evidence: { count: 1 }, tier: 'normal',
+}, { forceConsolidate: true });
+`);
+  const resKill = spawnSync(process.execPath, [childKill], { encoding: 'utf8' });
+  ok('kill-test: SEM o registro de eviction, o runner volta a NÃO avisar nada (defeito reproduzido)',
+    resKill.status === 0 && !/\[memory\] AVISO/.test(resKill.stderr), resKill.stderr);
+  const sabMod = require(sabPath);
+  const sabRes = sabMod.consolidate('p', { podDir });
+  ok('kill-test: e o motor sabotado poda com needsCuration=false — exatamente o defeito de ADR-022 §C4',
+    sabRes.needsCuration === false && sabRes.evicted.length === 0 && sabRes.topNCount < 34,
+    JSON.stringify({ needsCuration: sabRes.needsCuration, evicted: sabRes.evicted.length, topN: sabRes.topNCount }));
+  fs.rmSync(tmp, { recursive: true, force: true });
+}
+// ═══════════════════════════════════════════════════════════════════════════
+// AC5 — CONTRAPROVA da tabela de 8 promoções (ADR-022 §C4) sob o código novo
+// ═══════════════════════════════════════════════════════════════════════════
+console.log('\n--- AC5: promover 8 vezes NÃO caminha para memória ativa zerada ---');
+{
+  const { tmp, podDir } = tmpPod('promocoes');
+  seedPool(podDir, 34);
+  const base = consolidate('p', { podDir });
+  const trail = [{ step: 0, ranked: base.topNCount, hardened: 0, tokens: base.tokens, evicted: base.evicted.length }];
+  let silent = 0;
+  for (let n = 1; n <= 8; n++) {
+    // promove a heurística de MAIOR score ainda ativa (o caminho de SUCESSO do pod:
+    // o dono aprovando aprendizado), exatamente como a tabela do ADR-022 §C4.
+    const c = mem.computeConsolidation('p', { podDir });
+    const target = c.ranked[0];
+    mem.appendHardening('p', {
+      ref: mem.dedupKey(target),
+      target: { kind: 'knowledge', file: 'x.md', sha_before: 'a'.repeat(64), sha_after: 'b'.repeat(64) },
+      approved_by: 'daniel',
+      timestamp: `2026-08-0${n}T00:00:00.000Z`,
+    }, { podDir });
+    const r = consolidate('p', { podDir });
+    if (r.evicted.length > 0 && r.needsCuration !== true) silent += 1;
+    trail.push({ step: n, ranked: r.topNCount, hardened: r.hardenedCount, tokens: r.tokens, evicted: r.evicted.length });
+  }
+  const last = trail[trail.length - 1];
+  console.log(`      trilha: ${trail.map((t) => `${t.ranked}`).join(' → ')} (ranked por promoção)`);
+  ok(`AC5 após 8 promoções a memória ativa NÃO foi zerada (ranked=${last.ranked}, era 0 no código antigo)`,
+    last.ranked > 0, JSON.stringify(trail));
+  ok('AC5 ranked NÃO decresce a cada promoção (promover LIBERA orçamento em vez de consumi-lo)',
+    last.ranked >= trail[0].ranked - 8, JSON.stringify(trail.map((t) => t.ranked)));
+  ok('AC5 nenhum passo podou em SILÊNCIO (evicted>0 sem needsCuration é impossível agora)',
+    silent === 0);
+  ok('AC5 o teto seguiu respeitado em todos os 8 passos',
+    trail.every((t) => t.tokens <= TOKEN_BUDGET), JSON.stringify(trail.map((t) => t.tokens)));
+  fs.rmSync(tmp, { recursive: true, force: true });
+}
+// ═══════════════════════════════════════════════════════════════════════════
+// SF11.4b/AC11 — forge-ingest-memory PARA de descartar o retorno de consolidate()
+// (DEBT-SF11.4b-B, autorizado pelo dono). Execução REAL do script, stderr de verdade:
+// era o 4º e último chamador cego — ingerir conhecimento externo é justamente o ato
+// que empurra a cauda para fora, e ele não via nada sair.
+// ═══════════════════════════════════════════════════════════════════════════
+console.log('\n--- SF11.4b/AC11: o ingest externo vê o que a consolidação deixou de fora ---');
+{
+  const { tmp, podDir } = tmpPod('ingest');
+  seedPool(podDir, 40);
+  const res = spawnSync(process.execPath, [
+    path.join(__dirname, 'forge-ingest-memory.cjs'), podDir,
+    '--source', 'https://exemplo.invalid/artigo',
+    '--trigger', 'gatilho ingerido de fonte externa citada',
+    '--recommendation', 'recomendacao ingerida que passa a competir por slot com as de campo',
+  ], { encoding: 'utf8' });
+  ok('ingest: o comando completa (o aviso não derruba a ingestão, que já foi gravada)',
+    res.status === 0, `${res.status} ${res.stderr}`);
+  ok('ingest: STDOUT confirma a ingestão (contrato do comando intocado)',
+    /^(appended|merged): chave M1 /m.test(res.stdout), res.stdout);
+  ok('ingest: STDERR traz o LEDGER com total + quebra por causa (antes: silêncio absoluto)',
+    /\[memory\] AVISO: \d+ heurística\(s\) NÃO entraram no consolidado/.test(res.stderr) &&
+    /por teto de atenção TOP_N=30/.test(res.stderr), res.stderr);
+  const total = Number((res.stderr.match(/AVISO: (\d+) heurística/) || [])[1]);
+  const md = fs.readFileSync(memoryPaths('_', { podDir }).consolidated, 'utf8');
+  const injetadas = (md.match(/^- \*\*\[/gm) || []).length;
+  ok(`ingest: o número anunciado (${total}) == pool (41) − injetadas (${injetadas}) — contagem independente`,
+    total === 41 - injetadas, `${total} vs ${41 - injetadas}`);
+  fs.rmSync(tmp, { recursive: true, force: true });
+}
+// ═══════════════════════════════════════════════════════════════════════════
+// AC10 — a trilha auditável é append-only por construção
+// ═══════════════════════════════════════════════════════════════════════════
+console.log('\n--- AC10/DF-SF11.4-1: learnings.hardened.md nunca perde uma linha ---');
+{
+  const { tmp, podDir } = tmpPod('trilha');
+  const src = {
+    id: 'H1', ts: 1_700_000_000_000, trigger: 'trigger endurecido',
+    recommendation: 'recomendacao endurecida', evidence: { count: 1 }, tier: 'normal',
+  };
+  mem.append('p', src, { podDir });
+  mem.appendHardening('p', {
+    ref: mem.dedupKey(src),
+    target: { kind: 'knowledge', file: 'slides-html.md', sha_before: 'a'.repeat(64), sha_after: 'b'.repeat(64) },
+    approved_by: 'daniel', timestamp: '2026-08-01T00:00:00.000Z',
+  }, { podDir });
+  consolidate('p', { podDir });
+  const paths = memoryPaths('p', { podDir });
+  const first = fs.readFileSync(paths.hardenedDetail, 'utf8');
+  ok('trilha criada com a linha íntegra (asserção, aprovador, momento)',
+    first.includes('🔒 **[trigger endurecido]** recomendacao endurecida — endurecida → knowledge/slides-html.md _(por daniel, 2026-08-01T00:00:00.000Z)_'),
+    first);
+  ok('consolidado NÃO repete o texto da endurecida (só a referência agregada)',
+    !fs.readFileSync(paths.consolidated, 'utf8').includes('recomendacao endurecida'));
+  consolidate('p', { podDir });
+  ok('idempotência: 2ª consolidação produz a trilha BYTE-IDÊNTICA',
+    fs.readFileSync(paths.hardenedDetail, 'utf8') === first);
+  // pior caso: o log cru perde o registro-fonte (rotação manual/edição) ⇒ a linha FICA
+  fs.writeFileSync(paths.raw, '');
+  consolidate('p', { podDir });
+  const after = fs.readFileSync(paths.hardenedDetail, 'utf8');
+  ok('append-only real: registro-fonte fora do log cru e a linha da trilha PERMANECE',
+    after.includes('🔒 **[trigger endurecido]**') && after.includes('Preservadas'), after);
+  consolidate('p', { podDir });
+  ok('append-only real: preservação é estável (rodar de novo não duplica nem remove)',
+    fs.readFileSync(paths.hardenedDetail, 'utf8') === after);
+  fs.rmSync(tmp, { recursive: true, force: true });
+}
+console.log(`\n${passed}/${passed + failures.length} verificações passaram.`);
+if (failures.length) {
+  console.error('\nSUÍTE SF11.4 (orçamento da memória do pod) FALHOU:');
+  for (const f of failures) console.error(`  - ${f}`);
+  process.exit(1);
+}
+console.log('SF11.4 verde: poda que fala, endurecidas por referência, trilha append-only.');