agent-master-devsecops 0.0.0-stage → 5.1.0

package/scripts/core/magic_prompt_generator.js

@@ -0,0 +1,250 @@
+#!/usr/bin/env node
+/**
+ * scripts/core/magic_prompt_generator.js
+ * 
+ * Magic Prompt Generator & Web Bookmarklet (AGDEV-27 / v5.1.0 Enterprise).
+ * Gera prompt autocontido de ativação instantânea (< 900 tokens) e bookmarklet
+ * web para injeção em 1 clique no ChatGPT, Claude.ai, Gemini e DeepSeek Web.
+ * Em conformidade estrita com os 10 Princípios Canônicos de Engenharia e Tríplice Registro.
+ */
+
+'use strict';
+
+const fs = require('node:fs');
+const path = require('node:path');
+const { createSarifReport } = require('./sarif_engine.js');
+
+class MagicPromptGenerator {
+  constructor(baseDir = path.resolve(__dirname, '../..')) {
+    this.baseDir = baseDir;
+  }
+
+  generateMagicPrompt(target = 'generic') {
+    const prompt = `=== AGENT ORCHESTRATOR & SUÍTE MULTI-AGENTE (UNIVERSAL INSTANT ACTIVATION) ===
+[DIRECTIVE]: You are now running the canonical Agent Suite (Orchestrator, DevSecOps, QA, Scrum, SRE, UI/UX & Infra Engineer). Assume 100% adherence to the 10 Canonical Engineering Principles (v5.1 Enterprise) and rules below:
+
+[THE 14 GOLDEN ENGINEERING RULES & 10 CANONICAL PRINCIPLES]:
+1. Code Quality & Clean Architecture: DRY, defensive programming, explicit contracts and typed interfaces.
+2. DevSecOps Shift-Left: Immune to OWASP Top 10 (CWE-78, CWE-79, CWE-89, CWE-1333 ReDoS); zero secrets in commits.
+3. Triple Ledger Traceability: Dedicated branch per ticket (<TICKET>), formatted commits, Kanban sync and ADRs.
+4. TDD & Strict DoD: Automated tests (unit, integration, regression) written before/alongside implementation.
+5. Exception Handling & Resilience: No empty catches; graceful circuit breaking and resilient fallbacks.
+6. Observabilidade & SRE: Prometheus metrics (/metrics), process telemetry and W3C TraceContext headers.
+7. Value Engineering & Anti-Overengineering: Proportionate solutions without accidental complexity or premature microservices.
+8. Requirements Engineering & Invariant Acceptance Criteria: BDD Given-When-Then criteria remain immutable unless explicitly approved.
+9. Justified Technical Decision (Anti-Hype & ADRs): Formal trade-off evaluation documented in Confluence/Markdown ADRs.
+10. Continuous Kaizen: Root cause analysis on any defect; prevent recurrent regression autonomously.
+
+[OPERATIONAL MODES]:
+- modo: orchestrator (central coordination, triage and multi-agent dispatch)
+- modo: devsecops (secure, robust code, clean architecture and CI/CD)
+- modo: qa (adversarial cold review, bug hunting and breaking tests)
+- modo: scrum (Kaizen/PDCA continuous improvement without overengineering)
+- modo: sre (SRE, telemetry, incident diagnosis and self-healing)
+- modo: uiux (design system, accessibility WCAG 2.1 AA, UX ergonomics, design tokens)
+- modo: infra (real networking, containers, Docker, Cloudflare Tunnel and CI/CD)
+- modo: full-dev (autonomous sequential idea implementation loop)
+
+[ACTIVATION ACKNOWLEDGEMENT]:
+Acknowledge activation with a 2-line executive greeting:
+"⚡ Suíte Multi-Agente universalmente ativada e pronta para qualquer demanda.
+Informe a stack e solicite credenciais Atlassian (Jira/Confluence) e GitHub CLI se for nova máquina ou projeto."`;
+
+    return prompt;
+  }
+
+  generateBookmarklet() {
+    const rawPrompt = this.generateMagicPrompt();
+    const encodedPrompt = JSON.stringify(rawPrompt);
+
+    // Bookmarklet inline seguro que detecta o campo de chat e copia para o clipboard
+    const script = `javascript:(function(){
+  var promptText = ${encodedPrompt};
+  
+  if (navigator.clipboard && navigator.clipboard.writeText) {
+    navigator.clipboard.writeText(promptText).then(function() {
+      showToast("⚡ Suíte Multi-Agente copiada! Cole (Ctrl+V) no chat da IA.");
+    }).catch(function() {
+      fallbackPrompt(promptText);
+    });
+  } else {
+    fallbackPrompt(promptText);
+  }
+
+  var inputEl = document.querySelector('#prompt-textarea') || 
+                 document.querySelector('div[contenteditable="true"]') || 
+                 document.querySelector('textarea');
+  if (inputEl) {
+    if (inputEl.tagName === 'TEXTAREA') {
+      inputEl.value = promptText;
+      inputEl.dispatchEvent(new Event('input', { bubbles: true }));
+    } else if (inputEl.isContentEditable) {
+      inputEl.innerText = promptText;
+      inputEl.dispatchEvent(new Event('input', { bubbles: true }));
+    }
+  }
+
+  function showToast(msg) {
+    var toast = document.createElement('div');
+    toast.innerText = msg;
+    toast.style.position = 'fixed';
+    toast.style.top = '20px';
+    toast.style.right = '20px';
+    toast.style.backgroundColor = '#0f172a';
+    toast.style.color = '#38bdf8';
+    toast.style.padding = '14px 20px';
+    toast.style.borderRadius = '8px';
+    toast.style.boxShadow = '0 10px 25px rgba(0,0,0,0.5)';
+    toast.style.zIndex = '999999';
+    toast.style.fontFamily = 'system-ui, sans-serif';
+    toast.style.fontSize = '14px';
+    toast.style.border = '1px solid #38bdf8';
+    document.body.appendChild(toast);
+    setTimeout(function() { toast.remove(); }, 3500);
+  }
+
+  function fallbackPrompt(text) {
+    window.prompt("Copie o Magic Prompt abaixo:", text);
+  }
+})();`.replace(/\n\s*/g, '');
+
+    return script;
+  }
+
+  estimateTokens(text = '') {
+    if (!text || typeof text !== 'string') return 0;
+    return Math.ceil(text.length / 4);
+  }
+
+  exportArtifacts(targetDir = path.join(this.baseDir, 'dist', 'magic_prompt'), options = {}) {
+    const dryRun = Boolean(options.dryRun);
+    const magicPrompt = this.generateMagicPrompt();
+    const bookmarklet = this.generateBookmarklet();
+    const tokens = this.estimateTokens(magicPrompt);
+
+    const htmlContent = `<!DOCTYPE html>
+<html lang="pt-BR">
+<head>
+  <meta charset="UTF-8">
+  <title>Suíte Multi-Agente — Magic Prompt & Bookmarklet</title>
+  <style>
+    body { font-family: system-ui, -apple-system, sans-serif; background: #0f172a; color: #f8fafc; padding: 40px; line-height: 1.6; }
+    .card { background: #1e293b; border: 1px solid #334155; border-radius: 12px; padding: 24px; max-width: 800px; margin: 0 auto 30px; box-shadow: 0 10px 25px rgba(0,0,0,0.3); }
+    h1 { color: #38bdf8; margin-top: 0; }
+    pre { background: #090d16; padding: 16px; border-radius: 8px; overflow-x: auto; font-size: 13px; color: #cbd5e1; border: 1px solid #1e293b; }
+    .btn { display: inline-block; background: #0284c7; color: white; padding: 12px 20px; border-radius: 8px; text-decoration: none; font-weight: bold; cursor: grab; }
+    .btn:hover { background: #0369a1; }
+  </style>
+</head>
+<body>
+  <div class="card">
+    <h1>⚡ Suíte Multi-Agente — Ativação Instantânea</h1>
+    <p>Arraste o botão abaixo para a sua <strong>Barra de Favoritos</strong> do navegador. Ao clicar nele em qualquer aba do ChatGPT, Claude, Gemini ou DeepSeek, a suíte de agentes será ativada instantaneamente!</p>
+    <p style="margin: 30px 0;">
+      <a class="btn" href="${bookmarklet}">⚡ Ativar Suíte Multi-Agente</a>
+    </p>
+    <small style="color: #94a3b8;">Dica: você também pode clicar com o botão direito e selecionar "Adicionar aos favoritos".</small>
+  </div>
+
+  <div class="card">
+    <h2>📋 Magic Prompt (Cópia Manual — ~${tokens} tokens)</h2>
+    <pre id="promptText">${magicPrompt.replace(/</g, '&lt;').replace(/>/g, '&gt;')}</pre>
+  </div>
+</body>
+</html>`;
+
+    const mdContent = `# ⚡ Magic Prompt — Ativação Instantânea da Suíte Multi-Agente
+
+Copie o bloco abaixo e cole como primeira mensagem em **qualquer LLM** (ChatGPT, Claude.ai, Gemini, DeepSeek Web, Ollama ou LeChat) para assumir imediatamente 100% dos 10 Princípios Canônicos de Engenharia:
+
+\`\`\`text
+${magicPrompt}
+\`\`\`
+
+---
+*Orçamento semântico: ~${tokens} tokens (limite estrito de 1.000 tokens respeitado com 100% de conformidade).*
+`;
+
+    const files = [
+      { path: path.join(targetDir, 'MAGIC_PROMPT.md'), content: mdContent },
+      { path: path.join(targetDir, 'bookmarklet.html'), content: htmlContent }
+    ];
+
+    if (!dryRun) {
+      if (!fs.existsSync(targetDir)) fs.mkdirSync(targetDir, { recursive: true });
+      files.forEach(f => fs.writeFileSync(f.path, f.content, 'utf8'));
+    }
+
+    return {
+      status: 'SUCCESS',
+      targetDir,
+      tokens,
+      dryRun,
+      filesCount: files.length,
+      files: files.map(f => f.path),
+      magicPrompt,
+      bookmarklet
+    };
+  }
+
+  auditToSarif() {
+    const magicPrompt = this.generateMagicPrompt();
+    const tokens = this.estimateTokens(magicPrompt);
+    const findings = [];
+
+    if (tokens > 1000) {
+      findings.push({
+        ruleId: 'RULE-MAGIC-001',
+        name: 'MagicPromptBudgetExceeded',
+        severity: 'WARNING',
+        message: `O Magic Prompt excedeu o teto estrito de 1.000 tokens (atual: ${tokens} tokens).`,
+        remediation: 'Mantenha o prompt enxuto e hiper-focado.'
+      });
+    }
+
+    return createSarifReport({
+      toolName: 'agent-master-magic-prompt-generator',
+      rules: [
+        {
+          id: 'RULE-MAGIC-001',
+          name: 'MagicPromptBudgetExceeded',
+          description: 'Valida se o Magic Prompt cabe no orçamento estrito de < 1.000 tokens',
+          severity: 'MEDIUM',
+          cwe: 'CWE-400'
+        }
+      ],
+      findings,
+      properties: {
+        tokens,
+        underBudget: tokens <= 1000
+      }
+    });
+  }
+
+  formatReport() {
+    const prompt = this.generateMagicPrompt();
+    const tokens = this.estimateTokens(prompt);
+    return [
+      '### Relatório do Gerador de Magic Prompt & Bookmarklet',
+      `- **Tokens:** ~${tokens} tokens (< 1.000 tokens)`,
+      `- **Bookmarklet:** Gerado com injeção automática e fallback`,
+      `- **Conformidade:** 10 Princípios Canônicos Universais (v5.1)`
+    ].join('\n');
+  }
+}
+
+if (require.main === module) {
+  const generator = new MagicPromptGenerator();
+  const res = generator.exportArtifacts();
+  console.log('\n============================================================');
+  console.log('⚡ Magic Prompt Generator & Web Bookmarklet (AGDEV-27)');
+  console.log('============================================================\n');
+  console.log(`✅ Arquivos exportados com sucesso em: ${res.targetDir}`);
+  console.log(`📊 Orçamento de Tokens Estimado: ~${res.tokens} tokens (< 1.000 tokens)`);
+  console.log(`📄 Arquivos gerados:`, res.files.join(', '));
+  console.log('\nO bookmarklet HTML e o MAGIC_PROMPT.md estão prontos para uso!\n');
+}
+
+module.exports = {
+  MagicPromptGenerator
+};

