diff --git a/content/chapters/test-heavy-stress.json b/content/chapters/test-heavy-stress.json
index 060aa7f..6c05959 100644
--- a/content/chapters/test-heavy-stress.json
+++ b/content/chapters/test-heavy-stress.json
@@ -208,15 +208,111 @@
   "lessons": {
     "lesson1": {
       "title": "Foundations of Research Methodology",
-      "content": "Research methodology constitutes the systematic theoretical analysis of the methods applied to a field of study. It encompasses the comprehensive framework of epistemological, ontological, and phenomenological considerations that guide rigorous academic inquiry. Contemporary researchers must navigate complex paradigmatic tensions between positivist empirical approaches and constructivist interpretive methodologies. The theoretical foundations of quantitative research emphasize statistical significance, experimental control, and generalizability of findings across diverse populations. Conversely, qualitative investigation prioritizes comprehensive understanding, contextual interpretation, and the nuanced exploration of subjective phenomena. Modern academic discourse increasingly advocates for sophisticated mixed-methods approaches that synthesize both quantitative measurement and qualitative analysis. Triangulation strategies enhance validity through multiple data sources, theoretical perspectives, and methodological approaches. Researchers must demonstrate meticulous attention to bias reduction, sample representativeness, and ethical considerations throughout the investigation process. The operationalization of abstract concepts requires precise definitional frameworks and robust measurement instruments. Contemporary methodology emphasizes reproducibility, transparency, and rigorous peer review processes. Advanced statistical techniques including regression modeling, multivariate analysis, and machine learning algorithms enable sophisticated pattern recognition and predictive modeling. Researchers increasingly utilize computational processing power for extensive dataset analysis and complex simulation procedures."
+      "content": "Research methodology constitutes the systematic theoretical analysis of the methods applied to a field of study. It encompasses the comprehensive framework of epistemological, ontological, and phenomenological considerations that guide rigorous academic inquiry. Contemporary researchers must navigate complex paradigmatic tensions between positivist empirical approaches and constructivist interpretive methodologies. The theoretical foundations of quantitative research emphasize statistical significance, experimental control, and generalizability of findings across diverse populations. Conversely, qualitative investigation prioritizes comprehensive understanding, contextual interpretation, and the nuanced exploration of subjective phenomena. Modern academic discourse increasingly advocates for sophisticated mixed-methods approaches that synthesize both quantitative measurement and qualitative analysis. Triangulation strategies enhance validity through multiple data sources, theoretical perspectives, and methodological approaches. Researchers must demonstrate meticulous attention to bias reduction, sample representativeness, and ethical considerations throughout the investigation process. The operationalization of abstract concepts requires precise definitional frameworks and robust measurement instruments. Contemporary methodology emphasizes reproducibility, transparency, and rigorous peer review processes. Advanced statistical techniques including regression modeling, multivariate analysis, and machine learning algorithms enable sophisticated pattern recognition and predictive modeling. Researchers increasingly utilize computational processing power for extensive dataset analysis and complex simulation procedures.",
+      "questions": [
+        {
+          "question": "What are the key differences between positivist and constructivist research paradigms?",
+          "options": [
+            "Positivist emphasizes statistical significance while constructivist prioritizes contextual interpretation",
+            "Positivist uses qualitative methods while constructivist uses quantitative methods",
+            "Positivist focuses on subjective phenomena while constructivist emphasizes empirical control",
+            "There are no significant differences between these paradigms"
+          ],
+          "correct_answer": 0
+        },
+        {
+          "question": "According to the text, what is the primary purpose of triangulation in research methodology?",
+          "options": [
+            "To reduce research costs",
+            "To enhance validity through multiple data sources, theoretical perspectives, and methodological approaches",
+            "To simplify data collection procedures",
+            "To eliminate the need for peer review"
+          ],
+          "correct_answer": 1
+        },
+        {
+          "question": "What does 'operationalization' refer to in research methodology?",
+          "options": [
+            "The process of conducting surgical research",
+            "The management of research laboratories",
+            "Defining abstract concepts with precise frameworks and robust measurement instruments",
+            "The automation of data collection procedures"
+          ],
+          "correct_answer": 2
+        }
+      ]
     },
     "lesson2": {
       "title": "Advanced Statistical Analysis and Data Interpretation",
-      "content": "Statistical analysis represents the cornerstone of empirical research methodology, encompassing sophisticated techniques for data exploration, hypothesis testing, and inferential reasoning. Contemporary researchers utilize advanced algorithms for pattern recognition, anomaly detection, and predictive modeling across extensive datasets. The distribution characteristics of variables determine appropriate statistical procedures, including parametric and non-parametric approaches for hypothesis evaluation. Correlation analysis reveals relationships between variables, while causation requires controlled experimental manipulation and rigorous confounding variable elimination. Regression modeling enables prediction and explanation of dependent variable variance through multiple independent predictors. Cluster analysis identifies natural groupings within populations, facilitating targeted intervention strategies and segmentation approaches. Longitudinal studies track cohorts across time, revealing developmental patterns and causal sequences. Cross-sectional comparative designs enable efficient population sampling at specific temporal points. Measurement validity encompasses content, construct, and criterion-related approaches for instrument development. Reliability coefficients assess consistency across time, interrater agreement, and internal consistency measures. Confidence intervals provide probability-based ranges for population parameter estimation. Effect sizes quantify practical significance beyond statistical significance testing. Meta-analysis synthesizes findings across multiple independent studies, enhancing generalizability and statistical power. Advanced modeling techniques including structural equation modeling, hierarchical linear modeling, and machine learning algorithms enable sophisticated hypothesis testing with complex nested data structures."
+      "content": "Statistical analysis represents the cornerstone of empirical research methodology, encompassing sophisticated techniques for data exploration, hypothesis testing, and inferential reasoning. Contemporary researchers utilize advanced algorithms for pattern recognition, anomaly detection, and predictive modeling across extensive datasets. The distribution characteristics of variables determine appropriate statistical procedures, including parametric and non-parametric approaches for hypothesis evaluation. Correlation analysis reveals relationships between variables, while causation requires controlled experimental manipulation and rigorous confounding variable elimination. Regression modeling enables prediction and explanation of dependent variable variance through multiple independent predictors. Cluster analysis identifies natural groupings within populations, facilitating targeted intervention strategies and segmentation approaches. Longitudinal studies track cohorts across time, revealing developmental patterns and causal sequences. Cross-sectional comparative designs enable efficient population sampling at specific temporal points. Measurement validity encompasses content, construct, and criterion-related approaches for instrument development. Reliability coefficients assess consistency across time, interrater agreement, and internal consistency measures. Confidence intervals provide probability-based ranges for population parameter estimation. Effect sizes quantify practical significance beyond statistical significance testing. Meta-analysis synthesizes findings across multiple independent studies, enhancing generalizability and statistical power. Advanced modeling techniques including structural equation modeling, hierarchical linear modeling, and machine learning algorithms enable sophisticated hypothesis testing with complex nested data structures.",
+      "questions": [
+        {
+          "question": "What is the fundamental difference between correlation and causation according to the text?",
+          "options": [
+            "Correlation and causation are the same thing",
+            "Correlation reveals relationships while causation requires controlled experimental manipulation and confounding variable elimination",
+            "Causation is easier to establish than correlation",
+            "Correlation requires more data than causation"
+          ],
+          "correct_answer": 1
+        },
+        {
+          "question": "What advantage do longitudinal studies have over cross-sectional designs?",
+          "options": [
+            "They are cheaper to conduct",
+            "They require fewer participants",
+            "They track cohorts across time, revealing developmental patterns and causal sequences",
+            "They are simpler to analyze statistically"
+          ],
+          "correct_answer": 2
+        },
+        {
+          "question": "What does meta-analysis accomplish in research?",
+          "options": [
+            "It replaces the need for new research",
+            "It synthesizes findings across multiple independent studies, enhancing generalizability and statistical power",
+            "It reduces the cost of individual studies",
+            "It eliminates the need for statistical significance testing"
+          ],
+          "correct_answer": 1
+        }
+      ]
     },
     "lesson3": {
       "title": "Qualitative Research and Interpretive Methodologies",
-      "content": "Qualitative research methodology embraces interpretive paradigms that prioritize comprehensive understanding of complex social phenomena through detailed narrative analysis and contextual interpretation. Ethnographic approaches involve extensive participant observation, immersive fieldwork, and cultural interpretation through prolonged engagement with research participants. Phenomenological investigations explore lived experiences, consciousness structures, and subjective meaning-making processes through in-depth interview techniques. Grounded theory methodology emphasizes systematic data collection, theoretical sampling, and iterative analysis for theory development from empirical observations. Hermeneutical approaches focus on textual interpretation, discourse analysis, and the historical contextualization of cultural artifacts. Narrative research examines personal stories, biographical accounts, and identity construction through temporal sequence analysis. Case study methodology provides comprehensive investigation of specific instances, organizations, or phenomena within natural settings. Action research integrates investigation with practical intervention, emphasizing collaborative participation and social change objectives. Data collection techniques include semi-structured interviews, focus group discussions, participant observation, and document analysis procedures. Coding procedures involve open, axial, and selective approaches for pattern identification and categorical development. Triangulation strategies enhance credibility through multiple data sources, investigator perspectives, and theoretical frameworks. Member checking validates interpretations through participant feedback and collaborative meaning verification. Transferability replaces generalizability through detailed contextual description and theoretical conceptualization. Confirmability ensures objectivity through reflexive journaling, audit trails, and peer debriefing processes. Advanced qualitative analysis software facilitates systematic coding, pattern recognition, and theoretical model development."
+      "content": "Qualitative research methodology embraces interpretive paradigms that prioritize comprehensive understanding of complex social phenomena through detailed narrative analysis and contextual interpretation. Ethnographic approaches involve extensive participant observation, immersive fieldwork, and cultural interpretation through prolonged engagement with research participants. Phenomenological investigations explore lived experiences, consciousness structures, and subjective meaning-making processes through in-depth interview techniques. Grounded theory methodology emphasizes systematic data collection, theoretical sampling, and iterative analysis for theory development from empirical observations. Hermeneutical approaches focus on textual interpretation, discourse analysis, and the historical contextualization of cultural artifacts. Narrative research examines personal stories, biographical accounts, and identity construction through temporal sequence analysis. Case study methodology provides comprehensive investigation of specific instances, organizations, or phenomena within natural settings. Action research integrates investigation with practical intervention, emphasizing collaborative participation and social change objectives. Data collection techniques include semi-structured interviews, focus group discussions, participant observation, and document analysis procedures. Coding procedures involve open, axial, and selective approaches for pattern identification and categorical development. Triangulation strategies enhance credibility through multiple data sources, investigator perspectives, and theoretical frameworks. Member checking validates interpretations through participant feedback and collaborative meaning verification. Transferability replaces generalizability through detailed contextual description and theoretical conceptualization. Confirmability ensures objectivity through reflexive journaling, audit trails, and peer debriefing processes. Advanced qualitative analysis software facilitates systematic coding, pattern recognition, and theoretical model development.",
+      "questions": [
+        {
+          "question": "What is the primary focus of phenomenological investigations?",
+          "options": [
+            "Statistical analysis of large datasets",
+            "Exploring lived experiences, consciousness structures, and subjective meaning-making processes",
+            "Experimental manipulation of variables",
+            "Cost-benefit analysis of interventions"
+          ],
+          "correct_answer": 1
+        },
+        {
+          "question": "How does 'transferability' differ from 'generalizability' in qualitative research?",
+          "options": [
+            "They are identical concepts",
+            "Transferability is less rigorous than generalizability",
+            "Transferability replaces generalizability through detailed contextual description and theoretical conceptualization",
+            "Generalizability is only used in qualitative research"
+          ],
+          "correct_answer": 2
+        },
+        {
+          "question": "What is the purpose of 'member checking' in qualitative research?",
+          "options": [
+            "To reduce research costs",
+            "To validate interpretations through participant feedback and collaborative meaning verification",
+            "To recruit new participants",
+            "To analyze statistical data"
+          ],
+          "correct_answer": 1
+        }
+      ]
     }
   },
   "dialogs": [
@@ -241,6 +337,38 @@
         "Dr. Rodriguez: The implications extend beyond immediate findings to broader theoretical frameworks and practical applications in educational policy development and implementation.",
         "Prof. Chen: Longitudinal tracking enables causal inference through temporal sequence analysis, but correlation does not necessarily establish definitive causation relationships.",
         "Dr. Williams: Meta-analysis synthesis across multiple studies enhances generalizability while acknowledging contextual variations and methodological differences between investigations."
+      ],
+      "questions": [
+        {
+          "question": "According to the discussion, what research approach did Dr. Rodriguez's team use?",
+          "options": [
+            "Only quantitative methods",
+            "Only qualitative methods",
+            "Mixed-methods triangulation",
+            "Pure theoretical analysis"
+          ],
+          "correct_answer": 2
+        },
+        {
+          "question": "What concern did Prof. Chen raise about the quantitative approach?",
+          "options": [
+            "It was too expensive",
+            "The qualitative interpretation lacked phenomenological depth and hermeneutical rigor",
+            "It used too many participants",
+            "It was too time-consuming"
+          ],
+          "correct_answer": 1
+        },
+        {
+          "question": "What is the relationship between correlation and causation according to the dialog?",
+          "options": [
+            "They are the same thing",
+            "Correlation proves causation",
+            "Correlation does not necessarily establish definitive causation relationships",
+            "Causation is easier to prove than correlation"
+          ],
+          "correct_answer": 2
+        }
       ]
     },
     {
diff --git a/src/DRS/UnifiedDRS.js b/src/DRS/UnifiedDRS.js
index d9d6ffb..99726f2 100644
--- a/src/DRS/UnifiedDRS.js
+++ b/src/DRS/UnifiedDRS.js
@@ -6,6 +6,7 @@
 import Module from '../core/Module.js';
 import componentRegistry from '../components/ComponentRegistry.js';
 import ContentDependencyAnalyzer from './services/ContentDependencyAnalyzer.js';
+import exerciseFactory from './factories/ExerciseFactory.js';
 
 class UnifiedDRS extends Module {
     constructor(name, dependencies, config) {
@@ -1081,7 +1082,7 @@ class UnifiedDRS extends Module {
     }
 
     /**
-     * Load Word Discovery Module
+     * Load Word Discovery Module using ExerciseFactory
      */
     async _loadWordDiscoveryModule(exerciseType, config) {
         try {
@@ -1090,40 +1091,13 @@ class UnifiedDRS extends Module {
             // Get chapter content
             const chapterContent = await this._contentLoader.getContent(config.chapterId);
 
-            // Import and initialize Word Discovery Module
-            const { default: WordDiscoveryModule } = await import('./exercise-modules/WordDiscoveryModule.js');
-
-            // Get shared services from orchestrator if available
-            let prerequisiteEngine = null;
-            try {
-                const moduleLoader = window.app.getCore().moduleLoader;
-                const orchestrator = moduleLoader.getModule('smartPreviewOrchestrator');
-                if (orchestrator) {
-                    prerequisiteEngine = orchestrator.sharedServices?.prerequisiteEngine;
-                }
-            } catch (error) {
-                console.log('Could not get prerequisite engine:', error);
-            }
-
-            if (!prerequisiteEngine) {
-                throw new Error('PrerequisiteEngine not available');
-            }
-
-            // Initialize the word discovery module
-            const wordDiscoveryModule = new WordDiscoveryModule(
-                this, // orchestrator reference
-                null, // llmValidator (not needed for discovery)
-                prerequisiteEngine,
-                null  // contextMemory (not needed for discovery)
-            );
-
-            // Present the word discovery interface
-            await wordDiscoveryModule.present(this._container, {
+            const content = {
                 chapterContent: chapterContent,
                 exerciseType: exerciseType
-            });
+            };
 
-            console.log('✅ Word Discovery Module loaded successfully');
+            // Use generic helper
+            await this._loadExerciseViaFactory('vocabulary-discovery', config, content);
 
         } catch (error) {
             console.error('❌ Error loading Word Discovery Module:', error);
@@ -1132,11 +1106,11 @@ class UnifiedDRS extends Module {
     }
 
     /**
-     * Load DRS VocabularyModule (integrated flashcard system)
+     * Load DRS VocabularyModule (integrated flashcard system) using ExerciseFactory
      */
     async _loadVocabularyModule(exerciseType, config) {
         try {
-            console.log('📚 Loading DRS VocabularyModule (flashcard system)...');
+            console.log('📚 Loading DRS VocabularyModule...');
 
             // Load content for vocabulary exercises
             const chapterContent = await this._contentLoader.getContent(config.chapterId);
@@ -1146,64 +1120,6 @@ class UnifiedDRS extends Module {
                 throw new Error('No vocabulary content found for flashcards');
             }
 
-            // Import VocabularyModule from DRS
-            const { default: VocabularyModule } = await import('./exercise-modules/VocabularyModule.js');
-
-            // Get shared services from orchestrator or create fallbacks
-            let prerequisiteEngine = null;
-            let contextMemory = null;
-            try {
-                const moduleLoader = window.app.getCore().moduleLoader;
-                const orchestrator = moduleLoader.getModule('smartPreviewOrchestrator');
-                if (orchestrator && orchestrator.sharedServices) {
-                    prerequisiteEngine = orchestrator.sharedServices.prerequisiteEngine;
-                    contextMemory = orchestrator.sharedServices.contextMemory;
-                }
-            } catch (error) {
-                console.log('Could not get shared services, will create fallbacks:', error);
-            }
-
-            // Create PrerequisiteEngine if not available
-            if (!prerequisiteEngine) {
-                console.log('📚 Creating enhanced PrerequisiteEngine for VocabularyModule');
-
-                // Import and create enhanced PrerequisiteEngine
-                const PrerequisiteEngine = (await import('./services/PrerequisiteEngine.js')).default;
-                prerequisiteEngine = new PrerequisiteEngine();
-
-                // Initialize with persistent data for this chapter
-                await prerequisiteEngine.init(config.bookId, config.chapterId);
-
-                // Initialize with chapter content
-                if (chapterContent) {
-                    prerequisiteEngine.analyzeChapter(chapterContent);
-                    console.log(`📚 Initialized PrerequisiteEngine with chapter content`);
-                }
-            }
-
-            if (!contextMemory) {
-                console.log('📚 Creating fallback ContextMemory for VocabularyModule');
-                contextMemory = {
-                    recordInteraction: (interaction) => {
-                        console.log('📝 Interaction recorded (fallback):', interaction.type);
-                    }
-                };
-            }
-
-            // Create VocabularyModule instance
-            const vocabularyModule = new VocabularyModule(
-                this, // orchestrator reference
-                null, // llmValidator (not needed for local validation)
-                prerequisiteEngine,
-                contextMemory
-            );
-
-            // Store reference for cleanup
-            this._currentModule = vocabularyModule;
-
-            // Initialize the module
-            await vocabularyModule.init();
-
             // Prepare exercise data - convert vocabulary to expected format
             const vocabularyArray = Object.entries(chapterContent.vocabulary).map(([word, data]) => {
                 // Extract translation string from various possible formats
@@ -1232,14 +1148,14 @@ class UnifiedDRS extends Module {
                 };
             });
 
-            // Present vocabulary exercises
-            await vocabularyModule.present(this._container, {
+            const content = {
                 vocabulary: vocabularyArray,
                 chapterId: config.chapterId,
                 exerciseType: exerciseType
-            });
+            };
 
-            console.log('✅ DRS VocabularyModule (flashcards) started successfully');
+            // Use generic helper - always use 'vocabulary-flashcards' type for vocabulary module
+            await this._loadExerciseViaFactory('vocabulary-flashcards', config, content);
 
         } catch (error) {
             console.error('❌ Failed to load DRS VocabularyModule:', error);
@@ -1254,16 +1170,16 @@ class UnifiedDRS extends Module {
     }
 
     /**
-     * Load and initialize AI Analysis Module
+     * Load and initialize AI Analysis Module using ExerciseFactory
      */
     async _loadAIAnalysisModule(exerciseType, config) {
         try {
-            console.log('🤖 Loading AI Analysis Module for real chapter content...');
+            console.log('🤖 Loading AI Analysis Module...');
 
             // Load real chapter content first
             const contentRequest = {
                 type: 'exercise',
-                subtype: 'reading-comprehension-AI',
+                subtype: exerciseType,
                 bookId: config.bookId,
                 chapterId: config.chapterId,
                 difficulty: config.difficulty || 'medium'
@@ -1272,17 +1188,10 @@ class UnifiedDRS extends Module {
             let chapterContent;
             try {
                 chapterContent = await this._contentLoader.loadExercise(contentRequest);
-                console.log('📚 Chapter content loaded - FULL STRUCTURE:', chapterContent);
-                console.log('📚 Chapter content analysis:', {
+                console.log('📚 Chapter content loaded:', {
                     contentKeys: Object.keys(chapterContent),
                     hasDialogs: !!chapterContent.dialogs,
-                    dialogCount: chapterContent.dialogs ? Object.keys(chapterContent.dialogs).length : 0,
-                    hasConversations: !!chapterContent.conversations,
-                    hasSteps: !!chapterContent.steps,
-                    stepsCount: chapterContent.steps ? chapterContent.steps.length : 0,
-                    hasContent: !!chapterContent.content,
-                    hasVocabulary: !!chapterContent.vocabulary,
-                    vocabCount: chapterContent.vocabulary ? chapterContent.vocabulary.length : 0
+                    hasVocabulary: !!chapterContent.vocabulary
                 });
             } catch (error) {
                 console.warn('⚠️ Failed to load chapter content:', error);
@@ -1295,61 +1204,15 @@ class UnifiedDRS extends Module {
                 throw new Error('No real content found in chapter. AI Analysis requires real chapter content - no fallback available.');
             }
 
-            // Setup container with proper AI interface
-            this._container.innerHTML = `
-                <div class="ai-text-analysis">
-                    <div class="ai-header">
-                        <h2>🤖 AI Dialog Analysis</h2>
-                        <p class="chapter-info">
-                            <strong>Chapter:</strong> ${config.chapterId || 'Unknown'} |
-                            <strong>Real Dialogues:</strong> ${dialogues.length} found
-                        </p>
-                    </div>
+            // Prepare content for the module
+            const content = {
+                dialogues: dialogues,
+                chapterContent: chapterContent,
+                exerciseType: exerciseType
+            };
 
-                    <div class="dialog-content">
-                        <h3>📖 Chapter Dialog</h3>
-                        <div class="dialog-text" id="dialogText">
-                            ${this._formatDialogForDisplay(dialogues[0])}
-                        </div>
-                    </div>
-
-                    <div class="analysis-section">
-                        <h3>💭 Analysis Question</h3>
-                        <div class="question-text" id="questionText">
-                            What is the main topic of this dialog? Explain the context and key information discussed.
-                        </div>
-
-                        <div class="response-area">
-                            <textarea
-                                id="userResponse"
-                                placeholder="Write your analysis of the dialog here... (minimum 30 characters)"
-                                rows="4"
-                                maxlength="500"
-                            ></textarea>
-                            <div class="input-info">
-                                <span id="charCount">0</span>/500 characters (minimum 30)
-                            </div>
-                            <button id="submitResponse" class="submit-btn" disabled>
-                                🔍 Get AI Feedback
-                            </button>
-                        </div>
-                    </div>
-
-                    <div class="feedback-section" id="feedbackSection" style="display: none;">
-                        <h3>🎯 AI Feedback & Scoring</h3>
-                        <div class="feedback-content" id="feedbackContent"></div>
-                        <div class="action-buttons" id="actionButtons"></div>
-                    </div>
-                </div>
-            `;
-
-            // Add CSS styling for better UI
-            this._addAIAnalysisStyles();
-
-            // Setup event handlers for the AI interface
-            this._setupAIInterface(dialogues, chapterContent);
-
-            console.log('✅ AI Analysis interface loaded with real chapter content');
+            // Use generic helper
+            await this._loadExerciseViaFactory(exerciseType, config, content);
 
         } catch (error) {
             console.error('❌ Failed to load AI Analysis Module:', error);
@@ -2715,6 +2578,100 @@ class UnifiedDRS extends Module {
         return allText.join(' ');
     }
 
+    /**
+     * Generic helper to load any exercise via ExerciseFactory
+     * @param {string} exerciseType - Type of exercise to load
+     * @param {Object} config - Exercise configuration
+     * @param {Object} content - Exercise content
+     * @returns {Promise<Object>} - Created module instance
+     */
+    async _loadExerciseViaFactory(exerciseType, config, content) {
+        console.log(`🏭 Loading ${exerciseType} via factory...`);
+
+        try {
+            // Get dependencies
+            const dependencies = await this._getDependencies(config);
+
+            // Use factory to create and render module
+            const module = await exerciseFactory.createAndRender(
+                exerciseType,
+                this._container,
+                dependencies,
+                config,
+                content
+            );
+
+            // Store reference for cleanup
+            this._currentModule = module;
+
+            console.log(`✅ ${exerciseType} loaded successfully via factory`);
+            return module;
+
+        } catch (error) {
+            console.error(`❌ Failed to load ${exerciseType}:`, error);
+            throw error;
+        }
+    }
+
+    /**
+     * Get dependencies for exercise modules
+     * @param {Object} config - Exercise configuration
+     * @returns {Promise<Object>} - Dependencies object
+     */
+    async _getDependencies(config) {
+        // Get shared services from orchestrator or create fallbacks
+        let prerequisiteEngine = null;
+        let contextMemory = null;
+        let llmValidator = null;
+
+        try {
+            const moduleLoader = window.app.getCore().moduleLoader;
+            const orchestrator = moduleLoader.getModule('smartPreviewOrchestrator');
+            if (orchestrator && orchestrator.sharedServices) {
+                prerequisiteEngine = orchestrator.sharedServices.prerequisiteEngine;
+                contextMemory = orchestrator.sharedServices.contextMemory;
+                llmValidator = orchestrator.sharedServices.llmValidator;
+            }
+        } catch (error) {
+            console.log('Could not get shared services, will create fallbacks:', error);
+        }
+
+        // Create PrerequisiteEngine if not available
+        if (!prerequisiteEngine) {
+            console.log('📚 Creating enhanced PrerequisiteEngine');
+
+            const PrerequisiteEngine = (await import('./services/PrerequisiteEngine.js')).default;
+            prerequisiteEngine = new PrerequisiteEngine();
+
+            // Initialize with persistent data for this chapter
+            if (config.bookId && config.chapterId) {
+                await prerequisiteEngine.init(config.bookId, config.chapterId);
+            }
+        }
+
+        // Create ContextMemory if not available
+        if (!contextMemory) {
+            console.log('📚 Creating fallback ContextMemory');
+            contextMemory = {
+                recordInteraction: (interaction) => {
+                    console.log('📝 Interaction recorded (fallback):', interaction.type);
+                }
+            };
+        }
+
+        // LLMValidator is optional (only needed for AI modules)
+        if (!llmValidator) {
+            console.log('ℹ️ LLMValidator not available (optional for some modules)');
+        }
+
+        return {
+            orchestrator: this, // UnifiedDRS acts as orchestrator
+            prerequisiteEngine: prerequisiteEngine,
+            contextMemory: contextMemory,
+            llmValidator: llmValidator
+        };
+    }
+
     /**
      * Clean up UI
      */
diff --git a/src/DRS/factories/ExerciseFactory.js b/src/DRS/factories/ExerciseFactory.js
new file mode 100644
index 0000000..0fb147b
--- /dev/null
+++ b/src/DRS/factories/ExerciseFactory.js
@@ -0,0 +1,298 @@
+/**
+ * ExerciseFactory - Factory for creating DRS exercise modules
+ *
+ * Creates exercise modules that implement DRSExerciseInterface
+ * Provides unified creation, initialization, and lifecycle management
+ */
+
+import DRSExerciseInterface from '../interfaces/DRSExerciseInterface.js';
+
+class ExerciseFactory {
+    constructor() {
+        // Registry of available exercise modules
+        this._moduleRegistry = new Map();
+
+        // Module type to class name mapping
+        this._typeMap = {
+            'vocabulary-flashcards': 'VocabularyModule',
+            'vocabulary-discovery': 'WordDiscoveryModule',
+            'text': 'TextModule',
+            'text-analysis': 'TextAnalysisModule',
+            'reading': 'TextModule',
+            'reading-comprehension': 'TextModule',
+            'reading-comprehension-AI': 'TextAnalysisModule',
+            'grammar': 'GrammarModule',
+            'grammar-analysis': 'GrammarAnalysisModule',
+            'grammar-practice': 'GrammarModule',
+            'grammar-practice-AI': 'GrammarAnalysisModule',
+            'translation': 'TranslationModule',
+            'open-response': 'OpenResponseModule',
+            'phrase': 'PhraseModule',
+            'phrase-practice': 'PhraseModule',
+            'audio': 'AudioModule',
+            'listening-comprehension': 'AudioModule',
+            'listening-comprehension-AI': 'AudioModule',
+            'visual-description': 'ImageModule',
+            'visual-description-AI': 'ImageModule'
+        };
+
+        // Cache for loaded module classes
+        this._classCache = new Map();
+    }
+
+    /**
+     * Create an exercise module by type
+     * @param {string} exerciseType - Type of exercise to create
+     * @param {Object} dependencies - Dependencies (orchestrator, llmValidator, prerequisiteEngine, contextMemory)
+     * @param {Object} config - Exercise configuration
+     * @param {Object} content - Exercise content (optional, can be passed later to init)
+     * @returns {Promise<DRSExerciseInterface>} - Exercise module instance
+     */
+    async create(exerciseType, dependencies, config = {}, content = null) {
+        console.log(`🏭 ExerciseFactory creating: ${exerciseType}`);
+
+        // Validate exercise type
+        if (!this._typeMap[exerciseType]) {
+            throw new Error(`Unknown exercise type: ${exerciseType}. Available types: ${Object.keys(this._typeMap).join(', ')}`);
+        }
+
+        // Get module class name
+        const className = this._typeMap[exerciseType];
+        console.log(`📦 Resolved to module class: ${className}`);
+
+        // Load module class (with caching)
+        const ModuleClass = await this._loadModuleClass(className);
+
+        // Validate dependencies
+        this._validateDependencies(className, dependencies);
+
+        // Create instance
+        const instance = new ModuleClass(
+            dependencies.orchestrator,
+            dependencies.llmValidator,
+            dependencies.prerequisiteEngine,
+            dependencies.contextMemory
+        );
+
+        // Validate interface implementation
+        this._validateInterface(instance, className);
+
+        // Initialize the module with config and content
+        await instance.init(config, content);
+
+        console.log(`✅ ${className} created and initialized`);
+        return instance;
+    }
+
+    /**
+     * Load module class (with caching)
+     * @param {string} className - Name of the module class
+     * @returns {Promise<Class>} - Module class
+     */
+    async _loadModuleClass(className) {
+        // Check cache first
+        if (this._classCache.has(className)) {
+            console.log(`📦 Using cached class: ${className}`);
+            return this._classCache.get(className);
+        }
+
+        // Determine file path based on class name
+        let modulePath;
+        if (className === 'WordDiscoveryModule') {
+            modulePath = '../exercise-modules/WordDiscoveryModule.js';
+        } else if (className.endsWith('AnalysisModule')) {
+            modulePath = `../exercise-modules/${className}.js`;
+        } else {
+            modulePath = `../exercise-modules/${className}.js`;
+        }
+
+        console.log(`📂 Loading module from: ${modulePath}`);
+
+        try {
+            const module = await import(modulePath);
+            const ModuleClass = module.default;
+
+            // Cache the class
+            this._classCache.set(className, ModuleClass);
+
+            return ModuleClass;
+        } catch (error) {
+            throw new Error(`Failed to load module class ${className} from ${modulePath}: ${error.message}`);
+        }
+    }
+
+    /**
+     * Validate dependencies
+     * @param {string} className - Module class name
+     * @param {Object} dependencies - Dependencies object
+     */
+    _validateDependencies(className, dependencies) {
+        const required = ['orchestrator', 'prerequisiteEngine'];
+
+        // Modules that don't need AI validation
+        const noAIModules = ['VocabularyModule', 'WordDiscoveryModule'];
+
+        // Check required dependencies
+        for (const dep of required) {
+            if (!dependencies[dep]) {
+                throw new Error(`${className} requires dependency: ${dep}`);
+            }
+        }
+
+        // Check optional dependencies (warn if missing, except for no-AI modules)
+        if (!dependencies.llmValidator && !noAIModules.includes(className)) {
+            console.warn(`⚠️ ${className} missing optional dependency: llmValidator`);
+        }
+
+        if (!dependencies.contextMemory) {
+            console.warn(`⚠️ ${className} missing optional dependency: contextMemory`);
+        }
+    }
+
+    /**
+     * Validate that instance implements DRSExerciseInterface
+     * @param {Object} instance - Module instance
+     * @param {string} className - Class name for error messages
+     */
+    _validateInterface(instance, className) {
+        const requiredMethods = [
+            'init', 'render', 'destroy', 'validate',
+            'getResults', 'handleUserInput', 'markCompleted',
+            'getProgress', 'getExerciseType', 'getExerciseConfig'
+        ];
+
+        const missing = [];
+        for (const method of requiredMethods) {
+            if (typeof instance[method] !== 'function') {
+                missing.push(method);
+            }
+        }
+
+        if (missing.length > 0) {
+            throw new Error(
+                `${className} does not properly implement DRSExerciseInterface.\n` +
+                `Missing methods: ${missing.join(', ')}\n` +
+                `All DRS modules MUST implement the full interface.`
+            );
+        }
+
+        console.log(`✅ ${className} implements DRSExerciseInterface correctly`);
+    }
+
+    /**
+     * Get all supported exercise types
+     * @returns {string[]} - Array of exercise type strings
+     */
+    getSupportedTypes() {
+        return Object.keys(this._typeMap);
+    }
+
+    /**
+     * Check if exercise type is supported
+     * @param {string} exerciseType - Type to check
+     * @returns {boolean} - True if supported
+     */
+    isSupported(exerciseType) {
+        return this._typeMap.hasOwnProperty(exerciseType);
+    }
+
+    /**
+     * Get module class name for exercise type
+     * @param {string} exerciseType - Exercise type
+     * @returns {string} - Class name
+     */
+    getModuleClassName(exerciseType) {
+        return this._typeMap[exerciseType] || null;
+    }
+
+    /**
+     * Create exercise and render it immediately
+     * @param {string} exerciseType - Type of exercise
+     * @param {HTMLElement} container - Container element
+     * @param {Object} dependencies - Dependencies
+     * @param {Object} config - Configuration
+     * @param {Object} content - Exercise content
+     * @returns {Promise<DRSExerciseInterface>} - Created and rendered module
+     */
+    async createAndRender(exerciseType, container, dependencies, config, content) {
+        console.log(`🎨 Creating and rendering ${exerciseType}...`);
+
+        // Create the module with config and content
+        const module = await this.create(exerciseType, dependencies, config, content);
+
+        // Render it (content already passed in init)
+        await module.render(container);
+
+        console.log(`✅ ${exerciseType} created and rendered`);
+        return module;
+    }
+
+    /**
+     * Batch create multiple modules (for preloading)
+     * @param {Array} exerciseTypes - Array of exercise types to create
+     * @param {Object} dependencies - Shared dependencies
+     * @returns {Promise<Map>} - Map of type -> instance
+     */
+    async batchCreate(exerciseTypes, dependencies) {
+        console.log(`🏭 Batch creating ${exerciseTypes.length} modules...`);
+
+        const instances = new Map();
+        const errors = [];
+
+        for (const type of exerciseTypes) {
+            try {
+                const instance = await this.create(type, dependencies);
+                instances.set(type, instance);
+            } catch (error) {
+                errors.push({ type, error: error.message });
+                console.error(`❌ Failed to create ${type}:`, error);
+            }
+        }
+
+        if (errors.length > 0) {
+            console.warn(`⚠️ ${errors.length} modules failed to create:`, errors);
+        }
+
+        console.log(`✅ Batch created ${instances.size}/${exerciseTypes.length} modules`);
+        return instances;
+    }
+
+    /**
+     * Destroy module and clean up
+     * @param {DRSExerciseInterface} module - Module to destroy
+     */
+    async destroy(module) {
+        if (!module) return;
+
+        try {
+            await module.destroy();
+            console.log(`🧹 Module destroyed: ${module.getExerciseType()}`);
+        } catch (error) {
+            console.error('Failed to destroy module:', error);
+        }
+    }
+
+    /**
+     * Get factory statistics
+     * @returns {Object} - Factory stats
+     */
+    getStats() {
+        return {
+            supportedTypes: this.getSupportedTypes().length,
+            cachedClasses: this._classCache.size,
+            typeMapping: Object.keys(this._typeMap).length
+        };
+    }
+
+    /**
+     * Clear class cache (for hot reload during development)
+     */
+    clearCache() {
+        this._classCache.clear();
+        console.log('🧹 ExerciseFactory class cache cleared');
+    }
+}
+
+// Export singleton instance
+const exerciseFactory = new ExerciseFactory();
+export default exerciseFactory;
diff --git a/test-factory.html b/test-factory.html
new file mode 100644
index 0000000..d0b0bef
--- /dev/null
+++ b/test-factory.html
@@ -0,0 +1,310 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>ExerciseFactory Test</title>
+    <style>
+        body {
+            font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, sans-serif;
+            max-width: 1200px;
+            margin: 0 auto;
+            padding: 20px;
+            background: #f5f5f5;
+        }
+        h1 { color: #333; }
+        .test-section {
+            background: white;
+            padding: 20px;
+            margin: 20px 0;
+            border-radius: 8px;
+            box-shadow: 0 2px 4px rgba(0,0,0,0.1);
+        }
+        .test-item {
+            padding: 10px;
+            margin: 5px 0;
+            border-left: 4px solid #ddd;
+            display: flex;
+            justify-content: space-between;
+            align-items: center;
+        }
+        .test-item.pending { border-color: #ffc107; background: #fff8e1; }
+        .test-item.success { border-color: #4caf50; background: #e8f5e9; }
+        .test-item.error { border-color: #f44336; background: #ffebee; }
+        .status { font-weight: bold; }
+        .status.pending { color: #f57f17; }
+        .status.success { color: #2e7d32; }
+        .status.error { color: #c62828; }
+        button {
+            padding: 10px 20px;
+            background: #2196f3;
+            color: white;
+            border: none;
+            border-radius: 4px;
+            cursor: pointer;
+            font-size: 16px;
+        }
+        button:hover { background: #1976d2; }
+        button:disabled { background: #ccc; cursor: not-allowed; }
+        .details {
+            font-size: 12px;
+            color: #666;
+            margin-top: 5px;
+        }
+        pre {
+            background: #f5f5f5;
+            padding: 10px;
+            border-radius: 4px;
+            overflow-x: auto;
+            font-size: 12px;
+        }
+    </style>
+</head>
+<body>
+    <h1>🏭 ExerciseFactory Test Suite</h1>
+
+    <div class="test-section">
+        <h2>Factory Validation Tests</h2>
+        <div id="validation-tests"></div>
+        <button id="run-validation">Run Validation Tests</button>
+    </div>
+
+    <div class="test-section">
+        <h2>Module Creation Tests (11 modules)</h2>
+        <div id="creation-tests"></div>
+        <button id="run-creation">Run Creation Tests</button>
+    </div>
+
+    <div class="test-section">
+        <h2>Interface Compliance Tests</h2>
+        <div id="interface-tests"></div>
+        <button id="run-interface">Run Interface Tests</button>
+    </div>
+
+    <div class="test-section">
+        <h2>Test Results Summary</h2>
+        <div id="summary"></div>
+    </div>
+
+    <script type="module">
+        import exerciseFactory from './src/DRS/factories/ExerciseFactory.js';
+
+        const results = {
+            validation: [],
+            creation: [],
+            interface: []
+        };
+
+        // Mock dependencies
+        const mockDependencies = {
+            orchestrator: {
+                name: 'MockOrchestrator',
+                _eventBus: { emit: () => {} }
+            },
+            prerequisiteEngine: {
+                isDiscovered: () => false,
+                isWordMastered: () => false,
+                markDiscovered: () => {},
+                markMastered: () => {},
+                init: async () => {}
+            },
+            contextMemory: {
+                recordInteraction: () => {}
+            },
+            llmValidator: {
+                validate: async () => ({ success: true, score: 100 })
+            }
+        };
+
+        // Validation Tests
+        document.getElementById('run-validation').addEventListener('click', async () => {
+            const container = document.getElementById('validation-tests');
+            container.innerHTML = '<p>Running validation tests...</p>';
+
+            const tests = [
+                {
+                    name: 'Factory exports correctly',
+                    test: () => exerciseFactory !== undefined
+                },
+                {
+                    name: 'getSupportedTypes() returns array',
+                    test: () => Array.isArray(exerciseFactory.getSupportedTypes())
+                },
+                {
+                    name: 'Has at least 10 supported types',
+                    test: () => exerciseFactory.getSupportedTypes().length >= 10
+                },
+                {
+                    name: 'isSupported() works for valid type',
+                    test: () => exerciseFactory.isSupported('vocabulary-flashcards')
+                },
+                {
+                    name: 'isSupported() rejects invalid type',
+                    test: () => !exerciseFactory.isSupported('invalid-type')
+                }
+            ];
+
+            container.innerHTML = '';
+            for (const test of tests) {
+                try {
+                    const passed = test.test();
+                    results.validation.push({ name: test.name, passed, error: null });
+                    container.innerHTML += `
+                        <div class="test-item ${passed ? 'success' : 'error'}">
+                            <span>${test.name}</span>
+                            <span class="status ${passed ? 'success' : 'error'}">${passed ? '✅ PASS' : '❌ FAIL'}</span>
+                        </div>
+                    `;
+                } catch (error) {
+                    results.validation.push({ name: test.name, passed: false, error: error.message });
+                    container.innerHTML += `
+                        <div class="test-item error">
+                            <span>${test.name}</span>
+                            <span class="status error">❌ ERROR: ${error.message}</span>
+                        </div>
+                    `;
+                }
+            }
+            updateSummary();
+        });
+
+        // Creation Tests
+        document.getElementById('run-creation').addEventListener('click', async () => {
+            const container = document.getElementById('creation-tests');
+            container.innerHTML = '<p>Running creation tests (this may take a moment)...</p>';
+
+            const exerciseTypes = exerciseFactory.getSupportedTypes().slice(0, 11); // Test first 11
+
+            container.innerHTML = '';
+            for (const type of exerciseTypes) {
+                const testDiv = document.createElement('div');
+                testDiv.className = 'test-item pending';
+                testDiv.innerHTML = `
+                    <span>Creating ${type}...</span>
+                    <span class="status pending">⏳ PENDING</span>
+                `;
+                container.appendChild(testDiv);
+
+                try {
+                    const mockContent = {
+                        vocabulary: [{ word: 'test', translation: 'test' }],
+                        dialogues: [{ content: 'test dialog' }],
+                        chapterContent: { vocabulary: {} }
+                    };
+
+                    const module = await exerciseFactory.create(
+                        type,
+                        mockDependencies,
+                        { difficulty: 'medium' },
+                        mockContent
+                    );
+
+                    // Check if module has required methods
+                    const hasRequiredMethods =
+                        typeof module.render === 'function' &&
+                        typeof module.destroy === 'function' &&
+                        typeof module.validate === 'function' &&
+                        typeof module.getExerciseType === 'function';
+
+                    if (hasRequiredMethods) {
+                        testDiv.className = 'test-item success';
+                        testDiv.innerHTML = `
+                            <span>✅ ${type}</span>
+                            <span class="status success">SUCCESS</span>
+                        `;
+                        results.creation.push({ name: type, passed: true, error: null });
+
+                        // Clean up
+                        await module.destroy();
+                    } else {
+                        throw new Error('Missing required methods');
+                    }
+                } catch (error) {
+                    testDiv.className = 'test-item error';
+                    testDiv.innerHTML = `
+                        <div>
+                            <span>❌ ${type}</span>
+                            <div class="details">${error.message}</div>
+                        </div>
+                        <span class="status error">FAILED</span>
+                    `;
+                    results.creation.push({ name: type, passed: false, error: error.message });
+                }
+            }
+            updateSummary();
+        });
+
+        // Interface Tests
+        document.getElementById('run-interface').addEventListener('click', async () => {
+            const container = document.getElementById('interface-tests');
+            container.innerHTML = '<p>Running interface compliance tests...</p>';
+
+            const requiredMethods = [
+                'init', 'render', 'destroy', 'validate',
+                'getResults', 'handleUserInput', 'markCompleted',
+                'getProgress', 'getExerciseType', 'getExerciseConfig'
+            ];
+
+            try {
+                const mockContent = {
+                    vocabulary: [{ word: 'test', translation: 'test' }]
+                };
+
+                const module = await exerciseFactory.create(
+                    'vocabulary-flashcards',
+                    mockDependencies,
+                    {},
+                    mockContent
+                );
+
+                container.innerHTML = '';
+                for (const method of requiredMethods) {
+                    const exists = typeof module[method] === 'function';
+                    results.interface.push({ name: `Method: ${method}`, passed: exists, error: null });
+                    container.innerHTML += `
+                        <div class="test-item ${exists ? 'success' : 'error'}">
+                            <span>${method}()</span>
+                            <span class="status ${exists ? 'success' : 'error'}">${exists ? '✅ EXISTS' : '❌ MISSING'}</span>
+                        </div>
+                    `;
+                }
+
+                await module.destroy();
+            } catch (error) {
+                container.innerHTML = `
+                    <div class="test-item error">
+                        <span>Interface test failed</span>
+                        <span class="status error">❌ ERROR: ${error.message}</span>
+                    </div>
+                `;
+            }
+            updateSummary();
+        });
+
+        function updateSummary() {
+            const summary = document.getElementById('summary');
+            const allTests = [...results.validation, ...results.creation, ...results.interface];
+            const passed = allTests.filter(t => t.passed).length;
+            const failed = allTests.filter(t => !t.passed).length;
+            const total = allTests.length;
+
+            const percentage = total > 0 ? Math.round((passed / total) * 100) : 0;
+
+            summary.innerHTML = `
+                <h3>📊 Overall Results</h3>
+                <div style="font-size: 24px; margin: 20px 0;">
+                    <strong>${passed}/${total}</strong> tests passed (${percentage}%)
+                </div>
+                <div class="test-item ${percentage === 100 ? 'success' : 'error'}">
+                    <span>✅ Passed: ${passed}</span>
+                    <span>❌ Failed: ${failed}</span>
+                </div>
+                <pre>${JSON.stringify(exerciseFactory.getStats(), null, 2)}</pre>
+            `;
+        }
+
+        // Auto-run validation on load
+        document.getElementById('run-validation').click();
+    </script>
+</body>
+</html>