diff --git a/SELECTIVE_ENHANCEMENT_GUIDE.md b/SELECTIVE_ENHANCEMENT_GUIDE.md
new file mode 100644
index 0000000..179816d
--- /dev/null
+++ b/SELECTIVE_ENHANCEMENT_GUIDE.md
@@ -0,0 +1,239 @@
+# 📘 Guide du Selective Enhancement
+
+## 🎯 Qu'est-ce que c'est ?
+
+Le **Selective Enhancement** est un système modulaire qui améliore le contenu généré en appliquant des **couches d'amélioration** successives. Chaque couche utilise un LLM différent spécialisé pour un type d'amélioration.
+
+---
+
+## 🏗️ Architecture en 3 niveaux
+
+### Niveau 1 : Les Stacks Prédéfinis
+Ce sont des **"recettes"** qui définissent quelles couches appliquer et dans quel ordre.
+
+```javascript
+// Exemple de stack prédéfini
+{
+  name: 'standardEnhancement',
+  description: 'Amélioration technique et style (OpenAI + Mistral)',
+  layers: [
+    { type: 'technical', llm: 'gpt-4o-mini', intensity: 0.9 },
+    { type: 'style', llm: 'mistral-small', intensity: 0.8 }
+  ],
+  layersCount: 2
+}
+```
+
+### Niveau 2 : Les Couches (Layers)
+Chaque couche a 3 paramètres clés :
+
+- **type** : Ce que la couche améliore
+  - `technical` : Précision technique, termes métier
+  - `transitions` : Fluidité entre phrases
+  - `style` : Personnalité, ton, vocabulaire
+
+- **llm** : Le modèle utilisé
+  - `gpt-4o-mini` : Excellent pour précision technique
+  - `mistral-small` : Excellent pour style et personnalité
+  - `gemini-pro` : Bon pour fluidité (actuellement désactivé)
+
+- **intensity** : Force de l'amélioration (0.5 à 1.5)
+  - `0.6` : Légère amélioration
+  - `1.0` : Amélioration normale
+  - `1.2` : Amélioration forte
+
+### Niveau 3 : L'Exécution
+Quand vous choisissez un stack, voici ce qui se passe :
+
+```
+1. Charge la configuration du stack
+   └─> standardEnhancement = [technical + style]
+
+2. Applique Couche 1 : technical (gpt-4o-mini)
+   ├─ Avant : "Nos produits sont de qualité"
+   └─ Après : "Nos panneaux PMMA garantissent une durabilité optimale"
+
+3. Applique Couche 2 : style (mistral-small)
+   ├─ Avant : "Nos panneaux PMMA garantissent une durabilité optimale"
+   └─ Après : "Nos panneaux PMMA, c'est la garantie d'une durabilité qui tient dans le temps"
+
+4. Résultat final = contenu amélioré par les 2 couches
+```
+
+---
+
+## 📦 Stacks Disponibles
+
+### 1. `lightEnhancement` (Rapide)
+- **1 couche** : Technique uniquement
+- **Durée** : ~15-20s
+- **Usage** : Tests rapides, contenu déjà bon
+
+### 2. `standardEnhancement` (Équilibré) ⭐ RECOMMANDÉ
+- **2 couches** : Technique + Style
+- **Durée** : ~30-40s
+- **Usage** : Production standard, bon compromis qualité/vitesse
+
+### 3. `fullEnhancement` (Complet)
+- **2 couches** : Technique intense + Style
+- **Durée** : ~35-45s
+- **Usage** : Contenu premium, qualité maximale
+
+### 4. `personalityFocus` (Style prioritaire)
+- **2 couches** : Style fort + Technique légère
+- **Durée** : ~30-40s
+- **Usage** : Quand la personnalité est importante
+
+### 5. `adaptive` (Intelligent)
+- **Analyse automatique** du contenu
+- **Couches variables** selon les besoins détectés
+- **Durée** : Variable
+- **Usage** : Quand vous ne savez pas quoi choisir
+
+---
+
+## 🚀 Comment l'utiliser ?
+
+### Dans le code (Main.js)
+```javascript
+await handleModularWorkflow({
+  rowNumber: 2,
+  selectiveStack: 'standardEnhancement',  // ← Choisir le stack ici
+  adversarialMode: 'light',
+  source: 'production'
+});
+```
+
+### Via API
+```javascript
+POST /api/workflow/execute
+{
+  "rowNumber": 2,
+  "selectiveStack": "standardEnhancement",  // ← Choisir le stack ici
+  "adversarialMode": "light"
+}
+```
+
+### Via Interface Web
+```
+production-runner.html → Sélection stack dans le dropdown
+```
+
+---
+
+## 📊 Logs détaillés (après modification)
+
+Voici ce que vous verrez maintenant dans les logs :
+
+```
+📦 APPLICATION STACK SELECTIVE: standardEnhancement (2 couches)
+   📊 12 éléments | Description: Amélioration technique et style
+   🔍 Configuration du stack:
+      Couche 1: technical | LLM: gpt-4o-mini | Intensité: 0.9
+      Couche 2: style | LLM: mistral-small | Intensité: 0.8
+
+   🔧 === COUCHE 1/2 ===
+      Type: technical | LLM: gpt-4o-mini | Intensité: 0.9
+      Éléments en entrée: 12
+      📝 Échantillon AVANT (t0): Nos produits sont de qualité...
+      🤖 LLM spécifié: gpt-4o-mini
+      🔬 Branche: Technical Enhancement
+      📝 Config technique: LLM=gpt-4o-mini, Intensity=0.9
+      ✅ Technical enhancement terminé: 8 modifications
+      📝 Échantillon APRÈS (t0): Nos panneaux PMMA garantissent...
+      ✅ RÉSULTAT: 8 éléments modifiés (66.7% du total)
+      ⏱️  Durée: 2340ms
+
+   🔧 === COUCHE 2/2 ===
+      Type: style | LLM: mistral-small | Intensité: 0.8
+      Éléments en entrée: 12
+      📝 Échantillon AVANT (t0): Nos panneaux PMMA garantissent...
+      🤖 LLM spécifié: mistral-small
+      🎨 Branche: Style Enhancement
+      📝 Config style: LLM=mistral-small, Intensity=0.8
+      ✅ Style enhancement terminé: 6 modifications
+      📝 Échantillon APRÈS (t0): Nos panneaux PMMA, c'est la garantie...
+      ✅ RÉSULTAT: 6 éléments modifiés (50.0% du total)
+      ⏱️  Durée: 1890ms
+
+✅ === STACK SELECTIVE standardEnhancement TERMINÉ ===
+   📊 Couches réussies: 2/2
+   🔄 Modifications totales: 14
+   ⏱️  Durée totale: 4230ms
+
+   📋 RÉCAPITULATIF PAR COUCHE:
+      ✅ Couche 1: technical (gpt-4o-mini) - 8 modifs en 2340ms
+      ✅ Couche 2: style (mistral-small) - 6 modifs en 1890ms
+```
+
+---
+
+## ❓ FAQ
+
+### Q: Pourquoi 2 couches dans standardEnhancement ?
+**R:** Chaque LLM est spécialisé. GPT-4o-mini excelle en précision technique, Mistral en style. En combinant les deux, on obtient un contenu techniquement précis ET bien écrit.
+
+### Q: Quelle est la différence entre standardEnhancement et fullEnhancement ?
+**R:** fullEnhancement utilise des intensités plus fortes (1.0 au lieu de 0.9) donc des modifications plus poussées. Utile pour du contenu premium.
+
+### Q: Puis-je créer mes propres stacks ?
+**R:** Oui ! Modifiez `PREDEFINED_STACKS` dans `lib/selective-enhancement/SelectiveLayers.js`
+
+### Q: Comment savoir quel stack choisir ?
+**R:**
+- **Production standard** → `standardEnhancement`
+- **Tests rapides** → `lightEnhancement`
+- **Qualité max** → `fullEnhancement`
+- **Pas sûr** → `adaptive` (analyse automatique)
+
+### Q: Les modifications sont-elles cumulatives ?
+**R:** Oui ! Couche 1 modifie le contenu → Couche 2 modifie le résultat de Couche 1 → Résultat final = contenu doublement amélioré.
+
+---
+
+## 🔧 Configuration technique
+
+### Fichiers impliqués
+```
+lib/selective-enhancement/
+├── SelectiveCore.js       ← Moteur d'application des couches
+├── SelectiveLayers.js     ← Définition des stacks prédéfinis
+├── TechnicalLayer.js      ← Implémentation couche technique
+├── StyleLayer.js          ← Implémentation couche style
+└── TransitionLayer.js     ← Implémentation couche transitions
+```
+
+### Mapping LLM → Type de couche
+```javascript
+{
+  'technical': 'gpt-4o-mini',      // Précision technique
+  'transitions': 'gemini-pro',     // Fluidité (désactivé)
+  'style': 'mistral-small',        // Personnalité
+  'all': 'claude-sonnet-4-5'       // Polyvalent
+}
+```
+
+---
+
+## 🎓 Résumé
+
+**Configuration effective = Stack choisi**
+
+Quand vous faites :
+```javascript
+selectiveStack: 'standardEnhancement'
+```
+
+Cela charge automatiquement :
+```javascript
+{
+  layers: [
+    { type: 'technical', llm: 'gpt-4o-mini', intensity: 0.9 },
+    { type: 'style', llm: 'mistral-small', intensity: 0.8 }
+  ]
+}
+```
+
+Et applique les 2 couches **séquentiellement** sur votre contenu.
+
+**C'est aussi simple que ça !** 🎉
diff --git a/lib/selective-enhancement/SelectiveCore.js b/lib/selective-enhancement/SelectiveCore.js
index ebcfa2d..d3f73fa 100644
--- a/lib/selective-enhancement/SelectiveCore.js
+++ b/lib/selective-enhancement/SelectiveCore.js
@@ -17,7 +17,7 @@ async function applySelectiveLayer(existingContent, config = {}) {
   return await tracer.run('SelectiveCore.applySelectiveLayer()', async () => {
     const {
       layerType = 'technical', // 'technical' | 'transitions' | 'style' | 'all'
-      llmProvider = 'auto',     // 'claude' | 'gpt4' | 'gemini' | 'mistral' | 'auto'
+      llmProvider = 'auto',     // 'claude-sonnet-4-5' | 'gpt4' | 'gemini-pro' | 'mistral-small' | 'auto'
       analysisMode = true,      // Analyser avant d'appliquer
       preserveStructure = true,
       csvData = null,
@@ -51,34 +51,50 @@ async function applySelectiveLayer(existingContent, config = {}) {
 
       // Sélection automatique du LLM si 'auto'
       const selectedLLM = selectOptimalLLM(layerType, llmProvider);
+
+      // 🆕 LOG: LLM sélectionné et pourquoi
+      if (llmProvider === 'auto') {
+        logSh(`   🤖 Auto-sélection LLM: ${selectedLLM} (optimal pour ${layerType})`, 'INFO');
+      } else {
+        logSh(`   🤖 LLM spécifié: ${selectedLLM}`, 'DEBUG');
+      }
       
       // Application selon type de couche avec configuration tendance
       switch (layerType) {
         case 'technical':
+          logSh(`   🔬 Branche: Technical Enhancement`, 'DEBUG');
           const technicalConfig = activeTrendManager ?
             activeTrendManager.getLayerConfig('technical', { ...config, llmProvider: selectedLLM }) :
             { ...config, llmProvider: selectedLLM };
+          logSh(`   📝 Config technique: LLM=${technicalConfig.llmProvider}, Intensity=${technicalConfig.intensity || 'default'}`, 'DEBUG');
           const technicalResult = await applyTechnicalEnhancement(existingContent, technicalConfig);
           enhancedContent = technicalResult.content;
           layerStats = technicalResult.stats;
+          logSh(`   ✅ Technical enhancement terminé: ${layerStats.modificationsCount || 0} modifications`, 'DEBUG');
           break;
 
         case 'transitions':
+          logSh(`   🔗 Branche: Transition Enhancement`, 'DEBUG');
           const transitionConfig = activeTrendManager ?
             activeTrendManager.getLayerConfig('transitions', { ...config, llmProvider: selectedLLM }) :
             { ...config, llmProvider: selectedLLM };
+          logSh(`   📝 Config transitions: LLM=${transitionConfig.llmProvider}, Intensity=${transitionConfig.intensity || 'default'}`, 'DEBUG');
           const transitionResult = await applyTransitionEnhancement(existingContent, transitionConfig);
           enhancedContent = transitionResult.content;
           layerStats = transitionResult.stats;
+          logSh(`   ✅ Transition enhancement terminé: ${layerStats.modificationsCount || 0} modifications`, 'DEBUG');
           break;
 
         case 'style':
+          logSh(`   🎨 Branche: Style Enhancement`, 'DEBUG');
           const styleConfig = activeTrendManager ?
             activeTrendManager.getLayerConfig('style', { ...config, llmProvider: selectedLLM }) :
             { ...config, llmProvider: selectedLLM };
+          logSh(`   📝 Config style: LLM=${styleConfig.llmProvider}, Intensity=${styleConfig.intensity || 'default'}`, 'DEBUG');
           const styleResult = await applyStyleEnhancement(existingContent, styleConfig);
           enhancedContent = styleResult.content;
           layerStats = styleResult.stats;
+          logSh(`   ✅ Style enhancement terminé: ${layerStats.modificationsCount || 0} modifications`, 'DEBUG');
           break;
           
         case 'all':
@@ -108,6 +124,7 @@ async function applySelectiveLayer(existingContent, config = {}) {
       return {
         content: enhancedContent,
         stats,
+        modifications: stats.elementsEnhanced,  // ✅ AJOUTÉ: Mapping pour PipelineExecutor
         original: existingContent,
         config: { ...config, llmProvider: selectedLLM }
       };
@@ -170,9 +187,9 @@ async function applyAllSelectiveLayers(content, config = {}) {
   };
   
   const steps = [
-    { name: 'technical', llm: 'gpt4' },
-    { name: 'transitions', llm: 'gemini' },
-    { name: 'style', llm: 'mistral' }
+    { name: 'technical', llm: 'gpt-4o-mini' },
+    { name: 'transitions', llm: 'gemini-pro' },
+    { name: 'style', llm: 'mistral-small' }
   ];
   
   for (const step of steps) {
@@ -289,13 +306,13 @@ function selectOptimalLLM(layerType, llmProvider) {
   if (llmProvider !== 'auto') return llmProvider;
   
   const optimalMapping = {
-    'technical': 'openai',    // OpenAI GPT-4 excellent pour précision technique
-    'transitions': 'gemini',   // Gemini bon pour fluidité
-    'style': 'mistral',       // Mistral excellent pour style personnalité
-    'all': 'claude'           // Claude polyvalent pour tout
+    'technical': 'gpt-4o-mini',    // OpenAI GPT-4o Mini excellent pour précision technique
+    'transitions': 'gemini-pro',   // Gemini bon pour fluidité
+    'style': 'mistral-small',       // Mistral excellent pour style personnalité
+    'all': 'claude-sonnet-4-5'           // Claude polyvalent pour tout
   };
   
-  return optimalMapping[layerType] || 'claude';
+  return optimalMapping[layerType] || 'claude-sonnet-4-5';
 }
 
 /**
diff --git a/lib/selective-enhancement/SelectiveLayers.js b/lib/selective-enhancement/SelectiveLayers.js
index ff4dac3..0641960 100644
--- a/lib/selective-enhancement/SelectiveLayers.js
+++ b/lib/selective-enhancement/SelectiveLayers.js
@@ -17,51 +17,51 @@ const PREDEFINED_STACKS = {
     name: 'lightEnhancement',
     description: 'Amélioration technique légère avec OpenAI',
     layers: [
-      { type: 'technical', llm: 'openai', intensity: 0.7 }
+      { type: 'technical', llm: 'gpt-4o-mini', intensity: 0.7 }
     ],
     layersCount: 1
   },
-  
+
   // Stack standard - Technique + Transitions
   standardEnhancement: {
     name: 'standardEnhancement',
     description: 'Amélioration technique et style (OpenAI + Mistral)',
     layers: [
-      { type: 'technical', llm: 'openai', intensity: 0.9 },
-      { type: 'style', llm: 'mistral', intensity: 0.8 }
+      { type: 'technical', llm: 'gpt-4o-mini', intensity: 0.9 },
+      { type: 'style', llm: 'mistral-small', intensity: 0.8 }
     ],
     layersCount: 2
   },
-  
+
   // Stack complet - Toutes couches séquentielles
   fullEnhancement: {
     name: 'fullEnhancement',
     description: 'Enhancement complet multi-LLM (OpenAI + Mistral)',
     layers: [
-      { type: 'technical', llm: 'openai', intensity: 1.0 },
-      { type: 'style', llm: 'mistral', intensity: 0.8 }
+      { type: 'technical', llm: 'gpt-4o-mini', intensity: 1.0 },
+      { type: 'style', llm: 'mistral-small', intensity: 0.8 }
     ],
     layersCount: 2
   },
-  
+
   // Stack personnalité - Style prioritaire
   personalityFocus: {
     name: 'personalityFocus',
     description: 'Focus personnalité et style avec Mistral + technique légère',
     layers: [
-      { type: 'style', llm: 'mistral', intensity: 1.2 },
-      { type: 'technical', llm: 'openai', intensity: 0.6 }
+      { type: 'style', llm: 'mistral-small', intensity: 1.2 },
+      { type: 'technical', llm: 'gpt-4o-mini', intensity: 0.6 }
     ],
     layersCount: 2
   },
-  
+
   // Stack fluidité - Style prioritaire
   fluidityFocus: {
     name: 'fluidityFocus',
     description: 'Focus style et technique avec Mistral + OpenAI',
     layers: [
-      { type: 'style', llm: 'mistral', intensity: 1.1 },
-      { type: 'technical', llm: 'openai', intensity: 0.7 }
+      { type: 'style', llm: 'mistral-small', intensity: 1.1 },
+      { type: 'technical', llm: 'gpt-4o-mini', intensity: 0.7 }
     ],
     layersCount: 2
   }
@@ -73,7 +73,7 @@ const PREDEFINED_STACKS = {
 async function applyPredefinedStack(content, stackName, config = {}) {
   return await tracer.run('SelectiveLayers.applyPredefinedStack()', async () => {
     const stack = PREDEFINED_STACKS[stackName];
-    
+
     if (!stack) {
       throw new Error(`Stack selective prédéfini inconnu: ${stackName}. Disponibles: ${Object.keys(PREDEFINED_STACKS).join(', ')}`);
     }
@@ -89,6 +89,12 @@ async function applyPredefinedStack(content, stackName, config = {}) {
     logSh(`📦 APPLICATION STACK SELECTIVE: ${stack.name} (${stack.layersCount} couches)`, 'INFO');
     logSh(`   📊 ${Object.keys(content).length} éléments | Description: ${stack.description}`, 'INFO');
 
+    // 🆕 LOG: Détail des couches configurées dans ce stack
+    logSh(`   🔍 Configuration du stack:`, 'INFO');
+    stack.layers.forEach((layer, idx) => {
+      logSh(`      Couche ${idx + 1}: ${layer.type} | LLM: ${layer.llm} | Intensité: ${layer.intensity}`, 'INFO');
+    });
+
     try {
       let currentContent = content;
       const stackStats = {
@@ -102,9 +108,16 @@ async function applyPredefinedStack(content, stackName, config = {}) {
       // Appliquer chaque couche séquentiellement
       for (let i = 0; i < stack.layers.length; i++) {
         const layer = stack.layers[i];
-        
+
         try {
-          logSh(`   🔧 Couche ${i + 1}/${stack.layersCount}: ${layer.type} (${layer.llm})`, 'DEBUG');
+          logSh(`\n   🔧 === COUCHE ${i + 1}/${stack.layersCount} ===`, 'INFO');
+          logSh(`      Type: ${layer.type} | LLM: ${layer.llm} | Intensité: ${layer.intensity}`, 'INFO');
+          logSh(`      Éléments en entrée: ${Object.keys(currentContent).length}`, 'DEBUG');
+
+          // 🆕 LOG: Échantillon du contenu avant transformation
+          const sampleKey = Object.keys(currentContent)[0];
+          const sampleBefore = currentContent[sampleKey]?.substring(0, 100) || 'N/A';
+          logSh(`      📝 Échantillon AVANT (${sampleKey}): ${sampleBefore}...`, 'DEBUG');
 
           // Préparer configuration avec support tendances
           const layerConfig = {
@@ -118,26 +131,38 @@ async function applyPredefinedStack(content, stackName, config = {}) {
           // Ajouter tendance si présente
           if (config.trendManager) {
             layerConfig.trendManager = config.trendManager;
+            logSh(`      🎯 Tendance active: ${config.trendManager.currentTrendId || 'none'}`, 'DEBUG');
           }
 
+          const layerStartTime = Date.now();
           const layerResult = await applySelectiveLayer(currentContent, layerConfig);
-          
+          const layerDuration = Date.now() - layerStartTime;
+
           currentContent = layerResult.content;
-          
+
+          // 🆕 LOG: Échantillon après transformation
+          const sampleAfter = currentContent[sampleKey]?.substring(0, 100) || 'N/A';
+          logSh(`      📝 Échantillon APRÈS (${sampleKey}): ${sampleAfter}...`, 'DEBUG');
+
+          // 🆕 LOG: Résultats détaillés de la couche
+          const modifications = layerResult.stats.elementsEnhanced;
+          const modificationRate = ((modifications / Object.keys(currentContent).length) * 100).toFixed(1);
+
           stackStats.layers.push({
             order: i + 1,
             type: layer.type,
             llm: layer.llm,
             intensity: layer.intensity,
-            elementsEnhanced: layerResult.stats.elementsEnhanced,
-            duration: layerResult.stats.duration,
+            elementsEnhanced: modifications,
+            duration: layerDuration,
             success: !layerResult.stats.fallback
           });
-          
-          stackStats.totalModifications += layerResult.stats.elementsEnhanced;
-          stackStats.totalDuration += layerResult.stats.duration;
-          
-          logSh(`   ✅ Couche ${layer.type}: ${layerResult.stats.elementsEnhanced} améliorations`, 'DEBUG');
+
+          stackStats.totalModifications += modifications;
+          stackStats.totalDuration += layerDuration;
+
+          logSh(`      ✅ RÉSULTAT: ${modifications} éléments modifiés (${modificationRate}% du total)`, 'INFO');
+          logSh(`      ⏱️  Durée: ${layerDuration}ms`, 'DEBUG');
           
         } catch (layerError) {
           logSh(`   ❌ Couche ${layer.type} échouée: ${layerError.message}`, 'ERROR');
@@ -157,14 +182,25 @@ async function applyPredefinedStack(content, stackName, config = {}) {
       
       const duration = Date.now() - startTime;
       const successfulLayers = stackStats.layers.filter(l => l.success).length;
-      
-      logSh(`✅ STACK SELECTIVE ${stackName}: ${successfulLayers}/${stack.layersCount} couches | ${stackStats.totalModifications} modifications (${duration}ms)`, 'INFO');
-      
+
+      logSh(`\n✅ === STACK SELECTIVE ${stackName} TERMINÉ ===`, 'INFO');
+      logSh(`   📊 Couches réussies: ${successfulLayers}/${stack.layersCount}`, 'INFO');
+      logSh(`   🔄 Modifications totales: ${stackStats.totalModifications}`, 'INFO');
+      logSh(`   ⏱️  Durée totale: ${duration}ms`, 'INFO');
+
+      // 🆕 LOG: Tableau récapitulatif par couche
+      logSh(`\n   📋 RÉCAPITULATIF PAR COUCHE:`, 'INFO');
+      stackStats.layers.forEach(layer => {
+        const status = layer.success ? '✅' : '❌';
+        logSh(`      ${status} Couche ${layer.order}: ${layer.type} (${layer.llm}) - ${layer.elementsEnhanced || 0} modifs en ${layer.duration}ms`, 'INFO');
+      });
+
       await tracer.event('Stack selective appliqué', { ...stackStats, totalDuration: duration });
       
       return {
         content: currentContent,
         stats: { ...stackStats, totalDuration: duration },
+        modifications: stackStats.totalModifications,  // ✅ AJOUTÉ: Mapping pour PipelineExecutor
         original: content,
         stackApplied: stackName
       };
@@ -217,7 +253,7 @@ async function applyAdaptiveLayers(content, config = {}) {
       if (needsAnalysis.technical.needed && needsAnalysis.technical.score > analysisThreshold) {
         layersToApply.push({
           type: 'technical',
-          llm: 'openai',
+          llm: 'gpt-4o-mini',
           intensity: Math.min(maxIntensity, needsAnalysis.technical.score * 1.2),
           priority: 1
         });
@@ -228,7 +264,7 @@ async function applyAdaptiveLayers(content, config = {}) {
       if (needsAnalysis.style.needed && needsAnalysis.style.score > analysisThreshold) {
         layersToApply.push({
           type: 'style',
-          llm: 'mistral', 
+          llm: 'mistral-small', 
           intensity: Math.min(maxIntensity, needsAnalysis.style.score),
           priority: 3
         });
@@ -238,12 +274,13 @@ async function applyAdaptiveLayers(content, config = {}) {
         logSh(`✅ COUCHES ADAPTATIVES: Aucune amélioration nécessaire`, 'INFO');
         return {
           content,
-          stats: { 
-            adaptive: true, 
-            layersApplied: 0, 
-            analysisOnly: true, 
-            duration: Date.now() - startTime 
-          }
+          stats: {
+            adaptive: true,
+            layersApplied: 0,
+            analysisOnly: true,
+            duration: Date.now() - startTime
+          },
+          modifications: 0  // ✅ AJOUTÉ: Mapping pour PipelineExecutor (pas de modifications)
         };
       }
       
@@ -306,6 +343,7 @@ async function applyAdaptiveLayers(content, config = {}) {
       return {
         content: currentContent,
         stats: { ...adaptiveStats, totalDuration: duration },
+        modifications: adaptiveStats.totalModifications,  // ✅ AJOUTÉ: Mapping pour PipelineExecutor
         original: content
       };
 
@@ -395,6 +433,7 @@ async function applyLayerPipeline(content, layerSequence, config = {}) {
       return {
         content: currentContent,
         stats: { ...pipelineStats, totalDuration: duration },
+        modifications: pipelineStats.totalModifications,  // ✅ AJOUTÉ: Mapping pour PipelineExecutor
         original: content
       };