@daniellins/power-claude 0.16.3

package/scripts/validate-no-clone.cjs

@@ -0,0 +1,220 @@
+#!/usr/bin/env node
+'use strict';
+/**
+ * validate-no-clone.cjs — lint DETERMINÍSTICO da regra 3 (clonagem), classe
+ * TOKEN-DETECTÁVEL (Decisão E.1 do design *migrate-squad; SF3.3 P0.5).
+ *
+ * A regra 3 do ledger: métodos de figuras públicas migram COM fonte citada;
+ * clones/marcas do ecossistema anterior NÃO migram. Este lint cobre a classe que
+ * um token detecta — o RESIDUAL (persona parafraseada SEM token: tom/1ª pessoa/
+ * bordões copiados com o nome removido) é dívida DECLARADA e fica com o gate
+ * adversarial do pod-critic (dimensão anti-persona do G6, E.2). O lint NÃO
+ * pretende "resolver a regra 3 por máquina" — esse foi o overclaim da v1.
+ *
+ * Denylist (E.1.1) SEM lista mágica — derivada do squad-fonte quando dado:
+ *   - `source_mind` do squad-io.yaml legado (+ sobrenome/token ≥5 chars);
+ *   - nome do squad;
+ *   - prefixos dos agentes legados (agents/<prefixo>-*.md);
+ *   - + FORBIDDEN_TERMS de validate-branding.js (fonte única, importada).
+ *
+ * Regras de FAIL:
+ *   1. IDENTIDADE (E.1.2) — token na denylist em filename, `name:`/`description:`
+ *      de frontmatter, ou nome de step/agent (spec/wf). Nunca excusável por citação.
+ *   2. PERSONA com token (E.1.3) — `você é <mind>`, `encarne <mind>`,
+ *      `persona de <mind>`, `atue como <mind>`, assinatura em 1ª pessoa (`— <mind>`).
+ *      Assunção de persona é FAIL mesmo com citação (citar ≠ encarnar).
+ *   3. TOKEN em prosa SEM citação — token da denylist numa linha sem marcador de
+ *      fonte (`> Fonte:`, `[SOURCE:`, `Fonte:`). Citação é PERMITIDA e OBRIGATÓRIA.
+ *   4. KNOWLEDGE sem `Fonte:` (E.1.4) — todo arquivo passado via --knowledge deve
+ *      ter ≥1 linha de fonte citada; sem ela → FAIL.
+ *
+ * CLI:
+ *   node scripts/validate-no-clone.cjs <path...> [--squad-source <legacyDir>] [--knowledge <dir>]...
+ *   Exit 0 = limpo; exit 1 = listando arquivo:linha de cada violação.
+ *
+ * Integrado ao gate junto com validate-budgets.js/validate-branding.js
+ * (npm run validate). Node >= 18, sem dependências externas.
+ */
+
+const fs = require('node:fs');
+const path = require('node:path');
+const { FORBIDDEN_TERMS } = require('./validate-branding.js');
+
+const REPO_ROOT = path.resolve(__dirname, '..');
+const CITATION_MARKERS = [/>\s*Fonte:/i, /\[SOURCE:/i, /\bFonte:/i];
+const PERSONA_VERBS = ['você é', 'voce e', 'encarne', 'persona de', 'atue como', 'incorpore o mind', 'assuma a persona'];
+
+function isProbablyBinary(buf) {
+  return buf.subarray(0, 8000).includes(0);
+}
+
+function collectFiles(target) {
+  const full = path.isAbsolute(target) ? target : path.join(REPO_ROOT, target);
+  if (!fs.existsSync(full)) return [];
+  if (fs.statSync(full).isFile()) return [full];
+  const out = [];
+  const stack = [full];
+  while (stack.length) {
+    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();
+}
+
+/** Deriva a denylist do squad-fonte (E.1.1) — sem lista mágica. */
+function deriveDenylist(squadSource) {
+  const terms = new Set(FORBIDDEN_TERMS.map((t) => t.toLowerCase()));
+  if (!squadSource) return terms;
+  const abs = path.isAbsolute(squadSource) ? squadSource : path.join(REPO_ROOT, squadSource);
+  // source_mind + squad name do squad-io.yaml.
+  const ioPath = path.join(abs, 'squad-io.yaml');
+  if (fs.existsSync(ioPath)) {
+    const io = fs.readFileSync(ioPath, 'utf8');
+    const mind = io.match(/^\s*source_mind:\s*["']?([^"'\n]+)["']?/m);
+    if (mind) {
+      const phrase = mind[1].trim().toLowerCase();
+      terms.add(phrase);
+      for (const w of phrase.split(/\s+/)) if (w.length >= 5) terms.add(w);
+    }
+    const sq = io.match(/^\s*squad:\s*["']?([^"'\n]+)["']?/m);
+    if (sq) terms.add(sq[1].trim().toLowerCase());
+  }
+  // prefixos dos agentes legados: agents/<prefixo>-*.md.
+  const agentsDir = path.join(abs, 'agents');
+  if (fs.existsSync(agentsDir)) {
+    for (const f of fs.readdirSync(agentsDir)) {
+      if (!f.endsWith('.md')) continue;
+      const base = f.replace(/\.md$/, '');
+      const prefix = base.includes('-') ? base.slice(0, base.indexOf('-')) : base;
+      if (prefix.length >= 4) terms.add(prefix.toLowerCase());
+    }
+  }
+  // nome do diretório do squad como fallback de nome.
+  terms.add(path.basename(abs).toLowerCase());
+  return terms;
+}
+
+function hasCitation(line) {
+  return CITATION_MARKERS.some((re) => re.test(line));
+}
+
+function tokenIn(text, terms) {
+  const lower = text.toLowerCase();
+  for (const t of terms) if (t && lower.includes(t)) return t;
+  return null;
+}
+
+function frontmatter(content) {
+  const m = content.match(/^---\r?\n([\s\S]*?)\r?\n---/);
+  return m ? m[1] : '';
+}
+
+/** Varre UM arquivo pelas regras 1-3. Retorna [{ line, rule, term, text }]. */
+function scanClone(filePath, terms) {
+  const buf = fs.readFileSync(filePath);
+  if (isProbablyBinary(buf)) return [];
+  const content = buf.toString('utf8');
+  const violations = [];
+  const base = path.basename(filePath);
+
+  // Regra 1 — IDENTIDADE: filename.
+  const fnTerm = tokenIn(base, terms);
+  if (fnTerm) violations.push({ line: 0, rule: 'identidade/filename', term: fnTerm, text: base });
+
+  // Regra 1 — IDENTIDADE: name:/description: do frontmatter.
+  const fm = frontmatter(content);
+  for (const key of ['name', 'description']) {
+    const kv = fm.match(new RegExp(`^\\s*${key}:\\s*(.+)$`, 'm'));
+    if (kv) {
+      const t = tokenIn(kv[1], terms);
+      if (t) violations.push({ line: 0, rule: `identidade/${key}`, term: t, text: kv[1].trim().slice(0, 80) });
+    }
+  }
+
+  const lines = content.split(/\r?\n/);
+  lines.forEach((line, idx) => {
+    const lower = line.toLowerCase();
+    const term = tokenIn(line, terms);
+    // Regra 2 — PERSONA com token (FAIL mesmo com citação).
+    const verb = PERSONA_VERBS.find((v) => lower.includes(v));
+    if (verb && term) {
+      violations.push({ line: idx + 1, rule: 'persona', term, text: line.trim().slice(0, 80) });
+      return;
+    }
+    // assinatura em 1ª pessoa: linha `— <mind>` / `- <mind>` no fim.
+    if (term && /^\s*[—-]\s*/.test(line) && lower.trim().replace(/^[—-]\s*/, '').startsWith(term)) {
+      violations.push({ line: idx + 1, rule: 'persona/assinatura', term, text: line.trim().slice(0, 80) });
+      return;
+    }
+    // Regra 3 — token em prosa SEM citação.
+    if (term && !hasCitation(line)) {
+      violations.push({ line: idx + 1, rule: 'token-sem-fonte', term, text: line.trim().slice(0, 80) });
+    }
+  });
+  return violations;
+}
+
+/** Regra 4 — KNOWLEDGE sem `Fonte:`. */
+function scanKnowledge(filePath) {
+  const buf = fs.readFileSync(filePath);
+  if (isProbablyBinary(buf)) return [];
+  const content = buf.toString('utf8');
+  if (!/^\s*(>?\s*)?\[?(SOURCE|Fonte):/im.test(content)) {
+    return [{ line: 0, rule: 'knowledge-sem-fonte', term: '(fonte)', text: path.basename(filePath) }];
+  }
+  return [];
+}
+
+function parseArgs(argv) {
+  const targets = [];
+  const knowledge = [];
+  let squadSource = null;
+  for (let i = 0; i < argv.length; i++) {
+    const a = argv[i];
+    if (a === '--squad-source') squadSource = argv[++i];
+    else if (a === '--knowledge') knowledge.push(argv[++i]);
+    else targets.push(a);
+  }
+  return { targets, knowledge, squadSource };
+}
+
+function run(argv) {
+  const { targets, knowledge, squadSource } = parseArgs(argv);
+  const terms = deriveDenylist(squadSource);
+  const violations = [];
+  for (const target of targets) {
+    for (const file of collectFiles(target)) {
+      for (const v of scanClone(file, terms)) violations.push({ file, ...v });
+    }
+  }
+  for (const kdir of knowledge) {
+    for (const file of collectFiles(kdir)) {
+      if (!file.endsWith('.md')) continue;
+      for (const v of scanKnowledge(file)) violations.push({ file, ...v });
+    }
+  }
+  return { violations, denylistSize: terms.size };
+}
+
+function main() {
+  const { violations } = run(process.argv.slice(2));
+  if (violations.length) {
+    for (const v of violations) {
+      const rel = path.relative(REPO_ROOT, v.file);
+      const loc = v.line ? `${rel}:${v.line}` : rel;
+      console.error(`${loc}: [${v.rule}] token "${v.term}" — ${v.text}`);
+    }
+    console.error(`\n${violations.length} violação(ões) da regra 3 (classe token-detectável). Gate vermelho.`);
+    process.exit(1);
+  }
+  console.log('Regra 3 (token-detectável): limpo.');
+  process.exit(0);
+}
+
+module.exports = { run, deriveDenylist, scanClone, scanKnowledge, hasCitation };
+
+if (require.main === module) main();

package/scripts/validate-no-clone.test.cjs

@@ -0,0 +1,77 @@
+#!/usr/bin/env node
+'use strict';
+/**
+ * validate-no-clone.test.cjs — suíte PRÓPRIA do lint da regra 3 (Story SF3.3, AC5).
+ * Prova a classe TOKEN-DETECTÁVEL (E.1) com fixture positiva E negativa; o residual
+ * (persona parafraseada sem token) NÃO é testado aqui — é dívida declarada do G6.
+ * Cobre:
+ *   - denylist derivada do squad-fonte (source_mind + prefixo de agente + squad name).
+ *   - FAIL identidade (filename + name:) no estilo hormozi-*.
+ *   - FAIL persona com token ("você é Alex Hormozi", "encarne").
+ *   - PASS agente capability-based com `> Fonte:`.
+ *   - FAIL/PASS knowledge (sem/com `Fonte:`).
+ *   - gate default (só FORBIDDEN_TERMS) sobre template/ → limpo.
+ *
+ * Node >= 18. Exit 0/1.
+ */
+
+const path = require('node:path');
+const v = require('./validate-no-clone.cjs');
+
+const FIX = path.join(__dirname, '__fixtures__', 'migrate-squad');
+const LEGACY = path.join(FIX, 'legacy-squad');
+const AUTH = path.join(FIX, 'authored');
+
+let passed = 0;
+const failures = [];
+function ok(cond, label) {
+  if (cond) { passed++; console.log(`[OK   ] ${label}`); }
+  else { failures.push(label); console.log(`[FALHA] ${label}`); }
+}
+
+// denylist derivada do squad-fonte.
+{
+  const terms = v.deriveDenylist(LEGACY);
+  ok(terms.has('alex hormozi') && terms.has('hormozi'), 'denylist deriva source_mind (frase + sobrenome ≥5) do squad-io.yaml');
+  ok(terms.has('aiox'), 'denylist inclui FORBIDDEN_TERMS de validate-branding (fonte única)');
+}
+
+// FAIL — agente legado hormozi-offer.md: identidade + persona com token.
+{
+  const { violations } = v.run([path.join(LEGACY, 'agents', 'hormozi-offer.md'), '--squad-source', LEGACY]);
+  const rules = new Set(violations.map((x) => x.rule));
+  ok(rules.has('identidade/filename'), 'FAIL identidade: filename hormozi-*.md (nome de marca)');
+  ok(rules.has('identidade/name'), 'FAIL identidade: name: hormozi-* no frontmatter');
+  ok([...rules].some((r) => r.startsWith('persona')), 'FAIL persona: "você é Alex Hormozi"/"encarne" com token');
+  ok(violations.length >= 3, 'FAIL agente legado acumula ≥3 violações');
+}
+
+// PASS — agente capability-based com citação obrigatória (> Fonte:).
+{
+  const { violations } = v.run([path.join(AUTH, 'agents', 'offer-engineer.md'), '--squad-source', LEGACY]);
+  ok(violations.length === 0, 'PASS offer-engineer.md (metodologia com `> Fonte: $100M Offers`, sem persona)');
+}
+
+// Knowledge — regra 4.
+{
+  const bad = v.run(['--knowledge', path.join(AUTH, 'knowledge', 'no-source.md')]);
+  ok(bad.violations.length === 1 && bad.violations[0].rule === 'knowledge-sem-fonte', 'FAIL knowledge sem `Fonte:`');
+  const good = v.run(['--knowledge', path.join(AUTH, 'knowledge', 'value-stack-method.md')]);
+  ok(good.violations.length === 0, 'PASS knowledge COM `Fonte:` citada');
+}
+
+// Citação PERMITE mencionar o mind em prosa; persona ainda REPROVA mesmo citando.
+{
+  ok(v.hasCitation('> Fonte: método público de Alex Hormozi'), 'citação `> Fonte:` reconhecida como marcador válido');
+}
+
+// Gate default (sem --squad-source): só FORBIDDEN_TERMS; template/ limpo.
+{
+  const { violations, denylistSize } = v.run([path.join(__dirname, '..', 'template')]);
+  ok(denylistSize >= 5, 'gate default usa denylist = FORBIDDEN_TERMS (sem lista mágica extra)');
+  ok(violations.length === 0, 'gate default sobre template/ → limpo (integração npm run validate)');
+}
+
+console.log(`\n${passed} verificações OK, ${failures.length} falha(s).`);
+if (failures.length) { for (const f of failures) console.error(`  - ${f}`); process.exit(1); }
+process.exit(0);

package/scripts/validate-pipeline.cjs

@@ -0,0 +1,145 @@
+#!/usr/bin/env node
+'use strict';
+/**
+ * validate-pipeline.cjs — validador ESTÁTICO do contrato cross-pod `pipeline-<id>.yaml`
+ * (Story SF9.1/ADR-017 Decisão 1). Script NOVO, distinto de validate-pod-workflow.cjs (o
+ * validador intra-pod é consumido pelos 7 pods; misturar lógica cross-pod ali os arriscaria).
+ *
+ * Prova, SEM EXECUTAR NADA, que um pipeline está BEM-FORMADO:
+ *   1. Schema      — topo {id, deliverable, phases[]}; fase {id, pod, workflow, outputs≥1};
+ *                    inputs?/gate? opcionais; ids de fase únicos.
+ *   2. Referências — cada pod/workflow existe em disco (<pods-root>/<pod>/workflows/<wf>.yaml).
+ *   3. Sequencial  — inputs de uma fase referenciam SÓ outputs de uma fase ANTERIOR de fato
+ *                    declarada (nunca fase futura/self/ inexistente) — sem ciclo por construção.
+ *   4. Portão      — gate.veto[] reduz às formas de VETO_TYPES (reusa o vocabulário intra-pod,
+ *                    incl. command_check blessed); gate.checkpoint{criteria} bem-formado.
+ *
+ * Uso: node scripts/validate-pipeline.cjs <pipeline.yaml> [...] [--pods-root <dir>]
+ * Exit 0 = contrato bem-formado; exit != 0 = primeira violação nomeada. Node >= 18, zero-dep.
+ */
+
+const fs = require('node:fs');
+const path = require('node:path');
+const {
+  parseYaml, VETO_TYPES, checkCommandCheckSafety, checkJsonSchemaExtract, Fail,
+} = require('./validate-pod-workflow.cjs');
+
+const REPO_ROOT = path.resolve(__dirname, '..');
+function fail(msg) { throw new Fail(msg); }
+function isMap(v) { return v !== null && typeof v === 'object' && !Array.isArray(v); }
+
+/** Valida a forma de UMA asserção de veto do portão (reusa o vocabulário intra-pod). */
+function checkGateAssertion(a, where) {
+  if (!isMap(a)) fail(`${where}: asserção de portão é prosa/valor livre, não asserção estruturada (formas: ${Object.keys(VETO_TYPES).join(', ')})`);
+  if (typeof a.type !== 'string' || !(a.type in VETO_TYPES)) {
+    fail(`${where}: type de portão inválido ("${a.type}") — não redutível a asserção de máquina (formas: ${Object.keys(VETO_TYPES).join(', ')})`);
+  }
+  for (const req of VETO_TYPES[a.type]) {
+    if (!(req in a) || a[req] === null || a[req] === '') fail(`${where}: asserção (type=${a.type}) sem campo obrigatório "${req}"`);
+  }
+  if (a.type === 'field_matches') {
+    try { new RegExp(String(a.pattern)); } catch (e) { fail(`${where}: field_matches com regex inválida: ${e.message}`); }
+  }
+  if (a.type === 'command_check') { try { checkCommandCheckSafety(a); } catch (e) { fail(`${where}: ${e.message}`); } }
+  if (a.type === 'json_schema_valid') { try { checkJsonSchemaExtract(a); } catch (e) { fail(`${where}: ${e.message}`); } }
+}
+
+function podsRootFor(override) {
+  if (override) return path.resolve(override);
+  return path.join(REPO_ROOT, 'pods');
+}
+
+function validatePipeline(pipelinePath, podsRootOverride) {
+  let doc;
+  try { doc = parseYaml(fs.readFileSync(pipelinePath, 'utf8')); }
+  catch (e) { fail(`YAML malformado: ${e.message}`); }
+
+  // 1. Schema de topo.
+  if (!isMap(doc)) fail('raiz do pipeline não é um mapa YAML');
+  if (typeof doc.id !== 'string' || doc.id.trim() === '') fail('campo obrigatório ausente/vazio: id');
+  if (typeof doc.deliverable !== 'string' || doc.deliverable.trim() === '') fail('campo obrigatório ausente/vazio: deliverable');
+  if (!Array.isArray(doc.phases) || doc.phases.length === 0) fail('campo obrigatório ausente/vazio: phases[] (lista não-vazia)');
+
+  const podsRoot = podsRootFor(podsRootOverride);
+  const seenPhaseIds = new Set();
+  const outputsByPhase = new Map(); // phaseId -> Set(outputName), na ORDEM (só as anteriores contam)
+
+  doc.phases.forEach((ph, i) => {
+    const at = `phases[${i}]`;
+    if (!isMap(ph)) fail(`${at} não é um mapa`);
+    for (const req of ['id', 'pod', 'workflow']) {
+      if (typeof ph[req] !== 'string' || ph[req].trim() === '') fail(`${at}: campo obrigatório ausente/vazio: ${req}`);
+    }
+    if (seenPhaseIds.has(ph.id)) fail(`${at}: id de fase duplicado "${ph.id}"`);
+    // outputs: mapa não-vazio, paths RELATIVOS ao runDir (sem absoluto/traversal).
+    if (!isMap(ph.outputs) || Object.keys(ph.outputs).length === 0) fail(`fase "${ph.id}": outputs ausente ou vazio (mapa nome→path relativo ao runDir, ≥1)`);
+    for (const [name, rel] of Object.entries(ph.outputs)) {
+      if (typeof rel !== 'string' || rel.trim() === '') fail(`fase "${ph.id}": output "${name}" com path vazio`);
+      if (path.isAbsolute(rel) || rel.split(/[\\/]/).includes('..')) fail(`fase "${ph.id}": output "${name}" deve ser path RELATIVO ao runDir, sem traversal ("${rel}")`);
+    }
+    // 2. pod/workflow existem em disco.
+    const wfPath = path.join(podsRoot, ph.pod, 'workflows', `${ph.workflow}.yaml`);
+    if (!fs.existsSync(wfPath)) fail(`fase "${ph.id}": pod/workflow inexistente em disco — ${path.relative(REPO_ROOT, wfPath)}`);
+    // 3. inputs referenciam SÓ output de fase ANTERIOR declarada.
+    if ('inputs' in ph && ph.inputs != null) {
+      if (!isMap(ph.inputs)) fail(`fase "${ph.id}": inputs deve ser um mapa {local: "<- fase.output"}`);
+      for (const [local, refRaw] of Object.entries(ph.inputs)) {
+        if (typeof refRaw !== 'string') fail(`fase "${ph.id}": input "${local}" deve ser string "<- fase.output"`);
+        const ref = refRaw.replace(/^\s*<-\s*/, '').trim();
+        const dot = ref.indexOf('.');
+        if (dot <= 0) fail(`fase "${ph.id}": input "${local}" mal-formado ("${refRaw}") — esperado "<- <fase-anterior>.<output>"`);
+        const srcPhase = ref.slice(0, dot);
+        const srcOut = ref.slice(dot + 1);
+        if (srcPhase === ph.id) fail(`fase "${ph.id}": input "${local}" referencia a PRÓPRIA fase (ciclo)`);
+        if (!outputsByPhase.has(srcPhase)) fail(`fase "${ph.id}": input "${local}" referencia fase "${srcPhase}" não declarada ANTES desta (fase futura/inexistente — pipeline é sequencial puro)`);
+        if (!outputsByPhase.get(srcPhase).has(srcOut)) fail(`fase "${ph.id}": input "${local}" referencia output "${srcOut}" inexistente na fase "${srcPhase}"`);
+      }
+    }
+    // 4. gate opcional.
+    if ('gate' in ph && ph.gate != null) {
+      const g = ph.gate;
+      if (!isMap(g)) fail(`fase "${ph.id}": gate deve ser um mapa {veto?, checkpoint?}`);
+      const hasVeto = Array.isArray(g.veto) && g.veto.length > 0;
+      const hasCp = g.checkpoint != null;
+      if (!hasVeto && !hasCp) fail(`fase "${ph.id}": gate presente mas vazio (declare veto[] e/ou checkpoint)`);
+      if ('veto' in g && g.veto != null) {
+        if (!Array.isArray(g.veto)) fail(`fase "${ph.id}": gate.veto deve ser um array de asserções`);
+        g.veto.forEach((a, ai) => checkGateAssertion(a, `fase "${ph.id}" gate.veto[${ai}]`));
+      }
+      if (hasCp) {
+        if (!isMap(g.checkpoint) || typeof g.checkpoint.criteria !== 'string' || g.checkpoint.criteria.trim() === '') {
+          fail(`fase "${ph.id}": gate.checkpoint deve ser {criteria: "<texto>"} não-vazio`);
+        }
+      }
+    }
+    seenPhaseIds.add(ph.id);
+    outputsByPhase.set(ph.id, new Set(Object.keys(ph.outputs)));
+  });
+}
+
+function main() {
+  const args = process.argv.slice(2);
+  let podsRoot = null;
+  const targets = [];
+  for (let i = 0; i < args.length; i++) {
+    if (args[i] === '--pods-root') podsRoot = args[++i];
+    else targets.push(args[i]);
+  }
+  if (targets.length === 0) {
+    console.error('Uso: node scripts/validate-pipeline.cjs <pipeline.yaml> [...] [--pods-root <dir>]');
+    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 { validatePipeline(t, podsRoot); 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} pipeline(s) validado(s). Contrato bem-formado.`);
+  process.exit(0);
+}
+
+if (require.main === module) main();
+
+module.exports = { validatePipeline, checkGateAssertion, Fail };