@daniellins/power-claude 0.16.3

package/scripts/smoke-sweep.test.cjs

@@ -0,0 +1,170 @@
+#!/usr/bin/env node
+'use strict';
+/**
+ * smoke-sweep.test.cjs — suíte do SWEEP DE INJEÇÃO EXAUSTIVO (Story SF3.2, Decisão
+ * D.G3 / G-r2-2). Prova:
+ *  - 3a por TODA etapa + 3b por TODA assertion, com derivação POR FORMA (violação
+ *    mais forte) sobre o fixture das 5 formas (sweep-forms) → todas BLOQUEIAM (AC1/2).
+ *  - UNDERIVABILIDADE como REGRA GERAL fail-loud: os 4 casos do DoD 3 (field_matches
+ *    pattern universal; json_schema_valid sem required; section_exists não-ortogonal;
+ *    count_gte n:0) → cada um NÃO produz blocked:true silencioso, NÃO é pulado, e
+ *    devolve underivable (exit 1) com diagnóstico de assertion degenerada (AC3).
+ *  - Report JSON com binding {workflow, pod, spec_hash} embutido; blocked:false ⇒
+ *    ok:false (AC4). memoryPodDir ISOLADO: sweep não appenda learning na memória de
+ *    produção do pod (AC4, caveat SF2.4).
+ *
+ * Node >= 18. Exit 0/1.
+ */
+
+const fs = require('node:fs');
+const os = require('node:os');
+const path = require('node:path');
+const crypto = require('node:crypto');
+const { runSweep, deriveViolation, findNonMatchingValue, injectAndCheckBlock, SweepUnderivable } = require('./smoke-pod-workflow.cjs');
+
+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 FORMS_DIR = path.join(__dirname, '__fixtures__', 'sweep-forms');
+const FORMS_WF = path.join(FORMS_DIR, 'workflows', 'wf-forms.yaml');
+const FORMS_SMOKE = path.join(FORMS_DIR, 'workflows', 'wf-forms.smoke.json');
+const FORMS_SPEC = path.join(FORMS_DIR, 'specs', 'wf-forms.spec.json');
+const sha256File = (p) => crypto.createHash('sha256').update(fs.readFileSync(p)).digest('hex');
+
+// ===========================================================================
+// AC1/AC2/AC4 — sweep das 5 formas: todas bloqueiam, report com binding.
+// ===========================================================================
+const scenario = JSON.parse(fs.readFileSync(FORMS_SMOKE, 'utf8'));
+const res = runSweep({ workflowPath: FORMS_WF, podRoot: FORMS_DIR, scenario, specPath: FORMS_SPEC });
+
+ok(res.ok === true && res.underivable === null, 'AC1/2 sweep-forms VERDE — todas as provas bloquearam, zero underivável');
+ok(res.report.proofs.length === 9, `AC1/2 nº de provas = 9 (4×3a + 5×3b); obtido ${res.report.proofs.length}`);
+ok(res.report.proofs.every((p) => p.blocked === true), 'AC1/2 toda prova blocked:true (nenhum vazamento)');
+
+const forms3b = res.report.proofs.filter((p) => /^\d+:/.test(p.assertion)).map((p) => p.assertion.split(':')[1]);
+for (const form of ['field_matches', 'count_gte', 'section_exists', 'file_referenced_exists', 'json_schema_valid']) {
+  ok(forms3b.includes(form), `AC2 3b cobre a forma "${form}"`);
+}
+const step3a = res.report.proofs.filter((p) => p.assertion.startsWith('__template__')).map((p) => p.step);
+for (const s of ['s_field', 's_count', 's_section', 's_fileref']) {
+  ok(step3a.includes(s), `AC1 3a cobre a etapa "${s}" (seção obrigatória removida)`);
+}
+
+// Report com binding embutido (AC4) — spec_hash = sha256 da SPEC (não do wf).
+ok(res.report.workflow === 'wf-forms' && res.report.pod === 'sweep-forms', 'AC4 report embute {workflow, pod}');
+ok(res.report.spec_hash === sha256File(FORMS_SPEC), 'AC4 report.spec_hash = sha256(spec) — binding A.1 fecha o forward-compat da SF3.1');
+ok(res.report.proofs.every((p) => typeof p.step === 'string' && 'assertion' in p && typeof p.blocked === 'boolean'),
+  'AC4 cada prova é {step, assertion, blocked}');
+
+// memoryPodDir ISOLADO (AC4 / caveat SF2.4): sweep NÃO cria memória no pod real.
+ok(!fs.existsSync(path.join(FORMS_DIR, 'memory')),
+  'AC4 sweep NÃO appendou learning sintético na memória de produção do pod (memoryPodDir isolado)');
+
+// ===========================================================================
+// AC3 — UNDERIVABILIDADE: os 4 casos do DoD 3, cada um fail-loud (não blocked:true).
+// ===========================================================================
+function mkPod(caseName, { templateBody, assertion, artifact }) {
+  const dir = fs.mkdtempSync(path.join(os.tmpdir(), `pc-underiv-${caseName}-`));
+  fs.mkdirSync(path.join(dir, 'workflows'), { recursive: true });
+  fs.mkdirSync(path.join(dir, 'templates'), { recursive: true });
+  fs.writeFileSync(path.join(dir, 'templates', 't.md'), templateBody);
+  const wf = [
+    'state_machine:',
+    '  states: [init, running, complete, failed]',
+    '  initial: init',
+    '  terminal: [complete, failed]',
+    'steps:',
+    '  - id: s1',
+    '    agent: a1',
+    '    template: templates/t.md',
+    '    inputs: [x]',
+    '    outputs: [y]',
+    '    depends_on: []',
+    '    checkpoint: null',
+    '    veto:',
+    '      assertions:',
+    `        - ${JSON.stringify(assertion)}`,
+    '',
+  ].join('\n');
+  const wfPath = path.join(dir, 'workflows', 'wf-u.yaml');
+  fs.writeFileSync(wfPath, wf);
+  return { dir, wfPath, scenario: { target_step: 's1', artifacts: { s1: artifact } } };
+}
+
+const underivCases = [
+  ['field-universal', {
+    templateBody: '## Sec\n', assertion: { type: 'field_matches', field: 'v', pattern: '.*' },
+    artifact: '## Sec\nv: qualquer coisa\n', diag: /universal|sempre-true/i,
+  }],
+  ['json-no-required', {
+    templateBody: '', assertion: { type: 'json_schema_valid', schema: [] },
+    artifact: '{"a": 1}', diag: /required|degenerada|parse-error/i,
+  }],
+  ['section-nonorthogonal', {
+    templateBody: '## Body\n', assertion: { type: 'section_exists', section: '## Body' },
+    artifact: '## Body\nx\n', diag: /não-ortogonal|template/i,
+  }],
+  ['count-zero', {
+    templateBody: '## S\n', assertion: { type: 'count_gte', field: 'S', n: 0 },
+    artifact: '## S\n- a\n', diag: /degenerada|0>=0|n:0/i,
+  }],
+];
+
+for (const [name, spec] of underivCases) {
+  const { dir, wfPath, scenario: sc } = mkPod(name, spec);
+  const r = runSweep({ workflowPath: wfPath, podRoot: dir, scenario: sc });
+  ok(r.ok === false && r.underivable != null, `AC3 [${name}] → underivável fail-loud (ok:false)`);
+  ok(spec.diag.test(r.underivable.reason), `AC3 [${name}] diagnóstico de assertion degenerada/não-ortogonal ("${(r.underivable.reason || '').slice(0, 60)}…")`);
+  // anti-fallback + anti-skip: a assertion underivável NÃO virou blocked:true silencioso.
+  const leaked3b = (r.report.proofs || []).some((p) => /^\d+:/.test(p.assertion) && p.blocked === true);
+  ok(!leaked3b, `AC3 [${name}] anti-fallback: assertion underivável NÃO produziu blocked:true silencioso nem foi pulada`);
+  fs.rmSync(dir, { recursive: true, force: true });
+}
+
+// ===========================================================================
+// AC4 — blocked:false ⇒ ok:false (agregação fail-loud). Costura blockChecker:
+// prova o CONTRATO de vazamento (a enforcement real já foi provada acima).
+// ===========================================================================
+const leakRes = runSweep({
+  workflowPath: FORMS_WF, podRoot: FORMS_DIR, scenario, specPath: FORMS_SPEC,
+  blockChecker: (cfg, stepId) => stepId !== 's_json', // s_json "vaza" (não bloqueia)
+});
+ok(leakRes.ok === false && Array.isArray(leakRes.leaked) && leakRes.leaked.length >= 1,
+  'AC4 uma prova blocked:false ⇒ sweep ok:false com leaked[] populado (motor sabotado ⇒ exit 1)');
+ok(leakRes.leaked.every((l) => l.step === 's_json'),
+  'AC4 leaked[] nomeia exatamente a prova que vazou');
+
+// ===========================================================================
+// Unidade — findNonMatchingValue e deriveViolation (regra geral, não switch fechado).
+// ===========================================================================
+ok(findNonMatchingValue('.*').ok === false, 'unidade: findNonMatchingValue(".*") = universal (sem valor violador)');
+ok(findNonMatchingValue('[\\s\\S]*').ok === false, 'unidade: findNonMatchingValue("[\\s\\S]*") = universal');
+ok(findNonMatchingValue('^(ok|fail)$').ok === true, 'unidade: findNonMatchingValue("^(ok|fail)$") acha valor fora do pattern');
+let threw = false;
+try { deriveViolation({ type: 'tipo_inexistente' }, '', '', FORMS_DIR); } catch (e) { threw = e instanceof SweepUnderivable; }
+ok(threw, 'unidade: forma desconhecida ⇒ SweepUnderivable (Art. IV: PARA, não inventa 6ª regra)');
+
+// ===========================================================================
+// KILL-TEST PERMANENTE (finding QA #1) — o drive ISOLA a CLASSE de bloqueio: um
+// deriver que regredisse emitindo a violação da CLASSE ERRADA NÃO conta como blocked.
+// s_field/veto_violation quebra o VETO (status fora do pattern); s_field/template_violation
+// quebra a FORMA (sem `## Meta`). Se o expectClass não confere, blocked=false (pega o green-falso).
+// ===========================================================================
+// memoryPodDir ISOLADO também no kill-test (o drive é real; sem isso poluiria a memória do fixture).
+const cfgKill = { workflowPath: FORMS_WF, podRoot: FORMS_DIR, pod: 'sweep-forms', workflow: 'wf-forms', scenario, memoryPodDir: fs.mkdtempSync(path.join(os.tmpdir(), 'pc-kill-mem-')) };
+const vetoViol = '## Meta\nstatus: fora-do-pattern\n';   // quebra SÓ o veto (forma presente)
+const tmplViol = 'status: ok\n';                          // quebra SÓ a forma (## Meta ausente, veto passa)
+ok(injectAndCheckBlock(cfgKill, 's_field', vetoViol, 'veto') === true, 'kill-test: violação de VETO com expectClass=veto → blocked (classe certa)');
+ok(injectAndCheckBlock(cfgKill, 's_field', vetoViol, 'template') === false, 'kill-test: violação de VETO rotulada como 3a (expectClass=template) → NÃO conta como blocked (classe errada pega)');
+ok(injectAndCheckBlock(cfgKill, 's_field', tmplViol, 'template') === true, 'kill-test: violação de FORMA com expectClass=template → blocked (classe certa)');
+ok(injectAndCheckBlock(cfgKill, 's_field', tmplViol, 'veto') === false, 'kill-test: violação de FORMA rotulada como 3b (expectClass=veto) → NÃO conta como blocked (deriver 3b regredido é pego)');
+
+// ===========================================================================
+console.log(`\n${passed} asserções OK; ${failures.length} falha(s).`);
+if (failures.length) { for (const f of failures) console.error(`  ✗ ${f}`); process.exit(1); }
+console.log('smoke-sweep: sweep exaustivo + underivabilidade fail-loud provados.');
+process.exit(0);

