vibetachyon 1.5.1 → 1.5.2

package/dist/core/persona/config.js

@@ -3,6 +3,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.AGENT_BIN_MAP = void 0;
 exports.getActivePersonaPath = getActivePersonaPath;
 exports.listPersonas = listPersonas;
 exports.isPersonaId = isPersonaId;
@@ -11,10 +12,23 @@ exports.saveActivePersona = saveActivePersona;
 exports.loadActivePersona = loadActivePersona;
 const fs_1 = __importDefault(require("fs"));
 const path_1 = __importDefault(require("path"));
+// Agent name → persona id map (for CLI bin detection)
+exports.AGENT_BIN_MAP = {
+    quasar: 'architect',
+    lumen: 'frontend',
+    axiom: 'backend',
+    cipher: 'security',
+    flux: 'performance',
+    prism: 'reviewer',
+    zenith: 'growth',
+};
 const PERSONAS = {
     architect: {
         id: 'architect',
         label: 'Architect',
+        agentName: 'QUASAR',
+        agentColor: '\x1b[38;5;220m',
+        agentTagline: 'Projeta sistemas que escalam infinitamente.',
         description: 'Prioritizes structure, long-term shape, dependency boundaries, and execution sequencing.',
         defaultChecks: ['context', 'spec', 'gate'],
         riskTolerance: 'low',
@@ -24,6 +38,9 @@ const PERSONAS = {
     frontend: {
         id: 'frontend',
         label: 'Frontend',
+        agentName: 'LUMEN',
+        agentColor: '\x1b[38;5;231m',
+        agentTagline: 'Interfaces que iluminam a experiência do usuário.',
         description: 'Prioritizes UI quality, framework fit, and user-facing implementation details.',
         defaultChecks: ['context', 'frontend', 'gate'],
         riskTolerance: 'medium',
@@ -33,6 +50,9 @@ const PERSONAS = {
     backend: {
         id: 'backend',
         label: 'Backend',
+        agentName: 'AXIOM',
+        agentColor: '\x1b[38;5;39m',
+        agentTagline: 'A verdade por trás de toda API e banco de dados.',
         description: 'Prioritizes API contracts, services, persistence, and execution safety on the server side.',
         defaultChecks: ['context', 'gate'],
         riskTolerance: 'medium',
@@ -42,6 +62,9 @@ const PERSONAS = {
     security: {
         id: 'security',
         label: 'Security',
+        agentName: 'CIPHER',
+        agentColor: '\x1b[38;5;46m',
+        agentTagline: 'Nenhuma vulnerabilidade escapa do Cipher.',
         description: 'Prioritizes auth, access scope, unsafe patterns, secrets, and exploit surfaces.',
         defaultChecks: ['context', 'gate', 'release-evidence'],
         riskTolerance: 'low',
@@ -51,6 +74,9 @@ const PERSONAS = {
     performance: {
         id: 'performance',
         label: 'Performance',
+        agentName: 'FLUX',
+        agentColor: '\x1b[38;5;51m',
+        agentTagline: 'Velocidade sem resistência.',
         description: 'Prioritizes Lighthouse budgets, runtime weight, latency, and delivery efficiency.',
         defaultChecks: ['context', 'frontend', 'perf'],
         riskTolerance: 'medium',
@@ -60,6 +86,9 @@ const PERSONAS = {
     reviewer: {
         id: 'reviewer',
         label: 'Reviewer',
+        agentName: 'PRISM',
+        agentColor: '\x1b[38;5;135m',
+        agentTagline: 'Enxerga seu código de todos os ângulos.',
         description: 'Prioritizes findings, regressions, and missing validation before approval.',
         defaultChecks: ['context', 'gate', 'release-evidence'],
         riskTolerance: 'low',
@@ -69,6 +98,9 @@ const PERSONAS = {
     growth: {
         id: 'growth',
         label: 'Growth',
+        agentName: 'ZENITH',
+        agentColor: '\x1b[38;5;208m',
+        agentTagline: 'Leva seu SaaS ao ponto mais alto.',
         description: 'Prioritizes funnels, conversion, tracking, offers, and experiment surfaces.',
         defaultChecks: ['context', 'frontend', 'gate'],
         riskTolerance: 'high',

package/dist/core/security/cipher-audit.js

@@ -0,0 +1,322 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runCipherAudit = runCipherAudit;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+// Padrões de secrets hardcoded
+const SECRET_PATTERNS = [
+    { pattern: /sk_live_[a-zA-Z0-9]{20,}/g, label: 'Stripe secret key (live)' },
+    { pattern: /sk_test_[a-zA-Z0-9]{20,}/g, label: 'Stripe secret key (test)' },
+    { pattern: /rk_live_[a-zA-Z0-9]{20,}/g, label: 'Stripe restricted key (live)' },
+    { pattern: /AKIA[0-9A-Z]{16}/g, label: 'AWS Access Key ID' },
+    { pattern: /ghp_[a-zA-Z0-9]{36}/g, label: 'GitHub Personal Access Token' },
+    { pattern: /xoxb-[0-9]{11}-[0-9]{11}-[a-zA-Z0-9]{24}/g, label: 'Slack Bot Token' },
+    { pattern: /AIza[0-9A-Za-z\-_]{35}/g, label: 'Google API Key' },
+    { pattern: /eyJ[A-Za-z0-9_-]+\.[A-Za-z0-9_-]+\.[A-Za-z0-9_-]+/g, label: 'JWT Token hardcoded' },
+    { pattern: /password\s*[:=]\s*["'][^"']{6,}["']/gi, label: 'Hardcoded password' },
+    { pattern: /secret\s*[:=]\s*["'][^"']{8,}["']/gi, label: 'Hardcoded secret' },
+    { pattern: /api[_-]?key\s*[:=]\s*["'][^"']{8,}["']/gi, label: 'Hardcoded API key' },
+];
+const SKIP_DIRS = new Set([
+    'node_modules', '.git', '.next', 'dist', 'build', '.turbo',
+    'coverage', '.cache', '__pycache__', 'vendor',
+]);
+const SCAN_EXTENSIONS = new Set([
+    '.ts', '.tsx', '.js', '.jsx', '.env', '.json', '.yaml', '.yml',
+    '.py', '.rb', '.go', '.php', '.java', '.cs', '.sh', '.bash',
+]);
+function walkFiles(dir, maxFiles = 2000) {
+    const results = [];
+    function recurse(current, depth) {
+        if (depth > 8 || results.length >= maxFiles)
+            return;
+        let entries;
+        try {
+            entries = fs_1.default.readdirSync(current, { withFileTypes: true });
+        }
+        catch {
+            return;
+        }
+        for (const entry of entries) {
+            if (SKIP_DIRS.has(entry.name))
+                continue;
+            const full = path_1.default.join(current, entry.name);
+            if (entry.isDirectory()) {
+                recurse(full, depth + 1);
+            }
+            else if (entry.isFile()) {
+                const ext = path_1.default.extname(entry.name).toLowerCase();
+                if (SCAN_EXTENSIONS.has(ext) || entry.name.startsWith('.env')) {
+                    results.push(full);
+                }
+            }
+        }
+    }
+    recurse(dir, 0);
+    return results;
+}
+function checkSecrets(files, projectRoot) {
+    const findings = [];
+    for (const file of files) {
+        // Pula arquivos de lock e binários
+        if (file.endsWith('.lock') || file.endsWith('.min.js'))
+            continue;
+        let content;
+        try {
+            content = fs_1.default.readFileSync(file, 'utf8');
+        }
+        catch {
+            continue;
+        }
+        const lines = content.split('\n');
+        for (const { pattern, label } of SECRET_PATTERNS) {
+            pattern.lastIndex = 0;
+            for (let i = 0; i < lines.length; i++) {
+                const line = lines[i];
+                if (pattern.test(line)) {
+                    // Pula se estiver em comentário ou exemplo óbvio
+                    if (/\/\/.*example|\/\/.*sample|#.*example/i.test(line))
+                        continue;
+                    if (/your[_-]?key|placeholder|xxx|abc123/i.test(line))
+                        continue;
+                    findings.push({
+                        severity: 'critical',
+                        category: 'Secret Exposure',
+                        message: `${label} encontrado hardcoded`,
+                        file: path_1.default.relative(projectRoot, file),
+                        line: i + 1,
+                        snippet: line.trim().slice(0, 80),
+                    });
+                    pattern.lastIndex = 0;
+                    break; // um finding por arquivo por padrão
+                }
+                pattern.lastIndex = 0;
+            }
+        }
+    }
+    return findings;
+}
+function checkEnvFiles(projectRoot) {
+    const findings = [];
+    const gitignorePath = path_1.default.join(projectRoot, '.gitignore');
+    const envPath = path_1.default.join(projectRoot, '.env');
+    const envLocalPath = path_1.default.join(projectRoot, '.env.local');
+    let gitignoreContent = '';
+    if (fs_1.default.existsSync(gitignorePath)) {
+        gitignoreContent = fs_1.default.readFileSync(gitignorePath, 'utf8');
+    }
+    else {
+        findings.push({
+            severity: 'warning',
+            category: 'Git Security',
+            message: '.gitignore não encontrado — secrets podem ser commitados acidentalmente',
+        });
+    }
+    if (fs_1.default.existsSync(envPath)) {
+        if (!gitignoreContent.includes('.env')) {
+            findings.push({
+                severity: 'critical',
+                category: 'Git Security',
+                message: '.env existe mas NÃO está no .gitignore — risco de exposição de secrets',
+                file: '.env',
+            });
+        }
+        else {
+            findings.push({
+                severity: 'info',
+                category: 'Git Security',
+                message: '.env presente e protegido pelo .gitignore',
+                file: '.env',
+            });
+        }
+    }
+    if (fs_1.default.existsSync(envLocalPath) && !gitignoreContent.includes('.env.local')) {
+        findings.push({
+            severity: 'warning',
+            category: 'Git Security',
+            message: '.env.local existe mas pode não estar no .gitignore',
+            file: '.env.local',
+        });
+    }
+    return findings;
+}
+function checkDependencies(projectRoot) {
+    const findings = [];
+    const pkgPath = path_1.default.join(projectRoot, 'package.json');
+    if (!fs_1.default.existsSync(pkgPath))
+        return findings;
+    let pkg;
+    try {
+        pkg = JSON.parse(fs_1.default.readFileSync(pkgPath, 'utf8'));
+    }
+    catch {
+        return findings;
+    }
+    const allDeps = {
+        ...pkg.dependencies,
+        ...pkg.devDependencies,
+    };
+    // Pacotes conhecidamente problemáticos ou abandonados
+    const flagged = {
+        'event-stream': 'Pacote comprometido em supply chain attack (2018)',
+        'flatmap-stream': 'Pacote malicioso injetado via event-stream',
+        'node-uuid': 'Deprecated — use "uuid" em vez disso',
+        'request': 'Deprecated e não mantido desde 2020',
+        'lodash': 'Versões < 4.17.21 têm vulnerabilidade de prototype pollution',
+    };
+    for (const [dep, reason] of Object.entries(flagged)) {
+        if (allDeps[dep]) {
+            findings.push({
+                severity: dep === 'event-stream' || dep === 'flatmap-stream' ? 'critical' : 'warning',
+                category: 'Dependencies',
+                message: `${dep}@${allDeps[dep]}: ${reason}`,
+            });
+        }
+    }
+    // Verifica se tem npm audit disponível
+    findings.push({
+        severity: 'info',
+        category: 'Dependencies',
+        message: `${Object.keys(allDeps).length} dependências encontradas. Rode "npm audit" para verificação completa.`,
+    });
+    return findings;
+}
+function checkAuthPatterns(files, projectRoot) {
+    const findings = [];
+    // Rotas sem middleware de auth em Next.js/Express
+    const routeFiles = files.filter(f => (f.includes('/api/') || f.includes('/routes/')) &&
+        (f.endsWith('.ts') || f.endsWith('.js')));
+    let unprotectedRoutes = 0;
+    for (const file of routeFiles) {
+        let content;
+        try {
+            content = fs_1.default.readFileSync(file, 'utf8');
+        }
+        catch {
+            continue;
+        }
+        const hasAuth = content.includes('getSession') ||
+            content.includes('getServerSession') ||
+            content.includes('auth()') ||
+            content.includes('requireAuth') ||
+            content.includes('verifyToken') ||
+            content.includes('middleware') ||
+            content.includes('authenticate') ||
+            content.includes('authorize') ||
+            content.includes('clerkClient') ||
+            content.includes('currentUser');
+        const isPublicRoute = file.includes('/auth/') ||
+            file.includes('/public/') ||
+            file.includes('webhook') ||
+            file.includes('health') ||
+            file.includes('callback');
+        if (!hasAuth && !isPublicRoute) {
+            unprotectedRoutes++;
+            if (unprotectedRoutes <= 3) {
+                findings.push({
+                    severity: 'warning',
+                    category: 'Authentication',
+                    message: 'Rota sem verificação de autenticação detectada',
+                    file: path_1.default.relative(projectRoot, file),
+                });
+            }
+        }
+    }
+    if (unprotectedRoutes > 3) {
+        findings.push({
+            severity: 'warning',
+            category: 'Authentication',
+            message: `${unprotectedRoutes - 3} outras rotas sem autenticação detectadas`,
+        });
+    }
+    return findings;
+}
+function calculateScore(findings) {
+    let score = 100;
+    for (const f of findings) {
+        if (f.severity === 'critical')
+            score -= 20;
+        else if (f.severity === 'warning')
+            score -= 5;
+    }
+    return Math.max(0, score);
+}
+function saveReport(result, projectRoot) {
+    const dir = path_1.default.join(projectRoot, '.vibetachyon');
+    if (!fs_1.default.existsSync(dir))
+        fs_1.default.mkdirSync(dir, { recursive: true });
+    const reportPath = path_1.default.join(dir, 'cipher-audit.md');
+    const scoreEmoji = result.summary.score >= 80 ? '🟢' : result.summary.score >= 50 ? '🟡' : '🔴';
+    const lines = [
+        `# CIPHER — Security Audit Report`,
+        ``,
+        `**Projeto:** \`${result.projectRoot}\``,
+        `**Data:** ${new Date(result.timestamp).toLocaleString('pt-BR')}`,
+        `**Score de Segurança:** ${scoreEmoji} ${result.summary.score}/100`,
+        ``,
+        `## Resumo`,
+        ``,
+        `| Severidade | Total |`,
+        `|------------|-------|`,
+        `| 🔴 Critical | ${result.summary.critical} |`,
+        `| 🟡 Warning  | ${result.summary.warning} |`,
+        `| 🔵 Info     | ${result.summary.info} |`,
+        ``,
+        `## Findings`,
+        ``,
+    ];
+    const criticals = result.findings.filter(f => f.severity === 'critical');
+    const warnings = result.findings.filter(f => f.severity === 'warning');
+    const infos = result.findings.filter(f => f.severity === 'info');
+    for (const group of [
+        { label: '🔴 Critical', items: criticals },
+        { label: '🟡 Warning', items: warnings },
+        { label: '🔵 Info', items: infos },
+    ]) {
+        if (group.items.length === 0)
+            continue;
+        lines.push(`### ${group.label}`);
+        lines.push('');
+        for (const f of group.items) {
+            lines.push(`- **[${f.category}]** ${f.message}`);
+            if (f.file)
+                lines.push(`  - Arquivo: \`${f.file}\`${f.line ? ` (linha ${f.line})` : ''}`);
+            if (f.snippet)
+                lines.push(`  - \`${f.snippet}\``);
+        }
+        lines.push('');
+    }
+    lines.push(`---`);
+    lines.push(`*Gerado pelo CIPHER — VibeTachyon Security Agent*`);
+    fs_1.default.writeFileSync(reportPath, lines.join('\n'), 'utf8');
+    return reportPath;
+}
+async function runCipherAudit(projectRoot) {
+    const files = walkFiles(projectRoot);
+    const findings = [
+        ...checkSecrets(files, projectRoot),
+        ...checkEnvFiles(projectRoot),
+        ...checkDependencies(projectRoot),
+        ...checkAuthPatterns(files, projectRoot),
+    ];
+    const critical = findings.filter(f => f.severity === 'critical').length;
+    const warning = findings.filter(f => f.severity === 'warning').length;
+    const info = findings.filter(f => f.severity === 'info').length;
+    const result = {
+        projectRoot,
+        timestamp: new Date().toISOString(),
+        findings,
+        summary: {
+            critical,
+            warning,
+            info,
+            total: findings.length,
+            score: calculateScore(findings),
+        },
+    };
+    saveReport(result, projectRoot);
+    return result;
+}

package/dist/index.js

@@ -50,6 +50,7 @@ const update_js_1 = require("./core/spec/update.js");
 const validate_js_1 = require("./core/spec/validate.js");
 const personas_js_1 = require("./core/orchestrator/personas.js");
 const config_js_3 = require("./core/persona/config.js");
+const cipher_audit_js_1 = require("./core/security/cipher-audit.js");
 const contract_js_1 = require("./core/persona/contract.js");
 const inspect_js_1 = require("./core/persona/inspect.js");
 const recommend_js_1 = require("./core/persona/recommend.js");
@@ -119,6 +120,70 @@ function printBanner() {
 `;
     console.log(banner);
 }
+const AGENT_ASCII = {
+    QUASAR: `
+  ██████╗ ██╗   ██╗ █████╗ ███████╗ █████╗ ██████╗
+ ██╔═══██╗██║   ██║██╔══██╗██╔════╝██╔══██╗██╔══██╗
+ ██║   ██║██║   ██║███████║███████╗███████║██████╔╝
+ ██║▄▄ ██║██║   ██║██╔══██║╚════██║██╔══██║██╔══██╗
+ ╚██████╔╝╚██████╔╝██║  ██║███████║██║  ██║██║  ██║
+  ╚══▀▀═╝  ╚═════╝ ╚═╝  ╚═╝╚══════╝╚═╝  ╚═╝╚═╝  ╚═╝`,
+    LUMEN: `
+ ██╗     ██╗   ██╗███╗   ███╗███████╗███╗   ██╗
+ ██║     ██║   ██║████╗ ████║██╔════╝████╗  ██║
+ ██║     ██║   ██║██╔████╔██║█████╗  ██╔██╗ ██║
+ ██║     ██║   ██║██║╚██╔╝██║██╔══╝  ██║╚██╗██║
+ ███████╗╚██████╔╝██║ ╚═╝ ██║███████╗██║ ╚████║
+ ╚══════╝ ╚═════╝ ╚═╝     ╚═╝╚══════╝╚═╝  ╚═══╝`,
+    AXIOM: `
+  █████╗ ██╗  ██╗██╗ ██████╗ ███╗   ███╗
+ ██╔══██╗╚██╗██╔╝██║██╔═══██╗████╗ ████║
+ ███████║ ╚███╔╝ ██║██║   ██║██╔████╔██║
+ ██╔══██║ ██╔██╗ ██║██║   ██║██║╚██╔╝██║
+ ██║  ██║██╔╝ ██╗██║╚██████╔╝██║ ╚═╝ ██║
+ ╚═╝  ╚═╝╚═╝  ╚═╝╚═╝ ╚═════╝ ╚═╝     ╚═╝`,
+    CIPHER: `
+  ██████╗██╗██████╗ ██╗  ██╗███████╗██████╗
+ ██╔════╝██║██╔══██╗██║  ██║██╔════╝██╔══██╗
+ ██║     ██║██████╔╝███████║█████╗  ██████╔╝
+ ██║     ██║██╔═══╝ ██╔══██║██╔══╝  ██╔══██╗
+ ╚██████╗██║██║     ██║  ██║███████╗██║  ██║
+  ╚═════╝╚═╝╚═╝     ╚═╝  ╚═╝╚══════╝╚═╝  ╚═╝`,
+    FLUX: `
+ ███████╗██╗     ██╗   ██╗██╗  ██╗
+ ██╔════╝██║     ██║   ██║╚██╗██╔╝
+ █████╗  ██║     ██║   ██║ ╚███╔╝
+ ██╔══╝  ██║     ██║   ██║ ██╔██╗
+ ██║     ███████╗╚██████╔╝██╔╝ ██╗
+ ╚═╝     ╚══════╝ ╚═════╝ ╚═╝  ╚═╝`,
+    PRISM: `
+ ██████╗ ██████╗ ██╗███████╗███╗   ███╗
+ ██╔══██╗██╔══██╗██║██╔════╝████╗ ████║
+ ██████╔╝██████╔╝██║███████╗██╔████╔██║
+ ██╔═══╝ ██╔══██╗██║╚════██║██║╚██╔╝██║
+ ██║     ██║  ██║██║███████║██║ ╚═╝ ██║
+ ╚═╝     ╚═╝  ╚═╝╚═╝╚══════╝╚═╝     ╚═╝`,
+    ZENITH: `
+ ███████╗███████╗███╗   ██╗██╗████████╗██╗  ██╗
+ ╚══███╔╝██╔════╝████╗  ██║██║╚══██╔══╝██║  ██║
+   ███╔╝ █████╗  ██╔██╗ ██║██║   ██║   ███████║
+  ███╔╝  ██╔══╝  ██║╚██╗██║██║   ██║   ██╔══██║
+ ███████╗███████╗██║ ╚████║██║   ██║   ██║  ██║
+ ╚══════╝╚══════╝╚═╝  ╚═══╝╚═╝   ╚═╝   ╚═╝  ╚═╝`,
+};
+function printAgentBanner(personaId) {
+    const persona = (0, config_js_3.getPersona)(personaId);
+    const ascii = AGENT_ASCII[persona.agentName] ?? '';
+    console.log(`${persona.agentColor}${ascii}\x1b[0m`);
+    console.log(`${persona.agentColor}  ⚡ ${persona.agentName} — ${persona.label} Agent\x1b[0m`);
+    console.log(`\x1b[90m  ${persona.agentTagline}\x1b[0m`);
+    console.log('');
+}
+// Detecta se foi invocado por nome de agente (ex: `cipher audit`)
+function detectAgentBin() {
+    const binName = path_1.default.basename(process.argv[1] ?? '').replace(/\.js$/, '').toLowerCase();
+    return config_js_3.AGENT_BIN_MAP[binName] ?? null;
+}
 async function runInteractiveMode() {
     printBanner();
     (0, prompts_1.intro)(picocolors_1.default.yellow(`⚡ Orchestrating VibeTachyon CLI v${CLI_VERSION}...`));
@@ -5138,8 +5203,76 @@ async function main() {
         console.log(result.message);
         (0, session_state_js_1.recordSessionEvent)('mcp migrate', 'success', options.dryRun ? 'dry-run' : 'written');
     });
+    // Detecta se foi invocado por nome de agente (ex: `cipher audit`)
+    const agentPersonaId = detectAgentBin();
+    if (agentPersonaId) {
+        printAgentBanner(agentPersonaId);
+        // Auto-ativa a persona correspondente
+        const projectRoot = process.cwd();
+        (0, config_js_3.saveActivePersona)(projectRoot, agentPersonaId);
+    }
     if (process.argv.length <= 2) {
-        await runInteractiveMode();
+        if (!agentPersonaId) {
+            await runInteractiveMode();
+        }
+        else {
+            const projectRoot = process.cwd();
+            if (agentPersonaId === 'security') {
+                const steps = [
+                    '  Mapeando estrutura do projeto...',
+                    '  Escaneando arquivos em busca de secrets...',
+                    '  Verificando configurações de segurança...',
+                    '  Analisando dependências...',
+                    '  Verificando rotas e autenticação...',
+                    '  Gerando relatório...',
+                ];
+                const spinnerFrames = ['⠋', '⠙', '⠹', '⠸', '⠼', '⠴', '⠦', '⠧', '⠇', '⠏'];
+                let frameIdx = 0;
+                let stepIdx = 0;
+                const interval = setInterval(() => {
+                    const frame = spinnerFrames[frameIdx % spinnerFrames.length];
+                    const step = steps[Math.min(stepIdx, steps.length - 1)];
+                    process.stdout.write(`\r\x1b[38;5;46m  ${frame}\x1b[0m\x1b[90m${step}\x1b[0m\x1b[K`);
+                    frameIdx++;
+                    if (frameIdx % 8 === 0 && stepIdx < steps.length - 1)
+                        stepIdx++;
+                }, 80);
+                const result = await (0, cipher_audit_js_1.runCipherAudit)(projectRoot);
+                clearInterval(interval);
+                process.stdout.write(`\r\x1b[K`);
+                console.log(`\x1b[38;5;46m  ✓ Auditoria concluída\x1b[0m\n`);
+                const { summary } = result;
+                const scoreColor = summary.score >= 80 ? '\x1b[38;5;46m' : summary.score >= 50 ? '\x1b[38;5;220m' : '\x1b[38;5;196m';
+                console.log(`${scoreColor}  Score de Segurança: ${summary.score}/100\x1b[0m`);
+                console.log(`\x1b[38;5;196m  🔴 Critical: ${summary.critical}\x1b[0m`);
+                console.log(`\x1b[38;5;220m  🟡 Warning:  ${summary.warning}\x1b[0m`);
+                console.log(`\x1b[38;5;39m  🔵 Info:     ${summary.info}\x1b[0m`);
+                console.log('');
+                if (summary.critical > 0 || summary.warning > 0) {
+                    const criticals = result.findings.filter(f => f.severity === 'critical').slice(0, 3);
+                    const warnings = result.findings.filter(f => f.severity === 'warning').slice(0, 3);
+                    for (const f of criticals) {
+                        console.log(`\x1b[38;5;196m  ❌ [${f.category}] ${f.message}\x1b[0m`);
+                        if (f.file)
+                            console.log(`\x1b[90m     → ${f.file}${f.line ? `:${f.line}` : ''}\x1b[0m`);
+                    }
+                    for (const f of warnings) {
+                        console.log(`\x1b[38;5;220m  ⚠️  [${f.category}] ${f.message}\x1b[0m`);
+                        if (f.file)
+                            console.log(`\x1b[90m     → ${f.file}\x1b[0m`);
+                    }
+                    console.log('');
+                }
+                else {
+                    console.log(`\x1b[38;5;46m  ✅ Nenhum problema crítico encontrado.\x1b[0m\n`);
+                }
+                console.log(`\x1b[90m  Relatório completo salvo em .vibetachyon/cipher-audit.md\x1b[0m\n`);
+            }
+            else {
+                const persona = (0, config_js_3.getPersona)(agentPersonaId);
+                console.log(`\x1b[90m  Persona ${persona.agentName} ativada. Use os comandos do VibeTachyon normalmente.\x1b[0m\n`);
+            }
+        }
         return;
     }
     await program.parseAsync(process.argv);

package/package.json

@@ -1,10 +1,18 @@
 {
     "name": "vibetachyon",
-    "version": "1.5.1",
+    "version": "1.5.2",
     "description": "VibeCodes MCP CLI Installer and Server",
     "main": "dist/index.js",
     "bin": {
-        "vibetachyon": "dist/index.js"
+        "vibetachyon": "dist/index.js",
+        "quasar": "dist/index.js",
+        "lumen": "dist/index.js",
+        "axiom": "dist/index.js",
+        "cipher": "dist/index.js",
+        "flux": "dist/index.js",
+        "prism": "dist/index.js",
+        "zenith": "dist/index.js",
+        "nexus": "dist/index.js"
     },
     "scripts": {
         "build": "tsc",