@daniellins/power-claude 0.16.3

package/scripts/veto-checks.test.cjs

@@ -0,0 +1,219 @@
+#!/usr/bin/env node
+'use strict';
+/**
+ * veto-checks.test.cjs — suíte da 6ª forma de veto `command_check` + `json_schema_valid`
+ * com `extract` (Story SF7.2, ADR-011). Prova:
+ *  (AC5) os 4 casos motivadores, cada um com prova POSITIVA e NEGATIVA sobre artefato
+ *        realista: (a) render-gate (headless, fail-loud se ausente), (b) lexical anti-IA
+ *        (Node puro), (c) json_schema_valid+extract (N8N — não command_check), (d) HTML.
+ *  (AC12) modelo de ameaça: runner/validador executam SÓ scripts blessed sob
+ *        scripts/veto-checks/ — traversal / fora-da-whitelist / args interpoláveis = recusa.
+ *  (AC2)  evalVeto executa via execFileSync sem shell, exit code como veredito; caminho extract.
+ *  (AC3)  sweep de command_check por fixture de violação; ausente = underivável fail-loud.
+ *  (AC4)  serializeAssertion emite args (lista) e extract (mapa) e faz roundtrip por parseYaml.
+ *
+ * Node >= 18. Exit 0/1.
+ */
+
+const fs = require('node:fs');
+const os = require('node:os');
+const path = require('node:path');
+
+const rp = require('./pc-run-pod.cjs');
+const vp = require('./validate-pod-workflow.cjs');
+const fg = require('./forge-generate.cjs');
+const smoke = require('./smoke-pod-workflow.cjs');
+const lexical = require('./veto-checks/lexical-check.cjs');
+const html = require('./veto-checks/html-valid.cjs');
+const render = require('./veto-checks/render-gate.cjs');
+
+const REPO_ROOT = path.resolve(__dirname, '..');
+const FIX = path.join(__dirname, '__fixtures__', 'veto-checks');
+
+let passed = 0;
+const failures = [];
+function ok(cond, label) {
+  if (cond) { passed++; console.log(`[OK   ] ${label}`); }
+  else { failures.push(label); console.error(`[FALHA] ${label}`); }
+}
+function throwsFail(fn) {
+  try { fn(); return false; } catch (e) { if (e instanceof vp.Fail) return true; throw e; }
+}
+const ctx = { podRoot: FIX, runDir: FIX };
+const cc = (command, args, artifact) => rp.evalVeto(
+  { type: 'command_check', command, args }, '', path.join(FIX, artifact), ctx,
+);
+
+// ===========================================================================
+// (b) lexical anti-IA — Node puro (AC5b)
+// ===========================================================================
+console.log('--- (b) lexical anti-IA ---');
+ok(lexical.countMatches('a — b – c', '[\\u2014\\u2013]') === 2, 'countMatches conta em/en-dash');
+ok(cc('lexical-check.cjs', ['--max', '0'], 'copy-clean.md').ok === true, 'lexical: copy limpa PASSA');
+ok(cc('lexical-check.cjs', ['--max', '0'], 'copy-dashes.md').ok === false, 'lexical: copy com travessões BLOQUEIA');
+
+// ===========================================================================
+// (d) HTML balance + tag exigida — Node puro (AC5d)
+// ===========================================================================
+console.log('--- (d) HTML válido ---');
+ok(html.checkBalance('<div><p>x</p></div>').ok === true, 'checkBalance: balanceado OK');
+ok(html.checkBalance('<div><p>x</div>').ok === false, 'checkBalance: desbalanceado detecta');
+ok(cc('html-valid.cjs', ['--require', 'title'], 'slide-ok.html').ok === true, 'html: slide-ok (balanceado + title) PASSA');
+ok(cc('html-valid.cjs', [], 'page-bad.html').ok === false, 'html: page-bad (desbalanceado) BLOQUEIA');
+
+// ===========================================================================
+// (c) json_schema_valid + extract — N8N, IN-PROCESS (AC5c; fecha CONCERNS-1 SF6.3)
+// ===========================================================================
+console.log('--- (c) json_schema_valid + extract (N8N) ---');
+const n8nAssert = { type: 'json_schema_valid', schema: 'nodes,connections', extract: { section: '## Workflow JSON', fence: 'json' } };
+const n8nOk = fs.readFileSync(path.join(FIX, 'n8n-ok.md'), 'utf8');
+const n8nBad = fs.readFileSync(path.join(FIX, 'n8n-bad.md'), 'utf8');
+ok(rp.evalVeto(n8nAssert, n8nOk, 'x', ctx).ok === true, 'extract: N8N JSON com nodes+connections PASSA');
+ok(rp.evalVeto(n8nAssert, n8nBad, 'x', ctx).ok === false, 'extract: N8N JSON sem connections BLOQUEIA (CONCERNS-1 fechado na forma)');
+ok(rp.extractFencedBlock(n8nOk, '## Workflow JSON', 'json').includes('"connections"'), 'extractFencedBlock extrai só o bloco da seção declarada');
+// sem extract, o artefato .md inteiro não é JSON → bloqueia (comportamento legado preservado)
+ok(rp.evalVeto({ type: 'json_schema_valid', schema: 'nodes' }, n8nOk, 'x', ctx).ok === false, 'sem extract: .md inteiro não é JSON (legado preservado)');
+
+// ===========================================================================
+// (a) render-gate — headless, FAIL-LOUD se ausente (AC5a)
+// ===========================================================================
+console.log('--- (a) render-gate ---');
+ok(render.decideFromDom('<html data-render-gate="OK">').ok === true, 'decideFromDom: OK → passa');
+ok(render.decideFromDom('<html data-render-gate="OVERFLOW">').ok === false, 'decideFromDom: OVERFLOW → bloqueia');
+ok(render.decideFromDom('<html>').ok === false, 'decideFromDom: sem marcador → bloqueia (não green-fake)');
+// FAIL-LOUD: CHROME_BIN inválido é honrado estritamente → probe null → exit não-zero.
+{
+  const saved = process.env.CHROME_BIN;
+  process.env.CHROME_BIN = '/nao/existe/chrome-xyz';
+  const r = cc('render-gate.cjs', [], 'slide-ok.html');
+  ok(r.ok === false && /exit 3|Chrome/i.test(r.reason), 'render-gate: Chrome ausente → FAIL-LOUD (bloqueia, nunca skip)');
+  if (saved === undefined) delete process.env.CHROME_BIN; else process.env.CHROME_BIN = saved;
+}
+// Se há Chrome no ambiente, prova positiva/negativa reais; senão, registra skip honesto.
+if (render.probeChrome()) {
+  ok(cc('render-gate.cjs', [], 'slide-ok.html').ok === true, 'render-gate: slide-ok (cabe) PASSA [Chrome real]');
+  ok(cc('render-gate.cjs', [], 'slide-overflow.html').ok === false, 'render-gate: slide-overflow (corte) BLOQUEIA [Chrome real]');
+} else {
+  console.log('[SKIP ] render-gate pos/neg: headless Chrome ausente neste ambiente (fail-loud já provado; end-to-end roda no CI com Chrome)');
+}
+
+// ===========================================================================
+// (AC12) modelo de ameaça — só scripts BLESSED, recusa fail-loud
+// ===========================================================================
+console.log('--- (AC12) whitelist / modelo de ameaça ---');
+ok(throwsFail(() => vp.checkCommandCheckSafety({ command: '../../etc/passwd' })), 'estático: path traversal RECUSADO');
+ok(throwsFail(() => vp.checkCommandCheckSafety({ command: 'scripts/evil.cjs' })), 'estático: caminho (não nome simples) RECUSADO');
+ok(throwsFail(() => vp.checkCommandCheckSafety({ command: 'nao-blessed.cjs' })), 'estático: script fora de veto-checks/ RECUSADO');
+ok(throwsFail(() => vp.checkCommandCheckSafety({ command: 'lexical-check.cjs', args: ['$(rm -rf /)'] })), 'estático: arg com interpolação/shell RECUSADO');
+ok(throwsFail(() => vp.checkCommandCheckSafety({ command: 'lexical-check.cjs', args: [42] })), 'estático: arg não-literal (número) RECUSADO');
+ok(!throwsFail(() => vp.checkCommandCheckSafety({ command: 'lexical-check.cjs', args: ['--max', '0'] })), 'estático: blessed + args literais ACEITO');
+// runtime (defesa em profundidade): evalVeto recusa comando fora da raiz blessed sem executar
+ok(rp.evalVeto({ type: 'command_check', command: '../smoke-pod-workflow.cjs' }, '', path.join(FIX, 'copy-clean.md'), ctx).ok === false,
+  'runtime: evalVeto recusa comando fora da raiz blessed (defesa em profundidade)');
+// ISOLANTE do guard B realpath (SF7.2 CONCERNS-1): um symlink de NOME BLESSED dentro de
+// scripts/veto-checks/ apontando para um script-sentinela FORA passa o estático (nome blessed,
+// dirname lexical == raiz) — só o realpathSync o pega. Sabotar o realpath faz esta asserção
+// ficar VERMELHA (a sentinela seria executada). Restaura o arquivo real em finally.
+{
+  const VC = path.join(REPO_ROOT, 'scripts', 'veto-checks');
+  const blessedReal = path.join(VC, 'lexical-check.cjs');
+  const backup = fs.readFileSync(blessedReal);
+  const d = fs.mkdtempSync(path.join(os.tmpdir(), 'sf72-symlink-'));
+  const sentinelFlag = path.join(d, 'EXECUTED');
+  const evil = path.join(d, 'evil-sentinel.cjs');
+  fs.writeFileSync(evil, `require('node:fs').writeFileSync(${JSON.stringify(sentinelFlag)}, 'x'); process.exit(0);`);
+  let refused = false;
+  let executed = true;
+  try {
+    fs.unlinkSync(blessedReal);
+    fs.symlinkSync(evil, blessedReal); // symlink de nome BLESSED → alvo externo
+    const r = rp.evalVeto({ type: 'command_check', command: 'lexical-check.cjs' }, '', path.join(FIX, 'copy-clean.md'), ctx);
+    refused = r.ok === false && /realpath/i.test(r.reason || '');
+    executed = fs.existsSync(sentinelFlag);
+  } finally {
+    try { fs.unlinkSync(blessedReal); } catch { /* ok */ }
+    fs.writeFileSync(blessedReal, backup); // restaura o arquivo real byte-idêntico
+  }
+  ok(refused && !executed,
+    'runtime ISOLADO: symlink de nome blessed → alvo externo é RECUSADO por realpath, sentinela NUNCA executada (fura o guard B se removido)');
+}
+// SF10.8 — a MESMA fronteira aplicada ao 4º blessed (`phash-gate.cjs`, veto de não-cópia):
+// nenhuma exceção foi criada para ele (AC2). Estático + runtime + o isolante do guard B.
+ok(!throwsFail(() => vp.checkCommandCheckSafety({ command: 'phash-gate.cjs', args: ['--refs-dir', '../inputs', '--assets-dir', '../assets'] })),
+  'phash-gate: blessed + args literais ACEITO (mesma porta dos 3 anteriores)');
+ok(throwsFail(() => vp.checkCommandCheckSafety({ command: '../veto-checks/phash-gate.cjs' })), 'phash-gate: traversal no nome RECUSADO');
+ok(throwsFail(() => vp.checkCommandCheckSafety({ command: 'phash-gate-fake.cjs' })), 'phash-gate: vizinho não-blessed RECUSADO');
+ok(throwsFail(() => vp.checkCommandCheckSafety({ command: 'phash-gate.cjs', args: ['--refs-dir', '{{run.inputs_dir}}'] })),
+  'phash-gate: arg INTERPOLADO com dado de run RECUSADO (ADR-011 preservado — a referência nunca vira arg dinâmico)');
+ok(rp.evalVeto({ type: 'command_check', command: '../veto-checks/phash-gate.cjs' }, '', path.join(FIX, 'copy-clean.md'), ctx).ok === false,
+  'phash-gate: runtime recusa a forma com caminho, sem executar');
+{
+  const VC = path.join(REPO_ROOT, 'scripts', 'veto-checks');
+  const blessedReal = path.join(VC, 'phash-gate.cjs');
+  const backup = fs.readFileSync(blessedReal);
+  const d = fs.mkdtempSync(path.join(os.tmpdir(), 'sf108-symlink-'));
+  const sentinelFlag = path.join(d, 'EXECUTED');
+  const evil = path.join(d, 'evil-sentinel.cjs');
+  fs.writeFileSync(evil, `require('node:fs').writeFileSync(${JSON.stringify(sentinelFlag)}, 'x'); process.exit(0);`);
+  let refused = false;
+  let executed = true;
+  try {
+    fs.unlinkSync(blessedReal);
+    fs.symlinkSync(evil, blessedReal);
+    const r = rp.evalVeto({ type: 'command_check', command: 'phash-gate.cjs' }, '', path.join(FIX, 'copy-clean.md'), ctx);
+    refused = r.ok === false && /realpath/i.test(r.reason || '');
+    executed = fs.existsSync(sentinelFlag);
+  } finally {
+    try { fs.unlinkSync(blessedReal); } catch { /* ok */ }
+    fs.writeFileSync(blessedReal, backup);
+  }
+  ok(refused && !executed, 'phash-gate ISOLADO: symlink de nome blessed → alvo externo RECUSADO por realpath, sentinela NUNCA executada');
+}
+// validateWorkflow end-to-end: wf declarando comando não-blessed = exit 1 (Fail)
+{
+  const d = fs.mkdtempSync(path.join(os.tmpdir(), 'vc-badwf-'));
+  fs.mkdirSync(path.join(d, 'workflows')); fs.mkdirSync(path.join(d, 'templates'));
+  fs.writeFileSync(path.join(d, 'templates', 't.md'), '# T\n## Body\nx\n');
+  fs.writeFileSync(path.join(d, 'workflows', 'wf-bad.yaml'),
+    'state_machine:\n  states: [init, running, complete, failed]\n  initial: init\n  terminal: [complete, failed]\n' +
+    'steps:\n  - id: s\n    agent: a\n    template: templates/t.md\n    inputs: [x]\n    outputs: [y]\n    depends_on: []\n    checkpoint: null\n' +
+    '    veto:\n      assertions:\n        - { type: command_check, command: "evil.cjs" }\n');
+  ok(throwsFail(() => vp.validateWorkflow(path.join(d, 'workflows', 'wf-bad.yaml'), d)),
+    'validateWorkflow: wf com command_check fora da whitelist = exit 1 (recusa estática)');
+}
+
+// ===========================================================================
+// (AC3) sweep de command_check — fixture de violação; ausente = underivável fail-loud
+// ===========================================================================
+console.log('--- (AC3) sweep de command_check ---');
+const sweepPod = path.join(FIX, 'sweep-pod');
+const wfVc = path.join(sweepPod, 'workflows', 'wf-vc.yaml');
+ok(!throwsFail(() => vp.validateWorkflow(wfVc, sweepPod)), 'validate-pod-workflow: wf-vc (command_check blessed) PASSA estático');
+const scenario = JSON.parse(fs.readFileSync(path.join(sweepPod, 'workflows', 'wf-vc.smoke.json'), 'utf8'));
+const sweepOk = smoke.runSweep({ workflowPath: wfVc, podRoot: sweepPod, scenario });
+ok(sweepOk.ok === true && sweepOk.underivable === null && sweepOk.report.proofs.every((p) => p.blocked),
+  'sweep: command_check com fixture de violação → BLOQUEOU (prova de bloqueio)');
+const scenarioNoViol = { ...scenario, violations: {} };
+const sweepUnder = smoke.runSweep({ workflowPath: wfVc, podRoot: sweepPod, scenario: scenarioNoViol });
+ok(sweepUnder.underivable !== null && /sem fixture de violação/.test(sweepUnder.underivable.reason),
+  'sweep: sem fixture de violação → UNDERIVÁVEL fail-loud (nunca pulado)');
+
+// ===========================================================================
+// (AC4) forge-generate serializeAssertion — args (lista) e extract (mapa) + roundtrip
+// ===========================================================================
+console.log('--- (AC4) forge-generate serializeAssertion ---');
+const emitArgs = fg.serializeAssertion({ type: 'command_check', command: 'lexical-check.cjs', args: ['--max', '0'] });
+const emitExtract = fg.serializeAssertion({ type: 'json_schema_valid', schema: 'nodes,connections', extract: { section: '## Workflow JSON', fence: 'json' } });
+ok(/args: \[/.test(emitArgs), 'serializeAssertion emite args como flow-list');
+ok(/extract: \{/.test(emitExtract), 'serializeAssertion emite extract como flow-map');
+const rtArgs = vp.parseYaml('a: ' + emitArgs.slice(2)).a;
+const rtExtract = vp.parseYaml('a: ' + emitExtract.slice(2)).a;
+ok(Array.isArray(rtArgs.args) && rtArgs.args[0] === '--max', 'roundtrip: parseYaml lê args de volta como lista');
+ok(rtExtract.extract && rtExtract.extract.section === '## Workflow JSON', 'roundtrip: parseYaml lê extract de volta como mapa');
+
+if (failures.length > 0) {
+  console.error(`\nSuíte veto-checks FALHOU: ${failures.length} de ${passed + failures.length}.`);
+  process.exit(1);
+}
+console.log(`\n${passed} asserções verdes. command_check (6ª forma) + json_schema.extract provados.`);
+process.exit(0);

package/scripts/watcher-audit.cjs

@@ -0,0 +1,178 @@
+#!/usr/bin/env node
+'use strict';
+/**
+ * watcher-audit.cjs — auditoria DETERMINÍSTICA de ADERÊNCIA heurística por run
+ * (Story SF2.3, SPEC §G1 "watcher-rubric audita, a cada run, se o agente de fato
+ * aplicou as heurísticas do top-N — aderência, não resumo").
+ *
+ * CONTRATO (a filosofia da rubrica, honrada em código, não em prosa):
+ *   "O watcher NÃO resume o consolidado. Ele audita se o AGENTE APLICOU a heurística
+ *    no ARTEFATO que produziu."
+ *
+ * Por que arquivo NOVO (e não extensão de pod-memory.cjs): a auditoria opera sobre
+ * PARES (consolidado top-N aplicável, artefato produzido) e é consumida pelo
+ * `pod-critic` (agente/gate), não pelo runner. Manter o motor de lifecycle
+ * (pod-memory.cjs) focado em DADOS e o de auditoria em ADERÊNCIA é a fronteira limpa
+ * recomendada nas Dev Notes da story. NÃO é decisão de arquitetura nova — a SPEC já
+ * autoriza qualquer dos dois arquivos (AC3 do brief).
+ *
+ * COMO É DETERMINÍSTICO (proibido veto por LLM, SPEC §B1): para cada heurística do
+ * consolidado (linha `- **[trigger]** recomendação`), extrai os TOKENS DE CONTEÚDO
+ * (palavras significativas, sem stopwords) do trigger e da recomendação e mede, por
+ * presença/ausência no TEXTO DO ARTEFATO (normalizado), um PADRÃO VERIFICÁVEL:
+ *   - not-applicable → o CONTEXTO do trigger não aparece no artefato (a heurística não
+ *     se aplica a este artefato — não é falha do agente).
+ *   - applied        → contexto do trigger presente E ≥ THRESHOLD dos tokens da
+ *     recomendação presentes (o agente materializou o padrão recomendado).
+ *   - not-applied    → contexto presente mas o padrão da recomendação ausente (o
+ *     agente ENTROU no caso e NÃO aplicou — este é o achado que importa).
+ *
+ * Isto NÃO mede se o consolidado foi CITADO: mede o artefato por si só. Um artefato que
+ * apenas MENCIONA "consultei learnings.consolidated.md" sem materializar o padrão
+ * pontua not-applied — é exatamente a diferença entre "aderência" e "resumo/menção".
+ *
+ * Uso:
+ *   node scripts/watcher-audit.cjs <consolidado.md> <artefato> [--out <relatorio.md>]
+ *   (sem --out: imprime o relatório em stdout e sai 0; com achados not-applied → exit 3
+ *    para o pod-critic poder falhar o gate por código, se quiser)
+ *
+ * Node >= 18, sem dependências externas.
+ */
+
+const fs = require('node:fs');
+const path = require('node:path');
+
+const THRESHOLD = 0.5; // fração mínima dos tokens da recomendação presentes p/ "applied"
+
+// Stopwords PT-BR/EN — palavras sem poder discriminante. Determinístico, documentado.
+const STOPWORDS = new Set([
+  'a', 'o', 'as', 'os', 'um', 'uma', 'de', 'do', 'da', 'dos', 'das', 'em', 'no', 'na',
+  'nos', 'nas', 'e', 'ou', 'que', 'com', 'sem', 'por', 'para', 'ao', 'aos', 'se', 'ser',
+  'como', 'the', 'a', 'an', 'of', 'in', 'on', 'to', 'and', 'or', 'for', 'with', 'is',
+  'as', 'be', 'use', 'usar', 'sempre', 'nunca', 'deve', 'entao', 'então',
+]);
+
+function normalize(s) {
+  return String(s == null ? '' : s)
+    .toLowerCase()
+    .normalize('NFD')
+    .replace(/[̀-ͯ]/g, '')
+    .replace(/[^\w\s]/g, ' ')
+    .replace(/\s+/g, ' ')
+    .trim();
+}
+
+/** Tokens de conteúdo: palavras normalizadas com ≥3 chars, fora das stopwords. */
+function contentTokens(s) {
+  return [...new Set(normalize(s).split(' ').filter((w) => w.length >= 3 && !STOPWORDS.has(w)))];
+}
+
+/**
+ * Extrai as heurísticas do consolidado curado (formato de pod-memory.renderConsolidated):
+ *   `- **[trigger]** recomendação _(xN)_`  (top-N)
+ *   `- **[trigger]** recomendação _(fonte: ...)_`  (CRITICAL pinado)
+ */
+function parseConsolidatedHeuristics(md) {
+  const out = [];
+  for (const line of String(md).split(/\r?\n/)) {
+    const m = line.match(/^\s*-\s+\*\*\[(.+?)\]\*\*\s+(.*?)(?:\s+_\(.*\)_)?\s*$/);
+    if (m) out.push({ trigger: m[1].trim(), recommendation: m[2].trim() });
+  }
+  return out;
+}
+
+/**
+ * Audita aderência de UM artefato ao consolidado top-N. Puro e determinístico.
+ * @returns {{ results, appliedCount, notAppliedCount, notApplicableCount, auditable,
+ *             adherenceScore }}
+ */
+function auditAdherence(consolidatedMd, artifactText, opts = {}) {
+  const threshold = typeof opts.threshold === 'number' ? opts.threshold : THRESHOLD;
+  const heuristics = parseConsolidatedHeuristics(consolidatedMd);
+  const artifactNorm = ` ${normalize(artifactText)} `;
+  const has = (tok) => artifactNorm.includes(` ${tok} `) || artifactNorm.includes(` ${tok}`);
+
+  const results = heuristics.map((h) => {
+    const trigTokens = contentTokens(h.trigger);
+    const recTokens = contentTokens(h.recommendation);
+    const triggerPresent = trigTokens.length === 0 ? false : trigTokens.some((t) => has(t));
+    const recHits = recTokens.filter((t) => has(t)).length;
+    const ratio = recTokens.length ? recHits / recTokens.length : 0;
+    let status;
+    if (!triggerPresent) status = 'not-applicable';
+    else if (ratio >= threshold) status = 'applied';
+    else status = 'not-applied';
+    return {
+      trigger: h.trigger,
+      recommendation: h.recommendation,
+      status,
+      evidence: { trigger_present: triggerPresent, recommendation_signal_ratio: Number(ratio.toFixed(2)), recommendation_tokens: recTokens.length },
+    };
+  });
+
+  const appliedCount = results.filter((r) => r.status === 'applied').length;
+  const notAppliedCount = results.filter((r) => r.status === 'not-applied').length;
+  const notApplicableCount = results.filter((r) => r.status === 'not-applicable').length;
+  const auditable = appliedCount + notAppliedCount; // heurísticas cujo contexto se aplica
+  const adherenceScore = auditable === 0 ? null : Number((appliedCount / auditable).toFixed(2));
+  return { results, appliedCount, notAppliedCount, notApplicableCount, auditable, adherenceScore };
+}
+
+/** Renderiza o relatório de auditoria (destino claro — arquivo/stdout). */
+function renderReport(audit, meta = {}) {
+  const lines = [];
+  lines.push('# Watcher — auditoria de aderência heurística (SF2.3)');
+  lines.push('');
+  lines.push('> Audita se o AGENTE APLICOU as heurísticas do top-N no artefato — não resume o consolidado.');
+  if (meta.artifact) lines.push(`> Artefato: \`${meta.artifact}\``);
+  if (meta.consolidated) lines.push(`> Consolidado: \`${meta.consolidated}\``);
+  lines.push('');
+  lines.push(`- aderência (aplicadas / aplicáveis): ${audit.adherenceScore == null ? 'n/a (nenhuma aplicável)' : audit.adherenceScore}`);
+  lines.push(`- aplicadas: ${audit.appliedCount} · NÃO-aplicadas: ${audit.notAppliedCount} · não-aplicáveis: ${audit.notApplicableCount}`);
+  lines.push('');
+  lines.push('| heurística (trigger) | status | sinal-recomendação |');
+  lines.push('|---|---|---|');
+  for (const r of audit.results) {
+    lines.push(`| ${r.trigger} | ${r.status} | ${r.evidence.recommendation_signal_ratio} |`);
+  }
+  lines.push('');
+  if (audit.notAppliedCount > 0) {
+    lines.push('## Achados — heurísticas NÃO aplicadas (contexto presente, padrão ausente)');
+    for (const r of audit.results.filter((x) => x.status === 'not-applied')) {
+      lines.push(`- **[${r.trigger}]** ${r.recommendation}`);
+    }
+    lines.push('');
+  }
+  return lines.join('\n');
+}
+
+function main() {
+  const args = process.argv.slice(2);
+  let out = null;
+  const rest = [];
+  for (let i = 0; i < args.length; i++) {
+    if (args[i] === '--out') out = args[++i];
+    else rest.push(args[i]);
+  }
+  if (rest.length < 2) {
+    console.error('Uso: node scripts/watcher-audit.cjs <consolidado.md> <artefato> [--out <relatorio.md>]');
+    process.exit(2);
+  }
+  const consolidatedMd = fs.readFileSync(rest[0], 'utf8');
+  const artifactText = fs.readFileSync(rest[1], 'utf8');
+  const audit = auditAdherence(consolidatedMd, artifactText);
+  const report = renderReport(audit, { consolidated: path.basename(rest[0]), artifact: path.basename(rest[1]) });
+  if (out) {
+    fs.mkdirSync(path.dirname(path.resolve(out)), { recursive: true });
+    fs.writeFileSync(out, report);
+    console.log(`relatório de aderência gravado em ${path.relative(process.cwd(), path.resolve(out))}`);
+  } else {
+    console.log(report);
+  }
+  // exit 3 quando há heurística aplicável NÃO aplicada — o pod-critic decide o gate.
+  process.exit(audit.notAppliedCount > 0 ? 3 : 0);
+}
+
+if (require.main === module) main();
+
+module.exports = { auditAdherence, parseConsolidatedHeuristics, renderReport, contentTokens, normalize, THRESHOLD };

package/template/.claude/CLAUDE.md

@@ -0,0 +1,103 @@
+# POWER CLAUDE
+
+Framework de pods organizados por job-to-be-done. Cada pod é uma unidade de capacidade autocontida: agentes enxutos, conhecimento sob demanda e enforcement determinístico dos não-negociáveis.
+
+## O que é
+
+Cinco pods, cada um ativado por um slash command:
+
+| Pod | Job-to-be-done | Comando |
+|---|---|---|
+| `pods/dev-ia/` | Desenvolvimento de software com IA (ciclo story → validação → implementação → QA gate) | `/power:dev` |
+| `pods/authority-content/` | Conteúdo de autoridade multi-canal (radar → criação na voz → red-team factual → adaptação) | `/power:content` |
+| `pods/automation/` | Automações com N8N e Langgraph (desenho → workflow/grafo → red-team → runbook) | `/power:automation` |
+| `pods/academy/` | Palestras, treinamentos, mentorias e ofertas de consultoria | `/power:academy` |
+| `pods/squad-forge/` | Criação de novos pods, agentes e skills no padrão da casa | `/power:forge` |
+
+Fonte única da verdade: os agentes vivem nos pods. Slash commands são stubs finos que apontam para lá. Todo agente de pod é um arquivo markdown de até 150 linhas com `budget_tokens` declarado no frontmatter.
+
+## Regras de ouro do ambiente
+
+1. **Contexto é o ativo mais caro.** Todo agente declara `budget_tokens` e passa pelo gate `scripts/validate-budgets.js` (teto global: 1.500 tokens de ativação, 150 linhas). Conhecimento profundo carrega sob demanda — nunca na ativação. Budget de tokens é gate de CI, não sugestão.
+2. **Enforcement determinístico > instrução.** O que é inegociável vira hook ou gate de CI, não prosa. Prosa orienta; hook bloqueia. Se uma regra importa de verdade e ainda é só texto, o próximo passo é transformá-la em gate.
+3. **Verificação adversarial em tudo que sai para fora.** Todo pipeline que publica ou entrega tem fase de red-team obrigatória, executada por quem não produziu a peça. Gate de estilo não substitui red-team factual.
+4. **Conhecimento em `knowledge/`, nunca em entry points.** Agentes, commands e skills são mapas de rota; o conteúdo denso vive em `knowledge/` ou `pods/<pod>/knowledge/` e carrega por comando, sob demanda.
+5. **Git: push somente fast-forward e somente com aprovação humana ou papel devops.** Force-push é proibido para todos, inclusive devops — bloqueado deterministicamente por `.claude/hooks/enforce-git-push-authority.cjs`.
+6. **Nunca marcar Done sem QA independente.** Quem implementa não se aprova. Só o papel QA transiciona uma story para Done, e só depois de re-executar os gates — relato de sucesso não é evidência.
+7. **Autoatestado não é evidência.** Métrica de qualidade que um agente emite sobre o próprio trabalho (score, veredito, confiança) só vale pareada com validador externo — script de forma ou checkpoint humano. Dimensão sem evidência se declara insuficiente (`insufficient_data`); estimar para preencher é proibido.
+
+## Personalização (opcional, em três degraus)
+
+Nenhum pod exige que você construa um DNA de voz. Os pods que **assinam peças em seu nome**
+perguntam quem é você — uma vez, três campos (nome, handle, uma linha de autoridade) —, porque a
+alternativa seria assinar por uma pessoa inventada. Tudo o mais é opcional, tem default funcional
+e se ajusta com o seu feedback durante o uso.
+
+| Degrau | Você fornece | Onde |
+|---|---|---|
+| 1 — sem voz | nada; roda com tom neutro | — |
+| 2 — guia de estilo | pessoa gramatical, léxico proibido, tom em uma linha | `pods/<pod>/knowledge/dono.yaml` (cópia de `dono.example.yaml`) |
+| 3 — DNA de voz | um corpus do que você já escreveu | `knowledge/voice-dna/voice-dna.yaml`, via `/power:forge` → `mind-extractor` → `*extract {corpus}` |
+
+Com o degrau 3 presente, os campos `voz.*` do degrau 2 não são autorados em paralelo (ausentes ou
+`derived_from:`). Enquanto o arquivo carregar a sentinela (`meta.placeholder: true` /
+`pc:placeholder`), trate-o como **não personalizado** — e nunca bloqueie a rodada por isso.
+Passo a passo: `knowledge/voice-dna/README.md`.
+
+## Ciclo de desenvolvimento
+
+```
+SPEC → epic → story → validação → implementação → QA gate independente → fechamento
+```
+
+| Etapa | Skill | Papel |
+|---|---|---|
+| Validar a story (GO/NO-GO, checklist de 10 pontos) | `pc-validate-story` | PO |
+| Implementar os ACs (branch guard, gates verdes) | `pc-develop-story` | Dev |
+| QA gate (PASS/CONCERNS/FAIL/WAIVED + gate file) | `pc-review-story` | QA |
+| Corrigir findings do gate (inventário total) | `pc-apply-qa-fixes` | Dev |
+| Fechar (bookkeeping pós-Done, índice do epic) | `pc-close-story` | qualquer |
+| Commit local convencional com `[Story X.Y]` | `pc-commit` | Dev |
+
+Regras do ciclo:
+
+- Story só entra em implementação com veredito **GO** da validação (Status `Ready`).
+- Gate **FAIL** → `pc-apply-qa-fixes` → re-review. Máximo 3 iterações; depois escala ao humano.
+- Cada papel tem um subagente dedicado: `pc-po`, `pc-dev`, `pc-qa` (em `.claude/agents/`) — use-os para garantir contexto limpo entre implementação e revisão.
+- A matriz completa de papéis, vetos e escalação está em `.claude/rules/authority.md`.
+
+## Model routing
+
+| Modelo | Quando |
+|---|---|
+| `sonnet` | Default para todo trabalho |
+| `opus` | Arquitetura, síntese criativa, revisão adversarial (com justificativa registrada) |
+| `haiku` | Varreduras mecânicas em lote (triagem de arquivos, grep semântico, checagens repetitivas) |
+
+Routing é decisão de custo-benefício explícita: escalar para `opus` sem justificativa e varrer 200 arquivos com `sonnet` são o mesmo erro em direções opostas.
+
+## Estrutura do projeto
+
+```
+pods/               # Os 6 pods: agents/, knowledge/, tasks/, examples/
+knowledge/          # Conhecimento transversal (voice DNA, referências)
+docs/stories/       # Stories numeradas ({epic}.{n}.story.md) e índices de epic
+docs/qa/gates/      # Gate files de QA ({story}.yaml) — trilha de auditoria
+content/            # Peças de conteúdo produzidas pelos pods
+.claude/
+├── CLAUDE.md       # Este arquivo — identidade do ambiente
+├── settings.json   # Idioma, permissões (deny .env*) e registro de hooks
+├── hooks/          # Enforcement determinístico (autoridade de push)
+├── rules/          # authority.md — matriz de papéis do ciclo
+├── skills/         # As 6 skills pc-* do ciclo de desenvolvimento
+├── agents/         # Subagentes de papel: pc-po, pc-dev, pc-qa
+└── commands/power/ # Stubs /power:* que ativam os pods
+```
+
+## Convenções
+
+- Branch: `feat/{epic}.{n}-{slug}` — nunca commitar em `main`.
+- Commits convencionais (`feat:`, `fix:`, `docs:`, `chore:`) com `[Story X.Y]`.
+- Idioma: português, com termos técnicos em inglês.
+- Segredos só em `.env` (nunca versionado; leitura bloqueada por permissão deny).
+- Voz de conteúdo público: `knowledge/voice-dna/` — nunca persona de terceiros.

package/template/.claude/agents/pc-analyst.md

@@ -0,0 +1,100 @@
+---
+name: pc-analyst
+description: "Papel Analyst da fase Explore do POWER CLAUDE: transforma ideia ou problema vago em análise fundamentada e brief acionável que alimenta o planner. Use para: criar project brief, pesquisar mercado (TAM/SAM/SOM), analisar competidores, facilitar brainstorming, gerar prompt de pesquisa profunda, calcular ROI."
+model: sonnet
+budget_tokens: 1500
+tools: Read, Grep, Glob, Write, Edit, Bash, WebSearch, WebFetch
+permissionMode: acceptEdits
+---
+
+# pc-analyst — Explorador da Fase Explore
+
+Você é o papel **Analyst** do ciclo POWER CLAUDE.
+Sua função é converter ideias vagas em evidência estruturada: briefs, pesquisas
+de mercado, análises competitivas e sessões de ideação que dão ao planner e ao
+architect um ponto de partida sólido — fatos com fonte, não opinião com verniz.
+
+Critério de qualidade: alguém que nunca falou com o usuário consegue tomar uma
+decisão de produto lendo só o seu documento.
+
+> Para síntese estratégica pesada (executive summary de pesquisa extensa,
+> cenários best/base/worst, war-gaming competitivo), o operador pode elevar
+> este agente para `opus` com justificativa; o default é `sonnet`.
+
+## Fronteiras do papel
+
+- **NÃO escreve PRD** — o brief termina no Planner Handoff; PRD é do planner.
+- **NÃO decide arquitetura** — Technical Considerations são pensamentos
+  iniciais, nunca decisões; arquitetura é do papel architect.
+- **NÃO cria stories** — descoberta termina em documento, não em backlog.
+
+## Missões
+
+Cada missão carrega seu conhecimento sob demanda — o método vive FORA deste
+agente, em `knowledge/analyst/`:
+
+**`*brief`** — project brief em 12 seções, com Planner Handoff ao final.
+- Método: `knowledge/analyst/brief-skeleton.md`
+- Output: `docs/brief.md`
+
+**`*market`** — pesquisa de mercado: TAM/SAM/SOM em 3 abordagens, JTBD,
+Porter's Five Forces, oportunidades quantificadas.
+- Método: `knowledge/analyst/market-research-skeleton.md`
+- Output: `docs/market-research.md`
+
+**`*bench`** — análise competitiva: 5 categorias de competidor, matriz 2×2
+Market Share × Threat, SWOT, positioning map, plano de monitoramento.
+- Método: `knowledge/analyst/competitor-skeleton.md`
+- Output: `docs/competitor-analysis.md`
+
+**`*brainstorm {tópico}`** — facilitação em 4 fases com 20 técnicas;
+categorização Immediate / Future / Moonshots / Insights.
+- Método: `knowledge/analyst/brainstorming.md`
+- Output: `docs/brainstorming-session-results.md`
+
+**`*research-prompt {tópico}`** — prompt de pesquisa profunda: 8 tipos,
+perguntas primárias vs. secundárias, critérios de sucesso.
+- Método: `knowledge/analyst/research-prompt-structure.md`
+- Output: prompt pronto (ou `docs/research-prompt.md`)
+
+**`*roi`** — análise de ROI com fórmulas visíveis, breakeven, projeção de
+3 anos e análise de sensibilidade.
+- Método: `knowledge/analyst/roi-skeleton.md`
+- Output: `docs/roi-analysis.md`
+
+**`*elicit`** — motor de refinamento seção a seção (menu 0-9) sobre qualquer
+documento desta fase.
+- Método: `knowledge/analyst/elicitation-menu.md`
+- Output: seção refinada in-place
+
+Variações cobertas sem missão própria:
+- Pesquisa de dependências/constraints técnicas de uma feature →
+  `*research-prompt` tipo 5 (Technology & Innovation).
+- Validação de hipótese de produto → `*research-prompt` tipo 1.
+- Avaliação de risco/viabilidade → `*research-prompt` tipo 8.
+
+## Fluxo típico da fase Explore
+
+1. `*brainstorm` — divergir com o usuário.
+2. `*market` / `*bench` / `*research-prompt` — fundamentar com evidência.
+3. `*roi` — se o investimento precisa de defesa numérica.
+4. `*brief` — convergir tudo em documento fundacional.
+5. Planner Handoff — o brief vira entrada do PRD.
+
+Cada documento aceita `*elicit` a qualquer momento para refinar seções.
+
+## Regras de ouro
+
+1. **Todo dado com fonte e data.** Fato citado tem origem rastreável;
+   estimativa tem método declarado; opinião é rotulada como opinião.
+   Declare o nível de confiança e as incertezas de cada achado.
+2. **No Invention.** Nunca invente números, competidores, citações ou
+   tendências. Sem dado disponível? Registre a lacuna em "Areas Needing
+   Further Research" — lacuna honesta vale mais que preenchimento plausível.
+3. **Executive summary por ÚLTIMO** e rationale registrado por seção
+   (por que este escopo, por que estes segmentos, por que estas premissas).
+4. **Em brainstorming você é FACILITADOR:** extrai ideias do usuário com
+   perguntas e prompts; nunca gera por ele.
+5. **Modo autônomo:** toda escolha não confirmada com o usuário vira registro
+   `[AUTO-DECISION] {pergunta} → {decisão} ({razão})` no documento,
+   para revisão posterior.

package/template/.claude/agents/pc-architect.md

@@ -0,0 +1,32 @@
+---
+name: pc-architect
+description: "Papel Architect do ciclo POWER CLAUDE: classifica complexidade, decide stack/arquitetura com trade-offs e ADR, revisa arquitetura antes do dev e analisa impacto de mudanças. Use para: classificar complexidade de spec (assess), decisão de arquitetura com ADR, revisão de arquitetura pré-desenvolvimento, análise de impacto em sistema existente."
+model: opus
+budget_tokens: 1400
+tools: Read, Grep, Glob, Write, Edit, Bash, WebSearch, WebFetch
+permissionMode: acceptEdits
+---
+
+# pc-architect — Arquiteto do Ciclo
+
+## Papel
+
+Você é o papel **Architect** do ciclo POWER CLAUDE: decide como o sistema é construído e é o quality gate de arquitetura que SPECs e stories referenciam antes do desenvolvimento. Critério de qualidade: nenhuma decisão sem alternativas comparadas e critério explícito.
+
+> Model `opus` com justificativa: arquitetura é onde raciocínio profundo paga — uma decisão errada aqui custa épicos inteiros de retrabalho; o custo extra de inferência é ordens de grandeza menor que o custo de corrigi-la depois.
+
+## Missões
+
+| Missão | O que faz |
+|---|---|
+| `*assess` | Classificação de complexidade por 5 dimensões, cada uma pontuada 1-5: **escopo** (arquivos/módulos afetados), **integração** (APIs e sistemas externos), **infraestrutura** (mudanças necessárias), **conhecimento** (familiaridade com o domínio/stack), **risco** (criticidade do que pode quebrar). Soma ≤ 8 → SIMPLE; 9-15 → STANDARD; ≥ 16 → COMPLEX. O veredito decide a profundidade do processo: SIMPLE = spec enxuta direto a stories; STANDARD = SPEC completa + `*review`; COMPLEX = SPEC (planner elevado a opus) + `*design` com ADR + `*review` obrigatório. |
+| `*design` | Decisão de stack/arquitetura: ≥ 2 alternativas com trade-offs em tabela, critério de decisão explícito, e ADR curto (Contexto → Decisão → Consequências, incluindo as negativas) em `docs/adr/ADR-{n}-{slug}.md`. |
+| `*review` | Revisão de arquitetura de SPEC/story **antes** do desenvolvimento — o quality gate que as stories referenciam: consistência com as decisões da SPEC e ADRs vigentes, acoplamento e fronteiras de módulo, superfícies de segurança, pontos únicos de falha, testabilidade dos ACs. Veredito APPROVED / NEEDS_CHANGES com lista acionável — nunca "parece ok". |
+| `*impact` | Análise de impacto de mudança em sistema existente: mapeia módulos, contratos e dados afetados por leitura/grep real do código (nunca por suposição), avalia compatibilidade retroativa, plano de migração incremental e riscos com mitigação. |
+
+## Regras de ouro
+
+- **Toda decisão com alternativas consideradas e critério.** "Escolhi X" sem "em vez de Y, porque Z" não é decisão de arquitetura — é palpite.
+- **Dívida técnica declarada, nunca silenciosa:** atalho aceito vira registro explícito (onde, por quê, custo estimado de pagar depois) na SPEC/ADR/story.
+- **Segurança e custo são dimensões de TODA decisão** — avaliados em cada `*design`, `*review` e `*impact`, não seções opcionais.
+- **Você não implementa:** analisa, decide, revisa e recomenda. Código é do papel Dev; veredito de story é do PO/QA; publicação é do devops (`.claude/rules/authority.md`).