sinapse-ai 7.6.0 → 7.7.0

package/.claude/hooks/secret-scanning.cjs

@@ -0,0 +1,155 @@
+#!/usr/bin/env node
+'use strict';
+
+/**
+ * Hook: Secret Scanning
+ *
+ * RULE: Detect and block potential secrets/credentials from being written to files.
+ *
+ * Protocol (Claude Code PreToolUse):
+ *   exit 0  → allow
+ *   exit 2  → block (message shown to model via stderr)
+ *
+ * Fail-open: if parsing fails, allow.
+ *
+ * @module secret-scanning
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+// ---------------------------------------------------------------------------
+// Secret Patterns — ordered by severity
+// ---------------------------------------------------------------------------
+
+const SECRET_PATTERNS = [
+  // API Keys & Tokens
+  { name: 'AWS Access Key', pattern: /AKIA[0-9A-Z]{16}/ },
+  { name: 'AWS Secret Key', pattern: /(?:aws_secret_access_key|secret_key)\s*[=:]\s*['"]?[A-Za-z0-9/+=]{40}['"]?/i },
+  { name: 'GitHub Token', pattern: /gh[ps]_[A-Za-z0-9_]{36,}/ },
+  { name: 'GitHub OAuth', pattern: /gho_[A-Za-z0-9_]{36,}/ },
+  { name: 'Slack Token', pattern: /xox[bpors]-[0-9]{10,}-[A-Za-z0-9-]+/ },
+  { name: 'Stripe Key', pattern: /[sr]k_(live|test)_[A-Za-z0-9]{20,}/ },
+  { name: 'OpenAI Key', pattern: /sk-[A-Za-z0-9]{20,}/ },
+  { name: 'Anthropic Key', pattern: /sk-ant-[A-Za-z0-9-]{20,}/ },
+  { name: 'Supabase Key', pattern: /eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9\.[A-Za-z0-9_-]{50,}/ },
+  { name: 'Google API Key', pattern: /AIza[0-9A-Za-z_-]{35}/ },
+  { name: 'Vercel Token', pattern: /vercel_[A-Za-z0-9]{20,}/ },
+
+  // Private Keys
+  { name: 'RSA Private Key', pattern: /-----BEGIN RSA PRIVATE KEY-----/ },
+  { name: 'SSH Private Key', pattern: /-----BEGIN OPENSSH PRIVATE KEY-----/ },
+  { name: 'PGP Private Key', pattern: /-----BEGIN PGP PRIVATE KEY BLOCK-----/ },
+  { name: 'EC Private Key', pattern: /-----BEGIN EC PRIVATE KEY-----/ },
+
+  // Connection Strings
+  { name: 'DB Connection String', pattern: /(?:postgres|mysql|mongodb|redis):\/\/[^:]+:[^@]+@[^/\s]+/i },
+  { name: 'Supabase DB URL', pattern: /postgresql:\/\/postgres\.[A-Za-z0-9]+:[^@]+@/i },
+
+  // Generic Patterns (broader, lower confidence)
+  { name: 'Hardcoded Password', pattern: /(?:password|passwd|pwd)\s*[=:]\s*['"][^'"]{8,}['"]/i },
+  { name: 'Bearer Token', pattern: /[Bb]earer\s+[A-Za-z0-9_\-.]{20,}/ },
+  { name: 'Basic Auth', pattern: /[Bb]asic\s+[A-Za-z0-9+/=]{20,}/ },
+];
+
+/** Files that are expected to contain secret-like patterns */
+const EXEMPT_PATHS = [
+  '.env.example', '.env.template', '.env.sample',
+  'node_modules/', '.git/',
+  '.claude/hooks/',       // Hook scripts may reference patterns
+  'test/', 'tests/', '__tests__/',
+  '.sinapse-ai/core/',    // Framework core may have validators
+];
+
+/** File extensions to scan */
+const SCANNABLE_EXTENSIONS = [
+  '.ts', '.tsx', '.js', '.jsx', '.cjs', '.mjs',
+  '.json', '.yaml', '.yml', '.toml',
+  '.env', '.sh', '.bash', '.py',
+  '.md', '.txt', '.cfg', '.conf', '.ini',
+];
+
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+
+function projectRoot() {
+  return process.env.CLAUDE_PROJECT_DIR || process.cwd();
+}
+
+function relativize(filePath, root) {
+  const normalized = filePath.replace(/\\/g, '/');
+  const normalizedRoot = root.replace(/\\/g, '/');
+  if (normalized.startsWith(normalizedRoot)) {
+    return normalized.slice(normalizedRoot.length).replace(/^\/+/, '');
+  }
+  return normalized;
+}
+
+function isExempt(rel) {
+  return EXEMPT_PATHS.some((ep) => rel.includes(ep));
+}
+
+function isScannable(rel) {
+  return SCANNABLE_EXTENSIONS.some((ext) => rel.endsWith(ext));
+}
+
+function scanForSecrets(content) {
+  const findings = [];
+  for (const { name, pattern } of SECRET_PATTERNS) {
+    if (pattern.test(content)) {
+      findings.push(name);
+    }
+  }
+  return findings;
+}
+
+// ---------------------------------------------------------------------------
+// Main
+// ---------------------------------------------------------------------------
+
+function main() {
+  let input;
+  try {
+    input = JSON.parse(fs.readFileSync(0, 'utf8'));
+  } catch {
+    process.exit(0); // fail-open
+  }
+
+  const toolName = input.tool_name || '';
+  if (toolName !== 'Write' && toolName !== 'Edit') {
+    process.exit(0);
+  }
+
+  const toolInput = input.tool_input || {};
+  const filePath = toolInput.file_path || '';
+  if (!filePath) process.exit(0);
+
+  const root = projectRoot();
+  const rel = relativize(filePath, root);
+
+  if (isExempt(rel)) process.exit(0);
+  if (!isScannable(rel)) process.exit(0);
+
+  // Scan content being written
+  const content = toolInput.content || toolInput.new_string || '';
+  if (!content) process.exit(0);
+
+  const findings = scanForSecrets(content);
+  if (findings.length === 0) process.exit(0);
+
+  // BLOCK
+  process.stderr.write(
+    `\nSECRET SCANNING BLOCK: Potential secrets detected!\n` +
+    `File: ${rel}\n` +
+    `Found: ${findings.join(', ')}\n` +
+    `\n` +
+    `DO NOT commit secrets to code. Instead:\n` +
+    `  - Use environment variables (.env) for local dev\n` +
+    `  - Use .env.example with placeholder values for templates\n` +
+    `  - Use secret managers for production (Supabase Vault, etc.)\n`,
+  );
+  process.exit(2);
+}
+
+main();

package/.claude/rules/cross-squad-routing.md

