@daniellins/power-claude 0.16.3

package/scripts/validate-fidelity-output.cjs

@@ -0,0 +1,267 @@
+#!/usr/bin/env node
+'use strict';
+/**
+ * validate-fidelity-output.cjs — validador estático de FORMA + ARITMÉTICA do output
+ * do comando `*fidelity-score` (e do bloco `trindade:` de `*extract`/`*validate`) do
+ * mind-extractor (squad-forge). ADR-008 Decisão 2/4.
+ *
+ * FRONTEIRA (ADR-002/ADR-008): prova o que é MECANIZÁVEL — a aritmética de agregação
+ * e a coerência estrutural do bloco — e NUNCA julga CONTEÚDO. Ele não decide se o "4"
+ * é o score certo, nem se a citação sustenta o score, nem se um Playbook de fato existe
+ * no corpus: isso é JULGAMENTO do agente, revisado por QA/humano. Deixar a aritmética à
+ * LLM é o vetor real de fake-green do Risco 1 (score "premium" com denominador inflado,
+ * peso trocado ou threshold arredondado através de uma banda) — é isso que este script fecha.
+ *
+ * Verifica (fidelity_score): (i) 8 camadas presentes, cada uma `scored` (int 1-5 +
+ * `evidence` não-vazia) OU `insufficient_data`; (ii) `insufficient_data` FORA do
+ * denominador; (iii) peso de cada camada bate com o tipo (Observable 0.8 / Cognitive-Deep
+ * 1.0); (iv) média ponderada RECOMPUTADA casa com a reportada; (v) threshold/maturidade
+ * consistente com a média computada. Verifica (trindade): 3 componentes nomeados, cada um
+ * present|missing, e `verdict: blocked` SSE algum componente `missing` (coerência
+ * veredito<->status — nunca a presença real do componente no corpus).
+ *
+ * Uso:  node scripts/validate-fidelity-output.cjs <output.yaml> [<output.yaml> ...]
+ * Exit 0 = bloco bem-formado e aritmética honesta; exit 1 = primeira violação nomeada.
+ *
+ * Fonte única do formato: template/pods/squad-forge/knowledge/fidelity-rubric.yaml
+ * (seção output_contract:) — mudar o formato exige tocar rubrica + este validador (dívida
+ * de acoplamento declarada no ADR-008 Consequências).
+ *
+ * Node >= 18, sem dependências externas (reusa o parser YAML-lite do validador de workflow).
+ */
+
+const fs = require('node:fs');
+const path = require('node:path');
+const { parseYaml, Fail } = require('./validate-pod-workflow.cjs');
+
+const REPO_ROOT = path.resolve(__dirname, '..');
+
+// Espelho do knowledge/fidelity-rubric.yaml (threshold_bands + camadas). Acoplamento
+// declarado no ADR-008; a fixture da rubrica (validate-fidelity-output.test.cjs) confere
+// que a rubrica em disco carrega os mesmos 8 pesos/tipos, guardando contra drift.
+const LAYERS = [
+  { layer: 1, type: 'Observable',    weight: 0.8 },
+  { layer: 2, type: 'Observable',    weight: 0.8 },
+  { layer: 3, type: 'Observable',    weight: 0.8 },
+  { layer: 4, type: 'Observable',    weight: 0.8 },
+  { layer: 5, type: 'Cognitive',     weight: 1.0 },
+  { layer: 6, type: 'Deep Identity', weight: 1.0 },
+  { layer: 7, type: 'Deep Identity', weight: 1.0 },
+  { layer: 8, type: 'Deep Identity', weight: 1.0 },
+];
+const CANON = new Map(LAYERS.map((l) => [l.layer, l]));
+const THRESHOLD_BANDS = {
+  below_basic:  { min: 1.0,  max: 3.0,  maturity: 'v0' },
+  basic:        { min: 3.0,  max: 3.75, maturity: '1.0' },
+  intermediate: { min: 3.75, max: 4.25, maturity: '2.0' },
+  premium:      { min: 4.25, max: 4.85, maturity: '3.0+' },
+  elite:        { min: 4.65, max: 5.0,  maturity: '3.0+' },
+};
+const EPS = 0.01;      // folga na checagem de pertencimento à banda de threshold
+const AVG_TOL = 0.01;  // tolerância de arredondamento da média ponderada (2 casas)
+const TRINDADE_COMPONENTS = ['playbook', 'framework', 'swipe_file'];
+
+function fail(msg) {
+  throw new Fail(msg);
+}
+
+function isPlainMap(v) {
+  return v !== null && typeof v === 'object' && !Array.isArray(v);
+}
+
+// ---------------------------------------------------------------------------
+// Bloco fidelity_score — FORMA + ARITMÉTICA.
+// ---------------------------------------------------------------------------
+
+function validateFidelityBlock(fsb) {
+  if (!isPlainMap(fsb)) fail('fidelity_score não é um mapa');
+  const layers = fsb.layers;
+  if (!Array.isArray(layers)) fail('fidelity_score.layers ausente ou não é lista');
+  if (layers.length !== 8) fail(`fidelity_score.layers deve ter as 8 camadas — tem ${layers.length}`);
+
+  const seen = new Set();
+  let sumWeighted = 0;
+  let sumWeights = 0;
+  let scored = 0;
+  for (const L of layers) {
+    if (!isPlainMap(L)) fail('camada não é um mapa');
+    const n = L.layer;
+    if (!CANON.has(n)) fail(`camada com número inválido: ${JSON.stringify(n)} (esperado 1-8)`);
+    if (seen.has(n)) fail(`camada duplicada: ${n}`);
+    seen.add(n);
+    const canon = CANON.get(n);
+    if (L.type !== canon.type) {
+      fail(`camada ${n}: type "${L.type}" != "${canon.type}" da rubrica`);
+    }
+    if (L.weight !== canon.weight) {
+      fail(`camada ${n}: weight ${JSON.stringify(L.weight)} != ${canon.weight} (peso da rubrica para type ${canon.type})`);
+    }
+    if (L.status === 'scored') {
+      if (!Number.isInteger(L.score) || L.score < 1 || L.score > 5) {
+        fail(`camada ${n} scored: score deve ser inteiro 1-5 — recebeu ${JSON.stringify(L.score)}`);
+      }
+      if (typeof L.evidence !== 'string' || L.evidence.trim() === '') {
+        fail(`camada ${n} scored: evidence obrigatória e não-vazia (No Invention — score sem evidência citável é ficção)`);
+      }
+      sumWeighted += L.score * canon.weight;
+      sumWeights += canon.weight;
+      scored++;
+    } else if (L.status === 'insufficient_data') {
+      // Fora do denominador — não soma peso nem score (invariante ii).
+    } else {
+      fail(`camada ${n}: status inválido "${L.status}" (esperado scored | insufficient_data)`);
+    }
+  }
+  for (let i = 1; i <= 8; i++) if (!seen.has(i)) fail(`camada ${i} ausente`);
+
+  const insufficient = 8 - scored;
+  if (fsb.scored_count !== scored) {
+    fail(`scored_count reportado ${JSON.stringify(fsb.scored_count)} != ${scored} camadas scored reais`);
+  }
+  if (fsb.insufficient_count !== insufficient) {
+    fail(`insufficient_count reportado ${JSON.stringify(fsb.insufficient_count)} != ${insufficient} reais`);
+  }
+
+  if (scored === 0) {
+    // Nada pontuável: sem média, sem maturidade; threshold só pode ser insufficient_data.
+    if (fsb.weighted_average !== null && fsb.weighted_average !== undefined) {
+      fail('scored_count=0: weighted_average deve ser null (nenhuma camada sustenta média)');
+    }
+    if (fsb.threshold !== 'insufficient_data') {
+      fail(`scored_count=0: threshold deve ser "insufficient_data" — recebeu ${JSON.stringify(fsb.threshold)}`);
+    }
+    if (fsb.maturity !== null && fsb.maturity !== undefined) {
+      fail('scored_count=0: maturity deve ser ausente/null');
+    }
+    return;
+  }
+
+  const computed = sumWeighted / sumWeights;
+  if (typeof fsb.weighted_average !== 'number') {
+    fail(`weighted_average ausente ou não numérico: ${JSON.stringify(fsb.weighted_average)}`);
+  }
+  if (Math.abs(fsb.weighted_average - computed) > AVG_TOL) {
+    fail(`weighted_average reportado ${fsb.weighted_average} != ${computed.toFixed(4)} recomputado ` +
+      `(soma ${sumWeighted.toFixed(3)} / pesos ${sumWeights.toFixed(3)} sobre ${scored} camadas scored) — ` +
+      `fake-green aritmético (denominador inflado por insufficient_data, peso trocado ou média forjada)`);
+  }
+
+  const band = THRESHOLD_BANDS[fsb.threshold];
+  if (!band) {
+    fail(`threshold inválido "${fsb.threshold}" (esperado ${Object.keys(THRESHOLD_BANDS).join('|')})`);
+  }
+  if (computed < band.min - EPS || computed > band.max + EPS) {
+    fail(`threshold "${fsb.threshold}" (banda ${band.min}-${band.max}) inconsistente com a média computada ` +
+      `${computed.toFixed(3)} — threshold inflado/deflacionado (rótulo fora da própria banda)`);
+  }
+  if (fsb.maturity !== band.maturity) {
+    fail(`maturity "${fsb.maturity}" != "${band.maturity}" esperada para threshold "${fsb.threshold}"`);
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Bloco trindade — COERÊNCIA veredito<->status (nunca a presença real no corpus).
+// ---------------------------------------------------------------------------
+
+function validateTrindadeBlock(tr) {
+  if (!isPlainMap(tr)) fail('trindade não é um mapa');
+  const computedMissing = [];
+  for (const c of TRINDADE_COMPONENTS) {
+    const comp = tr[c];
+    if (!isPlainMap(comp)) fail(`trindade.${c} ausente ou não é um mapa {status, evidence}`);
+    if (comp.status === 'present') {
+      if (typeof comp.evidence !== 'string' || comp.evidence.trim() === '') {
+        fail(`trindade.${c} present: evidence obrigatória e não-vazia`);
+      }
+    } else if (comp.status === 'missing') {
+      computedMissing.push(c);
+    } else {
+      fail(`trindade.${c}: status inválido "${comp.status}" (esperado present | missing)`);
+    }
+  }
+  if (tr.verdict !== 'complete' && tr.verdict !== 'blocked') {
+    fail(`trindade.verdict inválido "${tr.verdict}" (esperado complete | blocked)`);
+  }
+  const reported = Array.isArray(tr.missing) ? tr.missing.slice().sort() : null;
+  if (reported === null) fail('trindade.missing ausente (use [] quando completo)');
+  const expected = computedMissing.slice().sort();
+  if (reported.join(',') !== expected.join(',')) {
+    fail(`trindade.missing reportado [${reported.join(', ')}] != [${expected.join(', ')}] (componentes com status missing)`);
+  }
+  // Coerência bloqueante: verdict=blocked SSE há componente missing (ADR-008 Decisão 4).
+  if (computedMissing.length > 0 && tr.verdict !== 'blocked') {
+    fail(`trindade.verdict deve ser "blocked" com componente(s) missing [${expected.join(', ')}] — ` +
+      `PROIBIDO aprovar com Trindade incompleta (AN003; ADR-008 Decisão 4)`);
+  }
+  if (computedMissing.length === 0 && tr.verdict !== 'complete') {
+    fail('trindade.verdict deve ser "complete" quando nenhum componente está missing');
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Documento (aceita fidelity_score e/ou trindade; exige ao menos um).
+// ---------------------------------------------------------------------------
+
+function validateFidelityOutput(doc) {
+  if (!isPlainMap(doc)) fail('raiz do output não é um mapa YAML');
+  const hasFs = 'fidelity_score' in doc;
+  const hasTr = 'trindade' in doc;
+  if (!hasFs && !hasTr) {
+    fail('nenhum bloco reconhecido — esperado fidelity_score e/ou trindade (output_contract da rubrica)');
+  }
+  if (hasFs) validateFidelityBlock(doc.fidelity_score);
+  if (hasTr) validateTrindadeBlock(doc.trindade);
+}
+
+function validateFile(filePath) {
+  let doc;
+  try {
+    doc = parseYaml(fs.readFileSync(filePath, 'utf8'));
+  } catch (e) {
+    fail(`YAML malformado: ${e.message}`);
+  }
+  validateFidelityOutput(doc);
+}
+
+function main() {
+  const targets = process.argv.slice(2);
+  if (targets.length === 0) {
+    console.error('Uso: node scripts/validate-fidelity-output.cjs <output.yaml> [...]');
+    process.exit(2);
+  }
+  let ok = 0;
+  for (const t of targets) {
+    const rel = path.relative(REPO_ROOT, path.resolve(t));
+    if (!fs.existsSync(t)) {
+      console.error(`[FALHA] ${rel}: arquivo não encontrado`);
+      process.exit(1);
+    }
+    try {
+      validateFile(t);
+      console.log(`[OK   ] ${rel}`);
+      ok++;
+    } catch (e) {
+      if (e instanceof Fail) {
+        console.error(`[FALHA] ${rel}: ${e.message}`);
+        process.exit(1);
+      }
+      throw e;
+    }
+  }
+  console.log(`\n${ok} output(s) de fidelidade validado(s). Forma + aritmética honestas.`);
+  process.exit(0);
+}
+
+if (require.main === module) {
+  main();
+}
+
+module.exports = {
+  validateFidelityOutput,
+  validateFidelityBlock,
+  validateTrindadeBlock,
+  LAYERS,
+  THRESHOLD_BANDS,
+  TRINDADE_COMPONENTS,
+  Fail,
+};

package/scripts/validate-fidelity-output.test.cjs

@@ -0,0 +1,101 @@
+#!/usr/bin/env node
+'use strict';
+/**
+ * validate-fidelity-output.test.cjs — suíte do validador de FORMA+ARITMÉTICA do
+ * *fidelity-score (Story SF7.1, AC5; ADR-008 Decisão 2/4). Prova:
+ *  (1) o output golden (7 scored + 1 insufficient + trindade completa) PASSA;
+ *  (2) cada fake-green FALHA (média forjada, insufficient no denominador, evidência
+ *      ausente, threshold inflado, peso adulterado, Trindade incoerente);
+ *  (3) a rubrica em disco carrega a FORMA exigida (8 camadas, weight numérico, Fonte:,
+ *      thresholds, 3 componentes da Trindade, output_contract) — AC5 fixture estrutural;
+ *  (4) SEM DRIFT: pesos/tipos da rubrica == constantes do validador.
+ *
+ * Node >= 18.
+ */
+
+const fs = require('node:fs');
+const path = require('node:path');
+const {
+  validateFidelityOutput, validateTrindadeBlock, LAYERS, THRESHOLD_BANDS, Fail,
+} = require('./validate-fidelity-output.cjs');
+const { parseYaml } = require('./validate-pod-workflow.cjs');
+
+const REPO_ROOT = path.resolve(__dirname, '..');
+const FIX = path.join(__dirname, '__fixtures__', 'fidelity');
+const RUBRIC = path.join(REPO_ROOT, 'template', 'pods', 'squad-forge', 'knowledge', 'fidelity-rubric.yaml');
+
+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 parseFix(name) {
+  return parseYaml(fs.readFileSync(path.join(FIX, name), 'utf8'));
+}
+/** True se validateFidelityOutput lançou Fail sobre o doc. */
+function throwsFail(doc) {
+  try { validateFidelityOutput(doc); return false; }
+  catch (e) { if (e instanceof Fail) return true; throw e; }
+}
+
+// --- (1) Golden PASSA (fidelity_score + trindade) ---
+let goldenOk = true;
+try { validateFidelityOutput(parseFix('golden.yaml')); } catch (e) { goldenOk = false; console.error(e.message); }
+ok(goldenOk, 'AC5 (1) golden (7 scored + 1 insufficient + trindade completa) PASSA');
+
+// --- (2) Fake-greens FALHAM, cada um pelo seu vetor ---
+// NOTA de redação (CONCERNS-1): fake-green-average (avg 4.60/premium) e fake-green-denominator
+// (avg 3.47/basic) reportam um threshold INCONSISTENTE com a média recomputada, então quem os
+// pega PRIMEIRO é o threshold-check — não isolam o average-recompute. O isolamento do
+// average-recompute é provado por fake-green-average-in-band (abaixo), único fixture que só ele pega.
+ok(throwsFail(parseFix('fake-green-average.yaml')),        'AC5 (2) média + threshold forjados (4.60/premium) FALHA (pego pelo threshold-check)');
+ok(throwsFail(parseFix('fake-green-denominator.yaml')),    'AC5 (2) insufficient_data no denominador (3.47/basic) FALHA (pego pelo threshold-check)');
+ok(throwsFail(parseFix('fake-green-average-in-band.yaml')),'AC5 (2) ISOLA o average-recompute: média forjada 4.20 DENTRO da banda intermediate (threshold consistente) — só o recompute pega, FALHA');
+ok(throwsFail(parseFix('fake-green-missing-evidence.yaml')),'AC5 (2) score sem evidência FALHA');
+ok(throwsFail(parseFix('fake-green-threshold.yaml')),      'AC5 (2) threshold inflado (premium sobre 4.03) FALHA');
+ok(throwsFail(parseFix('fake-green-weight.yaml')),         'AC5 (2) peso adulterado (Cognitive 0.8) FALHA');
+ok(throwsFail(parseFix('trindade-incoherent.yaml')),       'AC5 (2) Trindade: verdict complete com componente missing FALHA');
+
+// --- Sanidade inline: coerência da Trindade nos dois sentidos ---
+ok(!throwsFail({ trindade: {
+  playbook: { status: 'present', evidence: 'x' }, framework: { status: 'present', evidence: 'x' },
+  swipe_file: { status: 'present', evidence: 'x' }, verdict: 'complete', missing: [] } }),
+  'sanidade: trindade completa (todos present + verdict complete) PASSA');
+ok(throwsFail({ trindade: {
+  playbook: { status: 'missing', evidence: '' }, framework: { status: 'present', evidence: 'x' },
+  swipe_file: { status: 'present', evidence: 'x' }, verdict: 'blocked', missing: [] } }),
+  'sanidade: verdict blocked mas missing:[] (lista incoerente) FALHA');
+ok(throwsFail({}), 'sanidade: doc sem fidelity_score nem trindade FALHA');
+
+// --- (3) Rubrica em disco: FORMA estrutural (AC5 fixture) ---
+const rubricText = fs.readFileSync(RUBRIC, 'utf8');
+const rubric = parseYaml(rubricText);
+ok(Array.isArray(rubric.layers) && rubric.layers.length === 8, 'AC5 (3) rubrica tem 8 camadas');
+ok(rubric.layers.every((l) => typeof l.weight === 'number'), 'AC5 (3) toda camada tem weight numérico');
+ok(/^\s*#?\s*Fonte:/im.test(rubricText), 'AC5 (3) rubrica tem cabeçalho Fonte:');
+ok(rubric.scoring && rubric.scoring.thresholds && rubric.threshold_bands, 'AC5 (3) thresholds presentes');
+ok(rubric.trindade && rubric.trindade.components
+   && ['playbook', 'framework', 'swipe_file'].every((c) => c in rubric.trindade.components),
+   'AC5 (3) 3 componentes da Trindade nomeados');
+ok(!!rubric.output_contract, 'AC5 (3) output_contract presente');
+
+// --- (4) Sem drift: rubrica == constantes do validador ---
+const noDrift = LAYERS.every((canon) => {
+  const r = rubric.layers.find((l) => l.layer === canon.layer);
+  return r && r.type === canon.type && r.weight === canon.weight;
+});
+ok(noDrift, 'AC5 (4) pesos/tipos da rubrica == constantes LAYERS do validador (sem drift)');
+const bandsMatch = Object.keys(THRESHOLD_BANDS).every((k) => {
+  const r = rubric.threshold_bands[k];
+  return r && r.min === THRESHOLD_BANDS[k].min && r.max === THRESHOLD_BANDS[k].max
+    && r.maturity === THRESHOLD_BANDS[k].maturity;
+});
+ok(bandsMatch, 'AC5 (4) threshold_bands da rubrica == constantes do validador (sem drift)');
+
+if (failures.length > 0) {
+  console.error(`\nSuíte do validador de fidelidade FALHOU: ${failures.length} de ${passed + failures.length}.`);
+  process.exit(1);
+}
+console.log(`\n${passed} asserções verdes. Validador de fidelidade provado.`);
+process.exit(0);

package/scripts/validate-install.js

@@ -0,0 +1,230 @@
+#!/usr/bin/env node
+'use strict';
+/**
+ * validate-install.js — teste E2E do instalador POWER CLAUDE.
+ *
+ * Cria um tmpdir, roda `node bin/cli.js install --yes` com cwd no tmpdir e
+ * verifica o resultado. Exit 0/1 com relatório.
+ *
+ * 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 { motorEntries } = require('../installer/motor-scripts');
+const { sha256OfFile } = require('../installer/manifest');
+
+const REPO_ROOT = path.resolve(__dirname, '..');
+const CLI = path.join(REPO_ROOT, 'bin', 'cli.js');
+const TEMPLATE_DIR = path.join(REPO_ROOT, 'template');
+
+const results = [];
+function check(label, ok, detail) {
+  results.push({ label, ok, detail });
+  console.log(`[${ok ? 'OK   ' : 'FALHA'}] ${label}${detail ? ` — ${detail}` : ''}`);
+  return ok;
+}
+
+function countTemplateFiles(dir) {
+  let n = 0;
+  const stack = [dir];
+  while (stack.length > 0) {
+    const d = stack.pop();
+    for (const entry of fs.readdirSync(d, { withFileTypes: true })) {
+      const p = path.join(d, entry.name);
+      if (entry.isDirectory()) stack.push(p);
+      else if (entry.isFile()) n++;
+    }
+  }
+  return n;
+}
+
+function listPodDirs(dir) {
+  const podsDir = path.join(dir, 'pods');
+  if (!fs.existsSync(podsDir)) return [];
+  return fs
+    .readdirSync(podsDir, { withFileTypes: true })
+    .filter((e) => e.isDirectory())
+    .map((e) => e.name)
+    .sort();
+}
+
+function main() {
+  console.log('POWER CLAUDE — validate-install (E2E)\n');
+
+  const tmpdir = fs.mkdtempSync(path.join(os.tmpdir(), 'power-claude-e2e-'));
+  console.log(`Diretório de teste: ${tmpdir}\n`);
+
+  try {
+    // 1. Instalação não-interativa
+    const install = spawnSync(process.execPath, [CLI, 'install', '--yes'], {
+      cwd: tmpdir,
+      encoding: 'utf8',
+      timeout: 120000,
+    });
+    const installed = check('install --yes termina com exit 0', install.status === 0, `exit ${install.status}`);
+    if (!installed) {
+      console.error('\n--- stdout ---\n' + (install.stdout || ''));
+      console.error('\n--- stderr ---\n' + (install.stderr || ''));
+      finish(tmpdir);
+      return;
+    }
+
+    // 2. Arquivos essenciais
+    check('.claude/CLAUDE.md existe', fs.existsSync(path.join(tmpdir, '.claude', 'CLAUDE.md')));
+
+    const settingsPath = path.join(tmpdir, '.claude', 'settings.json');
+    let settings = null;
+    let settingsOk = false;
+    try {
+      settings = JSON.parse(fs.readFileSync(settingsPath, 'utf8'));
+      settingsOk = true;
+    } catch {
+      settingsOk = false;
+    }
+    check('.claude/settings.json parseia', settingsOk);
+    check(
+      '.claude/settings.json tem hooks',
+      Boolean(settings && settings.hooks && typeof settings.hooks === 'object' && Object.keys(settings.hooks).length > 0)
+    );
+
+    check(
+      '.claude/hooks/enforce-git-push-authority.cjs existe',
+      fs.existsSync(path.join(tmpdir, '.claude', 'hooks', 'enforce-git-push-authority.cjs'))
+    );
+
+    // 3. Pods e knowledge
+    check('pods/README.md existe', fs.existsSync(path.join(tmpdir, 'pods', 'README.md')));
+
+    const expectedPods = listPodDirs(TEMPLATE_DIR);
+    const installedPods = listPodDirs(tmpdir);
+    const allPodsPresent = expectedPods.every((p) => installedPods.includes(p));
+    check(
+      `5 diretórios de pods instalados (${expectedPods.length} esperados)`,
+      expectedPods.length >= 5 && allPodsPresent,
+      `instalados: ${installedPods.join(', ') || 'nenhum'}`
+    );
+
+    check('knowledge/voice-dna/ existe', fs.existsSync(path.join(tmpdir, 'knowledge', 'voice-dna')));
+
+    // 4. Manifest
+    const manifestPath = path.join(tmpdir, '.power-claude', 'manifest.json');
+    let manifest = null;
+    try {
+      manifest = JSON.parse(fs.readFileSync(manifestPath, 'utf8'));
+    } catch {
+      manifest = null;
+    }
+    check('.power-claude/manifest.json parseia', manifest !== null);
+    if (manifest) {
+      const expectedMin = countTemplateFiles(TEMPLATE_DIR);
+      check(
+        `manifest cobre >= ${expectedMin} arquivos (todos do template)`,
+        Array.isArray(manifest.files) && manifest.files.length >= expectedMin,
+        `manifest tem ${Array.isArray(manifest.files) ? manifest.files.length : 0}`
+      );
+      check('manifest tem version e installedAt', Boolean(manifest.version && manifest.installedAt));
+    }
+
+    // 5. .gitignore cobre .env
+    const gitignorePath = path.join(tmpdir, '.gitignore');
+    let coversEnv = false;
+    if (fs.existsSync(gitignorePath)) {
+      const lines = fs.readFileSync(gitignorePath, 'utf8').split(/\r?\n/).map((l) => l.trim());
+      coversEnv = lines.includes('.env');
+    }
+    check('.gitignore contém ".env"', coversEnv);
+
+    // 6. doctor passa no projeto recém-instalado
+    const doctor = spawnSync(process.execPath, [CLI, 'doctor'], { cwd: tmpdir, encoding: 'utf8', timeout: 120000 });
+    if (!check('doctor termina com exit 0 no projeto recém-instalado', doctor.status === 0, `exit ${doctor.status}`)) {
+      console.error('\n--- doctor stdout ---\n' + (doctor.stdout || ''));
+    }
+
+    // 7. Scripts do motor (ADR-007): os 14 presentes e byte-idênticos ao pacote.
+    const entries = motorEntries();
+    let allMotorPresent = true;
+    let allByteIdentical = true;
+    for (const { path: rel } of entries) {
+      const destPath = path.join(tmpdir, ...rel.split('/'));
+      const srcPath = path.join(REPO_ROOT, ...rel.split('/'));
+      if (!fs.existsSync(destPath)) {
+        allMotorPresent = false;
+        console.error(`  ausente: ${rel}`);
+      } else if (fs.existsSync(srcPath) && sha256OfFile(destPath) !== sha256OfFile(srcPath)) {
+        allByteIdentical = false;
+        console.error(`  difere do pacote: ${rel}`);
+      }
+    }
+    check(`${entries.length} scripts do motor presentes em scripts/<nome>`, allMotorPresent);
+    check('scripts do motor byte-idênticos ao pacote', allByteIdentical);
+
+    // 7b. Fixture negativa: scripts de teste/E2E NÃO vazam para o projeto.
+    const forbidden = [
+      'scripts/validate-install.js',
+      'scripts/validate-adopt.js',
+      'scripts/pc-run-pod.test.cjs',
+      'scripts/forge.test.cjs',
+      'scripts/__tests__/motor-scripts.test.cjs',
+    ];
+    const leaked = forbidden.filter((rel) => fs.existsSync(path.join(tmpdir, ...rel.split('/'))));
+    check('scripts de teste/E2E NÃO foram copiados (fixture negativa)', leaked.length === 0, leaked.length ? `vazaram: ${leaked.join(', ')}` : undefined);
+    check('diretório scripts/__tests__ NÃO foi copiado', !fs.existsSync(path.join(tmpdir, 'scripts', '__tests__')));
+    check('diretório scripts/__fixtures__ NÃO foi copiado', !fs.existsSync(path.join(tmpdir, 'scripts', '__fixtures__')));
+
+    // 8. update preserva script do motor modificado pelo usuário; intacto atualiza.
+    const MOD_REL = 'scripts/watcher-audit.cjs';
+    const INTACT_REL = 'scripts/pod-memory.cjs';
+    const modPath = path.join(tmpdir, ...MOD_REL.split('/'));
+    const userContent = fs.readFileSync(modPath, 'utf8') + '\n// edição do usuário — não sobrescrever\n';
+    fs.writeFileSync(modPath, userContent, 'utf8');
+    const userHash = sha256OfFile(modPath);
+    const update = spawnSync(process.execPath, [CLI, 'update', '--yes'], { cwd: tmpdir, encoding: 'utf8', timeout: 120000 });
+    check('update --yes termina com exit 0', update.status === 0, `exit ${update.status}`);
+    check('update PRESERVOU o script do motor modificado', sha256OfFile(modPath) === userHash);
+    check(
+      'update manteve script do motor intacto (byte-idêntico ao pacote)',
+      sha256OfFile(path.join(tmpdir, ...INTACT_REL.split('/'))) === sha256OfFile(path.join(REPO_ROOT, ...INTACT_REL.split('/')))
+    );
+
+    // 9. doctor: script do motor ausente com owner presente → FALHA (exit 1);
+    //    sem o owner → check pulado (doctor não falha por causa dele).
+    const DEL_REL = 'scripts/forge-generate.cjs'; // owner pod:squad-forge
+    fs.rmSync(path.join(tmpdir, ...DEL_REL.split('/')), { force: true });
+    const doctorMissing = spawnSync(process.execPath, [CLI, 'doctor'], { cwd: tmpdir, encoding: 'utf8', timeout: 120000 });
+    check('doctor FALHA (exit 1) com script do motor ausente e owner presente', doctorMissing.status === 1, `exit ${doctorMissing.status}`);
+    check('doctor aponta o script ausente', /forge-generate\.cjs/.test(doctorMissing.stdout || ''));
+    // Remove o owner (pod squad-forge) → o check do script ausente é pulado.
+    fs.rmSync(path.join(tmpdir, 'pods', 'squad-forge'), { recursive: true, force: true });
+    const doctorSkipped = spawnSync(process.execPath, [CLI, 'doctor'], { cwd: tmpdir, encoding: 'utf8', timeout: 120000 });
+    check(
+      'doctor PULA (warn) o script do motor quando o owner não está instalado',
+      /Motor: scripts\/forge-generate\.cjs.*pulada/i.test(doctorSkipped.stdout || ''),
+      undefined
+    );
+  } finally {
+    finish(tmpdir);
+  }
+}
+
+function finish(tmpdir) {
+  try {
+    fs.rmSync(tmpdir, { recursive: true, force: true });
+  } catch (error) {
+    console.warn(`Aviso: falha ao limpar tmpdir ${tmpdir}: ${error.message}`);
+  }
+  const failed = results.filter((r) => !r.ok);
+  console.log(`\n${results.length - failed.length}/${results.length} checagens passaram.`);
+  if (failed.length > 0) {
+    console.error('E2E FALHOU:');
+    for (const f of failed) console.error(`  - ${f.label}${f.detail ? ` (${f.detail})` : ''}`);
+    process.exit(1);
+  }
+  console.log('E2E verde.');
+  process.exit(0);
+}
+
+main();