package/scripts/validate-adopt.js

@@ -0,0 +1,235 @@
+#!/usr/bin/env node
+'use strict';
+/**
+ * validate-adopt.js — teste E2E do comando `power-claude adopt`.
+ *
+ * Monta um tmpdir simulando uma instalação FEITA À MÃO (sem manifest):
+ *   - alguns arquivos idênticos ao template,
+ *   - alguns modificados,
+ *   - alguns ausentes,
+ *   - um arquivo só do usuário (fora do template).
+ * Roda `node bin/cli.js adopt --yes` e verifica o manifest gerado, a não
+ * destrutividade e a composição com `update` (modificados preservados).
+ *
+ * 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 { walkFiles } = require('../installer/util');
+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 cp(src, dest) {
+  fs.mkdirSync(path.dirname(dest), { recursive: true });
+  fs.copyFileSync(src, dest);
+}
+
+function readManifest(tmpdir) {
+  try {
+    return JSON.parse(fs.readFileSync(path.join(tmpdir, '.power-claude', 'manifest.json'), 'utf8'));
+  } catch {
+    return null;
+  }
+}
+
+function main() {
+  console.log('POWER CLAUDE — validate-adopt (E2E)\n');
+
+  const tmpdir = fs.mkdtempSync(path.join(os.tmpdir(), 'power-claude-adopt-e2e-'));
+  console.log(`Diretório de teste: ${tmpdir}\n`);
+
+  try {
+    const templateFiles = walkFiles(TEMPLATE_DIR); // rels POSIX
+
+    // Escolhe 3 arquivos-fonte estáveis para os 3 papéis do fixture.
+    const IDENTICAL_REL = '.claude/CLAUDE.md';
+    const MODIFIED_REL = 'pods/README.md';
+    // Ausente: um arquivo real do template que NÃO criaremos no disco.
+    const ABSENT_REL = '.claude/hooks/enforce-git-push-authority.cjs';
+    for (const [name, rel] of [
+      ['IDENTICAL', IDENTICAL_REL],
+      ['MODIFIED', MODIFIED_REL],
+      ['ABSENT', ABSENT_REL],
+    ]) {
+      if (!templateFiles.includes(rel)) {
+        check(`fixture: ${name} (${rel}) existe no template`, false, 'arquivo-âncora sumiu do template');
+        finish(tmpdir);
+        return;
+      }
+    }
+
+    // Copia TODOS os arquivos do template para o disco (instalação à mão),
+    // EXCETO o ABSENT_REL. Modifica o MODIFIED_REL. IDENTICAL_REL fica igual.
+    for (const rel of templateFiles) {
+      if (rel === ABSENT_REL) continue;
+      const src = path.join(TEMPLATE_DIR, ...rel.split('/'));
+      const dest = path.join(tmpdir, ...rel.split('/'));
+      cp(src, dest);
+    }
+    // Modifica o MODIFIED_REL (append de conteúdo do usuário).
+    const modifiedPath = path.join(tmpdir, ...MODIFIED_REL.split('/'));
+    const modifiedContent = fs.readFileSync(modifiedPath, 'utf8') + '\n<!-- edição manual do usuário -->\n';
+    fs.writeFileSync(modifiedPath, modifiedContent, 'utf8');
+    const modifiedUserHash = sha256OfFile(modifiedPath);
+    const templateModifiedHash = sha256OfFile(path.join(TEMPLATE_DIR, ...MODIFIED_REL.split('/')));
+
+    // Arquivo SÓ do usuário, fora do template — nunca deve ser tocado.
+    const USER_ONLY_REL = 'docs/minhas-notas.md';
+    const userOnlyPath = path.join(tmpdir, ...USER_ONLY_REL.split('/'));
+    const userOnlyContent = '# Notas do usuário\nconteúdo intocável\n';
+    fs.mkdirSync(path.dirname(userOnlyPath), { recursive: true });
+    fs.writeFileSync(userOnlyPath, userOnlyContent, 'utf8');
+    const userOnlyHash = sha256OfFile(userOnlyPath);
+
+    // Scripts do motor (ADR-007) — fora do template, vêm do pacote. Monta 3 papéis:
+    //   idêntico  = pod-memory.cjs (cópia byte-idêntica do pacote)
+    //   modificado= watcher-audit.cjs (cópia + edição do usuário)
+    //   ausente   = forge-generate.cjs (não criado no disco)
+    const MOTOR_IDENTICAL = 'scripts/pod-memory.cjs';
+    const MOTOR_MODIFIED = 'scripts/watcher-audit.cjs';
+    const MOTOR_ABSENT = 'scripts/forge-generate.cjs';
+    cp(path.join(REPO_ROOT, ...MOTOR_IDENTICAL.split('/')), path.join(tmpdir, ...MOTOR_IDENTICAL.split('/')));
+    const motorModPath = path.join(tmpdir, ...MOTOR_MODIFIED.split('/'));
+    cp(path.join(REPO_ROOT, ...MOTOR_MODIFIED.split('/')), motorModPath);
+    fs.writeFileSync(motorModPath, fs.readFileSync(motorModPath, 'utf8') + '\n// edição do usuário\n', 'utf8');
+    const motorModUserHash = sha256OfFile(motorModPath);
+    const motorPkgHash = sha256OfFile(path.join(REPO_ROOT, ...MOTOR_MODIFIED.split('/')));
+
+    // Sem manifest no disco (instalação à mão).
+    check('fixture sem manifest antes do adopt', !fs.existsSync(path.join(tmpdir, '.power-claude', 'manifest.json')));
+
+    // 1. adopt --yes
+    const adopt = spawnSync(process.execPath, [CLI, 'adopt', '--yes'], {
+      cwd: tmpdir,
+      encoding: 'utf8',
+      timeout: 120000,
+    });
+    const ok = check('adopt --yes termina com exit 0', adopt.status === 0, `exit ${adopt.status}`);
+    if (!ok) {
+      console.error('\n--- stdout ---\n' + (adopt.stdout || ''));
+      console.error('\n--- stderr ---\n' + (adopt.stderr || ''));
+      finish(tmpdir);
+      return;
+    }
+
+    const manifest = readManifest(tmpdir);
+    check('.power-claude/manifest.json parseia', manifest !== null);
+    if (!manifest) {
+      finish(tmpdir);
+      return;
+    }
+    check('manifest tem version e installedAt', Boolean(manifest.version && manifest.installedAt));
+
+    const byPath = new Map(manifest.files.map((f) => [f.path, f]));
+
+    // Idêntico: rastreado com sha do disco (= template).
+    const idEntry = byPath.get(IDENTICAL_REL);
+    check(
+      'idêntico rastreado com sha do template (sem flag)',
+      Boolean(idEntry) && !idEntry.origin && idEntry.sha256 === sha256OfFile(path.join(TEMPLATE_DIR, ...IDENTICAL_REL.split('/'))),
+      idEntry ? `origin=${idEntry.origin || 'none'}` : 'ausente'
+    );
+
+    // Modificado: rastreado COM flag e sha=baseline do template (faz o update preservar).
+    const modEntry = byPath.get(MODIFIED_REL);
+    check(
+      'modificado rastreado com origin="modified"',
+      Boolean(modEntry) && modEntry.origin === 'modified',
+      modEntry ? `origin=${modEntry.origin}` : 'ausente'
+    );
+    check(
+      'modificado usa baseline do template (sha != disco) → update preserva',
+      Boolean(modEntry) && modEntry.sha256 === templateModifiedHash && modEntry.sha256 !== modifiedUserHash
+    );
+
+    // Ausente: NÃO escrito e NÃO rastreado (declinado em --yes).
+    check('ausente NÃO foi escrito no disco', !fs.existsSync(path.join(tmpdir, ...ABSENT_REL.split('/'))));
+    check('ausente NÃO entrou no manifest (declinado em --yes)', !byPath.has(ABSENT_REL));
+
+    // Arquivo do usuário fora do template: intocado e fora do manifest.
+    check('arquivo só-do-usuário intocado', fs.existsSync(userOnlyPath) && sha256OfFile(userOnlyPath) === userOnlyHash);
+    check('arquivo só-do-usuário NÃO entrou no manifest', !byPath.has(USER_ONLY_REL));
+
+    // Não destrutivo: o modificado no disco continua com o conteúdo do usuário.
+    check(
+      'adopt não sobrescreveu o arquivo modificado',
+      sha256OfFile(modifiedPath) === modifiedUserHash
+    );
+
+    // Scripts do motor: adopt classifica igual/modificado/ausente como o template.
+    const motorId = byPath.get(MOTOR_IDENTICAL);
+    check(
+      'motor idêntico rastreado sem flag (sha do pacote)',
+      Boolean(motorId) && !motorId.origin && motorId.sha256 === sha256OfFile(path.join(REPO_ROOT, ...MOTOR_IDENTICAL.split('/'))),
+      motorId ? `origin=${motorId.origin || 'none'}` : 'ausente'
+    );
+    const motorMod = byPath.get(MOTOR_MODIFIED);
+    check(
+      'motor modificado rastreado com origin="modified" e baseline do pacote → update preserva',
+      Boolean(motorMod) && motorMod.origin === 'modified' && motorMod.sha256 === motorPkgHash && motorMod.sha256 !== motorModUserHash
+    );
+    check('motor ausente NÃO entrou no manifest (declinado em --yes)', !byPath.has(MOTOR_ABSENT));
+    check('motor ausente NÃO foi escrito no disco', !fs.existsSync(path.join(tmpdir, ...MOTOR_ABSENT.split('/'))));
+
+    // 2. Re-adopt: detecta manifest e sai limpo sem alterar nada.
+    const manifestBefore = fs.readFileSync(path.join(tmpdir, '.power-claude', 'manifest.json'), 'utf8');
+    const readopt = spawnSync(process.execPath, [CLI, 'adopt', '--yes'], { cwd: tmpdir, encoding: 'utf8', timeout: 120000 });
+    check('re-adopt sai com exit 0 (manifest já existe)', readopt.status === 0, `exit ${readopt.status}`);
+    check('re-adopt orienta usar update', /update/.test(readopt.stdout || ''));
+    check(
+      're-adopt não altera o manifest',
+      fs.readFileSync(path.join(tmpdir, '.power-claude', 'manifest.json'), 'utf8') === manifestBefore
+    );
+
+    // 3. Composição com update: modificado preservado; ausente instalado pelo update.
+    const update = spawnSync(process.execPath, [CLI, 'update', '--yes'], { cwd: tmpdir, encoding: 'utf8', timeout: 120000 });
+    check('update --yes após adopt termina com exit 0', update.status === 0, `exit ${update.status}`);
+    check(
+      'update PRESERVOU o arquivo modificado pelo usuário',
+      sha256OfFile(modifiedPath) === modifiedUserHash
+    );
+    check(
+      'update PRESERVOU o script do motor modificado (mesmo contrato do template)',
+      sha256OfFile(motorModPath) === motorModUserHash
+    );
+
+    // 4. doctor roda sobre a instalação adotada.
+    const doctor = spawnSync(process.execPath, [CLI, 'doctor'], { cwd: tmpdir, encoding: 'utf8', timeout: 120000 });
+    check('doctor executa na instalação adotada (exit 0 ou 1 determinístico)', doctor.status === 0 || doctor.status === 1, `exit ${doctor.status}`);
+  } 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 do adopt FALHOU:');
+    for (const f of failed) console.error(`  - ${f.label}${f.detail ? ` (${f.detail})` : ''}`);
+    process.exit(1);
+  }
+  console.log('E2E do adopt verde.');
+  process.exit(0);
+}
+
+main();

package/scripts/validate-branding.js

@@ -0,0 +1,84 @@
+#!/usr/bin/env node
+'use strict';
+/**
+ * validate-branding.js — gate de branding do POWER CLAUDE.
+ *
+ * Varre template/, bin/, installer/, README.md e docs/mecanismos/ procurando
+ * (case-insensitive) termos proibidos de frameworks/autores anteriores. Exit 1
+ * listando arquivo:linha de cada ocorrência; exit 0 = branding limpo.
+ *
+ * Escopo do gate (SF7.12): enforcement é por TOKEN de identidade (lista fechada
+ * abaixo) — a régua funcional-vs-gratuito de FRASES de contraste fica com
+ * revisão humana (heurística de frase seria frágil; decisão registrada na story).
+ *
+ * Node >= 18, sem dependências externas.
+ */
+
+const fs = require('node:fs');
+const path = require('node:path');
+
+const REPO_ROOT = path.resolve(__dirname, '..');
+const SCAN_TARGETS = ['template', 'bin', 'installer', 'README.md', 'docs/mecanismos'];
+const FORBIDDEN_TERMS = ['aiox', 'oalanicolas', 'alan nicolas', 'pedro-valerio', 'thiago_finch'];
+
+function isProbablyBinary(buf) {
+  const sample = buf.subarray(0, 8000);
+  return sample.includes(0);
+}
+
+function collectFiles(target) {
+  const full = path.join(REPO_ROOT, target);
+  if (!fs.existsSync(full)) return [];
+  const stat = fs.statSync(full);
+  if (stat.isFile()) return [full];
+  const out = [];
+  const stack = [full];
+  while (stack.length > 0) {
+    const dir = stack.pop();
+    for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
+      const p = path.join(dir, entry.name);
+      if (entry.isDirectory()) stack.push(p);
+      else if (entry.isFile()) out.push(p);
+    }
+  }
+  return out.sort();
+}
+
+function scanFile(filePath) {
+  const buf = fs.readFileSync(filePath);
+  if (isProbablyBinary(buf)) return [];
+  const violations = [];
+  const lines = buf.toString('utf8').split(/\r?\n/);
+  lines.forEach((line, idx) => {
+    const lower = line.toLowerCase();
+    for (const term of FORBIDDEN_TERMS) {
+      if (lower.includes(term)) {
+        violations.push({ line: idx + 1, term, text: line.trim() });
+      }
+    }
+  });
+  return violations;
+}
+
+function main() {
+  let total = 0;
+  for (const target of SCAN_TARGETS) {
+    for (const filePath of collectFiles(target)) {
+      const rel = path.relative(REPO_ROOT, filePath);
+      for (const v of scanFile(filePath)) {
+        total++;
+        console.error(`${rel}:${v.line}: termo proibido "${v.term}" — ${v.text.slice(0, 100)}`);
+      }
+    }
+  }
+  if (total > 0) {
+    console.error(`\n${total} ocorrência(s) de branding proibido. Gate vermelho.`);
+    process.exit(1);
+  }
+  console.log('Branding limpo.');
+  process.exit(0);
+}
+
+module.exports = { FORBIDDEN_TERMS, SCAN_TARGETS };
+
+if (require.main === module) main();

