agent-master-devsecops 3.9.0 → 5.1.0

package/scripts/mcp/handlers/atlassian_handlers.js

@@ -0,0 +1,300 @@
+/**
+ * scripts/mcp/handlers/atlassian_handlers.js
+ * 
+ * Atlassian, Jira & Confluence MCP Handlers.
+ * Despacha chamadas JSON-RPC 2.0 para Sincronização Jira/Confluence, Remote Links,
+ * Diagnóstico de Credenciais (Regra 15) e Governança de Fluxo Kanban.
+ * 
+ * Versão: 5.1.0 Enterprise
+ */
+
+'use strict';
+
+const { ROOT_DIR } = require('../resources_registry.js');
+
+/**
+ * Helpers funcionais puros para construção determinística de respostas JSON-RPC 2.0 (DRY)
+ */
+function buildSuccessResponse(id, data) {
+  const textContent = typeof data === 'string' ? data : JSON.stringify(data, null, 2);
+  return {
+    jsonrpc: '2.0',
+    id,
+    result: {
+      content: [
+        {
+          type: 'text',
+          text: textContent
+        }
+      ]
+    }
+  };
+}
+
+function buildErrorResponse(id, code, message, data = null) {
+  const errObj = { code, message };
+  if (data) errObj.data = data;
+  return {
+    jsonrpc: '2.0',
+    id,
+    error: errObj
+  };
+}
+
+/**
+ * Handler para sincronização de Remote Links e páginas do Confluence (agent_sync_atlassian).
+ */
+function handleSyncAtlassian(id, args) {
+  const safeArgs = args && typeof args === 'object' ? args : {};
+  const {
+    extractIssueKeys,
+    formatRemoteLinkPayload,
+    getAuth,
+    auditSyncToSarif,
+    formatReport
+  } = require('../../integrations/atlassian_sync_action.js');
+
+  try {
+    const { issueKey, url, title, type, format } = safeArgs;
+    const authConfigured = Boolean(getAuth());
+    const payload = formatRemoteLinkPayload(url, title, type || 'commit');
+
+    if (format === 'sarif') {
+      const sarif = auditSyncToSarif({
+        keys: issueKey ? [issueKey] : [],
+        results: url ? [{ key: issueKey || 'UNKNOWN', type: type || 'commit', ref: url, status: 'SUCCESS' }] : []
+      });
+      return buildSuccessResponse(id, sarif);
+    }
+
+    if (format === 'markdown' && typeof formatReport === 'function') {
+      const report = formatReport({
+        keys: issueKey ? [issueKey] : [],
+        results: url ? [{ key: issueKey || 'UNKNOWN', type: type || 'commit', ref: url, status: 'SUCCESS' }] : []
+      });
+      return buildSuccessResponse(id, report);
+    }
+
+    return buildSuccessResponse(id, {
+      status: authConfigured ? 'READY_TO_SYNC' : 'SKIPPED_NO_AUTH',
+      issueKey: issueKey || null,
+      authConfigured,
+      remoteLinkPayload: payload
+    });
+  } catch (err) {
+    return buildErrorResponse(id, -32603, `Falha na sincronização Atlassian: ${err.message}`);
+  }
+}
+
+/**
+ * Handler para auditoria e healthcheck de credenciais Atlassian e GitHub (agent_check_credentials).
+ */
+function handleCheckCredentials(id, args) {
+  const safeArgs = args && typeof args === 'object' ? args : {};
+  const targetDir = safeArgs.targetDir || ROOT_DIR;
+  const format = safeArgs.format || 'json';
+
+  try {
+    const {
+      runCredentialHealthcheck,
+      formatReport,
+      auditToSarif
+    } = require('../../integrations/credentials_guard.js');
+
+    const check = runCredentialHealthcheck(targetDir);
+
+    if (format === 'sarif') {
+      const { auditToSarif: auditAtlassianClient } = require('../../integrations/atlassian_client.js');
+      const sarif = auditAtlassianClient(targetDir);
+      return buildSuccessResponse(id, sarif);
+    }
+
+    if (format === 'markdown') {
+      const report = formatReport(check);
+      return buildSuccessResponse(id, report);
+    }
+
+    return buildSuccessResponse(id, check);
+  } catch (err) {
+    return buildErrorResponse(id, -32603, `Falha ao auditar credenciais: ${err.message}`);
+  }
+}
+
+/**
+ * Handler para configuração segura de credenciais no arquivo .env local (agent_configure_credentials).
+ */
+function handleConfigureCredentials(id, args) {
+  const safeArgs = args && typeof args === 'object' ? args : {};
+  const { configureCredentials, auditToSarif } = require('../../integrations/credentials_guard.js');
+  const targetDir = safeArgs.targetDir || ROOT_DIR;
+  const { domain, email, token, jiraKey, confluenceSpace, format } = safeArgs;
+
+  if (!domain || !email || !token) {
+    return buildErrorResponse(
+      id,
+      -32602,
+      'Parâmetros obrigatórios ausentes: domain, email e token são requeridos.'
+    );
+  }
+
+  try {
+    const result = configureCredentials(targetDir, { domain, email, token, jiraKey, confluenceSpace });
+
+    if (format === 'sarif') {
+      const sarif = auditToSarif({ allReady: result.success, envProtected: true });
+      return buildSuccessResponse(id, sarif);
+    }
+
+    return buildSuccessResponse(id, result);
+  } catch (err) {
+    return buildErrorResponse(id, -32603, `Falha ao configurar credenciais: ${err.message}`);
+  }
+}
+
+/**
+ * Handler para padronização de quadros Kanban e JQLs canônicos (agent_standardize_kanban).
+ */
+function handleStandardizeKanban(id, args) {
+  const safeArgs = args && typeof args === 'object' ? args : {};
+  const {
+    CANONICAL_COLUMNS_LIST,
+    standardizeBoardColumns,
+    buildCanonicalJql,
+    auditToSarif
+  } = require('../../integrations/jira_manager.js');
+
+  const projectKey = safeArgs.projectKey || 'AGDEV';
+  const boardConfig = safeArgs.boardConfig;
+  const format = safeArgs.format || 'json';
+
+  try {
+    const jqls = {
+      todo: buildCanonicalJql(projectKey, 'A fazer'),
+      inProgress: buildCanonicalJql(projectKey, 'Em andamento'),
+      done: buildCanonicalJql(projectKey, 'Concluído')
+    };
+
+    const boardStandardization = boardConfig ? standardizeBoardColumns(boardConfig) : null;
+
+    if (format === 'sarif') {
+      const sarif = auditToSarif({ wipStatus: { isSaturated: false } });
+      return buildSuccessResponse(id, sarif);
+    }
+
+    return buildSuccessResponse(id, {
+      status: 'SUCCESS',
+      projectKey,
+      canonicalColumns: CANONICAL_COLUMNS_LIST,
+      standardQueries: jqls,
+      boardStandardization
+    });
+  } catch (err) {
+    return buildErrorResponse(id, -32603, `Falha ao padronizar Kanban: ${err.message}`);
+  }
+}
+
+/**
+ * Handler para o Modo Full Developer Pipeline com filtro de sanidade (agent_full_dev_pipeline).
+ */
+function handleFullDevPipeline(id, args) {
+  const safeArgs = args && typeof args === 'object' ? args : {};
+  const {
+    processFullDevPipeline,
+    auditToSarif,
+    formatReport
+  } = require('../../integrations/jira_manager.js');
+
+  const tasks = Array.isArray(safeArgs.tasks) ? safeArgs.tasks : [];
+  const projectContext = safeArgs.projectContext && typeof safeArgs.projectContext === 'object'
+    ? safeArgs.projectContext
+    : {};
+  const maxWip = safeArgs.maxWip || 2;
+  const format = safeArgs.format || 'json';
+
+  try {
+    const pipelineResult = processFullDevPipeline(tasks, projectContext, maxWip);
+
+    if (format === 'sarif') {
+      const sarif = auditToSarif(pipelineResult);
+      return buildSuccessResponse(id, sarif);
+    }
+
+    if (format === 'markdown') {
+      const report = formatReport(pipelineResult);
+      return buildSuccessResponse(id, report);
+    }
+
+    return buildSuccessResponse(id, pipelineResult);
+  } catch (err) {
+    return buildErrorResponse(id, -32603, `Falha no pipeline Full Dev: ${err.message}`);
+  }
+}
+
+/**
+ * Classe Canônica AtlassianHandlers
+ */
+class AtlassianHandlers {
+  constructor(options = {}) {
+    this.rootDir = options.rootDir || ROOT_DIR;
+    this.logger = options.logger || console;
+  }
+
+  handleSyncAtlassian(id, args) {
+    return AtlassianHandlers.handleSyncAtlassian(id, args);
+  }
+
+  handleCheckCredentials(id, args) {
+    return AtlassianHandlers.handleCheckCredentials(id, args);
+  }
+
+  handleConfigureCredentials(id, args) {
+    return AtlassianHandlers.handleConfigureCredentials(id, args);
+  }
+
+  handleStandardizeKanban(id, args) {
+    return AtlassianHandlers.handleStandardizeKanban(id, args);
+  }
+
+  handleFullDevPipeline(id, args) {
+    return AtlassianHandlers.handleFullDevPipeline(id, args);
+  }
+
+  static handleSyncAtlassian(id, args) {
+    return handleSyncAtlassian(id, args);
+  }
+
+  static handleCheckCredentials(id, args) {
+    return handleCheckCredentials(id, args);
+  }
+
+  static handleConfigureCredentials(id, args) {
+    return handleConfigureCredentials(id, args);
+  }
+
+  static handleStandardizeKanban(id, args) {
+    return handleStandardizeKanban(id, args);
+  }
+
+  static handleFullDevPipeline(id, args) {
+    return handleFullDevPipeline(id, args);
+  }
+
+  static buildSuccessResponse(id, data) {
+    return buildSuccessResponse(id, data);
+  }
+
+  static buildErrorResponse(id, code, msg, data) {
+    return buildErrorResponse(id, code, msg, data);
+  }
+}
+
+module.exports = {
+  AtlassianHandlers,
+  buildSuccessResponse,
+  buildErrorResponse,
+  handleSyncAtlassian,
+  handleCheckCredentials,
+  handleConfigureCredentials,
+  handleStandardizeKanban,
+  handleFullDevPipeline
+};