package/scripts/core/multi_agent_orchestrator.js

@@ -0,0 +1,421 @@
+/**
+ * Multi-Agent Event Bus & Orchestration Engine
+ * Topologia de cooperação determinística, barramento de eventos lógicos
+ * e handovers automáticos entre os 6 modos da suíte multi-agente.
+ * Conforme especificado em docs/ARCHITECTURE.md.
+ */
+
+const fs = require('node:fs');
+const path = require('node:path');
+const crypto = require('node:crypto');
+const { SECURITY_RULES } = require('../auditors/sast_scanner.js');
+const { createSarifReport } = require('./sarif_engine.js');
+
+// Definição canônica dos 7 modos / personas oficiais (+ full-dev)
+const AGENT_PERSONAS = {
+  ORCHESTRATOR: 'modo: orchestrator',
+  UIUX: 'modo: uiux',
+  DEVSECOPS: 'modo: devsecops',
+  QA: 'modo: qa',
+  SCRUM: 'modo: scrum',
+  SRE: 'modo: sre',
+  INFRA: 'modo: infra',
+  FULL_DEV: 'modo: full-dev'
+};
+
+// Definição canônica dos eventos de barramento
+const EVENT_TYPES = {
+  EVENT_REQUIREMENTS_READY: 'EVENT_REQUIREMENTS_READY',
+  EVENT_DESIGN_READY: 'EVENT_DESIGN_READY',
+  EVENT_UI_REVIEW: 'EVENT_UI_REVIEW',
+  EVENT_CODE_COMPLETE: 'EVENT_CODE_COMPLETE',
+  EVENT_REVIEW_FAILED: 'EVENT_REVIEW_FAILED',
+  EVENT_REVIEW_PASSED: 'EVENT_REVIEW_PASSED',
+  EVENT_METRIC_ANOMALY: 'EVENT_METRIC_ANOMALY',
+  EVENT_REFACTOR_PROPOSAL: 'EVENT_REFACTOR_PROPOSAL',
+  EVENT_AGENT_SELF_IMPROVE: 'EVENT_AGENT_SELF_IMPROVE',
+  EVENT_KANBAN_DISPATCH: 'EVENT_KANBAN_DISPATCH',
+  EVENT_INFRA_PROVISIONED: 'EVENT_INFRA_PROVISIONED'
+};
+
+class MultiAgentOrchestrator {
+  constructor(options = {}) {
+    this.history = [];
+    this.subscribers = new Map();
+    this.storagePath = typeof options === 'string' ? options : (options?.storagePath || null);
+    this.db = null;
+    this._initDatabase(this.storagePath);
+    this._setupDefaultRoutes();
+  }
+
+  _initDatabase(storagePath) {
+    try {
+      const { DatabaseSync } = require('node:sqlite');
+      if (storagePath) {
+        const dir = path.dirname(storagePath);
+        if (dir && !fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
+        this.db = new DatabaseSync(storagePath);
+      } else {
+        this.db = new DatabaseSync(':memory:');
+      }
+
+      this.db.exec(`
+        CREATE TABLE IF NOT EXISTS event_log (
+          id INTEGER PRIMARY KEY AUTOINCREMENT,
+          event_id TEXT UNIQUE,
+          event_type TEXT,
+          timestamp TEXT,
+          payload_json TEXT,
+          result_json TEXT
+        );
+        CREATE INDEX IF NOT EXISTS idx_event_type ON event_log(event_type);
+      `);
+
+      // Se existir histórico prévio persistido no banco, carrega na memória
+      const rows = this.db.prepare('SELECT * FROM event_log ORDER BY id ASC').all();
+      for (const row of rows) {
+        try {
+          this.history.push({
+            eventId: row.event_id,
+            eventType: row.event_type,
+            timestamp: row.timestamp,
+            payload: JSON.parse(row.payload_json || '{}'),
+            result: JSON.parse(row.result_json || '{}')
+          });
+        } catch (parseErr) {
+          void parseErr;
+        }
+      }
+    } catch (_) {
+      // Fallback transparente para armazenamento puramente em memória
+      this.db = null;
+    }
+  }
+
+  _setupDefaultRoutes() {
+    // Rota 0A: EVENT_REQUIREMENTS_READY (Orchestrator/Scrum -> UIUX)
+    this.on(EVENT_TYPES.EVENT_REQUIREMENTS_READY, (payload) => {
+      return {
+        handoffTo: AGENT_PERSONAS.UIUX,
+        status: 'READY_FOR_DESIGN',
+        reason: 'Requisitos funcionais homologados; necessário design visual e acessibilidade.',
+        nextAction: 'UIUX elabora jornada, tokens e especificações WCAG 2.1 AA.',
+        requiresFix: false
+      };
+    });
+
+    // Rota 0B: EVENT_DESIGN_READY (UIUX -> DevSecOps)
+    this.on(EVENT_TYPES.EVENT_DESIGN_READY, (payload) => {
+      return {
+        handoffTo: AGENT_PERSONAS.DEVSECOPS,
+        status: 'READY_FOR_IMPLEMENTATION',
+        reason: 'Especificações visuais, design tokens e estados de componentes concluídos.',
+        nextAction: 'DevSecOps implementa código semântico aderente aos tokens e contratos.',
+        requiresFix: false
+      };
+    });
+
+    // Rota 0C: EVENT_UI_REVIEW (QA -> UIUX)
+    this.on(EVENT_TYPES.EVENT_UI_REVIEW, (payload) => {
+      const a11yPassed = payload.a11yPassed !== false;
+      return {
+        handoffTo: AGENT_PERSONAS.UIUX,
+        status: a11yPassed ? 'A11Y_APPROVED' : 'A11Y_REJECTED',
+        reason: a11yPassed ? 'Auditoria de acessibilidade WCAG aprovada.' : 'Violação de contraste ou semântica ARIA detectada.',
+        nextAction: a11yPassed ? 'Tokens e componentes homologados.' : 'UIUX deve reajustar contraste e hierarquia visual.',
+        requiresFix: !a11yPassed
+      };
+    });
+
+    // Rota 0D: EVENT_INFRA_PROVISIONED (Infra -> DevSecOps / SRE)
+    this.on(EVENT_TYPES.EVENT_INFRA_PROVISIONED, (payload) => {
+      return {
+        handoffTo: AGENT_PERSONAS.DEVSECOPS,
+        status: 'INFRA_READY',
+        reason: 'Infraestrutura de CI/CD, containers e OTLP devidamente provisionados.',
+        nextAction: 'DevSecOps valida deployment local e SRE conecta monitoramento Prometheus.',
+        requiresFix: false
+      };
+    });
+
+    // Rota 1: EVENT_CODE_COMPLETE (DevSecOps -> QA)
+    this.on(EVENT_TYPES.EVENT_CODE_COMPLETE, (payload) => {
+      const codeOrDiff = payload.diff || payload.code || '';
+      const hasTests = codeOrDiff.includes('test') || payload.testsPassing === true;
+      const hasSecrets = SECURITY_RULES.some(r => r.cwe === 'CWE-798' && r.pattern.test(codeOrDiff));
+
+      if (hasSecrets) {
+        return {
+          handoffTo: AGENT_PERSONAS.QA,
+          status: 'REJECTED',
+          reason: 'Credencial ou segredo em texto plano detectado no diff (Regra 5).',
+          nextAction: 'QA emite veto e exige expurgo imediato.',
+          requiresFix: true
+        };
+      }
+
+      if (!hasTests) {
+        return {
+          handoffTo: AGENT_PERSONAS.QA,
+          status: 'REJECTED',
+          reason: 'Entrega de código sem testes automatizados comprovados (Regra 4).',
+          nextAction: 'QA exige inclusão de testes unitários antes de qualquer aprovação.',
+          requiresFix: true
+        };
+      }
+
+      return {
+        handoffTo: AGENT_PERSONAS.QA,
+        status: 'READY_FOR_INSPECTION',
+        reason: 'Código submetido à auditoria cética adversária.',
+        nextAction: 'QA realiza análise de segurança AST e casos de borda.',
+        requiresFix: false
+      };
+    });
+
+    // Rota 2: EVENT_REVIEW_FAILED (QA -> DevSecOps)
+    this.on(EVENT_TYPES.EVENT_REVIEW_FAILED, (payload) => {
+      return {
+        handoffTo: AGENT_PERSONAS.DEVSECOPS,
+        status: 'CORRECTION_REQUIRED',
+        reason: payload.finding || 'Falha apontada pela auditoria adversária.',
+        nextAction: 'DevSecOps deve sanar a causa raiz sem contornar testes ou lint.',
+        requiresFix: true
+      };
+    });
+
+    // Rota 3: EVENT_REVIEW_PASSED (QA -> Orchestrator / CI)
+    this.on(EVENT_TYPES.EVENT_REVIEW_PASSED, (payload) => {
+      return {
+        handoffTo: AGENT_PERSONAS.ORCHESTRATOR,
+        status: 'APPROVED',
+        reason: 'Auditoria cética concluída com 100% de conformidade.',
+        nextAction: 'Liberar Pull Request, validar esteira de CI e efetuar Tríplice Registro.',
+        requiresFix: false
+      };
+    });
+
+    // Rota 4: EVENT_METRIC_ANOMALY (SRE -> Scrum & SRE)
+    this.on(EVENT_TYPES.EVENT_METRIC_ANOMALY, (payload) => {
+      const metric = payload.metric || 'unknown';
+      const value = payload.value || 0;
+      const threshold = payload.threshold || 0;
+
+      return {
+        handoffTo: AGENT_PERSONAS.SCRUM,
+        status: 'ANOMALY_TRIGGERED',
+        reason: `Métrica ${metric} atingiu ${value} (limiar: ${threshold}).`,
+        nextAction: 'Disparar playbook de auto-remediação SRE e iniciar investigação Ishikawa/PDCA.',
+        remediation: payload.recommendedPlaybook || 'PLAYBOOK_CIRCUIT_BREAKER_LLM.md'
+      };
+    });
+
+    // Rota 5: EVENT_REFACTOR_PROPOSAL (Scrum/DevSecOps -> QA Shift-Left Gate -> Backlog)
+    this.on(EVENT_TYPES.EVENT_REFACTOR_PROPOSAL, (payload) => {
+      const isAligned = payload.contextAligned !== false;
+      const isQaApproved = payload.qaApproved !== false;
+      const isOffDomain = payload.isOffDomain === true;
+      const isRedundant = payload.isRedundant === true;
+
+      if (!isAligned || !isQaApproved || isOffDomain || isRedundant) {
+        return {
+          handoffTo: AGENT_PERSONAS.QA,
+          status: 'REJECTED_SANITY_FILTER',
+          reason: 'Veto do Quality Architect (Regra 14 / Shift-Left Gate): proposta fora de domínio, overengineering ou arquivos redundantes.',
+          nextAction: 'Ideia descartada para evitar inchaço do repositório e preservar foco no produto real.',
+          ideaId: payload.ideaId || 'I-REJECTED',
+          requiresFix: true
+        };
+      }
+
+      return {
+        handoffTo: AGENT_PERSONAS.DEVSECOPS,
+        status: 'QUEUED',
+        reason: 'Proposta de melhoria homologada pelo Quality Architect em conformidade com a Regra 14.',
+        nextAction: 'Cadastrar card no backlog e criar branch dedicada.',
+        ideaId: payload.ideaId || 'I-NEW',
+        requiresFix: false
+      };
+    });
+
+    // Rota 6: EVENT_AGENT_SELF_IMPROVE (Suíte Completa -> QA Auditoria Empírica -> Orchestrator)
+    this.on(EVENT_TYPES.EVENT_AGENT_SELF_IMPROVE, (payload) => {
+      const evalPassed = payload.evalPassed !== false;
+      if (!evalPassed) {
+        return {
+          handoffTo: AGENT_PERSONAS.QA,
+          status: 'SELF_IMPROVE_REJECTED',
+          reason: 'Veto de Auditoria Empírica de QA: auto-evolução reflexiva reprovada por falta de evidência empírica mensurável.',
+          nextAction: 'Descartar hipótese para prevenir alucinação cumulativa de regras.',
+          requiresFix: true
+        };
+      }
+
+      return {
+        handoffTo: AGENT_PERSONAS.ORCHESTRATOR,
+        status: 'REFLEXIVE_LOGGED',
+        reason: 'Ciclo de auto-evolução reflexiva validado pelo Quality Architect com evidência empírica.',
+        nextAction: 'Registrar hipótese validada de domínio em IDEAS.md.',
+        tokenBudget: payload.tokenBudget || 'Under 1500 tokens',
+        requiresFix: false
+      };
+    });
+
+    // Rota 7: EVENT_KANBAN_DISPATCH (Full Dev continuous loop)
+    this.on(EVENT_TYPES.EVENT_KANBAN_DISPATCH, (payload) => {
+      const { processFullDevPipeline } = require('../integrations/jira_manager.js');
+      const pipeline = processFullDevPipeline(payload.tasks || [], payload.projectContext || {});
+      return {
+        handoffTo: AGENT_PERSONAS.FULL_DEV,
+        status: pipeline.activeTask ? 'RESUME_IN_PROGRESS' : (pipeline.nextApprovedTask ? 'START_NEXT_TASK' : 'IDLE_TODO_EMPTY'),
+        reason: pipeline.activeTask ? 'Concluir tarefa atualmente em andamento antes de avançar.' : (pipeline.nextApprovedTask ? 'Ideia aprovada pelo filtro de sanidade (Regra 14).' : 'Nenhuma tarefa pendente viável em A fazer.'),
+        nextAction: pipeline.lifecyclePlan[0] ? pipeline.lifecyclePlan[0].message : 'Aguardar novas demandas.',
+        pipeline
+      };
+    });
+
+    // Rota 8: EVENT_INFRA_PROVISIONED (Infra Engineer -> DevSecOps)
+    this.on(EVENT_TYPES.EVENT_INFRA_PROVISIONED, (payload) => {
+      return {
+        handoffTo: AGENT_PERSONAS.DEVSECOPS,
+        status: 'INFRA_READY',
+        reason: payload.reason || 'Infraestrutura e túneis de rede provisionados com sucesso.',
+        nextAction: 'DevSecOps integra código à infraestrutura e CI/CD.',
+        requiresFix: false,
+        details: payload.details || {}
+      };
+    });
+  }
+
+  on(eventType, handler) {
+    this.subscribers.set(eventType, handler);
+  }
+
+  dispatch(eventType, payload = {}) {
+    if (!EVENT_TYPES[eventType]) {
+      throw new Error(`Evento desconhecido: ${eventType}. Eventos suportados: ${Object.keys(EVENT_TYPES).join(', ')}`);
+    }
+
+    const handler = this.subscribers.get(eventType);
+    const result = handler ? handler(payload) : { status: 'NO_HANDLER' };
+
+    const eventRecord = {
+      eventId: `EVT-${Date.now()}-${crypto.randomUUID().slice(0, 8)}`,
+      eventType,
+      timestamp: new Date().toISOString(),
+      payload,
+      result
+    };
+
+    this.history.push(eventRecord);
+
+    if (this.db) {
+      try {
+        const stmt = this.db.prepare(`
+          INSERT INTO event_log (event_id, event_type, timestamp, payload_json, result_json)
+          VALUES (?, ?, ?, ?, ?)
+        `);
+        stmt.run(
+          eventRecord.eventId,
+          eventRecord.eventType,
+          eventRecord.timestamp,
+          JSON.stringify(eventRecord.payload),
+          JSON.stringify(eventRecord.result)
+        );
+      } catch (insertErr) {
+        void insertErr;
+      }
+    }
+
+    return eventRecord;
+  }
+
+  processKanbanPipeline(tasks = [], projectContext = {}) {
+    const { processFullDevPipeline } = require('../integrations/jira_manager.js');
+    return processFullDevPipeline(tasks, projectContext);
+  }
+
+  getHistory(options = {}) {
+    if (options && options.eventType) {
+      return this.history.filter(h => h.eventType === options.eventType);
+    }
+    return [...this.history];
+  }
+
+  getEventLog(options = {}) {
+    return this.getHistory(options);
+  }
+
+  clearHistory() {
+    this.history = [];
+    if (this.db) {
+      try {
+        this.db.exec('DELETE FROM event_log');
+      } catch (delErr) {
+        void delErr;
+      }
+    }
+  }
+
+  closeDatabase() {
+    if (this.db) {
+      try {
+        this.db.close();
+      } catch (closeErr) {
+        void closeErr;
+      }
+      this.db = null;
+    }
+  }
+
+  auditToSarif() {
+    const history = this.getHistory();
+    const reviewFailures = history.filter(h => h.eventType === EVENT_TYPES.EVENT_REVIEW_FAILED);
+    const findings = [];
+
+    if (reviewFailures.length > 0) {
+      findings.push({
+        ruleId: 'RULE-BUS-001',
+        name: 'ReviewFailureEventsDetected',
+        severity: 'WARNING',
+        message: `Detectados ${reviewFailures.length} eventos de falha de revisão adversária no barramento.`,
+        remediation: 'Investigue os bloqueios do AGENT_QA e aplique autocura adaptativa.'
+      });
+    }
+
+    return createSarifReport({
+      toolName: 'agent-master-orchestrator',
+      rules: [
+        {
+          id: 'RULE-BUS-001',
+          name: 'ReviewFailureEventsDetected',
+          description: 'Identifica eventos de falha de revisão nos handovers entre agentes',
+          severity: 'HIGH',
+          cwe: 'CWE-400'
+        }
+      ],
+      findings,
+      properties: {
+        totalEvents: history.length,
+        reviewFailuresCount: reviewFailures.length,
+        storageEngine: this.db ? 'SQLite WAL' : 'In-Memory'
+      }
+    });
+  }
+
+  formatReport() {
+    const h = this.getHistory();
+    return [
+      '### Relatório do Barramento de Eventos Multi-Agente',
+      `- **Total de Eventos:** ${h.length}`,
+      `- **Engine de Armazenamento:** ${this.db ? 'SQLite WAL' : 'In-Memory'}`,
+      `- **Personas Homologadas:** ${Object.values(AGENT_PERSONAS).join(', ')}`
+    ].join('\n');
+  }
+}
+
+module.exports = {
+  MultiAgentOrchestrator,
+  AGENT_PERSONAS,
+  EVENT_TYPES
+};