drm-core 1.0.0 → 1.2.0

package/cli/index.js

@@ -1,10 +1,6 @@
 /**
  * DRM CLI — Direct Response Marketing Framework
- *
- * Commands:
- *   init <name>   Create new DRM project
- *   install       Install DRM in existing project
- *   doctor        Diagnose DRM installation
+ * Orquestracao de agentes de IA para marketing de resposta direta
  */
 
 const { Command } = require('commander');
@@ -15,6 +11,185 @@ const chalk = require('chalk');
 const SCAFFOLD_DIR = path.join(__dirname, '..', 'scaffold');
 const VERSION = require('../package.json').version;
 
+// ══════════════════════════════════════════════
+// LOGO & BRANDING
+// ══════════════════════════════════════════════
+
+const LOGO = `
+${chalk.bold.cyan('    ╔══════════════════════════════════════════════════════╗')}
+${chalk.bold.cyan('    ║')}                                                      ${chalk.bold.cyan('║')}
+${chalk.bold.cyan('    ║')}   ${chalk.bold.white('██████╗  ██████╗  ███╗   ███╗')}                       ${chalk.bold.cyan('║')}
+${chalk.bold.cyan('    ║')}   ${chalk.bold.white('██╔══██╗ ██╔══██╗ ████╗ ████║')}                       ${chalk.bold.cyan('║')}
+${chalk.bold.cyan('    ║')}   ${chalk.bold.white('██║  ██║ ██████╔╝ ██╔████╔██║')}                       ${chalk.bold.cyan('║')}
+${chalk.bold.cyan('    ║')}   ${chalk.bold.white('██║  ██║ ██╔══██╗ ██║╚██╔╝██║')}                       ${chalk.bold.cyan('║')}
+${chalk.bold.cyan('    ║')}   ${chalk.bold.white('██████╔╝ ██║  ██║ ██║ ╚═╝ ██║')}                       ${chalk.bold.cyan('║')}
+${chalk.bold.cyan('    ║')}   ${chalk.bold.white('╚═════╝  ╚═╝  ╚═╝ ╚═╝     ╚═╝')}                       ${chalk.bold.cyan('║')}
+${chalk.bold.cyan('    ║')}                                                      ${chalk.bold.cyan('║')}
+${chalk.bold.cyan('    ║')}   ${chalk.gray('Direct Response Marketing Framework')}              ${chalk.bold.cyan('║')}
+${chalk.bold.cyan('    ║')}   ${chalk.gray(`v${VERSION} — Orquestracao de Agentes de IA`)}          ${chalk.bold.cyan('║')}
+${chalk.bold.cyan('    ║')}                                                      ${chalk.bold.cyan('║')}
+${chalk.bold.cyan('    ╚══════════════════════════════════════════════════════╝')}
+`;
+
+const LOGO_MINI = `
+${chalk.bold.cyan('  ┌─────────────────────────────────────────┐')}
+${chalk.bold.cyan('  │')} ${chalk.bold.white('DRM')} ${chalk.gray('— Direct Response Marketing')} ${chalk.dim(`v${VERSION}`)} ${chalk.bold.cyan('│')}
+${chalk.bold.cyan('  └─────────────────────────────────────────┘')}
+`;
+
+const DIVIDER = chalk.gray('  ─────────────────────────────────────────');
+
+// ══════════════════════════════════════════════
+// AGENTS TABLE
+// ══════════════════════════════════════════════
+
+const AGENTS = [
+  { id: 'atena',    icon: '⚔️',  name: 'Atena',    role: 'Estrategista / Master',   refs: 'Kennedy, Abraham, Deiss' },
+  { id: 'apolo',    icon: '✍️',  name: 'Apolo',    role: 'Copywriter',              refs: 'Georgi, Schwartz, Halbert' },
+  { id: 'hermes',   icon: '🚀', name: 'Hermes',   role: 'Media Buyer',             refs: 'Mandalia, Barbas, Shackelford' },
+  { id: 'zeus',     icon: '👑', name: 'Zeus',     role: 'Creative Director',       refs: 'Ogilvy, Sullivan, Georgi' },
+  { id: 'cronos',   icon: '📊', name: 'Cronos',   role: 'Analista de Dados',       refs: 'Hormozi, Sanocki, Chen' },
+  { id: 'hefesto',  icon: '🔨', name: 'Hefesto',  role: 'Editor de Video',         refs: 'Agora, MindValley, Icaro' },
+  { id: 'afrodite', icon: '🎨', name: 'Afrodite', role: 'Designer',               refs: 'Brunson, Wiebe, Laja' },
+  { id: 'temis',    icon: '⚖️',  name: 'Temis',    role: 'Compliance',              refs: 'Meta, Google, LGPD' },
+  { id: 'poseidon', icon: '🌊', name: 'Poseidon', role: 'Funnel Architect',        refs: 'Brunson, Brown, Ladeira' },
+];
+
+// ══════════════════════════════════════════════
+// PROGRESS HELPERS
+// ══════════════════════════════════════════════
+
+function sleep(ms) { return new Promise(r => setTimeout(r, ms)); }
+
+async function step(label, fn) {
+  const isTTY = process.stdout.isTTY;
+  if (isTTY) process.stdout.write(chalk.gray(`  ◌ ${label}...`));
+  try {
+    await fn();
+    if (isTTY) {
+      process.stdout.clearLine(0);
+      process.stdout.cursorTo(0);
+    }
+    console.log(chalk.green(`  ✓ ${label}`));
+  } catch (err) {
+    if (isTTY) {
+      process.stdout.clearLine(0);
+      process.stdout.cursorTo(0);
+    }
+    console.log(chalk.red(`  ✗ ${label} — ${err.message}`));
+    throw err;
+  }
+}
+
+function printStats(targetDir) {
+  const counts = {
+    agents: 0, workflows: 0, templates: 0, checklists: 0, tasks: 0, rules: 0
+  };
+
+  const dirs = {
+    agents: '.drm-core/agents',
+    workflows: '.drm-core/workflows',
+    templates: '.drm-core/templates',
+    checklists: '.drm-core/checklists',
+    rules: '.drm-core/rules',
+  };
+
+  for (const [key, dir] of Object.entries(dirs)) {
+    const full = path.join(targetDir, dir);
+    if (fs.existsSync(full)) {
+      counts[key] = fs.readdirSync(full).filter(f => f.endsWith('.md') || f.endsWith('.yaml')).length;
+    }
+  }
+
+  // Count tasks recursively
+  const tasksDir = path.join(targetDir, '.drm-core/tasks');
+  if (fs.existsSync(tasksDir)) {
+    const countFiles = (dir) => {
+      let count = 0;
+      for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
+        if (entry.isDirectory()) count += countFiles(path.join(dir, entry.name));
+        else if (entry.name.endsWith('.md')) count++;
+      }
+      return count;
+    };
+    counts.tasks = countFiles(tasksDir);
+  }
+
+  console.log('');
+  console.log(chalk.bold('  Framework Stats'));
+  console.log(DIVIDER);
+  console.log(`  ${chalk.cyan('Agentes')}      ${chalk.white(counts.agents)}  ${chalk.gray('personas com referencias reais de DR')}`);
+  console.log(`  ${chalk.cyan('Workflows')}    ${chalk.white(counts.workflows)}  ${chalk.gray('fluxos multi-agente declarativos')}`);
+  console.log(`  ${chalk.cyan('Templates')}   ${chalk.white(String(counts.templates).padStart(2))}  ${chalk.gray('estruturas de entregaveis')}`);
+  console.log(`  ${chalk.cyan('Tasks')}       ${chalk.white(String(counts.tasks).padStart(2))}  ${chalk.gray('definicoes step-by-step')}`);
+  console.log(`  ${chalk.cyan('Checklists')}   ${chalk.white(counts.checklists)}  ${chalk.gray('quality gates e validacoes')}`);
+  console.log(`  ${chalk.cyan('Rules')}        ${chalk.white(counts.rules)}  ${chalk.gray('regras de dominio')}`);
+  console.log(DIVIDER);
+}
+
+function printAgentsTable() {
+  console.log('');
+  console.log(chalk.bold('  Panteao de Agentes'));
+  console.log(DIVIDER);
+  console.log(chalk.gray(`  ${'Agente'.padEnd(14)} ${'Papel'.padEnd(24)} Referencias`));
+  console.log(DIVIDER);
+  AGENTS.forEach(a => {
+    console.log(`  ${chalk.cyan(`@${a.id}`.padEnd(14))} ${chalk.white(a.role.padEnd(24))} ${chalk.gray(a.refs)}`);
+  });
+  console.log(DIVIDER);
+}
+
+function printConstitution() {
+  console.log('');
+  console.log(chalk.bold('  Constitution'));
+  console.log(DIVIDER);
+  const articles = [
+    ['I',   'Conversao First',  'NON-NEGOTIABLE', chalk.red],
+    ['II',  'Agent Authority',  'NON-NEGOTIABLE', chalk.red],
+    ['III', 'Data-Driven',      'MUST',           chalk.yellow],
+    ['IV',  'No Invention',     'MUST',           chalk.yellow],
+    ['V',   'Compliance First', 'MUST',           chalk.yellow],
+    ['VI',  'Copy is King',     'SHOULD',         chalk.blue],
+  ];
+  articles.forEach(([num, name, sev, color]) => {
+    console.log(`  ${chalk.gray(`Art. ${num}`.padEnd(10))} ${chalk.white(name.padEnd(20))} ${color(sev)}`);
+  });
+  console.log(DIVIDER);
+}
+
+function printFunnelDiagram() {
+  console.log('');
+  console.log(chalk.bold('  Modelo de Negocio'));
+  console.log(DIVIDER);
+  console.log(chalk.cyan('  Frontend (VSL)'));
+  console.log(chalk.white('  Ad → Microlead/VSL → LP → Checkout → Bump → Upsell → Downsell'));
+  console.log(chalk.gray('                              │'));
+  console.log(chalk.gray('                              ▼'));
+  console.log(chalk.cyan('  Backend (WhatsApp)'));
+  console.log(chalk.white('  API WhatsApp → Nutricao → Qualificacao → Oferta High-Ticket'));
+  console.log(DIVIDER);
+}
+
+function printNextSteps(name) {
+  console.log('');
+  console.log(chalk.bold('  Proximos Passos'));
+  console.log(DIVIDER);
+  if (name) {
+    console.log(chalk.white(`  ${chalk.cyan('$')} cd ${name}`));
+  }
+  console.log(chalk.white(`  ${chalk.cyan('$')} claude${' '.repeat(20)}${chalk.gray('# Abrir Claude Code')}`));
+  console.log(chalk.white(`  ${chalk.cyan('$')} @atena${' '.repeat(20)}${chalk.gray('# Estrategista Master')}`));
+  console.log(chalk.white(`  ${chalk.cyan('$')} /DRM:agents:apolo${' '.repeat(9)}${chalk.gray('# Copywriter')}`));
+  console.log(chalk.white(`  ${chalk.cyan('$')} /DRM:agents:hermes${' '.repeat(8)}${chalk.gray('# Media Buyer')}`));
+  console.log('');
+  console.log(chalk.gray('  Tambem compativel com Gemini CLI e Antigravity.'));
+  console.log('');
+}
+
+// ══════════════════════════════════════════════
+// COMMANDS
+// ══════════════════════════════════════════════
+
 function createProgram() {
   const program = new Command();
 
@@ -27,50 +202,89 @@ function createProgram() {
   program
     .command('init <name>')
     .description('Criar novo projeto DRM')
-    .action(async (name) => {
+    .option('--skip-git', 'Nao inicializar git')
+    .option('--minimal', 'Instalar apenas agentes e constitution')
+    .action(async (name, opts) => {
       const targetDir = path.resolve(process.cwd(), name);
 
       if (fs.existsSync(targetDir)) {
-        console.error(chalk.red(`Erro: Diretorio "${name}" ja existe.`));
+        console.error(chalk.red(`\n  Erro: Diretorio "${name}" ja existe.\n`));
         process.exit(1);
       }
 
-      console.log(chalk.bold.cyan('\n⚔️  DRM — Direct Response Marketing Framework\n'));
-      console.log(chalk.gray(`Criando projeto "${name}"...\n`));
+      console.log(LOGO);
+
+      console.log(chalk.bold('  Instalando Framework'));
+      console.log(DIVIDER);
 
-      // Create directory
       fs.mkdirSync(targetDir, { recursive: true });
 
-      // Copy scaffold
-      await copyScaffold(targetDir);
+      await step('Constitution + Agentes (9 deuses)', async () => {
+        fs.copySync(path.join(SCAFFOLD_DIR, '.drm-core'), path.join(targetDir, '.drm-core'));
+        await sleep(100);
+      });
+
+      await step('Runtime config', async () => {
+        fs.copySync(path.join(SCAFFOLD_DIR, '.drm'), path.join(targetDir, '.drm'));
+        await sleep(50);
+      });
+
+      await step('Claude Code (commands + rules + settings)', async () => {
+        const srcClaude = path.join(SCAFFOLD_DIR, '.claude');
+        if (fs.existsSync(srcClaude)) {
+          fs.copySync(srcClaude, path.join(targetDir, '.claude'));
+        }
+        createClaudeMd(targetDir, name, true);
+        createSettingsJson(targetDir, true);
+        await sleep(50);
+      });
 
-      // Create project package.json
+      await step('Gemini CLI + Antigravity', async () => {
+        const srcGemini = path.join(SCAFFOLD_DIR, '.gemini');
+        const srcAnti = path.join(SCAFFOLD_DIR, '.antigravity');
+        if (fs.existsSync(srcGemini)) fs.copySync(srcGemini, path.join(targetDir, '.gemini'));
+        if (fs.existsSync(srcAnti)) fs.copySync(srcAnti, path.join(targetDir, '.antigravity'));
+        await sleep(50);
+      });
+
+      await step('Estrutura de entregaveis (docs/)', async () => {
+        fs.copySync(path.join(SCAFFOLD_DIR, 'docs'), path.join(targetDir, 'docs'));
+        await sleep(50);
+      });
+
+      // package.json
       const projectPkg = {
         name: name,
         version: '1.0.0',
-        description: '',
+        description: 'Projeto DRM — Direct Response Marketing',
         private: true,
-        scripts: {},
-        keywords: [],
+        scripts: { doctor: 'npx drm-core doctor' },
+        keywords: ['drm', 'direct-response-marketing'],
         license: 'UNLICENSED',
         type: 'commonjs'
       };
       fs.writeJsonSync(path.join(targetDir, 'package.json'), projectPkg, { spaces: 2 });
 
-      // Init git
-      try {
-        const { execSync } = require('child_process');
-        execSync('git init', { cwd: targetDir, stdio: 'ignore' });
-        console.log(chalk.green('  ✓ Git inicializado'));
-      } catch {
-        console.log(chalk.yellow('  ⚠ Git nao encontrado — inicialize manualmente'));
+      // Git
+      if (!opts.skipGit) {
+        await step('Git init', async () => {
+          const { execSync } = require('child_process');
+          execSync('git init', { cwd: targetDir, stdio: 'ignore' });
+
+          // Create .gitignore
+          const gitignore = `node_modules/\n.env\n.drm/handoffs/\n.drm/cache/\n.DS_Store\n*.log\n`;
+          fs.writeFileSync(path.join(targetDir, '.gitignore'), gitignore);
+          await sleep(50);
+        });
       }
 
-      // Create .claude/CLAUDE.md and settings.json
-      createClaudeMd(targetDir, name);
-      createSettingsJson(targetDir);
+      console.log(DIVIDER);
+      console.log(chalk.bold.green(`\n  ✓ Projeto "${name}" criado com sucesso!`));
 
-      console.log(chalk.bold.green('\n✓ Projeto DRM criado com sucesso!\n'));
+      printStats(targetDir);
+      printConstitution();
+      printAgentsTable();
+      printFunnelDiagram();
       printNextSteps(name);
     });
 
@@ -80,39 +294,78 @@ function createProgram() {
     .description('Instalar DRM em projeto existente')
     .action(async () => {
       const targetDir = process.cwd();
+      const projectName = path.basename(targetDir);
+
+      console.log(LOGO_MINI);
+
+      console.log(chalk.bold('  Instalando em projeto existente'));
+      console.log(DIVIDER);
 
-      console.log(chalk.bold.cyan('\n⚔️  DRM — Instalando em projeto existente\n'));
+      await step('Framework core (.drm-core/)', async () => {
+        fs.copySync(path.join(SCAFFOLD_DIR, '.drm-core'), path.join(targetDir, '.drm-core'), { overwrite: false });
+        await sleep(100);
+      });
+
+      await step('Runtime config (.drm/)', async () => {
+        const srcDrm = path.join(SCAFFOLD_DIR, '.drm');
+        const destDrm = path.join(targetDir, '.drm');
+        if (!fs.existsSync(destDrm)) fs.copySync(srcDrm, destDrm);
+        await sleep(50);
+      });
+
+      await step('Claude Code commands', async () => {
+        fs.copySync(
+          path.join(SCAFFOLD_DIR, '.claude/commands/DRM'),
+          path.join(targetDir, '.claude/commands/DRM'),
+          { overwrite: false }
+        );
+        await sleep(50);
+      });
+
+      await step('Claude Code rules', async () => {
+        const srcRules = path.join(SCAFFOLD_DIR, '.claude/rules');
+        if (fs.existsSync(srcRules)) {
+          fs.copySync(srcRules, path.join(targetDir, '.claude/rules'), { overwrite: false });
+        }
+        await sleep(50);
+      });
 
-      // Copy scaffold (skip existing files)
-      await copyScaffold(targetDir, { overwrite: false });
+      await step('Estrutura docs/', async () => {
+        fs.copySync(path.join(SCAFFOLD_DIR, 'docs'), path.join(targetDir, 'docs'), { overwrite: false });
+        await sleep(50);
+      });
 
-      // Merge CLAUDE.md if exists
-      const claudeMdPath = path.join(targetDir, '.claude', 'CLAUDE.md');
-      if (fs.existsSync(claudeMdPath)) {
-        const existing = fs.readFileSync(claudeMdPath, 'utf8');
-        if (!existing.includes('DRM — Direct Response Marketing')) {
-          const drmSection = getDrmClaudeMdSection();
-          fs.appendFileSync(claudeMdPath, '\n\n' + drmSection);
-          console.log(chalk.green('  ✓ CLAUDE.md atualizado (secao DRM adicionada)'));
+      // CLAUDE.md merge
+      await step('CLAUDE.md', async () => {
+        const claudeMdPath = path.join(targetDir, '.claude', 'CLAUDE.md');
+        if (fs.existsSync(claudeMdPath)) {
+          const existing = fs.readFileSync(claudeMdPath, 'utf8');
+          if (!existing.includes('DRM — Direct Response Marketing')) {
+            fs.appendFileSync(claudeMdPath, '\n\n' + getDrmClaudeMdSection());
+          }
         } else {
-          console.log(chalk.gray('  - CLAUDE.md ja contem secao DRM'));
+          createClaudeMd(targetDir, projectName, true);
         }
-      } else {
-        fs.ensureDirSync(path.join(targetDir, '.claude'));
-        createClaudeMd(targetDir, path.basename(targetDir));
-      }
+        await sleep(50);
+      });
 
-      // Merge settings.json if exists
-      const settingsPath = path.join(targetDir, '.claude', 'settings.json');
-      if (fs.existsSync(settingsPath)) {
-        mergeSettingsJson(settingsPath);
-        console.log(chalk.green('  ✓ settings.json atualizado (deny/allow DRM adicionados)'));
-      } else {
-        createSettingsJson(targetDir);
-      }
+      // settings.json merge
+      await step('settings.json', async () => {
+        const settingsPath = path.join(targetDir, '.claude', 'settings.json');
+        if (fs.existsSync(settingsPath)) {
+          mergeSettingsJson(settingsPath);
+        } else {
+          createSettingsJson(targetDir, true);
+        }
+        await sleep(50);
+      });
+
+      console.log(DIVIDER);
+      console.log(chalk.bold.green(`\n  ✓ DRM instalado com sucesso!`));
 
-      console.log(chalk.bold.green('\n✓ DRM instalado com sucesso!\n'));
-      printAgents();
+      printStats(targetDir);
+      printAgentsTable();
+      printNextSteps(null);
     });
 
   // === doctor ===
@@ -122,88 +375,96 @@ function createProgram() {
     .action(() => {
       const targetDir = process.cwd();
 
-      console.log(chalk.bold.cyan('\n⚔️  DRM Doctor — Diagnostico\n'));
+      console.log(LOGO_MINI);
+      console.log(chalk.bold('  Diagnostico'));
+      console.log(DIVIDER);
 
       const checks = [
-        { name: '.drm-core/constitution.md', path: '.drm-core/constitution.md' },
-        { name: '.drm-core/agents/ (9 agentes)', path: '.drm-core/agents/atena.md' },
-        { name: '.drm-core/rules/ (4 rules)', path: '.drm-core/rules/copy-standards.md' },
-        { name: '.drm/config.yaml', path: '.drm/config.yaml' },
-        { name: '.claude/CLAUDE.md', path: '.claude/CLAUDE.md' },
-        { name: '.claude/settings.json', path: '.claude/settings.json' },
-        { name: '.claude/commands/DRM/', path: '.claude/commands/DRM/agents/atena.md' },
-        { name: '.claude/rules/drm-*', path: '.claude/rules/drm-agent-authority.md' },
-        { name: '.gemini/commands/', path: '.gemini/commands/drm-atena.toml', optional: true },
-        { name: '.antigravity/rules/', path: '.antigravity/rules/agents/atena.md', optional: true },
+        { name: 'Constitution',           path: '.drm-core/constitution.md' },
+        { name: 'Agentes (9)',            path: '.drm-core/agents/atena.md' },
+        { name: 'Workflows (8)',          path: '.drm-core/workflows/funil-vsl-completo.yaml' },
+        { name: 'Templates (12)',         path: '.drm-core/templates/vsl-full-template.md' },
+        { name: 'Checklists (8)',         path: '.drm-core/checklists/copy-quality-gate.md' },
+        { name: 'Tasks (15)',             path: '.drm-core/tasks/copy/escrever-vsl-full.md' },
+        { name: 'Rules (4)',              path: '.drm-core/rules/copy-standards.md' },
+        { name: 'Data files',             path: '.drm-core/data/workflow-chains.yaml' },
+        { name: 'Runtime config',         path: '.drm/config.yaml' },
+        { name: 'CLAUDE.md',              path: '.claude/CLAUDE.md' },
+        { name: 'settings.json',          path: '.claude/settings.json' },
+        { name: 'Slash commands (DRM)',    path: '.claude/commands/DRM/agents/atena.md' },
+        { name: 'Governance rules',        path: '.claude/rules/drm-agent-authority.md' },
+        { name: 'Gemini CLI',             path: '.gemini/commands/drm-atena.toml', optional: true },
+        { name: 'Antigravity',            path: '.antigravity/rules/agents/atena.md', optional: true },
       ];
 
-      let passed = 0;
-      let failed = 0;
-      let optional = 0;
+      let passed = 0, failed = 0, skipped = 0;
 
-      checks.forEach(({ name, path: checkPath, optional: isOptional }) => {
+      checks.forEach(({ name, path: checkPath, optional }) => {
         const fullPath = path.join(targetDir, checkPath);
         if (fs.existsSync(fullPath)) {
           console.log(chalk.green(`  ✓ ${name}`));
           passed++;
-        } else if (isOptional) {
-          console.log(chalk.yellow(`  ○ ${name} (opcional)`));
-          optional++;
+        } else if (optional) {
+          console.log(chalk.gray(`  ○ ${name} ${chalk.dim('(opcional)')}`));
+          skipped++;
         } else {
           console.log(chalk.red(`  ✗ ${name}`));
           failed++;
         }
       });
 
-      // Count agents
+      console.log(DIVIDER);
+
+      // Agent listing
       const agentsDir = path.join(targetDir, '.drm-core', 'agents');
       if (fs.existsSync(agentsDir)) {
-        const agents = fs.readdirSync(agentsDir).filter(f => f.endsWith('.md'));
-        console.log(chalk.gray(`\n  Agentes: ${agents.map(a => a.replace('.md', '')).join(', ')}`));
+        const agentFiles = fs.readdirSync(agentsDir).filter(f => f.endsWith('.md'));
+        console.log('');
+        console.log(chalk.bold('  Agentes detectados'));
+        console.log(DIVIDER);
+        agentFiles.forEach(f => {
+          const id = f.replace('.md', '');
+          const agent = AGENTS.find(a => a.id === id);
+          if (agent) {
+            console.log(`  ${agent.icon}  ${chalk.cyan(`@${agent.id}`.padEnd(14))} ${chalk.white(agent.role)}`);
+          }
+        });
+        console.log(DIVIDER);
       }
 
-      console.log(chalk.bold(`\n  Resultado: ${passed} ok, ${failed} falha(s), ${optional} opcional(is)\n`));
-
-      if (failed > 0) {
-        console.log(chalk.yellow('  Execute "npx drm-core install" para corrigir.\n'));
-        process.exit(1);
+      // Verdict
+      console.log('');
+      if (failed === 0) {
+        console.log(chalk.bold.green(`  ✓ Framework DRM operacional (${passed}/${passed + failed} checks)`));
+        console.log(chalk.gray('    Use @atena para comecar.\n'));
       } else {
-        console.log(chalk.green('  Framework DRM operacional. Use @atena para comecar.\n'));
+        console.log(chalk.bold.red(`  ✗ ${failed} problema(s) encontrado(s)`));
+        console.log(chalk.yellow('    Execute "npx drm-core install" para corrigir.\n'));
+        process.exit(1);
       }
     });
 
-  return program;
-}
-
-// === Helpers ===
-
-async function copyScaffold(targetDir, options = { overwrite: true }) {
-  const items = [
-    { src: '.drm-core', label: '.drm-core/ (framework)' },
-    { src: '.drm', label: '.drm/ (runtime)' },
-    { src: '.claude/commands/DRM', label: '.claude/commands/DRM/ (slash commands)' },
-    { src: '.claude/rules', label: '.claude/rules/ (governance rules)', merge: true },
-    { src: '.gemini', label: '.gemini/ (Gemini CLI)' },
-    { src: '.antigravity', label: '.antigravity/ (Antigravity)' },
-    { src: 'docs', label: 'docs/ (entregaveis)', merge: true },
-  ];
-
-  for (const item of items) {
-    const srcPath = path.join(SCAFFOLD_DIR, item.src);
-    const destPath = path.join(targetDir, item.src);
-
-    if (!fs.existsSync(srcPath)) continue;
+  // === info ===
+  program
+    .command('info')
+    .description('Mostrar informacoes do framework')
+    .action(() => {
+      const targetDir = process.cwd();
 
-    if (item.merge || options.overwrite) {
-      fs.copySync(srcPath, destPath, { overwrite: options.overwrite });
-    } else if (!fs.existsSync(destPath)) {
-      fs.copySync(srcPath, destPath);
-    }
+      console.log(LOGO);
+      printStats(targetDir);
+      printConstitution();
+      printAgentsTable();
+      printFunnelDiagram();
+    });
 
-    console.log(chalk.green(`  ✓ ${item.label}`));
-  }
+  return program;
 }
 
+// ══════════════════════════════════════════════
+// HELPERS
+// ══════════════════════════════════════════════
+
 function getDrmClaudeMdSection() {
   return `---
 
@@ -260,23 +521,17 @@ Frontend (VSL) -> Checkout -> Order Bump -> Upsell -> Downsell
 Backend (WhatsApp API) -> Nutricao -> Oferta High-Ticket -> Onboarding
 
 ---
-*DRM Framework v1.0*`;
+*DRM Framework v${VERSION}*`;
 }
 
-function createClaudeMd(targetDir, projectName) {
+function createClaudeMd(targetDir, projectName, silent) {
   const claudeDir = path.join(targetDir, '.claude');
   fs.ensureDirSync(claudeDir);
-
-  const content = `# ${projectName}
-
-${getDrmClaudeMdSection()}
-`;
-
+  const content = `# ${projectName}\n\n${getDrmClaudeMdSection()}\n`;
   fs.writeFileSync(path.join(claudeDir, 'CLAUDE.md'), content);
-  console.log(chalk.green('  ✓ .claude/CLAUDE.md'));
 }
 
-function createSettingsJson(targetDir) {
+function createSettingsJson(targetDir, silent) {
   const claudeDir = path.join(targetDir, '.claude');
   fs.ensureDirSync(claudeDir);
 
@@ -284,112 +539,52 @@ function createSettingsJson(targetDir) {
     language: 'portuguese',
     permissions: {
       deny: [
-        'Edit(.drm-core/constitution.md)',
-        'Write(.drm-core/constitution.md)',
-        'Edit(.drm-core/agents/**)',
-        'Write(.drm-core/agents/**)',
-        'Edit(.drm-core/tasks/**)',
-        'Write(.drm-core/tasks/**)',
-        'Edit(.drm-core/templates/**)',
-        'Write(.drm-core/templates/**)',
-        'Edit(.drm-core/workflows/**)',
-        'Write(.drm-core/workflows/**)',
-        'Edit(.drm-core/checklists/**)',
-        'Write(.drm-core/checklists/**)',
-        'Edit(.drm-core/rules/**)',
-        'Write(.drm-core/rules/**)'
+        'Edit(.drm-core/constitution.md)', 'Write(.drm-core/constitution.md)',
+        'Edit(.drm-core/agents/**)', 'Write(.drm-core/agents/**)',
+        'Edit(.drm-core/tasks/**)', 'Write(.drm-core/tasks/**)',
+        'Edit(.drm-core/templates/**)', 'Write(.drm-core/templates/**)',
+        'Edit(.drm-core/workflows/**)', 'Write(.drm-core/workflows/**)',
+        'Edit(.drm-core/checklists/**)', 'Write(.drm-core/checklists/**)',
+        'Edit(.drm-core/rules/**)', 'Write(.drm-core/rules/**)'
       ],
       allow: [
         'Read(.drm-core/**)',
-        'Edit(.drm-core/data/**)',
-        'Write(.drm-core/data/**)',
-        'Edit(.drm/**)',
-        'Write(.drm/**)',
-        'Edit(docs/**)',
-        'Write(docs/**)'
+        'Edit(.drm-core/data/**)', 'Write(.drm-core/data/**)',
+        'Edit(.drm/**)', 'Write(.drm/**)',
+        'Edit(docs/**)', 'Write(docs/**)'
       ]
     }
   };
 
   fs.writeJsonSync(path.join(claudeDir, 'settings.json'), settings, { spaces: 2 });
-  console.log(chalk.green('  ✓ .claude/settings.json'));
 }
 
 function mergeSettingsJson(settingsPath) {
   const settings = fs.readJsonSync(settingsPath);
-
   if (!settings.permissions) settings.permissions = {};
   if (!settings.permissions.deny) settings.permissions.deny = [];
   if (!settings.permissions.allow) settings.permissions.allow = [];
 
-  const drmDenyRules = [
-    'Edit(.drm-core/constitution.md)',
-    'Write(.drm-core/constitution.md)',
-    'Edit(.drm-core/agents/**)',
-    'Write(.drm-core/agents/**)',
-    'Edit(.drm-core/tasks/**)',
-    'Write(.drm-core/tasks/**)',
-    'Edit(.drm-core/templates/**)',
-    'Write(.drm-core/templates/**)',
-    'Edit(.drm-core/workflows/**)',
-    'Write(.drm-core/workflows/**)',
-    'Edit(.drm-core/checklists/**)',
-    'Write(.drm-core/checklists/**)',
-    'Edit(.drm-core/rules/**)',
-    'Write(.drm-core/rules/**)'
+  const drmDeny = [
+    'Edit(.drm-core/constitution.md)', 'Write(.drm-core/constitution.md)',
+    'Edit(.drm-core/agents/**)', 'Write(.drm-core/agents/**)',
+    'Edit(.drm-core/tasks/**)', 'Write(.drm-core/tasks/**)',
+    'Edit(.drm-core/templates/**)', 'Write(.drm-core/templates/**)',
+    'Edit(.drm-core/workflows/**)', 'Write(.drm-core/workflows/**)',
+    'Edit(.drm-core/checklists/**)', 'Write(.drm-core/checklists/**)',
+    'Edit(.drm-core/rules/**)', 'Write(.drm-core/rules/**)'
   ];
-
-  const drmAllowRules = [
-    'Read(.drm-core/**)',
-    'Edit(.drm-core/data/**)',
-    'Write(.drm-core/data/**)',
-    'Edit(.drm/**)',
-    'Write(.drm/**)'
+  const drmAllow = [
+    'Read(.drm-core/**)', 'Edit(.drm-core/data/**)', 'Write(.drm-core/data/**)',
+    'Edit(.drm/**)', 'Write(.drm/**)'
   ];
 
-  drmDenyRules.forEach(rule => {
-    if (!settings.permissions.deny.includes(rule)) {
-      settings.permissions.deny.push(rule);
-    }
-  });
-
-  drmAllowRules.forEach(rule => {
-    if (!settings.permissions.allow.includes(rule)) {
-      settings.permissions.allow.push(rule);
-    }
-  });
+  drmDeny.forEach(r => { if (!settings.permissions.deny.includes(r)) settings.permissions.deny.push(r); });
+  drmAllow.forEach(r => { if (!settings.permissions.allow.includes(r)) settings.permissions.allow.push(r); });
 
   fs.writeJsonSync(settingsPath, settings, { spaces: 2 });
 }
 
-function printNextSteps(name) {
-  console.log(chalk.bold('Proximos passos:\n'));
-  console.log(chalk.white(`  cd ${name}`));
-  console.log(chalk.white('  claude                    # Abrir Claude Code'));
-  console.log(chalk.white('  @atena                    # Ativar estrategista'));
-  console.log(chalk.white('  /DRM:agents:apolo         # Ativar copywriter'));
-  console.log(chalk.gray('\n  Ou use Gemini CLI / Antigravity com os mesmos agentes.\n'));
-}
-
-function printAgents() {
-  console.log(chalk.bold('Agentes disponiveis:\n'));
-  const agents = [
-    ['@atena', 'Estrategista / Master'],
-    ['@apolo', 'Copywriter'],
-    ['@hermes', 'Media Buyer'],
-    ['@zeus', 'Creative Director'],
-    ['@cronos', 'Analista de Dados'],
-    ['@hefesto', 'Editor de Video'],
-    ['@afrodite', 'Designer'],
-    ['@temis', 'Compliance'],
-    ['@poseidon', 'Funnel Architect'],
-  ];
-  agents.forEach(([name, role]) => {
-    console.log(chalk.white(`  ${chalk.cyan(name.padEnd(12))} ${role}`));
-  });
-  console.log('');
-}
-
 async function run(args = process.argv) {
   const program = createProgram();
   await program.parseAsync(args);