package/scripts/validate-budgets.js

@@ -0,0 +1,140 @@
+#!/usr/bin/env node
+/**
+ * validate-budgets.js — gate de orçamento de ativação dos agentes de pod.
+ *
+ * Percorre pods/<pod>/agents/<agente>.md, parseia o frontmatter e valida:
+ *   (a) budget_tokens declarado
+ *   (b) tokens estimados (bytes/4) <= budget_tokens declarado
+ *   (c) tokens estimados <= teto global (1500)
+ *   (d) arquivo <= 150 linhas
+ *
+ * Exit 0 com tabela de status; exit 1 listando cada violação.
+ * Node >= 18, sem dependências externas.
+ */
+'use strict';
+
+const fs = require('node:fs');
+const path = require('node:path');
+
+const REPO_ROOT = path.resolve(__dirname, '..');
+// Diretórios a varrer: args CLI (1+) > env PODS_DIR > defaults (./pods e ./.claude/agents).
+// Cada diretório pode ter layout de pods (<dir>/<pod>/agents/*.md) ou flat (<dir>/*.md).
+// Ex.: `node scripts/validate-budgets.js template/pods template/.claude/agents` no repo do framework.
+const argDirs = process.argv.slice(2);
+const defaultDirs = [
+  process.env.PODS_DIR || path.join(REPO_ROOT, 'pods'),
+  path.join(REPO_ROOT, '.claude', 'agents'),
+];
+const SCAN_DIRS = (argDirs.length ? argDirs : defaultDirs)
+  .map((d) => path.resolve(d))
+  .filter((d) => fs.existsSync(d));
+const GLOBAL_TOKEN_CAP = 1500;
+const MAX_LINES = 150;
+
+function parseFrontmatter(content) {
+  const match = content.match(/^---\r?\n([\s\S]*?)\r?\n---/);
+  if (!match) return null;
+  const fields = {};
+  for (const line of match[1].split(/\r?\n/)) {
+    const kv = line.match(/^([A-Za-z_][\w-]*):\s*(.*)$/);
+    if (kv) fields[kv[1]] = kv[2].trim().replace(/^["']|["']$/g, '');
+  }
+  return fields;
+}
+
+function collectAgentFiles() {
+  const files = [];
+  for (const dir of SCAN_DIRS) {
+    let flat = false;
+    for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
+      if (entry.isFile() && entry.name.endsWith('.md') && entry.name !== 'README.md') {
+        files.push(path.join(dir, entry.name));
+        flat = true;
+      }
+    }
+    if (flat) continue; // layout flat (ex.: .claude/agents)
+    for (const pod of fs.readdirSync(dir, { withFileTypes: true })) {
+      if (!pod.isDirectory()) continue;
+      const agentsDir = path.join(dir, pod.name, 'agents');
+      if (!fs.existsSync(agentsDir)) continue;
+      for (const entry of fs.readdirSync(agentsDir, { withFileTypes: true })) {
+        if (entry.isFile() && entry.name.endsWith('.md')) {
+          files.push(path.join(agentsDir, entry.name));
+        }
+      }
+    }
+  }
+  return files.sort();
+}
+
+function validate(filePath) {
+  const content = fs.readFileSync(filePath, 'utf8');
+  const bytes = Buffer.byteLength(content, 'utf8');
+  const estTokens = Math.ceil(bytes / 4);
+  const lines = content.split(/\r?\n/).length;
+  const fm = parseFrontmatter(content);
+  const rel = path.relative(REPO_ROOT, filePath);
+  const name = (fm && fm.name) || path.basename(filePath, '.md');
+
+  const errors = [];
+  let budget = null;
+
+  if (!fm || !fm.budget_tokens) {
+    errors.push('budget_tokens nao declarado no frontmatter');
+  } else {
+    budget = Number.parseInt(fm.budget_tokens, 10);
+    if (!Number.isFinite(budget) || budget <= 0) {
+      errors.push(`budget_tokens invalido: "${fm.budget_tokens}"`);
+      budget = null;
+    } else if (estTokens > budget) {
+      errors.push(`excede o proprio budget: ~${estTokens} tokens > ${budget}`);
+    }
+  }
+  if (estTokens > GLOBAL_TOKEN_CAP) {
+    errors.push(`excede o teto global: ~${estTokens} tokens > ${GLOBAL_TOKEN_CAP}`);
+  }
+  if (lines > MAX_LINES) {
+    errors.push(`excede o limite de linhas: ${lines} > ${MAX_LINES}`);
+  }
+
+  return { name, rel, lines, estTokens, budget, errors };
+}
+
+function main() {
+  const files = collectAgentFiles();
+  if (files.length === 0) {
+    console.error(`Nenhum agente encontrado em: ${SCAN_DIRS.map((d) => path.relative(REPO_ROOT, d)).join(', ') || '(nenhum diretório existente)'}`);
+    process.exit(1);
+  }
+
+  const results = files.map(validate);
+  const failed = results.filter((r) => r.errors.length > 0);
+
+  const headers = ['agente', 'linhas', 'tokens est.', 'budget', 'status'];
+  const rows = results.map((r) => [
+    r.name,
+    String(r.lines),
+    String(r.estTokens),
+    r.budget === null ? '—' : String(r.budget),
+    r.errors.length === 0 ? 'OK' : 'FALHA',
+  ]);
+  const widths = headers.map((h, i) => Math.max(h.length, ...rows.map((row) => row[i].length)));
+  const fmtRow = (row) => row.map((cell, i) => cell.padEnd(widths[i])).join(' | ');
+
+  console.log(fmtRow(headers));
+  console.log(widths.map((w) => '-'.repeat(w)).join('-|-'));
+  for (const row of rows) console.log(fmtRow(row));
+
+  if (failed.length > 0) {
+    console.error('\nVIOLACOES:');
+    for (const r of failed) {
+      for (const err of r.errors) console.error(`  ${r.rel}: ${err}`);
+    }
+    console.error(`\n${failed.length} agente(s) reprovado(s) de ${results.length}.`);
+    process.exit(1);
+  }
+  console.log(`\n${results.length} agente(s) validado(s). Gate verde.`);
+  process.exit(0);
+}
+
+main();