@daniellins/power-claude 0.16.3

package/scripts/consolidate-knowledge-runner.test.cjs

@@ -0,0 +1,249 @@
+#!/usr/bin/env node
+'use strict';
+/**
+ * consolidate-knowledge-runner.test.cjs — NÃO-REGRESSÃO do `consolidate` para TODOS os
+ * pods (Story SF10.10, AC12 — o achado de MAIOR RAIO DE DANO da story).
+ *
+ * O defeito (verificado por execução ANTES do fix): `renderConsolidated` lia
+ * `h.mark.target.assertion.type` sem guarda. Um registro de hardening com o alvo NOVO
+ * (`kind:'knowledge'`, que não tem `assertion`) fazia `consolidate` LANÇAR
+ * `TypeError: Cannot read properties of undefined (reading 'type')`. E `consolidate`
+ * não roda só na ferramenta: `pc-run-pod.cjs` o chama em TODO run (a cada K=20 appends
+ * e SEMPRE no fechamento limpo). Ou seja: um registro do alvo novo no log envenenava o
+ * RUNTIME de qualquer pod, não a ferramenta de hardening.
+ *
+ * Por isso este teste prova pelo CAMINHO DO RUNNER, não só pela lib:
+ *
+ *   PARTE 1 (produção, sem truque) — `pc-run-pod.cjs` via CLI, run completo sobre um pod
+ *     com registro `kind:'knowledge'` no log: o run completa, NENHUM aviso `[memory]`
+ *     sai no stderr, e o consolidado EM DISCO ganha a linha 🔒 do knowledge.
+ *     A 3ª asserção é o que impede fake-green: o runner engole exceção de memória em
+ *     `recordLearning` (aviso em stderr, run segue). "Completou" sozinho NÃO prova nada —
+ *     só o consolidado escrito prova que `consolidate` foi até o fim.
+ *
+ *   PARTE 2 (kill-test) — o MESMO fixture, o MESMO runner, com uma cópia SABOTADA de
+ *     pod-memory.cjs (o ramo por `kind` revertido para o código pré-fix) injetada no
+ *     require.cache: o runner passa a emitir o aviso `[memory]` com o TypeError e o
+ *     consolidado NÃO recebe a linha 🔒 — exatamente as asserções da Parte 1 ficando
+ *     vermelhas. Prova que a Parte 1 exercita o mecanismo, e não uma tautologia.
+ *
+ * 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 { spawnSync } = require('node:child_process');
+
+const REPO = path.resolve(__dirname, '..');
+const RUNNER = path.join(REPO, 'scripts', 'pc-run-pod.cjs');
+const FIXT = path.join(REPO, 'scripts', '__fixtures__', 'pod-run');
+
+let passed = 0;
+const failures = [];
+function check(cond, label, extra) {
+  if (cond) { passed++; console.log(`[OK   ] ${label}`); }
+  else { failures.push(label); console.log(`[FALHA] ${label}${extra ? `\n        ${extra}` : ''}`); }
+}
+
+const BUILD_OK = '## Escopo\n## Contexto\nstatus: rascunho\n';
+const GATE_OK = '## Veredito\nveredito: GO\n';
+const FINAL_OK = '## Escopo\n## Contexto\nconfianca: alta\n';
+const ARTIFACTS = { build: BUILD_OK, gate: GATE_OK, finalize: FINAL_OK };
+
+const TRIGGER = 'slides sem riqueza grafica';
+const RECOMMENDATION = 'usar blocos visuais com hierarquia tipografica no lugar de texto corrido';
+const KNOWLEDGE_FILE = 'slides-html.md';
+const SHA_A = 'a'.repeat(64);
+const SHA_B = 'b'.repeat(64);
+
+/**
+ * Pod temporário (cópia do fixture do runner) com a heurística no log cru E o registro
+ * de hardening do alvo NOVO — o registro que, sem o fix, derruba `consolidate`.
+ * O registro é plantado como TEXTO (não via appendHardening) de propósito: o teste
+ * simula um log que já existe em disco, independente do escritor.
+ */
+function makePod(label) {
+  const tmp = fs.mkdtempSync(path.join(os.tmpdir(), `sf10.10-${label}-`));
+  const podDir = path.join(tmp, 'pod');
+  fs.cpSync(FIXT, podDir, { recursive: true });
+  fs.rmSync(path.join(podDir, 'memory'), { recursive: true, force: true });
+  fs.mkdirSync(path.join(podDir, 'memory'), { recursive: true });
+  const lines = [
+    JSON.stringify({
+      id: 'src-1', ts: 1_700_000_000_000, trigger: TRIGGER, recommendation: RECOMMENDATION,
+      evidence: { count: 2 }, tier: 'normal', attributed_by: null, source_run_id: 'r1',
+    }),
+    JSON.stringify({
+      type: 'hardening',
+      ref: `${TRIGGER}||${RECOMMENDATION}`,
+      target: { pod: 'test-pod', kind: 'knowledge', file: KNOWLEDGE_FILE, sha_before: SHA_A, sha_after: SHA_B },
+      approved_by: 'daniel',
+      timestamp: '2026-08-01T00:00:00.000Z',
+    }),
+  ];
+  fs.writeFileSync(path.join(podDir, 'memory', 'learnings.jsonl'), `${lines.join('\n')}\n`);
+  return { tmp, podDir, runsRoot: path.join(tmp, 'runs') };
+}
+
+const HARDENED_LINE = `🔒 **[${TRIGGER}]**`;
+const KNOWLEDGE_MARK = `endurecida → knowledge/${KNOWLEDGE_FILE}`;
+
+function consolidatedOf(podDir) {
+  const p = path.join(podDir, 'memory', 'learnings.consolidated.md');
+  return fs.existsSync(p) ? fs.readFileSync(p, 'utf8') : '';
+}
+
+// SF11.4/ADR-022 (DF-SF11.4-1): o DETALHE da endurecida saiu do artefato injetado e
+// passou a viver na trilha auditável. A prova de que `consolidate` foi ATÉ O FIM dentro
+// do runner (o ponto desta suíte) migra junto — o writeFileSync da trilha é posterior ao
+// do consolidado, então é o teste mais estrito de "não lançou no meio do caminho".
+function hardenedDetailOf(podDir) {
+  const p = path.join(podDir, 'memory', 'learnings.hardened.md');
+  return fs.existsSync(p) ? fs.readFileSync(p, 'utf8') : '';
+}
+
+// ═══════════════════════════════════════════════════════════════════════════
+// PARTE 1 — caminho REAL do runner (subprocesso, produção, zero truque)
+// ═══════════════════════════════════════════════════════════════════════════
+console.log('\n--- PARTE 1: run completo pelo pc-run-pod.cjs (CLI) com registro kind:"knowledge" no log ---');
+{
+  const { tmp, podDir, runsRoot } = makePod('runner');
+  const wf = path.join(podDir, 'workflows', 'wf-min.yaml');
+  const stderrChunks = [];
+  const cli = (args) => {
+    const r = spawnSync(process.execPath, [RUNNER, ...args], { encoding: 'utf8', cwd: REPO });
+    stderrChunks.push(r.stderr || '');
+    return r;
+  };
+
+  const start = cli(['start', 'test-pod', 'wf-min', '--workflow-file', wf, '--pod-root', podDir, '--runs-root', runsRoot]);
+  check(start.status === 0, 'runner: start exit 0', `${start.stdout}${start.stderr}`);
+  const statePath = (start.stdout.match(/→ (.+state\.json)/) || [])[1];
+  check(!!statePath && fs.existsSync(statePath), 'runner: state.json criado');
+
+  // Dirige o run até o fechamento limpo (o ponto que SEMPRE chama consolidate).
+  let guard = 0;
+  let completed = false;
+  while (guard++ < 12 && !completed) {
+    const state = JSON.parse(fs.readFileSync(statePath, 'utf8'));
+    const runDir = path.dirname(statePath);
+    // planta o artefato de cada etapa despachada (simula o subagente)
+    for (const [id, s] of Object.entries(state.steps)) {
+      if (s.artifact && ARTIFACTS[id]) {
+        const abs = path.resolve(runDir, s.artifact);
+        if (!fs.existsSync(abs)) {
+          fs.mkdirSync(path.dirname(abs), { recursive: true });
+          fs.writeFileSync(abs, ARTIFACTS[id], 'utf8');
+        }
+      }
+    }
+    const awaiting = Object.entries(state.steps).find(([, s]) => s.status === 'awaiting_approval');
+    const cmd = awaiting ? ['approve', '--step', awaiting[0]] : ['next'];
+    const r = cli([...cmd, '--state', statePath, '--workflow-file', wf, '--pod-root', podDir]);
+    if (r.status !== 0) { check(false, `runner: comando ${cmd[0]} exit 0`, `${r.stdout}${r.stderr}`); break; }
+    if (/\[complete\]/.test(r.stdout)) completed = true;
+  }
+  check(completed, 'runner: workflow chegou a [complete] (fechamento limpo ⇒ consolidate SEMPRE dispara)');
+
+  const stderrAll = stderrChunks.join('');
+  check(!/\[memory\]/.test(stderrAll),
+    'runner: NENHUM aviso "[memory]" no stderr (consolidate não lançou em nenhum ponto do run)',
+    stderrAll.slice(0, 400));
+
+  // A prova que não é fake-green: o consolidado EM DISCO tem a linha do alvo novo.
+  // Sem o fix, consolidate lança ANTES do writeFileSync — este arquivo não conteria
+  // a seção 🔒 (o runner engole a exceção e o run "completa" mesmo assim).
+  const md = consolidatedOf(podDir);
+  const detail = hardenedDetailOf(podDir);
+  check(md.includes('## Endurecidas (🔒 → enforcement)') && md.includes(`knowledge/${KNOWLEDGE_FILE} (1)`) &&
+    detail.includes(HARDENED_LINE) && detail.includes(KNOWLEDGE_MARK),
+    'runner: consolidado ESCRITO com a referência agregada + trilha com a linha 🔒 → knowledge/<file> (consolidate foi até o fim dentro do runner)',
+    `${md.slice(0, 300)}\n---TRILHA---\n${detail.slice(0, 300)}`);
+  check(!md.split('## Endurecidas')[0].includes(`**[${TRIGGER}]**`),
+    'runner: heurística endurecida DEMOVIDA do top-N ativo também no alvo knowledge');
+  check(!/undefined/.test(md), 'runner: linha do alvo knowledge sem "undefined" (ramo correto, não o ramo veto)');
+
+  fs.rmSync(tmp, { recursive: true, force: true });
+}
+
+// ═══════════════════════════════════════════════════════════════════════════
+// PARTE 2 — KILL-TEST: mesmo runner, pod-memory SABOTADA (código pré-fix)
+// ═══════════════════════════════════════════════════════════════════════════
+console.log('\n--- PARTE 2: kill-test — o mesmo fixture com o ramo por `kind` revertido ---');
+{
+  const { tmp, podDir, runsRoot } = makePod('kill');
+  const wf = path.join(podDir, 'workflows', 'wf-min.yaml');
+
+  // Sabotagem: substitui o ramo por `kind` pela linha EXATA do código pré-SF10.10.
+  const memSrc = fs.readFileSync(path.join(__dirname, 'pod-memory.cjs'), 'utf8');
+  // SF11.4: o ramo por `kind` foi extraído para hardeningTargetLabel (fonte ÚNICA do
+  // rótulo, usada pela referência agregada E pela trilha) — a âncora acompanha o código.
+  const anchor = '  const t = (h.mark && h.mark.target) || {};\n  const kind = hardeningKind(t);';
+  check(memSrc.includes(anchor), 'kill-test: âncora do ramo por `kind` encontrada em hardeningTargetLabel');
+  const sabotaged = memSrc.replace(anchor, '  const t = h.mark.target;\n  const kind = t.assertion.type && "veto";');
+  check(sabotaged !== memSrc, 'kill-test: sabotagem aplicada (volta a ler target.assertion.type sem guarda)');
+  const sabPath = path.join(tmp, 'pod-memory-sabotada.cjs');
+  fs.writeFileSync(sabPath, sabotaged);
+
+  // Injeta a cópia sabotada no lugar de ./pod-memory.cjs e recarrega o runner REAL.
+  const memResolved = require.resolve('./pod-memory.cjs');
+  const runnerResolved = require.resolve('./pc-run-pod.cjs');
+  const memBackup = require.cache[memResolved];
+  delete require.cache[runnerResolved];
+  require.cache[memResolved] = { id: memResolved, filename: memResolved, loaded: true, exports: require(sabPath) };
+  let R;
+  const warnings = [];
+  const realErr = console.error;
+  try {
+    R = require(runnerResolved);
+    console.error = (...a) => { warnings.push(a.join(' ')); };
+    // mesmo run, in-process (o runner é o de produção; só a memória foi sabotada)
+    const { ctx } = R.startRun({
+      workflowPath: wf, podRootOverride: podDir, pod: 'test-pod', workflow: 'wf-min',
+      mode: 'interactive', taskRef: 'kill-test', runsRoot,
+    });
+    let guard = 0;
+    let done = false;
+    while (guard++ < 12 && !done) {
+      const runDir = ctx.runDir;
+      for (const [id, s] of Object.entries(ctx.state.steps)) {
+        if (s.artifact && ARTIFACTS[id]) {
+          const abs = path.resolve(runDir, s.artifact);
+          if (!fs.existsSync(abs)) {
+            fs.mkdirSync(path.dirname(abs), { recursive: true });
+            fs.writeFileSync(abs, ARTIFACTS[id], 'utf8');
+          }
+        }
+      }
+      const awaiting = Object.entries(ctx.state.steps).find(([, s]) => s.status === 'awaiting_approval');
+      const r = awaiting ? R.approve(ctx, awaiting[0]) : R.advance(ctx);
+      if (r.action === 'complete') done = true;
+    }
+    check(done, 'kill-test: o run SABOTADO também "completa" — prova de que "completou" NÃO é evidência');
+  } finally {
+    console.error = realErr;
+    if (memBackup) require.cache[memResolved] = memBackup; else delete require.cache[memResolved];
+    delete require.cache[runnerResolved];
+  }
+
+  const warned = warnings.join('\n');
+  check(/\[memory\]/.test(warned) && /Cannot read properties of undefined/.test(warned),
+    'kill-test: SEM o ramo por `kind`, o runner emite "[memory] aviso ... TypeError" (defeito reproduzido)',
+    warned.slice(0, 300));
+  const md = consolidatedOf(podDir);
+  check(!md.includes(`knowledge/${KNOWLEDGE_FILE} (1)`) && !hardenedDetailOf(podDir).includes(KNOWLEDGE_MARK),
+    'kill-test: e nem o consolidado nem a trilha recebem o alvo knowledge (a asserção da Parte 1 ficaria VERMELHA)',
+    md.slice(0, 200));
+
+  fs.rmSync(tmp, { recursive: true, force: true });
+}
+
+console.log(`\n${passed}/${passed + failures.length} verificações passaram.`);
+if (failures.length) {
+  console.error('\nSUÍTE AC12 (não-regressão do consolidate pelo caminho do runner) FALHOU:');
+  for (const f of failures) console.error(`  - ${f}`);
+  process.exit(1);
+}
+console.log('AC12 verde: registro kind:"knowledge" no log NÃO quebra consolidate — provado pelo runner, não só pela lib.');
+process.exit(0);

