eva4j 1.0.16 → 1.0.18

package/src/utils/config-manager.js

@@ -1,5 +1,6 @@
 const fs = require('fs-extra');
 const path = require('path');
+const { toCamelCase } = require('./naming');
 
 class ConfigManager {
   constructor(projectPath = process.cwd()) {
@@ -88,8 +89,9 @@ class ConfigManager {
   async moduleExists(moduleName) {
     const config = await this.loadProjectConfig();
     if (!config) return false;
-    
-    return config.modules.some(module => module.name === moduleName);
+
+    const normalized = toCamelCase(moduleName);
+    return config.modules.some(module => module.name === normalized);
   }
 
   /**

package/src/utils/domain-validator.js

@@ -1,6 +1,6 @@
 'use strict';
 
-const { pluralizeWord } = require('./naming');
+const { pluralizeWord, singularizeWord, toPascalCase } = require('./naming');
 
 /**
  * Domain-level validator for eva evaluate system --domain
@@ -13,9 +13,10 @@ const { pluralizeWord } = require('./naming');
  *
  * Categories:
  *   C1 — Kafka Event Contracts
- *   C4 — Behavior Gaps
- *   C5 — Cross-Reference Integrity
- *   C6 — Audit & Traceability
+ *   C2 — Behavior Gaps
+ *   C3 — Cross-Reference Integrity
+ *   C4 — Audit & Traceability
+ *   C5 — Temporal Workflow Integrity
  */
 
 // ── Internal helpers ─────────────────────────────────────────────────────────
@@ -119,7 +120,10 @@ function buildSystemAsyncMap(systemConfig) {
     map[ev.event] = {
       producer: ev.producer,
       topic: ev.topic,
-      consumers: (ev.consumers || []).map((c) => (typeof c === 'string' ? c : c.module)),
+      consumers: (ev.consumers || []).map((c) => {
+        if (typeof c === 'string') return { module: c, useCase: undefined, readModel: undefined };
+        return { module: c.module, useCase: c.useCase, readModel: c.readModel };
+      }),
     };
   }
   return map;
@@ -213,8 +217,9 @@ function runC1(domainConfigs, systemConfig) {
     'C1-002': { label: 'Listener referencia evento que ningún módulo produce', severity: 'ok', findings: [] },
     'C1-003': { label: 'Campo en listener.fields no existe en el evento del productor', severity: 'ok', findings: [] },
     'C1-004': { label: 'Campo existe pero con tipo incompatible productor/consumidor', severity: 'ok', findings: [] },
-    'C1-005': { label: 'system.yaml registra consumidor pero módulo no tiene listener declarado', severity: 'ok', findings: [] },
+    'C1-005': { label: 'system.yaml registra consumidor pero módulo no tiene listener o readModel.syncedBy declarado', severity: 'ok', findings: [] },
     'C1-006': { label: 'Listener declara producer: incorrecto', severity: 'ok', findings: [] },
+    'C1-007': { label: 'Campo de readModel no cubierto por eventos UPSERT del productor', severity: 'ok', findings: [] },
   };
 
   // C1-001: produced event in domain but zero consumers in system.yaml
@@ -277,20 +282,38 @@ function runC1(domainConfigs, systemConfig) {
     }
   }
 
-  // C1-005: system.yaml consumer present but module has no listener
+  // C1-005: system.yaml consumer present but module has no listener or readModel.syncedBy
   for (const [eventName, sysEntry] of Object.entries(systemAsyncMap)) {
-    for (const consumerModule of sysEntry.consumers) {
-      const consumerConfig = domainConfigs[consumerModule];
+    for (const consumer of sysEntry.consumers) {
+      const consumerConfig = domainConfigs[consumer.module];
       if (!consumerConfig) continue; // module domain.yaml not loaded — skip
-      const hasListener = (consumerConfig.listeners || []).some((l) => l.event === eventName);
-      if (!hasListener) {
-        checks['C1-005'].findings.push(
-          finding(
-            consumerModule,
-            `system.yaml registra '${consumerModule}' como consumidor de '${eventName}' pero el módulo no tiene listener declarado`,
-            `Evento producido por: ${sysEntry.producer}`
-          )
+
+      if (consumer.readModel) {
+        // readModel consumer → check readModels[].syncedBy[]
+        const hasSync = (consumerConfig.readModels || []).some((rm) =>
+          (rm.syncedBy || []).some((s) => s.event === eventName)
         );
+        if (!hasSync) {
+          checks['C1-005'].findings.push(
+            finding(
+              consumer.module,
+              `system.yaml registra '${consumer.module}' como consumidor readModel de '${eventName}' pero el módulo no tiene readModels[].syncedBy con ese evento`,
+              `Evento producido por: ${sysEntry.producer}, readModel esperado: ${consumer.readModel}`
+            )
+          );
+        }
+      } else {
+        // useCase consumer → check listeners[]
+        const hasListener = (consumerConfig.listeners || []).some((l) => l.event === eventName);
+        if (!hasListener) {
+          checks['C1-005'].findings.push(
+            finding(
+              consumer.module,
+              `system.yaml registra '${consumer.module}' como consumidor de '${eventName}' pero el módulo no tiene listener declarado`,
+              `Evento producido por: ${sysEntry.producer}`
+            )
+          );
+        }
       }
     }
   }
@@ -312,6 +335,35 @@ function runC1(domainConfigs, systemConfig) {
     }
   }
 
+  // C1-007: readModel field not covered by any UPSERT event from producer (RM-008)
+  for (const [moduleName, config] of Object.entries(domainConfigs)) {
+    for (const rm of config.readModels || []) {
+      // Collect field names from all UPSERT syncedBy events
+      const upsertEventFields = new Set();
+      for (const sync of rm.syncedBy || []) {
+        if ((sync.action || '').toUpperCase() !== 'UPSERT') continue;
+        const producerInfo = producedEvents[sync.event];
+        if (!producerInfo) continue; // caught by other checks
+        for (const f of producerInfo.fields) {
+          upsertEventFields.add(f.name);
+        }
+      }
+      // Check each readModel field (except 'id') is covered
+      for (const rmField of rm.fields || []) {
+        if (rmField.name === 'id') continue; // mapped to {entityName}Id in events
+        if (!upsertEventFields.has(rmField.name)) {
+          checks['C1-007'].findings.push(
+            finding(
+              moduleName,
+              `ReadModel '${rm.name}' tiene campo '${rmField.name}' que no aparece en ningún evento UPSERT de syncedBy`,
+              `Source: ${rm.source ? rm.source.module : '?'}. El campo siempre será null — agregar a los events del productor o quitar del readModel`
+            )
+          );
+        }
+      }
+    }
+  }
+
   // Assign severities
   setDefaultSeverities(checks, {
     'C1-001': 'info',
@@ -320,6 +372,7 @@ function runC1(domainConfigs, systemConfig) {
     'C1-004': 'error',
     'C1-005': 'error',
     'C1-006': 'error',
+    'C1-007': 'warning',
   });
 
   return checks;
@@ -336,6 +389,11 @@ function runC2(domainConfigs, systemConfig) {
     'C2-005': { label: 'Transición de estado sin Domain Event asociado (sin trigger)', severity: 'ok', findings: [] },
     'C2-006': { label: 'Colisión de nombre de useCase entre endpoints y listeners', severity: 'ok', findings: [] },
     'C2-007': { label: 'UseCase FindAll con nombre de agregado sin pluralizar correctamente', severity: 'ok', findings: [] },
+    'C2-008': { label: 'Evento con valor de lifecycle inválido', severity: 'ok', findings: [] },
+    'C2-009': { label: 'Evento lifecycle incompatible con configuración de entidad', severity: 'ok', findings: [] },
+    'C2-010': { label: 'Campo de lifecycle event no existe en la entidad raíz', severity: 'ok', findings: [] },
+    'C2-011': { label: 'Endpoint useCase no se resuelve a ningún agregado del módulo', severity: 'ok', findings: [] },
+    'C2-012': { label: 'Nombre del agregado no coincide con la entidad raíz (causa import incorrecto en ApplicationMapper)', severity: 'ok', findings: [] },
   };
 
   for (const [moduleName, config] of Object.entries(domainConfigs)) {
@@ -405,6 +463,7 @@ function runC2(domainConfigs, systemConfig) {
     }
 
     // C2-004: event trigger references a method that does not exist in any transition
+    // Skipped for events that use lifecycle: instead of triggers:
     const allTransitionMethods = new Set();
     for (const agg of config.aggregates || []) {
       for (const en of agg.enums || []) {
@@ -414,7 +473,14 @@ function runC2(domainConfigs, systemConfig) {
       }
     }
     for (const agg of config.aggregates || []) {
+      // Skip C2-004 for aggregates that have no enums — stateless entities have no transition
+      // methods, so event triggers on creation/registration cannot reference any method.
+      const aggHasEnumsWithTransitions = (agg.enums || []).some(
+        (en) => Array.isArray(en.transitions) && en.transitions.length > 0
+      );
       for (const ev of agg.events || []) {
+        if (ev.lifecycle) continue; // lifecycle events don't reference transition methods
+        if (!aggHasEnumsWithTransitions) continue; // stateless aggregate — no transitions to reference
         for (const trigger of ev.triggers || []) {
           if (!allTransitionMethods.has(trigger)) {
             checks['C2-004'].findings.push(
@@ -429,6 +495,74 @@ function runC2(domainConfigs, systemConfig) {
       }
     }
 
+    // C2-008: event lifecycle value is not one of the valid options
+    const validLifecycleValues = ['create', 'update', 'delete', 'softDelete'];
+    for (const agg of config.aggregates || []) {
+      for (const ev of agg.events || []) {
+        if (ev.lifecycle && !validLifecycleValues.includes(ev.lifecycle)) {
+          checks['C2-008'].findings.push(
+            finding(
+              moduleName,
+              `Evento '${ev.name}' tiene lifecycle: '${ev.lifecycle}' que no es un valor válido`,
+              `Valores válidos: ${validLifecycleValues.join(', ')}`
+            )
+          );
+        }
+      }
+    }
+
+    // C2-009: lifecycle value is incompatible with entity configuration
+    for (const agg of config.aggregates || []) {
+      const rootEntity = (agg.entities || []).find(e => e.isRoot);
+      const hasSoftDelete = rootEntity && rootEntity.hasSoftDelete;
+      for (const ev of agg.events || []) {
+        if (ev.lifecycle === 'softDelete' && !hasSoftDelete) {
+          checks['C2-009'].findings.push(
+            finding(
+              moduleName,
+              `Evento '${ev.name}' tiene lifecycle: 'softDelete' pero la entidad raíz '${rootEntity ? rootEntity.name : agg.name}' no tiene hasSoftDelete: true`,
+              `Agregado: ${agg.name}. Agregar hasSoftDelete: true a la entidad raíz o cambiar lifecycle a 'delete'`
+            )
+          );
+        }
+        if (ev.lifecycle === 'delete' && hasSoftDelete) {
+          checks['C2-009'].findings.push(
+            finding(
+              moduleName,
+              `Evento '${ev.name}' tiene lifecycle: 'delete' pero la entidad raíz '${rootEntity.name}' tiene hasSoftDelete: true`,
+              `Agregado: ${agg.name}. Usar lifecycle: 'softDelete' en su lugar o quitar hasSoftDelete`
+            )
+          );
+        }
+      }
+    }
+
+    // C2-010: lifecycle event field not found in root entity
+    for (const agg of config.aggregates || []) {
+      const rootEntityC10 = (agg.entities || []).find(e => e.isRoot);
+      if (!rootEntityC10) continue;
+      const entityFieldNames = new Set((rootEntityC10.fields || []).map(f => f.name));
+      const entityBase = rootEntityC10.name.charAt(0).toLowerCase() + rootEntityC10.name.slice(1);
+      for (const ev of agg.events || []) {
+        if (!ev.lifecycle) continue;
+        for (const ef of ev.fields || []) {
+          // Skip {entityName}Id — mapped to aggregateId in DomainEvent
+          if (ef.name === entityBase + 'Id') continue;
+          // Skip temporal auto-resolved fields (*At + LocalDateTime)
+          if (ef.name.endsWith('At') && ef.type === 'LocalDateTime') continue;
+          if (!entityFieldNames.has(ef.name)) {
+            checks['C2-010'].findings.push(
+              finding(
+                moduleName,
+                `Evento '${ev.name}' (lifecycle: ${ev.lifecycle}) tiene campo '${ef.name}' que no existe en la entidad raíz '${rootEntityC10.name}'`,
+                `Agregado: ${agg.name}. Quitar '${ef.name}' del evento o agregar el campo a la entidad`
+              )
+            );
+          }
+        }
+      }
+    }
+
     // C2-005: transition method without any associated domain event trigger
     for (const agg of config.aggregates || []) {
       for (const en of agg.enums || []) {
@@ -566,6 +700,108 @@ function runC2(domainConfigs, systemConfig) {
         }
       }
     }
+
+    // C2-011: Endpoint useCase not semantically resolvable to any aggregate
+    // Detects FindAll/Get use cases that won't match any aggregate via exact
+    // or fuzzy matching — these silently fall to scaffold with the wrong
+    // aggregate's ResponseDto, producing code that doesn't compile.
+    const allAggs = config.aggregates || [];
+    for (const ver of (config.endpoints && config.endpoints.versions) || []) {
+      for (const op of ver.operations || []) {
+        const uc = op.useCase || '';
+        let resolved = false;
+
+        for (const agg of allAggs) {
+          const aggName = agg.name;
+          const aggPlural = pluralizeWord(aggName);
+          // Exact standard match
+          if (uc === `Create${aggName}` || uc === `Update${aggName}` ||
+              uc === `Delete${aggName}` || uc === `Get${aggName}` ||
+              uc === `FindAll${aggPlural}`) {
+            resolved = true;
+            break;
+          }
+          // Fuzzy FindAll: singular of suffix is prefix of aggregate name (or vice-versa)
+          if (uc.startsWith('FindAll')) {
+            const suffix = uc.slice(7);
+            if (suffix) {
+              const singular = singularizeWord(suffix).toLowerCase();
+              const aggLower = aggName.toLowerCase();
+              if (aggLower.startsWith(singular) || singular.startsWith(aggLower)) {
+                resolved = true;
+                break;
+              }
+            }
+          }
+          // Fuzzy Get: suffix is prefix of aggregate name (or vice-versa)
+          if (uc.startsWith('Get') && !uc.startsWith('GetAll')) {
+            const suffix = uc.slice(3);
+            if (suffix) {
+              const suffixLower = suffix.toLowerCase();
+              const aggLower = aggName.toLowerCase();
+              if (aggLower.startsWith(suffixLower) || suffixLower.startsWith(aggLower)) {
+                resolved = true;
+                break;
+              }
+            }
+          }
+          // Transition match
+          const entities = agg.entities || [];
+          const rootEntity = entities.find(e => e.isRoot) || entities[0] || {};
+          const enums = rootEntity.enums || agg.enums || [];
+          for (const enumDef of enums) {
+            for (const tr of (enumDef.transitions || [])) {
+              const methodPascal = tr.method.charAt(0).toUpperCase() + tr.method.slice(1);
+              if (uc === `${methodPascal}${aggName}`) {
+                resolved = true;
+              }
+            }
+          }
+          if (resolved) break;
+          // SubEntity match
+          const rels = (rootEntity.relationships || []).filter(r => r.type === 'OneToMany' && !r.isInverse);
+          for (const rel of rels) {
+            if (uc === `Add${rel.target}` || uc === `Remove${rel.target}`) {
+              resolved = true;
+              break;
+            }
+          }
+          if (resolved) break;
+          // Substring fallback: aggregate name inside useCase
+          if (uc.toLowerCase().includes(aggName.toLowerCase())) {
+            resolved = true;
+            break;
+          }
+        }
+
+        if (!resolved) {
+          const firstAgg = allAggs.length > 0 ? allAggs[0].name : '(none)';
+          checks['C2-011'].findings.push(
+            finding(
+              moduleName,
+              `UseCase '${uc}' no se resuelve a ningún agregado del módulo — se asignará al primero ('${firstAgg}') y generará código con tipos incorrectos`,
+              `Versión: ${ver.version}. Considere renombrar el useCase para que contenga el nombre del agregado, o verificar que el agregado destino existe.`
+            )
+          );
+        }
+      }
+    }
+  }
+
+  // C2-012: Aggregate name ≠ root entity name → ApplicationMapper imports wrong class
+  for (const [moduleName, config] of Object.entries(domainConfigs)) {
+    for (const agg of config.aggregates || []) {
+      const rootEntity = (agg.entities || []).find(e => e.isRoot);
+      if (rootEntity && toPascalCase(rootEntity.name) !== agg.name) {
+        checks['C2-012'].findings.push(
+          finding(
+            moduleName,
+            `Agregado '${agg.name}' tiene entidad raíz '${rootEntity.name}' (PascalCase: '${toPascalCase(rootEntity.name)}') — los nombres no coinciden. El generador usará '${agg.name}' para imports y mappers pero la clase de dominio se llamará '${toPascalCase(rootEntity.name)}'`,
+            `Renombre la entidad raíz a '${agg.name.charAt(0).toLowerCase() + agg.name.slice(1)}' o el agregado a '${toPascalCase(rootEntity.name)}' para que coincidan.`
+          )
+        );
+      }
+    }
   }
 
   setDefaultSeverities(checks, {
@@ -576,6 +812,11 @@ function runC2(domainConfigs, systemConfig) {
     'C2-005': 'info',
     'C2-006': 'error',
     'C2-007': 'error',
+    'C2-008': 'error',
+    'C2-009': 'warning',
+    'C2-010': 'error',
+    'C2-011': 'error',
+    'C2-012': 'error',
   });
 
   return checks;
@@ -935,6 +1176,225 @@ function runC4(domainConfigs, systemConfig) {
   return checks;
 }
 
+// ─── C5 — Temporal Workflow Integrity ────────────────────────────────────────
+
+function runC5(domainConfigs, systemConfig) {
+  const checks = {
+    'C5-001': { label: 'Tipo de input de actividad de compensación incompatible con actividad padre', severity: 'ok', findings: [] },
+    'C5-002': { label: 'Step de workflow referencia actividad no declarada en módulo destino', severity: 'ok', findings: [] },
+    'C5-003': { label: 'Compensación de workflow referencia actividad no declarada en módulo destino', severity: 'ok', findings: [] },
+    'C5-004': { label: 'Tipo de input en step incompatible con el output del step que lo provee', severity: 'ok', findings: [] },
+  };
+
+  const workflows = systemConfig.workflows || [];
+  if (workflows.length === 0) return checks;
+
+  // Build map: moduleName → { activityName → activityDef }
+  const moduleActivities = {};
+  for (const [moduleName, config] of Object.entries(domainConfigs)) {
+    const acts = {};
+    for (const act of config.activities || []) {
+      acts[act.name] = act;
+    }
+    moduleActivities[moduleName] = acts;
+  }
+
+  for (const wf of workflows) {
+    for (const step of wf.steps || []) {
+      const target = step.target;
+      const acts = moduleActivities[target] || {};
+
+      // C5-002: activity not found in target module
+      if (step.activity && !acts[step.activity]) {
+        checks['C5-002'].findings.push(
+          finding(
+            target,
+            `Workflow '${wf.name}' step '${step.activity}' no se encuentra en activities de '${target}'`,
+            `Declarar la actividad '${step.activity}' en ${target}.yaml activities[]`
+          )
+        );
+      }
+
+      // C5-003: compensation activity not found in target module
+      if (step.compensation && !acts[step.compensation]) {
+        checks['C5-003'].findings.push(
+          finding(
+            target,
+            `Workflow '${wf.name}' compensación '${step.compensation}' no se encuentra en activities de '${target}'`,
+            `Declarar la actividad '${step.compensation}' en ${target}.yaml activities[]`
+          )
+        );
+      }
+
+      // C5-001: compensation input type mismatch with parent activity
+      if (step.activity && step.compensation && acts[step.activity] && acts[step.compensation]) {
+        const parentAct = acts[step.activity];
+        const compAct = acts[step.compensation];
+        const parentInputs = parentAct.input || [];
+        const compInputs = compAct.input || [];
+
+        // Compare each input field by position and type
+        const maxLen = Math.max(parentInputs.length, compInputs.length);
+        for (let i = 0; i < maxLen; i++) {
+          const pField = parentInputs[i];
+          const cField = compInputs[i];
+
+          if (!pField || !cField) {
+            // Different number of input fields
+            checks['C5-001'].findings.push(
+              finding(
+                target,
+                `Workflow '${wf.name}': '${step.compensation}' tiene ${compInputs.length} campo(s) de input pero '${step.activity}' tiene ${parentInputs.length}`,
+                `La compensación recibe el mismo input que la actividad padre — deben coincidir en cantidad y tipos`
+              )
+            );
+            break; // report once per pair
+          }
+
+          const pType = normalizeType(pField.type);
+          const cType = normalizeType(cField.type);
+          if (pType !== cType && !typesCompatible(pField.type, cField.type)) {
+            checks['C5-001'].findings.push(
+              finding(
+                target,
+                `Workflow '${wf.name}': input '${cField.name}' de compensación '${step.compensation}' es '${cField.type}' pero la actividad padre '${step.activity}' usa '${pField.type}'`,
+                `Campo '${pField.name}' (pos ${i}). La compensación recibe el mismo input en runtime — usar un tipo neutral compartido (ej: nestedType con los campos mínimos necesarios)`
+              )
+            );
+          }
+        }
+      }
+    }
+  }
+
+  // C5-004: workflow data-flow type mismatch
+  // Trace variable types through the step chain: each step's output feeds the pool,
+  // each subsequent step's input is checked against the pool types.
+  for (const wf of workflows) {
+    const pool = {}; // varName → { type, producerStep }
+
+    for (const step of wf.steps || []) {
+      if (!step.activity) continue; // skip non-activity steps (e.g. wait)
+      const target = step.target;
+      const acts = moduleActivities[target] || {};
+      const actDef = acts[step.activity];
+      if (!actDef) continue; // caught by C5-002
+
+      const actInputs = actDef.input || [];
+      const stepInputs = step.input || [];
+
+      // Check each step input against pool (positional: step.input[i] → activity.input[i])
+      for (let i = 0; i < stepInputs.length && i < actInputs.length; i++) {
+        const varName = stepInputs[i];
+        const poolEntry = pool[varName];
+        if (!poolEntry) continue; // workflow-level param with no prior producer — skip
+
+        const expectedType = actInputs[i].type;
+        if (!expectedType) continue;
+
+        const poolType = normalizeType(poolEntry.type);
+        const expType = normalizeType(expectedType);
+        if (poolType !== expType && !typesCompatible(poolEntry.type, expectedType)) {
+          checks['C5-004'].findings.push(
+            finding(
+              target,
+              `Workflow '${wf.name}': step '${step.activity}' espera '${varName}' como '${expectedType}' pero '${poolEntry.producerStep}' lo produce como '${poolEntry.type}'`,
+              `Variable '${varName}' fluye de '${poolEntry.producerStep}' → '${step.activity}'. Los tipos deben coincidir — agregar un campo de proyección con el tipo correcto en el output del productor`
+            )
+          );
+        }
+      }
+
+      // Register step outputs in pool (positional: step.output[i] → activity.output[i])
+      const actOutputs = actDef.output || [];
+      const stepOutputs = step.output || [];
+      for (let i = 0; i < stepOutputs.length && i < actOutputs.length; i++) {
+        pool[stepOutputs[i]] = {
+          type: actOutputs[i].type,
+          producerStep: step.activity,
+        };
+      }
+    }
+  }
+
+  // Also validate domain-level compensation references (activity.compensation within same module)
+  for (const [moduleName, config] of Object.entries(domainConfigs)) {
+    const acts = moduleActivities[moduleName] || {};
+    for (const act of config.activities || []) {
+      if (!act.compensation) continue;
+      const compAct = acts[act.compensation];
+
+      if (!compAct) {
+        // Compensation activity not found — only report if not already caught by C5-003
+        const alreadyCaught = checks['C5-003'].findings.some(
+          (f) => f.module === moduleName && f.message.includes(`'${act.compensation}'`)
+        );
+        if (!alreadyCaught) {
+          checks['C5-003'].findings.push(
+            finding(
+              moduleName,
+              `Actividad '${act.name}' declara compensation: '${act.compensation}' pero no existe en activities de '${moduleName}'`,
+              `Declarar la actividad '${act.compensation}' en ${moduleName}.yaml activities[]`
+            )
+          );
+        }
+        continue;
+      }
+
+      // Type mismatch check at domain level
+      const parentInputs = act.input || [];
+      const compInputs = compAct.input || [];
+      const maxLen = Math.max(parentInputs.length, compInputs.length);
+      for (let i = 0; i < maxLen; i++) {
+        const pField = parentInputs[i];
+        const cField = compInputs[i];
+
+        if (!pField || !cField) {
+          const alreadyCaught = checks['C5-001'].findings.some(
+            (f) => f.module === moduleName && f.message.includes(`'${act.compensation}'`) && f.message.includes(`'${act.name}'`)
+          );
+          if (!alreadyCaught) {
+            checks['C5-001'].findings.push(
+              finding(
+                moduleName,
+                `Actividad '${act.compensation}' tiene ${compInputs.length} campo(s) de input pero '${act.name}' tiene ${parentInputs.length}`,
+                `La compensación recibe el mismo input que la actividad padre — deben coincidir en cantidad y tipos`
+              )
+            );
+          }
+          break;
+        }
+
+        const pType = normalizeType(pField.type);
+        const cType = normalizeType(cField.type);
+        if (pType !== cType && !typesCompatible(pField.type, cField.type)) {
+          const alreadyCaught = checks['C5-001'].findings.some(
+            (f) => f.module === moduleName && f.message.includes(`'${cField.name}'`) && f.message.includes(`'${act.compensation}'`)
+          );
+          if (!alreadyCaught) {
+            checks['C5-001'].findings.push(
+              finding(
+                moduleName,
+                `Input '${cField.name}' de compensación '${act.compensation}' es '${cField.type}' pero la actividad padre '${act.name}' usa '${pField.type}'`,
+                `Campo '${pField.name}' (pos ${i}). La compensación recibe el mismo input en runtime — usar un tipo neutral compartido (ej: nestedType con los campos mínimos necesarios)`
+              )
+            );
+          }
+        }
+      }
+    }
+  }
+
+  setDefaultSeverities(checks, {
+    'C5-001': 'error',
+    'C5-002': 'error',
+    'C5-003': 'error',
+    'C5-004': 'error',
+  });
+
+  return checks;
+}
+
 // ── Severity finalization ────────────────────────────────────────────────────
 
 /**
@@ -960,6 +1420,7 @@ function validateDomain(domainConfigs, systemConfig) {
   const c2Checks = runC2(domainConfigs, systemConfig);
   const c3Checks = runC3(domainConfigs, systemConfig);
   const c4Checks = runC4(domainConfigs, systemConfig);
+  const c5Checks = runC5(domainConfigs, systemConfig);
 
   const categories = [
     {
@@ -986,6 +1447,12 @@ function validateDomain(domainConfigs, systemConfig) {
       description: 'Verifica que las entidades críticas tengan mecanismos de trazabilidad de cambios.',
       checks: checksToArray(c4Checks),
     },
+    {
+      id: 'C5',
+      label: 'Integridad de Workflows Temporal',
+      description: 'Verifica que las actividades, compensaciones y contratos de tipos en workflows Temporal sean coherentes.',
+      checks: checksToArray(c5Checks),
+    },
   ];
 
   // Compute summary
@@ -1000,11 +1467,22 @@ function validateDomain(domainConfigs, systemConfig) {
   }
 
   const { generateDomainDiagrams } = require('./domain-diagram');
+  const { generateBlueprintDiagrams } = require('./bounded-context-diagram');
+
+  const blueprintResults = generateBlueprintDiagrams(domainConfigs, systemConfig);
+  const blueprintDiagrams = {};
+  const useCaseDetails = {};
+  for (const [mod, result] of Object.entries(blueprintResults)) {
+    blueprintDiagrams[mod] = result.diagram || '';
+    useCaseDetails[mod] = result.useCases || {};
+  }
 
   return {
     summary: { errors, warnings, info, ok },
     categories,
     diagrams: generateDomainDiagrams(domainConfigs),
+    blueprints: blueprintDiagrams,
+    useCaseDetails,
   };
 }