@@ -0,0 +1,47 @@
+# Cross-Squad Routing Rules
+
+> Applies to Imperator (sinapse-orqx) and ALL squad orchestrators (*-orqx).
+
+## Single-Squad Requests
+
+When a request maps cleanly to one domain, route directly:
+
+```
+"Crie um headline" → @copy-orqx → @headline-specialist
+"Audite a marca" → @brand-orqx → @brand-auditor
+"Otimize SEO" → @growth-orqx → @seo-specialist
+```
+
+## Multi-Squad Patterns
+
+For requests spanning multiple domains, use established patterns:
+
+| Pattern | Squads | Trigger |
+|---------|--------|---------|
+| `brand_launch` | brand + design + content + copy + animations | New brand from scratch |
+| `go_to_market` | product + commercial + content + paidmedia + growth | Launch product/service |
+| `strategic_pivot` | council + research + finance + product | Major direction change |
+| `full_digital_presence` | brand + design + content + animations + growth + paidmedia | Complete digital setup |
+| `security_compliance_audit` | cybersecurity + research | Security assessment |
+| `content_campaign` | content + copy + growth + paidmedia | Multi-channel campaign |
+| `course_launch` | courses + content + copy + commercial | Course/workshop launch |
+
+## Routing Priority
+
+1. **Exact match** — Request clearly belongs to one squad
+2. **Pattern match** — Request matches a known multi-squad pattern
+3. **Diagnostic** — Unclear request → Imperator diagnoses before routing
+
+## Handoff Between Squads
+
+When work flows from one squad to another:
+1. Outgoing squad writes deliverables to `docs/` or project files
+2. Outgoing orchestrator generates handoff artifact
+3. Incoming orchestrator receives artifact + reads deliverables
+4. Incoming orchestrator routes to appropriate specialist
+
+## Anti-Patterns
+
+- Never have two squads working on the same file simultaneously
+- Never skip the orchestrator (user → specialist directly) for multi-squad work
+- Never route to a squad without providing context from the previous squad

package/.claude/rules/hook-governance.md

@@ -0,0 +1,61 @@
+# Hook Governance Rules
+
+> Applies to ALL agents. Hooks are the enforcement layer of the Constitution.
+
+## Active Hook Registry
+
+### PreToolUse — Bash
+| Hook | Purpose | Behavior |
+|------|---------|----------|
+| `enforce-git-push-authority.sh` | Art. II — Only @devops can push | BLOCK (deny) |
+| `sql-governance.py` | Security — Block dangerous SQL | BLOCK (exit 2) |
+| `enforce-delegation.cjs` | Art. VIII — Orchestrators can't execute | BLOCK (exit 2) |
+
+### PreToolUse — Write|Edit
+| Hook | Purpose | Behavior |
+|------|---------|----------|
+| `enforce-architecture-first.cjs` | Art. III — Docs before protected code | BLOCK (exit 2) |
+| `write-path-validation.cjs` | Convention — Warn wrong doc paths | WARN (exit 0) |
+| `enforce-story-gate.cjs` | Art. III — Story required for code | BLOCK (exit 2) |
+| `slug-validation.py` | Convention — Validate naming | WARN (exit 0) |
+| `mind-clone-governance.py` | Cloning — DNA required | BLOCK (exit 2) |
+| `enforce-delegation.cjs` | Art. VIII — Orchestrators can't execute | BLOCK (exit 2) |
+
+### PreToolUse — Read
+| Hook | Purpose | Behavior |
+|------|---------|----------|
+| `read-protection.py` | Security — Control sensitive file access | WARN (exit 0) |
+
+### UserPromptSubmit
+| Hook | Purpose | Behavior |
+|------|---------|----------|
+| `synapse-wrapper.cjs` | SYNAPSE context injection | ALLOW (exit 0) |
+
+### PreCompact
+| Hook | Purpose | Behavior |
+|------|---------|----------|
+| `precompact-wrapper.cjs` | Session digest before compaction | ALLOW (exit 0) |
+
+## Hook Design Principles
+
+1. **Fail-open** — If a hook crashes or can't parse input, exit 0 (allow)
+2. **Fast** — Each hook must complete in < 5 seconds
+3. **Silent on success** — Only output on block or warning
+4. **Deterministic** — Same input always produces same output
+5. **No side effects** — Hooks read state but don't modify it
+
+## Adding New Hooks
+
+1. Create script in `.claude/hooks/` (prefer CJS for portability)
+2. Add entry to `.claude/settings.json` under appropriate event
+3. Document in this file (hook-governance.md)
+4. Test with mock JSON via stdin
+5. Verify fail-open behavior with invalid input
+
+## Exit Code Protocol
+
+| Code | Meaning | Effect |
+|------|---------|--------|
+| 0 | Allow | Operation proceeds |
+| 2 | Block | Operation denied, message shown to model |
+| Other | Ignored | Operation proceeds (treated as 0) |

package/.claude/rules/security-scanning.md

@@ -0,0 +1,42 @@
+# Security Scanning Rules
+
+> Applies to ALL agents writing code or configuration files.
+
+## Secret Detection
+
+NEVER commit files containing:
+- API keys, tokens, or passwords in plaintext
+- `.env` files with real values (use `.env.example` with placeholders)
+- OAuth credentials (`access_token`, `refresh_token`, `client_secret`)
+- Private keys (RSA, SSH, PGP)
+- Database connection strings with credentials
+- Webhook URLs with embedded tokens
+
+## Path Traversal Prevention
+
+When handling file paths from user input or external sources:
+- Reject paths containing `..` segments
+- Reject absolute paths outside project root
+- Normalize paths before validation (`path.resolve()` then check prefix)
+- Never construct paths with string concatenation from untrusted input
+
+## SQL Injection Prevention
+
+- Always use parameterized queries — never string interpolation
+- Supabase RPC functions must use `$1, $2` parameter placeholders
+- Edge functions must validate and sanitize all query parameters
+- `sql-governance.py` hook blocks dangerous SQL patterns automatically
+
+## Dependency Security
+
+- Review new dependencies before adding (`npm audit`)
+- Prefer well-maintained packages (>1K weekly downloads, recent updates)
+- Pin exact versions in production dependencies
+- Never install packages with known critical vulnerabilities
+
+## Hooks Enforcement
+
+Active security hooks in `.claude/settings.json`:
+- `sql-governance.py` — blocks dangerous SQL in Bash commands
+- `read-protection.py` — controls access to sensitive config files
+- `enforce-architecture-first.cjs` — requires docs before protected code paths

package/.sinapse-ai/cli/commands/health/index.js