package/scripts/default-funcional.test.cjs

@@ -0,0 +1,153 @@
+#!/usr/bin/env node
+'use strict';
+/**
+ * default-funcional.test.cjs — AC13 da Story SF12.1 (ADR-027 Decisão 5, DF-SF12.1-7/-20).
+ *
+ * "Personalização é opcional" deixa de ser promessa de README e vira requisito
+ * VERIFICÁVEL — com DUAS pré-condições distintas, porque os pods NÃO são iguais:
+ *
+ *   (a) PODS DE MÉTODO  (`dev-ia`, `automation`, `hormozi-method`)
+ *       A saída não depende de quem é o dono. Pré-condição: ZERO dado de dono na
+ *       árvore do pod. Gate: `validate-budgets` + canário verdes.
+ *
+ *   (b) PODS DE IDENTIDADE (`content-carousel`, `authority-content`, `academy`,
+ *       `squad-forge`) — a saída é assinada. Pré-condição: verdes com APENAS o
+ *       TRIO DE ATRIBUIÇÃO (nome/handle/autoridade) fornecido como dado de rodada,
+ *       e NENHUM dado de voz/DNA. É o que `wf-content-carousel.smoke.json` já faz
+ *       com a identidade fictícia canônica.
+ *
+ * A distinção é proposital e fina (ADR-027 Decisão 5): nenhum gate pode exigir
+ * dado de COMPORTAMENTO/ESTILO — nunca, em pod nenhum. Um gate PODE exigir dado de
+ * ATRIBUIÇÃO quando o entregável é assinado, porque a alternativa seria publicar
+ * uma assinatura fabricada: dano externo e irreversível, pior que um bloqueio.
+ *
+ * ALCANCE DECLARADO, e este limite é intransponível: isto prova que o pipeline
+ * RODA sem personalização. NÃO prova que a saída é BOA — qualidade de saída é
+ * julgamento humano, sem oráculo de máquina (fronteira ADR-002). Nenhuma asserção
+ * abaixo afirma o contrário.
+ *
+ * Node >= 18, zero dependências. Exit 0/1.
+ */
+
+const fs = require('node:fs');
+const path = require('node:path');
+const { execFileSync } = require('node:child_process');
+
+const OL = require('./owner-layer.cjs');
+const { parseYaml } = require('./validate-pod-workflow.cjs');
+
+const REPO_ROOT = path.resolve(__dirname, '..');
+const PODS = path.join(REPO_ROOT, 'template', 'pods');
+
+let passed = 0;
+const failures = [];
+function ok(cond, label) {
+  if (cond) { passed++; console.log(`[OK   ] ${label}`); }
+  else { failures.push(label); console.log(`[FALHA] ${label}`); }
+}
+
+const METODO = ['dev-ia', 'automation', 'hormozi-method'];
+const IDENTIDADE = ['content-carousel', 'authority-content', 'academy', 'squad-forge'];
+
+// Marcas de dado de dono que um pod poderia consumir. Não é heurística semântica:
+// é a lista dos nomes de arquivo/campo que o framework de fato usa.
+const MARCAS_DE_DONO = ['dono.yaml', 'dono.example', 'voice-dna', 'voice_dna'];
+
+function walk(dir) {
+  const out = [];
+  for (const e of fs.readdirSync(dir, { withFileTypes: true })) {
+    const p = path.join(dir, e.name);
+    if (e.isDirectory()) out.push(...walk(p));
+    else if (e.isFile()) out.push(p);
+  }
+  return out;
+}
+
+// ===========================================================================
+// Sanidade da classificação — se um pod nasce/some, esta suíte precisa falhar
+// alto em vez de validar uma lista obsoleta em silêncio.
+// ===========================================================================
+const podsEmDisco = fs.readdirSync(PODS, { withFileTypes: true })
+  .filter((e) => e.isDirectory()).map((e) => e.name).sort();
+const classificados = METODO.concat(IDENTIDADE).sort();
+ok(podsEmDisco.length === classificados.length && podsEmDisco.every((p, i) => p === classificados[i]),
+  `AC13 — a classificação cobre TODOS os pods do template (disco: ${podsEmDisco.join(', ')})`);
+
+// ===========================================================================
+// (a) PODS DE MÉTODO — zero dado de dono na árvore.
+// ===========================================================================
+for (const pod of METODO) {
+  const arquivos = walk(path.join(PODS, pod));
+  const hits = [];
+  for (const f of arquivos) {
+    const buf = fs.readFileSync(f);
+    if (buf.subarray(0, 8000).includes(0)) continue;
+    const txt = buf.toString('utf8');
+    for (const marca of MARCAS_DE_DONO) {
+      if (txt.includes(marca)) hits.push(`${path.relative(REPO_ROOT, f)} → "${marca}"`);
+    }
+  }
+  ok(hits.length === 0,
+    `AC13(a) — pod de método \`${pod}\`: ZERO dado de dono em ${arquivos.length} arquivos${hits.length ? `\n         ${hits.join('\n         ')}` : ''}`);
+}
+
+// ===========================================================================
+// (b) PODS DE IDENTIDADE — o trio de atribuição, e SÓ ele, como dado de rodada.
+//
+// O canário do `content-carousel` é o caso executável: o cenário de smoke fornece
+// nome + handle + remissão de autoridade (a assinatura do CTA) e NADA de voz.
+// ===========================================================================
+const smokePath = path.join(PODS, 'content-carousel', 'workflows', 'wf-content-carousel.smoke.json');
+const smoke = JSON.parse(fs.readFileSync(smokePath, 'utf8'));
+const smokeTexto = JSON.stringify(smoke);
+
+ok(smokeTexto.includes(OL.FICTIONAL_IDENTITY.nome) && smokeTexto.includes(OL.FICTIONAL_IDENTITY.handle),
+  `AC13(b) — o cenário de smoke fornece o TRIO por dado de rodada (${OL.FICTIONAL_IDENTITY.nome} / ${OL.FICTIONAL_IDENTITY.handle} + remissão de autoridade)`);
+ok(/autoridade/i.test(smokeTexto),
+  'AC13(b) — a 3ª parte do trio (linha de autoridade) está no cenário, não num arquivo de configuração');
+ok(MARCAS_DE_DONO.every((m) => !smokeTexto.includes(m)),
+  'AC13(b) — o cenário NÃO carrega dado de voz/DNA: o pipeline roda com atribuição e nada mais');
+
+// Nenhuma instância de dono existe na árvore distribuída — só o `.example.`.
+const instanciasDeDono = [];
+for (const pod of METODO.concat(IDENTIDADE)) {
+  const dir = path.join(PODS, pod, 'knowledge');
+  if (!fs.existsSync(dir)) continue;
+  for (const f of fs.readdirSync(dir)) {
+    if (/^dono.*\.yaml$/.test(f) && !/\.example\./.test(f)) instanciasDeDono.push(`${pod}/knowledge/${f}`);
+  }
+}
+ok(instanciasDeDono.length === 0,
+  `AC13 — nenhuma INSTÂNCIA de dono na árvore do template (só \`.example.\`)${instanciasDeDono.length ? `: ${instanciasDeDono.join(', ')}` : ''}`);
+ok(!fs.existsSync(path.join(REPO_ROOT, 'template', 'knowledge', 'voice-dna', 'voice-dna.yaml')),
+  'AC13 — nenhuma INSTÂNCIA de voice-dna na árvore do template');
+
+// O placeholder do degrau 2 carrega o trio, e o trio é a ÚNICA exigência possível.
+const donoExample = parseYaml(fs.readFileSync(
+  path.join(PODS, 'content-carousel', 'knowledge', 'dono.example.yaml'), 'utf8'));
+ok(donoExample.dono && ['nome', 'handle', 'autoridade'].every((k) => k in donoExample.dono),
+  'AC13 — `dono.example.yaml` declara o trio de atribuição (nome/handle/autoridade)');
+ok(donoExample.dono.voz && typeof donoExample.dono.voz === 'object',
+  'AC13 — os campos de VOZ existem como opcionais no mesmo arquivo (degrau 2), separados do trio');
+
+// ===========================================================================
+// OS DOIS GATES, EXECUTADOS AQUI — o oráculo do AC13 é o exit code deles.
+// ===========================================================================
+function gate(label, cmd, args) {
+  let code = 0;
+  try {
+    execFileSync(cmd, args, { cwd: REPO_ROOT, stdio: ['ignore', 'pipe', 'pipe'] });
+  } catch (e) {
+    code = typeof e.status === 'number' ? e.status : 1;
+  }
+  ok(code === 0, `AC13 — gate \`${label}\` com a árvore SEM personalização: exit ${code}`);
+}
+gate('validate-budgets (forma canônica de npm run validate)',
+  'node', ['scripts/validate-budgets.js', 'template/pods', 'template/.claude/agents']);
+gate('canário (smoke-pod-workflow)',
+  'node', ['scripts/smoke-pod-workflow.cjs', 'scripts/__fixtures__/smoke-canary/workflows/wf-canary.yaml']);
+
+// ===========================================================================
+console.log(`\n${failures.length === 0 ? 'PASS' : 'FAIL'} — ${passed} asserções OK, ${failures.length} falha(s)`);
+if (failures.length > 0) for (const f of failures) console.error(`  ✗ ${f}`);
+process.exit(failures.length === 0 ? 0 : 1);