eva4j 1.0.14 → 1.0.16

package/src/utils/system-validator.js

@@ -1,14 +1,16 @@
 'use strict';
 
 /**
- * Validates a parsed system.yaml object against 5 architectural checks.
+ * Validates a parsed system.yaml object against the S1–S5 static evaluation rules.
  *
  * @param {object} systemConfig - Parsed system.yaml content
- * @returns {{ errors: string[], warnings: string[], ok: string[], score: number }}
+ * @param {Record<string, object>} [domainConfigs={}] - moduleName → parsed domain YAML (used to check domain-level events)
+ * @returns {{ errors: string[], warnings: string[], info: string[], ok: string[], score: number }}
  */
-function validateSystem(systemConfig) {
+function validateSystem(systemConfig, domainConfigs = {}) {
   const errors = [];
   const warnings = [];
+  const info = [];
   const ok = [];
 
   const modules = systemConfig.modules || [];
@@ -16,93 +18,206 @@ function validateSystem(systemConfig) {
   const integrations = systemConfig.integrations || {};
   const asyncEvents = integrations.async || [];
   const syncIntegrations = integrations.sync || [];
+  const messaging = systemConfig.messaging || {};
+  const topicPrefix = (messaging.kafka || {}).topicPrefix || null;
 
-  // Build a quick lookup: module name → exposes array of "METHOD /path" strings
-  const moduleExposes = {};
+  // Helper: normalize a consumer entry to its module name string
+  const consumerModule = (c) => (typeof c === 'string' ? c : c.module);
+
+  // ── S1 — Integridad de módulos ────────────────────────────────────────────
+
+  // Collect all module names referenced in integrations
+  const referencedInIntegrations = new Set();
+  for (const ev of asyncEvents) {
+    if (ev.producer) referencedInIntegrations.add(ev.producer);
+    for (const c of ev.consumers || []) referencedInIntegrations.add(consumerModule(c));
+  }
+  for (const sync of syncIntegrations) {
+    if (sync.caller) referencedInIntegrations.add(sync.caller);
+    if (sync.calls) referencedInIntegrations.add(sync.calls);
+  }
+
+  // S1-001: module referenced but not declared
+  let s1_001_found = false;
+  for (const ref of referencedInIntegrations) {
+    if (!moduleNames.has(ref)) {
+      errors.push(`[S1-001] Módulo '${ref}' referenciado en integrations pero no declarado en modules[]`);
+      s1_001_found = true;
+    }
+  }
+  if (!s1_001_found) {
+    ok.push('[S1-001] Todos los módulos referenciados en integrations están declarados en modules[] ✓');
+  }
+
+  // S1-002: module with no responsibilities
+  let s1_002_found = false;
   for (const mod of modules) {
-    moduleExposes[mod.name] = (mod.exposes || []).map(
-      (ep) => `${ep.method} ${ep.path}`
+    const hasExposes = (mod.exposes || []).length > 0;
+    const producesEvents = asyncEvents.some((e) => e.producer === mod.name);
+    const consumesEvents = asyncEvents.some((e) =>
+      (e.consumers || []).some((c) => consumerModule(c) === mod.name)
     );
+    if (!hasExposes && !producesEvents && !consumesEvents) {
+      errors.push(`[S1-002] Módulo '${mod.name}' no tiene ninguna responsabilidad — no expone endpoints, no produce ni consume eventos`);
+      s1_002_found = true;
+    }
+  }
+  if (!s1_002_found) {
+    ok.push('[S1-002] Todos los módulos tienen al menos una responsabilidad declarada ✓');
+  }
+
+  // S1-003: module without description
+  let s1_003_found = false;
+  for (const mod of modules) {
+    if (!mod.description || mod.description.trim() === '') {
+      warnings.push(`[S1-003] Módulo '${mod.name}' no tiene campo description declarado`);
+      s1_003_found = true;
+    }
+  }
+  if (!s1_003_found) {
+    ok.push('[S1-003] Todos los módulos tienen description declarado ✓');
   }
 
-  // ── Check 1: Referential Integrity ────────────────────────────────────────
+  // S1-004: purely reactive module not documented
+  for (const mod of modules) {
+    const producesEvents = asyncEvents.some((e) => e.producer === mod.name);
+    const consumesEvents = asyncEvents.some((e) =>
+      (e.consumers || []).some((c) => consumerModule(c) === mod.name)
+    );
+    const makesSyncCalls = syncIntegrations.some((s) => s.caller === mod.name);
+    const hasExposes = (mod.exposes || []).length > 0;
 
-  // 1a. Event producers
+    const isPurelyReactive = consumesEvents && !producesEvents && !makesSyncCalls && !hasExposes;
+    if (isPurelyReactive) {
+      const desc = (mod.description || '').toLowerCase();
+      const documentedAsReactive = desc.includes('consume') || desc.includes('reactiv') || desc.includes('event') || desc.includes('suscri') || desc.includes('listen');
+      if (!documentedAsReactive) {
+        info.push(`[S1-004] Módulo '${mod.name}' es puramente reactivo (solo consume eventos) pero su description no lo documenta explícitamente`);
+      }
+    }
+  }
+
+  // ── S2 — Integridad del grafo de eventos async ────────────────────────────
+
+  // S2-001: event with no consumers
+  let s2_001_found = false;
   for (const ev of asyncEvents) {
-    if (!moduleNames.has(ev.producer)) {
-      errors.push(
-        `Integridad referencial: el productor '${ev.producer}' del evento '${ev.event}' no está declarado en modules[]`
-      );
+    const consumers = ev.consumers || [];
+    if (consumers.length === 0) {
+      errors.push(`[S2-001] Evento '${ev.event}' declarado en integrations.async sin consumidores`);
+      s2_001_found = true;
+    }
+  }
+  if (!s2_001_found && asyncEvents.length > 0) {
+    ok.push('[S2-001] Todos los eventos async tienen al menos un consumidor declarado ✓');
+  }
+
+  // S2-002: duplicate topic values
+  const topicToEvent = {};
+  let s2_002_found = false;
+  for (const ev of asyncEvents) {
+    if (!ev.topic) continue;
+    if (topicToEvent[ev.topic]) {
+      errors.push(`[S2-002] Topic '${ev.topic}' está declarado para dos eventos distintos: '${topicToEvent[ev.topic]}' y '${ev.event}'`);
+      s2_002_found = true;
     } else {
-      ok.push(`Productor '${ev.producer}' del evento '${ev.event}' existe ✓`);
+      topicToEvent[ev.topic] = ev.event;
     }
   }
+  if (!s2_002_found && asyncEvents.length > 0) {
+    ok.push('[S2-002] No hay colisiones de topics en integrations.async ✓');
+  }
 
-  // 1b. Event consumers
+  // S2-003: self-loop (module consuming its own event)
+  let s2_003_found = false;
   for (const ev of asyncEvents) {
-    const consumers = ev.consumers || [];
-    for (const c of consumers) {
-      const moduleName = typeof c === 'string' ? c : c.module;
-      if (!moduleNames.has(moduleName)) {
-        errors.push(
-          `Integridad referencial: el consumidor '${moduleName}' del evento '${ev.event}' no está declarado en modules[]`
-        );
+    for (const c of ev.consumers || []) {
+      if (consumerModule(c) === ev.producer) {
+        errors.push(`[S2-003] Módulo '${ev.producer}' está listado como consumidor de su propio evento '${ev.event}' (self-loop)`);
+        s2_003_found = true;
       }
     }
   }
-  if (asyncEvents.every((ev) => (ev.consumers || []).every((c) => moduleNames.has(typeof c === 'string' ? c : c.module)))) {
-    ok.push('Todos los consumidores de eventos están declarados como módulos ✓');
+  if (!s2_003_found && asyncEvents.length > 0) {
+    ok.push('[S2-003] No se detectaron self-loops en el grafo de eventos ✓');
   }
 
-  // 1c. Sync integration caller/callee existence
-  for (const sync of syncIntegrations) {
-    if (!moduleNames.has(sync.caller)) {
-      errors.push(
-        `Integridad referencial: el caller '${sync.caller}' de la integración síncrona no está declarado en modules[]`
-      );
+  // S2-004: module produces but never consumes
+  const producerSet = new Set(asyncEvents.map((e) => e.producer).filter(Boolean));
+  const consumerSet = new Set(
+    asyncEvents.flatMap((e) => (e.consumers || []).map(consumerModule))
+  );
+  for (const mod of modules) {
+    if (producerSet.has(mod.name) && !consumerSet.has(mod.name)) {
+      warnings.push(`[S2-004] Módulo '${mod.name}' produce eventos pero no consume ninguno`);
     }
-    if (!moduleNames.has(sync.calls)) {
-      errors.push(
-        `Integridad referencial: el callee '${sync.calls}' de la integración síncrona (caller: ${sync.caller}) no está declarado en modules[]`
+  }
+
+  // S2-005: module consumes but never produces
+  // Also check domain-level events[] — a module may produce Domain Events not yet
+  // wired in system.yaml integrations.async[], which is a valid design-in-progress.
+  for (const mod of modules) {
+    if (consumerSet.has(mod.name) && !producerSet.has(mod.name)) {
+      const domainCfg = domainConfigs[mod.name];
+      const producesDomainEvents = (domainCfg?.aggregates || []).some(
+        (agg) => (agg.events || []).length > 0
       );
+      if (!producesDomainEvents) {
+        warnings.push(`[S2-005] Módulo '${mod.name}' consume eventos pero no produce ninguno`);
+      }
     }
   }
 
-  // 1d. Sync endpoints exist in target module's exposes
-  let allSyncEndpointsFound = true;
-  for (const sync of syncIntegrations) {
-    if (!moduleNames.has(sync.calls)) continue; // already caught above
-    const targetExposes = moduleExposes[sync.calls] || [];
-    for (const endpoint of sync.using || []) {
-      const normalized = endpoint.trim().toUpperCase().replace(/\/+$/, '');
-      const found = targetExposes.some((ep) => {
-        const normalizedEp = ep.trim().toUpperCase().replace(/\/+$/, '');
-        return normalizedEp === normalized || endpointMatches(ep, endpoint);
-      });
-      if (!found) {
-        errors.push(
-          `Integridad referencial: el endpoint '${endpoint}' usado por '${sync.caller}' no está declarado en el exposes[] de '${sync.calls}'`
-        );
-        allSyncEndpointsFound = false;
-      }
+  // S2-006: event name not following PascalCase + Event suffix
+  const eventNameRegex = /^[A-Z][a-zA-Z0-9]*Event$/;
+  let s2_006_found = false;
+  for (const ev of asyncEvents) {
+    if (ev.event && !eventNameRegex.test(ev.event)) {
+      warnings.push(`[S2-006] Nombre de evento '${ev.event}' no sigue la convención PascalCase con sufijo 'Event'`);
+      s2_006_found = true;
     }
   }
-  if (allSyncEndpointsFound && syncIntegrations.length > 0) {
-    ok.push('Todos los endpoints usados en integraciones síncronas están declarados en los módulos destino ✓');
+  if (!s2_006_found && asyncEvents.length > 0) {
+    ok.push('[S2-006] Todos los nombres de eventos siguen la convención PascalCase + sufijo Event ✓');
   }
 
-  // ── Check 2: Cycle Detection (sync deps) ─────────────────────────────────
+  // ── S3 — Integridad de llamadas síncronas ────────────────────────────────
 
-  // Build directed graph: A → B when caller=A, calls=B
-  const syncGraph = {};
+  // S3-001: sync call to module with no exposes
+  let s3_001_found = false;
   for (const sync of syncIntegrations) {
-    if (!syncGraph[sync.caller]) syncGraph[sync.caller] = [];
-    syncGraph[sync.caller].push(sync.calls);
+    if (!moduleNames.has(sync.calls)) continue; // already caught by S1-001
+    const targetMod = modules.find((m) => m.name === sync.calls);
+    if (targetMod && (!targetMod.exposes || targetMod.exposes.length === 0)) {
+      errors.push(`[S3-001] '${sync.caller}' llama síncronamente a '${sync.calls}' pero este módulo no declara exposes[]`);
+      s3_001_found = true;
+    }
+  }
+  if (!s3_001_found && syncIntegrations.length > 0) {
+    ok.push('[S3-001] Todos los módulos destino de llamadas síncronas tienen endpoints expuestos ✓');
+  }
+
+  // S3-002: endpoint in using[] not found in target exposes[]
+  let s3_002_found = false;
+  for (const sync of syncIntegrations) {
+    if (!moduleNames.has(sync.calls)) continue;
+    const targetMod = modules.find((m) => m.name === sync.calls);
+    const targetExposes = (targetMod?.exposes || []).map((ep) => `${ep.method} ${ep.path}`);
+    for (const endpoint of sync.using || []) {
+      const found = targetExposes.some((ep) => endpointMatches(ep, endpoint));
+      if (!found) {
+        errors.push(`[S3-002] Endpoint '${endpoint}' usado por '${sync.caller}' no está declarado en exposes[] de '${sync.calls}'`);
+        s3_002_found = true;
+      }
+    }
+  }
+  if (!s3_002_found && syncIntegrations.length > 0) {
+    ok.push('[S3-002] Todos los endpoints referenciados en llamadas síncronas existen en el módulo destino ✓');
   }
 
-  // Detect strict bidirectional sync coupling (A→B and B→A)
+  // S3-003: bidirectional sync coupling (WARNING, not error)
   const biDirChecked = new Set();
-  let biDirFound = false;
+  let s3_003_found = false;
   for (const sync of syncIntegrations) {
     const key = [sync.caller, sync.calls].sort().join('↔');
     if (biDirChecked.has(key)) continue;
@@ -111,189 +226,194 @@ function validateSystem(systemConfig) {
       (s) => s.caller === sync.calls && s.calls === sync.caller
     );
     if (reverse) {
-      errors.push(
-        `Acoplamiento circular síncrono: '${sync.caller}' y '${sync.calls}' se llaman mutuamente de forma síncrona. Esto puede causar deadlocks.`
-      );
-      biDirFound = true;
+      warnings.push(`[S3-003] Acoplamiento síncrono bidireccional: '${sync.caller}' llama a '${sync.calls}' y viceversa`);
+      s3_003_found = true;
     }
   }
+  if (!s3_003_found && syncIntegrations.length > 0) {
+    ok.push('[S3-003] No se detectó acoplamiento síncrono bidireccional ✓');
+  }
 
-  // DFS for longer cycles
-  function detectCycle(startNode) {
-    const visited = new Set();
-    function dfs(node, path) {
-      if (path.includes(node)) return path.concat(node);
-      if (visited.has(node)) return null;
-      visited.add(node);
-      for (const neighbor of syncGraph[node] || []) {
-        const result = dfs(neighbor, path.concat(node));
-        if (result) return result;
-      }
-      return null;
+  // S3-004: module with more than 3 distinct outgoing sync dependencies
+  const outgoingSyncDeps = {};
+  for (const sync of syncIntegrations) {
+    if (!outgoingSyncDeps[sync.caller]) outgoingSyncDeps[sync.caller] = new Set();
+    outgoingSyncDeps[sync.caller].add(sync.calls);
+  }
+  for (const [caller, deps] of Object.entries(outgoingSyncDeps)) {
+    if (deps.size > 3) {
+      warnings.push(`[S3-004] Módulo '${caller}' tiene ${deps.size} dependencias síncronas salientes distintas (>${3}): ${[...deps].join(', ')}`);
     }
-    return dfs(startNode, []);
-  }
-
-  const cycleChecked = new Set();
-  let cycleFound = false;
-  for (const node of Object.keys(syncGraph)) {
-    if (cycleChecked.has(node)) continue;
-    const cycle = detectCycle(node);
-    if (cycle && cycle.length > 2) {
-      const cycleStr = cycle.join(' → ');
-      errors.push(`Ciclo síncrono detectado: ${cycleStr}`);
-      cycle.forEach((n) => cycleChecked.add(n));
-      cycleFound = true;
+  }
+
+  // S3-005: module consulted synchronously but emits no events
+  const syncCallees = new Set(syncIntegrations.map((s) => s.calls).filter(Boolean));
+  for (const callee of syncCallees) {
+    const producesAny = asyncEvents.some((e) => e.producer === callee);
+    if (!producesAny) {
+      info.push(`[S3-005] Módulo '${callee}' es consultado síncronamente pero no emite ningún evento cuando su estado cambia`);
     }
   }
 
-  if (!biDirFound && !cycleFound) {
-    ok.push('No se detectaron ciclos ni acoplamiento síncrono bidireccional ✓');
+  // S3-006: duplicate port name across different caller modules → ConflictingBeanDefinitionException
+  let s3_006_found = false;
+  const portsByName = {};
+  for (const sync of syncIntegrations) {
+    const portName = sync.port;
+    if (!portName) continue;
+    if (!portsByName[portName]) portsByName[portName] = [];
+    portsByName[portName].push(sync.caller);
+  }
+  for (const [portName, callers] of Object.entries(portsByName)) {
+    const uniqueCallers = [...new Set(callers)];
+    if (uniqueCallers.length > 1) {
+      const suggestions = uniqueCallers.map((c) => {
+        const prefix = c.replace(/-([a-z])/g, (_, l) => l.toUpperCase());
+        return `${prefix[0].toUpperCase() + prefix.slice(1)}${portName}`;
+      }).join(', ');
+      errors.push(
+        `[S3-006] Port '${portName}' es usado por módulos distintos (${uniqueCallers.join(', ')}). ` +
+        `Esto causa ConflictingBeanDefinitionException en Spring. ` +
+        `Cada módulo debe usar un nombre propio: ej. ${suggestions}`
+      );
+      s3_006_found = true;
+    }
+  }
+  if (!s3_006_found && syncIntegrations.length > 0) {
+    ok.push('[S3-006] No hay nombres de port duplicados entre módulos distintos ✓');
   }
 
-  // ── Check 3: Role Analysis ────────────────────────────────────────────────
+  // ── S4 — Coherencia de endpoints ─────────────────────────────────────────
 
   for (const mod of modules) {
-    const hasExposes = (mod.exposes || []).length > 0;
-    const producesEvents = asyncEvents.some((e) => e.producer === mod.name);
-    const consumesEvents = asyncEvents.some((e) =>
-      (e.consumers || []).some((c) => (typeof c === 'string' ? c : c.module) === mod.name)
-    );
-    const makesSyncCalls = syncIntegrations.some((s) => s.caller === mod.name);
-    const receivesSyncCalls = syncIntegrations.some((s) => s.calls === mod.name);
-
-    const hasAnyIntegration = producesEvents || consumesEvents || makesSyncCalls || receivesSyncCalls;
+    const exposes = mod.exposes || [];
+
+    // S4-001: duplicate METHOD + path within same module
+    const endpointKeys = new Set();
+    for (const ep of exposes) {
+      const key = `${(ep.method || '').toUpperCase()} ${ep.path || ''}`;
+      if (endpointKeys.has(key)) {
+        errors.push(`[S4-001] Módulo '${mod.name}' tiene dos endpoints con el mismo método y path: ${key}`);
+      } else {
+        endpointKeys.add(key);
+      }
+    }
 
-    if (!hasExposes && !hasAnyIntegration) {
-      warnings.push(
-        `Módulo aislado: '${mod.name}' no tiene endpoints expuestos ni integraciones declaradas`
-      );
-    } else if (!hasExposes) {
-      warnings.push(
-        `'${mod.name}' no tiene endpoints expuestos (exposes[] vacío o ausente)`
+    // S4-002: PUT /{id} without GET /{id} for same resource base
+    for (const ep of exposes) {
+      if ((ep.method || '').toUpperCase() !== 'PUT') continue;
+      // Normalize path param to detect /{id} pattern
+      const normalizedPut = (ep.path || '').replace(/\{[^}]+\}$/, '{id}');
+      if (!normalizedPut.match(/\{id\}$/)) continue; // only check PUT /{id} style paths
+      const resourceBase = normalizedPut.replace(/\{id\}$/, '{id}');
+      const hasGet = exposes.some(
+        (g) => (g.method || '').toUpperCase() === 'GET' &&
+          (g.path || '').replace(/\{[^}]+\}$/, '{id}') === resourceBase
       );
-    } else if (!hasAnyIntegration) {
-      ok.push(`'${mod.name}' es un módulo autónomo sin dependencias de integración`);
+      if (!hasGet) {
+        warnings.push(`[S4-002] Módulo '${mod.name}' tiene PUT ${ep.path} sin el correspondiente GET ${ep.path}`);
+      }
     }
 
-    // Check: module that only consumes — expected, no warning
-    if (!producesEvents && consumesEvents && !makesSyncCalls) {
-      ok.push(`'${mod.name}' es consumidor puro de eventos (correcto: no produce eventos propios)`);
+    // S4-003: DELETE without description documenting physical vs logical
+    for (const ep of exposes) {
+      if ((ep.method || '').toUpperCase() !== 'DELETE') continue;
+      if (!ep.description || ep.description.trim() === '') {
+        warnings.push(`[S4-003] Endpoint DELETE ${ep.path} en '${mod.name}' no tiene description que indique si el borrado es físico o lógico`);
+      }
     }
-  }
-
-  // ── Check 4: Behavior Gaps ─────────────────────────────────────────────────
 
-  const schedulerVerbs = ['expire', 'clean', 'close', 'archive', 'timeout', 'process', 'purge', 'flush'];
-  const mutationMethods = new Set(['PUT', 'PATCH', 'DELETE', 'POST']);
+    // S4-004: endpoint without description (info)
+    for (const ep of exposes) {
+      if (!ep.description || ep.description.trim() === '') {
+        info.push(`[S4-004] Endpoint ${ep.method} ${ep.path} en '${mod.name}' no tiene campo description`);
+      }
+    }
 
-  for (const mod of modules) {
-    for (const ep of mod.exposes || []) {
-      const useCaseLower = (ep.useCase || '').toLowerCase();
-      const method = (ep.method || '').toUpperCase();
-
-      if (!mutationMethods.has(method)) continue;
-
-      const matchedVerb = schedulerVerbs.find((v) => useCaseLower.startsWith(v) || useCaseLower.includes(v));
-      if (!matchedVerb) continue;
-
-      // Check: is this endpoint reachable via an async event
-      const triggeredByEvent = asyncEvents.some((ev) =>
-        (ev.consumers || []).some((c) => {
-          const consumer = typeof c === 'string' ? c : c.module;
-          if (consumer !== mod.name) return false;
-          // The event name often matches the use case verb
-          const eventLower = ev.event.toLowerCase();
-          return schedulerVerbs.some((v) => eventLower.includes(v));
-        })
+    // S4-005: module with POST but no GET /{id} (info)
+    const hasPost = exposes.some((ep) => (ep.method || '').toUpperCase() === 'POST');
+    if (hasPost) {
+      const hasGetById = exposes.some(
+        (ep) => (ep.method || '').toUpperCase() === 'GET' &&
+          /\{[^}]+\}$/.test(ep.path || '')
       );
-
-      // Check: is this endpoint called by a sync integration
-      const triggeredBySync = syncIntegrations.some((s) => s.calls === mod.name && (s.using || []).some((u) => u.includes(ep.path)));
-
-      if (!triggeredByEvent && !triggeredBySync) {
-        warnings.push(
-          `Gap de comportamiento: '${ep.useCase}' (${ep.method} ${ep.path}) en '${mod.name}' no tiene ningún evento ni llamada síncrona que lo active. Puede necesitar un scheduler o job periódico.`
-        );
+      if (!hasGetById) {
+        info.push(`[S4-005] Módulo '${mod.name}' tiene POST de creación pero no declara GET /{id} para recuperar el recurso creado`);
       }
     }
   }
 
-  // Check: modules with no exposes at all (already partially covered above, but surface separately)
-  for (const mod of modules) {
-    if (!mod.exposes || mod.exposes.length === 0) {
-      ok.push(`'${mod.name}' no expone endpoints REST directamente (módulo de integración)`);
-    }
-  }
+  // ── S5 — Coherencia del sistema global ───────────────────────────────────
 
-  // ── Check 5: Coupling Patterns ────────────────────────────────────────────
+  // S5-001: messaging.enabled: false with async events declared
+  if (messaging.enabled === false && asyncEvents.length > 0) {
+    warnings.push(`[S5-001] messaging.enabled está en false pero hay ${asyncEvents.length} eventos declarados en integrations.async`);
+  } else if (messaging.enabled !== false && asyncEvents.length > 0) {
+    ok.push('[S5-001] Configuración de messaging es coherente con los eventos declarados ✓');
+  }
 
-  for (const sync of syncIntegrations) {
-    const caller = sync.caller;
-    const callee = sync.calls;
+  // S5-002: success event without matching failure event for same subject
+  // Suffixes that represent external operations with side-effects → warning if no failure counterpart
+  const successSuffixesWarning = ['confirmedevent', 'approvedevent', 'placedevent', 'activatedevent'];
+  // Suffixes that represent physical/irreversible facts → info only (compensation less expected)
+  const successSuffixesInfo = ['completedevent'];
+  const failureSuffixes = ['failedevent', 'rejectedevent', 'cancelledevent', 'canceledevent', 'expiredevent'];
 
-    // Find reverse async: callee publishes event that caller consumes
-    const reverseAsyncEvents = asyncEvents.filter((ev) => {
-      if (ev.producer !== callee) return false;
-      return (ev.consumers || []).some((c) => (typeof c === 'string' ? c : c.module) === caller);
+  for (const ev of asyncEvents) {
+    const evLower = (ev.event || '').toLowerCase();
+    const matchedWarning = successSuffixesWarning.find((s) => evLower.endsWith(s));
+    const matchedInfo = !matchedWarning && successSuffixesInfo.find((s) => evLower.endsWith(s));
+    const matched = matchedWarning || matchedInfo;
+    if (!matched) continue;
+
+    // Derive subject: strip the matched suffix
+    const subjectLength = evLower.length - matched.length;
+    const subject = evLower.slice(0, subjectLength);
+
+    // Check if there's any failure event with the same subject prefix
+    const hasFailure = asyncEvents.some((other) => {
+      const otherLower = (other.event || '').toLowerCase();
+      return failureSuffixes.some((f) => otherLower.endsWith(f) && otherLower.startsWith(subject));
     });
 
-    if (reverseAsyncEvents.length > 0) {
-      const eventNames = reverseAsyncEvents.map((e) => e.event).join(', ');
-      warnings.push(
-        `Acoplamiento asimétrico: '${caller}' llama síncronamente a '${callee}', mientras '${callee}' responde vía eventos asíncronos (${eventNames}). Considerar pasar los datos necesarios directamente en el evento para eliminar la llamada síncrona.`
-      );
+    if (!hasFailure) {
+      const msg = `[S5-002] Evento de éxito '${ev.event}' existe pero no hay un evento de fallo correspondiente para el sujeto '${subject}' que permita compensación`;
+      if (matchedWarning) {
+        warnings.push(msg);
+      } else {
+        info.push(msg);
+      }
     }
   }
 
-  // Detect dual trigger: endpoint appears in both sync.using and as event-triggered consumer
+  // S5-003: auth/security module with no integrations (info)
+  const authPattern = /auth|security|identity|session/i;
   for (const mod of modules) {
-    for (const ep of mod.exposes || []) {
-      const endpointStr = `${ep.method} ${ep.path}`;
-      const inSync = syncIntegrations.some(
-        (s) => s.calls === mod.name && (s.using || []).some((u) => endpointMatches(endpointStr, u) || endpointMatches(u, endpointStr))
-      );
-      const inEvents = asyncEvents.some(
-        (ev) =>
-          (ev.consumers || []).some((c) => (typeof c === 'string' ? c : c.module) === mod.name) &&
-          asyncEvents.some(() => false) // placeholder; real dual-trigger needs business knowledge
-      );
-      // Flag endpoints used in sync AND the module also consumes events (approximate heuristic)
-      if (inSync) {
-        const modConsumesEvents = asyncEvents.some((ev) =>
-          (ev.consumers || []).some((c) => (typeof c === 'string' ? c : c.module) === mod.name)
-        );
-        if (modConsumesEvents) {
-          ok.push(
-            `'${mod.name}' tiene endpoints accesibles tanto síncronamente como vía eventos (diseño dual — intencional)`
-          );
-          break; // one ok per module is enough
-        }
-      }
-      void inEvents; // suppress unused warning
+    if (!authPattern.test(mod.name)) continue;
+    const hasAnyIntegration =
+      asyncEvents.some((e) => e.producer === mod.name || (e.consumers || []).some((c) => consumerModule(c) === mod.name)) ||
+      syncIntegrations.some((s) => s.caller === mod.name || s.calls === mod.name);
+    if (!hasAnyIntegration) {
+      info.push(`[S5-003] Módulo '${mod.name}' parece manejar autenticación/seguridad pero no tiene ninguna integración declarada con otros módulos`);
     }
   }
 
-  // Highlight producer-only modules (no event consumption, no sync calls received) — healthy pattern
+  // S5-004: module with no connection to system graph (info)
   for (const mod of modules) {
-    const onlyProduces =
-      asyncEvents.some((e) => e.producer === mod.name) &&
-      !asyncEvents.some((e) =>
-        (e.consumers || []).some((c) => (typeof c === 'string' ? c : c.module) === mod.name)
-      ) &&
-      !syncIntegrations.some((s) => s.calls === mod.name);
-
-    if (onlyProduces) {
-      ok.push(`'${mod.name}' es productor puro de eventos sin dependencias entrantes (bajo acoplamiento) ✓`);
+    const hasAnyConnection =
+      asyncEvents.some((e) => e.producer === mod.name || (e.consumers || []).some((c) => consumerModule(c) === mod.name)) ||
+      syncIntegrations.some((s) => s.caller === mod.name || s.calls === mod.name);
+    if (!hasAnyConnection) {
+      info.push(`[S5-004] Módulo '${mod.name}' no tiene ninguna conexión al grafo del sistema — ni async ni sync`);
     }
   }
 
-  // ── Score ────────────────────────────────────────────────────────────────
+  // ── Score (info items do not affect score) ────────────────────────────────
 
   const total = ok.length + errors.length + warnings.length * 0.5;
   const score = total > 0 ? Math.round((ok.length / total) * 100) : 100;
 
-  return { errors, warnings, ok, score };
+  return { errors, warnings, info, ok, score };
 }
 
 /**