@@ -0,0 +1,237 @@
+#!/usr/bin/env node
+'use strict';
+
+/**
+ * sinapse health — Framework Health Analytics
+ *
+ * Analyzes the health of a SINAPSE installation:
+ * - Hook connectivity (wired vs orphaned)
+ * - Squad completeness (metadata, preferences, KBs)
+ * - Rule coverage
+ * - Agent authority compliance
+ * - Skill activation coverage
+ *
+ * Usage:
+ *   sinapse health              # Full health report
+ *   sinapse health --json       # JSON output
+ *   sinapse health --fix        # Auto-fix common issues
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+function findProjectRoot() {
+  let dir = process.cwd();
+  while (dir !== path.dirname(dir)) {
+    if (fs.existsSync(path.join(dir, '.sinapse-ai'))) return dir;
+    dir = path.dirname(dir);
+  }
+  return process.cwd();
+}
+
+function checkHooks(root) {
+  const results = { score: 0, max: 0, issues: [] };
+  const settingsPath = path.join(root, '.claude', 'settings.json');
+
+  results.max += 3;
+  if (!fs.existsSync(settingsPath)) {
+    results.issues.push({ severity: 'critical', msg: '.claude/settings.json not found' });
+    return results;
+  }
+
+  const settings = JSON.parse(fs.readFileSync(settingsPath, 'utf8'));
+  const hooks = settings.hooks || {};
+
+  // Check PreToolUse exists
+  if (hooks.PreToolUse && hooks.PreToolUse.length > 0) {
+    results.score += 1;
+  } else {
+    results.issues.push({ severity: 'high', msg: 'No PreToolUse hooks configured' });
+  }
+
+  // Check UserPromptSubmit exists
+  if (hooks.UserPromptSubmit && hooks.UserPromptSubmit.length > 0) {
+    results.score += 1;
+  } else {
+    results.issues.push({ severity: 'medium', msg: 'No UserPromptSubmit hooks configured' });
+  }
+
+  // Count total connected hooks
+  let connected = 0;
+  Object.values(hooks).forEach((matchers) =>
+    matchers.forEach((m) => (m.hooks || []).forEach(() => connected++)),
+  );
+
+  // Check hook files exist
+  const hooksDir = path.join(root, '.claude', 'hooks');
+  if (fs.existsSync(hooksDir)) {
+    const hookFiles = fs.readdirSync(hooksDir).filter((f) => f.endsWith('.cjs') || f.endsWith('.sh') || f.endsWith('.py'));
+    const orphaned = hookFiles.length - connected;
+    if (orphaned <= 5) results.score += 1; // Some orphaned is OK (utilities, legacy)
+    else results.issues.push({ severity: 'low', msg: `${orphaned} hook files not connected to settings.json` });
+  }
+
+  results.connected = connected;
+  return results;
+}
+
+function checkSquads(root) {
+  const results = { score: 0, max: 0, issues: [], squads: [] };
+  const squadsDir = path.join(root, 'squads');
+
+  if (!fs.existsSync(squadsDir)) {
+    results.issues.push({ severity: 'medium', msg: 'squads/ directory not found' });
+    return results;
+  }
+
+  const squadDirs = fs.readdirSync(squadsDir).filter((d) => d.startsWith('squad-') && fs.statSync(path.join(squadsDir, d)).isDirectory());
+
+  for (const squad of squadDirs) {
+    const dir = path.join(squadsDir, squad);
+    const checks = { name: squad, metadata: false, preferences: false, agents: 0, tasks: 0 };
+    results.max += 2;
+
+    // Check metadata
+    const yamlPath = path.join(dir, 'squad.yaml');
+    if (fs.existsSync(yamlPath)) {
+      const content = fs.readFileSync(yamlPath, 'utf8');
+      checks.metadata = /agents_count|total_files/.test(content);
+      if (checks.metadata) results.score += 1;
+      else results.issues.push({ severity: 'low', msg: `${squad}: missing metadata in squad.yaml` });
+    }
+
+    // Check preferences
+    checks.preferences = fs.existsSync(path.join(dir, 'preferences'));
+    if (checks.preferences) results.score += 1;
+    else results.issues.push({ severity: 'low', msg: `${squad}: missing preferences/ directory` });
+
+    // Count assets
+    const agentsDir = path.join(dir, 'agents');
+    const tasksDir = path.join(dir, 'tasks');
+    checks.agents = fs.existsSync(agentsDir) ? fs.readdirSync(agentsDir).filter((f) => f.endsWith('.md')).length : 0;
+    checks.tasks = fs.existsSync(tasksDir) ? fs.readdirSync(tasksDir).filter((f) => f.endsWith('.md')).length : 0;
+
+    results.squads.push(checks);
+  }
+
+  return results;
+}
+
+function checkRules(root) {
+  const results = { score: 0, max: 1, issues: [] };
+  const rulesDir = path.join(root, '.claude', 'rules');
+
+  if (!fs.existsSync(rulesDir)) {
+    results.issues.push({ severity: 'high', msg: '.claude/rules/ not found' });
+    return results;
+  }
+
+  const rules = fs.readdirSync(rulesDir).filter((f) => f.endsWith('.md'));
+  if (rules.length >= 13) results.score += 1;
+  else results.issues.push({ severity: 'medium', msg: `Only ${rules.length} rules (recommended: 16+)` });
+
+  results.count = rules.length;
+  return results;
+}
+
+function checkSkills(root) {
+  const results = { score: 0, max: 1, issues: [] };
+  const skillsDir = path.join(root, '.claude', 'skills');
+
+  if (!fs.existsSync(skillsDir)) {
+    results.issues.push({ severity: 'medium', msg: '.claude/skills/ not found' });
+    return results;
+  }
+
+  const skills = fs.readdirSync(skillsDir).filter((f) => f.endsWith('.md') || fs.statSync(path.join(skillsDir, f)).isDirectory());
+  // Check for path-activated skills
+  let pathActivated = 0;
+  for (const skill of skills) {
+    const skillPath = path.join(skillsDir, skill);
+    if (fs.statSync(skillPath).isFile()) {
+      const content = fs.readFileSync(skillPath, 'utf8');
+      if (/^paths:/m.test(content)) pathActivated++;
+    }
+  }
+
+  if (pathActivated >= 3) results.score += 1;
+  else results.issues.push({ severity: 'low', msg: `Only ${pathActivated} path-activated skills (recommended: 5+)` });
+
+  results.total = skills.length;
+  results.pathActivated = pathActivated;
+  return results;
+}
+
+async function runHealth(options = {}) {
+  const root = findProjectRoot();
+  const pkg = JSON.parse(fs.readFileSync(path.join(root, 'package.json'), 'utf8'));
+
+  const hookResults = checkHooks(root);
+  const squadResults = checkSquads(root);
+  const ruleResults = checkRules(root);
+  const skillResults = checkSkills(root);
+
+  const totalScore = hookResults.score + squadResults.score + ruleResults.score + skillResults.score;
+  const totalMax = hookResults.max + squadResults.max + ruleResults.max + skillResults.max;
+  const percentage = Math.round((totalScore / totalMax) * 100);
+
+  const allIssues = [
+    ...hookResults.issues,
+    ...squadResults.issues,
+    ...ruleResults.issues,
+    ...skillResults.issues,
+  ];
+
+  if (options.json) {
+    console.log(JSON.stringify({
+      version: pkg.version,
+      health: percentage,
+      score: `${totalScore}/${totalMax}`,
+      hooks: { connected: hookResults.connected, score: `${hookResults.score}/${hookResults.max}` },
+      squads: { count: squadResults.squads.length, score: `${squadResults.score}/${squadResults.max}` },
+      rules: { count: ruleResults.count, score: `${ruleResults.score}/${ruleResults.max}` },
+      skills: { total: skillResults.total, pathActivated: skillResults.pathActivated, score: `${skillResults.score}/${skillResults.max}` },
+      issues: allIssues,
+    }, null, 2));
+    return;
+  }
+
+  // Pretty output
+  const bar = (score, max) => {
+    const filled = Math.round((score / max) * 10);
+    return '█'.repeat(filled) + '░'.repeat(10 - filled);
+  };
+
+  console.log(`\n  SINAPSE Health Report — v${pkg.version}`);
+  console.log(`  ${'═'.repeat(50)}\n`);
+  console.log(`  Overall Health: ${percentage}% ${bar(totalScore, totalMax)} (${totalScore}/${totalMax})\n`);
+  console.log(`  Hooks:   ${bar(hookResults.score, hookResults.max)} ${hookResults.connected || 0} connected`);
+  console.log(`  Squads:  ${bar(squadResults.score, squadResults.max)} ${squadResults.squads.length} squads`);
+  console.log(`  Rules:   ${bar(ruleResults.score, ruleResults.max)} ${ruleResults.count || 0} rules`);
+  console.log(`  Skills:  ${bar(skillResults.score, skillResults.max)} ${skillResults.pathActivated || 0} path-activated\n`);
+
+  if (allIssues.length > 0) {
+    console.log(`  Issues (${allIssues.length}):`);
+    for (const issue of allIssues.slice(0, 10)) {
+      const icon = issue.severity === 'critical' ? '🔴' : issue.severity === 'high' ? '🟠' : issue.severity === 'medium' ? '🟡' : '🔵';
+      console.log(`    ${icon} ${issue.msg}`);
+    }
+    if (allIssues.length > 10) console.log(`    ... and ${allIssues.length - 10} more`);
+    console.log('');
+  } else {
+    console.log('  ✅ No issues found!\n');
+  }
+}
+
+module.exports = { runHealth };
+
+if (require.main === module) {
+  const args = process.argv.slice(2);
+  runHealth({
+    json: args.includes('--json'),
+    fix: args.includes('--fix'),
+  }).catch((err) => {
+    console.error(`Error: ${err.message}`);
+    process.exit(1);
+  });
+}

package/.sinapse-ai/cli/commands/performance/index.js

@@ -0,0 +1,157 @@
+#!/usr/bin/env node
+'use strict';
+
+/**
+ * sinapse performance — Squad & Agent Performance Ranking
+ *
+ * Analyzes squad and agent completeness, ranking by:
+ * - Asset coverage (agents, tasks, KBs, workflows, templates, checklists)
+ * - Metadata completeness
+ * - Preferences tracking
+ * - Orchestrator enrichment level
+ *
+ * Usage:
+ *   sinapse performance              # Full ranking
+ *   sinapse performance --json       # JSON output
+ *   sinapse performance --top 5      # Top 5 only
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+function findProjectRoot() {
+  let dir = process.cwd();
+  while (dir !== path.dirname(dir)) {
+    if (fs.existsSync(path.join(dir, '.sinapse-ai'))) return dir;
+    dir = path.dirname(dir);
+  }
+  return process.cwd();
+}
+
+function analyzeSquad(squadDir, squadName) {
+  const result = {
+    name: squadName,
+    agents: 0,
+    tasks: 0,
+    kbs: 0,
+    workflows: 0,
+    templates: 0,
+    checklists: 0,
+    hasMetadata: false,
+    hasPreferences: false,
+    orchestratorLines: 0,
+    score: 0,
+  };
+
+  // Count assets
+  const countMd = (subdir) => {
+    const dir = path.join(squadDir, subdir);
+    if (!fs.existsSync(dir)) return 0;
+    return fs.readdirSync(dir).filter((f) => f.endsWith('.md')).length;
+  };
+
+  const countAny = (subdir) => {
+    const dir = path.join(squadDir, subdir);
+    if (!fs.existsSync(dir)) return 0;
+    return fs.readdirSync(dir).filter((f) => !f.startsWith('.')).length;
+  };
+
+  result.agents = countMd('agents');
+  result.tasks = countMd('tasks');
+  // Try both naming conventions
+  result.kbs = countAny('knowledge-bases') || countAny('knowledge-base');
+  result.workflows = countAny('workflows');
+  result.templates = countMd('templates') || countAny('templates');
+  result.checklists = countMd('checklists') || countAny('checklists');
+
+  // Metadata check
+  const yamlPath = path.join(squadDir, 'squad.yaml');
+  if (fs.existsSync(yamlPath)) {
+    const content = fs.readFileSync(yamlPath, 'utf8');
+    result.hasMetadata = /agents_count|total_files/.test(content);
+  }
+
+  // Preferences check
+  result.hasPreferences = fs.existsSync(path.join(squadDir, 'preferences'));
+
+  // Orchestrator enrichment
+  const orqxFile = fs.readdirSync(path.join(squadDir, 'agents')).find((f) => f.includes('-orqx'));
+  if (orqxFile) {
+    const content = fs.readFileSync(path.join(squadDir, 'agents', orqxFile), 'utf8');
+    result.orchestratorLines = content.split('\n').length;
+  }
+
+  // Calculate score (weighted)
+  result.score =
+    (result.agents >= 6 ? 15 : result.agents * 2.5) +
+    (result.tasks >= 50 ? 25 : result.tasks * 0.5) +
+    (result.kbs >= 8 ? 15 : result.kbs * 1.875) +
+    (result.workflows >= 3 ? 10 : result.workflows * 3.33) +
+    (result.templates >= 3 ? 10 : result.templates * 3.33) +
+    (result.checklists >= 2 ? 5 : result.checklists * 2.5) +
+    (result.hasMetadata ? 5 : 0) +
+    (result.hasPreferences ? 5 : 0) +
+    (result.orchestratorLines >= 100 ? 10 : result.orchestratorLines * 0.1);
+
+  result.score = Math.round(result.score * 10) / 10;
+
+  return result;
+}
+
+async function runPerformance(options = {}) {
+  const root = findProjectRoot();
+  const squadsDir = path.join(root, 'squads');
+
+  if (!fs.existsSync(squadsDir)) {
+    console.error('No squads/ directory found.');
+    process.exit(1);
+  }
+
+  const squadDirs = fs.readdirSync(squadsDir)
+    .filter((d) => d.startsWith('squad-') && fs.statSync(path.join(squadsDir, d)).isDirectory());
+
+  const rankings = squadDirs
+    .map((d) => analyzeSquad(path.join(squadsDir, d), d))
+    .sort((a, b) => b.score - a.score);
+
+  const limit = options.top || rankings.length;
+  const display = rankings.slice(0, limit);
+
+  if (options.json) {
+    console.log(JSON.stringify({ rankings: display, total: rankings.length }, null, 2));
+    return;
+  }
+
+  // Pretty output
+  console.log(`\n  SINAPSE Performance Ranking — ${rankings.length} Squads`);
+  console.log(`  ${'═'.repeat(60)}\n`);
+
+  const maxScore = rankings[0]?.score || 100;
+
+  display.forEach((sq, i) => {
+    const rank = i + 1;
+    const barLen = Math.round((sq.score / maxScore) * 20);
+    const bar = '█'.repeat(barLen) + '░'.repeat(20 - barLen);
+    const medal = rank === 1 ? '🥇' : rank === 2 ? '🥈' : rank === 3 ? '🥉' : `#${rank}`;
+    const meta = sq.hasMetadata ? '✓' : '✗';
+    const pref = sq.hasPreferences ? '✓' : '✗';
+
+    console.log(`  ${String(medal).padEnd(4)} ${sq.name.padEnd(25)} ${bar} ${sq.score.toFixed(1)}`);
+    console.log(`       ${sq.agents}a ${sq.tasks}t ${sq.kbs}kb ${sq.workflows}wf ${sq.templates}tpl ${sq.checklists}ck | meta:${meta} pref:${pref} orqx:${sq.orchestratorLines}L`);
+    console.log('');
+  });
+}
+
+module.exports = { runPerformance };
+
+if (require.main === module) {
+  const args = process.argv.slice(2);
+  const topIdx = args.indexOf('--top');
+  runPerformance({
+    json: args.includes('--json'),
+    top: topIdx >= 0 ? parseInt(args[topIdx + 1], 10) : undefined,
+  }).catch((err) => {
+    console.error(`Error: ${err.message}`);
+    process.exit(1);
+  });
+}

package/.sinapse-ai/cli/commands/routing-intel/index.js

@@ -0,0 +1,176 @@
+#!/usr/bin/env node
+'use strict';
+
+/**
+ * sinapse routing-intel — Routing Intelligence Analyzer
+ *
+ * Analyzes the routing configuration across all orchestrators:
+ * - Delegation matrix completeness
+ * - Cross-squad handoff coverage
+ * - Routing pattern conflicts
+ * - Agent reachability (can every agent be reached via routing?)
+ *
+ * Usage:
+ *   sinapse routing-intel                 # Full routing analysis
+ *   sinapse routing-intel analyze         # Deep analysis with recommendations
+ *   sinapse routing-intel --json          # JSON output
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+function findProjectRoot() {
+  let dir = process.cwd();
+  while (dir !== path.dirname(dir)) {
+    if (fs.existsSync(path.join(dir, '.sinapse-ai'))) return dir;
+    dir = path.dirname(dir);
+  }
+  return process.cwd();
+}
+
+function extractDelegation(content) {
+  const delegations = [];
+  // Match delegation tables: | pattern | agent |
+  const tableRows = content.match(/\|[^|]+\|[^|]+\|/g) || [];
+  for (const row of tableRows) {
+    const cells = row.split('|').map((c) => c.trim()).filter(Boolean);
+    if (cells.length >= 2 && cells[1].startsWith('@')) {
+      delegations.push({ pattern: cells[0], target: cells[1] });
+    }
+  }
+
+  // Match inline delegations: → @agent, delegate to @agent
+  const inlineMatches = content.match(/(?:→|delegate to|route to)\s+@([\w-]+)/gi) || [];
+  for (const match of inlineMatches) {
+    const agentMatch = match.match(/@([\w-]+)/);
+    if (agentMatch) delegations.push({ pattern: 'inline', target: `@${agentMatch[1]}` });
+  }
+
+  return delegations;
+}
+
+function extractHandoffs(content) {
+  const handoffs = { inbound: [], outbound: [] };
+
+  // Look for inbound/outbound sections
+  const inboundMatch = content.match(/###?\s*Inbound[\s\S]*?(?=###?\s*Outbound|###?\s*[A-Z]|$)/i);
+  if (inboundMatch) {
+    const squads = inboundMatch[0].match(/@[\w-]+|squad-[\w-]+/g) || [];
+    handoffs.inbound = [...new Set(squads)];
+  }
+
+  const outboundMatch = content.match(/###?\s*Outbound[\s\S]*?(?=###?\s*[A-Z]|##\s|$)/i);
+  if (outboundMatch) {
+    const squads = outboundMatch[0].match(/@[\w-]+|squad-[\w-]+/g) || [];
+    handoffs.outbound = [...new Set(squads)];
+  }
+
+  return handoffs;
+}
+
+async function runRoutingIntel(options = {}) {
+  const root = findProjectRoot();
+  const squadsDir = path.join(root, 'squads');
+
+  if (!fs.existsSync(squadsDir)) {
+    console.error('No squads/ directory found.');
+    process.exit(1);
+  }
+
+  const squadDirs = fs.readdirSync(squadsDir)
+    .filter((d) => d.startsWith('squad-') && fs.statSync(path.join(squadsDir, d)).isDirectory());
+
+  const routingMap = [];
+  const allAgents = new Set();
+  const reachableAgents = new Set();
+
+  for (const squad of squadDirs) {
+    const agentsDir = path.join(squadsDir, squad, 'agents');
+    if (!fs.existsSync(agentsDir)) continue;
+
+    const agentFiles = fs.readdirSync(agentsDir).filter((f) => f.endsWith('.md'));
+    for (const file of agentFiles) {
+      const agentId = file.replace('.md', '');
+      allAgents.add(agentId);
+    }
+
+    // Find orchestrator
+    const orqxFile = agentFiles.find((f) => f.includes('-orqx'));
+    if (!orqxFile) continue;
+
+    const content = fs.readFileSync(path.join(agentsDir, orqxFile), 'utf8');
+    const delegations = extractDelegation(content);
+    const handoffs = extractHandoffs(content);
+
+    // Mark delegated agents as reachable
+    for (const d of delegations) {
+      const target = d.target.replace('@', '');
+      reachableAgents.add(target);
+    }
+
+    routingMap.push({
+      squad,
+      orchestrator: orqxFile.replace('.md', ''),
+      delegations: delegations.length,
+      handoffs,
+      hasRoutingIntel: /routing intelligence|routing table/i.test(content),
+      hasDelegationMatrix: /delegation matrix|delegation|delegacao/i.test(content),
+    });
+  }
+
+  // Find unreachable agents (not in any delegation)
+  const unreachable = [...allAgents].filter((a) => !reachableAgents.has(a) && !a.includes('-orqx'));
+
+  if (options.json) {
+    console.log(JSON.stringify({
+      squads: routingMap,
+      totalAgents: allAgents.size,
+      reachableAgents: reachableAgents.size,
+      unreachableAgents: unreachable,
+      coverage: Math.round((reachableAgents.size / allAgents.size) * 100),
+    }, null, 2));
+    return;
+  }
+
+  // Pretty output
+  console.log(`\n  SINAPSE Routing Intelligence Report`);
+  console.log(`  ${'═'.repeat(55)}\n`);
+
+  console.log(`  Agents: ${allAgents.size} total | ${reachableAgents.size} reachable | ${unreachable.length} unreachable`);
+  console.log(`  Coverage: ${Math.round((reachableAgents.size / allAgents.size) * 100)}%\n`);
+
+  console.log(`  Squad Routing Matrix:`);
+  console.log(`  ${'─'.repeat(55)}`);
+
+  for (const entry of routingMap) {
+    const routing = entry.hasRoutingIntel ? '✓' : '✗';
+    const deleg = entry.hasDelegationMatrix ? '✓' : '✗';
+    const inCount = entry.handoffs.inbound.length;
+    const outCount = entry.handoffs.outbound.length;
+
+    console.log(`  ${entry.squad.padEnd(25)} ${entry.delegations}d | in:${inCount} out:${outCount} | routing:${routing} deleg:${deleg}`);
+  }
+
+  if (options.analyze && unreachable.length > 0) {
+    console.log(`\n  Unreachable Agents (${unreachable.length}):`);
+    for (const agent of unreachable.slice(0, 15)) {
+      console.log(`    ⚠ ${agent}`);
+    }
+    if (unreachable.length > 15) console.log(`    ... and ${unreachable.length - 15} more`);
+  }
+
+  console.log('');
+}
+
+module.exports = { runRoutingIntel };
+
+if (require.main === module) {
+  const args = process.argv.slice(2);
+  runRoutingIntel({
+    json: args.includes('--json'),
+    analyze: args.includes('analyze'),
+  }).catch((err) => {
+    console.error(`Error: ${err.message}`);
+    process.exit(1);
+  });
+}

package/.sinapse-ai/install-manifest.yaml

@@ -7,10 +7,10 @@
 # - SHA256 hashes for change detection
 # - File types for categorization
 #
-version: 7.6.0
-generated_at: "2026-04-01T02:05:35.822Z"
+version: 7.7.0
+generated_at: "2026-04-01T14:18:00.782Z"
 generator: scripts/generate-install-manifest.js
-file_count: 1104
+file_count: 1107
 files:
   - path: cli/commands/config/index.js
     hash: sha256:66f111eceef0f60fa0a8904add783b615d55b01d5fe36408623c3dd828e702f6
@@ -20,6 +20,10 @@ files:
     hash: sha256:36f8e38ab767fa5478d8dabac548c66dc2c0fc521c216e954ac33fcea0ba597b
     type: cli
     size: 6720
+  - path: cli/commands/health/index.js
+    hash: sha256:7140286f6f0fcd283dcc0a6261dfe914ee50aae5c97ddd9e548ffa6a3279fe1e
+    type: cli
+    size: 8579
   - path: cli/commands/manifest/index.js
     hash: sha256:440df152d1be0d1700551206b512e47ce38ef1f6244eecebdf7df74888976250
     type: cli
@@ -100,6 +104,10 @@ files:
     hash: sha256:5f7ac17e3fd47ff9d3d4544f67b28f44b821097e0ce5eb2059e8550c0f54e4e1
     type: cli
     size: 12355
+  - path: cli/commands/performance/index.js
+    hash: sha256:aa2f14a846ff7301d9694fd1e50897e559b3c437d2eccb07e4f2ad21f9921c9c
+    type: cli
+    size: 5039
   - path: cli/commands/pro/index.js
     hash: sha256:be706f637b3f54d882a8e1d3ee953a40c7ae7b94ca3bfcafdd4d6865d0526964
     type: cli
@@ -116,6 +124,10 @@ files:
     hash: sha256:bc993858504617a233ce191ab44a438f675605022e43375d282f589a734b6c64
     type: cli
     size: 5320
+  - path: cli/commands/routing-intel/index.js
+    hash: sha256:f13824f426e7a2091024a20ecad0299d75abd46881bd0226b86a9207e6ecf3fa
+    type: cli
+    size: 5761
   - path: cli/commands/validate/index.js
     hash: sha256:93c39b64cd1a234ce848843c0a9b291a1f85f142e77485e281ebc0e7344afea2
     type: cli

package/bin/sinapse.js

@@ -1077,6 +1077,40 @@ async function main() {
       showHelp();
       break;
 
+    case 'health': {
+      // Framework health analytics
+      const { runHealth } = require('../.sinapse-ai/cli/commands/health/index.js');
+      const healthArgs = args.slice(1);
+      await runHealth({
+        json: healthArgs.includes('--json'),
+        fix: healthArgs.includes('--fix'),
+      });
+      break;
+    }
+
+    case 'performance': {
+      // Squad & agent performance ranking
+      const { runPerformance } = require('../.sinapse-ai/cli/commands/performance/index.js');
+      const perfArgs = args.slice(1);
+      const topIdx = perfArgs.indexOf('--top');
+      await runPerformance({
+        json: perfArgs.includes('--json'),
+        top: topIdx >= 0 ? parseInt(perfArgs[topIdx + 1], 10) : undefined,
+      });
+      break;
+    }
+
+    case 'routing-intel': {
+      // Routing intelligence analyzer
+      const { runRoutingIntel } = require('../.sinapse-ai/cli/commands/routing-intel/index.js');
+      const riArgs = args.slice(1);
+      await runRoutingIntel({
+        json: riArgs.includes('--json'),
+        analyze: riArgs.includes('analyze'),
+      });
+      break;
+    }
+
     case undefined:
       // No arguments - launch Claude Code with SINAPSE branding
       launchSinapse([]);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "sinapse-ai",
-  "version": "7.6.0",
+  "version": "7.7.0",
   "description": "SINAPSE AI: Framework de orquestracao de IA — 18 squads, 175 agentes especializados",
   "bin": {
     "sinapse": "bin/sinapse.js",

package/squads/squad-claude/agents/swarm-orqx.md

@@ -68,3 +68,31 @@ Strategic and systems-oriented. Swarm thinks in terms of parallelism, isolation
 | **Inbound** | Any squad | When multi-agent orchestration is needed |
 | **Outbound** | squad-dev | When agent implementation patterns need coding |
 | **Outbound** | squad-devops | When worktree branches need merge/deploy coordination |
+
+## Activation Instructions
+
+1. Read this file completely
+2. Adopt the Swarm persona — systems-oriented, parallelism-focused
+3. Greet user with: "🐝 Swarm — Multi-Agent Orchestrator activated. Can this be parallelized?"
+4. Await user input
+
+## Available Workflows
+
+| Workflow | Description | Agents Involved |
+|----------|-------------|-----------------|
+| `team-formation` | Design and spawn a multi-agent team | Swarm + target agents |
+| `parallel-sprint` | Decompose and execute tasks in parallel | Swarm + worker agents |
+| `worktree-isolation` | Setup isolated git worktrees for parallel work | Swarm + devops |
+
+## Routing Intelligence
+
+| Request Pattern | Route To | Confidence |
+|----------------|----------|------------|
+| "team", "agents", "parallel", "swarm" | Handle directly | High |
+| "worktree", "branch isolation", "parallel branches" | Handle directly | High |
+| "hooks", "PreToolUse", "PostToolUse" | @hooks-architect | High |
+| "MCP", "server", "tool integration" | @mcp-integrator | High |
+| "config", "settings.json", "rules" | @config-engineer | High |
+| "skill", "slash command", "workflow" | @skill-craftsman | High |
+| "project setup", "install", "brownfield" | @project-integrator | High |
+| "roadmap", "tracking", "changelog" | @roadmap-sentinel | High |

package/squads/squad-claude/preferences/README.md

@@ -0,0 +1,15 @@
+# Preferences Directory
+
+> Diretorio para logs de preferencias por projeto/cliente.
+> Atualizado automaticamente pelos agentes do squad apos cada ciclo de entrega.
+
+## Como usar
+
+1. Para cada novo projeto, criar `{projeto}-preferences.md`
+2. Agentes consultam antes de iniciar nova entrega
+3. Atualizar apos cada ciclo de aprovacao
+
+## Arquivos
+
+- `README.md` — Este arquivo
+- `{projeto}-preferences.md` — Um arquivo por projeto ativo

package/squads/squad-claude/squad.yaml

@@ -3,6 +3,19 @@ version: "1.0.0"
 short-title: "Claude Code Mastery Squad"
 description: "Squad especialista em Claude Code: hooks, MCP servers, subagents, skills, configuracao, context engineering, integracao de projetos e roadmap tracking."
 slashPrefix: SINAPSE
+
+metadata:
+  created_at: "2026-03-16"
+  updated_at: "2026-04-01"
+  created_by: "squad-creator (Craft)"
+  agents_count: 10
+  tasks_count: 49
+  knowledge_bases_count: 5
+  workflows_count: 2
+  templates_count: 0
+  checklists_count: 0
+  quality_target: "5.0/5.0 em todas as dimensoes"
+
 tags: [claude-code, hooks, mcp, subagents, skills, context-engineering, configuration]
 components:
   agents: [claude-orqx.md, hooks-architect.md, mcp-integrator.md, swarm-orqx.md, config-engineer.md, skill-craftsman.md, project-integrator.md, roadmap-sentinel.md]

package/squads/squad-commercial/agents/commercial-orqx.md

@@ -41,7 +41,48 @@ Revenue Cycle Orchestrator — coordena o sistema comercial completo, desde dema
 7. manage-pipeline-forecast
 8. conduct-commercial-retrospective
 
+## Activation Instructions
+
+1. Read this file completely
+2. Adopt the Pipeline persona — strategic, results-oriented, data-driven
+3. Greet user with: "🚀 Pipeline — Revenue Cycle Orchestrator activated. Revenue previsivel nao e sorte — e engenharia de sistema."
+4. Await user input
+
+## Available Workflows
+
+| Workflow | Description | Agents Involved |
+|----------|-------------|-----------------|
+| `greenfield-commercial-system` | Build commercial system from scratch | All 11 agents |
+| `pipeline-optimization` | Optimize existing pipeline metrics | Vault, Cascade, Ledger |
+| `deal-acceleration` | Accelerate specific deals through pipeline | Edge, Mint, Bond |
+| `quarterly-review` | Full commercial performance review | Pipeline + all agents |
+| `client-expansion` | Expand existing accounts | Bond, Mint, Edge |
+| `forecast-calibration` | Calibrate revenue forecasts | Ledger, Vault, Pipeline |
+
+## Routing Intelligence
+
+| Request Pattern | Route To | Confidence |
+|----------------|----------|------------|
+| "CRM", "Hubspot", "Salesforce", "leads" | @vault (CRM Ops) | High |
+| "funnel", "pipeline stages", "conversion" | @cascade (Funnel Architect) | High |
+| "pricing", "offer", "proposal" | @mint (Offer Designer) | High |
+| "revenue", "forecast", "MRR", "ARR" | @ledger (Revenue Analytics) | High |
+| "onboarding", "churn", "NPS", "retention" | @bond (Client Success) | High |
+| "sales methodology", "SPIN", "discovery" | @edge (Sales Method) | High |
+| "outbound", "prospecting", "cold email" | @outreach (Outbound) | High |
+| "social selling", "LinkedIn selling" | @signal-commercial (Social Selling) | High |
+| "competitive analysis", "win/loss" | @scout (Competitive Intel) | Medium |
+
 ## Cross-Squad Handoffs
-- **Recebe de:** @growth-analytics (pipeline data, attribution), @content-intelligence (funnel content)
-- **Envia para:** @product-systems (client feedback), @operations-hub (process requirements)
-- **Escalates to:** @sinapse-orqx (cross-squad coordination)
+
+### Inbound
+- **@growth-orqx:** Pipeline data, attribution, lead scoring
+- **@content-orqx:** Funnel content, case studies, collateral
+- **@copy-orqx:** Sales copy, email sequences, proposals
+- **@brand-orqx:** Brand guidelines for commercial materials
+
+### Outbound
+- **@product-orqx:** Client feedback, feature requests, adoption data
+- **@finance-orqx:** Revenue data, forecasts, pricing validation
+- **@growth-orqx:** Conversion data, campaign attribution
+- **@sinapse-orqx:** Cross-squad coordination, escalations

package/squads/squad-commercial/squad.yaml

@@ -16,6 +16,13 @@ metadata:
   language: pt-BR
   created: "2026-03-13"
   author: "Sinapse"
+  agents_count: 11
+  tasks_count: 85
+  knowledge_bases_count: 13
+  workflows_count: 6
+  templates_count: 6
+  checklists_count: 3
+  quality_target: "5.0/5.0 em todas as dimensoes"
 
 agents:
   - id: commercial-orqx

package/squads/squad-council/preferences/README.md

@@ -0,0 +1,15 @@
+# Preferences Directory
+
+> Diretorio para logs de preferencias por projeto/cliente.
+> Atualizado automaticamente pelos agentes do squad apos cada ciclo de entrega.
+
+## Como usar
+
+1. Para cada novo projeto, criar `{projeto}-preferences.md`
+2. Agentes consultam antes de iniciar nova entrega
+3. Atualizar apos cada ciclo de aprovacao
+
+## Arquivos
+
+- `README.md` — Este arquivo
+- `{projeto}-preferences.md` — Um arquivo por projeto ativo

package/squads/squad-council/squad.yaml

@@ -16,6 +16,13 @@ metadata:
   language: pt-BR
   created: "2026-03-16"
   author: "Sinapse"
+  agents_count: 11
+  tasks_count: 56
+  knowledge_bases_count: 3
+  workflows_count: 2
+  templates_count: 0
+  checklists_count: 0
+  quality_target: "5.0/5.0 em todas as dimensoes"
 
 agents:
   - id: council-orqx

package/squads/squad-cybersecurity/preferences/README.md

@@ -0,0 +1,15 @@
+# Preferences Directory
+
+> Diretorio para logs de preferencias por projeto/cliente.
+> Atualizado automaticamente pelos agentes do squad apos cada ciclo de entrega.
+
+## Como usar
+
+1. Para cada novo projeto, criar `{projeto}-preferences.md`
+2. Agentes consultam antes de iniciar nova entrega
+3. Atualizar apos cada ciclo de aprovacao
+
+## Arquivos
+
+- `README.md` — Este arquivo
+- `{projeto}-preferences.md` — Um arquivo por projeto ativo

package/squads/squad-cybersecurity/squad.yaml

@@ -6,6 +6,18 @@ author: "Sinapse"
 license: MIT
 slashPrefix: SINAPSE
 
+metadata:
+  created_at: "2026-03-16"
+  updated_at: "2026-04-01"
+  created_by: "squad-creator (Craft)"
+  agents_count: 9
+  tasks_count: 53
+  knowledge_bases_count: 3
+  workflows_count: 2
+  templates_count: 0
+  checklists_count: 0
+  quality_target: "5.0/5.0 em todas as dimensoes"
+
 tags:
   - cybersecurity
   - security

package/squads/squad-finance/preferences/README.md

@@ -0,0 +1,15 @@
+# Preferences Directory
+
+> Diretorio para logs de preferencias por projeto/cliente.
+> Atualizado automaticamente pelos agentes do squad apos cada ciclo de entrega.
+
+## Como usar
+
+1. Para cada novo projeto, criar `{projeto}-preferences.md`
+2. Agentes consultam antes de iniciar nova entrega
+3. Atualizar apos cada ciclo de aprovacao
+
+## Arquivos
+
+- `README.md` — Este arquivo
+- `{projeto}-preferences.md` — Um arquivo por projeto ativo

package/squads/squad-growth/agents/growth-orqx.md

@@ -66,6 +66,36 @@ Orquestrador do squad de Growth Analytics. Coordena todos os agentes, classifica
 7. plan-experimentation-roadmap
 8. conduct-growth-retrospective
 
+## Activation Instructions
+
+1. Read this file completely
+2. Adopt the Catalyst persona — data-driven, analytical, metrics-obsessed
+3. Greet user with: "🚀 Catalyst — Growth Orchestrator activated. Se nao e mensuravel, nao e growth."
+4. Await user input
+
+## Available Workflows
+
+| Workflow | Description | Agents Involved |
+|----------|-------------|-----------------|
+| `instrumentation-first` | Setup tracking & analytics from scratch | Signal, Insight |
+| `cro-optimization` | Conversion rate optimization cycle | Convert, Lever |
+| `seo-acceleration` | Organic growth strategy | Rank, Insight |
+| `growth-campaign` | Full growth campaign (plan → execute → measure) | All 6 agents |
+| `experimentation-sprint` | 2-week A/B testing sprint | Convert, Lever, Insight |
+| `analytics-audit` | Audit existing analytics setup | Signal, Insight, Catalyst |
+
+## Routing Intelligence
+
+| Request Pattern | Route To | Confidence |
+|----------------|----------|------------|
+| "GA4", "tracking", "events", "tag manager" | @signal (Analytics Engineer) | High |
+| "A/B test", "conversion", "CRO", "landing page" | @convert (CRO Specialist) | High |
+| "SEO", "keywords", "organic", "search ranking" | @rank (SEO Strategist) | High |
+| "dashboard", "BI", "report", "data analysis" | @insight (Data Analyst) | High |
+| "growth hack", "viral", "referral", "PLG" | @lever (Growth Hacker) | High |
+| "campaign analytics", "attribution", "ROAS" | @pulse (Campaign Analyst) | High |
+| "paid media", "ads", "Meta Ads", "Google Ads" | Delegate to @paidmedia-orqx | High |
+
 ## Escalation
 
 - **Escalates to:** @sinapse-orqx (Imperator) para coordenacao cross-squad, decisoes arquiteturais ou escalacoes alem do escopo da squad

package/squads/squad-growth/squad.yaml

@@ -15,6 +15,13 @@ metadata:
   language: pt-BR
   created: "2026-03-12"
   author: "Sinapse"
+  agents_count: 7
+  tasks_count: 77
+  knowledge_bases_count: 12
+  workflows_count: 6
+  templates_count: 6
+  checklists_count: 3
+  quality_target: "5.0/5.0 em todas as dimensoes"
 
 agents:
   - id: growth-orqx

package/squads/squad-paidmedia/preferences/README.md

@@ -0,0 +1,15 @@
+# Preferences Directory
+
+> Diretorio para logs de preferencias por projeto/cliente.
+> Atualizado automaticamente pelos agentes do squad apos cada ciclo de entrega.
+
+## Como usar
+
+1. Para cada novo projeto, criar `{projeto}-preferences.md`
+2. Agentes consultam antes de iniciar nova entrega
+3. Atualizar apos cada ciclo de aprovacao
+
+## Arquivos
+
+- `README.md` — Este arquivo
+- `{projeto}-preferences.md` — Um arquivo por projeto ativo

package/squads/squad-product/squad.yaml

@@ -15,6 +15,13 @@ metadata:
   language: pt-BR
   created: "2026-03-13"
   author: "Sinapse"
+  agents_count: 7
+  tasks_count: 75
+  knowledge_bases_count: 11
+  workflows_count: 6
+  templates_count: 5
+  checklists_count: 3
+  quality_target: "5.0/5.0 em todas as dimensoes"
 
 agents:
   - id: product-orqx

package/squads/squad-storytelling/preferences/README.md

@@ -0,0 +1,15 @@
+# Preferences Directory
+
+> Diretorio para logs de preferencias por projeto/cliente.
+> Atualizado automaticamente pelos agentes do squad apos cada ciclo de entrega.
+
+## Como usar
+
+1. Para cada novo projeto, criar `{projeto}-preferences.md`
+2. Agentes consultam antes de iniciar nova entrega
+3. Atualizar apos cada ciclo de aprovacao
+
+## Arquivos
+
+- `README.md` — Este arquivo
+- `{projeto}-preferences.md` — Um arquivo por projeto ativo