package/scripts/mcp/handlers/core_handlers.js

@@ -0,0 +1,419 @@
+/**
+ * scripts/mcp/handlers/core_handlers.js
+ * 
+ * Core & Governance MCP Handlers.
+ * Despacha chamadas JSON-RPC 2.0 para status do Full Dev, eventos multi-agente,
+ * gates de governança da Tríade (Regra 16), mineração de ideias de domínio,
+ * consultoria arquitetural (Princípio 7) e Dynamic Knowledge Gateway (ADR-008).
+ * 
+ * Versão: 5.1.0 Enterprise
+ */
+
+'use strict';
+
+const fs = require('node:fs');
+const path = require('node:path');
+const { ROOT_DIR } = require('../resources_registry.js');
+const { setMcpProfile } = require('../tools_registry.js');
+const { createSarifReport } = require('../../core/sarif_engine.js');
+
+let _orchestratorInstance = null;
+function getOrchestrator() {
+  if (!_orchestratorInstance) {
+    const { MultiAgentOrchestrator } = require('../../core/multi_agent_orchestrator.js');
+    _orchestratorInstance = new MultiAgentOrchestrator();
+  }
+  return _orchestratorInstance;
+}
+
+/**
+ * Helpers funcionais puros para construção determinística de respostas JSON-RPC 2.0 (DRY)
+ */
+function buildSuccessResponse(id, data) {
+  const textContent = typeof data === 'string' ? data : JSON.stringify(data, null, 2);
+  return {
+    jsonrpc: '2.0',
+    id,
+    result: {
+      content: [
+        {
+          type: 'text',
+          text: textContent
+        }
+      ]
+    }
+  };
+}
+
+function buildErrorResponse(id, code, message, data = null) {
+  const errObj = { code, message };
+  if (data) errObj.data = data;
+  return {
+    jsonrpc: '2.0',
+    id,
+    error: errObj
+  };
+}
+
+/**
+ * Helper puro para extração da próxima ideia pendente do IDEAS.md
+ * @param {string} ideasContent
+ * @returns {string}
+ */
+function extractNextIdea(ideasContent = '') {
+  if (!ideasContent || typeof ideasContent !== 'string') {
+    return 'Nenhuma ideia pendente no backlog aberto.';
+  }
+
+  const lines = ideasContent.split(/\r?\n/);
+  for (const line of lines) {
+    const trimmed = line.trim();
+    if (/^- I-\d+/i.test(trimmed)) {
+      if (!/\[(CONCLUÍDO|EM PRODUÇÃO|DONE|DROP|REJEITAD[OA]|ARCHIVED)\]/i.test(trimmed)) {
+        return trimmed.replace(/^- /, '');
+      }
+    }
+  }
+
+  return 'Nenhuma ideia pendente no backlog aberto.';
+}
+
+/**
+ * Handler para verificação de status do Modo Full Dev (agent_full_dev_status).
+ */
+function handleFullDevStatus(id, args) {
+  const safeArgs = args && typeof args === 'object' ? args : {};
+  const rootDir = safeArgs.rootDir || ROOT_DIR;
+  const ideasPath = path.join(rootDir, 'docs', 'IDEAS.md');
+
+  let ideasContent = '';
+  if (fs.existsSync(ideasPath)) {
+    try {
+      ideasContent = fs.readFileSync(ideasPath, 'utf8');
+    } catch {
+      // tolerância defensiva
+    }
+  }
+
+  const nextIdea = extractNextIdea(ideasContent);
+  const statusPayload = {
+    modo: 'full-dev',
+    status: 'ATIVO',
+    proximaIdeia: nextIdea,
+    regrasAtivas: 27,
+    principiosCanonicos: 10,
+    versao: '5.1.0',
+    governance: 'Tríplice Registro Obrigatório (Git, Jira, Confluence)'
+  };
+
+  if (safeArgs.format === 'sarif') {
+    const rules = [
+      {
+        id: 'RULE-DEV-001',
+        name: 'FullDevStatusCheck',
+        severity: 'NOTE',
+        message: 'Status operacional do modo Full Dev inspecionado com sucesso.'
+      }
+    ];
+    const sarif = createSarifReport({
+      toolName: 'agent-master-full-dev',
+      toolVersion: '5.1.0',
+      rules,
+      findings: [
+        {
+          ruleId: 'RULE-DEV-001',
+          message: `Modo Full Dev ${statusPayload.status}. Próxima ideia: ${statusPayload.proximaIdeia}`,
+          filePath: 'docs/IDEAS.md',
+          line: 1,
+          column: 1
+        }
+      ]
+    });
+    return buildSuccessResponse(id, sarif);
+  }
+
+  return buildSuccessResponse(id, statusPayload);
+}
+
+/**
+ * Handler para despacho de eventos pelo barramento multi-agente (agent_orchestrate_event).
+ */
+function handleOrchestrateEvent(id, args) {
+  const safeArgs = args && typeof args === 'object' ? args : {};
+  const eventType = safeArgs.eventType;
+  const payload = safeArgs.payload || {};
+
+  if (!eventType) {
+    return buildErrorResponse(id, -32602, 'Parâmetro obrigatório ausente: eventType é requerido.');
+  }
+
+  try {
+    const orchestrator = getOrchestrator();
+    const eventRecord = orchestrator.dispatch(eventType, payload);
+    return buildSuccessResponse(id, {
+      status: 'SUCCESS',
+      eventRecord
+    });
+  } catch (err) {
+    return buildErrorResponse(id, -32603, `Falha ao despachar evento: ${err.message}`);
+  }
+}
+
+/**
+ * Handler para telemetria e metadados do Web Dashboard Inspector (agent_inspector_info).
+ */
+function handleInspectorInfo(id, args) {
+  const safeArgs = args && typeof args === 'object' ? args : {};
+  const { getTelemetry, auditTelemetryToSarif } = require('../../bin/web_inspector.js');
+  const port = Number(safeArgs.port) || 4040;
+  const format = safeArgs.format ? String(safeArgs.format).toLowerCase() : 'json';
+
+  try {
+    if (format === 'sarif') {
+      const sarif = auditTelemetryToSarif();
+      return buildSuccessResponse(id, sarif);
+    }
+
+    return buildSuccessResponse(id, {
+      status: 'READY',
+      dashboardUrl: `http://localhost:${port}`,
+      endpoints: {
+        dashboard: '/',
+        status: '/api/status',
+        mcpProxy: '/api/mcp',
+        evalHarness: '/api/eval',
+        magicPrompt: '/api/magic-prompt'
+      },
+      telemetry: getTelemetry()
+    });
+  } catch (err) {
+    return buildErrorResponse(id, -32603, `Falha ao obter telemetria do Inspector: ${err.message}`);
+  }
+}
+
+/**
+ * Handler para diagnóstico bimodal de onboarding e stack (agent_smart_onboarding).
+ */
+function handleSmartOnboarding(id, args) {
+  const safeArgs = args && typeof args === 'object' ? args : {};
+  const { detectProjectMode, inspectProjectContext } = require('../../bin/smart_onboarding.js');
+  const targetDir = safeArgs.targetDir || process.cwd();
+
+  try {
+    const mode = detectProjectMode(targetDir);
+    const context = inspectProjectContext(targetDir);
+    return buildSuccessResponse(id, { mode, context });
+  } catch (err) {
+    return buildErrorResponse(id, -32603, `Falha ao executar Smart Onboarding: ${err.message}`);
+  }
+}
+
+/**
+ * Handler para fiscalização do Gate da Tríade - Regra 16 (agent_verify_triad_gate).
+ */
+function handleVerifyTriadGate(id, args) {
+  const safeArgs = args && typeof args === 'object' ? args : {};
+  const { verifyTriadGateSync, auditTriadToSarif } = require('../../bin/smart_onboarding.js');
+  const targetDir = safeArgs.targetDir || process.cwd();
+  const format = safeArgs.format ? String(safeArgs.format).toLowerCase() : 'json';
+
+  try {
+    if (format === 'sarif') {
+      const sarif = auditTriadToSarif(targetDir, safeArgs);
+      return buildSuccessResponse(id, sarif);
+    }
+
+    let gateResult;
+    try {
+      gateResult = verifyTriadGateSync(targetDir, safeArgs);
+    } catch (err) {
+      gateResult = {
+        canDevelop: false,
+        verdict: 'BLOQUEADO_REGRA_16',
+        gateMessage: `⛔ Erro ao verificar Gate da Tríade: ${err.message}`,
+        blockers: [err.message]
+      };
+    }
+
+    return buildSuccessResponse(id, gateResult);
+  } catch (err) {
+    return buildErrorResponse(id, -32603, `Falha ao verificar Gate da Tríade: ${err.message}`);
+  }
+}
+
+/**
+ * Handler para alternância dinâmica de perfis MCP (agent_set_mcp_profile).
+ */
+function handleSetMcpProfile(id, args) {
+  const safeArgs = args && typeof args === 'object' ? args : {};
+  const target = safeArgs.profile || 'all';
+
+  try {
+    const res = setMcpProfile(target);
+    return buildSuccessResponse(id, res);
+  } catch (err) {
+    return buildErrorResponse(id, -32603, `Falha ao alternar perfil MCP: ${err.message}`);
+  }
+}
+
+/**
+ * Handler para mineração de oportunidades e ideação de domínio (agent_mine_domain_ideas).
+ */
+function handleMineDomainIdeas(id, args) {
+  const safeArgs = args && typeof args === 'object' ? args : {};
+  const { mineDomainIdeas, DomainIdeaMiner } = require('../../bin/domain_idea_miner.js');
+  const targetDir = safeArgs.targetDir ? path.resolve(safeArgs.targetDir) : process.cwd();
+  const autoApply = safeArgs.autoApply === true;
+  const dryRun = safeArgs.dryRun === true;
+  const format = safeArgs.format ? String(safeArgs.format).toLowerCase() : 'json';
+
+  try {
+    if (format === 'sarif') {
+      const miner = new DomainIdeaMiner({ rootDir: targetDir });
+      const sarif = miner.mineToSarif(targetDir);
+      return buildSuccessResponse(id, sarif);
+    }
+
+    const report = mineDomainIdeas(targetDir, {
+      autoApply,
+      dryRun,
+      ideasFilePath: path.join(targetDir, 'docs', 'IDEAS.md')
+    });
+
+    return buildSuccessResponse(id, {
+      status: 'SUCCESS',
+      targetDir,
+      scannedFilesCount: report.scannedFilesCount,
+      opportunitiesFound: report.opportunitiesFound,
+      opportunities: report.opportunities,
+      syncResult: report.syncResult
+    });
+  } catch (err) {
+    return buildErrorResponse(id, -32603, `Falha ao minerar ideias de domínio: ${err.message}`);
+  }
+}
+
+/**
+ * Handler para consultoria e recomendação arquitetural - Princípio 7 (agent_recommend_architecture).
+ */
+function handleRecommendArchitecture(id, args) {
+  const safeArgs = args && typeof args === 'object' ? args : {};
+  const { recommendArchitecture } = require('../../core/architecture_advisor.js');
+
+  try {
+    const report = recommendArchitecture(safeArgs);
+    return buildSuccessResponse(id, report.reportMarkdown);
+  } catch (err) {
+    return buildErrorResponse(id, -32603, `Falha ao gerar recomendação arquitetural: ${err.message}`);
+  }
+}
+
+/**
+ * Handler para consulta ao Dynamic Knowledge Gateway - ADR-008 (agent_ground_knowledge).
+ */
+async function handleGroundKnowledge(id, args) {
+  const safeArgs = args && typeof args === 'object' ? args : {};
+  const { getKnowledgeGateway } = require('../../core/knowledge_gateway.js');
+  const gateway = getKnowledgeGateway();
+  const action = safeArgs.action || 'lookup_doc';
+
+  try {
+    let resultPayload = null;
+
+    if (action === 'query_osv') {
+      resultPayload = await gateway.queryOsv(safeArgs.package || safeArgs.name, safeArgs.version, safeArgs.ecosystem || 'npm');
+    } else if (action === 'get_wcag_spec') {
+      resultPayload = gateway.getWcagSpec(safeArgs.criterion || safeArgs.ruleId);
+    } else if (action === 'get_spring_blueprint') {
+      resultPayload = await gateway.getSpringBlueprint(safeArgs);
+    } else if (action === 'get_runtime_lts') {
+      resultPayload = await gateway.getRuntimeLts(safeArgs.tech || safeArgs.stack);
+    } else if (action === 'get_cache_stats') {
+      resultPayload = gateway.getCacheStats();
+    } else if (action === 'clear_cache') {
+      resultPayload = gateway.clearCache();
+    } else {
+      resultPayload = gateway.lookupDoc(safeArgs.tech || safeArgs.stack || 'general', safeArgs.topic || 'architecture');
+    }
+
+    return buildSuccessResponse(id, resultPayload);
+  } catch (err) {
+    return buildErrorResponse(id, -32603, `Falha ao consultar Knowledge Gateway: ${err.message}`);
+  }
+}
+
+/**
+ * Classe Canônica CoreHandlers
+ */
+class CoreHandlers {
+  constructor(options = {}) {
+    this.rootDir = options.rootDir || ROOT_DIR;
+    this.logger = options.logger || console;
+  }
+
+  handleFullDevStatus(id, args) {
+    return CoreHandlers.handleFullDevStatus(id, args);
+  }
+
+  handleOrchestrateEvent(id, args) {
+    return CoreHandlers.handleOrchestrateEvent(id, args);
+  }
+
+  handleInspectorInfo(id, args) {
+    return CoreHandlers.handleInspectorInfo(id, args);
+  }
+
+  handleSmartOnboarding(id, args) {
+    return CoreHandlers.handleSmartOnboarding(id, args);
+  }
+
+  handleVerifyTriadGate(id, args) {
+    return CoreHandlers.handleVerifyTriadGate(id, args);
+  }
+
+  handleSetMcpProfile(id, args) {
+    return CoreHandlers.handleSetMcpProfile(id, args);
+  }
+
+  handleMineDomainIdeas(id, args) {
+    return CoreHandlers.handleMineDomainIdeas(id, args);
+  }
+
+  handleRecommendArchitecture(id, args) {
+    return CoreHandlers.handleRecommendArchitecture(id, args);
+  }
+
+  async handleGroundKnowledge(id, args) {
+    return CoreHandlers.handleGroundKnowledge(id, args);
+  }
+
+  // Métodos estáticos canônicos
+  static buildSuccessResponse(id, data) { return buildSuccessResponse(id, data); }
+  static buildErrorResponse(id, code, msg, data) { return buildErrorResponse(id, code, msg, data); }
+  static extractNextIdea(content) { return extractNextIdea(content); }
+  static handleFullDevStatus(id, args) { return handleFullDevStatus(id, args); }
+  static handleOrchestrateEvent(id, args) { return handleOrchestrateEvent(id, args); }
+  static handleInspectorInfo(id, args) { return handleInspectorInfo(id, args); }
+  static handleSmartOnboarding(id, args) { return handleSmartOnboarding(id, args); }
+  static handleVerifyTriadGate(id, args) { return handleVerifyTriadGate(id, args); }
+  static handleSetMcpProfile(id, args) { return handleSetMcpProfile(id, args); }
+  static handleMineDomainIdeas(id, args) { return handleMineDomainIdeas(id, args); }
+  static handleRecommendArchitecture(id, args) { return handleRecommendArchitecture(id, args); }
+  static handleGroundKnowledge(id, args) { return handleGroundKnowledge(id, args); }
+}
+
+module.exports = {
+  CoreHandlers,
+  buildSuccessResponse,
+  buildErrorResponse,
+  extractNextIdea,
+  handleFullDevStatus,
+  handleOrchestrateEvent,
+  handleInspectorInfo,
+  handleSmartOnboarding,
+  handleVerifyTriadGate,
+  handleSetMcpProfile,
+  handleMineDomainIdeas,
+  handleRecommendArchitecture,
+  handleGroundKnowledge
+};