diff --git a/.gitignore b/.gitignore
index cff1b08..7217f01 100644
--- a/.gitignore
+++ b/.gitignore
@@ -53,8 +53,7 @@ test_*.js
 *_debug.js
 test-*.js
 
-# HTML généré (logs viewer)
-logs-viewer.html
+# HTML généré était ici mais maintenant on le garde dans tools/
 
 # Unit test reports
 TEST*.xml
diff --git a/code.js b/code.js
index a1dcd72..a2bdb22 100644
--- a/code.js
+++ b/code.js
@@ -1,6 +1,6 @@
 /*
   code.js — bundle concaténé
-  Généré: 2025-09-03T04:21:57.159Z
+  Généré: 2025-09-04T01:10:08.540Z
   Source: lib
   Fichiers: 16
   Ordre: topo
@@ -57,12 +57,13 @@ const fileDest = pino.destination({
 });
 tee.pipe(fileDest);
 
-// Custom levels for Pino to include TRACE and PROMPT
+// Custom levels for Pino to include TRACE, PROMPT, and LLM
 const customLevels = {
   trace: 5,   // Below debug (10)
   debug: 10,
   info: 20,
   prompt: 25, // New level for prompts (between info and warn)
+  llm: 26,    // New level for LLM interactions (between prompt and warn)
   warn: 30,
   error: 40,
   fatal: 50
@@ -178,6 +179,9 @@ async function logSh(message, level = 'INFO') {
     case 'prompt':
       logger.prompt(traceData, message);
       break;
+    case 'llm':
+      logger.llm(traceData, message);
+      break;
     default:
       logger.info(traceData, message);
   }
@@ -1282,7 +1286,10 @@ async function callLLM(llmProvider, prompt, options = {}, personality = null) {
     // 📢 AFFICHAGE PROMPT COMPLET POUR DEBUG AVEC INFO IA
     logSh(`\n🔍 ===== PROMPT ENVOYÉ À ${llmProvider.toUpperCase()} (${config.model}) | PERSONNALITÉ: ${personality?.nom || 'AUCUNE'} =====`, 'PROMPT');
     logSh(prompt, 'PROMPT');
-    logSh(`===== FIN PROMPT ${llmProvider.toUpperCase()} (${personality?.nom || 'AUCUNE'}) =====\n`, 'PROMPT');
+    
+    // 📤 LOG LLM REQUEST COMPLET
+    logSh(`📤 LLM REQUEST [${llmProvider.toUpperCase()}] (${config.model}) | Personnalité: ${personality?.nom || 'AUCUNE'}`, 'LLM');
+    logSh(prompt, 'LLM');
     
     // Préparer la requête selon le provider
     const requestData = buildRequestData(llmProvider, prompt, options, personality);
@@ -1293,8 +1300,12 @@ async function callLLM(llmProvider, prompt, options = {}, personality = null) {
     // Parser la réponse selon le format du provider
     const content = parseResponse(llmProvider, response);
     
+    // 📥 LOG LLM RESPONSE COMPLET
+    logSh(`📥 LLM RESPONSE [${llmProvider.toUpperCase()}] (${config.model}) | Durée: ${Date.now() - startTime}ms`, 'LLM');
+    logSh(content, 'LLM');
+    
     const duration = Date.now() - startTime;
-    logSh(`✅ ${llmProvider.toUpperCase()} (${personality?.nom || 'sans personnalité'}) réponse en ${duration}ms: "${content.substring(0, 150)}${content.length > 150 ? '...' : ''}"`, 'INFO');
+    logSh(`✅ ${llmProvider.toUpperCase()} (${personality?.nom || 'sans personnalité'}) réponse en ${duration}ms`, 'INFO');
     
     // Enregistrer les stats d'usage
     await recordUsageStats(llmProvider, prompt.length, content.length, duration);
@@ -1727,6 +1738,8 @@ module.exports = {
   LLM_CONFIG
 };
 
+
+
 /*
 ┌────────────────────────────────────────────────────────────────────┐
 │  File: lib/ElementExtraction.js                                    │
@@ -2309,38 +2322,21 @@ CONTEXTE:
 `;
 
   missingElements.forEach((missing, index) => {
-    prompt += `${index + 1}. [${missing.name}] `;
-    
-    // INSTRUCTIONS SPÉCIFIQUES PAR TYPE
-    if (missing.type.includes('titre_h1')) {
-      prompt += `→ Titre H1 principal (8-10 mots) pour ${contextAnalysis.mainKeyword}\n`;
-    } else if (missing.type.includes('titre_h2')) {
-      prompt += `→ Titre H2 section (6-8 mots) lié à ${contextAnalysis.mainKeyword}\n`;
-    } else if (missing.type.includes('titre_h3')) {
-      prompt += `→ Sous-titre H3 (4-6 mots) spécialisé ${contextAnalysis.mainKeyword}\n`;
-    } else if (missing.type.includes('texte') || missing.type.includes('txt')) {
-      prompt += `→ Thème/sujet pour paragraphe 150 mots sur ${contextAnalysis.mainKeyword}\n`;
-    } else if (missing.type.includes('faq_question')) {
-      prompt += `→ Question client directe sur ${contextAnalysis.mainKeyword} (8-12 mots)\n`;
-    } else if (missing.type.includes('faq_reponse')) {
-      prompt += `→ Thème réponse experte ${contextAnalysis.mainKeyword} (2-4 mots)\n`;
-    } else {
-      prompt += `→ Expression/mot-clé pertinent ${contextAnalysis.mainKeyword}\n`;
-    }
+    prompt += `${index + 1}. [${missing.name}] → Mot-clé SEO\n`;
   });
   
   prompt += `\nCONSIGNES:
-- Reste dans le thème ${contextAnalysis.mainKeyword}
-- Varie les angles et expressions
-- Évite répétitions avec mots-clés existants
-- Précis et pertinents
+- Thème: ${contextAnalysis.mainKeyword}
+- Mots-clés SEO naturels
+- Varie les termes
+- Évite répétitions
 
 FORMAT:
 [${missingElements[0].name}]
-Expression/mot-clé généré 1
+mot-clé
 
 [${missingElements[1] ? missingElements[1].name : 'exemple'}]
-Expression/mot-clé généré 2
+mot-clé
 
 etc...`;
 
@@ -2596,6 +2592,11 @@ const { logSh } = require('./ErrorReporting');
 const { tracer } = require('./trace.js');
 const { selectMultiplePersonalitiesWithAI, getPersonalities } = require('./BrainConfig');
 
+// Utilitaire pour les délais
+function sleep(ms) {
+  return new Promise(resolve => setTimeout(resolve, ms));
+}
+
 /**
  * NOUVELLE APPROCHE - Multi-Personnalités Batch Enhancement
  * 4 personnalités différentes utilisées dans le pipeline pour maximum d'anti-détection
@@ -2804,8 +2805,8 @@ async function generateAllContentBase(hierarchy, csvData, aiProvider) {
 }
 
 /**
- * ÉTAPE 2 - Enhancement technique BATCH OPTIMISÉ avec IA configurable
- * OPTIMISATION : 1 appel extraction + 1 appel enhancement au lieu de 20+
+ * ÉTAPE 2 - Enhancement technique ÉLÉMENT PAR ÉLÉMENT avec IA configurable
+ * NOUVEAU : Traitement individuel pour fiabilité maximale et debug précis
  */
 async function enhanceAllTechnicalTerms(baseContents, csvData, aiProvider) {
   logSh('🔧 === DÉBUT ENHANCEMENT TECHNIQUE ===', 'INFO');
@@ -2872,96 +2873,96 @@ async function enhanceAllTechnicalTerms(baseContents, csvData, aiProvider) {
 }
 
 /**
- * NOUVELLE FONCTION : Extraction batch TOUS les termes techniques
+ * Analyser un seul élément pour détecter les termes techniques
  */
-async function extractAllTechnicalTermsBatch(baseContents, csvData, aiProvider) {
-  const contentEntries = Object.keys(baseContents);
-  
-  const batchAnalysisPrompt = `MISSION: Analyser ces ${contentEntries.length} contenus et identifier leurs termes techniques.
+async function analyzeSingleElementTechnicalTerms(tag, content, csvData, aiProvider) {
+  const prompt = `MISSION: Analyser ce contenu et déterminer s'il contient des termes techniques.
 
 CONTEXTE: ${csvData.mc0} - Secteur: signalétique/impression
 
-CONTENUS À ANALYSER:
-
-${contentEntries.map((tag, i) => `[${i + 1}] TAG: ${tag}
-CONTENU: "${baseContents[tag]}"`).join('\n\n')}
+CONTENU À ANALYSER:
+TAG: ${tag}
+CONTENU: "${content}"
 
 CONSIGNES:
-- Identifie UNIQUEMENT les vrais termes techniques métier/industrie
+- Cherche UNIQUEMENT des vrais termes techniques métier/industrie
 - Évite mots génériques (qualité, service, pratique, personnalisé, etc.)
-- Focus: matériaux, procédés, normes, dimensions, technologies
-- Si aucun terme technique → "AUCUN"
+- Focus: matériaux, procédés, normes, dimensions, technologies spécifiques
 
-EXEMPLES VALIDES: dibond, impression UV, fraisage CNC, épaisseur 3mm, aluminium brossé
-EXEMPLES INVALIDES: durable, pratique, personnalisé, moderne, esthétique
+EXEMPLES VALIDES: dibond, impression UV, fraisage CNC, épaisseur 3mm, aluminium brossé, anodisation
+EXEMPLES INVALIDES: durable, pratique, personnalisé, moderne, esthétique, haute performance
 
-FORMAT RÉPONSE EXACT:
-[1] dibond, impression UV, 3mm OU AUCUN
-[2] aluminium, fraisage CNC OU AUCUN
-[3] AUCUN
-etc... (${contentEntries.length} lignes total)`;
+RÉPONSE REQUISE:
+- Si termes techniques trouvés: "OUI - termes: [liste des termes séparés par virgules]"
+- Si aucun terme technique: "NON"
+
+EXEMPLE:
+OUI - termes: aluminium composite, impression numérique, gravure laser`;
 
   try {
-    const analysisResponse = await callLLM(aiProvider, batchAnalysisPrompt, {
-      temperature: 0.3,
-      maxTokens: 2000
-    }, csvData.personality);
-    
-    return parseAllTechnicalTermsResponse(analysisResponse, baseContents, contentEntries);
-    
+    const response = await callLLM(aiProvider, prompt, { temperature: 0.3 });
+    
+    if (response.toUpperCase().startsWith('OUI')) {
+      // Extraire les termes de la réponse
+      const termsMatch = response.match(/termes:\s*(.+)/i);
+      const terms = termsMatch ? termsMatch[1].trim() : '';
+      logSh(`✅ [${tag}] Termes techniques détectés: ${terms}`, 'DEBUG');
+      return true;
+    } else {
+      logSh(`⏭️ [${tag}] Pas de termes techniques`, 'DEBUG');  
+      return false;
+    }
   } catch (error) {
-    logSh(`❌ FATAL: Extraction termes techniques batch échouée: ${error.message}`, 'ERROR');
-    throw new Error(`FATAL: Analyse termes techniques impossible - arrêt du workflow: ${error.message}`);
+    logSh(`❌ ERREUR analyse ${tag}: ${error.message}`, 'ERROR');
+    return false; // En cas d'erreur, on skip l'enhancement
   }
 }
 
 /**
- * NOUVELLE FONCTION : Enhancement batch TOUS les éléments
+ * Enhancer un seul élément techniquement
  */
-async function enhanceAllElementsTechnicalBatch(elementsNeedingEnhancement, csvData, aiProvider) {
-  if (elementsNeedingEnhancement.length === 0) return {};
-  
-  const batchEnhancementPrompt = `MISSION: Améliore UNIQUEMENT la précision technique de ces ${elementsNeedingEnhancement.length} contenus.
+async function enhanceSingleElementTechnical(tag, content, csvData, aiProvider) {
+  const prompt = `MISSION: Améliore ce contenu en intégrant des termes techniques précis.
 
-PERSONNALITÉ: ${csvData.personality?.nom} (${csvData.personality?.style})
-CONTEXTE: ${csvData.mc0} - Secteur: Signalétique/impression
-VOCABULAIRE PRÉFÉRÉ: ${csvData.personality?.vocabulairePref}
-
-CONTENUS + TERMES À AMÉLIORER:
-
-${elementsNeedingEnhancement.map((item, i) => `[${i + 1}] TAG: ${item.tag}
-CONTENU ACTUEL: "${item.content}"
-TERMES TECHNIQUES À INTÉGRER: ${item.technicalTerms.join(', ')}`).join('\n\n')}
+CONTEXTE: ${csvData.mc0} - Secteur: signalétique/impression
 
-CONSIGNES STRICTES:
-- Améliore UNIQUEMENT la précision technique, garde le style ${csvData.personality?.nom}
-- GARDE la même longueur, structure et ton
-- Intègre naturellement les termes techniques listés
-- NE CHANGE PAS le fond du message ni le style personnel
-- Utilise un vocabulaire expert mais accessible
-- ÉVITE les répétitions excessives
-- RESPECTE le niveau technique: ${csvData.personality?.niveauTechnique}
-- Termes techniques secteur: dibond, aluminium, impression UV, fraisage, épaisseur, PMMA
+CONTENU À AMÉLIORER:
+TAG: ${tag}
+CONTENU: "${content}"
 
-FORMAT RÉPONSE:
-[1] Contenu avec amélioration technique selon ${csvData.personality?.nom}
-[2] Contenu avec amélioration technique selon ${csvData.personality?.nom}
-etc... (${elementsNeedingEnhancement.length} éléments total)`;
+OBJECTIFS:
+- Remplace les termes génériques par des termes techniques précis
+- Ajoute des spécifications techniques réalistes
+- Maintient le même style et longueur
+- Intègre naturellement: matériaux (dibond, aluminium composite), procédés (impression UV, gravure laser), dimensions, normes
+
+EXEMPLE DE TRANSFORMATION:
+"matériaux haute performance" → "dibond 3mm ou aluminium composite"
+"impression moderne" → "impression UV haute définition"
+"fixation solide" → "fixation par chevilles inox Ø6mm"
+
+CONTRAINTES:
+- GARDE la même structure
+- MÊME longueur approximative
+- Style cohérent avec l'original
+- RÉPONDS DIRECTEMENT par le contenu amélioré, sans préfixe`;
 
   try {
-    const enhanced = await callLLM(aiProvider, batchEnhancementPrompt, {
-      temperature: 0.4,
-      maxTokens: 5000 // Plus large pour batch total
-    }, csvData.personality);
-    
-    return parseTechnicalEnhancementBatchResponse(enhanced, elementsNeedingEnhancement);
-    
+    const enhancedContent = await callLLM(aiProvider, prompt, { temperature: 0.7 });
+    return enhancedContent.trim();
   } catch (error) {
-    logSh(`❌ FATAL: Enhancement technique batch échoué: ${error.message}`, 'ERROR');
-    throw new Error(`FATAL: Enhancement technique batch impossible - arrêt du workflow: ${error.message}`);
+    logSh(`❌ ERREUR enhancement ${tag}: ${error.message}`, 'ERROR');
+    return content; // En cas d'erreur, on retourne le contenu original
   }
 }
 
+// ANCIENNES FONCTIONS BATCH SUPPRIMÉES - REMPLACÉES PAR TRAITEMENT INDIVIDUEL
+
+/**
+ * NOUVELLE FONCTION : Enhancement batch TOUS les éléments
+ */
+// FONCTION SUPPRIMÉE : enhanceAllElementsTechnicalBatch() - Remplacée par traitement individuel
+
 /**
  * ÉTAPE 3 - Enhancement transitions BATCH avec IA configurable
  */
@@ -3015,7 +3016,8 @@ async function enhanceAllTransitions(baseContents, csvData, aiProvider) {
       
       const batchTransitionsPrompt = `MISSION: Améliore UNIQUEMENT les transitions et fluidité de ces contenus.
 
-PERSONNALITÉ: ${csvData.personality?.nom} (${csvData.personality?.style})
+CONTEXTE: Article SEO professionnel pour site web commercial
+PERSONNALITÉ: ${csvData.personality?.nom} (${csvData.personality?.style} adapté web)
 CONNECTEURS PRÉFÉRÉS: ${csvData.personality?.connecteursPref}
 
 CONTENUS:
@@ -3093,9 +3095,10 @@ async function enhanceAllPersonalityStyle(baseContents, csvData, aiProvider) {
       
       const batchStylePrompt = `MISSION: Adapte UNIQUEMENT le style de ces contenus selon ${personality.nom}.
 
+CONTEXTE: Finalisation article SEO pour site e-commerce professionnel
 PERSONNALITÉ: ${personality.nom}
 DESCRIPTION: ${personality.description}
-STYLE CIBLE: ${personality.style}
+STYLE CIBLE: ${personality.style} adapté au web professionnel
 VOCABULAIRE: ${personality.vocabulairePref}
 CONNECTEURS: ${personality.connecteursPref}
 NIVEAU TECHNIQUE: ${personality.niveauTechnique}
@@ -3149,9 +3152,8 @@ etc...`;
 /**
  * Sleep function replacement for Utilities.sleep
  */
-function sleep(ms) {
-  return new Promise(resolve => setTimeout(resolve, ms));
-}
+
+// FONCTION SUPPRIMÉE : sleep() dupliquée - déjà définie ligne 12
 
 /**
  * RESTAURÉ DEPUIS .GS : Génération des paires FAQ cohérentes
@@ -3187,32 +3189,33 @@ async function generateFAQPairsRestored(faqPairs, csvData, aiProvider) {
 function createBatchFAQPairsPrompt(faqPairs, csvData) {
   const personality = csvData.personality;
   
-  let prompt = `PERSONNALITÉ: ${personality.nom} | ${personality.description}
-STYLE: ${personality.style}
-VOCABULAIRE: ${personality.vocabulairePref}
-CONNECTEURS: ${personality.connecteursPref}
-NIVEAU TECHNIQUE: ${personality.niveauTechnique}
+  let prompt = `=== 1. CONTEXTE ===
+Entreprise: Autocollant.fr - signalétique personnalisée
+Sujet: ${csvData.mc0}
+Section: FAQ pour article SEO commercial
 
-GÉNÈRE ${faqPairs.length} PAIRES FAQ COHÉRENTES pour ${csvData.mc0}:
+=== 2. PERSONNALITÉ ===
+Rédacteur: ${personality.nom}
+Style: ${personality.style}
+Ton: ${personality.description || 'professionnel'}
 
-RÈGLES STRICTES:
-- QUESTIONS: Neutres, directes, langage client naturel (8-15 mots)
-- RÉPONSES: Style ${personality.style}, vocabulaire ${personality.vocabulairePref} (50-80 mots)
-- Sujets à couvrir: prix, livraison, personnalisation, installation, durabilité
-- ÉVITE répétitions excessives et expressions trop familières
-- Style ${personality.nom} reconnaissable mais PROFESSIONNEL
-- PAS de messages d'excuse ("je n'ai pas l'information")
-- RÉPONDS DIRECTEMENT par questions et réponses, sans préfixe
+=== 3. RÈGLES GÉNÉRALES ===
+- Questions naturelles de clients
+- Réponses expertes et rassurantes  
+- Langage professionnel mais accessible
+- Textes rédigés humainement et de façon authentique
+- Couvrir: prix, livraison, personnalisation, installation, durabilité
+- IMPÉRATIF: Respecter strictement les contraintes XML
+
+=== 4. PAIRES FAQ À GÉNÉRER ===
 
-PAIRES À GÉNÉRER:
 `;
 
   faqPairs.forEach((pair, index) => {
     const questionTag = pair.question.tag.replace(/\|/g, '').replace(/[{}]/g, '').replace(/<\/?strong>/g, '');
     const answerTag = pair.answer.tag.replace(/\|/g, '').replace(/[{}]/g, '').replace(/<\/?strong>/g, '');
     
-    prompt += `${index + 1}. [${questionTag}] + [${answerTag}]
-   Question client sur ${csvData.mc0} → Réponse ${personality.style}
+    prompt += `${index + 1}. [${questionTag}] + [${answerTag}] - Paire FAQ naturelle
 `;
   });
   
@@ -3533,10 +3536,25 @@ function findAssociatedTitle(textElement, existingResults) {
 function createBatchBasePrompt(elements, type, csvData, existingResults = {}) {
   const personality = csvData.personality;
   
-  let prompt = `RÉDACTEUR: ${personality.nom} | Style: ${personality.style}
-SUJET: ${csvData.mc0}
-
-${type === 'titre' ? 'GÉNÈRE DES TITRES COURTS ET IMPACTANTS' : `GÉNÈRE ${elements.length} ${type.toUpperCase()}S PROFESSIONNELS`}:
+  let prompt = `=== 1. CONTEXTE ===
+Entreprise: Autocollant.fr - signalétique personnalisée
+Sujet: ${csvData.mc0}
+Type d'article: SEO professionnel pour site commercial
+
+=== 2. PERSONNALITÉ ===
+Rédacteur: ${personality.nom}
+Style: ${personality.style}
+Ton: ${personality.description || 'professionnel'}
+
+=== 3. RÈGLES GÉNÉRALES ===
+- Contenu SEO optimisé
+- Langage naturel et fluide
+- Éviter répétitions
+- Pas de références techniques dans le contenu
+- Textes rédigés humainement et de façon authentique
+- IMPÉRATIF: Respecter strictement les contraintes XML (nombre de mots, etc.)
+
+=== 4. ÉLÉMENTS À GÉNÉRER ===
 `;
 
   // AJOUTER CONTEXTE DES TITRES POUR LES TEXTES
@@ -3548,7 +3566,7 @@ ${type === 'titre' ? 'GÉNÈRE DES TITRES COURTS ET IMPACTANTS' : `GÉNÈRE ${el
     
     if (generatedTitles.length > 0) {
       prompt += `
-CONTEXTE - TITRES GÉNÉRÉS:
+Titres existants pour contexte:
 ${generatedTitles.join('\n')}
 
 `;
@@ -3560,34 +3578,33 @@ ${generatedTitles.join('\n')}
     
     prompt += `${index + 1}. [${cleanTag}] `;
     
-    // INSTRUCTIONS SPÉCIFIQUES ET COURTES PAR TYPE
+    // INSTRUCTIONS PROPRES PAR ÉLÉMENT
     if (type === 'titre') {
       if (elementInfo.element.type === 'titre_h1') {
-        prompt += `CRÉER UN TITRE H1 PRINCIPAL (8-12 mots) sur "${csvData.t0}" - NE PAS écrire "Titre_H1_1"\n`;
+        prompt += `Titre principal accrocheur\n`;
       } else if (elementInfo.element.type === 'titre_h2') {
-        prompt += `CRÉER UN TITRE H2 SECTION (6-10 mots) sur "${csvData.mc0}" - NE PAS écrire "Titre_H2_X"\n`;
+        prompt += `Titre de section engageant\n`;
       } else if (elementInfo.element.type === 'titre_h3') {
-        prompt += `CRÉER UN TITRE H3 SOUS-SECTION (4-8 mots) - NE PAS écrire "Titre_H3_X"\n`;
+        prompt += `Sous-titre spécialisé\n`;
       } else {
-        prompt += `CRÉER UN TITRE ACCROCHEUR (4-10 mots) sur "${csvData.mc0}" - NE PAS écrire "Titre_"\n`;
+        prompt += `Titre pertinent\n`;
       }
     } else if (type === 'texte') {
-      const wordCount = elementInfo.element.name && elementInfo.element.name.includes('H2') ? '150' : '100';
-      prompt += `Paragraphe ${wordCount} mots, style ${personality.style}\n`;
+      prompt += `Paragraphe informatif\n`;
       
       // ASSOCIER LE TITRE CORRESPONDANT AUTOMATIQUEMENT
       const associatedTitle = findAssociatedTitle(elementInfo, existingResults);
       if (associatedTitle) {
-        prompt += `   Développe le titre: "${associatedTitle}"\n`;
+        prompt += `   Contexte: "${associatedTitle}"\n`;
       }
       
       if (elementInfo.element.resolvedContent) {
-        prompt += `   Thème: "${elementInfo.element.resolvedContent}"\n`;
+        prompt += `   Angle: "${elementInfo.element.resolvedContent}"\n`;
       }
     } else if (type === 'intro') {
-      prompt += `Introduction 80-100 mots, ton accueillant\n`;
+      prompt += `Introduction engageante\n`;
     } else {
-      prompt += `Contenu pertinent pour ${csvData.mc0}\n`;
+      prompt += `Contenu pertinent\n`;
     }
   });
   
@@ -3597,15 +3614,16 @@ ${generatedTitles.join('\n')}
 - Phrases: ${personality.longueurPhrases}
 - Niveau technique: ${personality.niveauTechnique}
 
-CONSIGNES STRICTES:
-- RESPECTE le style ${personality.style} de ${personality.nom} mais RESTE PROFESSIONNEL
-- INTERDICTION ABSOLUE: "du coup", "bon", "alors", "franchement", "nickel", "tip-top", "costaud" en excès
-- VARIE les connecteurs: ${personality.connecteursPref}
-- POUR LES TITRES: SEULEMENT le titre réel, JAMAIS de référence "Titre_H1_1" ou "Titre_H2_7"
-- EXEMPLE TITRE: "Plaques personnalisées résistantes aux intempéries" PAS "Titre_H2_1"  
-- RÉPONDS DIRECTEMENT par le contenu demandé, SANS introduction ni nom de tag
-- PAS de message d'excuse du type "je n'ai pas l'information"
-- CONTENU cohérent et professionnel, évite la sur-familiarité
+CONSIGNES STRICTES POUR ARTICLE SEO:
+- CONTEXTE: Article professionnel pour site e-commerce, destiné aux clients potentiels
+- STYLE: ${personality.style} de ${personality.nom} mais ADAPTÉ au web professionnel
+- INTERDICTION ABSOLUE: expressions trop familières répétées ("du coup", "bon", "franchement", "nickel", "tip-top")  
+- VOCABULAIRE: Mélange expertise technique + accessibilité client
+- SEO: Utilise naturellement "${csvData.mc0}" et termes associés
+- POUR LES TITRES: Titre SEO attractif UNIQUEMENT, JAMAIS "Titre_H1_1" ou "Titre_H2_7"
+- EXEMPLE TITRE: "Plaques personnalisées résistantes : guide complet 2024" 
+- CONTENU: Informatif, rassurant, incite à l'achat SANS être trop commercial
+- RÉPONDS DIRECTEMENT par le contenu web demandé, SANS préfixe
 
 FORMAT DE RÉPONSE ${type === 'titre' ? '(TITRES UNIQUEMENT)' : ''}:
 [${elements[0].tag.replace(/\|/g, '').replace(/[{}]/g, '').replace(/<\/?strong>/g, '')}]
@@ -3696,107 +3714,11 @@ function cleanXMLTagsFromContent(content) {
 
 // ============= PARSING FUNCTIONS =============
 
-/**
- * Parser réponse extraction termes
- */
-function parseAllTechnicalTermsResponse(response, baseContents, contentEntries) {
-  const results = [];
-  const regex = /\[(\d+)\]\s*([^[]*?)(?=\[\d+\]|$)/gs;
-  let match;
-  const parsedItems = {};
-  
-  // Parser la réponse
-  while ((match = regex.exec(response)) !== null) {
-    const index = parseInt(match[1]) - 1; // Convertir en 0-indexé
-    const termsText = match[2].trim();
-    parsedItems[index] = termsText;
-  }
-  
-  // Mapper aux éléments
-  contentEntries.forEach((tag, index) => {
-    const termsText = parsedItems[index] || 'AUCUN';
-    const hasTerms = !termsText.toUpperCase().includes('AUCUN');
-    
-    const technicalTerms = hasTerms ? 
-      termsText.split(',').map(t => t.trim()).filter(t => t.length > 0) : 
-      [];
-    
-    results.push({
-      tag: tag,
-      content: baseContents[tag],
-      technicalTerms: technicalTerms,
-      needsEnhancement: hasTerms && technicalTerms.length > 0
-    });
-    
-    logSh(`🔍 [${tag}]: ${hasTerms ? technicalTerms.join(', ') : 'pas de termes techniques'}`, 'DEBUG');
-  });
-  
-  const enhancementCount = results.filter(r => r.needsEnhancement).length;
-  logSh(`📊 Analyse terminée: ${enhancementCount}/${contentEntries.length} éléments ont besoin d'enhancement`, 'INFO');
-  
-  return results;
[31