feat: replay E2E fonctionnel — 25/25 actions, 0 retries, SomEngine via serveur

Validé sur PC Windows (DESKTOP-58D5CAC, 2560x1600) :
- 8 clics résolus visuellement (1 anchor_template, 1 som_text_match, 6 som_vlm)
- Score moyen 0.75, temps moyen 1.6s
- Texte tapé correctement (bonjour, test word, date, email)
- 0 retries, 2 actions non vérifiées (OK)

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

.kiro/specs/correction-proprietes-etapes-vides/design.md

@@ -0,0 +1,522 @@
+# Design Technique - Correction des Propriétés d'Étapes Vides
+
+**Auteur :** Dom, Alice, Kiro  
+**Date :** 12 janvier 2026  
+**Version :** 1.0.0
+
+## Vue d'Ensemble de la Solution
+
+Cette solution corrige le problème des propriétés d'étapes vides en refactorisant la logique de détection et de mapping des types d'étapes dans le Visual Workflow Builder.
+
+### Problème Diagnostiqué
+
+```typescript
+// PROBLÈME ACTUEL : getParameterConfig() retourne []
+const getParameterConfig = useCallback((): ParameterConfig[] => {
+  if (!selectedStep) return [];
+  return stepParametersConfig[selectedStep.type] || []; // ← Retourne toujours []
+}, [selectedStep]);
+```
+
+**Cause racine** : Incohérence entre les types d'étapes créées et les clés de `stepParametersConfig`.
+
+## Architecture de la Solution
+
+### 1. Normalisation des Types d'Étapes
+
+```typescript
+// Nouveau système de mapping unifié
+interface StepTypeResolver {
+  resolveParameterConfig(step: Step): ParameterConfig[];
+  isVWBCatalogAction(step: Step): boolean;
+  getVWBActionId(step: Step): string | null;
+  normalizeStepType(stepType: string): StepType | null;
+}
+
+// Implémentation du résolveur
+class StepTypeResolverImpl implements StepTypeResolver {
+  private readonly typeMapping = new Map<string, StepType>();
+  private readonly vwbActionIds = new Set<string>();
+  
+  constructor() {
+    this.initializeTypeMappings();
+  }
+  
+  private initializeTypeMappings() {
+    // Mapping explicite des types d'étapes
+    this.typeMapping.set('click', 'click');
+    this.typeMapping.set('type', 'type');
+    this.typeMapping.set('wait', 'wait');
+    // ... autres mappings
+    
+    // Actions VWB du catalogue
+    this.vwbActionIds.add('click_anchor');
+    this.vwbActionIds.add('type_text');
+    this.vwbActionIds.add('type_secret');
+    // ... autres actions VWB
+  }
+}
+```
+
+### 2. Refactoring du PropertiesPanel
+
+```typescript
+// Nouvelle logique de résolution des paramètres
+const PropertiesPanel: React.FC<PropertiesPanelProps> = ({ selectedStep, ... }) => {
+  const stepTypeResolver = useStepTypeResolver();
+  const { vwbAction, isLoading } = useVWBActionDetails(selectedStep);
+  
+  // Résolution unifiée des paramètres
+  const parameterConfig = useMemo(() => {
+    if (!selectedStep) return [];
+    
+    // Log pour débogage
+    console.log('🔍 Résolution paramètres pour étape:', {
+      id: selectedStep.id,
+      type: selectedStep.type,
+      data: selectedStep.data
+    });
+    
+    return stepTypeResolver.resolveParameterConfig(selectedStep);
+  }, [selectedStep, stepTypeResolver]);
+  
+  // Détection VWB améliorée
+  const isVWBAction = useMemo(() => {
+    if (!selectedStep) return false;
+    return stepTypeResolver.isVWBCatalogAction(selectedStep);
+  }, [selectedStep, stepTypeResolver]);
+  
+  // Rendu conditionnel amélioré
+  return (
+    <Box>
+      {/* Debug info en mode développement */}
+      {process.env.NODE_ENV === 'development' && (
+        <DebugPanel 
+          step={selectedStep}
+          parameterConfig={parameterConfig}
+          isVWBAction={isVWBAction}
+        />
+      )}
+      
+      {/* Contenu principal */}
+      {isVWBAction && vwbAction ? (
+        <VWBActionProperties
+          action={vwbAction}
+          parameters={localParameters}
+          variables={variables}
+          onParameterChange={handleVWBParameterChange}
+          onValidationChange={handleVWBValidationChange}
+        />
+      ) : parameterConfig.length > 0 ? (
+        <StandardParametersEditor
+          config={parameterConfig}
+          parameters={localParameters}
+          variables={variables}
+          onParameterChange={handleParameterChange}
+        />
+      ) : (
+        <EmptyStateMessage stepType={selectedStep?.type} />
+      )}
+    </Box>
+  );
+};
+```
+
+### 3. Amélioration des Hooks VWB
+
+```typescript
+// Hook de résolution des types d'étapes
+export const useStepTypeResolver = (): StepTypeResolver => {
+  return useMemo(() => new StepTypeResolverImpl(), []);
+};
+
+// Hook amélioré pour les détails d'actions VWB
+export const useVWBActionDetails = (step: Step | null) => {
+  const [vwbAction, setVwbAction] = useState<VWBCatalogAction | null>(null);
+  const [isLoading, setIsLoading] = useState(false);
+  const [error, setError] = useState<string | null>(null);
+  
+  const stepTypeResolver = useStepTypeResolver();
+  
+  useEffect(() => {
+    const loadVWBAction = async () => {
+      if (!step || !stepTypeResolver.isVWBCatalogAction(step)) {
+        setVwbAction(null);
+        return;
+      }
+      
+      const actionId = stepTypeResolver.getVWBActionId(step);
+      if (!actionId) {
+        setVwbAction(null);
+        return;
+      }
+      
+      setIsLoading(true);
+      setError(null);
+      
+      try {
+        // Essayer le catalogue dynamique d'abord
+        let action = await catalogService.getActionDetails(actionId);
+        
+        // Fallback vers le catalogue statique
+        if (!action) {
+          action = getStaticActionById(actionId);
+        }
+        
+        setVwbAction(action);
+        
+        console.log('✅ Action VWB chargée:', {
+          actionId,
+          actionName: action?.name,
+          source: action ? 'catalogue' : 'statique'
+        });
+        
+      } catch (err) {
+        const errorMessage = err instanceof Error ? err.message : 'Erreur inconnue';
+        setError(errorMessage);
+        console.error('❌ Erreur chargement action VWB:', err);
+      } finally {
+        setIsLoading(false);
+      }
+    };
+    
+    loadVWBAction();
+  }, [step, stepTypeResolver]);
+  
+  return { vwbAction, isLoading, error };
+};
+```
+
+### 4. Composant de Débogage
+
+```typescript
+// Composant pour diagnostiquer les problèmes de mapping
+const DebugPanel: React.FC<{
+  step: Step | null;
+  parameterConfig: ParameterConfig[];
+  isVWBAction: boolean;
+}> = ({ step, parameterConfig, isVWBAction }) => {
+  if (!step) return null;
+  
+  return (
+    <Accordion>
+      <AccordionSummary expandIcon={<ExpandMoreIcon />}>
+        <Typography variant="caption" color="primary">
+          🔧 Debug Info (Dev Mode)
+        </Typography>
+      </AccordionSummary>
+      <AccordionDetails>
+        <Box sx={{ fontSize: '0.75rem', fontFamily: 'monospace' }}>
+          <Typography variant="caption" display="block">
+            <strong>Step ID:</strong> {step.id}
+          </Typography>
+          <Typography variant="caption" display="block">
+            <strong>Step Type:</strong> {step.type}
+          </Typography>
+          <Typography variant="caption" display="block">
+            <strong>Is VWB Action:</strong> {isVWBAction ? 'Yes' : 'No'}
+          </Typography>
+          <Typography variant="caption" display="block">
+            <strong>Parameter Config Count:</strong> {parameterConfig.length}
+          </Typography>
+          <Typography variant="caption" display="block">
+            <strong>Step Data:</strong>
+          </Typography>
+          <pre style={{ fontSize: '0.7rem', margin: '4px 0' }}>
+            {JSON.stringify(step.data, null, 2)}
+          </pre>
+          <Typography variant="caption" display="block">
+            <strong>Available Step Types in Config:</strong>
+          </Typography>
+          <pre style={{ fontSize: '0.7rem', margin: '4px 0' }}>
+            {JSON.stringify(Object.keys(stepParametersConfig), null, 2)}
+          </pre>
+        </Box>
+      </AccordionDetails>
+    </Accordion>
+  );
+};
+```
+
+### 5. Composant d'État Vide Amélioré
+
+```typescript
+// Message d'état vide avec diagnostic
+const EmptyStateMessage: React.FC<{ stepType?: string }> = ({ stepType }) => {
+  return (
+    <Alert severity="warning" sx={{ m: 2 }}>
+      <AlertTitle>Aucun paramètre configurable</AlertTitle>
+      <Typography variant="body2" gutterBottom>
+        Cette étape n'a pas de paramètres configurables.
+      </Typography>
+      {stepType && (
+        <Typography variant="caption" color="text.secondary">
+          Type d'étape : <code>{stepType}</code>
+        </Typography>
+      )}
+      <Typography variant="caption" display="block" sx={{ mt: 1 }}>
+        Si vous pensez que c'est une erreur, vérifiez la configuration des types d'étapes.
+      </Typography>
+    </Alert>
+  );
+};
+```
+
+## Stratégie de Migration
+
+### Phase 1 : Diagnostic et Logging
+1. Ajouter des logs détaillés dans `getParameterConfig()`
+2. Créer le composant `DebugPanel` pour visualiser les problèmes
+3. Identifier tous les cas où le mapping échoue
+
+### Phase 2 : Refactoring Progressif
+1. Créer `StepTypeResolver` avec tests unitaires
+2. Migrer `PropertiesPanel` pour utiliser le nouveau résolveur
+3. Améliorer les hooks VWB avec gestion d'erreurs
+
+### Phase 3 : Validation et Optimisation
+1. Tests d'intégration complets
+2. Optimisation des performances avec mémorisation
+3. Documentation et guides utilisateur
+
+## Tests et Validation
+
+### Tests Unitaires
+
+```typescript
+describe('StepTypeResolver', () => {
+  let resolver: StepTypeResolver;
+  
+  beforeEach(() => {
+    resolver = new StepTypeResolverImpl();
+  });
+  
+  describe('resolveParameterConfig', () => {
+    it('should return click parameters for click step', () => {
+      const step: Step = {
+        id: 'test-1',
+        type: 'click',
+        name: 'Test Click',
+        position: { x: 0, y: 0 },
+        data: {},
+        executionState: StepExecutionState.IDLE,
+        validationErrors: []
+      };
+      
+      const config = resolver.resolveParameterConfig(step);
+      
+      expect(config).toHaveLength(2);
+      expect(config[0].name).toBe('target');
+      expect(config[1].name).toBe('clickType');
+    });
+    
+    it('should detect VWB catalog actions', () => {
+      const step: Step = {
+        id: 'test-2',
+        type: 'click_anchor',
+        name: 'VWB Click',
+        position: { x: 0, y: 0 },
+        data: {
+          isVWBCatalogAction: true,
+          vwbActionId: 'click_anchor'
+        },
+        executionState: StepExecutionState.IDLE,
+        validationErrors: []
+      };
+      
+      const isVWB = resolver.isVWBCatalogAction(step);
+      const actionId = resolver.getVWBActionId(step);
+      
+      expect(isVWB).toBe(true);
+      expect(actionId).toBe('click_anchor');
+    });
+  });
+});
+```
+
+### Tests d'Intégration
+
+```typescript
+describe('PropertiesPanel Integration', () => {
+  it('should display parameters for standard steps', async () => {
+    const step: Step = createMockStep('type', {
+      target: null,
+      text: 'Hello World',
+      clearFirst: true
+    });
+    
+    render(
+      <PropertiesPanel
+        selectedStep={step}
+        variables={[]}
+        onParameterChange={jest.fn()}
+        onVisualSelection={jest.fn()}
+      />
+    );
+    
+    // Vérifier que les paramètres sont affichés
+    expect(screen.getByLabelText('Champ de saisie')).toBeInTheDocument();
+    expect(screen.getByLabelText('Texte à saisir')).toBeInTheDocument();
+    expect(screen.getByLabelText('Vider le champ d\'abord')).toBeInTheDocument();
+  });
+  
+  it('should display VWB action properties', async () => {
+    const step: Step = createMockVWBStep('click_anchor');
+    
+    render(
+      <PropertiesPanel
+        selectedStep={step}
+        variables={[]}
+        onParameterChange={jest.fn()}
+        onVisualSelection={jest.fn()}
+      />
+    );
+    
+    // Attendre le chargement de l'action VWB
+    await waitFor(() => {
+      expect(screen.getByText('Cliquer sur Ancre')).toBeInTheDocument();
+    });
+    
+    // Vérifier que le composant VWB est affiché
+    expect(screen.getByText('Élément visuel à cliquer')).toBeInTheDocument();
+  });
+});
+```
+
+## Performance et Optimisation
+
+### Mémorisation des Résolutions
+
+```typescript
+// Cache pour éviter les recalculs
+const stepTypeCache = new Map<string, ParameterConfig[]>();
+
+const resolveParameterConfigCached = (step: Step): ParameterConfig[] => {
+  const cacheKey = `${step.type}_${step.data.isVWBCatalogAction}_${step.data.vwbActionId}`;
+  
+  if (stepTypeCache.has(cacheKey)) {
+    return stepTypeCache.get(cacheKey)!;
+  }
+  
+  const config = resolveParameterConfigInternal(step);
+  stepTypeCache.set(cacheKey, config);
+  
+  return config;
+};
+```
+
+### Lazy Loading des Actions VWB
+
+```typescript
+// Chargement différé des détails d'actions
+const useVWBActionDetailsLazy = (step: Step | null) => {
+  const [shouldLoad, setShouldLoad] = useState(false);
+  
+  // Ne charger que quand l'étape est sélectionnée et visible
+  useEffect(() => {
+    if (step && stepTypeResolver.isVWBCatalogAction(step)) {
+      setShouldLoad(true);
+    }
+  }, [step]);
+  
+  return useVWBActionDetails(shouldLoad ? step : null);
+};
+```
+
+## Monitoring et Observabilité
+
+### Métriques de Performance
+
+```typescript
+// Tracking des performances de résolution
+const performanceTracker = {
+  trackResolution: (stepType: string, duration: number) => {
+    console.log(`⏱️ Résolution ${stepType}: ${duration}ms`);
+    
+    // En production, envoyer à un service de monitoring
+    if (process.env.NODE_ENV === 'production') {
+      analytics.track('step_resolution_time', {
+        stepType,
+        duration,
+        timestamp: Date.now()
+      });
+    }
+  }
+};
+```
+
+### Logs Structurés
+
+```typescript
+// Système de logs pour diagnostic
+const logger = {
+  debug: (message: string, context: any) => {
+    if (process.env.NODE_ENV === 'development') {
+      console.log(`🔍 [PropertiesPanel] ${message}`, context);
+    }
+  },
+  
+  error: (message: string, error: Error, context: any) => {
+    console.error(`❌ [PropertiesPanel] ${message}`, { error, context });
+  },
+  
+  info: (message: string, context: any) => {
+    console.log(`ℹ️ [PropertiesPanel] ${message}`, context);
+  }
+};
+```
+
+## Sécurité et Robustesse
+
+### Validation des Types
+
+```typescript
+// Validation stricte des types d'étapes
+const validateStepType = (step: Step): boolean => {
+  if (!step || !step.type) {
+    logger.error('Step invalide', new Error('Step ou type manquant'), { step });
+    return false;
+  }
+  
+  if (typeof step.type !== 'string') {
+    logger.error('Type d\'étape invalide', new Error('Type doit être string'), { 
+      stepType: step.type,
+      stepId: step.id 
+    });
+    return false;
+  }
+  
+  return true;
+};
+```
+
+### Gestion d'Erreurs Gracieuse
+
+```typescript
+// Fallback en cas d'erreur de résolution
+const resolveParameterConfigSafe = (step: Step): ParameterConfig[] => {
+  try {
+    if (!validateStepType(step)) {
+      return [];
+    }
+    
+    return resolveParameterConfig(step);
+  } catch (error) {
+    logger.error('Erreur résolution paramètres', error as Error, { 
+      stepId: step.id,
+      stepType: step.type 
+    });
+    
+    // Retourner une configuration minimale en cas d'erreur
+    return [{
+      name: 'error_fallback',
+      label: 'Configuration en erreur',
+      type: 'text',
+      required: false,
+      description: 'Une erreur est survenue lors du chargement des paramètres.'
+    }];
+  }
+};
+```
+
+Cette architecture garantit une résolution robuste et performante des propriétés d'étapes, avec une observabilité complète pour faciliter le débogage et la maintenance.

