eva4j 1.0.17 → 1.0.18

package/src/utils/domain-validator.js

@@ -1,6 +1,6 @@
 'use strict';
 
-const { pluralizeWord, singularizeWord } = require('./naming');
+const { pluralizeWord, singularizeWord, toPascalCase } = require('./naming');
 
 /**
  * Domain-level validator for eva evaluate system --domain
@@ -13,9 +13,10 @@ const { pluralizeWord, singularizeWord } = 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 ─────────────────────────────────────────────────────────
@@ -392,6 +393,7 @@ function runC2(domainConfigs, systemConfig) {
     '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)) {
@@ -471,8 +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(
@@ -780,6 +788,22 @@ function runC2(domainConfigs, systemConfig) {
     }
   }
 
+  // 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, {
     'C2-001': 'warning',
     'C2-002': 'info',
@@ -792,6 +816,7 @@ function runC2(domainConfigs, systemConfig) {
     'C2-009': 'warning',
     'C2-010': 'error',
     'C2-011': 'error',
+    'C2-012': 'error',
   });
 
   return checks;
@@ -1151,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 ────────────────────────────────────────────────────
 
 /**
@@ -1176,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 = [
     {
@@ -1202,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
@@ -1216,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,
   };
 }
 

package/src/utils/naming.js

@@ -47,6 +47,15 @@ function toKebabCase(str) {
     .toLowerCase();
 }
 
+/**
+ * Convert string to SCREAMING_SNAKE_CASE
+ * @param {string} str - Input string
+ * @returns {string} SCREAMING_SNAKE_CASE string
+ */
+function toScreamingSnakeCase(str) {
+  return toSnakeCase(str).toUpperCase();
+}
+
 /**
  * Pluralize a word
  * @param {string} word - Word to pluralize
@@ -137,6 +146,7 @@ module.exports = {
   toCamelCase,
   toSnakeCase,
   toKebabCase,
+  toScreamingSnakeCase,
   pluralizeWord,
   singularizeWord,
   toPackagePath,

package/src/utils/system-validator.js

@@ -1,5 +1,7 @@
 'use strict';
 
+const { toPascalCase, toCamelCase } = require('./naming');
+
 /**
  * Validates a parsed system.yaml object against the S1–S5 static evaluation rules.
  *
@@ -21,6 +23,10 @@ function validateSystem(systemConfig, domainConfigs = {}) {
   const messaging = systemConfig.messaging || {};
   const topicPrefix = (messaging.kafka || {}).topicPrefix || null;
 
+  // Detect Temporal orchestration mode — suppresses Kafka/Feign-specific rules
+  const orchestration = systemConfig.orchestration || {};
+  const isTemporalMode = !!(orchestration.enabled && orchestration.engine === 'temporal');
+
   // Helper: normalize a consumer entry to its module name string
   const consumerModule = (c) => (typeof c === 'string' ? c : c.module);
 
@@ -57,7 +63,17 @@ function validateSystem(systemConfig, domainConfigs = {}) {
     const consumesEvents = asyncEvents.some((e) =>
       (e.consumers || []).some((c) => consumerModule(c) === mod.name)
     );
-    if (!hasExposes && !producesEvents && !consumesEvents) {
+    // In Temporal mode: a module with activities or local workflows is a valid participant
+    const hasTemporalRole = isTemporalMode && (() => {
+      const domCfg = domainConfigs[mod.name] || {};
+      return (Array.isArray(domCfg.activities) && domCfg.activities.length > 0) ||
+             (Array.isArray(domCfg.workflows) && domCfg.workflows.length > 0) ||
+             (systemConfig.workflows || []).some((wf) =>
+               (wf.trigger && toCamelCase(wf.trigger.module) === toCamelCase(mod.name)) ||
+               (wf.steps || []).some((s) => s.target && toCamelCase(s.target) === toCamelCase(mod.name))
+             );
+    })();
+    if (!hasExposes && !producesEvents && !consumesEvents && !hasTemporalRole) {
       errors.push(`[S1-002] Módulo '${mod.name}' no tiene ninguna responsabilidad — no expone endpoints, no produce ni consume eventos`);
       s1_002_found = true;
     }
@@ -346,10 +362,13 @@ function validateSystem(systemConfig, domainConfigs = {}) {
   // ── S5 — Coherencia del sistema global ───────────────────────────────────
 
   // 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 ✓');
+  // Not applicable to Temporal-based systems
+  if (!isTemporalMode) {
+    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 ✓');
+    }
   }
 
   // S5-002: success event without matching failure event for same subject
@@ -399,12 +418,151 @@ function validateSystem(systemConfig, domainConfigs = {}) {
   }
 
   // S5-004: module with no connection to system graph (info)
-  for (const mod of modules) {
-    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`);
+  // Suppressed for Temporal mode — connectivity is via workflows[], not integrations.async[]/sync[]
+  if (!isTemporalMode) {
+    for (const mod of modules) {
+      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`);
+      }
+    }
+  }
+
+  // ── T1 — Temporal Workflow Integrity ──────────────────────────────────────
+  // Skipped in Temporal mode — handled exclusively by temporal-validator.js
+  if (!isTemporalMode && orchestration.enabled && Array.isArray(systemConfig.workflows)) {
+    // Build activity registry from domainConfigs: PascalCase name → { module, input[], output[] }
+    const activityMap = new Map();
+    for (const [modName, domainCfg] of Object.entries(domainConfigs)) {
+      if (!domainCfg || !Array.isArray(domainCfg.activities)) continue;
+      const modCamel = toCamelCase(modName);
+      for (const act of domainCfg.activities) {
+        const actPascal = toPascalCase(act.name);
+        const inputNames = Array.isArray(act.input) ? act.input.map((f) => f.name || f) : [];
+        const outputNames = Array.isArray(act.output) ? act.output.map((f) => f.name || f) : [];
+        activityMap.set(`${modCamel}::${actPascal}`, { module: modCamel, inputNames, outputNames });
+      }
+    }
+
+    let t1_001_found = false;
+    let t1_002_found = false;
+    let t1_004_found = false;
+    let t1_006_found = false;
+
+    for (const wf of systemConfig.workflows) {
+      const wfName = wf.name || '(unnamed)';
+      const hostModule = wf.trigger && wf.trigger.module ? toCamelCase(wf.trigger.module) : null;
+      const rawSteps = Array.isArray(wf.steps) ? wf.steps : [];
+
+      // Track available output names from prior steps for T1-002
+      const availableOutputNames = new Set();
+
+      // Compute workflow-level input names: step inputs not satisfied by prior step outputs
+      // (first pass to collect all step outputs)
+      const allStepOutputs = new Map(); // stepIndex → rawOutputNames
+      for (let i = 0; i < rawSteps.length; i++) {
+        const rawOut = Array.isArray(rawSteps[i].output) ? rawSteps[i].output : [];
+        allStepOutputs.set(i, new Set(rawOut));
+      }
+
+      // Compute workflow-level inputs: inputs not provided by any prior step's output
+      const workflowInputNames = new Set();
+      const priorOutputs = new Set();
+      for (let i = 0; i < rawSteps.length; i++) {
+        const stepInputs = Array.isArray(rawSteps[i].input) ? rawSteps[i].input : [];
+        for (const inName of stepInputs) {
+          if (!priorOutputs.has(inName)) {
+            workflowInputNames.add(inName);
+          }
+        }
+        const stepOutputs = allStepOutputs.get(i) || new Set();
+        for (const outName of stepOutputs) {
+          priorOutputs.add(outName);
+        }
+      }
+
+      for (let i = 0; i < rawSteps.length; i++) {
+        const step = rawSteps[i];
+        const actName = step.activity ? toPascalCase(step.activity) : null;
+        if (!actName) continue;
+
+        const targetModule = step.target ? toCamelCase(step.target) : hostModule;
+        const key = `${targetModule}::${actName}`;
+        const registered = activityMap.get(key);
+
+        // T1-004: Activity not found in target module
+        if (!registered) {
+          warnings.push(`[T1-004] Workflow '${wfName}' paso ${i + 1}: actividad '${actName}' no encontrada en activities[] de '${targetModule}'`);
+          t1_004_found = true;
+        }
+
+        // T1-001: Step output name not in activity's formal output fields
+        const rawOutputNames = Array.isArray(step.output) ? step.output : [];
+        if (registered && rawOutputNames.length > 0) {
+          const formalOutputSet = new Set(registered.outputNames);
+          for (const outName of rawOutputNames) {
+            if (!formalOutputSet.has(outName)) {
+              errors.push(`[T1-001] Workflow '${wfName}' paso ${i + 1} (${actName}): output '${outName}' no existe en los campos de salida de la actividad — campos disponibles: [${registered.outputNames.join(', ')}]`);
+              t1_001_found = true;
+            }
+          }
+
+          // T1-003: Step output count exceeds activity formal output count
+          if (rawOutputNames.length > registered.outputNames.length) {
+            warnings.push(`[T1-003] Workflow '${wfName}' paso ${i + 1} (${actName}): declara ${rawOutputNames.length} outputs pero la actividad solo define ${registered.outputNames.length} campos de salida`);
+          }
+        }
+
+        // T1-002: Step input name not resolvable
+        const rawInputNames = Array.isArray(step.input) ? step.input : [];
+        if (rawInputNames.length > 0) {
+          for (const inName of rawInputNames) {
+            if (!availableOutputNames.has(inName)) {
+              // Not from a prior step — must come from workflow input (OK, no error)
+              // But if we detect it's truly orphaned, we'd need full data-flow analysis.
+              // For now, we skip pure workflow-input names (they're always valid).
+            }
+          }
+        }
+
+        // T1-005: Sync step with no output declaration
+        if (step.type !== 'async' && rawOutputNames.length === 0 && registered && registered.outputNames.length > 0) {
+          info.push(`[T1-005] Workflow '${wfName}' paso ${i + 1} (${actName}): paso síncrono sin output: declarado — la actividad define ${registered.outputNames.length} campo(s) de salida que no se propagan`);
+        }
+
+        // Add this step's outputs to available set for subsequent steps
+        for (const outName of rawOutputNames) {
+          availableOutputNames.add(outName);
+        }
+
+        // T1-006: Compensation input field not resolvable
+        if (step.compensation) {
+          const compName = toPascalCase(step.compensation);
+          const compTarget = step.target ? toCamelCase(step.target) : hostModule;
+          const compKey = `${compTarget}::${compName}`;
+          const compRegistered = activityMap.get(compKey);
+          if (compRegistered) {
+            for (const compIn of compRegistered.inputNames) {
+              if (!availableOutputNames.has(compIn) && !workflowInputNames.has(compIn)) {
+                errors.push(`[T1-006] Workflow '${wfName}' paso ${i + 1} (${actName}): compensación '${compName}' requiere input '${compIn}' pero no está disponible en outputs de pasos previos ni en inputs del workflow`);
+                t1_006_found = true;
+              }
+            }
+          }
+        }
+      }
+    }
+
+    if (!t1_001_found) {
+      ok.push('[T1-001] Todos los outputs de pasos de workflow coinciden con campos formales de la actividad ✓');
+    }
+    if (!t1_004_found) {
+      ok.push('[T1-004] Todas las actividades referenciadas en workflows existen en sus módulos target ✓');
+    }
+    if (!t1_006_found) {
+      ok.push('[T1-006] Todos los inputs de compensaciones son resolubles desde outputs de pasos previos o inputs del workflow ✓');
     }
   }