.kiro/specs/correction-proprietes-etapes-vides/requirements.md

@@ -0,0 +1,216 @@
+# Correction des Propriétés d'Étapes Vides - Spécifications
+
+**Auteur :** Dom, Alice, Kiro  
+**Date :** 12 janvier 2026  
+**Version :** 1.0.0
+
+## Problème Identifié
+
+Le système de propriétés d'étapes du Visual Workflow Builder affiche systématiquement "Cette étape n'a pas de paramètres configurables" même pour les étapes qui devraient avoir des paramètres (comme `type_text`, `click_anchor`, etc.).
+
+### Analyse du Problème
+
+1. **Code existant fonctionnel** : Les composants `PropertiesPanel` et `VWBActionProperties` sont correctement implémentés
+2. **Configuration complète** : La configuration `stepParametersConfig` contient tous les types d'étapes standard
+3. **Problème de mapping** : La fonction `getParameterConfig()` retourne un tableau vide car le mapping entre `selectedStep.type` et `stepParametersConfig` ne fonctionne pas
+4. **Détection VWB défaillante** : La logique de détection des actions VWB du catalogue ne fonctionne pas correctement
+
+### Causes Racines Identifiées
+
+1. **Incohérence des types d'étapes** : Les types d'étapes créées ne correspondent pas aux clés de `stepParametersConfig`
+2. **Logique de détection VWB** : Les hooks `useIsVWBStep` et `useVWBActionId` ne détectent pas correctement les actions du catalogue
+3. **Mapping défaillant** : La correspondance entre les étapes du canvas et les configurations de paramètres est rompue
+
+## User Stories
+
+### US-1 : Affichage des Propriétés Standard
+**En tant qu'utilisateur**, je veux voir les propriétés configurables pour les étapes standard (click, type, wait, etc.) **afin de** pouvoir configurer correctement mes workflows.
+
+**Critères d'acceptation :**
+- Les étapes `click` affichent les paramètres `target` et `clickType`
+- Les étapes `type` affichent les paramètres `target`, `text`, et `clearFirst`
+- Les étapes `wait` affichent le paramètre `duration`
+- Tous les autres types d'étapes standard affichent leurs paramètres respectifs
+
+### US-2 : Affichage des Propriétés VWB
+**En tant qu'utilisateur**, je veux voir les propriétés configurables pour les actions VWB du catalogue **afin de** pouvoir utiliser les actions avancées du système.
+
+**Critères d'acceptation :**
+- Les actions `click_anchor` affichent le composant `VWBActionProperties`
+- Les actions `type_text` affichent les paramètres VWB appropriés
+- La détection des actions VWB fonctionne correctement
+- Le chargement des détails d'actions depuis le catalogue fonctionne
+
+### US-3 : Validation en Temps Réel
+**En tant qu'utilisateur**, je veux que les paramètres soient validés en temps réel **afin de** détecter les erreurs avant l'exécution.
+
+**Critères d'acceptation :**
+- Les paramètres requis sont marqués comme obligatoires
+- Les erreurs de validation s'affichent immédiatement
+- Les suggestions d'amélioration sont proposées
+- L'état de validation global est visible
+
+### US-4 : Persistance des Paramètres
+**En tant qu'utilisateur**, je veux que mes paramètres soient sauvegardés automatiquement **afin de** ne pas perdre ma configuration.
+
+**Critères d'acceptation :**
+- Les changements de paramètres sont sauvegardés immédiatement
+- La configuration persiste lors du changement d'étape
+- Les valeurs par défaut sont appliquées correctement
+- L'état est synchronisé avec le store Redux
+
+## Exigences Techniques
+
+### Correction de la Logique de Mapping
+
+1. **Normalisation des types d'étapes**
+   - Standardiser les types d'étapes entre le canvas et la configuration
+   - Créer un mapping explicite entre les types d'étapes et les configurations
+   - Gérer les cas spéciaux (actions VWB vs étapes standard)
+
+2. **Amélioration de la détection VWB**
+   - Corriger les hooks `useIsVWBStep` et `useVWBActionId`
+   - Implémenter une détection robuste basée sur les métadonnées d'étape
+   - Gérer le fallback vers les configurations standard
+
+3. **Validation de la configuration**
+   - Vérifier que `stepParametersConfig` contient toutes les configurations nécessaires
+   - Ajouter des logs de débogage pour tracer le processus de résolution
+   - Implémenter des tests unitaires pour la logique de mapping
+
+### Architecture de la Solution
+
+```typescript
+// Structure de données normalisée
+interface StepTypeMapping {
+  standardTypes: Record<StepType, ParameterConfig[]>;
+  vwbTypes: Set<string>;
+  typeNormalizer: (stepType: string) => StepType | null;
+  isVWBType: (stepType: string) => boolean;
+}
+
+// Logique de résolution améliorée
+function resolveParameterConfig(step: Step): ParameterConfig[] {
+  // 1. Normaliser le type d'étape
+  // 2. Vérifier si c'est une action VWB
+  // 3. Retourner la configuration appropriée
+  // 4. Logger le processus pour débogage
+}
+```
+
+### Composants à Modifier
+
+1. **PropertiesPanel/index.tsx**
+   - Corriger la fonction `getParameterConfig()`
+   - Améliorer la logique de détection VWB
+   - Ajouter des logs de débogage
+
+2. **hooks/useVWBStepIntegration.ts**
+   - Corriger `useIsVWBStep` et `useVWBActionId`
+   - Améliorer la détection basée sur les métadonnées
+   - Gérer les cas edge
+
+3. **types/index.ts**
+   - Standardiser les types d'étapes
+   - Ajouter des métadonnées pour la détection VWB
+   - Créer des types utilitaires pour le mapping
+
+## Critères d'Acceptation Globaux
+
+### Fonctionnels
+- [ ] Toutes les étapes standard affichent leurs propriétés configurables
+- [ ] Toutes les actions VWB du catalogue affichent le composant spécialisé
+- [ ] La validation en temps réel fonctionne correctement
+- [ ] Les paramètres sont persistés automatiquement
+- [ ] L'interface est responsive et accessible
+
+### Techniques
+- [ ] Aucune erreur TypeScript dans la compilation
+- [ ] Tous les tests unitaires passent
+- [ ] Les tests d'intégration valident le comportement end-to-end
+- [ ] La performance reste optimale (< 100ms pour l'affichage)
+- [ ] Le code respecte les conventions du projet
+
+### Qualité
+- [ ] Code documenté en français avec attribution auteur
+- [ ] Tests couvrant tous les cas d'usage
+- [ ] Gestion d'erreurs robuste
+- [ ] Logs de débogage appropriés
+- [ ] Compatibilité avec l'architecture existante
+
+## Contraintes
+
+### Techniques
+- Maintenir la compatibilité avec l'architecture React + TypeScript existante
+- Respecter les patterns Material-UI établis
+- Conserver les performances actuelles
+- Assurer la thread-safety pour les hooks
+
+### Fonctionnelles
+- Ne pas casser les workflows existants
+- Maintenir la compatibilité avec le catalogue d'actions
+- Préserver l'expérience utilisateur actuelle
+- Respecter les conventions d'accessibilité
+
+### Organisationnelles
+- Documentation en français obligatoire
+- Attribution auteur "Dom, Alice, Kiro" avec date
+- Tests dans le répertoire `tests/`
+- Documentation dans le répertoire `docs/`
+
+## Définition de "Terminé"
+
+La correction est considérée comme terminée quand :
+
+1. **Validation fonctionnelle**
+   - Toutes les étapes affichent leurs propriétés configurables
+   - La validation en temps réel fonctionne
+   - Les paramètres sont persistés correctement
+
+2. **Validation technique**
+   - Compilation TypeScript sans erreur
+   - Tous les tests passent (unitaires + intégration)
+   - Performance maintenue
+
+3. **Validation qualité**
+   - Code documenté et testé
+   - Respect des conventions du projet
+   - Documentation utilisateur mise à jour
+
+4. **Validation utilisateur**
+   - Interface intuitive et responsive
+   - Pas de régression fonctionnelle
+   - Expérience utilisateur améliorée
+
+## Risques et Mitigation
+
+### Risques Identifiés
+
+1. **Régression fonctionnelle** : Les modifications pourraient casser des fonctionnalités existantes
+   - *Mitigation* : Tests de régression complets avant déploiement
+
+2. **Performance dégradée** : La logique de détection pourrait être coûteuse
+   - *Mitigation* : Optimisation avec mémorisation et cache
+
+3. **Complexité accrue** : La logique de mapping pourrait devenir complexe
+   - *Mitigation* : Refactoring en composants simples et testables
+
+4. **Incompatibilité TypeScript** : Les changements de types pourraient créer des erreurs
+   - *Mitigation* : Migration progressive avec validation continue
+
+## Métriques de Succès
+
+### Métriques Fonctionnelles
+- **Taux d'affichage des propriétés** : 100% des étapes affichent leurs propriétés
+- **Temps de réponse** : < 100ms pour l'affichage des propriétés
+- **Taux d'erreur** : 0% d'erreurs dans la console lors de l'utilisation
+
+### Métriques Techniques
+- **Couverture de tests** : > 90% pour les composants modifiés
+- **Compilation TypeScript** : 0 erreur, 0 warning
+- **Performance** : Pas de régression mesurable
+
+### Métriques Qualité
+- **Documentation** : 100% des fonctions documentées
+- **Conventions** : 100% de respect des conventions projet
+- **Accessibilité** : Conformité WCAG 2.1 AA maintenue

.kiro/specs/correction-proprietes-etapes-vides/tasks.md

@@ -0,0 +1,341 @@
+# Tâches - Correction des Propriétés d'Étapes Vides
+
+**Auteur :** Dom, Alice, Kiro  
+**Date :** 12 janvier 2026  
+**Version :** 1.0.0
+
+## Phase 1 : Diagnostic et Analyse (Priorité Critique)
+
+### Tâche 1.1 : Diagnostic Approfondi du Problème
+- [x] **1.1.1** Créer un script de diagnostic pour analyser le mapping des types d'étapes
+- [x] **1.1.2** Ajouter des logs détaillés dans `getParameterConfig()` pour tracer l'exécution
+- [x] **1.1.3** Créer un composant `DebugPanel` pour visualiser les données d'étapes en temps réel
+- [x] **1.1.4** Identifier tous les cas où `stepParametersConfig[selectedStep.type]` retourne `undefined`
+- [x] **1.1.5** Documenter les incohérences entre types d'étapes créées et configurations disponibles
+
+**Critères d'acceptation :**
+- Script de diagnostic exécutable avec rapport détaillé
+- Logs structurés permettant de tracer le problème
+- Composant de debug fonctionnel en mode développement
+- Documentation complète des cas d'échec identifiés
+
+### Tâche 1.2 : Validation de l'Architecture Existante
+- [ ] **1.2.1** Auditer la configuration `stepParametersConfig` pour vérifier sa complétude
+- [ ] **1.2.2** Tester les hooks `useIsVWBStep` et `useVWBActionId` avec différents types d'étapes
+- [ ] **1.2.3** Valider le fonctionnement du composant `VWBActionProperties` isolément
+- [ ] **1.2.4** Vérifier la cohérence des types TypeScript entre les composants
+- [ ] **1.2.5** Identifier les dépendances manquantes ou incorrectes
+
+**Critères d'acceptation :**
+- Rapport d'audit complet de l'architecture
+- Tests unitaires validant chaque composant individuellement
+- Documentation des incohérences TypeScript trouvées
+- Plan de correction des dépendances identifiées
+
+## Phase 2 : Implémentation du Résolveur de Types (Priorité Haute)
+
+### Tâche 2.1 : Création du StepTypeResolver
+- [x] **2.1.1** Implémenter l'interface `StepTypeResolver` avec la logique de mapping unifiée
+- [x] **2.1.2** Créer la classe `StepTypeResolverImpl` avec mapping explicite des types d'étapes
+- [x] **2.1.3** Implémenter la méthode `resolveParameterConfig()` avec gestion des cas edge
+- [x] **2.1.4** Ajouter la détection robuste des actions VWB du catalogue
+- [x] **2.1.5** Implémenter le cache de résolution pour optimiser les performances
+
+**Critères d'acceptation :**
+- Interface `StepTypeResolver` complètement implémentée
+- Mapping explicite de tous les types d'étapes standard et VWB
+- Gestion d'erreurs gracieuse avec fallbacks appropriés
+- Cache de résolution fonctionnel avec invalidation intelligente
+- Tests unitaires couvrant tous les cas d'usage
+
+### Tâche 2.2 : Intégration du Hook useStepTypeResolver
+- [x] **2.2.1** Créer le hook `useStepTypeResolver` avec mémorisation appropriée
+- [x] **2.2.2** Implémenter la logique de résolution thread-safe
+- [x] **2.2.3** Ajouter la gestion des erreurs et des états de chargement
+- [x] **2.2.4** Optimiser les performances avec `useMemo` et `useCallback`
+- [x] **2.2.5** Intégrer les logs de débogage structurés
+
+**Critères d'acceptation :**
+- Hook fonctionnel avec API stable
+- Gestion d'état robuste (loading, error, success)
+- Performance optimisée sans re-rendus inutiles
+- Logs de débogage informatifs et structurés
+- Tests d'intégration validant le comportement
+
+### Tâche 2.3 : Test de Compilation TypeScript et Build
+- [x] **2.3.1** Exécuter `npx tsc --noEmit` pour vérifier l'absence d'erreurs TypeScript
+- [x] **2.3.2** Lancer `npm run build` pour valider la compilation de production
+- [x] **2.3.3** Vérifier que les fichiers générés sont corrects et optimisés
+- [x] **2.3.4** Valider les types TypeScript avec les nouveaux composants
+- [x] **2.3.5** Corriger toute erreur de compilation identifiée
+
+**Critères d'acceptation :**
+- Compilation TypeScript sans erreur ni warning
+- Build de production réussi avec taille optimisée
+- Tous les types TypeScript correctement inférés
+- Aucune régression dans les imports/exports existants
+
+## Phase 3 : Refactoring du PropertiesPanel (Priorité Haute)
+
+### Tâche 3.1 : Modification du Composant Principal
+- [x] **3.1.1** Refactorer `PropertiesPanel/index.tsx` pour utiliser le nouveau résolveur
+- [x] **3.1.2** Remplacer la logique `getParameterConfig()` par la résolution unifiée
+- [x] **3.1.3** Améliorer la détection des actions VWB avec le nouveau système
+- [x] **3.1.4** Intégrer le composant `DebugPanel` en mode développement
+- [x] **3.1.5** Optimiser le rendu conditionnel pour éviter les re-rendus inutiles
+
+**Critères d'acceptation :**
+- [x] Composant `PropertiesPanel` entièrement refactorisé
+- [x] Logique de résolution unifiée et robuste
+- [x] Détection VWB fonctionnelle à 100%
+- [x] Debug panel intégré et fonctionnel
+- [x] Performance maintenue ou améliorée
+
+### Tâche 3.2 : Amélioration des Hooks VWB
+- [x] **3.2.1** Refactorer `useVWBStepIntegration` avec la nouvelle logique de détection
+- [x] **3.2.2** Créer le hook `useVWBActionDetails` avec chargement lazy et gestion d'erreurs
+- [x] **3.2.3** Implémenter le fallback vers le catalogue statique en cas d'échec
+- [x] **3.2.4** Ajouter la validation des données d'actions chargées
+- [x] **3.2.5** Optimiser les appels API avec cache et debouncing
+
+**Critères d'acceptation :**
+- [x] Hooks VWB entièrement refactorisés et testés
+- [x] Chargement lazy fonctionnel avec états appropriés
+- [x] Fallback vers catalogue statique opérationnel
+- [x] Validation robuste des données d'actions
+- [x] Performance optimisée avec cache intelligent
+
+### Tâche 3.3 : Test de Compilation TypeScript et Build
+- [x] **3.3.1** Exécuter `npx tsc --noEmit` pour vérifier l'absence d'erreurs TypeScript
+- [x] **3.3.2** Lancer `npm run build` pour valider la compilation de production
+- [x] **3.3.3** Vérifier que les fichiers générés sont corrects et optimisés
+- [x] **3.3.4** Valider les types TypeScript avec les composants modifiés
+- [x] **3.3.5** Corriger toute erreur de compilation identifiée
+
+**Critères d'acceptation :**
+- [x] Compilation TypeScript sans erreur ni warning
+- [x] Build de production réussi avec taille optimisée
+- [x] Tous les types TypeScript correctement inférés
+- [x] Aucune régression dans les imports/exports existants
+
+## Phase 4 : Composants Utilitaires et UX (Priorité Moyenne)
+
+### Tâche 4.1 : Création des Composants Utilitaires
+- [ ] **4.1.1** Implémenter le composant `StandardParametersEditor` pour les étapes standard
+- [ ] **4.1.2** Créer le composant `EmptyStateMessage` avec diagnostic amélioré
+- [ ] **4.1.3** Développer le composant `DebugPanel` avec informations détaillées
+- [ ] **4.1.4** Implémenter le composant `LoadingState` pour les chargements d'actions VWB
+- [ ] **4.1.5** Créer le composant `ErrorBoundary` pour la gestion d'erreurs gracieuse
+
+**Critères d'acceptation :**
+- Tous les composants utilitaires implémentés et testés
+- Interface utilisateur cohérente et accessible
+- Gestion d'erreurs gracieuse dans tous les cas
+- Messages d'aide informatifs pour les utilisateurs
+- Composants réutilisables et bien documentés
+
+### Tâche 4.2 : Amélioration de l'Expérience Utilisateur
+- [ ] **4.2.1** Ajouter des indicateurs de chargement pour les actions VWB
+- [ ] **4.2.2** Implémenter des messages d'erreur informatifs et actionnables
+- [ ] **4.2.3** Créer des tooltips explicatifs pour les paramètres complexes
+- [ ] **4.2.4** Ajouter la validation en temps réel avec feedback visuel
+- [ ] **4.2.5** Optimiser la responsivité sur différentes tailles d'écran
+
+**Critères d'acceptation :**
+- Interface utilisateur fluide et intuitive
+- Feedback visuel approprié pour tous les états
+- Messages d'aide contextuels et utiles
+- Validation en temps réel fonctionnelle
+- Compatibilité mobile et desktop assurée
+
+### Tâche 4.3 : Test de Compilation TypeScript et Build
+- [ ] **4.3.1** Exécuter `npx tsc --noEmit` pour vérifier l'absence d'erreurs TypeScript
+- [ ] **4.3.2** Lancer `npm run build` pour valider la compilation de production
+- [ ] **4.3.3** Vérifier que les fichiers générés sont corrects et optimisés
+- [ ] **4.3.4** Valider les types TypeScript avec les nouveaux composants
+- [ ] **4.3.5** Corriger toute erreur de compilation identifiée
+
+**Critères d'acceptation :**
+- Compilation TypeScript sans erreur ni warning
+- Build de production réussi avec taille optimisée
+- Tous les types TypeScript correctement inférés
+- Aucune régression dans les imports/exports existants
+
+## Phase 5 : Tests et Validation (Priorité Haute)
+
+### Tâche 5.1 : Tests Unitaires Complets
+- [ ] **5.1.1** Créer les tests unitaires pour `StepTypeResolver` avec tous les cas d'usage
+- [ ] **5.1.2** Tester les hooks `useStepTypeResolver` et `useVWBActionDetails`
+- [ ] **5.1.3** Valider le comportement du `PropertiesPanel` refactorisé
+- [ ] **5.1.4** Tester la gestion d'erreurs et les cas edge
+- [ ] **5.1.5** Atteindre une couverture de tests > 90% pour les composants modifiés
+
+**Critères d'acceptation :**
+- Suite de tests unitaires complète et robuste
+- Couverture de tests > 90% pour tous les composants modifiés
+- Tests des cas d'erreur et des cas edge
+- Tests de performance pour les opérations critiques
+- Documentation des tests et des cas couverts
+
+### Tâche 5.2 : Tests d'Intégration End-to-End
+- [ ] **5.2.1** Créer des tests d'intégration pour le workflow complet de configuration
+- [ ] **5.2.2** Tester l'interaction entre `PropertiesPanel` et les autres composants
+- [ ] **5.2.3** Valider le chargement et l'affichage des actions VWB du catalogue
+- [ ] **5.2.4** Tester la persistance des paramètres et la synchronisation d'état
+- [ ] **5.2.5** Valider la compatibilité avec les workflows existants
+
+**Critères d'acceptation :**
+- Tests d'intégration couvrant tous les workflows utilisateur
+- Validation de l'interaction entre composants
+- Tests de régression pour les fonctionnalités existantes
+- Validation de la persistance des données
+- Compatibilité ascendante assurée
+
+### Tâche 5.3 : Test de Compilation TypeScript et Build
+- [ ] **5.3.1** Exécuter `npx tsc --noEmit` pour vérifier l'absence d'erreurs TypeScript
+- [ ] **5.3.2** Lancer `npm run build` pour valider la compilation de production
+- [ ] **5.3.3** Vérifier que les fichiers générés sont corrects et optimisés
+- [ ] **5.3.4** Valider les types TypeScript avec tous les tests
+- [ ] **5.3.5** Corriger toute erreur de compilation identifiée
+
+**Critères d'acceptation :**
+- Compilation TypeScript sans erreur ni warning
+- Build de production réussi avec taille optimisée
+- Tous les types TypeScript correctement inférés
+- Aucune régression dans les imports/exports existants
+
+## Phase 6 : Performance et Optimisation (Priorité Moyenne)
+
+### Tâche 6.1 : Optimisation des Performances
+- [ ] **6.1.1** Implémenter la mémorisation pour les résolutions de types coûteuses
+- [ ] **6.1.2** Optimiser le chargement des actions VWB avec lazy loading
+- [ ] **6.1.3** Ajouter un cache intelligent pour les configurations de paramètres
+- [ ] **6.1.4** Minimiser les re-rendus avec `React.memo` et `useMemo`
+- [ ] **6.1.5** Profiler et optimiser les goulots d'étranglement identifiés
+
+**Critères d'acceptation :**
+- Temps de réponse < 100ms pour l'affichage des propriétés
+- Réduction des re-rendus inutiles > 50%
+- Cache intelligent avec invalidation appropriée
+- Profiling montrant des améliorations mesurables
+- Pas de régression de performance sur les autres composants
+
+### Tâche 6.2 : Monitoring et Observabilité
+- [ ] **6.2.1** Implémenter des métriques de performance pour les résolutions de types
+- [ ] **6.2.2** Ajouter des logs structurés pour le débogage en production
+- [ ] **6.2.3** Créer un système d'alertes pour les erreurs de résolution
+- [ ] **6.2.4** Implémenter le tracking des erreurs utilisateur
+- [ ] **6.2.5** Ajouter des métriques d'usage pour l'amélioration continue
+
+**Critères d'acceptation :**
+- Système de métriques fonctionnel et informatif
+- Logs structurés permettant le débogage efficace
+- Alertes configurées pour les erreurs critiques
+- Tracking d'erreurs intégré et fonctionnel
+- Dashboard de métriques accessible aux développeurs
+
+### Tâche 6.3 : Test de Compilation TypeScript et Build
+- [ ] **6.3.1** Exécuter `npx tsc --noEmit` pour vérifier l'absence d'erreurs TypeScript
+- [ ] **6.3.2** Lancer `npm run build` pour valider la compilation de production
+- [ ] **6.3.3** Vérifier que les fichiers générés sont corrects et optimisés
+- [ ] **6.3.4** Valider les types TypeScript avec les optimisations
+- [ ] **6.3.5** Corriger toute erreur de compilation identifiée
+
+**Critères d'acceptation :**
+- Compilation TypeScript sans erreur ni warning
+- Build de production réussi avec taille optimisée
+- Tous les types TypeScript correctement inférés
+- Aucune régression dans les imports/exports existants
+
+## Phase 7 : Documentation et Finalisation (Priorité Basse)
+
+### Tâche 7.1 : Documentation Technique Complète
+- [ ] **7.1.1** Documenter l'architecture du nouveau système de résolution
+- [ ] **7.1.2** Créer un guide de débogage pour les problèmes de propriétés
+- [ ] **7.1.3** Documenter les APIs des nouveaux hooks et composants
+- [ ] **7.1.4** Créer des exemples d'usage pour les développeurs
+- [ ] **7.1.5** Mettre à jour la documentation existante avec les changements
+
+**Critères d'acceptation :**
+- Documentation technique complète et à jour
+- Guide de débogage pratique et utilisable
+- APIs documentées avec exemples d'usage
+- Exemples de code fonctionnels et testés
+- Documentation existante mise à jour
+
+### Tâche 7.2 : Guide Utilisateur et Formation
+- [ ] **7.2.1** Créer un guide utilisateur pour la configuration des propriétés
+- [ ] **7.2.2** Documenter les nouvelles fonctionnalités et améliorations
+- [ ] **7.2.3** Créer des tutoriels vidéo pour les cas d'usage complexes
+- [ ] **7.2.4** Préparer la formation pour l'équipe de support
+- [ ] **7.2.5** Mettre à jour les FAQ avec les nouvelles informations
+
+**Critères d'acceptation :**
+- Guide utilisateur complet et accessible
+- Documentation des nouvelles fonctionnalités
+- Tutoriels vidéo informatifs et de qualité
+- Formation équipe de support préparée
+- FAQ mise à jour avec informations pertinentes
+
+### Tâche 7.3 : Test de Compilation TypeScript et Build Final
+- [ ] **7.3.1** Exécuter `npx tsc --noEmit` pour vérifier l'absence d'erreurs TypeScript
+- [ ] **7.3.2** Lancer `npm run build` pour valider la compilation de production finale
+- [ ] **7.3.3** Vérifier que les fichiers générés sont corrects et optimisés
+- [ ] **7.3.4** Valider les types TypeScript avec toute la documentation
+- [ ] **7.3.5** Corriger toute erreur de compilation identifiée
+
+**Critères d'acceptation :**
+- Compilation TypeScript sans erreur ni warning
+- Build de production réussi avec taille optimisée
+- Tous les types TypeScript correctement inférés
+- Aucune régression dans les imports/exports existants
+
+## Critères de Validation Globaux
+
+### Validation Fonctionnelle
+- [ ] Toutes les étapes standard affichent leurs propriétés configurables
+- [ ] Toutes les actions VWB du catalogue affichent le composant spécialisé
+- [ ] La validation en temps réel fonctionne correctement
+- [ ] Les paramètres sont persistés automatiquement
+- [ ] L'interface est responsive et accessible
+
+### Validation Technique
+- [ ] Compilation TypeScript sans erreur (validée à chaque phase)
+- [ ] Tous les tests unitaires et d'intégration passent
+- [ ] Performance maintenue ou améliorée
+- [ ] Code documenté en français avec attribution auteur
+- [ ] Respect des conventions du projet
+
+### Validation Qualité
+- [ ] Couverture de tests > 90%
+- [ ] Gestion d'erreurs robuste
+- [ ] Logs de débogage appropriés
+- [ ] Documentation complète et à jour
+- [ ] Compatibilité avec l'architecture existante
+
+## Estimation et Priorités
+
+### Estimation Temporelle
+- **Phase 1** : 1-2 jours (Critique)
+- **Phase 2** : 2-3 jours (Haute)
+- **Phase 3** : 2-3 jours (Haute)
+- **Phase 4** : 1-2 jours (Moyenne)
+- **Phase 5** : 2-3 jours (Haute)
+- **Phase 6** : 1-2 jours (Moyenne)
+- **Phase 7** : 1 jour (Basse)
+
+**Total estimé** : 10-16 jours
+
+### Dépendances Critiques
+- Phase 1 doit être complétée avant Phase 2
+- Phase 2 doit être complétée avant Phase 3
+- Phase 5 peut commencer en parallèle de Phase 4
+- Phase 6 et 7 peuvent être exécutées en parallèle
+
+### Risques et Mitigation
+- **Risque** : Régression fonctionnelle
+  - **Mitigation** : Tests de régression complets à chaque phase
+- **Risque** : Performance dégradée
+  - **Mitigation** : Profiling continu et optimisation proactive
+- **Risque** : Complexité accrue
+  - **Mitigation** : Refactoring progressif avec validation continue