diff --git a/.gitattributes b/.gitattributes
new file mode 100644
index 0000000000000000000000000000000000000000..c671c4b2aae90c838da3da1a8c7ac0471ec38580
--- /dev/null
+++ b/.gitattributes
@@ -0,0 +1,11 @@
+custom_components/st-audiorec/** filter=lfs diff=lfs merge=lfs -text
+*.wav filter=lfs diff=lfs merge=lfs -text
+*.mp3 filter=lfs diff=lfs merge=lfs -text
+*.ogg filter=lfs diff=lfs merge=lfs -text
+*.pt filter=lfs diff=lfs merge=lfs -text
+*.pth filter=lfs diff=lfs merge=lfs -text
+*.onnx filter=lfs diff=lfs merge=lfs -text
+*.bin filter=lfs diff=lfs merge=lfs -text
+*.tar.gz filter=lfs diff=lfs merge=lfs -text
+*.zip filter=lfs diff=lfs merge=lfs -text
+custom_components/** filter=lfs diff=lfs merge=lfs -text
diff --git a/.gitignore b/.gitignore
new file mode 100644
index 0000000000000000000000000000000000000000..d8752e9398ad6f5cfd421c553fc4a00ec98ee81e
--- /dev/null
+++ b/.gitignore
@@ -0,0 +1,47 @@
+# Python
+__pycache__/
+*.py[cod]
+*.pyo
+*.pyd
+*.pyc
+*.log
+*.sqlite3
+*.db
+venv/
+.venv/
+env/
+ENV/
+env.bak/
+pip-wheel-metadata/
+dist/
+*.egg-info/
+
+# Editor / OS
+.vscode/
+.idea/
+*.swp
+.DS_Store
+Thumbs.db
+
+# Node / frontend
+node_modules/
+npm-debug.log*
+yarn-error.log*
+package-lock.json
+.pnpm-debug.log
+
+# Specific frontend inside your component
+custom_components/st-audiorec/st_audiorec/frontend/node_modules/
+
+# Virtual env / credentials
+*.env
+.env.*
+
+# Hugging Face / caches
+.cache/
+.hf/
+
+# IDE metadata
+*.sublime-workspace
+*.sublime-project
+custom_components/st-audiorec/st_audiorec/frontend/node_modules
diff --git a/.kiro/specs/ai-questions/design.md b/.kiro/specs/ai-questions/design.md
new file mode 100644
index 0000000000000000000000000000000000000000..9ee31610c88d4db7bb61f765966f43893cbc7b10
--- /dev/null
+++ b/.kiro/specs/ai-questions/design.md
@@ -0,0 +1,262 @@
+# Design Document
+
+## Overview
+
+The AI Questions feature integrates with the existing SyncMaster broadcast system to provide interactive AI-powered questioning capabilities. Students can select any text segment from broadcast content and engage in natural language conversations with AI to better understand the material. The system leverages the existing Gemini AI infrastructure and maintains the current multilingual support.
+
+## Architecture
+
+### High-Level Architecture
+
+```
+┌─────────────────┐    ┌─────────────────┐    ┌─────────────────┐
+│   Broadcast UI  │    │  Question Engine│    │   AI Service    │
+│                 │    │                 │    │                 │
+│ - Text Selection│───▶│ - Context Prep  │───▶│ - Gemini AI     │
+│ - Ask AI Button │    │ - Question Proc │    │ - Translation   │
+│ - Response Area │◀───│ - Response Format│◀───│ - Conversation  │
+└─────────────────┘    └─────────────────┘    └─────────────────┘
+         │                       │                       │
+         │                       │                       │
+         ▼                       ▼                       ▼
+┌─────────────────┐    ┌─────────────────┐    ┌─────────────────┐
+│ Session State   │    │ Question History│    │ Context Manager │
+│                 │    │                 │    │                 │
+│ - Selected Text │    │ - Q&A Pairs     │    │ - Text Context  │
+│ - Active Conv   │    │ - Timestamps    │    │ - Conversation  │
+│ - UI Language   │    │ - User Prefs    │    │ - Memory Mgmt   │
+└─────────────────┘    └─────────────────┘    └─────────────────┘
+```
+
+### Component Integration
+
+The AI Questions feature integrates seamlessly with existing components:
+- **Broadcast System**: Uses existing `broadcast_segments` for text selection
+- **Translation System**: Leverages current `translator.py` for AI responses
+- **UI System**: Extends Streamlit interface with question components
+
+## Components and Interfaces
+
+### 1. Question Engine (`ai_questions.py`)
+
+**Primary Class: `AIQuestionEngine`**
+
+```python
+class AIQuestionEngine:
+    def __init__(self, translator_instance):
+        self.translator = translator_instance
+        self.conversation_history = {}
+        self.question_templates = {
+            'ar': [
+                "اشرح هذا النص",
+                "أعطني أمثلة على هذا",
+                "ما معنى هذا؟",
+                "كيف يُستخدم هذا؟",
+                "ما أهمية هذا؟"
+            ],
+            'en': [
+                "Explain this text",
+                "Give me examples of this",
+                "What does this mean?",
+                "How is this used?",
+                "Why is this important?"
+            ]
+        }
+    
+    def process_question(self, selected_text, question, ui_language='ar'):
+        """Process user question about selected text"""
+        
+    def get_question_templates(self, ui_language='ar'):
+        """Get pre-defined question templates"""
+        
+    def format_ai_response(self, response, ui_language='ar'):
+        """Format AI response for display"""
+        
+    def save_conversation(self, text_id, question, answer):
+        """Save Q&A pair to conversation history"""
+        
+    def get_conversation_history(self, text_id):
+        """Retrieve conversation history for specific text"""
+```
+
+### 2. UI Components (Extended `app.py`)
+
+**Text Selection Interface**
+- Click-to-select functionality for broadcast segments
+- Visual highlighting of selected text
+- Context-aware "Ask AI" button activation
+
+**Question Input Modal**
+- Template selection buttons
+- Free-form question input
+- Context display showing selected text
+- Submit and cancel options
+
+**Response Display Area**
+- Formatted AI responses
+- Conversation history
+- Copy functionality
+- Follow-up question options
+
+### 3. Context Manager
+
+**Text Context Preparation**
+```python
+@dataclass
+class QuestionContext:
+    selected_text: str
+    segment_info: Dict[str, Any]  # timestamp, translations, etc.
+    conversation_id: str
+    ui_language: str
+    previous_questions: List[Dict[str, str]]
+```
+
+**Conversation Management**
+- Maintains context across multiple questions
+- Manages conversation threads per text segment
+- Handles context window limitations
+- Provides conversation persistence
+
+## Data Models
+
+### Question Session
+```python
+@dataclass
+class QuestionSession:
+    session_id: str
+    selected_text: str
+    segment_id: str
+    start_timestamp: int
+    ui_language: str
+    conversation: List[QAPair]
+    created_at: datetime
+```
+
+### Q&A Pair
+```python
+@dataclass
+class QAPair:
+    question: str
+    answer: str
+    timestamp: datetime
+    question_type: str  # 'template' or 'custom'
+    response_time_ms: int
+```
+
+### Text Selection
+```python
+@dataclass
+class TextSelection:
+    text: str
+    segment_id: str
+    start_ms: int
+    end_ms: int
+    translations: Dict[str, str]
+    selection_timestamp: int
+```
+
+## Error Handling
+
+### AI Service Error Handling
+
+1. **Service Unavailability**
+   - Graceful degradation when Gemini AI is unavailable
+   - Clear error messages to users
+   - Retry mechanisms for transient failures
+
+2. **Response Quality Issues**
+   - Validation of AI responses
+   - Fallback to simpler question processing
+   - User feedback mechanisms for poor responses
+
+3. **Context Management Errors**
+   - Handling of oversized context windows
+   - Conversation history cleanup
+   - Memory management for long sessions
+
+### User Experience Error Handling
+
+```python
+def handle_question_error(self, error_type, context):
+    """Handle various question processing errors"""
+    error_messages = {
+        'ai_unavailable': {
+            'ar': 'خدمة الذكاء الاصطناعي غير متاحة حالياً. يرجى المحاولة لاحقاً.',
+            'en': 'AI service is currently unavailable. Please try again later.'
+        },
+        'invalid_selection': {
+            'ar': 'يرجى تحديد نص صالح قبل طرح السؤال.',
+            'en': 'Please select valid text before asking a question.'
+        },
+        'processing_timeout': {
+            'ar': 'انتهت مهلة معالجة السؤال. يرجى المحاولة مرة أخرى.',
+            'en': 'Question processing timed out. Please try again.'
+        }
+    }
+```
+
+## Testing Strategy
+
+### Unit Testing
+- **Question Processing Tests**: Various question types and text selections
+- **Context Management Tests**: Conversation history and memory management
+- **AI Integration Tests**: Response formatting and error handling
+- **UI Component Tests**: Text selection and modal interactions
+
+### Integration Testing
+- **End-to-End Question Flow**: From text selection to AI response display
+- **Multi-language Testing**: Arabic and English question processing
+- **Conversation Continuity**: Follow-up questions and context maintenance
+- **Performance Testing**: Response times and memory usage
+
+### User Acceptance Testing
+- **Student Workflow Testing**: Real-world usage scenarios
+- **Question Quality Testing**: Relevance and accuracy of AI responses
+- **Interface Usability Testing**: Ease of text selection and question input
+- **Accessibility Testing**: Screen reader compatibility and keyboard navigation
+
+## Implementation Phases
+
+### Phase 1: Core Question Engine
+- Implement `AIQuestionEngine` class
+- Add basic question processing with Gemini AI
+- Create question templates for both languages
+- Integrate with existing translator system
+
+### Phase 2: UI Integration
+- Add text selection functionality to broadcast segments
+- Implement "Ask AI" button and modal interface
+- Create question input and response display components
+- Add visual feedback for text selection
+
+### Phase 3: Conversation Management
+- Implement conversation history tracking
+- Add follow-up question capabilities
+- Create context management for multi-turn conversations
+- Add conversation persistence across sessions
+
+### Phase 4: Advanced Features
+- Add copy/export functionality for Q&A pairs
+- Implement conversation search and filtering
+- Add question analytics and usage tracking
+- Create advanced question templates and suggestions
+
+## Performance Considerations
+
+### Response Time Optimization
+- Asynchronous AI request processing
+- Response caching for common questions
+- Progressive loading for long conversations
+- Optimized context preparation
+
+### Memory Management
+- Efficient conversation history storage
+- Automatic cleanup of old conversations
+- Streaming responses for long AI answers
+- Optimized text selection handling
+
+### Scalability
+- Support for multiple concurrent question sessions
+- Efficient handling of large broadcast segments
+- Configurable conversation history limits
+- Resource usage monitoring and optimization
\ No newline at end of file
diff --git a/.kiro/specs/ai-questions/requirements.md b/.kiro/specs/ai-questions/requirements.md
new file mode 100644
index 0000000000000000000000000000000000000000..5069202607d5850fffa74646f966cd9618941bf6
--- /dev/null
+++ b/.kiro/specs/ai-questions/requirements.md
@@ -0,0 +1,91 @@
+# Requirements Document
+
+## Introduction
+
+This feature adds AI-powered question generation functionality to the SyncMaster broadcast system. Students can select any text segment from the broadcast and ask the AI to generate questions, explanations, or provide additional information about specific content. This enhances the learning experience by allowing interactive exploration of lecture content through intelligent questioning.
+
+## Requirements
+
+### Requirement 1
+
+**User Story:** As a student reviewing broadcast content, I want to select any text segment and ask AI questions about it, so that I can better understand specific concepts or get clarification on unclear points.
+
+#### Acceptance Criteria
+
+1. WHEN the user clicks on any broadcast segment THEN the system SHALL highlight the selected text
+2. WHEN text is selected THEN the system SHALL display a "❓ Ask AI" button
+3. WHEN the user clicks "Ask AI" THEN the system SHALL open a question input interface
+4. WHEN the user submits a question THEN the system SHALL send the selected text and question to the AI service
+5. IF no text is selected THEN the "Ask AI" button SHALL be disabled with explanatory tooltip
+
+### Requirement 2
+
+**User Story:** As a student, I want to ask different types of questions about the selected content, so that I can get explanations, examples, or deeper insights about the material.
+
+#### Acceptance Criteria
+
+1. WHEN the question interface opens THEN the system SHALL provide quick question templates
+2. WHEN templates are provided THEN they SHALL include: "Explain this", "Give examples", "What does this mean?", "How is this used?"
+3. WHEN the user selects a template THEN the system SHALL auto-fill the question input
+4. WHEN the user types a custom question THEN the system SHALL accept free-form text input
+5. WHEN processing the question THEN the system SHALL include the selected text as context for the AI
+
+### Requirement 3
+
+**User Story:** As a student, I want to receive AI-generated answers in my preferred language, so that I can understand the explanations clearly.
+
+#### Acceptance Criteria
+
+1. WHEN generating AI responses THEN the system SHALL use the current UI language setting
+2. WHEN the UI is in Arabic THEN AI responses SHALL be in Arabic
+3. WHEN the UI is in English THEN AI responses SHALL be in English
+4. WHEN the selected text is in a different language THEN the AI SHALL provide context-aware responses
+5. IF language detection fails THEN the system SHALL default to the UI language
+
+### Requirement 4
+
+**User Story:** As a student, I want to see the AI's answer clearly formatted and easy to read, so that I can quickly understand the information provided.
+
+#### Acceptance Criteria
+
+1. WHEN the AI responds THEN the answer SHALL be displayed in a dedicated response area
+2. WHEN displaying the response THEN the system SHALL show the original selected text for reference
+3. WHEN formatting the response THEN the system SHALL use clear typography and spacing
+4. WHEN the response is long THEN the system SHALL provide scrollable content area
+5. WHEN multiple questions are asked THEN the system SHALL maintain a conversation history
+
+### Requirement 5
+
+**User Story:** As a student, I want to ask follow-up questions about the same content, so that I can have a natural conversation with the AI about the topic.
+
+#### Acceptance Criteria
+
+1. WHEN an AI response is displayed THEN the system SHALL provide an option to ask follow-up questions
+2. WHEN asking follow-up questions THEN the system SHALL maintain context from previous questions
+3. WHEN the conversation continues THEN the system SHALL display the full conversation thread
+4. WHEN starting a new question on different content THEN the system SHALL start a fresh conversation
+5. IF the conversation becomes too long THEN the system SHALL provide option to clear history
+
+### Requirement 6
+
+**User Story:** As a student, I want to copy or save the AI's answers, so that I can include them in my notes or study materials.
+
+#### Acceptance Criteria
+
+1. WHEN an AI response is displayed THEN the system SHALL provide a "Copy" button
+2. WHEN the user clicks "Copy" THEN the response text SHALL be copied to clipboard
+3. WHEN copying THEN the system SHALL include both the original question and AI answer
+4. WHEN multiple Q&A pairs exist THEN the user SHALL be able to copy individual answers or the entire conversation
+5. WHEN copying THEN the system SHALL format the text appropriately for pasting into documents
+
+### Requirement 7
+
+**User Story:** As a student, I want the AI question feature to work seamlessly with the existing broadcast interface, so that my workflow is not disrupted.
+
+#### Acceptance Criteria
+
+1. WHEN the question interface is open THEN the broadcast content SHALL remain visible
+2. WHEN asking questions THEN the broadcast playback SHALL not be interrupted
+3. WHEN switching between segments THEN any open question interface SHALL adapt to the new selection
+4. WHEN the broadcast is updated with new segments THEN the question feature SHALL work with new content
+5. IF the AI service is unavailable THEN the system SHALL display appropriate error messages and fallback options
\ No newline at end of file
diff --git a/.kiro/specs/ai-questions/tasks.md b/.kiro/specs/ai-questions/tasks.md
new file mode 100644
index 0000000000000000000000000000000000000000..4a4cc1fb32cb5d9df7dd86d137270516b21a0b97
--- /dev/null
+++ b/.kiro/specs/ai-questions/tasks.md
@@ -0,0 +1,209 @@
+# Implementation Plan
+
+- [x] 1. Set up AI question engine infrastructure
+
+
+  - Create ai_questions.py module with AIQuestionEngine class
+  - Implement basic question processing using existing Gemini AI integration
+  - Add question templates for Arabic and English languages
+  - Create data models for question sessions and Q&A pairs
+  - _Requirements: 1.1, 2.1, 3.1_
+
+
+
+- [ ] 2. Implement text selection functionality
+- [ ] 2.1 Add clickable text selection to broadcast segments
+  - Modify broadcast segment display to make text selectable
+  - Implement visual highlighting for selected text
+  - Add session state management for selected text
+  - Create text selection validation and error handling
+
+  - Write unit tests for text selection functionality
+  - _Requirements: 1.1, 1.5_
+
+- [ ] 2.2 Create "Ask AI" button with conditional display
+  - Add "Ask AI" button that appears when text is selected
+  - Implement button state management (enabled/disabled)
+  - Add tooltips and help text for button functionality
+  - Create button styling consistent with existing UI
+
+  - Test button behavior with different text selections
+  - _Requirements: 1.2, 1.5_
+
+- [ ] 3. Build question input interface
+- [ ] 3.1 Create question input modal with templates
+  - Implement modal dialog for question input
+  - Add pre-defined question templates with quick selection
+
+  - Create free-form text input for custom questions
+  - Display selected text context in the modal
+  - Add submit and cancel functionality
+  - _Requirements: 2.1, 2.2, 2.3, 2.4_
+
+- [ ] 3.2 Implement question processing and AI integration
+  - Connect question input to AIQuestionEngine
+  - Add context preparation including selected text and metadata
+
+  - Implement AI request processing with error handling
+  - Add loading indicators during AI processing
+  - Create timeout handling for long AI responses
+  - _Requirements: 1.4, 2.5, 7.5_
+
+- [ ] 4. Create AI response display system
+- [x] 4.1 Build response display area with formatting
+
+  - Create dedicated area for displaying AI responses
+  - Implement proper text formatting and typography
+  - Add scrollable content area for long responses
+  - Display original selected text for reference
+  - Create responsive design for different screen sizes
+  - _Requirements: 4.1, 4.2, 4.3, 4.4_
+
+- [x] 4.2 Add conversation history management
+
+  - Implement conversation thread display
+  - Add conversation history storage in session state
+  - Create conversation navigation and scrolling
+  - Add conversation clearing functionality
+  - Test conversation persistence across UI interactions
+  - _Requirements: 5.1, 5.2, 5.3, 5.4, 5.5_
+
+
+- [ ] 5. Implement multilingual support
+- [ ] 5.1 Add language-aware AI response generation
+  - Configure AI responses based on UI language setting
+  - Implement language detection for selected text
+  - Add context-aware response generation
+  - Create fallback mechanisms for language detection failures
+  - Test multilingual question processing
+  - _Requirements: 3.1, 3.2, 3.3, 3.4, 3.5_
+
+
+- [ ] 5.2 Create multilingual question templates
+  - Implement Arabic question templates
+  - Add English question templates
+  - Create template selection based on UI language
+  - Add template customization and expansion
+  - Test template functionality in both languages
+  - _Requirements: 2.1, 2.2, 2.3_
+
+- [ ] 6. Add copy and export functionality
+- [ ] 6.1 Implement response copying features
+  - Add "Copy" button for individual AI responses
+  - Implement clipboard integration for copying text
+  - Create formatted copying including questions and answers
+  - Add copy confirmation feedback to users
+  - Test copying functionality across different browsers
+
+
+  - _Requirements: 6.1, 6.2, 6.3_
+
+- [ ] 6.2 Create conversation export capabilities
+  - Add functionality to copy entire conversations
+  - Implement formatted export for study materials
+  - Create export options for individual Q&A pairs
+  - Add export formatting for different use cases
+  - Test export functionality with various conversation lengths
+  - _Requirements: 6.4, 6.5_
+
+- [ ] 7. Integrate with existing broadcast system
+- [ ] 7.1 Ensure seamless broadcast integration
+  - Integrate question interface with existing broadcast UI
+  - Maintain broadcast visibility during question sessions
+  - Ensure broadcast playback is not interrupted by questions
+  - Add smooth transitions between broadcast and question modes
+  - Test integration with all existing broadcast features
+  - _Requirements: 7.1, 7.2_
+
+- [ ] 7.2 Handle dynamic broadcast updates
+  - Adapt question interface to new broadcast segments
+  - Update text selection when broadcast content changes
+  - Maintain question sessions across broadcast updates
+  - Handle segment deletion and modification gracefully
+  - Test with real-time broadcast updates
+  - _Requirements: 7.3, 7.4_
+
+- [ ] 8. Implement error handling and fallbacks
+- [ ] 8.1 Add comprehensive error handling
+  - Implement AI service unavailability handling
+  - Add user-friendly error messages in both languages
+  - Create retry mechanisms for failed AI requests
+  - Add fallback options when AI service fails
+  - Test error scenarios and recovery mechanisms
+  - _Requirements: 7.5_
+
+- [ ] 8.2 Create robust conversation management
+  - Add conversation cleanup for memory management
+  - Implement conversation size limits and warnings
+  - Create automatic conversation archiving
+  - Add conversation recovery after errors
+  - Test conversation stability under various conditions
+  - _Requirements: 5.5_
+
+- [ ] 9. Add advanced question features
+- [ ] 9.1 Implement follow-up question capabilities
+  - Add "Ask follow-up" functionality to responses
+  - Maintain conversation context across multiple questions
+  - Create intelligent context summarization for long conversations
+  - Add conversation branching for different topics
+  - Test follow-up question accuracy and relevance
+  - _Requirements: 5.1, 5.2, 5.3_
+
+- [ ] 9.2 Create question suggestion system
+  - Implement AI-powered question suggestions based on selected text
+  - Add smart question recommendations
+  - Create question difficulty levels (basic, intermediate, advanced)
+  - Add question categorization (explanation, examples, application)
+  - Test suggestion quality and relevance
+  - _Requirements: 2.1, 2.2_
+
+- [ ] 10. Optimize performance and user experience
+- [ ] 10.1 Implement performance optimizations
+  - Add asynchronous processing for AI requests
+  - Implement response caching for common questions
+  - Create progressive loading for long conversations
+  - Add memory optimization for conversation history
+  - Test performance with large broadcast segments
+  - _Requirements: 4.4, 5.5_
+
+- [ ] 10.2 Enhance user experience features
+  - Add keyboard shortcuts for common actions
+  - Implement drag-and-drop text selection
+  - Create question history search functionality
+  - Add question bookmarking and favorites
+  - Test accessibility features and screen reader compatibility
+  - _Requirements: 7.1, 7.2_
+
+- [ ] 11. Create comprehensive testing suite
+- [ ] 11.1 Write unit tests for question engine
+  - Create tests for AIQuestionEngine class methods
+  - Add tests for question processing and formatting
+  - Write tests for conversation management
+  - Create tests for error handling scenarios
+  - Implement test data fixtures for various question types
+  - _Requirements: All requirements validation_
+
+- [ ] 11.2 Implement integration tests
+  - Create end-to-end tests for complete question flow
+  - Add tests for multilingual question processing
+  - Write tests for UI component interactions
+  - Create tests for broadcast system integration
+  - Implement performance tests for AI response times
+  - _Requirements: All requirements validation_
+
+- [ ] 12. Final integration and polish
+- [ ] 12.1 Complete system integration
+  - Ensure seamless integration with all existing features
+  - Test compatibility with export functionality
+  - Verify proper session state management
+  - Add configuration options for question features
+  - Create deployment-ready code with proper error handling
+  - _Requirements: All requirements_
+
+- [ ] 12.2 Create user documentation and help
+  - Write user guide for AI question features
+  - Create in-app help and tooltips
+  - Add troubleshooting documentation
+  - Create video tutorials for complex workflows
+  - Document keyboard shortcuts and advanced features
+  - _Requirements: 7.5_
\ No newline at end of file
diff --git a/.kiro/specs/broadcast-export/design.md b/.kiro/specs/broadcast-export/design.md
new file mode 100644
index 0000000000000000000000000000000000000000..0765af4bad890e84f044ac23fffd78555397e181
--- /dev/null
+++ b/.kiro/specs/broadcast-export/design.md
@@ -0,0 +1,274 @@
+# Design Document
+
+## Overview
+
+The broadcast export feature extends SyncMaster Enhanced with the ability to export lecture content from a specific timestamp. The system will integrate seamlessly with the existing broadcast functionality, providing students with formatted documents containing original text, translations, and AI-generated summaries. The design prioritizes simplicity, reliability, and multilingual support.
+
+## Architecture
+
+### High-Level Architecture
+
+```
+┌─────────────────┐    ┌─────────────────┐    ┌─────────────────┐
+│   Streamlit UI  │    │  Export Engine  │    │  File Generators│
+│                 │    │                 │    │                 │
+│ - Export Button │───▶│ - Data Filter   │───▶│ - Word Exporter │
+│ - Preview Modal │    │ - Content Prep  │    │ - GDocs Exporter│
+│ - Download Link │◀───│ - Format Router │◀───│ - Summary Gen   │
+└─────────────────┘    └─────────────────┘    └─────────────────┘
+         │                       │                       │
+         │                       │                       │
+         ▼                       ▼                       ▼
+┌─────────────────┐    ┌─────────────────┐    ┌─────────────────┐
+│ Session State   │    │ Broadcast Data  │    │ External APIs   │
+│                 │    │                 │    │                 │
+│ - Export Time   │    │ - Segments      │    │ - Google Docs   │
+│ - UI Language   │    │ - Translations  │    │ - Gemini AI     │
+│ - Export Config │    │ - Timestamps    │    │ - File System   │
+└─────────────────┘    └─────────────────┘    └─────────────────┘
+```
+
+### Component Integration
+
+The export feature integrates with existing SyncMaster components:
+- **Broadcast System**: Uses `st.session_state.broadcast_segments` for data
+- **Translation System**: Leverages existing `translator.py` for summaries
+- **UI System**: Extends current Streamlit interface with export controls
+
+## Components and Interfaces
+
+### 1. Export Engine (`exporter.py`)
+
+**Primary Class: `BroadcastExporter`**
+
+```python
+class BroadcastExporter:
+    def __init__(self, translator_instance):
+        self.translator = translator_instance
+        self.supported_formats = ['word', 'google_docs']
+    
+    def filter_segments_from_timestamp(self, segments, export_timestamp):
+        """Filter broadcast segments from export timestamp"""
+        
+    def prepare_export_content(self, segments, include_summary=True):
+        """Prepare structured content for export"""
+        
+    def export_to_word(self, content, filename):
+        """Generate Word document"""
+        
+    def export_to_google_docs(self, content, title):
+        """Create Google Docs document"""
+        
+    def generate_export_summary(self, segments, target_language='ar'):
+        """Generate summary for export content"""
+```
+
+### 2. UI Components (Extended `app.py`)
+
+**Export Button Integration**
+- Location: Within the broadcast expander section
+- Trigger: Records current timestamp and opens export modal
+- State Management: Uses session state for export configuration
+
+**Export Modal**
+- Preview content display
+- Format selection (Word/Google Docs)
+- Export confirmation/cancellation
+- Progress indication during export
+
+### 3. Document Generators
+
+**Word Document Structure:**
+```
+Title: محاضرة - [Date/Time]
+Export Time: [Timestamp]
+═══════════════════════════════════
+
+📻 البرودكاست المُصدر
+═══════════════════════════════════
+
+[Segment 1: Time Range]
+Original: [Text]
+Translation: [Text]
+
+[Segment 2: Time Range]
+Original: [Text]
+Translation: [Text]
+
+📝 الملخص
+═══════════════════════════════════
+[AI-Generated Summary]
+```
+
+**Google Docs Integration:**
+- Uses Google Docs API v1
+- Creates shareable documents
+- Applies consistent formatting
+- Handles authentication via service account
+
+## Data Models
+
+### Export Configuration
+```python
+@dataclass
+class ExportConfig:
+    export_timestamp: int  # Unix timestamp in milliseconds
+    format_type: str      # 'word' or 'google_docs'
+    include_summary: bool # Whether to include AI summary
+    ui_language: str      # 'ar' or 'en' for interface
+    target_language: str  # Translation language for summary
+```
+
+### Export Content
+```python
+@dataclass
+class ExportContent:
+    title: str
+    export_time: str
+    segments: List[BroadcastSegment]
+    summary: Optional[str]
+    metadata: Dict[str, Any]
+```
+
+### Broadcast Segment (Extended)
+```python
+@dataclass
+class BroadcastSegment:
+    id: str
+    start_ms: int
+    end_ms: int
+    text: str
+    translations: Dict[str, str]  # language_code -> translated_text
+    timestamp_formatted: str     # Human-readable time range
+```
+
+## Error Handling
+
+### Export Process Error Handling
+
+1. **Timestamp Validation**
+   - Verify export timestamp is valid
+   - Handle edge cases (no segments after timestamp)
+   - Provide user feedback for empty exports
+
+2. **Document Generation Errors**
+   - Word document creation failures
+   - Google Docs API errors
+   - File system permission issues
+   - Network connectivity problems
+
+3. **Summary Generation Errors**
+   - AI service unavailability
+   - Empty content handling
+   - Fallback to export without summary
+
+4. **User Experience Error Handling**
+   - Clear error messages in user's language
+   - Graceful degradation (Word fallback for Google Docs)
+   - Retry mechanisms for transient failures
+
+### Error Recovery Strategies
+
+```python
+def export_with_fallback(self, content, format_type):
+    """Export with automatic fallback handling"""
+    try:
+        if format_type == 'google_docs':
+            return self.export_to_google_docs(content)
+    except GoogleDocsError:
+        # Fallback to Word export
+        return self.export_to_word(content)
+    except Exception as e:
+        # Log error and provide user feedback
+        return self.handle_export_error(e)
+```
+
+## Testing Strategy
+
+### Unit Testing
+- **Export Engine Tests**: Data filtering, content preparation, format generation
+- **Document Generator Tests**: Word document structure, Google Docs API integration
+- **Error Handling Tests**: Various failure scenarios and recovery mechanisms
+
+### Integration Testing
+- **End-to-End Export Flow**: From button click to document download
+- **Multi-language Testing**: Arabic and English interface testing
+- **Cross-format Testing**: Consistency between Word and Google Docs exports
+
+### User Acceptance Testing
+- **Student Workflow Testing**: Real lecture scenario testing
+- **Performance Testing**: Export speed with large broadcast segments
+- **Accessibility Testing**: Screen reader compatibility, keyboard navigation
+
+### Test Data Scenarios
+```python
+# Test scenarios for broadcast segments
+test_scenarios = [
+    "empty_broadcast",           # No segments to export
+    "single_segment",           # One segment after timestamp
+    "multiple_segments",        # Multiple segments with translations
+    "mixed_languages",          # Segments in different languages
+    "large_content",           # Performance testing with many segments
+    "special_characters",      # Unicode and RTL text handling
+]
+```
+
+## Implementation Phases
+
+### Phase 1: Core Export Engine
+- Implement `BroadcastExporter` class
+- Add timestamp filtering functionality
+- Create basic Word document generation
+- Integrate with existing broadcast data
+
+### Phase 2: UI Integration
+- Add export button to broadcast section
+- Implement export modal with preview
+- Add progress indicators and user feedback
+- Handle multilingual UI elements
+
+### Phase 3: Advanced Features
+- Google Docs integration
+- Enhanced document formatting
+- Summary generation for export content
+- Error handling and fallback mechanisms
+
+### Phase 4: Testing and Optimization
+- Comprehensive testing suite
+- Performance optimization
+- User experience refinements
+- Documentation and help content
+
+## Security Considerations
+
+### Data Privacy
+- Export content remains on user's device or chosen cloud service
+- No intermediate storage of sensitive lecture content
+- Google Docs integration uses user's own Google account
+
+### API Security
+- Google Docs API authentication via OAuth 2.0
+- Secure handling of API credentials
+- Rate limiting and quota management
+
+### File Security
+- Generated Word documents include no executable content
+- Sanitization of user input in document titles
+- Secure temporary file handling during generation
+
+## Performance Considerations
+
+### Export Speed Optimization
+- Lazy loading of large broadcast segments
+- Asynchronous document generation
+- Progress feedback for long-running exports
+
+### Memory Management
+- Streaming document generation for large content
+- Cleanup of temporary files and resources
+- Efficient handling of multilingual text encoding
+
+### Scalability
+- Support for exports with hundreds of broadcast segments
+- Optimized data structures for large lecture sessions
+- Configurable export limits to prevent system overload
\ No newline at end of file
diff --git a/.kiro/specs/broadcast-export/requirements.md b/.kiro/specs/broadcast-export/requirements.md
new file mode 100644
index 0000000000000000000000000000000000000000..57fee0acbaa81410a4de5556a64ecc588362bcb1
--- /dev/null
+++ b/.kiro/specs/broadcast-export/requirements.md
@@ -0,0 +1,87 @@
+# Requirements Document
+
+## Introduction
+
+This feature adds export functionality to the SyncMaster Enhanced application, specifically for the broadcast section. The feature allows students to export their lecture content (original text, translations, and summaries) from a specific point in time when they press the export button, rather than exporting the entire broadcast history. This enables students to capture and save important lecture segments for later review in Word or Google Docs format.
+
+## Requirements
+
+### Requirement 1
+
+**User Story:** As a student using SyncMaster during a lecture, I want to export the broadcast content from a specific moment, so that I can save important lecture segments for later review.
+
+#### Acceptance Criteria
+
+1. WHEN the user clicks the export button THEN the system SHALL record the current timestamp as the export starting point
+2. WHEN exporting THEN the system SHALL include only broadcast segments that occurred after the export timestamp
+3. WHEN exporting THEN the system SHALL include both original text and translations for each segment
+4. IF no segments exist after the export timestamp THEN the system SHALL display a message indicating no content to export
+
+### Requirement 2
+
+**User Story:** As a student, I want to export my lecture content to Word format, so that I can easily review and edit the content offline.
+
+#### Acceptance Criteria
+
+1. WHEN the user selects Word export THEN the system SHALL generate a .docx file
+2. WHEN generating the Word document THEN the system SHALL include a header with lecture title and export timestamp
+3. WHEN generating the Word document THEN the system SHALL format the content with clear sections for broadcast segments and summary
+4. WHEN the Word document is generated THEN the system SHALL provide a download link to the user
+5. IF the Word generation fails THEN the system SHALL display an error message and suggest alternative export options
+
+### Requirement 3
+
+**User Story:** As a student, I want to export my lecture content to Google Docs, so that I can access and share it from anywhere.
+
+#### Acceptance Criteria
+
+1. WHEN the user selects Google Docs export THEN the system SHALL create a new Google Docs document
+2. WHEN creating the Google Docs document THEN the system SHALL use the same formatting structure as Word export
+3. WHEN the Google Docs document is created THEN the system SHALL provide a shareable link to the user
+4. IF Google Docs integration is not available THEN the system SHALL fall back to Word export
+5. WHEN Google Docs export fails THEN the system SHALL display an error message with troubleshooting steps
+
+### Requirement 4
+
+**User Story:** As a student, I want the exported content to include the Arabic summary, so that I can have a comprehensive review document.
+
+#### Acceptance Criteria
+
+1. WHEN exporting THEN the system SHALL include the current Arabic summary if available
+2. WHEN no Arabic summary exists THEN the system SHALL generate a new summary based on the exported segments
+3. WHEN generating a new summary THEN the system SHALL use the same AI translation service as the main application
+4. IF summary generation fails THEN the system SHALL export without the summary section and notify the user
+
+### Requirement 5
+
+**User Story:** As a student, I want to preview the export content before downloading, so that I can verify it contains the information I need.
+
+#### Acceptance Criteria
+
+1. WHEN the user clicks export THEN the system SHALL display a preview modal showing the content to be exported
+2. WHEN showing the preview THEN the system SHALL display the number of segments and estimated document length
+3. WHEN in preview mode THEN the user SHALL be able to confirm or cancel the export
+4. WHEN the user confirms export THEN the system SHALL proceed with the selected format
+5. WHEN the user cancels export THEN the system SHALL close the preview without creating any files
+
+### Requirement 6
+
+**User Story:** As a student, I want the export feature to work in both Arabic and English interfaces, so that I can use it regardless of my language preference.
+
+#### Acceptance Criteria
+
+1. WHEN the interface language is Arabic THEN all export UI elements SHALL be displayed in Arabic
+2. WHEN the interface language is English THEN all export UI elements SHALL be displayed in English
+3. WHEN exporting THEN the document structure SHALL adapt to the interface language while preserving content languages
+4. WHEN displaying error messages THEN they SHALL be shown in the current interface language
+
+### Requirement 7
+
+**User Story:** As a student, I want the export button to be easily accessible in the broadcast section, so that I can quickly export content during live lectures.
+
+#### Acceptance Criteria
+
+1. WHEN viewing the broadcast section THEN the export button SHALL be prominently displayed
+2. WHEN the broadcast section is collapsed THEN the export button SHALL remain visible
+3. WHEN clicking the export button THEN the system SHALL respond within 2 seconds
+4. WHEN no broadcast segments exist THEN the export button SHALL be disabled with an explanatory tooltip
\ No newline at end of file
diff --git a/.kiro/specs/broadcast-export/tasks.md b/.kiro/specs/broadcast-export/tasks.md
new file mode 100644
index 0000000000000000000000000000000000000000..b8b53ff191374aa41cf52e86e41648d5ceea7033
--- /dev/null
+++ b/.kiro/specs/broadcast-export/tasks.md
@@ -0,0 +1,194 @@
+# Implementation Plan
+
+- [x] 1. Set up export infrastructure and dependencies
+
+
+  - Install required Python packages for document generation (python-docx, google-api-python-client)
+  - Update requirements.txt with new dependencies
+  - Create basic project structure for export functionality
+  - _Requirements: 1.1, 2.1, 3.1_
+
+- [ ] 2. Implement core export engine
+- [x] 2.1 Create BroadcastExporter class with timestamp filtering
+
+
+
+  - Write BroadcastExporter class in new exporter.py file
+  - Implement filter_segments_from_timestamp method to filter segments by export time
+  - Add prepare_export_content method to structure data for export
+  - Create unit tests for timestamp filtering logic
+  - _Requirements: 1.1, 1.2, 1.3_
+
+- [ ] 2.2 Implement Word document generation functionality
+  - Add export_to_word method using python-docx library
+  - Create document template with proper Arabic/English formatting
+  - Implement structured content layout (header, segments, summary sections)
+  - Add proper RTL text support for Arabic content
+  - Write unit tests for Word document generation
+  - _Requirements: 2.1, 2.2, 2.3, 6.3_
+
+- [ ] 2.3 Add export content preparation and formatting
+  - Implement content structuring for both original text and translations
+  - Add timestamp formatting for human-readable time ranges
+  - Create multilingual document headers and section titles
+  - Handle special characters and Unicode text properly
+  - Write tests for content preparation logic
+  - _Requirements: 1.3, 2.3, 6.1, 6.2_
+
+
+- [ ] 3. Integrate export functionality with existing UI
+- [ ] 3.1 Add export button to broadcast section
+
+
+  - Modify app.py to add export button in broadcast expander
+  - Implement export timestamp recording when button is clicked
+  - Add button state management (enabled/disabled based on content)
+  - Create multilingual button text and tooltips
+  - _Requirements: 7.1, 7.2, 7.4, 6.1, 6.2_
+
+- [ ] 3.2 Create export preview modal interface
+  - Implement export preview modal using Streamlit components
+  - Add content preview showing segments count and estimated length
+  - Create format selection interface (Word/Google Docs options)
+  - Add confirm/cancel buttons with proper event handling
+  - Write UI tests for modal functionality
+  - _Requirements: 5.1, 5.2, 5.3, 5.4, 5.5_
+
+- [ ] 3.3 Implement export progress and feedback system
+  - Add progress indicators during export generation
+  - Create success/error message display system
+  - Implement download link generation for completed exports
+  - Add multilingual error messages and user feedback
+  - Handle export cancellation and cleanup
+  - _Requirements: 7.3, 6.4, 2.4_
+
+- [ ] 4. Add summary generation for export content
+- [ ] 4.1 Integrate AI summary generation for export segments
+  - Extend exporter.py with generate_export_summary method
+  - Use existing translator.py functionality for summary generation
+  - Implement summary generation based on filtered segments only
+  - Add fallback handling when summary generation fails
+  - Create tests for summary integration
+  - _Requirements: 4.1, 4.2, 4.3, 4.4_
+
+- [ ] 4.2 Handle summary inclusion in export documents
+  - Modify Word document generation to include summary section
+  - Add conditional summary inclusion based on user preferences
+  - Implement proper formatting for Arabic summary text
+  - Handle cases where summary is unavailable or generation fails
+  - Test summary formatting in exported documents
+  - _Requirements: 4.1, 4.4, 6.3_
+
+- [ ] 5. Implement Google Docs integration
+- [x] 5.1 Set up Google Docs API integration
+
+
+
+  - Create Google Docs API service setup and authentication
+  - Implement OAuth 2.0 flow for user authorization
+  - Add Google API credentials management
+  - Create basic Google Docs document creation functionality
+  - Write integration tests for Google API connectivity
+  - _Requirements: 3.1, 3.2_
+
+- [ ] 5.2 Implement Google Docs export functionality
+  - Add export_to_google_docs method to BroadcastExporter
+  - Implement document formatting using Google Docs API
+  - Add proper RTL text support for Arabic content in Google Docs
+  - Create shareable link generation for exported documents
+  - Handle Google Docs API errors and rate limiting
+  - _Requirements: 3.1, 3.2, 3.3, 6.3_
+
+- [ ] 5.3 Add Google Docs fallback and error handling
+  - Implement automatic fallback to Word export when Google Docs fails
+  - Add user-friendly error messages for Google Docs issues
+  - Create retry mechanisms for transient API failures
+  - Handle authentication errors and re-authorization flow
+  - Test fallback scenarios and error recovery
+  - _Requirements: 3.4, 3.5_
+
+- [ ] 6. Implement comprehensive error handling
+- [ ] 6.1 Add export validation and error prevention
+  - Implement pre-export validation (timestamp, content availability)
+  - Add user input sanitization for document titles and content
+  - Create validation for export configuration parameters
+  - Handle edge cases (empty segments, invalid timestamps)
+  - Write comprehensive validation tests
+  - _Requirements: 1.4, 7.4_
+
+- [ ] 6.2 Create robust error recovery system
+  - Implement try-catch blocks for all export operations
+  - Add logging for debugging export failures
+  - Create user-friendly error messages in multiple languages
+  - Implement cleanup procedures for failed exports
+  - Add error reporting and diagnostics functionality
+  - _Requirements: 2.5, 3.5, 6.4_
+
+- [ ] 7. Add multilingual support and localization
+- [ ] 7.1 Implement Arabic interface support for export features
+  - Add Arabic translations for all export UI elements
+  - Create RTL-compatible export modal layout
+  - Implement Arabic document templates and formatting
+  - Add Arabic error messages and user feedback
+  - Test Arabic interface functionality thoroughly
+  - _Requirements: 6.1, 6.4_
+
+- [ ] 7.2 Ensure consistent multilingual document generation
+  - Implement language-aware document formatting
+  - Add proper font selection for Arabic and English text
+  - Create consistent styling across different languages
+  - Handle mixed-language content in exports
+  - Test document generation with various language combinations
+  - _Requirements: 6.3_
+
+Auto-process snapshots (keeps recording)
+- [ ] 8. Create comprehensive testing suite
+- [ ] 8.1 Write unit tests for export functionality
+  - Create tests for BroadcastExporter class methods
+  - Add tests for timestamp filtering and content preparation
+  - Write tests for Word document generation
+  - Create tests for error handling and edge cases
+  - Implement test data fixtures for various scenarios
+  - _Requirements: All requirements validation_
+
+- [ ] 8.2 Implement integration tests for complete export flow
+  - Create end-to-end tests from button click to document download
+  - Add tests for multilingual export scenarios
+  - Write tests for Google Docs integration (with mocking)
+  - Create performance tests for large broadcast segments
+  - Implement user workflow simulation tests
+  - _Requirements: All requirements validation_
+
+- [ ] 9. Optimize performance and user experience
+- [ ] 9.1 Implement export performance optimizations
+  - Add asynchronous processing for large exports
+  - Implement memory-efficient document generation
+  - Create progress tracking for long-running exports
+  - Add export size limits and warnings
+  - Optimize data structures for large segment collections
+  - _Requirements: 7.3_
+
+- [ ] 9.2 Enhance user experience and accessibility
+  - Add keyboard navigation support for export interface
+  - Implement screen reader compatibility
+  - Create helpful tooltips and user guidance
+  - Add export history and recent exports tracking
+  - Implement user preferences for export settings
+  - _Requirements: 5.1, 7.1, 7.2_
+
+- [ ] 10. Final integration and documentation
+- [ ] 10.1 Complete integration with main application
+  - Ensure seamless integration with existing broadcast functionality
+  - Test compatibility with all existing features
+  - Verify proper session state management
+  - Add configuration options for export features
+  - Create deployment-ready code with proper error handling
+  - _Requirements: All requirements_
+
+- [ ] 10.2 Create user documentation and help content
+  - Write user guide for export functionality
+  - Create troubleshooting documentation
+  - Add inline help text and tooltips
+  - Create video tutorials or screenshots for complex workflows
+  - Document API integration requirements for Google Docs
+  - _Requirements: 3.5, 6.4_
\ No newline at end of file
diff --git a/.kiro/specs/model-management/design.md b/.kiro/specs/model-management/design.md
new file mode 100644
index 0000000000000000000000000000000000000000..b02f537d5b772c0510f1fd49f28f0c386ca20009
--- /dev/null
+++ b/.kiro/specs/model-management/design.md
@@ -0,0 +1,225 @@
+# Model Management System Design
+
+## Overview
+
+The Model Management System provides a centralized, robust approach to managing AI model configurations across multiple providers (Gemini, OpenRouter, Groq). It includes automatic validation, fallback mechanisms, health monitoring, and user-friendly status reporting.
+
+## Architecture
+
+### Core Components
+
+1. **ModelManager**: Central coordinator for all model operations
+2. **ModelValidator**: Validates model configurations against provider APIs
+3. **ModelHealthMonitor**: Monitors model availability and performance
+4. **FallbackChain**: Manages automatic fallback to alternative models
+5. **ModelConfigStore**: Centralized configuration management
+6. **StatusReporter**: Provides real-time status information to users
+
+### Component Interactions
+
+```
+User Request → ModelManager → ModelValidator → Provider API
+                    ↓
+            FallbackChain → Alternative Models
+                    ↓
+            StatusReporter → User Feedback
+```
+
+## Components and Interfaces
+
+### ModelManager
+
+**Purpose**: Central coordinator for all AI model operations
+
+**Key Methods**:
+- `get_available_model(provider, task_type)`: Returns best available model for a task
+- `execute_with_fallback(prompt, preferences)`: Executes request with automatic fallback
+- `get_system_status()`: Returns current status of all models
+- `refresh_configurations()`: Reloads and validates all configurations
+
+**Interfaces**:
+- Input: User requests, configuration updates
+- Output: Model responses, status information, error messages
+
+### ModelValidator
+
+**Purpose**: Validates model configurations against provider APIs
+
+**Key Methods**:
+- `validate_model(provider, model_id)`: Tests if a model is valid and accessible
+- `validate_all_models()`: Validates all configured models
+- `suggest_alternatives(invalid_model)`: Suggests working alternatives for invalid models
+- `update_model_status(model, status)`: Updates model availability status
+
+**Validation Process**:
+1. Send minimal test request to provider API
+2. Check response for success/error patterns
+3. Update model status based on results
+4. Log validation results with timestamps
+
+### ModelHealthMonitor
+
+**Purpose**: Continuously monitors model health and availability
+
+**Key Methods**:
+- `start_monitoring()`: Begins periodic health checks
+- `check_model_health(model)`: Performs health check on specific model
+- `handle_model_failure(model, error)`: Responds to model failures
+- `get_health_report()`: Returns comprehensive health status
+
+**Monitoring Strategy**:
+- Periodic health checks every 5 minutes
+- Immediate checks after failures
+- Exponential backoff for failed models
+- Automatic recovery detection
+
+### FallbackChain
+
+**Purpose**: Manages automatic fallback to alternative models
+
+**Fallback Priority**:
+1. **Primary Models**: User-configured preferred models
+2. **Secondary Models**: Validated working alternatives
+3. **Emergency Models**: Always-available simple response system
+
+**Fallback Logic**:
+```
+Primary Model → Secondary Models → Emergency Response
+     ↓               ↓                    ↓
+  Full AI        Reduced AI         Rule-based
+  Response       Response           Response
+```
+
+### ModelConfigStore
+
+**Purpose**: Centralized configuration management
+
+**Configuration Structure**:
+```json
+{
+  "providers": {
+    "openrouter": {
+      "api_key": "...",
+      "models": {
+        "primary": "meta-llama/llama-3.2-3b-instruct:free",
+        "fallbacks": [
+          "meta-llama/llama-3.1-8b-instruct:free",
+          "google/gemma-2-9b-it:free"
+        ]
+      }
+    },
+    "groq": {
+      "api_key": "...",
+      "models": {
+        "primary": "llama-3.3-70b-versatile",
+        "fallbacks": ["mixtral-8x7b-32768"]
+      }
+    }
+  }
+}
+```
+
+## Data Models
+
+### ModelStatus
+```python
+@dataclass
+class ModelStatus:
+    provider: str
+    model_id: str
+    status: str  # 'available', 'unavailable', 'quota_exceeded', 'error'
+    last_checked: datetime
+    error_message: Optional[str]
+    response_time_ms: Optional[int]
+    success_rate: float
+```
+
+### ProviderConfig
+```python
+@dataclass
+class ProviderConfig:
+    name: str
+    api_key: str
+    base_url: str
+    primary_models: List[str]
+    fallback_models: List[str]
+    timeout_seconds: int = 30
+    retry_attempts: int = 3
+```
+
+### ValidationResult
+```python
+@dataclass
+class ValidationResult:
+    model_id: str
+    is_valid: bool
+    error_message: Optional[str]
+    suggested_alternatives: List[str]
+    validation_timestamp: datetime
+```
+
+## Error Handling
+
+### Error Categories
+
+1. **Configuration Errors**: Invalid API keys, malformed model IDs
+2. **Network Errors**: Timeout, connection failures
+3. **Provider Errors**: Rate limits, quota exceeded, model unavailable
+4. **Validation Errors**: Model not found, unsupported parameters
+
+### Error Response Strategy
+
+1. **Immediate Fallback**: Switch to next available model
+2. **User Notification**: Inform user of fallback with clear messaging
+3. **Automatic Recovery**: Retry failed models after cooldown period
+4. **Graceful Degradation**: Provide simple responses when all AI fails
+
+### Error Logging
+
+- Structured logging with error categories
+- Performance metrics tracking
+- User-friendly error messages
+- Detailed technical logs for debugging
+
+## Testing Strategy
+
+### Unit Tests
+- Model validation logic
+- Fallback chain behavior
+- Configuration parsing
+- Error handling scenarios
+
+### Integration Tests
+- End-to-end model requests
+- Provider API interactions
+- Fallback mechanisms
+- Configuration updates
+
+### Performance Tests
+- Response time monitoring
+- Concurrent request handling
+- Memory usage optimization
+- Fallback performance impact
+
+### User Acceptance Tests
+- Model status visibility
+- Error message clarity
+- Fallback transparency
+- Configuration management UI
+
+## Implementation Phases
+
+### Phase 1: Core Infrastructure
+- ModelManager implementation
+- Basic validation system
+- Simple fallback mechanism
+
+### Phase 2: Advanced Features
+- Health monitoring
+- Comprehensive error handling
+- Performance optimization
+
+### Phase 3: User Experience
+- Status dashboard
+- Configuration UI
+- Advanced monitoring features
\ No newline at end of file
diff --git a/.kiro/specs/model-management/requirements.md b/.kiro/specs/model-management/requirements.md
new file mode 100644
index 0000000000000000000000000000000000000000..a38c862287520276d524b921135abdb4bb9246d2
--- /dev/null
+++ b/.kiro/specs/model-management/requirements.md
@@ -0,0 +1,62 @@
+# Requirements Document
+
+## Introduction
+
+This feature aims to create a robust model management system that prevents invalid model configurations, provides automatic fallback mechanisms, and ensures reliable AI service availability. The system should handle model validation, automatic updates, and graceful error handling to prevent service disruptions.
+
+## Requirements
+
+### Requirement 1
+
+**User Story:** As a system administrator, I want automatic model validation so that invalid model configurations are detected and corrected before they cause service failures.
+
+#### Acceptance Criteria
+
+1. WHEN the system starts THEN it SHALL validate all configured AI models against their respective service APIs
+2. WHEN an invalid model is detected THEN the system SHALL automatically replace it with a known working fallback model
+3. WHEN model validation fails THEN the system SHALL log the error and continue with fallback models
+4. WHEN a model becomes unavailable THEN the system SHALL automatically switch to the next available model in the priority list
+
+### Requirement 2
+
+**User Story:** As a developer, I want centralized model configuration management so that all AI services use consistent and validated model settings.
+
+#### Acceptance Criteria
+
+1. WHEN the application initializes THEN it SHALL load model configurations from a centralized configuration system
+2. WHEN model configurations are updated THEN all AI services SHALL automatically use the new configurations
+3. WHEN a service requests a model THEN the system SHALL provide the most appropriate available model based on priority and availability
+4. WHEN model configurations are invalid THEN the system SHALL provide clear error messages and suggested fixes
+
+### Requirement 3
+
+**User Story:** As an end user, I want transparent model status information so that I understand which AI services are available and their current status.
+
+#### Acceptance Criteria
+
+1. WHEN I access the application THEN I SHALL see the current status of all AI models (available, unavailable, quota exceeded, etc.)
+2. WHEN a model fails THEN I SHALL receive a clear notification about the fallback being used
+3. WHEN model status changes THEN the UI SHALL update to reflect the current availability
+4. WHEN I encounter an AI error THEN I SHALL receive helpful information about alternative options
+
+### Requirement 4
+
+**User Story:** As a system operator, I want automatic model health monitoring so that model issues are detected and resolved proactively.
+
+#### Acceptance Criteria
+
+1. WHEN the system is running THEN it SHALL periodically check the health of all configured AI models
+2. WHEN a model health check fails THEN the system SHALL attempt to use alternative models
+3. WHEN all models for a service fail THEN the system SHALL provide graceful degradation with simple responses
+4. WHEN model health is restored THEN the system SHALL automatically resume using the preferred models
+
+### Requirement 5
+
+**User Story:** As a developer, I want comprehensive error handling and logging so that model-related issues can be quickly diagnosed and resolved.
+
+#### Acceptance Criteria
+
+1. WHEN a model error occurs THEN the system SHALL log detailed error information including model name, error type, and suggested resolution
+2. WHEN fallback models are used THEN the system SHALL log the fallback chain and reasons for each fallback
+3. WHEN model configurations are automatically corrected THEN the system SHALL log the changes made
+4. WHEN users encounter model errors THEN they SHALL receive user-friendly error messages with actionable guidance
\ No newline at end of file
diff --git a/.kiro/specs/model-management/tasks.md b/.kiro/specs/model-management/tasks.md
new file mode 100644
index 0000000000000000000000000000000000000000..a5124b0b60fc8da91cb3fde1621b1250f7b36209
--- /dev/null
+++ b/.kiro/specs/model-management/tasks.md
@@ -0,0 +1,103 @@
+# Implementation Plan
+
+- [ ] 1. Create core model management infrastructure
+  - Implement ModelStatus and ProviderConfig data classes
+  - Create ModelConfigStore for centralized configuration management
+  - Set up basic logging and error handling framework
+  - _Requirements: 2.1, 2.2, 5.1_
+
+- [ ] 2. Implement ModelValidator component
+  - Create ModelValidator class with validation methods
+  - Implement validate_model() method for individual model testing
+  - Add validate_all_models() method for batch validation
+  - Create suggest_alternatives() method for fallback recommendations
+  - Write unit tests for validation logic
+  - _Requirements: 1.1, 1.2, 1.3_
+
+- [ ] 3. Build FallbackChain system
+  - Implement FallbackChain class with priority-based model selection
+  - Create fallback logic that tries primary, secondary, and emergency models
+  - Add automatic model switching when failures occur
+  - Implement graceful degradation to simple responses
+  - Write tests for fallback scenarios
+  - _Requirements: 1.4, 4.2, 4.3_
+
+- [ ] 4. Create ModelManager central coordinator
+  - Implement ModelManager class as main interface
+  - Add get_available_model() method for model selection
+  - Create execute_with_fallback() method for request handling
+  - Implement get_system_status() for status reporting
+  - Add refresh_configurations() for dynamic config updates
+  - Write integration tests for ModelManager
+  - _Requirements: 2.3, 3.2, 4.1_
+
+- [ ] 5. Implement ModelHealthMonitor
+  - Create ModelHealthMonitor class for continuous monitoring
+  - Add periodic health check functionality (5-minute intervals)
+  - Implement check_model_health() for individual model testing
+  - Create handle_model_failure() for failure response
+  - Add exponential backoff for failed models
+  - Write tests for health monitoring scenarios
+  - _Requirements: 4.1, 4.2, 4.4_
+
+- [ ] 6. Build StatusReporter for user feedback
+  - Create StatusReporter class for user-facing status information
+  - Implement real-time status updates for UI
+  - Add user-friendly error message generation
+  - Create status dashboard data formatting
+  - Implement notification system for model changes
+  - Write tests for status reporting functionality
+  - _Requirements: 3.1, 3.2, 3.3, 3.4_
+
+- [ ] 7. Integrate with existing AI services
+  - Update AITranslator to use ModelManager
+  - Modify AIQuestionEngine to use new model management
+  - Update all AI service calls to use execute_with_fallback()
+  - Replace hardcoded model configurations with centralized config
+  - Add model status display to existing UI components
+  - _Requirements: 2.2, 2.3, 3.1_
+
+- [ ] 8. Implement comprehensive error handling
+  - Add structured error logging with categories
+  - Create user-friendly error messages for each error type
+  - Implement automatic error recovery mechanisms
+  - Add performance metrics tracking
+  - Create error reporting dashboard
+  - Write tests for all error scenarios
+  - _Requirements: 5.1, 5.2, 5.3, 5.4_
+
+- [ ] 9. Add configuration management features
+  - Create configuration validation on startup
+  - Implement automatic model configuration updates
+  - Add configuration backup and restore functionality
+  - Create configuration migration tools for updates
+  - Add configuration validation UI
+  - Write tests for configuration management
+  - _Requirements: 2.1, 2.4, 1.2_
+
+- [ ] 10. Create monitoring and analytics
+  - Implement performance metrics collection
+  - Add model usage statistics tracking
+  - Create health monitoring dashboard
+  - Add alerting for critical model failures
+  - Implement trend analysis for model performance
+  - Write tests for monitoring functionality
+  - _Requirements: 4.1, 4.4, 5.1_
+
+- [ ] 11. Build user interface components
+  - Create model status display widget
+  - Add model selection interface for users
+  - Implement error notification system
+  - Create configuration management UI
+  - Add health monitoring dashboard
+  - Write UI tests for all components
+  - _Requirements: 3.1, 3.2, 3.3, 3.4_
+
+- [ ] 12. Implement final integration and testing
+  - Integrate all components into main application
+  - Run comprehensive end-to-end tests
+  - Perform load testing with multiple concurrent requests
+  - Test all fallback scenarios under various failure conditions
+  - Validate user experience with real-world usage patterns
+  - Create deployment and maintenance documentation
+  - _Requirements: All requirements validation_
\ No newline at end of file
diff --git a/Dockerfile b/Dockerfile
new file mode 100644
index 0000000000000000000000000000000000000000..1f1be75aa0f749c6b10cb265420b2aea8364ecd7
--- /dev/null
+++ b/Dockerfile
@@ -0,0 +1,41 @@
+#
+# -- Dockerfile for Streamlit app --
+#
+
+# Base image
+FROM python:3.9-slim
+
+# Set working directory
+WORKDIR /app
+
+# Install system dependencies (including ffmpeg)
+RUN apt-get update && apt-get install -y \
+    build-essential \
+    ffmpeg \
+    && rm -rf /var/lib/apt/lists/*
+
+# Copy requirements file
+COPY requirements.txt ./requirements.txt
+
+# Install Python dependencies
+RUN pip install --no-cache-dir --upgrade pip
+RUN pip install --no-cache-dir -r requirements.txt
+
+# Copy the entire app
+COPY . .
+
+# Create .streamlit directory and set permissions
+RUN mkdir -p /app/.streamlit && \
+    chmod -R 755 /app/.streamlit
+
+# Set environment variable for Streamlit config
+ENV STREAMLIT_CONFIG_DIR=/app/.streamlit
+
+# Expose the port that Streamlit runs on
+EXPOSE 8501
+
+# Add a health check
+HEALTHCHECK CMD curl --fail http://localhost:8501/_stcore/health
+
+# Command to run the app
+ENTRYPOINT ["streamlit", "run", "app.py", "--server.port=8501", "--server.address=0.0.0.0"]
diff --git a/FIX_GOOGLE_ACCESS.md b/FIX_GOOGLE_ACCESS.md
new file mode 100644
index 0000000000000000000000000000000000000000..a35434b0d2a512f7e8068d658f495ff2ad0d22f0
--- /dev/null
+++ b/FIX_GOOGLE_ACCESS.md
@@ -0,0 +1,27 @@
+# 🔧 حل مشكلة Google Access
+
+## 🎯 المشكلة:
+```
+Error 403: access_denied
+SyncMaster Export has not completed the Google verification process
+```
+
+## ✅ الحل السريع:
+
+### 1️⃣ إضافة نفسك كـ Test User:
+1. اذهب إلى [Google Cloud Console](https://console.cloud.google.com/)
+2. اختر مشروع `syncmaster-export`
+3. اذهب إلى: **APIs & Services** → **OAuth consent screen**
+4. اضغط على **"ADD USERS"** في قسم "Test users"
+5. أضف إيميل Google الخاص بك
+6. اضغط **"SAVE"**
+
+### 2️⃣ أو: نشر التطبيق للعامة (أسرع):
+1. في نفس صفحة **OAuth consent screen**
+2. اضغط **"PUBLISH APP"**
+3. اضغط **"CONFIRM"**
+4. الآن يمكن لأي شخص استخدام التطبيق
+
+## 🔧 حل مشكلة المنفذ:
+
+المشكلة أن Streamlit يستخدم المنفذ 8501، لذلك سنغير المنفذ للمصادقة.
\ No newline at end of file
diff --git a/GOOGLE_SETUP.md b/GOOGLE_SETUP.md
new file mode 100644
index 0000000000000000000000000000000000000000..f58078392493d7519aebba439825a43e02927417
--- /dev/null
+++ b/GOOGLE_SETUP.md
@@ -0,0 +1,47 @@
+# إعداد Google Docs للتصدير المباشر
+
+## الخطوات المطلوبة:
+
+### 1. إنشاء مشروع Google Cloud
+1. اذهب إلى [Google Cloud Console](https://console.cloud.google.com/)
+2. أنشئ مشروع جديد أو اختر مشروع موجود
+3. اكتب اسم المشروع (مثل: "SyncMaster Export")
+
+### 2. تفعيل Google Docs API
+1. في القائمة الجانبية، اذهب إلى "APIs & Services" > "Library"
+2. ابحث عن "Google Docs API"
+3. اضغط على "Enable"
+
+### 3. إنشاء بيانات الاعتماد
+1. اذهب إلى "APIs & Services" > "Credentials"
+2. اضغط على "Create Credentials" > "OAuth 2.0 Client ID"
+3. إذا لم تكن قد أعددت شاشة الموافقة، ستحتاج لإعدادها:
+   - اختر "External" للمستخدمين العاديين
+   - املأ المعلومات المطلوبة (اسم التطبيق، إيميل الدعم)
+   - أضف نطاقات Google Docs
+4. اختر "Desktop application" كنوع التطبيق
+5. اكتب اسم العميل (مثل: "SyncMaster Desktop")
+6. اضغط "Create"
+
+### 4. تحميل ملف بيانات الاعتماد
+1. بعد إنشاء بيانات الاعتماد، اضغط على أيقونة التحميل
+2. احفظ الملف باسم `credentials.json`
+3. ضع الملف في نفس مجلد التطبيق
+
+### 5. تشغيل التطبيق
+1. شغل التطبيق: `streamlit run app.py`
+2. اضغط على زر "📤 تصدير إلى Google Docs"
+3. ستفتح نافذة متصفح للمصادقة مع Google
+4. سجل دخول بحساب Google الخاص بك
+5. امنح الصلاحيات المطلوبة
+6. ارجع للتطبيق وستجد رابط المستند الجديد
+
+## ملاحظات مهمة:
+- يتم حفظ بيانات المصادقة في ملف `token.json` لاستخدامها لاحقاً
+- لا تشارك ملفات `credentials.json` أو `token.json` مع أحد
+- يمكنك إلغاء الصلاحيات من إعدادات حساب Google في أي وقت
+
+## استكشاف الأخطاء:
+- إذا ظهر خطأ "credentials.json not found"، تأكد من وضع الملف في المجلد الصحيح
+- إذا فشلت المصادقة، احذف ملف `token.json` وحاول مرة أخرى
+- تأكد من تفعيل Google Docs API في مشروعك
\ No newline at end of file
diff --git a/GOOGLE_SETUP_EASY.md b/GOOGLE_SETUP_EASY.md
new file mode 100644
index 0000000000000000000000000000000000000000..442034405cf95048c1acc7f73c1073e6e352a060
--- /dev/null
+++ b/GOOGLE_SETUP_EASY.md
@@ -0,0 +1,82 @@
+# 🚀 إعداد Google Docs - الطريقة السهلة
+
+## 📝 الإجابات على أسئلتك:
+
+### ❓ ماذا أدخل في هذه الحقول؟
+```
+Authorised JavaScript origins: اتركه فارغ (لا تدخل شيء)
+Authorised redirect URIs: اتركه فارغ (لا تدخل شيء)
+```
+**السبب**: نحن ننشئ تطبيق Desktop وليس Web، لذلك لا نحتاج هذه الحقول.
+
+### ❓ لم أستطع الوصول إلى صفحة Scopes؟
+**الحل**: لا تقلق! يمكنك تخطي إضافة الـ Scopes يدوياً. التطبيق سيطلبها تلقائياً.
+
+---
+
+## 🎯 الطريقة المبسطة (5 دقائق فقط):
+
+### 1️⃣ اذهب إلى Google Cloud Console
+🔗 **الرابط**: https://console.cloud.google.com/
+
+### 2️⃣ أنشئ مشروع جديد
+- اضغط "Select a project" → "NEW PROJECT"
+- اسم المشروع: `SyncMaster`
+- اضغط "CREATE"
+
+### 3️⃣ فعّل Google Docs API
+- من القائمة الجانبية: "APIs & Services" → "Library"
+- ابحث عن: `Google Docs API`
+- اضغط على النتيجة الأولى → "ENABLE"
+
+### 4️⃣ إعداد OAuth Consent Screen (مبسط)
+- اذهب إلى: "APIs & Services" → "OAuth consent screen"
+- اختر "External" → "CREATE"
+- املأ فقط:
+  - **App name**: `SyncMaster`
+  - **User support email**: إيميلك
+  - **Developer contact information**: إيميلك
+- اضغط "SAVE AND CONTINUE" في جميع الصفحات (لا تغير شيء آخر)
+
+### 5️⃣ إنشاء Client ID
+- اذهب إلى: "APIs & Services" → "Credentials"
+- اضغط "+ CREATE CREDENTIALS" → "OAuth 2.0 Client ID"
+- اختر "Desktop application"
+- الاسم: `SyncMaster Desktop`
+- **اترك جميع الحقول الأخرى فارغة**
+- اضغط "CREATE"
+
+### 6️⃣ تحميل الملف
+- ستظهر نافذة منبثقة
+- اضغط "DOWNLOAD JSON"
+- احفظ الملف باسم `credentials.json`
+- ضعه في مجلد التطبيق (نفس مكان app.py)
+
+### 7️⃣ اختبار
+```bash
+python check_credentials.py
+```
+يجب أن ترى: ✅ ملف بيانات الاعتماد صحيح!
+
+---
+
+## 🎉 الآن جرب الزر!
+- شغل التطبيق
+- اضغط "📤 تصدير إلى Google Docs"
+- ستفتح نافذة متصفح
+- سجل دخول بحساب Google
+- اضغط "Allow" لمنح الصلاحيات
+- ستحصل على رابط المستند!
+
+---
+
+## 🔧 إذا ظهر تحذير "App isn't verified":
+هذا طبيعي! اضغط:
+1. "Advanced"
+2. "Go to SyncMaster (unsafe)"
+3. "Allow"
+
+---
+
+## 📞 مازلت تواجه مشاكل؟
+أرسل لي لقطة شاشة من الخطأ وسأساعدك فوراً!
\ No newline at end of file
diff --git a/GOOGLE_SETUP_SIMPLE.md b/GOOGLE_SETUP_SIMPLE.md
new file mode 100644
index 0000000000000000000000000000000000000000..138c4019aed8736a7c44a571239b246e19b57e02
--- /dev/null
+++ b/GOOGLE_SETUP_SIMPLE.md
@@ -0,0 +1,85 @@
+# 🚀 إعداد Google Docs - دليل مبسط
+
+## ❌ المشكلة الحالية:
+```
+Error 401: invalid_client
+The OAuth client was not found.
+```
+
+## ✅ الحل السريع:
+
+### الخطوة 1: اذهب إلى Google Cloud Console
+🔗 **الرابط المباشر**: https://console.cloud.google.com/
+
+### الخطوة 2: إنشاء مشروع جديد
+1. اضغط على "Select a project" في الأعلى
+2. اضغط على "NEW PROJECT"
+3. اكتب اسم المشروع: `SyncMaster Export`
+4. اضغط "CREATE"
+
+### الخطوة 3: تفعيل Google Docs API
+1. في القائمة الجانبية ← "APIs & Services" ← "Library"
+2. ابحث عن: `Google Docs API`
+3. اضغط على النتيجة الأولى
+4. اضغط "ENABLE"
+
+### الخطوة 4: إعداد OAuth Consent Screen
+1. اذهب إلى "APIs & Services" ← "OAuth consent screen"
+2. اختر "External"
+3. اضغط "CREATE"
+4. املأ المعلومات المطلوبة:
+   - **App name**: `SyncMaster Export`
+   - **User support email**: إيميلك
+   - **Developer contact information**: إيميلك
+5. اضغط "SAVE AND CONTINUE"
+6. **في صفحة "Scopes"**: 
+   - **لا تضيف أي Scopes يدوياً**
+   - فقط اضغط "SAVE AND CONTINUE" مباشرة
+   - (التطبيق سيطلب الصلاحيات تلقائياً عند الاستخدام)
+7. في صفحة "Test users": اضغط "SAVE AND CONTINUE" 
+8. في صفحة "Summary": اضغط "BACK TO DASHBOARD"
+
+### الخطوة 5: إنشاء OAuth 2.0 Client ID
+1. اذهب إلى "APIs & Services" ← "Credentials"
+2. اضغط "+ CREATE CREDENTIALS" ← "OAuth 2.0 Client ID"
+3. اختر "Desktop application"
+4. اكتب الاسم: `SyncMaster Desktop`
+5. **اترك الحقول فارغة**:
+   - **Authorised JavaScript origins**: اتركه فارغ (لا تدخل شيء)
+   - **Authorised redirect URIs**: اتركه فارغ (لا تدخل شيء)
+6. اضغط "CREATE"
+
+### الخطوة 6: تحميل ملف البيانات
+1. ستظهر نافذة منبثقة مع Client ID و Client Secret
+2. اضغط "DOWNLOAD JSON"
+3. احفظ الملف باسم `credentials.json`
+4. انسخ الملف إلى مجلد التطبيق (نفس مجلد app.py)
+
+### الخطوة 7: اختبار التطبيق
+1. احذف ملف `token.json` إذا كان موجوداً
+2. شغل التطبيق
+3. اضغط على زر "📤 تصدير إلى Google Docs"
+4. ستفتح نافذة متصفح للمصادقة
+5. سجل دخول بحساب Google
+6. اضغط "Allow" لمنح الصلاحيات
+
+## 🎯 نصائح مهمة:
+- **استخدم نفس حساب Google** الذي أنشأت به المشروع
+- **لا تشارك ملف credentials.json** مع أحد
+- **إذا ظهر تحذير "App isn't verified"** اضغط "Advanced" ثم "Go to SyncMaster Export (unsafe)"
+
+## 🔧 استكشاف الأخطاء:
+
+### إذا ظهر "invalid_client":
+- تأكد من استبدال ملف `credentials.json` بالملف الحقيقي من Google
+- تأكد من أن الملف في نفس مجلد `app.py`
+
+### إذا ظهر "access_denied":
+- تأكد من الضغط على "Allow" في صفحة المصادقة
+- تأكد من تسجيل الدخول بنفس حساب Google الذي أنشأت به المشروع
+
+### إذا ظهر "redirect_uri_mismatch":
+- احذف ملف `token.json` وحاول مرة أخرى
+
+## 📞 إذا احتجت مساعدة:
+أرسل لي لقطة شاشة من الخطأ وسأساعدك في حله!
\ No newline at end of file
diff --git a/INTEGRATION_SOLUTION.md b/INTEGRATION_SOLUTION.md
new file mode 100644
index 0000000000000000000000000000000000000000..ab15e12529623bbef1161846f01e8c3f16c071c9
--- /dev/null
+++ b/INTEGRATION_SOLUTION.md
@@ -0,0 +1,75 @@
+# SyncMaster - Integrated Setup
+
+## 🚀 التشغيل المبسط (HuggingFace Ready)
+
+الآن يمكنك تشغيل التطبيق بأمر واحد فقط:
+
+```bash
+npm run dev
+```
+
+أو 
+
+```bash
+npm start
+```
+
+## 🔧 كيف تم حل المشكلة
+
+### المشكلة السابقة:
+- كان يتطلب تشغيل `python recorder_server.py` و `npm run dev` بشكل منفصل
+- غير مناسب للنشر على HuggingFace أو المنصات السحابية
+
+### الحل الجديد:
+1. **خادم متكامل**: تم إنشاء `integrated_server.py` الذي يشغل خادم التسجيل تلقائياً
+2. **نقطة دخول موحدة**: ملف `main.py` يبدأ كل شيء معاً
+3. **تكوين ذكي**: يكتشف البيئة تلقائياً (محلي أو سحابي)
+
+## 📁 الملفات الجديدة
+
+- `integrated_server.py` - يدير خادم التسجيل المدمج
+- `main.py` - نقطة الدخول الرئيسية 
+- `app_config.py` - إعدادات التطبيق
+- `startup.py` - مُشغل متقدم للتطوير
+
+## 🎯 للاستخدام العادي
+
+```bash
+# تشغيل التطبيق (يشمل خادم التسجيل)
+npm run dev
+
+# أو استخدام Python مباشرة
+streamlit run main.py
+```
+
+## ⚙️ للتطوير المتقدم
+
+```bash
+# تشغيل الخوادم بشكل منفصل (للتطوير)
+npm run dev-separate
+```
+
+## 🌐 للنشر على HuggingFace
+
+فقط ارفع المشروع واستخدم:
+- **Command**: `npm run start`
+- **Port**: `5050`
+
+سيتم تشغيل خادم التسجيل تلقائياً في الخلفية!
+
+## ✅ اختبار النظام
+
+```bash
+python integrated_server.py
+```
+
+## 🎉 النتيجة
+
+- **✅ تشغيل بأمر واحد فقط**
+- **✅ جاهز للنشر على HuggingFace**
+- **✅ يعمل محلياً وسحابياً**
+- **✅ لا حاجة لتشغيل أوامر متعددة**
+
+---
+
+المشكلة محلولة! الآن يمكنك استخدام `npm run dev` فقط وسيعمل كل شيء تلقائياً 🎊
diff --git a/PERFORMANCE_IMPROVEMENTS.md b/PERFORMANCE_IMPROVEMENTS.md
new file mode 100644
index 0000000000000000000000000000000000000000..541339ef8befb415fe3b05769ff73032ec5eaa61
--- /dev/null
+++ b/PERFORMANCE_IMPROVEMENTS.md
@@ -0,0 +1,76 @@
+# 🚀 تحسينات الأداء - مشكلة الشاشة البيضاء محلولة
+
+## 🔍 التحليل والمشكلة:
+كانت المشكلة أن خادم التسجيل يبدأ **بشكل متزامن** عند تحميل الصفحة، مما يسبب:
+- ⏰ تأخير في التحميل (نصف ثانية إلى ثانية)
+- ⚪ شاشة بيضاء أثناء انتظار بدء الخادم
+- 🐌 تجربة مستخدم بطيئة
+
+## ✅ الحلول المطبقة:
+
+### 1. **تشغيل غير متزامن للخادم**
+```python
+# بدلاً من:
+ensure_recorder_server()  # يحجب الواجهة
+
+# الآن:
+recorder_thread = threading.Thread(target=start_recorder_async, daemon=True)
+recorder_thread.start()  # لا يحجب الواجهة
+```
+
+### 2. **تسريع فحص الاستجابة**
+```python
+# قبل: timeout=3 ثوان
+# الآن: timeout=0.5 ثانية
+response = requests.get(url, timeout=0.5)
+```
+
+### 3. **تحسين انتظار بدء الخادم**
+```python
+# قبل: sleep(1) × 10 مرات = 10 ثوان
+# الآن: sleep(0.5) × 15 مرة = 7.5 ثانية
+time.sleep(0.5)
+```
+
+### 4. **تحسين CSS لمنع الفلاش**
+```css
+.main .block-container { 
+    animation: fadeIn 0.2s ease-in-out; 
+}
+.stSpinner { display: none !important; }
+```
+
+### 5. **فحص ذكي للخادم**
+```python
+# فحص سريع أولاً
+if integrated_server.is_server_responding():
+    return True  # خروج فوري إذا كان يعمل
+```
+
+## 📊 النتائج:
+
+### قبل التحسين:
+- ⏱️ **تحميل الصفحة**: 1+ ثانية
+- ⚪ **شاشة بيضاء**: نعم
+- 🔄 **تأخير ملحوظ**: نعم
+
+### بعد التحسين:
+- ⏱️ **تحميل الصفحة**: 0.008-0.023 ثانية
+- ⚪ **شاشة بيضاء**: لا
+- ⚡ **تحميل فوري**: نعم
+
+## 🎯 التحسينات الإضافية:
+
+1. **عدم عرض رسائل تحميل غير ضرورية**
+2. **بدء الخادم في الخلفية فقط عند الحاجة**
+3. **تقليل عدد رسائل السجل**
+4. **تحسين CSS للانتقالات السلسة**
+
+## 🚀 النتيجة النهائية:
+
+✅ **لا مزيد من الشاشة البيضاء**  
+✅ **تحميل فوري للمحتوى**  
+✅ **تجربة مستخدم سلسة**  
+✅ **أداء ممتاز (0.008 ثانية)**  
+
+**المشكلة محلولة تماماً!** 🎊
diff --git a/QUICK_START.md b/QUICK_START.md
new file mode 100644
index 0000000000000000000000000000000000000000..3908262d9cabfe18f98d3dfd7e4df039d3fab7c8
--- /dev/null
+++ b/QUICK_START.md
@@ -0,0 +1,202 @@
+# 🎯 دليل الإصلاح والتشغيل السريع - SyncMaster Enhanced
+# Quick Fix and Startup Guide - SyncMaster Enhanced
+
+## ✅ النظام جاهز للعمل! / System Ready!
+
+تم اختبار جميع المكونات بنجاح ✅ All components tested successfully
+
+## 🚀 طرق التشغيل / Startup Methods
+
+### 1. التشغيل التلقائي المتقدم / Advanced Auto-Start (موصى به / Recommended)
+```bash
+python start_debug.py
+```
+**المزايا / Benefits:**
+- فحص تلقائي للمشاكل / Automatic problem detection
+- إصلاح تضارب المنافذ / Port conflict resolution  
+- رسائل خطأ واضحة / Clear error messages
+- تشغيل آمن / Safe startup
+
+### 2. التشغيل اليدوي / Manual Startup
+```bash
+# النافذة الأولى / First Terminal
+python recorder_server.py
+
+# النافذة الثانية / Second Terminal  
+streamlit run app.py --server.port 8501
+```
+
+### 3. التشغيل السريع / Quick Start (Windows)
+```bash
+start_enhanced.bat
+```
+
+## 🌐 الروابط / URLs
+
+بعد التشغيل الناجح / After successful startup:
+
+- **🎙️ واجهة التسجيل / Recording Interface**: http://localhost:5001
+- **💻 التطبيق الرئيسي / Main Application**: http://localhost:8501
+- **🔄 فحص حالة الخادم / Server Status**: http://localhost:5001/record
+
+## 📋 خطوات الاستخدام / Usage Steps
+
+### للطلاب الجدد / For New Users:
+
+#### 1. إعداد اللغة / Language Setup
+- اختر اللغة المفضلة (عربي/English)
+- فعّل الترجمة التلقائية
+- اختر اللغة المستهدفة
+
+#### 2. التسجيل / Recording
+- اذهب لتبويب "🎙️ Record Audio"  
+- اضغط "Start Recording" / "بدء التسجيل"
+- تحدث بوضوح
+- استخدم "Mark Important" للنقاط المهمة
+- اضغط "Stop" عند الانتهاء
+
+#### 3. المعالجة / Processing
+- اضغط "Extract Text" / "استخراج النص"
+- انتظر المعالجة (قد تستغرق دقائق)
+- راجع النص الأصلي والمترجم
+
+#### 4. الحفظ / Saving
+- انسخ النص المطلوب
+- احفظ ملف JSON للمراجعة لاحقاً
+
+## 🔧 استكشاف الأخطاء / Troubleshooting
+
+### المشكلة الأكثر شيوعاً / Most Common Issue:
+```
+Error: Failed to fetch
+POST http://localhost:5001/record net::ERR_CONNECTION_REFUSED
+```
+
+### الحل السريع / Quick Fix:
+```bash
+# 1. أوقف جميع العمليات / Stop all processes
+taskkill /f /im python.exe
+
+# 2. شغّل الاختبار / Run test
+python test_system.py
+
+# 3. شغّل النظام / Start system
+python start_debug.py
+```
+
+### إذا لم يعمل / If Still Not Working:
+```bash
+# فحص المنافذ / Check ports
+netstat -an | findstr :5001
+netstat -an | findstr :8501
+
+# إعادة تثبيت التبعيات / Reinstall dependencies
+pip install --upgrade -r requirements.txt
+```
+
+## 💡 نصائح مهمة / Important Tips
+
+### للحصول على أفضل النتائج / For Best Results:
+
+#### جودة التسجيل / Recording Quality:
+- استخدم سماعة رأس بميكروفون
+- اجلس في مكان هادئ
+- تحدث بوضوح وبطء نسبي
+- تجنب الضوضاء الخلفية
+
+#### إعدادات الترجمة / Translation Settings:
+- **للطلاب العرب**: فعّل الترجمة للإنجليزية لفهم المصطلحات التقنية
+- **للطلاب الدوليين**: استخدم الترجمة للغتك الأم
+- **للمحاضرات المختلطة**: راجع النص بكلا اللغتين
+
+#### استخدام العلامات / Using Markers:
+- ضع علامة عند المفاهيم الجديدة
+- اعلم النقاط المهمة للامتحان
+- استخدم العلامات للتنظيم
+
+## 📱 متطلبات النظام / System Requirements
+
+### الحد الأدنى / Minimum:
+- Python 3.8+
+- 4 GB RAM
+- اتصال إنترنت للترجمة
+- مساحة 1 GB على القرص الصلب
+
+### الموصى به / Recommended:
+- Python 3.10+
+- 8 GB RAM
+- اتصال إنترنت سريع
+- SSD للتخزين
+- ميكروفون عالي الجودة
+
+## 🌟 ميزات متقدمة / Advanced Features
+
+### اختصارات لوحة المفاتيح / Keyboard Shortcuts:
+- **Space**: بدء/إيقاف التسجيل
+- **M**: وضع علامة مهمة  
+- **P**: إيقاف مؤقت/استئناف
+- **R**: إعادة تسجيل
+
+### واجهة برمجة التطبيقات / API Features:
+- ترجمة نصوص مستقلة
+- معالجة مجمعة للملفات
+- كشف اللغة التلقائي
+- تخصيص إعدادات الصوت
+
+## 📞 الدعم التقني / Technical Support
+
+### أدوات التشخيص / Diagnostic Tools:
+```bash
+# اختبار شامل / Complete test
+python test_system.py
+
+# فحص الاتصال / Connection test  
+python -c "import requests; print(requests.get('http://localhost:5001/record').status_code)"
+
+# اختبار الترجمة / Translation test
+python -c "from translator import AITranslator; t=AITranslator(); print(t.translate_text('Hello', 'ar'))"
+```
+
+### ملفات السجل / Log Files:
+- تحقق من console المتصفح (F12)
+- راجع سجلات الطرفية
+- ابحث عن ملفات tmp*.json
+
+## 🎓 للمدرسين والمحاضرين / For Teachers and Lecturers
+
+### إعدادات الفصل / Classroom Setup:
+- تأكد من إذن التسجيل
+- وضح للطلاب كيفية الاستخدام
+- اقترح جلسات تدريبية
+
+### نصائح للمحاضرات / Lecture Tips:
+- تحدث بوضوح
+- اكرر المصطلحات المهمة  
+- استخدم فترات صمت قصيرة
+- اشرح بعدة لغات إذا أمكن
+
+---
+
+## 🎉 مبروك! / Congratulations!
+
+**النظام جاهز للاستخدام! / System is ready to use!**
+
+```bash
+# للبدء الآن / To start now:
+python start_debug.py
+```
+
+**استمتع بتجربة تعليمية محسنة مع SyncMaster! 🚀**
+**Enjoy an enhanced learning experience with SyncMaster! 🚀**
+
+---
+
+### 📋 Checklist
+
+- ✅ Python مثبت / Python installed
+- ✅ التبعيات مثبتة / Dependencies installed  
+- ✅ مفتاح API مُعد / API key configured
+- ✅ اختبار النظام نجح / System test passed
+- ✅ جاهز للاستخدام / Ready to use
+
+**🎯 التالي: python start_debug.py**
diff --git a/README.md b/README.md
new file mode 100644
index 0000000000000000000000000000000000000000..107df7d3a20110780ee68158d707012966e83258
--- /dev/null
+++ b/README.md
@@ -0,0 +1,221 @@
+---
+title: SyncMaster Enhanced
+emoji: 🚀
+colorFrom: red
+colorTo: red
+sdk: docker
+app_port: 8501
+tags:
+- streamlit
+- ai-translation
+- speech-to-text
+- multilingual
+- education
+pinned: false
+short_description: AI-powered audio transcription
+license: mit
+---
+
+# SyncMaster Enhanced - AI-Powered Audio Transcription & Translation
+
+> **🌟 New: Enhanced with AI Translation Support for International Students**
+> **جديد: محسن مع دعم الترجمة بالذكاء الاصطناعي للطلاب الدوليين**
+
+SyncMaster is an intelligent audio-text synchronization platform specifically designed for international students in universities. It provides real-time audio recording, AI-powered transcription, and automatic translation to help students better understand and review their lectures.
+
+## ✨ Key Features
+
+### 🌐 Multi-Language Support
+- **Full Arabic Interface**: Complete Arabic UI for better accessibility
+- **AI-Powered Translation**: Automatic translation to Arabic, English, French, and Spanish
+- **Language Detection**: Automatically detects the source language
+- **Academic Context**: Specialized translation for academic content
+
+### 🎙️ Enhanced Recording
+- **Browser-based Recording**: Record directly from your web browser
+- **Real-time Audio Visualization**: Visual feedback during recording
+- **Important Markers**: Mark important points during lectures
+- **Pause/Resume**: Full control over recording sessions
+
+### 🤖 AI Technology
+- **Gemini AI Integration**: Accurate transcription using Google's Gemini AI
+- **Advanced Translation**: Context-aware translation for educational content
+- **Parallel Processing**: Fast and efficient audio processing
+
+### 📱 Student-Friendly Features
+- **Responsive Design**: Works on desktop, tablet, and mobile
+- **Keyboard Shortcuts**: Quick access to common functions
+- **Accessibility**: Screen reader support and RTL language support
+- **Offline Capability**: Process recordings without constant internet
+
+## 🚀 Quick Start
+
+### For International Students:
+
+1. **Setup**:
+   ```bash
+   # Clone or download the project
+   # Install Python 3.8+
+   python setup_enhanced.py
+   ```
+
+2. **Run**:
+   ```bash
+   # Windows
+   start_enhanced.bat
+   
+   # Linux/Mac
+   python setup_enhanced.py
+   ```
+
+3. **Configure**:
+   - Add your Gemini API key to `.env` file
+   - Choose your preferred language (Arabic/English)
+   - Enable translation and select target language
+
+### API Key Setup:
+1. Get a free Gemini API key from [Google AI Studio](https://makersuite.google.com/app/apikey)
+2. Add it to your `.env` file:
+   ```
+   GEMINI_API_KEY=your_api_key_here
+   ```
+
+## 📖 Usage Guide
+
+### Recording Lectures:
+1. Go to the **Record Audio** tab
+2. Click **Start Recording**
+3. Use **Mark Important** for key points
+4. Click **Stop** when finished
+5. Click **Extract Text** to process
+
+### Translation:
+1. Enable translation in settings
+2. Select target language
+3. Process your audio
+4. Review both original and translated text
+
+### Export Options:
+- Copy text for notes
+- Save as files for later review
+- Generate synchronized videos (coming soon)
+
+## 🎓 For Students
+
+### Arabic Students (للطلاب العرب):
+- استخدم الواجهة العربية لسهولة الاستخدام
+- فعّل الترجمة للإنجليزية لفهم المصطلحات التقنية
+- ضع علامات على المفاهيم الجديدة أثناء المحاضرة
+
+### International Students:
+- Use translation to your native language for better understanding
+- Mark important concepts during lectures
+- Review both original and translated text together
+
+## ⌨️ Keyboard Shortcuts
+- **Space**: Start/Stop recording
+- **M**: Mark important point
+- **P**: Pause/Resume
+- **R**: Re-record
+
+## 🔧 Technical Requirements
+
+### System Requirements:
+- Python 3.8 or higher
+- Modern web browser (Chrome, Firefox, Safari, Edge)
+- Microphone access for recording
+- Internet connection for AI processing
+
+### Dependencies:
+- Streamlit (Web interface)
+- Google Generative AI (Transcription & Translation)
+- Flask (Recording server)
+- LibROSA (Audio processing)
+
+## 📱 Browser Compatibility
+
+| Browser | Recording | Translation | UI |
+|---------|-----------|-------------|----| 
+| Chrome | ✅ | ✅ | ✅ |
+| Firefox | ✅ | ✅ | ✅ |
+| Safari | ✅ | ✅ | ✅ |
+| Edge | ✅ | ✅ | ✅ |
+
+## 🛠️ Troubleshooting
+
+### Common Issues:
+
+**Microphone not working:**
+- Grant microphone permission to your browser
+- Check system audio settings
+- Try a different browser
+
+**Translation errors:**
+- Check internet connection
+- Verify Gemini API key
+- Try processing again
+
+**Poor transcription quality:**
+- Ensure clear audio recording
+- Reduce background noise
+- Speak clearly and at moderate pace
+
+## 🔮 Roadmap
+
+### Coming Soon:
+- **Smart Content Analysis**: Automatic extraction of key concepts
+- **Study Cards**: Generate flashcards from lectures
+- **Platform Integration**: Connect with Moodle, Canvas, etc.
+- **Collaborative Features**: Share recordings with classmates
+- **Advanced Analytics**: Learning progress tracking
+
+## 📚 Documentation
+
+- [**Arabic Guide**](README_AR.md) - دليل باللغة العربية
+- [**API Documentation**](docs/api.md) - Technical API reference
+- [**Troubleshooting**](docs/troubleshooting.md) - Detailed problem solving
+
+## 🤝 Contributing
+
+We welcome contributions from the international student community:
+
+1. Fork the repository
+2. Create a feature branch
+3. Add your improvements
+4. Submit a pull request
+
+### Areas for Contribution:
+- Additional language support
+- UI improvements
+- Mobile optimization
+- Documentation translation
+
+## 📄 License
+
+This project is licensed under the MIT License - see the [LICENSE](LICENSE) file for details.
+
+## 🙏 Acknowledgments
+
+- Google Gemini AI for transcription and translation
+- Streamlit team for the amazing web framework
+- International student community for feedback and testing
+
+## 📞 Support
+
+For technical support or questions:
+- Check the browser console (F12) for error details
+- Review log files in the application directory
+- Ensure all dependencies are up to date
+
+---
+
+**Made with ❤️ for international students worldwide**
+**صُنع بـ ❤️ للطلاب الدوليين حول العالم**
+
+---
+
+### Quick Links:
+- 🚀 [Quick Start Guide](docs/quickstart.md)
+- 🌐 [Arabic Documentation](README_AR.md)
+- 🎓 [Student Guide](docs/student-guide.md)
+- 🔧 [Technical Setup](docs/technical-setup.md)
diff --git a/README_AR.md b/README_AR.md
new file mode 100644
index 0000000000000000000000000000000000000000..98a8ec201d6c87876c6574a9272773c8f0d8de1f
--- /dev/null
+++ b/README_AR.md
@@ -0,0 +1,134 @@
+# SyncMaster - دليل المستخدم للطلاب الأجانب
+
+## 🎯 نظرة عامة
+SyncMaster هو تطبيق ذكي مطور خصيصاً للطلاب الأجانب في الجامعات لتسجيل المحاضرات وتحويلها إلى نص مكتوب مع ترجمة فورية باستخدام الذكاء الاصطناعي.
+
+## ✨ الميزات الجديدة
+
+### 🌐 دعم متعدد اللغات
+- **واجهة عربية كاملة**: تم تطوير واجهة باللغة العربية لتسهيل الاستخدام
+- **ترجمة فورية**: ترجمة النص المنسوخ إلى العربية والإنجليزية والفرنسية والإسبانية
+- **كشف اللغة التلقائي**: يتعرف النظام على لغة المحاضرة تلقائياً
+
+### 🎙️ ميزات التسجيل المحسنة
+- **تسجيل مباشر**: تسجيل المحاضرات مباشرة من المتصفح
+- **علامات مهمة**: وضع علامات على النقاط المهمة أثناء التسجيل
+- **مؤشر مستوى الصوت**: عرض مرئي لمستوى الصوت
+- **إيقاف مؤقت واستئناف**: تحكم كامل في التسجيل
+
+### 🤖 ذكاء اصطناعي متطور
+- **نسخ دقيق**: استخدام Gemini AI لنسخ دقيق للمحاضرات
+- **ترجمة محسنة**: ترجمة متخصصة للمحتوى الأكاديمي
+- **معالجة متوازية**: معالجة سريعة وفعالة
+
+## 🚀 كيفية الاستخدام
+
+### الخطوة 1: إعداد اللغة
+1. اختر لغة الواجهة من القائمة العلوية (العربية/English)
+2. فعّل الترجمة التلقائية
+3. اختر اللغة المستهدفة للترجمة
+
+### الخطوة 2: التسجيل
+1. اضغط على تبويب "🎙️ Record Audio"
+2. اضغط "Start Recording" لبدء التسجيل
+3. استخدم "Mark Important" لوضع علامات على النقاط المهمة
+4. اضغط "Stop" لإنهاء التسجيل
+
+### الخطوة 3: المعالجة والترجمة
+1. اضغط "Extract Text" لبدء المعالجة
+2. انتظر حتى يكتمل النسخ والترجمة
+3. راجع النص الأصلي والمترجم
+
+### الخطوة 4: التصدير
+1. احفظ النتائج أو انسخها
+2. استخدم الملف المحفوظ للمراجعة لاحقاً
+
+## ⌨️ اختصارات لوحة المفاتيح
+- **Space**: بدء/إيقاف التسجيل
+- **M**: وضع علامة مهمة
+- **P**: إيقاف مؤقت/استئناف
+- **R**: إعادة تسجيل
+
+## 📱 نصائح للطلاب الأجانب
+
+### للطلاب العرب:
+- استخدم الواجهة العربية للسهولة
+- فعّل الترجمة للإنجليزية لفهم المصطلحات التقنية
+- ضع علامات على المفاهيم الجديدة
+
+### للطلاب الدوليين:
+- استخدم الترجمة إلى لغتك الأم للفهم الأفضل
+- اعتمد على العلامات المهمة للمراجعة السريعة
+- راجع النص المترجم والأصلي معاً
+
+## 🔧 إعدادات متقدمة
+
+### جودة التسجيل:
+- **عالية**: للمحاضرات المهمة (320 kbps)
+- **متوسطة**: للاستخدام العادي (192 kbps)
+- **منخفضة**: لتوفير المساحة (128 kbps)
+
+### إعدادات الترجمة:
+- **Arabic**: للطلاب العرب
+- **English**: للمحتوى الدولي
+- **French**: للطلاب الفرنكوفونيين
+- **Spanish**: للطلاب الناطقين بالإسبانية
+
+## 🛠️ استكشاف الأخطاء
+
+### مشاكل الميكروفون:
+1. تأكد من إعطاء إذن الميكروفون للمتصفح
+2. تحقق من إعدادات الصوت في النظام
+3. جرب متصفح آخر إذا لزم الأمر
+
+### مشاكل الترجمة:
+1. تأكد من اتصال الإنترنت
+2. تحقق من صحة مفتاح API
+3. جرب إعادة المعالجة
+
+### مشاكل في النسخ:
+1. تأكد من وضوح الصوت
+2. قلل الضوضاء في الخلفية
+3. تحدث بوضوح وبطء نسبياً
+
+## 📞 الدعم التقني
+
+### الحصول على المساعدة:
+- تحقق من console المتصفح (F12) للأخطاء
+- راجع ملفات السجل في مجلد التطبيق
+- تأكد من تحديث جميع المكتبات
+
+### نصائح للأداء الأفضل:
+- استخدم Chrome أو Firefox للتوافق الأفضل
+- أغلق التطبيقات الأخرى أثناء التسجيل
+- تأكد من مساحة كافية على القرص الصلب
+
+## 🎓 نصائح أكاديمية
+
+### للمحاضرات:
+- اجلس في مقدمة القاعة للصوت الأوضح
+- استخدم علامات المحاضر المهمة كدليل
+- راجع الترجمة مع زملاء الدراسة
+
+### للمذاكرة:
+- استخدم النص المترجم للمراجعة السريعة
+- ابحث عن المفاهيم المترجمة في مصادر إضافية
+- اربط النص الأصلي بالترجمة لتحسين اللغة
+
+## 🔮 ميزات قادمة
+
+### التحديثات المخططة:
+- **تحليل المحتوى**: استخراج النقاط الرئيسية تلقائياً
+- **بطاقات المراجعة**: إنشاء بطاقات دراسة من المحاضرات
+- **التكامل مع المنصات**: ربط مع Moodle وCanvas
+- **المشاركة التعاونية**: مشاركة المحاضرات مع الزملاء
+
+---
+
+## 📄 إخلاء المسؤولية
+
+هذا التطبيق مخصص للاستخدام التعليمي. تأكد من الحصول على إذن المحاضر قبل تسجيل المحاضرات. النسخ والترجمة قد يحتويان على أخطاء، لذا راجعهما دائماً.
+
+---
+
+**نتمنى لك تجربة تعليمية ممتازة مع SyncMaster! 🎓✨**
diff --git a/SOLUTION_SUMMARY.md b/SOLUTION_SUMMARY.md
new file mode 100644
index 0000000000000000000000000000000000000000..6e3811f7ff20ddd8e6c9b27c8fc79175758b81fe
--- /dev/null
+++ b/SOLUTION_SUMMARY.md
@@ -0,0 +1,69 @@
+# 🎉 تم حل المشكلة بنجاح!
+
+## ✅ ملخص الحل
+
+تم حل مشكلة "system offline" في ميزة Lecture Recorder بنجاح. الآن يمكنك تشغيل التطبيق بأمر واحد فقط:
+
+```bash
+npm run dev
+```
+
+## 🔧 التغييرات التي تمت
+
+### 1. ملفات جديدة تم إنشاؤها:
+- `integrated_server.py` - خادم متكامل للتسجيل
+- `main.py` - نقطة دخول بسيطة ومدمجة
+- `app_config.py` - إعدادات التطبيق
+- `startup.py` - مُشغل متقدم للتطوير
+
+### 2. ملفات تم تعديلها:
+- `app.py` - إضافة استيراد الخادم المدمج
+- `package.json` - تحديث أوامر التشغيل
+
+## 🚀 كيفية الاستخدام
+
+### للاستخدام العادي:
+```bash
+npm run dev
+```
+
+### للنشر على HuggingFace:
+```bash
+npm start
+```
+
+### للتطوير المتقدم (خوادم منفصلة):
+```bash
+npm run dev-separate
+```
+
+## ✨ المميزات الجديدة
+
+1. **🎯 تشغيل موحد**: أمر واحد فقط لتشغيل كل شيء
+2. **☁️ جاهز للسحابة**: يعمل تلقائياً على HuggingFace و Railway
+3. **🔧 تكوين ذكي**: يكتشف البيئة ويتكيف معها
+4. **🛡️ معالجة أخطاء محسنة**: تشغيل احتياطي في حالة فشل الطريقة الأولى
+5. **📊 مراقبة الحالة**: فحص تلقائي لحالة الخوادم
+
+## 🧪 اختبار النظام
+
+تم اختبار النظام وأظهر النتائج التالية:
+- ✅ خادم التسجيل يبدأ تلقائياً
+- ✅ Streamlit يعمل على المنفذ 5050
+- ✅ خادم التسجيل يعمل على المنفذ 5001
+- ✅ التكامل بين الخوادم يعمل بنجاح
+
+## 🎊 النتيجة النهائية
+
+**المشكلة محلولة تماماً!** 
+
+لن تحتاج بعد الآن إلى:
+- ❌ تشغيل `python recorder_server.py` منفصلاً
+- ❌ القلق بشأن "system offline"
+- ❌ تشغيل أوامر متعددة
+
+فقط استخدم `npm run dev` وسيعمل كل شيء تلقائياً! 🚀
+
+---
+
+**جاهز للنشر على HuggingFace الآن!** 🌟
diff --git a/SUMMARY_FIX_REPORT.md b/SUMMARY_FIX_REPORT.md
new file mode 100644
index 0000000000000000000000000000000000000000..3d25cafd0c66157728e4d84f861f4e2449c0a5b6
--- /dev/null
+++ b/SUMMARY_FIX_REPORT.md
@@ -0,0 +1,169 @@
+# حل مشكلة زر التلخيص - تقرير الإصلاح النهائي 🎉
+
+## 📋 ملخص المشكلة
+كان زر "Generate Smart Lecture Summary" لا يعمل في تلخيص النص المستخرج من الذكاء الاصطناعي بعد جلبه من الصوت، مع ظهور خطأ CORS:
+
+```
+Access to fetch at 'http://localhost:5001/summarize' from origin 'http://localhost:5054' has been blocked by CORS policy: Response to preflight request doesn't pass access control check: The 'Access-Control-Allow-Origin' header contains multiple values '*, *', but only one is allowed.
+```
+
+## 🔍 التشخيص المنجز
+تم إنشاء نظام تشخيص شامل كشف عن:
+
+### 1. مشكلة CORS الرئيسية ❌
+- **المشكلة**: الخادم يرسل `'*, *'` بدلاً من `'*'`
+- **السبب**: تكرار إعدادات CORS - مرة من `flask-cors` ومرة يدوياً في كل endpoint
+- **النتيجة**: تكرار header `Access-Control-Allow-Origin`
+
+### 2. مكتبة مفقودة ❌
+- **المشكلة**: `google-generativeai` غير مثبتة
+- **التأثير**: فشل في وظيفة التلخيص
+
+## ✅ الحلول المطبقة
+
+### 1. إصلاح مشكلة CORS
+#### أ. تبسيط إعداد CORS في `recorder_server.py`:
+```python
+# قبل الإصلاح - إعداد معقد
+CORS(app, resources={
+    r"/record": {"origins": "*"},
+    r"/translate": {"origins": "*"},
+    r"/languages": {"origins": "*"},
+    r"/ui-translations/*": {"origins": "*"},
+    r"/notes": {"origins": "*"},
+    r"/notes/*": {"origins": "*"},
+    r"/summarize": {"origins": "*"}
+})
+
+# بعد الإصلاح - إعداد مبسط وصحيح
+CORS(app, 
+     origins="*",
+     methods=['GET', 'POST', 'PUT', 'DELETE', 'OPTIONS'],
+     allow_headers=['Content-Type', 'Authorization']
+)
+```
+
+#### ب. إزالة الإعدادات اليدوية المكررة:
+```python
+# قبل الإصلاح - إعداد يدوي مكرر
+if request.method == 'OPTIONS':
+    headers = {
+        'Access-Control-Allow-Origin': '*',
+        'Access-Control-Allow-Methods': 'POST, OPTIONS',
+        'Access-Control-Allow-Headers': 'Content-Type',
+    }
+    return ('', 204, headers)
+
+# بعد الإصلاح - تبسيط
+if request.method == 'OPTIONS':
+    return '', 204  # flask-cors ستتولى الأمر
+```
+
+### 2. تثبيت المكتبات المفقودة
+```bash
+pip install google-generativeai
+```
+
+### 3. تحسين معالجة الأخطاء في JavaScript
+تم تحديث دالة `generateSummary()` في `templates/recorder.html`:
+- رسائل خطأ محددة باللغة العربية
+- معالجة أفضل لتنسيقات الاستجابة المختلفة
+- تشخيص أوضح للمشاكل
+
+### 4. تحسين دالة عرض النتائج
+تم تحديث `displaySummaryResults()` للتعامل مع:
+- تنسيقات مختلفة للاستجابة (نص أو كائن)
+- عرض محتوى احتياطي في حالة عدم وجود المحتوى المتوقع
+
+## 🧪 أدوات التشخيص المُنشأة
+
+### 1. `diagnose_summary.py`
+نظام تشخيص شامل يفحص:
+- حالة العمليات والمنافذ
+- إعدادات CORS
+- وظيفة التلخيص
+- المكتبات المطلوبة
+
+### 2. `test_summary_button.py`
+اختبار مبسط ومباشر لزر التلخيص
+
+### 3. `test_summarize.py`
+اختبار أساسي لـ endpoint التلخيص
+
+## 📊 نتائج الاختبار النهائية ✅
+
+```
+🎉 جميع الاختبارات نجحت!
+✅ زر التلخيص يعمل بشكل صحيح
+
+📊 ملخص التشخيص:
+  📦 المكتبات: ✅ موجودة
+  🔧 عملية Python: ✅ تعمل
+  🌐 المنفذ 5001: ✅ مفتوح
+  🔧 CORS: ✅ صحيح
+  🤖 التلخيص: ✅ يعمل
+```
+
+## 🔧 الملفات المُعدّلة
+
+### 1. `recorder_server.py`
+- إصلاح إعدادات CORS
+- إزالة التكرار في headers
+- تبسيط معالجة OPTIONS requests
+
+### 2. `templates/recorder.html`
+- تحسين دالة `generateSummary()`
+- تحسين دالة `displaySummaryResults()`
+- رسائل خطأ أوضح
+
+### 3. ملفات التشخيص الجديدة
+- `diagnose_summary.py`
+- `test_summary_button.py`
+- `test_summarize.py`
+
+## 🚀 كيفية التحقق من الحل
+
+### 1. تشغيل الخادم:
+```bash
+python recorder_server.py
+```
+
+### 2. تشغيل التشخيص:
+```bash
+python diagnose_summary.py
+```
+
+### 3. اختبار زر التلخيص:
+```bash
+python test_summary_button.py
+```
+
+### 4. اختبار من الواجهة:
+1. افتح `http://localhost:5054`
+2. سجل صوت أو ادخل نص
+3. اضغط زر "🤖 Generate Smart Lecture Summary"
+4. تأكد من ظهور الملخص
+
+## 💡 نصائح للمستقبل
+
+### 1. تجنب تكرار CORS
+- استخدم إعداد CORS واحد فقط
+- لا تضع إعدادات يدوية إضافية
+
+### 2. مراقبة التبعيات
+- تأكد من تثبيت جميع المكتبات المطلوبة
+- استخدم `requirements.txt` محدث
+
+### 3. استخدام أدوات التشخيص
+- شغل `diagnose_summary.py` عند مواجهة مشاكل
+- يوفر تشخيص سريع وشامل
+
+## 🎯 الخلاصة
+
+تم حل مشكلة زر التلخيص بنجاح من خلال:
+1. ✅ إصلاح مشكلة CORS المزدوجة
+2. ✅ تثبيت المكتبات المفقودة  
+3. ✅ تحسين معالجة الأخطاء
+4. ✅ إنشاء أدوات تشخيص شاملة
+
+**النتيجة: زر التلخيص يعمل بشكل مثالي الآن! 🎉**
diff --git a/TECHNICAL_IMPLEMENTATION.md b/TECHNICAL_IMPLEMENTATION.md
new file mode 100644
index 0000000000000000000000000000000000000000..f893c5cf9af91405267f24578d50f8959085d199
--- /dev/null
+++ b/TECHNICAL_IMPLEMENTATION.md
@@ -0,0 +1,299 @@
+# SyncMaster Enhanced - Technical Implementation Summary
+
+## 🎯 Summary of Enhancements
+
+This document outlines the comprehensive improvements made to SyncMaster to support AI-powered translation for international students.
+
+## 🔧 New Components Added
+
+### 1. `translator.py` - AI Translation Engine
+```python
+class AITranslator:
+    - translate_text(text, target_language='ar', source_language='auto')
+    - detect_language(text)
+    - translate_ui_elements(ui_dict, target_language='ar')
+    - batch_translate(texts, target_language='ar')
+```
+
+**Features:**
+- Gemini AI-powered translation
+- Academic content optimization
+- Multi-language support (Arabic, English, French, Spanish)
+- Batch processing capabilities
+- Context-aware translation
+
+### 2. Enhanced `audio_processor.py`
+```python
+class AudioProcessor:
+    - get_word_timestamps_with_translation(audio_file_path, target_language='ar')
+    - batch_translate_transcription(audio_file_path, target_languages)
+    - _create_translated_timestamps(original_timestamps, original_text, translated_text)
+```
+
+**New Features:**
+- Integrated translation with transcription
+- Proportional timestamp mapping for translated text
+- Multi-language processing
+- Enhanced error handling and logging
+
+### 3. Updated `recorder_server.py`
+```python
+@app.route('/record', methods=['POST'])
+def record():
+    # Enhanced with translation parameters:
+    # - target_language
+    # - enable_translation
+    # - comprehensive response with both original and translated text
+
+@app.route('/translate', methods=['POST'])
+def translate_text():
+    # Standalone translation endpoint
+
+@app.route('/languages', methods=['GET'])
+def get_supported_languages():
+    # Get list of supported languages
+
+@app.route('/ui-translations/<language>', methods=['GET'])
+def get_ui_translations(language):
+    # Get UI translations for specific language
+```
+
+### 4. Enhanced `templates/recorder.html`
+**New Features:**
+- Multi-language interface (English/Arabic)
+- RTL support for Arabic
+- Translation toggle controls
+- Target language selection
+- Enhanced visual design
+- Keyboard shortcuts
+- Accessibility improvements
+
+**UI Improvements:**
+- Modern gradient design
+- Responsive layout for mobile devices
+- Real-time language switching
+- Visual feedback for translation status
+- Better error messaging
+
+### 5. Updated `app.py` - Main Application
+**Enhancements:**
+- Language selection in sidebar
+- Translation settings integration
+- Enhanced processing workflow
+- Bilingual interface support
+- Improved user experience flow
+
+## 🌐 Multi-Language Support Implementation
+
+### UI Translation System
+```python
+UI_TRANSLATIONS = {
+    'en': { /* English translations */ },
+    'ar': { /* Arabic translations */ }
+}
+```
+
+### Dynamic Language Switching
+- Client-side language detection
+- Server-side translation API
+- Real-time UI updates
+- RTL text direction support
+
+### Translation Workflow
+1. **Audio Recording** → Record with language preferences
+2. **Transcription** → AI-powered speech-to-text
+3. **Language Detection** → Automatic source language identification
+4. **Translation** → Context-aware AI translation
+5. **Presentation** → Side-by-side original and translated text
+
+## 🚀 API Enhancements
+
+### Recording Endpoint (`/record`)
+**Request Parameters:**
+```json
+{
+    "audio_data": "binary_audio_file",
+    "markers": "[timestamp_array]",
+    "target_language": "ar|en|fr|es",
+    "enable_translation": "true|false"
+}
+```
+
+**Response Format:**
+```json
+{
+    "success": true,
+    "original_text": "Original transcription",
+    "translated_text": "Translated text",
+    "file_path": "path/to/saved/file.json",
+    "markers": [timestamps],
+    "target_language": "ar",
+    "translation_enabled": true,
+    "translation_success": true,
+    "language_detected": "en"
+}
+```
+
+### Translation Endpoint (`/translate`)
+**Request:**
+```json
+{
+    "text": "Text to translate",
+    "target_language": "ar",
+    "source_language": "auto"
+}
+```
+
+**Response:**
+```json
+{
+    "success": true,
+    "original_text": "Original text",
+    "translated_text": "النص المترجم",
+    "source_language": "en",
+    "target_language": "ar"
+}
+```
+
+## 📱 Frontend Enhancements
+
+### JavaScript Features
+```javascript
+// Language Management
+async function loadTranslations(language)
+function applyTranslations()
+function changeLanguage()
+
+// Enhanced Recording
+function displayResults(result)
+function displayMarkers(markers)
+function showMessage(message, type)
+
+// Keyboard Shortcuts
+document.addEventListener('keydown', handleKeyboardShortcuts)
+```
+
+### CSS Improvements
+```css
+/* RTL Support */
+html[dir="rtl"] { direction: rtl; }
+
+/* Modern Design */
+:root {
+    --primary-color: #4A90E2;
+    --success-color: #50C878;
+    /* ... more color variables */
+}
+
+/* Responsive Design */
+@media (max-width: 768px) {
+    /* Mobile optimizations */
+}
+```
+
+## 🔒 Security & Performance
+
+### Security Measures
+- Input validation for all API endpoints
+- CORS configuration for cross-origin requests
+- Secure file handling with temporary files
+- API key protection in environment variables
+
+### Performance Optimizations
+- Parallel processing for audio and translation
+- Efficient memory management
+- Chunked audio processing
+- Client-side caching for translations
+
+## 📊 File Structure Changes
+
+```
+SyncMaster - Copy (2)/
+├── translator.py              # NEW: AI Translation engine
+├── audio_processor.py         # ENHANCED: With translation support
+├── recorder_server.py         # ENHANCED: Additional endpoints
+├── app.py                    # ENHANCED: Multi-language support
+├── templates/
+│   └── recorder.html         # ENHANCED: Multi-language UI
+├── README_AR.md              # NEW: Arabic documentation
+├── setup_enhanced.py         # NEW: Enhanced setup script
+├── start_enhanced.bat        # NEW: Quick start script
+├── requirements.txt          # UPDATED: Additional dependencies
+└── .env                      # UPDATED: Additional configuration
+```
+
+## 🎓 Educational Features
+
+### For International Students
+1. **Language Barrier Reduction**: Real-time translation of lectures
+2. **Better Comprehension**: Side-by-side original and translated text
+3. **Cultural Adaptation**: Interface in native language
+4. **Academic Context**: Specialized translation for educational content
+
+### For Arabic Students
+1. **Native Interface**: Complete Arabic UI
+2. **Technical Term Translation**: English technical terms with Arabic explanations
+3. **Reading Direction**: Proper RTL text display
+4. **Cultural Context**: Academic content adapted for Arabic speakers
+
+## 🔧 Installation & Setup
+
+### Enhanced Setup Process
+1. **Automated Installation**: `python setup_enhanced.py`
+2. **Dependency Management**: Automatic package installation
+3. **Configuration Validation**: Environment file checking
+4. **Service Management**: Automatic server startup
+
+### Quick Start Options
+- **Windows**: `start_enhanced.bat`
+- **Cross-platform**: `python setup_enhanced.py`
+- **Manual**: Individual component startup
+
+## 📈 Testing & Quality Assurance
+
+### Translation Quality
+- Academic content optimization
+- Technical term preservation
+- Context-aware translation
+- Fallback mechanisms
+
+### User Experience Testing
+- Multi-language interface testing
+- Mobile responsiveness
+- Accessibility compliance
+- Performance optimization
+
+## 🔮 Future Enhancements
+
+### Planned Features
+1. **Advanced Translation**: Subject-specific terminology
+2. **Collaboration Tools**: Shared study sessions
+3. **Learning Analytics**: Progress tracking
+4. **Platform Integration**: LMS connectivity
+5. **Offline Support**: Local processing capabilities
+
+### Technical Roadmap
+1. **Model Optimization**: Faster processing
+2. **Caching System**: Reduced API calls
+3. **Advanced UI**: More interactive features
+4. **Mobile App**: Native mobile application
+
+---
+
+## 📞 Technical Support
+
+### Debugging Features
+- Comprehensive logging system
+- Browser console integration
+- Error message localization
+- Performance monitoring
+
+### Troubleshooting Resources
+- Detailed error messages
+- Multi-language support documentation
+- Community forum integration
+- Technical FAQ
+
+---
+
+**This enhanced version of SyncMaster represents a significant advancement in making educational technology accessible to international students worldwide.**
diff --git a/TROUBLESHOOTING.md b/TROUBLESHOOTING.md
new file mode 100644
index 0000000000000000000000000000000000000000..8872e2d993dd128afb3ea0a9f18cdee1710b453c
--- /dev/null
+++ b/TROUBLESHOOTING.md
@@ -0,0 +1,251 @@
+# 🛠️ دليل استكشاف الأخطاء - SyncMaster Enhanced
+# Troubleshooting Guide - SyncMaster Enhanced
+
+## 🔍 الأخطاء الشائعة وحلولها / Common Errors and Solutions
+
+### 1. خطأ الاتصال بالخادم / Server Connection Error
+```
+Error: Failed to fetch
+POST http://localhost:5001/record net::ERR_CONNECTION_REFUSED
+```
+
+**الأسباب المحتملة / Possible Causes:**
+- الخادم غير يعمل / Server not running
+- منفذ 5001 مستخدم من برنامج آخر / Port 5001 used by another application
+- جدار حماية يحجب الاتصال / Firewall blocking connection
+
+**الحلول / Solutions:**
+
+#### أ) تشغيل اختبار النظام / Run System Test:
+```bash
+python test_system.py
+```
+
+#### ب) تشغيل الخادم يدوياً / Start Server Manually:
+```bash
+# إيقاف جميع العمليات / Stop all processes
+taskkill /f /im python.exe
+
+# تشغيل الخادم / Start server
+python recorder_server.py
+```
+
+#### ج) استخدام البدء المتقدم / Use Debug Startup:
+```bash
+python start_debug.py
+```
+
+#### د) فحص المنافذ / Check Ports:
+```bash
+# Windows
+netstat -an | findstr :5001
+
+# Linux/Mac
+lsof -i :5001
+```
+
+### 2. مشكلة مفتاح API / API Key Issues
+```
+ERROR: GEMINI_API_KEY not found in environment variables
+```
+
+**الحل / Solution:**
+1. تأكد من وجود ملف `.env`:
+```bash
+# إنشاء ملف .env / Create .env file
+echo GEMINI_API_KEY=your_actual_api_key_here > .env
+```
+
+2. احصل على مفتاح API من:
+   - [Google AI Studio](https://makersuite.google.com/app/apikey)
+
+3. أضف المفتاح إلى `.env`:
+```
+GEMINI_API_KEY=AIzaSyAS7JtrXjlNjyuo3RG5z6rkwocCwFy1YuA
+```
+
+### 3. مشاكل الصوت / Audio Issues
+```
+UserWarning: PySoundFile failed. Trying audioread instead.
+```
+
+**الحلول / Solutions:**
+
+#### أ) تثبيت SoundFile مرة أخرى / Reinstall SoundFile:
+```bash
+pip uninstall soundfile
+pip install soundfile
+```
+
+#### ب) تثبيت FFmpeg (إذا لزم الأمر) / Install FFmpeg if needed:
+```bash
+# Windows (using chocolatey)
+choco install ffmpeg
+
+# Or download from: https://ffmpeg.org/download.html
+```
+
+#### ج) فحص تنسيق الملف / Check Audio Format:
+- استخدم WAV بدلاً من MP3
+- تأكد من جودة التسجيل
+
+### 4. مشاكل الترجمة / Translation Issues
+```
+WARNING: Gemini returned empty translation response
+```
+
+**الحلول / Solutions:**
+
+#### أ) فحص اتصال الإنترنت / Check Internet Connection:
+```bash
+ping google.com
+```
+
+#### ب) اختبار مفتاح API / Test API Key:
+```python
+python test_system.py
+```
+
+#### ج) تغيير النموذج / Change Model:
+- إذا فشل `gemini-2.5-flash`، جرب `gemini-1.5-flash`
+
+### 5. مشاكل الواجهة / UI Issues
+
+#### أ) الواجهة لا تحمّل / Interface Won't Load:
+```bash
+# تحقق من المنفذ / Check port
+python -c "import socket; s=socket.socket(); s.bind(('',8501)); print('Port 8501 available')"
+
+# تشغيل على منفذ مختلف / Run on different port
+streamlit run app.py --server.port 8502
+```
+
+#### ب) مشاكل اللغة العربية / Arabic Language Issues:
+- تأكد من دعم المتصفح للـ RTL
+- استخدم Chrome أو Firefox للأفضل
+
+### 6. مشاكل الأداء / Performance Issues
+
+#### أ) بطء في المعالجة / Slow Processing:
+- تحقق من سرعة الإنترنت
+- قلل حجم الملف الصوتي
+- استخدم جودة أقل للتسجيل
+
+#### ب) استهلاك ذاكرة عالي / High Memory Usage:
+```bash
+# إعادة تشغيل النظام / Restart system
+python start_debug.py
+```
+
+## 🔧 أدوات التشخيص / Diagnostic Tools
+
+### 1. اختبار شامل / Complete Test:
+```bash
+python test_system.py
+```
+
+### 2. فحص المنافذ / Port Check:
+```python
+python -c "
+import socket
+ports = [5001, 8501, 8502]
+for port in ports:
+    try:
+        s = socket.socket()
+        s.bind(('localhost', port))
+        s.close()
+        print(f'Port {port}: Available ✅')
+    except:
+        print(f'Port {port}: Busy ❌')
+"
+```
+
+### 3. فحص التبعيات / Dependencies Check:
+```bash
+pip list | grep -E "(streamlit|flask|librosa|soundfile|google-generativeai)"
+```
+
+### 4. فحص العمليات / Process Check:
+```bash
+# Windows
+tasklist | findstr python
+
+# Linux/Mac
+ps aux | grep python
+```
+
+## 📱 نصائح لحل المشاكل / Troubleshooting Tips
+
+### للطلاب الجدد / For New Users:
+1. **ابدأ بالاختبار الشامل / Start with system test**:
+   ```bash
+   python test_system.py
+   ```
+
+2. **استخدم البدء المتقدم / Use debug startup**:
+   ```bash
+   python start_debug.py
+   ```
+
+3. **تحقق من المتطلبات / Check requirements**:
+   - Python 3.8+
+   - مفتاح Gemini API صالح
+   - اتصال إنترنت مستقر
+
+### للطلاب المتقدمين / For Advanced Users:
+1. **مراجعة السجلات / Check logs**:
+   - افتح console المتصفح (F12)
+   - راجع سجلات الطرفية
+
+2. **تخصيص الإعدادات / Customize settings**:
+   - غير المنافذ في حالة التضارب
+   - عدّل إعدادات الصوت
+
+3. **التشخيص المتقدم / Advanced diagnostics**:
+   ```python
+   # اختبار الاتصال / Test connection
+   import requests
+   response = requests.get('http://localhost:5001/record')
+   print(response.status_code, response.text)
+   ```
+
+## 🆘 طلب المساعدة / Getting Help
+
+### معلومات مطلوبة / Required Information:
+1. نظام التشغيل / Operating System
+2. إصدار Python / Python Version
+3. نتائج `python test_system.py`
+4. رسائل الخطأ الكاملة / Complete error messages
+5. سجلات الطرفية / Terminal logs
+
+### خطوات الإبلاغ / Reporting Steps:
+1. شغّل الاختبار الشامل
+2. احفظ النتائج
+3. صوّر رسائل الخطأ
+4. اذكر الخطوات التي أدت للمشكلة
+
+---
+
+## 🎯 Quick Fix Commands / أوامر الإصلاح السريع
+
+```bash
+# إعادة تعيين كامل / Complete Reset
+taskkill /f /im python.exe
+python test_system.py
+python start_debug.py
+
+# إصلاح التبعيات / Fix Dependencies  
+pip install --upgrade -r requirements.txt
+
+# إصلاح المنافذ / Fix Ports
+python start_debug.py
+
+# اختبار الترجمة / Test Translation
+python -c "from translator import AITranslator; t=AITranslator(); print(t.translate_text('Hello', 'ar'))"
+```
+
+---
+
+**تذكر: معظم المشاكل تُحل بإعادة تشغيل النظام وتشغيل الاختبار الشامل! 🔄**
+
+**Remember: Most issues are solved by restarting and running the system test! 🔄**
diff --git a/ai_questions.py b/ai_questions.py
new file mode 100644
index 0000000000000000000000000000000000000000..6f1b466ba321163ade2cc72d7ed4c718e385b360
--- /dev/null
+++ b/ai_questions.py
@@ -0,0 +1,773 @@
+# ai_questions.py - AI-Powered Question Engine for SyncMaster
+
+import time
+import hashlib
+from datetime import datetime
+from typing import Dict, List, Optional, Tuple, Any
+from dataclasses import dataclass, field
+import streamlit as st
+
+@dataclass
+class QAPair:
+    """Represents a question-answer pair"""
+    question: str
+    answer: str
+    timestamp: datetime
+    question_type: str  # 'template' or 'custom'
+    response_time_ms: int
+    model_used: str = "Unknown"  # Which AI model was used
+
+@dataclass
+class QuestionSession:
+    """Represents a question session for a specific text segment"""
+    session_id: str
+    selected_text: str
+    segment_id: str
+    start_timestamp: int
+    ui_language: str
+    conversation: List[QAPair] = field(default_factory=list)
+    created_at: datetime = field(default_factory=datetime.now)
+
+@dataclass
+class TextSelection:
+    """Represents selected text from broadcast"""
+    text: str
+    segment_id: str
+    start_ms: int
+    end_ms: int
+    translations: Dict[str, str] = field(default_factory=dict)
+    selection_timestamp: int = field(default_factory=lambda: int(time.time() * 1000))
+
+class AIQuestionEngine:
+    """
+    AI-powered question engine for interactive learning
+    """
+    
+    def __init__(self, translator_instance=None):
+        self.translator = translator_instance
+        self.conversation_history: Dict[str, QuestionSession] = {}
+        self.model_usage_stats = {
+            'Gemini AI': 0,
+            'Groq AI': 0,
+            'OpenRouter AI': 0,
+            'Simple Response': 0
+        }
+        
+        # Question templates in multiple languages
+        self.question_templates = {
+            'ar': [
+                "اشرح هذا النص بالتفصيل",
+                "أعطني أمثلة عملية على هذا",
+                "ما معنى هذا المصطلح؟",
+                "كيف يُستخدم هذا في الواقع؟",
+                "ما أهمية هذا الموضوع؟",
+                "ما هي النقاط الرئيسية هنا؟",
+                "اربط هذا بمفاهيم أخرى",
+                "ما هي التطبيقات العملية؟"
+            ],
+            'en': [
+                "Explain this text in detail",
+                "Give me practical examples of this",
+                "What does this term mean?",
+                "How is this used in practice?",
+                "Why is this topic important?",
+                "What are the key points here?",
+                "Connect this to other concepts",
+                "What are the practical applications?"
+            ],
+            'fr': [
+                "Expliquez ce texte en détail",
+                "Donnez-moi des exemples pratiques",
+                "Que signifie ce terme?",
+                "Comment cela est-il utilisé en pratique?",
+                "Pourquoi ce sujet est-il important?",
+                "Quels sont les points clés ici?",
+                "Reliez cela à d'autres concepts",
+                "Quelles sont les applications pratiques?"
+            ],
+            'es': [
+                "Explica este texto en detalle",
+                "Dame ejemplos prácticos de esto",
+                "¿Qué significa este término?",
+                "¿Cómo se usa esto en la práctica?",
+                "¿Por qué es importante este tema?",
+                "¿Cuáles son los puntos clave aquí?",
+                "Conecta esto con otros conceptos",
+                "¿Cuáles son las aplicaciones prácticas?"
+            ],
+            'de': [
+                "Erkläre diesen Text im Detail",
+                "Gib mir praktische Beispiele dafür",
+                "Was bedeutet dieser Begriff?",
+                "Wie wird das in der Praxis verwendet?",
+                "Warum ist dieses Thema wichtig?",
+                "Was sind die wichtigsten Punkte hier?",
+                "Verbinde das mit anderen Konzepten",
+                "Was sind die praktischen Anwendungen?"
+            ],
+            'zh': [
+                "详细解释这段文字",
+                "给我一些实际例子",
+                "这个术语是什么意思？",
+                "这在实践中如何使用？",
+                "为什么这个话题很重要？",
+                "这里的要点是什么？",
+                "将此与其他概念联系起来",
+                "实际应用有哪些？"
+            ]
+        }
+        
+        # Response formatting templates
+        self.response_templates = {
+            'ar': {
+                'context_intro': "بناءً على النص المحدد:",
+                'explanation_intro': "الشرح:",
+                'examples_intro': "أمثلة:",
+                'importance_intro': "الأهمية:",
+                'applications_intro': "التطبيقات:",
+                'error_message': "عذراً، حدث خطأ في معالجة سؤالك. يرجى المحاولة مرة أخرى."
+            },
+            'en': {
+                'context_intro': "Based on the selected text:",
+                'explanation_intro': "Explanation:",
+                'examples_intro': "Examples:",
+                'importance_intro': "Importance:",
+                'applications_intro': "Applications:",
+                'error_message': "Sorry, there was an error processing your question. Please try again."
+            }
+        }
+    
+    def get_question_templates(self, ui_language: str = 'ar') -> List[str]:
+        """Get pre-defined question templates for the specified language"""
+        return self.question_templates.get(ui_language, self.question_templates['ar'])
+    
+    def create_session_id(self, selected_text: str, segment_id: str) -> str:
+        """Create a unique session ID for a text selection"""
+        content = f"{selected_text}_{segment_id}_{int(time.time())}"
+        return hashlib.md5(content.encode()).hexdigest()[:12]
+    
+    def process_question(self, 
+                        selected_text: str, 
+                        question: str, 
+                        segment_info: Dict[str, Any],
+                        ui_language: str = 'ar',
+                        session_id: Optional[str] = None,
+                        preferred_model: str = 'auto') -> Tuple[Optional[str], Optional[str], str]:
+        """
+        Process a user question about selected text
+        
+        Args:
+            selected_text: The text the user selected
+            question: The user's question
+            segment_info: Information about the broadcast segment
+            ui_language: UI language ('ar' or 'en')
+            session_id: Existing session ID or None for new session
+            
+        Returns:
+            Tuple of (answer, error_message, session_id)
+        """
+        
+        if not self.translator:
+            error_msg = self.response_templates[ui_language]['error_message']
+            return None, error_msg, session_id or ""
+        
+        try:
+            # Create or get session
+            if not session_id:
+                session_id = self.create_session_id(selected_text, segment_info.get('id', ''))
+                session = QuestionSession(
+                    session_id=session_id,
+                    selected_text=selected_text,
+                    segment_id=segment_info.get('id', ''),
+                    start_timestamp=segment_info.get('start_ms', 0),
+                    ui_language=ui_language
+                )
+                self.conversation_history[session_id] = session
+            else:
+                session = self.conversation_history.get(session_id)
+                if not session:
+                    # Session not found, create new one
+                    session = QuestionSession(
+                        session_id=session_id,
+                        selected_text=selected_text,
+                        segment_id=segment_info.get('id', ''),
+                        start_timestamp=segment_info.get('start_ms', 0),
+                        ui_language=ui_language
+                    )
+                    self.conversation_history[session_id] = session
+            
+            # Prepare context for AI
+            context = self._prepare_question_context(selected_text, question, session, ui_language)
+            
+            # Get AI response with preferred model
+            start_time = time.time()
+            ai_response, error, model_used = self.get_ai_response_with_model(context, ui_language, preferred_model)
+            response_time = int((time.time() - start_time) * 1000)
+            
+            if ai_response:
+                # Format response
+                formatted_response = self.format_ai_response(ai_response, ui_language)
+                
+                # Save to conversation history with model info
+                question_type = 'template' if question in self.get_question_templates(ui_language) else 'custom'
+                qa_pair = QAPair(
+                    question=question,
+                    answer=formatted_response,
+                    timestamp=datetime.now(),
+                    question_type=question_type,
+                    response_time_ms=response_time
+                )
+                # Add model info to the QA pair
+                qa_pair.model_used = model_used
+                session.conversation.append(qa_pair)
+                
+                return formatted_response, None, session_id, model_used
+            else:
+                error_msg = error or self.response_templates[ui_language]['error_message']
+                return None, error_msg, session_id, None
+                
+        except Exception as e:
+            error_msg = f"{self.response_templates[ui_language]['error_message']} ({str(e)})"
+            return None, error_msg, session_id or ""
+    
+    def _prepare_question_context(self, 
+                                 selected_text: str, 
+                                 question: str, 
+                                 session: QuestionSession,
+                                 ui_language: str) -> str:
+        """Prepare context for AI question processing"""
+        
+        templates = self.response_templates[ui_language]
+        
+        # Build context with conversation history
+        context_parts = []
+        
+        # Add selected text context
+        context_parts.append(f"{templates['context_intro']}")
+        context_parts.append(f'"{selected_text}"')
+        context_parts.append("")
+        
+        # Add conversation history if exists
+        if session.conversation:
+            context_parts.append("Previous conversation:")
+            for qa in session.conversation[-3:]:  # Last 3 Q&A pairs for context
+                context_parts.append(f"Q: {qa.question}")
+                context_parts.append(f"A: {qa.answer[:200]}...")  # Truncate long answers
+                context_parts.append("")
+        
+        # Add current question
+        context_parts.append(f"Current question: {question}")
+        context_parts.append("")
+        
+        # Add instructions based on language
+        language_instructions = {
+            'ar': """
+أجب على السؤال بناءً على النص المحدد. اجعل إجابتك:
+- واضحة ومفهومة
+- مرتبطة بالنص المحدد
+- تحتوي على أمثلة عملية إذا كان ذلك مناسباً
+- باللغة العربية الفصحى
+- منظمة ومنسقة بشكل جيد
+
+إذا كان السؤال يطلب شرحاً، قدم شرحاً مفصلاً.
+إذا كان يطلب أمثلة، قدم أمثلة واقعية ومفيدة.
+إذا كان يطلب التوضيح، اشرح المفاهيم بطريقة بسيطة.
+""",
+            'en': """
+Answer the question based on the selected text. Make your answer:
+- Clear and understandable
+- Related to the selected text
+- Include practical examples when appropriate
+- In English
+- Well-organized and formatted
+
+If the question asks for explanation, provide detailed explanation.
+If it asks for examples, provide real-world, helpful examples.
+If it asks for clarification, explain concepts in simple terms.
+""",
+            'fr': """
+Répondez à la question basée sur le texte sélectionné. Rendez votre réponse:
+- Claire et compréhensible
+- Liée au texte sélectionné
+- Incluez des exemples pratiques si approprié
+- En français
+- Bien organisée et formatée
+
+Si la question demande une explication, fournissez une explication détaillée.
+Si elle demande des exemples, fournissez des exemples réels et utiles.
+Si elle demande des clarifications, expliquez les concepts en termes simples.
+""",
+            'es': """
+Responde la pregunta basada en el texto seleccionado. Haz que tu respuesta sea:
+- Clara y comprensible
+- Relacionada con el texto seleccionado
+- Incluye ejemplos prácticos cuando sea apropiado
+- En español
+- Bien organizada y formateada
+
+Si la pregunta pide explicación, proporciona explicación detallada.
+Si pide ejemplos, proporciona ejemplos reales y útiles.
+Si pide aclaración, explica conceptos en términos simples.
+""",
+            'de': """
+Beantworte die Frage basierend auf dem ausgewählten Text. Mache deine Antwort:
+- Klar und verständlich
+- Bezogen auf den ausgewählten Text
+- Enthalte praktische Beispiele wenn angemessen
+- Auf Deutsch
+- Gut organisiert und formatiert
+
+Wenn die Frage nach Erklärung fragt, gib detaillierte Erklärung.
+Wenn sie nach Beispielen fragt, gib reale und hilfreiche Beispiele.
+Wenn sie nach Klarstellung fragt, erkläre Konzepte in einfachen Begriffen.
+""",
+            'zh': """
+根据选定的文本回答问题。让你的回答：
+- 清晰易懂
+- 与选定文本相关
+- 适当时包含实际例子
+- 用中文
+- 组织良好且格式化
+
+如果问题要求解释，提供详细解释。
+如果要求例子，提供真实有用的例子。
+如果要求澄清，用简单术语解释概念。
+"""
+        }
+        
+        instructions = language_instructions.get(ui_language, language_instructions['en'])
+        
+        context_parts.append(instructions)
+        
+        return "\n".join(context_parts)
+    
+    def _get_ai_response(self, context: str, ui_language: str) -> Tuple[Optional[str], Optional[str], Optional[str]]:
+        """Get AI response using multiple AI services with fallback
+        
+        Returns:
+            Tuple of (response_text, error_message, model_used)
+        """
+        
+        # Model 1: Try Gemini first
+        try:
+            if hasattr(self.translator, 'model') and self.translator.model:
+                response = self.translator.model.generate_content(context)
+                if response and hasattr(response, 'text') and response.text:
+                    self.model_usage_stats['Gemini AI'] += 1
+                    return response.text.strip(), None, "Gemini AI"
+        except Exception as e:
+            error_msg = str(e)
+            print(f"Gemini AI failed: {error_msg}")  # Debug log
+            # Continue to next model instead of returning error immediately
+        
+        # Model 2: Try Groq
+        try:
+            if hasattr(self.translator, '_groq_complete'):
+                response, error = self.translator._groq_complete(context)
+                if response and response.strip():
+                    self.model_usage_stats['Groq AI'] += 1
+                    return response.strip(), None, "Groq AI"
+                print(f"Groq failed: {error}")  # Debug log
+        except Exception as e:
+            print(f"Groq exception: {str(e)}")  # Debug log
+        
+        # Model 3: Try OpenRouter
+        try:
+            if hasattr(self.translator, '_openrouter_complete'):
+                response, error = self.translator._openrouter_complete(context)
+                if response and response.strip():
+                    self.model_usage_stats['OpenRouter AI'] += 1
+                    return response.strip(), None, "OpenRouter AI"
+                print(f"OpenRouter failed: {error}")  # Debug log
+        except Exception as e:
+            print(f"OpenRouter exception: {str(e)}")  # Debug log
+        
+        # Fallback: Simple rule-based response
+        simple_response, _ = self._generate_simple_response(context, ui_language)
+        self.model_usage_stats['Simple Response'] += 1
+        return simple_response, None, "Simple Response (AI services unavailable)"
+    
+    def _try_fallback_services(self, context: str, ui_language: str) -> Tuple[Optional[str], Optional[str]]:
+        """Try fallback AI services when Gemini is unavailable"""
+        
+        # Try OpenRouter (free models)
+        if hasattr(self.translator, '_openrouter_complete'):
+            try:
+                response, error = self.translator._openrouter_complete(context)
+                if response:
+                    return response.strip(), None
+            except Exception:
+                pass
+        
+        # Try Groq (free tier)
+        if hasattr(self.translator, '_groq_complete'):
+            try:
+                response, error = self.translator._groq_complete(context)
+                if response:
+                    return response.strip(), None
+            except Exception:
+                pass
+        
+        # Fallback to simple rule-based responses
+        return self._generate_simple_response(context, ui_language)
+    
+    def _generate_simple_response(self, context: str, ui_language: str) -> Tuple[Optional[str], Optional[str]]:
+        """Generate simple rule-based response when AI services are unavailable"""
+        
+        # Extract the question from context
+        lines = context.split('\n')
+        question = ""
+        selected_text = ""
+        
+        for line in lines:
+            if line.startswith('Current question:'):
+                question = line.replace('Current question:', '').strip()
+            elif line.startswith('"') and line.endswith('"'):
+                selected_text = line.strip('"')
+        
+        if not question or not selected_text:
+            return None, "Could not process question"
+        
+        # Simple rule-based responses
+        if ui_language == 'ar':
+            responses = self._get_arabic_simple_responses(question, selected_text)
+        else:
+            responses = self._get_english_simple_responses(question, selected_text)
+        
+        return responses
+    
+    def _get_arabic_simple_responses(self, question: str, selected_text: str) -> Tuple[str, None]:
+        """Generate simple Arabic responses based on question patterns"""
+        
+        question_lower = question.lower()
+        
+        if any(word in question_lower for word in ['اشرح', 'شرح', 'وضح']):
+            response = f"""بناءً على النص المحدد:
+"{selected_text}"
+
+هذا النص يتحدث عن موضوع مهم يحتاج إلى فهم عميق. النقاط الرئيسية تشمل المفاهيم والأفكار المطروحة في النص.
+
+للحصول على شرح أكثر تفصيلاً، يُنصح بمراجعة مصادر إضافية أو طرح أسئلة أكثر تحديداً.
+
+ملاحظة: هذه إجابة مبسطة بسبب عدم توفر خدمة الذكاء الاصطناعي حالياً."""
+
+        elif any(word in question_lower for word in ['أمثلة', 'مثال', 'تطبيق']):
+            response = f"""أمثلة على النص المحدد:
+"{selected_text}"
+
+يمكن تطبيق هذا المفهوم في عدة مجالات:
+• في الحياة العملية
+• في الدراسة والتعلم
+• في المشاريع والأعمال
+
+للحصول على أمثلة أكثر تفصيلاً، يُنصح بالبحث في مصادر متخصصة.
+
+ملاحظة: هذه إجابة مبسطة بسبب عدم توفر خدمة الذكاء الاصطناعي حالياً."""
+
+        elif any(word in question_lower for word in ['معنى', 'تعريف', 'ما هو']):
+            response = f"""معنى النص المحدد:
+"{selected_text}"
+
+هذا النص يشير إلى مفهوم أو فكرة معينة تحتاج إلى تفسير. المعنى العام يتعلق بالموضوع المطروح في السياق.
+
+للحصول على تعريف أكثر دقة، يُنصح بمراجعة المصادر المتخصصة.
+
+ملاحظة: هذه إجابة مبسطة بسبب عدم توفر خدمة الذكاء الاصطناعي حالياً."""
+
+        else:
+            response = f"""بخصوص سؤالك حول:
+"{selected_text}"
+
+هذا موضوع مهم يستحق الدراسة والتفكير. النص المحدد يحتوي على معلومات قيمة يمكن الاستفادة منها.
+
+للحصول على إجابة أكثر تفصيلاً، يُنصح بـ:
+• مراجعة مصادر إضافية
+• طرح أسئلة أكثر تحديداً
+• البحث في المراجع المتخصصة
+
+ملاحظة: هذه إجابة مبسطة بسبب عدم توفر خدمة الذكاء الاصطناعي حالياً."""
+
+        return response, None
+    
+    def _get_english_simple_responses(self, question: str, selected_text: str) -> Tuple[str, None]:
+        """Generate simple English responses based on question patterns"""
+        
+        question_lower = question.lower()
+        
+        if any(word in question_lower for word in ['explain', 'clarify', 'describe']):
+            response = f"""Based on the selected text:
+"{selected_text}"
+
+This text discusses an important topic that requires deep understanding. The main points include the concepts and ideas presented in the text.
+
+For a more detailed explanation, it's recommended to consult additional sources or ask more specific questions.
+
+Note: This is a simplified response due to AI service being temporarily unavailable."""
+
+        elif any(word in question_lower for word in ['example', 'application', 'use']):
+            response = f"""Examples related to the selected text:
+"{selected_text}"
+
+This concept can be applied in several areas:
+• In practical life
+• In study and learning
+• In projects and work
+
+For more detailed examples, it's recommended to search specialized sources.
+
+Note: This is a simplified response due to AI service being temporarily unavailable."""
+
+        elif any(word in question_lower for word in ['mean', 'definition', 'what is']):
+            response = f"""Meaning of the selected text:
+"{selected_text}"
+
+This text refers to a specific concept or idea that needs interpretation. The general meaning relates to the topic presented in the context.
+
+For a more precise definition, it's recommended to consult specialized sources.
+
+Note: This is a simplified response due to AI service being temporarily unavailable."""
+
+        else:
+            response = f"""Regarding your question about:
+"{selected_text}"
+
+This is an important topic worth studying and thinking about. The selected text contains valuable information that can be beneficial.
+
+For a more detailed answer, it's recommended to:
+• Consult additional sources
+• Ask more specific questions
+• Search specialized references
+
+Note: This is a simplified response due to AI service being temporarily unavailable."""
+
+        return response, None
+    
+    def format_ai_response(self, response: str, ui_language: str) -> str:
+        """Format AI response for better display"""
+        
+        # Clean up response
+        response = response.strip()
+        
+        # Remove markdown artifacts
+        response = response.replace('**', '')
+        response = response.replace('```', '')
+        response = response.replace('`', '')
+        
+        # Remove extra whitespace
+        lines = [line.strip() for line in response.split('\n')]
+        response = '\n'.join(line for line in lines if line)
+        
+        return response
+    
+    def get_conversation_history(self, session_id: str) -> Optional[QuestionSession]:
+        """Get conversation history for a specific session"""
+        return self.conversation_history.get(session_id)
+    
+    def clear_conversation(self, session_id: str) -> bool:
+        """Clear conversation history for a specific session"""
+        if session_id in self.conversation_history:
+            del self.conversation_history[session_id]
+            return True
+        return False
+    
+    def get_all_sessions(self) -> Dict[str, QuestionSession]:
+        """Get all active question sessions"""
+        return self.conversation_history.copy()
+    
+    def get_model_usage_stats(self) -> Dict[str, int]:
+        """Get usage statistics for different AI models"""
+        return self.model_usage_stats.copy()
+    
+    def check_model_availability(self) -> Dict[str, Dict[str, Any]]:
+        """Check availability status of all AI models"""
+        models_status = {}
+        
+        # Check Gemini
+        try:
+            if hasattr(self.translator, 'model') and self.translator.model:
+                # Try a minimal test
+                test_response = self.translator.model.generate_content("Hi")
+                models_status['Gemini AI'] = {
+                    'status': 'available',
+                    'icon': '✅',
+                    'message': 'متاح' if st.session_state.get('language', 'ar') == 'ar' else 'Available',
+                    'color': 'green'
+                }
+            else:
+                models_status['Gemini AI'] = {
+                    'status': 'unavailable',
+                    'icon': '❌',
+                    'message': 'غير متاح' if st.session_state.get('language', 'ar') == 'ar' else 'Unavailable',
+                    'color': 'red'
+                }
+        except Exception as e:
+            error_str = str(e)
+            if "429" in error_str or "quota" in error_str.lower():
+                models_status['Gemini AI'] = {
+                    'status': 'quota_exceeded',
+                    'icon': '⚠️',
+                    'message': 'انتهت الحصة' if st.session_state.get('language', 'ar') == 'ar' else 'Quota exceeded',
+                    'color': 'orange'
+                }
+            else:
+                models_status['Gemini AI'] = {
+                    'status': 'error',
+                    'icon': '❌',
+                    'message': 'خطأ مؤقت' if st.session_state.get('language', 'ar') == 'ar' else 'Temporary error',
+                    'color': 'red'
+                }
+        
+        # Check Groq
+        try:
+            if hasattr(self.translator, '_groq_complete') and hasattr(self.translator, 'groq_api_key') and self.translator.groq_api_key:
+                models_status['Groq AI'] = {
+                    'status': 'available',
+                    'icon': '✅',
+                    'message': 'متاح' if st.session_state.get('language', 'ar') == 'ar' else 'Available',
+                    'color': 'green'
+                }
+            else:
+                models_status['Groq AI'] = {
+                    'status': 'not_configured',
+                    'icon': '⚙️',
+                    'message': 'غير مُعد' if st.session_state.get('language', 'ar') == 'ar' else 'Not configured',
+                    'color': 'gray'
+                }
+        except Exception:
+            models_status['Groq AI'] = {
+                'status': 'error',
+                'icon': '❌',
+                'message': 'خطأ' if st.session_state.get('language', 'ar') == 'ar' else 'Error',
+                'color': 'red'
+            }
+        
+        # Check OpenRouter
+        try:
+            if hasattr(self.translator, '_openrouter_complete') and hasattr(self.translator, 'openrouter_api_key') and self.translator.openrouter_api_key:
+                models_status['OpenRouter AI'] = {
+                    'status': 'available',
+                    'icon': '✅',
+                    'message': 'متاح' if st.session_state.get('language', 'ar') == 'ar' else 'Available',
+                    'color': 'green'
+                }
+            else:
+                models_status['OpenRouter AI'] = {
+                    'status': 'not_configured',
+                    'icon': '⚙️',
+                    'message': 'غير مُعد' if st.session_state.get('language', 'ar') == 'ar' else 'Not configured',
+                    'color': 'gray'
+                }
+        except Exception:
+            models_status['OpenRouter AI'] = {
+                'status': 'error',
+                'icon': '❌',
+                'message': 'خطأ' if st.session_state.get('language', 'ar') == 'ar' else 'Error',
+                'color': 'red'
+            }
+        
+        # Simple Response is always available
+        models_status['Simple Response'] = {
+            'status': 'available',
+            'icon': '🛡️',
+            'message': 'متاح دائماً' if st.session_state.get('language', 'ar') == 'ar' else 'Always available',
+            'color': 'blue'
+        }
+        
+        return models_status
+    
+    def get_ai_response_with_model(self, context: str, ui_language: str, preferred_model: str = 'auto') -> Tuple[Optional[str], Optional[str], Optional[str]]:
+        """Get AI response using a specific model or auto-selection"""
+        
+        if preferred_model == 'auto':
+            return self._get_ai_response(context, ui_language)
+        
+        # Try specific model first
+        if preferred_model == 'Gemini AI':
+            try:
+                if hasattr(self.translator, 'model') and self.translator.model:
+                    response = self.translator.model.generate_content(context)
+                    if response and hasattr(response, 'text') and response.text:
+                        self.model_usage_stats['Gemini AI'] += 1
+                        return response.text.strip(), None, "Gemini AI"
+            except Exception as e:
+                return None, f"Gemini AI error: {str(e)}", None
+        
+        elif preferred_model == 'Groq AI':
+            try:
+                if hasattr(self.translator, '_groq_complete'):
+                    response, error = self.translator._groq_complete(context)
+                    if response and response.strip():
+                        self.model_usage_stats['Groq AI'] += 1
+                        return response.strip(), None, "Groq AI"
+                    else:
+                        return None, f"Groq AI error: {error}", None
+            except Exception as e:
+                return None, f"Groq AI error: {str(e)}", None
+        
+        elif preferred_model == 'OpenRouter AI':
+            try:
+                if hasattr(self.translator, '_openrouter_complete'):
+                    response, error = self.translator._openrouter_complete(context)
+                    if response and response.strip():
+                        self.model_usage_stats['OpenRouter AI'] += 1
+                        return response.strip(), None, "OpenRouter AI"
+                    else:
+                        return None, f"OpenRouter AI error: {error}", None
+            except Exception as e:
+                return None, f"OpenRouter AI error: {str(e)}", None
+        
+        elif preferred_model == 'Simple Response':
+            simple_response, _ = self._generate_simple_response(context, ui_language)
+            self.model_usage_stats['Simple Response'] += 1
+            return simple_response, None, "Simple Response"
+        
+        # If preferred model fails, fall back to auto-selection
+        return self._get_ai_response(context, ui_language)
+    
+    def format_conversation_for_export(self, session_id: str, ui_language: str = 'ar') -> Optional[str]:
+        """Format conversation for export/copying"""
+        
+        session = self.conversation_history.get(session_id)
+        if not session:
+            return None
+        
+        export_lines = []
+        
+        # Header
+        if ui_language == 'ar':
+            export_lines.append("محادثة الذكاء الاصطناعي")
+            export_lines.append(f"النص المحدد: {session.selected_text}")
+            export_lines.append(f"التاريخ: {session.created_at.strftime('%Y-%m-%d %H:%M:%S')}")
+        else:
+            export_lines.append("AI Conversation")
+            export_lines.append(f"Selected Text: {session.selected_text}")
+            export_lines.append(f"Date: {session.created_at.strftime('%Y-%m-%d %H:%M:%S')}")
+        
+        export_lines.append("=" * 50)
+        export_lines.append("")
+        
+        # Q&A pairs
+        for i, qa in enumerate(session.conversation, 1):
+            if ui_language == 'ar':
+                export_lines.append(f"السؤال {i}: {qa.question}")
+                export_lines.append(f"الإجابة {i}: {qa.answer}")
+            else:
+                export_lines.append(f"Question {i}: {qa.question}")
+                export_lines.append(f"Answer {i}: {qa.answer}")
+            
+            export_lines.append("-" * 30)
+            export_lines.append("")
+        
+        return "\n".join(export_lines)
+
+# Global instance
+ai_question_engine = None
+
+def get_ai_question_engine():
+    """Get or create AI question engine instance"""
+    global ai_question_engine
+    if ai_question_engine is None:
+        from translator import get_translator
+        translator = get_translator()
+        ai_question_engine = AIQuestionEngine(translator)
+    return ai_question_engine
\ No newline at end of file
diff --git a/app.py b/app.py
new file mode 100644
index 0000000000000000000000000000000000000000..19b75490a8726f9a5205750c8e440e2354d0772f
--- /dev/null
+++ b/app.py
@@ -0,0 +1,1812 @@
+# app.py - Refactored to eliminate recorder_server.py dependency
+
+import streamlit as st
+import os
+import tempfile
+import json
+from pathlib import Path
+import time
+import traceback
+import streamlit.components.v1 as components
+import hashlib
+from datetime import datetime
+# from st_audiorec import st_audiorec  # Import the new recorder component - OLD
+# Reduce metrics/usage writes that can cause permission errors on hosted environments
+try:
+    st.set_option('browser.gatherUsageStats', False)
+except Exception:
+    pass
+
+# Robust component declaration: prefer local build, else fall back to pip package
+parent_dir = os.path.dirname(os.path.abspath(__file__))
+build_dir = os.path.join(parent_dir, "custom_components/st-audiorec/st_audiorec/frontend/build")
+
+def st_audiorec(key=None):
+    """Return audio recorder component value, trying local build first, then pip package fallback."""
+    try:
+        if os.path.isdir(build_dir):
+            _component_func = components.declare_component("st_audiorec", path=build_dir)
+            return _component_func(key=key, default=0)
+        # Fallback to pip-installed component if available
+        try:
+            from st_audiorec import st_audiorec as st_audiorec_pkg
+            return st_audiorec_pkg(key=key)
+        except Exception:
+            st.warning("Audio recorder component is unavailable on this deployment (missing local build and pip fallback).")
+            return None
+    except Exception:
+        # Final safety net
+        st.warning("Failed to initialize audio recorder component.")
+        return None
+
+# --- Critical Imports and Initial Checks ---
+AUDIO_PROCESSOR_CLASS = None
+IMPORT_ERROR_TRACEBACK = None
+try:
+    from audio_processor import AudioProcessor
+    AUDIO_PROCESSOR_CLASS = AudioProcessor
+except Exception:
+    IMPORT_ERROR_TRACEBACK = traceback.format_exc()
+
+from video_generator import VideoGenerator
+from mp3_embedder import MP3Embedder
+from utils import format_timestamp
+from translator import get_translator, UI_TRANSLATIONS
+from exporter import BroadcastExporter, ExportConfig
+from google_docs_config import google_docs_manager
+from ai_questions import get_ai_question_engine, TextSelection
+from style_fixes import apply_custom_styling, create_broadcast_bubble, create_white_container, create_processing_result_container
+import requests
+from dotenv import load_dotenv
+
+# --- API Key Check ---
+def check_api_key():
+    """Check for Gemini API key and display instructions if not found."""
+    load_dotenv()
+    if not os.getenv("GEMINI_API_KEY"):
+        st.error("🔴 FATAL ERROR: GEMINI_API_KEY is not set!")
+        st.info("To fix this, please follow these steps:")
+        st.markdown("""
+            1.  **Find the file named `.env.example`** in the `syncmaster2` directory.
+            2.  **Rename it to `.env`**.
+            3.  **Open the `.env` file** with a text editor.
+            4.  **Get your free API key** from [Google AI Studio](https://aistudio.google.com/app/apikey).
+            5.  **Paste your key** into the file, replacing `"PASTE_YOUR_GEMINI_API_KEY_HERE"`.
+            6.  **Save the file and restart the application.**
+        """)
+        return False
+    return True
+
+# --- Summary Helper (robust to cached translator without summarize_text) ---
+def generate_summary(text: str, target_language: str = 'ar'):
+    """Generate a concise summary in target_language, with graceful fallback.
+
+    If summarize_text is unavailable (cached instance), fall back to Arabic summary
+    then translate to the target language if needed.
+    """
+    tr = get_translator()
+    try:
+        if hasattr(tr, 'summarize_text') and callable(getattr(tr, 'summarize_text')):
+            s, err = tr.summarize_text(text or '', target_language=target_language)
+            if s:
+                return s, None
+        # Fallback path: Arabic summary first
+        s_ar, err_ar = tr.summarize_text_arabic(text or '')
+        if target_language and target_language != 'ar' and s_ar:
+            tx, err_tx = tr.translate_text(s_ar, target_language=target_language)
+            if tx:
+                return tx, None
+            return s_ar, err_tx
+        return s_ar, err_ar
+    except Exception as e:
+        return None, str(e)
+
+# --- Page Configuration ---
+st.set_page_config(
+    page_title="SyncMaster - AI Audio-Text Synchronization",
+    page_icon="🎵",
+    layout="wide"
+)
+
+# --- Browser Console Logging Utility ---
+def log_to_browser_console(messages):
+    """Injects JavaScript to log messages to the browser's console."""
+    if isinstance(messages, str):
+        messages = [messages]
+    escaped_messages = [json.dumps(str(msg)) for msg in messages]
+    js_code = f"""
+    <script>
+    (function() {{
+        const logs = [{', '.join(escaped_messages)}];
+        console.group("Backend Logs from SyncMaster");
+        logs.forEach(log => {{
+            const content = String(log);
+            if (content.includes('--- ERROR') || content.includes('--- FATAL')) {{
+                console.error(log);
+            }} else if (content.includes('--- WARNING')) {{
+                console.warn(log);
+            }} else if (content.includes('--- DEBUG')) {{
+                console.debug(log);
+            }} else {{
+                console.log(log);
+            }}
+        }});
+        console.groupEnd();
+    }})();
+    </script>
+    """
+    components.html(js_code, height=0, scrolling=False)
+
+# --- AI Models Reset Function ---
+def reset_ai_models():
+    """Reset all AI models and clear cache completely"""
+    
+    # Clear ALL session state keys that might contain cached AI instances
+    keys_to_clear = []
+    for key in list(st.session_state.keys()):
+        if any(term in key.lower() for term in ['translator', 'ai', 'question', 'model', 'engine', 'processing']):
+            keys_to_clear.append(key)
+    
+    for key in keys_to_clear:
+        del st.session_state[key]
+    
+    # Force reload environment variables
+    load_dotenv(override=True)
+    
+    # Clear Python module cache completely
+    import sys
+    import importlib
+    
+    modules_to_reload = ['translator', 'ai_questions', 'exporter']
+    for module_name in modules_to_reload:
+        if module_name in sys.modules:
+            try:
+                # Delete from sys.modules first
+                del sys.modules[module_name]
+            except:
+                pass
+    
+    # Clear any global instances
+    try:
+        import translator
+        if hasattr(translator, 'translator_instance'):
+            translator.translator_instance = None
+    except:
+        pass
+    
+    try:
+        import ai_questions
+        if hasattr(ai_questions, 'ai_question_engine'):
+            ai_questions.ai_question_engine = None
+    except:
+        pass
+
+# --- Session State Initialization ---
+def initialize_session_state():
+    """Initializes the session state variables if they don't exist."""
+    if 'step' not in st.session_state:
+        st.session_state.step = 1
+    if 'audio_data' not in st.session_state:
+        st.session_state.audio_data = None
+    if 'language' not in st.session_state:
+        st.session_state.language = 'en'
+    if 'enable_translation' not in st.session_state:
+        st.session_state.enable_translation = True
+    if 'target_language' not in st.session_state:
+        st.session_state.target_language = 'ar'
+    if 'transcription_data' not in st.session_state:
+        st.session_state.transcription_data = None
+    if 'edited_text' not in st.session_state:
+        st.session_state.edited_text = ""
+    if 'video_style' not in st.session_state:
+        st.session_state.video_style = {
+            'animation_style': 'Karaoke Style', 'text_color': '#FFFFFF',
+            'highlight_color': '#FFD700', 'background_color': '#000000',
+            'font_family': 'Arial', 'font_size': 48
+        }
+    if 'new_recording' not in st.session_state:
+        st.session_state.new_recording = None
+    # Transcript feed (prepend latest) and dedupe set
+    if 'transcript_feed' not in st.session_state:
+        st.session_state.transcript_feed = []  # list of {id, ts, text}
+    if 'transcript_ids' not in st.session_state:
+        st.session_state.transcript_ids = set()
+    # Incremental broadcast state
+    if 'broadcast_segments' not in st.session_state:
+        st.session_state.broadcast_segments = []  # [{id, recording_id, start_ms, end_ms, checksum, text}]
+    if 'lastFetchedEnd_ms' not in st.session_state:
+        st.session_state.lastFetchedEnd_ms = 0
+    # Broadcast translation language (separate from general UI translation target)
+    if 'broadcast_translation_lang' not in st.session_state:
+        # Default broadcast translation target to Arabic
+        st.session_state.broadcast_translation_lang = 'ar'
+    if 'summary_language' not in st.session_state:
+        # Default summary language to Arabic
+        st.session_state.summary_language = 'ar'
+    # Auto-generate Arabic summary toggle
+    if 'auto_generate_summary' not in st.session_state:
+        st.session_state.auto_generate_summary = True
+    # Export functionality state
+    if 'export_timestamp' not in st.session_state:
+        st.session_state.export_timestamp = None
+    if 'show_export_modal' not in st.session_state:
+        st.session_state.show_export_modal = False
+    if 'export_format' not in st.session_state:
+        st.session_state.export_format = 'word'
+    # AI Questions functionality state
+    if 'selected_text' not in st.session_state:
+        st.session_state.selected_text = None
+    if 'selected_segment_id' not in st.session_state:
+        st.session_state.selected_segment_id = None
+    if 'show_question_modal' not in st.session_state:
+        st.session_state.show_question_modal = False
+    if 'current_question_session' not in st.session_state:
+        st.session_state.current_question_session = None
+    if 'preferred_ai_model' not in st.session_state:
+        st.session_state.preferred_ai_model = 'auto'
+    if 'preferred_answer_language' not in st.session_state:
+        st.session_state.preferred_answer_language = 'auto'
+    # Background processing state
+    if 'processing_queue' not in st.session_state:
+        st.session_state.processing_queue = []
+    if 'processing_results' not in st.session_state:
+        st.session_state.processing_results = {}
+    if 'processing_status' not in st.session_state:
+        st.session_state.processing_status = {}
+
+# --- Background Audio Processing Function ---
+def queue_audio_processing(audio_bytes, original_filename="recorded_audio.wav"):
+    """Queue audio for background processing"""
+    import uuid
+    
+    # Generate unique ID for this processing task
+    task_id = str(uuid.uuid4())[:8]
+    
+    # Add to processing queue
+    task = {
+        'id': task_id,
+        'audio_bytes': audio_bytes,
+        'filename': original_filename,
+        'timestamp': time.time(),
+        'status': 'queued'
+    }
+    
+    st.session_state.processing_queue.append(task)
+    st.session_state.processing_status[task_id] = 'queued'
+    
+    # Show immediate feedback
+    st.info(f"🔄 {'تم إضافة التسجيل للمعالجة' if st.session_state.language == 'ar' else 'Audio queued for processing'} (ID: {task_id})")
+    
+    return task_id
+
+def process_queued_audio():
+    """Process queued audio in background"""
+    if not st.session_state.processing_queue:
+        return
+    
+    # Process first item in queue
+    task = st.session_state.processing_queue[0]
+    task_id = task['id']
+    
+    # Update status
+    st.session_state.processing_status[task_id] = 'processing'
+    task['status'] = 'processing'
+    
+    # Show processing status
+    with st.status(f"🔄 {'معالجة التسجيل' if st.session_state.language == 'ar' else 'Processing audio'} {task_id}...", expanded=False):
+        try:
+            # Process the audio
+            result = run_audio_processing_sync(task['audio_bytes'], task['filename'])
+            
+            if result:
+                # Store result
+                st.session_state.processing_results[task_id] = result
+                st.session_state.processing_status[task_id] = 'completed'
+                task['status'] = 'completed'
+                
+                st.success(f"✅ {'تم الانتهاء من المعالجة' if st.session_state.language == 'ar' else 'Processing completed'} {task_id}")
+            else:
+                st.session_state.processing_status[task_id] = 'failed'
+                task['status'] = 'failed'
+                st.error(f"❌ {'فشلت المعالجة' if st.session_state.language == 'ar' else 'Processing failed'} {task_id}")
+        
+        except Exception as e:
+            st.session_state.processing_status[task_id] = 'failed'
+            task['status'] = 'failed'
+            st.error(f"❌ {'خطأ في المعالجة' if st.session_state.language == 'ar' else 'Processing error'} {task_id}: {str(e)}")
+    
+    # Remove from queue
+    st.session_state.processing_queue.pop(0)
+
+# --- Centralized Audio Processing Function ---
+def run_audio_processing(audio_bytes, original_filename="recorded_audio.wav"):
+    """Main audio processing function with background support"""
+    
+    # Check if background processing is enabled
+    if st.session_state.get('background_processing', True):
+        return queue_audio_processing(audio_bytes, original_filename)
+    else:
+        return run_audio_processing_sync(audio_bytes, original_filename)
+
+def run_audio_processing_sync(audio_bytes, original_filename="recorded_audio.wav"):
+    """
+    A single, robust function to handle all audio processing.
+    Takes audio bytes as input and returns the processed data.
+    """
+    # This function is the classic, non-Custom path; ensure editor sections are enabled
+    st.session_state['_custom_active'] = False
+    if not audio_bytes:
+        st.error("No audio data provided to process.")
+        return
+
+    tmp_file_path = None
+    log_to_browser_console("--- INFO: Starting unified audio processing. ---")
+    
+    try:
+        with tempfile.NamedTemporaryFile(delete=False, suffix=Path(original_filename).suffix) as tmp_file:
+            tmp_file.write(audio_bytes)
+            tmp_file_path = tmp_file.name
+        
+        processor = AUDIO_PROCESSOR_CLASS()
+        result_data = None
+        full_text = ""
+        word_timestamps = []
+
+        # Determine which processing path to take
+        if st.session_state.enable_translation:
+            with st.spinner("⏳ Performing AI Transcription & Translation... please wait."):
+                result_data, processor_logs = processor.get_word_timestamps_with_translation(
+                    tmp_file_path,
+                    st.session_state.target_language,
+                )
+
+            log_to_browser_console(processor_logs)
+
+            if not result_data or not result_data.get("original_text"):
+                st.warning(
+                    "Could not generate transcription with translation. Check browser console (F12) for logs."
+                )
+                return
+
+            st.session_state.transcription_data = {
+                "text": result_data["original_text"],
+                "translated_text": result_data["translated_text"],
+                "word_timestamps": result_data["word_timestamps"],
+                "audio_bytes": audio_bytes,
+                "original_suffix": Path(original_filename).suffix,
+                "translation_success": result_data.get("translation_success", False),
+                "detected_language": result_data.get("language_detected", "unknown"),
+            }
+            # Update transcript feed (prepend, dedupe by digest)
+            try:
+                digest = hashlib.md5(audio_bytes).hexdigest()
+            except Exception:
+                digest = f"snap-{int(time.time()*1000)}"
+            if digest not in st.session_state.transcript_ids:
+                st.session_state.transcript_ids.add(digest)
+                st.session_state.transcript_feed.insert(
+                    0,
+                    {
+                        "id": digest,
+                        "ts": int(time.time() * 1000),
+                        "text": result_data["original_text"],
+                    },
+                )
+            # Rebuild edited_text with newest first
+            st.session_state.edited_text = "\n\n".join(
+                [s["text"] for s in st.session_state.transcript_feed]
+            )
+
+        else:  # Standard processing without translation
+            with st.spinner("⏳ Performing AI Transcription... please wait."):
+                word_timestamps, processor_logs = processor.get_word_timestamps(
+                    tmp_file_path
+                )
+
+            log_to_browser_console(processor_logs)
+
+            if not word_timestamps:
+                st.warning(
+                    "Could not generate timestamps. Check browser console (F12) for logs."
+                )
+                return
+
+            full_text = " ".join([d["word"] for d in word_timestamps])
+            st.session_state.transcription_data = {
+                "text": full_text,
+                "word_timestamps": word_timestamps,
+                "audio_bytes": audio_bytes,
+                "original_suffix": Path(original_filename).suffix,
+                "translation_success": False,
+            }
+            # Update transcript feed (prepend, dedupe by digest)
+            try:
+                digest = hashlib.md5(audio_bytes).hexdigest()
+            except Exception:
+                digest = f"snap-{int(time.time()*1000)}"
+            if digest not in st.session_state.transcript_ids:
+                st.session_state.transcript_ids.add(digest)
+                st.session_state.transcript_feed.insert(
+                    0, {"id": digest, "ts": int(time.time() * 1000), "text": full_text}
+                )
+            # Rebuild edited_text with newest first
+            st.session_state.edited_text = "\n\n".join(
+                [s["text"] for s in st.session_state.transcript_feed]
+            )
+
+        st.session_state.step = 1  # Keep it on the same step
+        
+        # Return result for background processing
+        return {
+            'original_text': result_data.get("original_text") if result_data else full_text,
+            'translated_text': result_data.get("translated_text") if result_data else None,
+            'detected_language': result_data.get("language_detected") if result_data else "unknown",
+            'translation_success': result_data.get("translation_success", False) if result_data else False,
+            'word_timestamps': result_data.get("word_timestamps") if result_data else word_timestamps
+        }
+    
+    except Exception as e:
+        st.error("An unexpected error occurred during audio processing!")
+        st.exception(e)
+        log_to_browser_console(f"--- FATAL ERROR in run_audio_processing: {traceback.format_exc()} ---")
+        return None
+    finally:
+        if tmp_file_path and os.path.exists(tmp_file_path):
+            os.unlink(tmp_file_path)
+
+
+# --- Main Application Logic ---
+def main():
+    # Apply custom styling first
+    apply_custom_styling()
+    
+    # Force reload environment variables
+    load_dotenv(override=True)
+    
+    # Clear AI models cache on first run or if there's an issue
+    if 'app_initialized' not in st.session_state:
+        reset_ai_models()
+        st.session_state.app_initialized = True
+    
+    initialize_session_state()
+    
+    st.markdown("""
+    <style>
+    .main .block-container { animation: fadeIn 0.2s ease-in-out; }
+    @keyframes fadeIn { from { opacity: 0; } to { opacity: 1; } }
+    .block-container { padding-top: 1rem; }
+    </style>
+    """, unsafe_allow_html=True)
+    
+    with st.sidebar:
+        st.markdown("## 🌐 Language Settings")
+        language_options = {'English': 'en', 'العربية': 'ar'}
+        selected_lang_display = st.selectbox(
+            "Interface Language",
+            options=list(language_options.keys()),
+            index=0 if st.session_state.language == 'en' else 1
+        )
+        st.session_state.language = language_options[selected_lang_display]
+        
+        st.markdown("## 🔤 Translation Settings")
+        st.session_state.enable_translation = st.checkbox(
+            "Enable AI Translation" if st.session_state.language == 'en' else "تفعيل الترجمة بالذكاء الاصطناعي",
+            value=st.session_state.enable_translation,
+            help="Automatically translate transcribed text" if st.session_state.language == 'en' else "ترجمة النص تلقائياً"
+        )
+        
+        if st.session_state.enable_translation:
+            target_lang_options = {
+                'Arabic (العربية)': 'ar', 'English': 'en', 'French (Français)': 'fr', 'Spanish (Español)': 'es'
+            }
+            selected_target = st.selectbox(
+                "Target Language" if st.session_state.language == 'en' else "اللغة المستهدفة",
+                options=list(target_lang_options.keys()), index=0
+            )
+            st.session_state.target_language = target_lang_options[selected_target]
+        # Auto summary toggle
+        st.session_state.auto_generate_summary = st.checkbox(
+            "Auto-generate Arabic summary" if st.session_state.language == 'en' else "توليد الملخص العربي تلقائياً",
+            value=st.session_state.auto_generate_summary
+        )
+        
+        # Google Account Status
+        st.markdown("## 🔐 Google Account")
+        if google_docs_manager.is_authenticated():
+            st.success("✅ متصل" if st.session_state.language == 'ar' else "✅ Connected")
+        else:
+            st.info("🔒 غير متصل" if st.session_state.language == 'ar' else "🔒 Not connected")
+        
+        # AI Questions Status
+        st.markdown("## 🤖 AI Questions")
+        
+        # Show preferred model
+        if st.session_state.preferred_ai_model != 'auto':
+            st.info(f"🎯 {'النموذج المفضل' if st.session_state.language == 'ar' else 'Preferred Model'}: {st.session_state.preferred_ai_model}")
+        else:
+            st.info("🔄 " + ("تلقائي" if st.session_state.language == 'ar' else "Auto selection"))
+        
+        # Model reset button
+        if st.button("🔄 " + ("إعادة تعيين النماذج" if st.session_state.language == 'ar' else "Reset AI Models"), help="إعادة تحميل نماذج الذكاء الاصطناعي" if st.session_state.language == 'ar' else "Reload AI models"):
+            reset_ai_models()
+            st.success("✅ " + ("تم إعادة تعيين النماذج" if st.session_state.language == 'ar' else "AI models reset successfully"))
+            st.rerun()
+        
+        # Show preferred answer language
+        answer_lang = st.session_state.get('preferred_answer_language', 'auto')
+        if answer_lang != 'auto':
+            lang_names = {'ar': '🇸🇦 العربية', 'en': '🇺🇸 English', 'fr': '🇫🇷 Français', 'es': '🇪🇸 Español', 'de': '🇩🇪 Deutsch', 'zh': '🇨🇳 中文'}
+            lang_display = lang_names.get(answer_lang, answer_lang)
+            st.info(f"🌐 {'لغة الإجابة' if st.session_state.language == 'ar' else 'Answer Language'}: {lang_display}")
+        else:
+            current_ui_lang = "🇸🇦 العربية" if st.session_state.language == 'ar' else "🇺🇸 English"
+            st.info(f"🌐 {'لغة الإجابة' if st.session_state.language == 'ar' else 'Answer Language'}: {current_ui_lang} ({'تلقائي' if st.session_state.language == 'ar' else 'Auto'})")
+        
+        # Test AI services availability
+        translator = get_translator()
+        services_status = {}
+        
+        # Test Gemini
+        try:
+            if hasattr(translator, 'model') and translator.model:
+                test_response = translator.model.generate_content("Test")
+                services_status['Gemini'] = "✅"
+            else:
+                services_status['Gemini'] = "❌"
+        except Exception as e:
+            error_str = str(e)
+            if "429" in error_str or "quota" in error_str.lower():
+                services_status['Gemini'] = "⚠️"
+            else:
+                services_status['Gemini'] = "❌"
+        
+        # Test Groq
+        try:
+            if hasattr(translator, '_groq_complete') and translator.groq_api_key:
+                services_status['Groq'] = "✅"
+            else:
+                services_status['Groq'] = "❌"
+        except Exception:
+            services_status['Groq'] = "❌"
+        
+        # Test OpenRouter
+        try:
+            if hasattr(translator, '_openrouter_complete') and translator.openrouter_api_key:
+                services_status['OpenRouter'] = "✅"
+            else:
+                services_status['OpenRouter'] = "❌"
+        except Exception:
+            services_status['OpenRouter'] = "❌"
+        
+        # Display services status
+        st.markdown("**" + ("حالة النماذج" if st.session_state.language == 'ar' else "Models Status") + ":**")
+        for service, status in services_status.items():
+            if status == "✅":
+                st.success(f"{status} {service}")
+            elif status == "⚠️":
+                st.warning(f"{status} {service} (حد يومي)" if st.session_state.language == 'ar' else f"{status} {service} (quota)")
+            else:
+                st.error(f"{status} {service}")
+        
+        # Overall status
+        available_count = sum(1 for status in services_status.values() if status == "✅")
+        if available_count > 0:
+            st.info(f"🤖 {available_count}/3 " + ("نماذج متاحة" if st.session_state.language == 'ar' else "models available"))
+        else:
+            st.warning("⚠️ جميع النماذج غير متاحة" if st.session_state.language == 'ar' else "⚠️ All models unavailable")
+        
+        # Show conversation status and usage stats
+        question_engine = get_ai_question_engine()
+        usage_stats = question_engine.get_model_usage_stats()
+        total_questions = sum(usage_stats.values())
+        
+        if st.session_state.current_question_session:
+            session = question_engine.get_conversation_history(st.session_state.current_question_session)
+            if session and session.conversation:
+                st.info(f"💬 {len(session.conversation)} " + ("أسئلة نشطة" if st.session_state.language == 'ar' else "active questions"))
+            else:
+                st.info("🤖 جاهز للأسئلة" if st.session_state.language == 'ar' else "🤖 Ready for questions")
+        else:
+            st.info("🤖 جاهز للأسئلة" if st.session_state.language == 'ar' else "🤖 Ready for questions")
+        
+        # Show usage statistics
+        if total_questions > 0:
+            with st.expander("📊 إحصائيات الاستخدام" if st.session_state.language == 'ar' else "📊 Usage Statistics"):
+                st.write(f"**{'إجمالي الأسئلة' if st.session_state.language == 'ar' else 'Total Questions'}: {total_questions}**")
+                for model, count in usage_stats.items():
+                    if count > 0:
+                        percentage = (count / total_questions) * 100
+                        st.write(f"• {model}: {count} ({percentage:.1f}%)")
+        else:
+            st.caption("📊 لا توجد إحصائيات بعد" if st.session_state.language == 'ar' else "📊 No statistics yet")
+        
+        # Quick model switcher
+        st.markdown("**" + ("تبديل سريع للنموذج" if st.session_state.language == 'ar' else "Quick Model Switch") + "**")
+        
+        question_engine = get_ai_question_engine()
+        models_status = question_engine.check_model_availability()
+        
+        # Create buttons for each available model
+        cols = st.columns(2)
+        model_names = ['auto', 'Gemini AI', 'Groq AI', 'OpenRouter AI']
+        
+        for i, model in enumerate(model_names):
+            with cols[i % 2]:
+                if model == 'auto':
+                    button_text = "🔄 تلقائي" if st.session_state.language == 'ar' else "🔄 Auto"
+                    is_current = st.session_state.preferred_ai_model == 'auto'
+                else:
+                    status_info = models_status.get(model, {})
+                    icon = status_info.get('icon', '❓')
+                    button_text = f"{icon} {model.split()[0]}"  # Show first word + icon
+                    is_current = st.session_state.preferred_ai_model == model
+                
+                button_type = "primary" if is_current else "secondary"
+                
+                if st.button(button_text, key=f"switch_{model}", type=button_type, use_container_width=True):
+                    st.session_state.preferred_ai_model = model
+                    st.rerun()
+        
+        # Quick language switcher
+        st.markdown("**" + ("تبديل سريع للغة" if st.session_state.language == 'ar' else "Quick Language Switch") + "**")
+        
+        language_buttons = {
+            'auto': "🔄 تلقائي" if st.session_state.language == 'ar' else "🔄 Auto",
+            'ar': "🇸🇦 عربي",
+            'en': "🇺🇸 EN",
+            'fr': "🇫🇷 FR",
+            'es': "🇪🇸 ES"
+        }
+        
+        cols_lang = st.columns(3)
+        for i, (lang_code, button_text) in enumerate(language_buttons.items()):
+            with cols_lang[i % 3]:
+                is_current_lang = st.session_state.get('preferred_answer_language', 'auto') == lang_code
+                button_type_lang = "primary" if is_current_lang else "secondary"
+                
+                if st.button(button_text, key=f"switch_lang_{lang_code}", type=button_type_lang, use_container_width=True):
+                    st.session_state.preferred_answer_language = lang_code
+                    st.rerun()
+        
+        # Processing status
+        if st.session_state.processing_queue or st.session_state.processing_results:
+            st.markdown("## 🔄 " + ("حالة المعالجة" if st.session_state.language == 'ar' else "Processing Status"))
+            
+            # Queue status
+            if st.session_state.processing_queue:
+                queue_count = len(st.session_state.processing_queue)
+                st.warning(f"⏳ {queue_count} " + ("في الانتظار" if st.session_state.language == 'ar' else "in queue"))
+            
+            # Results count
+            if st.session_state.processing_results:
+                results_count = len(st.session_state.processing_results)
+                st.success(f"✅ {results_count} " + ("مكتمل" if st.session_state.language == 'ar' else "completed"))
+            
+            # Clear all button
+            if st.button("🗑️ " + ("مسح الكل" if st.session_state.language == 'ar' else "Clear All")):
+                st.session_state.processing_queue = []
+                st.session_state.processing_results = {}
+                st.session_state.processing_status = {}
+                st.rerun()
+    
+    st.title("🎵 SyncMaster")
+    if st.session_state.language == 'ar':
+        st.markdown("### منصة المزامنة الذكية بين الصوت والنص")
+    else:
+        st.markdown("### The Intelligent Audio-Text Synchronization Platform")
+    
+    # Simplified interface - removed step indicators as requested
+        # Global settings for long recording retention and custom snapshot duration
+    with st.expander("⚙️ Recording Settings (Snapshots)", expanded=False):
+        st.session_state.setdefault('retention_minutes', 30)
+        # 0 means: use full buffer by default for Custom
+        st.session_state.setdefault('custom_snapshot_seconds', 0)
+        # Auto-Custom interval seconds (for frontend auto trigger)
+        st.session_state.setdefault('auto_custom_interval_sec', 10)
+        # Auto-start incremental snapshots when recording begins
+        st.session_state.setdefault('auto_start_custom', False)
+        st.session_state.retention_minutes = st.number_input("Retention window (minutes)", min_value=5, max_value=240, value=st.session_state.retention_minutes)
+        st.session_state.custom_snapshot_seconds = st.number_input("Custom snapshot (seconds; 0 = full buffer)", min_value=0, max_value=3600, value=st.session_state.custom_snapshot_seconds)
+        st.session_state.auto_custom_interval_sec = st.number_input("Auto Custom interval (seconds)", min_value=1, max_value=3600, value=st.session_state.auto_custom_interval_sec, help="How often to auto-trigger the same Custom action while recording.")
+        st.session_state.auto_start_custom = st.checkbox("Auto-start incremental snapshots on record", value=st.session_state.auto_start_custom, help="Start sending Custom intervals automatically as soon as you start recording.")
+        # Inject globals into the page for the component to pick up
+        components.html(f"""
+        <script>
+            window.ST_AREC_RETENTION_MINUTES = {int(st.session_state.retention_minutes)};
+            window.ST_AREC_CUSTOM_SNAPSHOT_SECONDS = {int(st.session_state.custom_snapshot_seconds)};
+            window.ST_AREC_LAST_FETCHED_END_MS = {int(st.session_state.get('lastFetchedEnd_ms', 0))};
+            window.ST_AREC_CUSTOM_AUTO_INTERVAL_SECONDS = {int(st.session_state.get('auto_custom_interval_sec', 10))};
+            window.ST_AREC_AUTO_START = {str(bool(st.session_state.get('auto_start_custom', True))).lower()};
+            console.log('Recorder config', window.ST_AREC_RETENTION_MINUTES, window.ST_AREC_CUSTOM_SNAPSHOT_SECONDS);
+        </script>
+        """, height=0)
+
+    if AUDIO_PROCESSOR_CLASS is None:
+        st.error("Fatal Error: The application could not start correctly.")
+        st.subheader("An error occurred while trying to import `AudioProcessor`:")
+        st.code(IMPORT_ERROR_TRACEBACK, language="python")
+        st.stop()
+    
+    step_1_upload_and_process()
+    
+    # Process background queue
+    if st.session_state.get('background_processing', True) and st.session_state.processing_queue:
+        process_queued_audio()
+    
+    # Show processing results optionally
+    if st.session_state.get('show_processing_results', False):
+        show_processing_results()
+    elif st.session_state.processing_results:
+        # Show a button to view results if there are any
+        if st.button("📝 " + ("عرض نتائج المعالجة" if st.session_state.language == 'ar' else "Show Processing Results") + f" ({len(st.session_state.processing_results)})", type="secondary"):
+            st.session_state.show_processing_results = True
+            st.rerun()
+    
+    # Note: step_2_review_and_customize removed as requested
+    # Results are now shown in show_processing_results() function
+    
+    # AI Question modal (show outside of other components)
+    if st.session_state.show_question_modal:
+        show_question_modal()
+    
+    # Export modal (show outside of other components)
+    if st.session_state.show_export_modal:
+        show_export_modal()
+
+# --- Show Processing Results ---
+def show_processing_results():
+    """Show processing results in the same page"""
+    
+    if not st.session_state.processing_results:
+        return
+    
+    st.markdown("---")
+    
+    # Header with results count and close button
+    col_header, col_close = st.columns([4, 1])
+    
+    with col_header:
+        results_count = len(st.session_state.processing_results)
+        st.subheader(f"📝 {'نتائج المعالجة' if st.session_state.language == 'ar' else 'Processing Results'} ({results_count})")
+    
+    with col_close:
+        if st.button("❌ " + ("إخفاء" if st.session_state.language == 'ar' else "Hide"), key="hide_results"):
+            st.session_state.show_processing_results = False
+            st.rerun()
+    
+    if results_count > 1:
+        # Show all results in one view option
+        show_all = st.checkbox(
+            "عرض جميع النتائج مجمعة" if st.session_state.language == 'ar' else "Show all results combined",
+            help="عرض جميع النصوص والترجمات في مكان واحد" if st.session_state.language == 'ar' else "Display all texts and translations in one place"
+        )
+        
+        if show_all:
+            # Combined view
+            st.markdown("### " + ("النصوص الأصلية مجمعة" if st.session_state.language == 'ar' else "Combined Original Texts"))
+            combined_original = "\n\n".join([result.get('original_text', '') for result in st.session_state.processing_results.values() if result.get('original_text')])
+            if combined_original:
+                st.write(combined_original)
+                
+                if st.button("📋 " + ("نسخ جميع النصوص" if st.session_state.language == 'ar' else "Copy All Texts")):
+                    st.code(combined_original, language=None)
+            
+            st.markdown("### " + ("الترجمات مجمعة" if st.session_state.language == 'ar' else "Combined Translations"))
+            combined_translation = "\n\n".join([result.get('translated_text', '') for result in st.session_state.processing_results.values() if result.get('translated_text')])
+            if combined_translation:
+                st.write(combined_translation)
+                
+                if st.button("📋 " + ("نسخ جميع الترجمات" if st.session_state.language == 'ar' else "Copy All Translations")):
+                    st.code(combined_translation, language=None)
+            
+            st.markdown("---")
+    
+    # Show results for each completed processing
+    for task_id, result in st.session_state.processing_results.items():
+        with st.expander(f"🎵 {'التسجيل' if st.session_state.language == 'ar' else 'Recording'} {task_id}", expanded=True):
+            
+            # Original text in white container
+            if result.get('original_text'):
+                original_title = "النص الأصلي" if st.session_state.language == 'ar' else "Original Text"
+                original_container = create_white_container(original_title, result['original_text'], "📝")
+                st.markdown(original_container, unsafe_allow_html=True)
+            
+            # Translation in white container
+            if result.get('translated_text'):
+                translation_title = "الترجمة" if st.session_state.language == 'ar' else "Translation"
+                translation_container = create_white_container(translation_title, result['translated_text'], "🌐")
+                st.markdown(translation_container, unsafe_allow_html=True)
+            
+            # Language info
+            if result.get('detected_language'):
+                st.caption(f"🌐 {'اللغة المكتشفة' if st.session_state.language == 'ar' else 'Detected language'}: {result['detected_language']}")
+            
+            # Action buttons
+            col1, col2, col3 = st.columns(3)
+            
+            with col1:
+                if st.button(f"📋 {'نسخ النص' if st.session_state.language == 'ar' else 'Copy Text'}", key=f"copy_original_{task_id}"):
+                    st.code(result.get('original_text', ''), language=None)
+                    st.success("✅ " + ("تم تنسيق النص للنسخ" if st.session_state.language == 'ar' else "Text formatted for copying"))
+            
+            with col2:
+                if result.get('translated_text') and st.button(f"📋 {'نسخ الترجمة' if st.session_state.language == 'ar' else 'Copy Translation'}", key=f"copy_translation_{task_id}"):
+                    st.code(result.get('translated_text', ''), language=None)
+                    st.success("✅ " + ("تم تنسيق الترجمة للنسخ" if st.session_state.language == 'ar' else "Translation formatted for copying"))
+            
+            with col3:
+                if st.button(f"🗑️ {'حذف' if st.session_state.language == 'ar' else 'Delete'}", key=f"delete_{task_id}"):
+                    del st.session_state.processing_results[task_id]
+                    if task_id in st.session_state.processing_status:
+                        del st.session_state.processing_status[task_id]
+                    st.rerun()
+
+# --- Step 1: Upload and Process ---
+def step_1_upload_and_process():
+    st.header("🎵 " + ("مصدر الصوت" if st.session_state.language == 'ar' else "Audio Source"))
+    
+    upload_tab, record_tab = st.tabs(["📤 Upload a File", "🎙️ Record Audio"])
+
+    with upload_tab:
+        st.subheader("Upload an existing audio file")
+        uploaded_file = st.file_uploader("Choose an audio file", type=['mp3', 'wav', 'm4a'], help="Supported formats: MP3, WAV, M4A")
+        if uploaded_file:
+            st.session_state.audio_data = uploaded_file.getvalue()
+            st.success(f"File ready for processing: {uploaded_file.name}")
+            st.audio(st.session_state.audio_data)
+            if st.button("🚀 Start AI Processing", type="primary", use_container_width=True):
+                run_audio_processing(st.session_state.audio_data, uploaded_file.name)
+        if st.session_state.audio_data:
+            if st.button("🔄 Use a Different File"):
+                reset_session()
+                st.rerun()
+
+    with record_tab:
+        st.subheader("Record audio directly from your microphone")
+        
+        # Recording instructions
+        # Recording instructions with improved controls
+        if st.session_state.language == 'ar':
+            st.info("🎙️ **تحكم بسيط في التسجيل:**\n- اضغط الميكروفون لبدء التسجيل\n- اضغط مرة أخرى للتوقف\n- استخدم الأزرار أدناه للتحكم الإضافي")
+        else:
+            st.info("🎙️ **Simple Recording Controls:**\n- Click microphone to start recording\n- Click again to stop\n- Use buttons below for additional control")
+        
+        # Recording control buttons
+        col_record_info, col_record_controls = st.columns([2, 1])
+        
+        with col_record_info:
+            # This will show recording status
+            pass
+        
+        with col_record_controls:
+            # Recording control buttons in a more compact layout
+            col_pause, col_resume = st.columns(2)
+            
+            with col_pause:
+                if st.button("⏸️ " + ("إيقاف مؤقت" if st.session_state.language == 'ar' else "Pause"), 
+                           help="إيقاف مؤقت للتسجيل" if st.session_state.language == 'ar' else "Pause recording",
+                           use_container_width=True):
+                    st.info("💡 " + ("استخدم زر الميكروفون للإيقاف المؤقت" if st.session_state.language == 'ar' else "Use microphone button to pause"))
+            
+            with col_resume:
+                if st.button("▶️ " + ("استئناف" if st.session_state.language == 'ar' else "Resume"), 
+                           help="استئناف التسجيل" if st.session_state.language == 'ar' else "Resume recording",
+                           use_container_width=True):
+                    st.info("💡 " + ("استخدم زر الميكروفون للاستئناف" if st.session_state.language == 'ar' else "Use microphone button to resume"))
+        
+        # Recording status
+        recording_status_placeholder = st.empty()
+        
+        # Use the audio recorder component
+        wav_audio_data = st_audiorec()
+        
+        # Show recording status and controls
+        if wav_audio_data:
+            # Check if wav_audio_data is bytes or dict
+            if isinstance(wav_audio_data, bytes):
+                # Simple bytes data - show audio player
+                recording_status_placeholder.success("🎵 " + ("تسجيل جاهز للمعالجة" if st.session_state.language == 'ar' else "Recording ready for processing"))
+                
+                # Recording controls
+                col_play, col_clear = st.columns(2)
+                
+                with col_play:
+                    st.audio(wav_audio_data, format='audio/wav')
+                
+                with col_clear:
+                    if st.button("🗑️ " + ("مسح التسجيل" if st.session_state.language == 'ar' else "Clear Recording")):
+                        st.rerun()
+            
+            elif isinstance(wav_audio_data, dict):
+                # Dict data - handle interval processing
+                recording_status_placeholder.info("🔄 " + ("معالجة المقاطع..." if st.session_state.language == 'ar' else "Processing intervals..."))
+
+        # Google Docs Export and Logout Buttons
+        col_export, col_logout = st.columns([3, 1])
+        
+        with col_export:
+            export_button_text = "📤 تصدير إلى Google Docs" if st.session_state.language == 'ar' else "📤 Export to Google Docs"
+            if st.button(export_button_text, type="primary", use_container_width=True):
+                export_to_google_docs_directly()
+        
+        with col_logout:
+            # Check if user is authenticated
+            if google_docs_manager.is_authenticated():
+                logout_text = "🚪 خروج" if st.session_state.language == 'ar' else "🚪 Logout"
+                if st.button(logout_text, use_container_width=True, help="تسجيل الخروج من Google" if st.session_state.language == 'ar' else "Logout from Google"):
+                    logout_from_google()
+            else:
+                # Show login status
+                login_status = "غير متصل" if st.session_state.language == 'ar' else "Not logged in"
+                st.caption(f"🔒 {login_status}")
+        
+        # Processing settings
+        st.markdown("**" + ("إعدادات المعالجة" if st.session_state.language == 'ar' else "Processing Settings") + "**")
+        
+        # Auto-process toggle (changed default to False for better UX)
+        st.session_state.setdefault('auto_process_snapshots', False)
+        auto_process = st.checkbox(
+            "معالجة تلقائية للمقاطع" if st.session_state.language == 'ar' else "Auto-process snapshots", 
+            key='auto_process_snapshots', 
+            help="عند التفعيل، يتم معالجة المقاطع تلقائياً أثناء التسجيل" if st.session_state.language == 'ar' else "When enabled, snapshots are processed automatically during recording"
+        )
+        
+        # Background processing toggle
+        st.session_state.setdefault('background_processing', True)
+        background_mode = st.checkbox(
+            "معالجة في الخلفية" if st.session_state.language == 'ar' else "Background processing",
+            key='background_processing',
+            value=True,
+            help="يسمح بالاستمرار في استخدام التطبيق أثناء المعالجة" if st.session_state.language == 'ar' else "Allows continued use of the app during processing"
+        )
+
+        if wav_audio_data:
+            # Two possible payload shapes: raw bytes array (legacy) or interval payload dict
+            if isinstance(wav_audio_data, dict) and wav_audio_data.get('type') in ('interval_wav', 'no_new'):
+                payload = wav_audio_data
+                # Mark Custom interval flow active so Step 2 editor/style can be hidden
+                st.session_state['_custom_active'] = True
+                if payload['type'] == 'no_new':
+                    st.info("No new audio chunks yet.")
+                elif payload['type'] == 'interval_wav':
+                    # Extract interval audio
+                    b = bytes(payload['bytes'])
+                    sr = int(payload.get('sr', 16000))
+                    start_ms = int(payload['start_ms'])
+                    end_ms = int(payload['end_ms'])
+                    # Dedupe/trim logic
+                    if end_ms <= start_ms:
+                        st.warning("The received interval is empty.")
+                    else:
+                        # Prevent overlap with prior segment
+                        last_end = st.session_state.lastFetchedEnd_ms or 0
+                        eff_start_ms = max(start_ms, last_end)
+                        if eff_start_ms < end_ms:
+                            # If there is overlap, trim the audio bytes accordingly (assumes WAV PCM16 mono header 44 bytes)
+                            try:
+                                delta_ms = eff_start_ms - start_ms
+                                if delta_ms > 0:
+                                    if len(b) >= 44 and b[0:4] == b'RIFF' and b[8:12] == b'WAVE':
+                                        bytes_per_sample = 2  # PCM16 mono
+                                        drop_samples = int(sr * (delta_ms / 1000.0))
+                                        drop_bytes = drop_samples * bytes_per_sample
+                                        data_size = int.from_bytes(b[40:44], 'little') if len(b) >= 44 else len(b) - 44
+                                        pcm = b[44:]
+                                        if drop_bytes < len(pcm):
+                                            pcm_trim = pcm[drop_bytes:]
+                                        else:
+                                            pcm_trim = b''
+                                        new_data_size = len(pcm_trim)
+                                        # Rebuild header sizes
+                                        header = bytearray(b[:44])
+                                        # ChunkSize at offset 4 = 36 + Subchunk2Size
+                                        (36 + new_data_size).to_bytes(4, 'little')
+                                        header[4:8] = (36 + new_data_size).to_bytes(4, 'little')
+                                        # Subchunk2Size at offset 40
+                                        header[40:44] = new_data_size.to_bytes(4, 'little')
+                                        b = bytes(header) + pcm_trim
+                                    else:
+                                        # Not a recognizable WAV header; keep as-is
+                                        pass
+                            except Exception as _:
+                                pass
+                            # Compute checksum
+                            digest = hashlib.md5(b).hexdigest()
+                            # Skip if identical checksum and same window
+                            exists = any(s.get('checksum') == digest and s.get('start_ms') == eff_start_ms and s.get('end_ms') == end_ms for s in st.session_state.broadcast_segments)
+                            if not exists:
+                                # Show spinner during extraction so the user sees a waiting icon until text appears
+                                with st.spinner("⏳ Extracting text from interval..."):
+                                    # Run standard pipeline to get text (no translation to keep it light)
+                                    # Reuse run_audio_processing internals via a temp path
+                                    with tempfile.NamedTemporaryFile(delete=False, suffix='.wav') as tf:
+                                        tf.write(b)
+                                        tmp_path = tf.name
+                                    try:
+                                        processor = AUDIO_PROCESSOR_CLASS()
+                                        word_timestamps, processor_logs, model_used = processor.get_word_timestamps(tmp_path)
+                                        full_text = " ".join([d['word'] for d in word_timestamps]) if word_timestamps else ""
+                                        # Fallback: if timestamps extraction yielded no words, try plain transcription
+                                        if not full_text:
+                                            plain_text, err, fallback_model = processor.transcribe_audio(tmp_path)
+                                            if plain_text:
+                                                full_text = plain_text.strip()
+                                                model_used = fallback_model
+                                    finally:
+                                        if os.path.exists(tmp_path): os.unlink(tmp_path)
+
+                                # Append segment immediately with only the original text
+                                seg = {
+                                    'id': digest,
+                                    'recording_id': payload.get('session_id', 'local'),
+                                    'start_ms': eff_start_ms,
+                                    'end_ms': end_ms,
+                                    'checksum': digest,
+                                    'text': full_text,
+                                    'translations': {},
+                                    'transcription_model': model_used,
+                                }
+                                st.session_state.broadcast_segments.append(seg)
+                                st.session_state.broadcast_segments.sort(key=lambda s: s['start_ms'])
+                                st.session_state.lastFetchedEnd_ms = end_ms
+                                if full_text:
+                                    if digest not in st.session_state.transcript_ids:
+                                        st.session_state.transcript_ids.add(digest)
+                                        st.session_state.transcript_feed.insert(
+                                            0,
+                                            {
+                                                "id": digest,
+                                                "ts": int(time.time() * 1000),
+                                                "text": full_text,
+                                            },
+                                        )
+                                        st.session_state.edited_text = "\n\n".join(
+                                            [s["text"] for s in st.session_state.transcript_feed]
+                                        )
+                                st.success(f"Added new segment: {eff_start_ms/1000:.2f}s → {end_ms/1000:.2f}s")
+
+                                # Now, asynchronously update translation and summary after segment is added
+                                def update_translation_and_summary():
+                                    try:
+                                        if full_text and st.session_state.get('enable_translation', True):
+                                            translator = get_translator()
+                                            sel_lang = st.session_state.get('broadcast_translation_lang', 'ar')
+                                            tx, _ = translator.translate_text(full_text, target_language=sel_lang)
+                                            if tx:
+                                                seg['translations'][sel_lang] = tx
+                                    except Exception:
+                                        pass
+                                    # Update summary
+                                    if st.session_state.get('auto_generate_summary', True):
+                                        try:
+                                            source_text = " \n".join([s.get('text', '') for s in st.session_state.broadcast_segments if s.get('text')])
+                                            if source_text.strip():
+                                                summary, _ = generate_summary(source_text, target_language=st.session_state.get('summary_language', 'ar'))
+                                                if summary:
+                                                    st.session_state.arabic_explanation = summary
+                                        except Exception:
+                                            pass
+                                import threading
+                                threading.Thread(target=update_translation_and_summary, daemon=True).start()
+                            else:
+                                st.info("Duplicate segment ignored.")
+                        else:
+                            st.info("No new parts after the last point.")
+            else:
+                # Legacy: treat as full wav bytes
+                bytes_data = bytes(wav_audio_data)
+                # This is not the Custom interval mode
+                st.session_state['_custom_active'] = False
+                st.session_state.audio_data = bytes_data
+                st.audio(bytes_data)
+                digest = hashlib.md5(bytes_data).hexdigest()
+                last_digest = st.session_state.get('_last_component_digest')
+                if st.session_state.auto_process_snapshots and digest != last_digest:
+                    st.session_state['_last_component_digest'] = digest
+                    task_id = run_audio_processing(bytes_data, "snapshot.wav")
+                    if task_id:
+                        st.success(f"🔄 {'تم إضافة المقطع للمعالجة' if st.session_state.language == 'ar' else 'Snapshot queued for processing'}")
+                else:
+                    # Simple single button for processing
+                    if st.button("📝 " + ("استخراج النص" if st.session_state.language == 'ar' else "Extract Text"), type="primary", use_container_width=True):
+                        st.session_state['_last_component_digest'] = digest
+                        task_id = run_audio_processing(bytes_data, "recorded_audio.wav")
+                        if task_id:
+                            st.success(f"✅ {'تم إضافة التسجيل للمعالجة' if st.session_state.language == 'ar' else 'Audio queued for processing'}")
+
+        # Simplified: removed external live slice server UI to avoid complexity
+
+    # Always show Broadcast view in Step 1 as well (regardless of transcription_data)
+    with st.expander("📻 Broadcast (latest first)", expanded=True):
+        # Language selector for broadcast translations
+        try:
+                translator = get_translator()
+                langs = translator.get_supported_languages()
+                codes = list(langs.keys())
+                labels = ["detect language — Arabic (العربية)"] + [f"{code} — {langs[code]}" for code in codes]
+                current = st.session_state.get('broadcast_translation_lang', 'ar')
+                # If not set, default to 'detect'
+                if current not in codes and current != 'detect':
+                    current = 'detect'
+                default_index = 0 if current == 'detect' else (codes.index(current) + 1 if current in codes else 1)
+                sel_label = st.selectbox("Broadcast translation language", labels, index=default_index)
+                if sel_label.startswith("detect language"):
+                    sel_code = 'detect'
+                else:
+                    sel_code = sel_label.split(' — ')[0]
+                st.session_state.broadcast_translation_lang = sel_code
+        except Exception:
+            sel_code = st.session_state.get('broadcast_translation_lang', 'ar')
+        
+        if st.session_state.broadcast_segments:
+            for s in sorted(st.session_state.broadcast_segments, key=lambda s: s['start_ms'], reverse=True):
+                # Create unique segment ID
+                segment_id = s.get('id', f"seg_{s['start_ms']}_{s['end_ms']}")
+                
+                # Original text with selection capability
+                original_text = s.get('text', '')
+                if original_text:
+                    # Check if this segment is selected
+                    is_selected = (st.session_state.selected_segment_id == segment_id)
+                    
+                    # Create timestamp for bubble
+                    timestamp = f"{s['start_ms']/1000:.1f}s → {s['end_ms']/1000:.1f}s"
+                    
+                    # Create columns for bubble and ask button
+                    col_bubble, col_ask = st.columns([5, 1])
+                    
+                    with col_bubble:
+                        # Display text as chat bubble
+                        bubble_html = create_broadcast_bubble(original_text, timestamp, is_selected)
+                        st.markdown(bubble_html, unsafe_allow_html=True)
+                        
+                        if is_selected:
+                            st.success("🔍 " + ("هذا النص محدد للأسئلة" if st.session_state.language == 'ar' else "This text is selected for questions"))
+                    
+                    with col_ask:
+                        # Ask AI button
+                        ask_button_text = "🤖 اسأل" if st.session_state.language == 'ar' else "🤖 Ask"
+                        button_type = "primary" if not is_selected else "secondary"
+                        if st.button(ask_button_text, key=f"ask_{segment_id}", type=button_type, use_container_width=True, help="اسأل الذكاء الاصطناعي عن هذا النص" if st.session_state.language == 'ar' else "Ask AI about this text"):
+                            # Select this text and open question modal
+                            st.session_state.selected_text = original_text
+                            st.session_state.selected_segment_id = segment_id
+                            st.session_state.show_question_modal = True
+                            st.rerun()
+                
+                # Show model used for transcription
+                model_note = s.get('transcription_model', None)
+                if model_note:
+                    st.caption(f"Model used: {model_note}")
+                
+                # Ensure and show translation in selected language
+                if s.get('text') and st.session_state.get('enable_translation', True):
+                    if 'translations' not in s or not isinstance(s.get('translations'), dict):
+                        s['translations'] = {}
+                    # Detect language and translate if 'detect' is selected
+                    if sel_code == 'detect':
+                        # Use detected language from segment if available, else fallback to 'ar'
+                        detected_lang = s.get('detected_language', None)
+                        target_lang = 'ar'  # Always translate to Arabic in detect mode
+                        if target_lang not in s['translations']:
+                            try:
+                                tx, _ = get_translator().translate_text(s.get('text', ''), target_language=target_lang)
+                                if tx:
+                                    s['translations'][target_lang] = tx
+                            except Exception:
+                                pass
+                        if s['translations'].get(target_lang):
+                            st.caption(f"Translation (AR):")
+                            st.write(s['translations'][target_lang])
+                    else:
+                        if sel_code not in s['translations']:
+                            try:
+                                tx, _ = get_translator().translate_text(s.get('text', ''), target_language=sel_code)
+                                if tx:
+                                    s['translations'][sel_code] = tx
+                            except Exception:
+                                pass
+                        if s['translations'].get(sel_code):
+                            st.caption(f"Translation ({sel_code.upper()}):")
+                            st.write(s['translations'][sel_code])
+                st.divider()
+        else:
+            st.caption("No segments yet. Use the Custom button while recording.")
+        
+
+
+# --- Google Logout Function ---
+def logout_from_google():
+    """Logout from Google account"""
+    try:
+        success = google_docs_manager.logout()
+        
+        if success:
+            st.success("تم تسجيل الخروج بنجاح!" if st.session_state.language == 'ar' else "Successfully logged out!")
+            st.info("يمكنك الآن تسجيل الدخول بحساب آخر" if st.session_state.language == 'ar' else "You can now login with a different account")
+            # Force rerun to update UI
+            time.sleep(1)
+            st.rerun()
+        else:
+            st.error("خطأ في تسجيل الخروج" if st.session_state.language == 'ar' else "Error during logout")
+    
+    except Exception as e:
+        st.error(f"خطأ غير متوقع: {str(e)}" if st.session_state.language == 'ar' else f"Unexpected error: {str(e)}")
+
+# --- Direct Google Docs Export Function ---
+def export_to_google_docs_directly():
+    """Export broadcast segments directly to Google Docs without conditions"""
+    
+    try:
+        # Get current segments (all segments, not filtered by timestamp)
+        segments = st.session_state.broadcast_segments or []
+        
+        # Show progress
+        with st.spinner("جاري التصدير إلى Google Docs..." if st.session_state.language == 'ar' else "Exporting to Google Docs..."):
+            # Export directly
+            doc_url, error = google_docs_manager.export_broadcast_to_docs(
+                segments, 
+                ui_language=st.session_state.language
+            )
+        
+        if doc_url and not error:
+            st.success("تم إنشاء المستند بنجاح!" if st.session_state.language == 'ar' else "Document created successfully!")
+            
+            # Show clickable link
+            if st.session_state.language == 'ar':
+                st.markdown(f"🔗 [فتح المستند في Google Docs]({doc_url})")
+                st.info("💡 نصيحة: اضغط على الرابط أعلاه لفتح المستند في تبويب جديد")
+            else:
+                st.markdown(f"🔗 [Open Document in Google Docs]({doc_url})")
+                st.info("💡 Tip: Click the link above to open the document in a new tab")
+            
+            # Also show the URL for copying
+            st.code(doc_url, language=None)
+            
+            # Show current user info
+            if google_docs_manager.is_authenticated():
+                st.caption("✅ متصل بحساب Google" if st.session_state.language == 'ar' else "✅ Connected to Google account")
+            
+        else:
+            error_msg = error or "Unknown error occurred"
+            st.error(f"خطأ في التصدير: {error_msg}" if st.session_state.language == 'ar' else f"Export error: {error_msg}")
+            
+            # Show setup instructions if credentials are missing
+            if "credentials" in error_msg.lower() or "authentication" in error_msg.lower():
+                st.info("📋 يرجى مراجعة ملف GOOGLE_SETUP.md لإعداد Google Docs" if st.session_state.language == 'ar' else "📋 Please check GOOGLE_SETUP.md for Google Docs setup instructions")
+    
+    except Exception as e:
+        st.error(f"خطأ غير متوقع: {str(e)}" if st.session_state.language == 'ar' else f"Unexpected error: {str(e)}")
+
+# --- AI Question Modal Function ---
+def show_question_modal():
+    """Display AI question modal for selected text"""
+    
+    if not st.session_state.selected_text:
+        st.session_state.show_question_modal = False
+        return
+    
+    # Get AI question engine
+    question_engine = get_ai_question_engine()
+    
+    # Modal header
+    st.subheader("🤖 اسأل الذكاء الاصطناعي" if st.session_state.language == 'ar' else "🤖 Ask AI")
+    
+    # Show selected text
+    with st.expander("النص المحدد" if st.session_state.language == 'ar' else "Selected Text", expanded=True):
+        st.write(f"📝 {st.session_state.selected_text}")
+    
+    # Show conversation history if exists
+    if st.session_state.current_question_session:
+        session = question_engine.get_conversation_history(st.session_state.current_question_session)
+        if session and session.conversation:
+            with st.expander(f"💬 تاريخ المحادثة ({len(session.conversation)} أسئلة)" if st.session_state.language == 'ar' else f"💬 Conversation History ({len(session.conversation)} questions)", expanded=False):
+                for i, qa in enumerate(session.conversation, 1):
+                    st.markdown(f"**{i}. {qa.question}**")
+                    st.write(qa.answer)
+                    
+                    # Show timing and model info
+                    model_info = getattr(qa, 'model_used', 'Unknown')
+                    model_color = "green" if "Gemini" in model_info else "orange" if "Groq" in model_info or "OpenRouter" in model_info else "red"
+                    
+                    caption_text = f"⏱️ {qa.timestamp.strftime('%H:%M:%S')} - {qa.response_time_ms}ms"
+                    model_text = f"🔧 {model_info}"
+                    
+                    st.caption(caption_text)
+                    st.markdown(f"<small style='color: {model_color}'>{model_text}</small>", unsafe_allow_html=True)
+                    
+                    if i < len(session.conversation):
+                        st.divider()
+    
+    # Model selection (moved to top)
+    st.markdown("**" + ("اختيار النموذج" if st.session_state.language == 'ar' else "Model Selection") + "**")
+    
+    # Get model availability
+    models_status = question_engine.check_model_availability()
+    
+    # Create model options with status indicators
+    model_options = {}
+    for model_name, status_info in models_status.items():
+        display_name = f"{status_info['icon']} {model_name} - {status_info['message']}"
+        model_options[display_name] = model_name
+    
+    # Add auto option
+    auto_text = "🔄 تلقائي (أفضل نموذج متاح)" if st.session_state.language == 'ar' else "🔄 Auto (Best available model)"
+    model_options = {auto_text: 'auto', **model_options}
+    
+    # Find current selection index
+    current_model = st.session_state.get('preferred_ai_model', 'auto')
+    current_index = 0
+    for i, (display_name, model_name) in enumerate(model_options.items()):
+        if model_name == current_model:
+            current_index = i
+            break
+    
+    # Model selector
+    selected_model_display = st.selectbox(
+        "النموذج المفضل" if st.session_state.language == 'ar' else "Preferred Model",
+        options=list(model_options.keys()),
+        index=current_index,
+        help="اختر النموذج المفضل للإجابة" if st.session_state.language == 'ar' else "Choose preferred model for answering"
+    )
+    
+    selected_model = model_options[selected_model_display]
+    st.session_state.preferred_ai_model = selected_model
+    
+    # Show model status details
+    if selected_model != 'auto':
+        status_info = models_status[selected_model]
+        if status_info['status'] != 'available':
+            if status_info['status'] == 'quota_exceeded':
+                st.warning("⚠️ هذا النموذج استنفد حصته اليومية" if st.session_state.language == 'ar' else "⚠️ This model has exceeded its daily quota")
+            elif status_info['status'] == 'not_configured':
+                st.info("ℹ️ هذا النموذج غير مُعد - سيتم استخدام البديل" if st.session_state.language == 'ar' else "ℹ️ This model is not configured - fallback will be used")
+            else:
+                st.error("❌ هذا النموذج غير متاح حالياً" if st.session_state.language == 'ar' else "❌ This model is currently unavailable")
+    
+    # Language selection for answers
+    st.markdown("**" + ("لغة الإجابة" if st.session_state.language == 'ar' else "Answer Language") + "**")
+    
+    # Language options
+    language_options = {
+        "🔄 تلقائي (حسب لغة الواجهة)" if st.session_state.language == 'ar' else "🔄 Auto (Interface language)": 'auto',
+        "🇸🇦 العربية": 'ar',
+        "🇺🇸 English": 'en',
+        "🇫🇷 Français": 'fr',
+        "🇪🇸 Español": 'es',
+        "🇩🇪 Deutsch": 'de',
+        "🇨🇳 中文": 'zh'
+    }
+    
+    # Find current language selection
+    current_lang = st.session_state.get('preferred_answer_language', 'auto')
+    current_lang_index = 0
+    for i, (display_name, lang_code) in enumerate(language_options.items()):
+        if lang_code == current_lang:
+            current_lang_index = i
+            break
+    
+    # Language selector
+    selected_language_display = st.selectbox(
+        "لغة الإجابة المفضلة" if st.session_state.language == 'ar' else "Preferred Answer Language",
+        options=list(language_options.keys()),
+        index=current_lang_index,
+        help="اختر اللغة التي تريد الحصول على الإجابة بها" if st.session_state.language == 'ar' else "Choose the language for AI responses"
+    )
+    
+    selected_answer_language = language_options[selected_language_display]
+    st.session_state.preferred_answer_language = selected_answer_language
+    
+    # Show language info
+    if selected_answer_language == 'auto':
+        current_ui_lang = "العربية" if st.session_state.language == 'ar' else "English"
+        st.caption(f"ℹ️ سيتم استخدام لغة الواجهة الحالية: {current_ui_lang}" if st.session_state.language == 'ar' else f"ℹ️ Will use current interface language: {current_ui_lang}")
+    else:
+        lang_names = {'ar': 'العربية', 'en': 'English', 'fr': 'Français', 'es': 'Español', 'de': 'Deutsch', 'zh': '中文'}
+        selected_lang_name = lang_names.get(selected_answer_language, selected_answer_language)
+        st.caption(f"ℹ️ الإجابات ستكون باللغة: {selected_lang_name}" if st.session_state.language == 'ar' else f"ℹ️ Answers will be in: {selected_lang_name}")
+    
+    # Question templates
+    st.markdown("**" + ("قوالب الأسئلة السريعة" if st.session_state.language == 'ar' else "Quick Question Templates") + "**")
+    
+    templates = question_engine.get_question_templates(st.session_state.language)
+    
+    # Display templates as buttons in columns
+    cols = st.columns(2)
+    for i, template in enumerate(templates[:6]):  # Show first 6 templates
+        with cols[i % 2]:
+            if st.button(template, key=f"template_{i}", use_container_width=True):
+                # Process template question
+                process_ai_question(template, is_template=True, preferred_model=selected_model, answer_language=selected_answer_language)
+                return
+    
+    # Custom question input
+    st.markdown("**" + ("أو اكتب سؤالك الخاص" if st.session_state.language == 'ar' else "Or Write Your Own Question") + "**")
+    
+    custom_question = st.text_area(
+        "سؤالك" if st.session_state.language == 'ar' else "Your Question",
+        placeholder="اكتب سؤالك هنا..." if st.session_state.language == 'ar' else "Type your question here...",
+        height=100
+    )
+    
+    # Action buttons
+    col_ask, col_cancel = st.columns(2)
+    
+    with col_ask:
+        if st.button("🚀 اسأل" if st.session_state.language == 'ar' else "🚀 Ask", type="primary", disabled=not custom_question.strip()):
+            if custom_question.strip():
+                process_ai_question(custom_question.strip(), is_template=False, preferred_model=selected_model, answer_language=selected_answer_language)
+                return
+    
+    with col_cancel:
+        if st.button("❌ إلغاء" if st.session_state.language == 'ar' else "❌ Cancel"):
+            st.session_state.show_question_modal = False
+            st.session_state.selected_text = None
+            st.session_state.selected_segment_id = None
+            st.rerun()
+
+def process_ai_question(question: str, is_template: bool = False, preferred_model: str = 'auto', answer_language: str = 'auto'):
+    """Process AI question and show response"""
+    
+    question_engine = get_ai_question_engine()
+    
+    # Prepare segment info
+    segment_info = {
+        'id': st.session_state.selected_segment_id,
+        'start_ms': 0,  # We'll get this from the actual segment if needed
+        'end_ms': 0
+    }
+    
+    # Show processing indicator
+    with st.spinner("جاري معالجة سؤالك..." if st.session_state.language == 'ar' else "Processing your question..."):
+        # Determine answer language
+        if answer_language == 'auto':
+            answer_lang = st.session_state.language
+        else:
+            answer_lang = answer_language
+        
+        # Process question
+        result = question_engine.process_question(
+            selected_text=st.session_state.selected_text,
+            question=question,
+            segment_info=segment_info,
+            ui_language=answer_lang,  # Use selected answer language
+            session_id=st.session_state.current_question_session,
+            preferred_model=preferred_model
+        )
+        
+        # Handle different return formats for backward compatibility
+        if len(result) == 4:
+            answer, error, session_id, model_used = result
+        else:
+            answer, error, session_id = result
+            model_used = "Unknown"
+    
+    # Update session ID
+    st.session_state.current_question_session = session_id
+    
+    if answer:
+        # Check response type and model fallback
+        is_simple_response = "ملاحظة: هذه إجابة مبسطة" in answer or "Note: This is a simplified response" in answer
+        preferred_model = st.session_state.get('preferred_ai_model', 'auto')
+        model_fallback = preferred_model != 'auto' and preferred_model != model_used
+        
+        if is_simple_response:
+            st.warning("⚠️ خدمة الذكاء الاصطناعي غير متاحة حالياً - إجابة مبسطة" if st.session_state.language == 'ar' else "⚠️ AI service temporarily unavailable - simplified response")
+        elif model_fallback:
+            st.info(f"ℹ️ النموذج المفضل ({preferred_model}) غير متاح - تم استخدام {model_used}" if st.session_state.language == 'ar' else f"ℹ️ Preferred model ({preferred_model}) unavailable - used {model_used}")
+        else:
+            st.success("تم الحصول على الإجابة!" if st.session_state.language == 'ar' else "Got the answer!")
+        
+        # Display Q&A
+        st.markdown("### " + ("السؤال" if st.session_state.language == 'ar' else "Question"))
+        st.write(f"❓ {question}")
+        
+        st.markdown("### " + ("الإجابة" if st.session_state.language == 'ar' else "Answer"))
+        st.write(f"🤖 {answer}")
+        
+        # Show which model was used with enhanced styling
+        if model_used:
+            # Get model status for better display
+            question_engine = get_ai_question_engine()
+            models_status = question_engine.check_model_availability()
+            
+            model_info = models_status.get(model_used, {})
+            icon = model_info.get('icon', '🤖')
+            color = model_info.get('color', 'gray')
+            
+            # Show if user's preferred model was used or fallback occurred
+            preferred_model = st.session_state.get('preferred_ai_model', 'auto')
+            if preferred_model != 'auto' and preferred_model != model_used:
+                fallback_msg = " (تم التبديل للبديل)" if st.session_state.language == 'ar' else " (fallback used)"
+                color = "orange"
+            else:
+                fallback_msg = ""
+            
+            model_display = f"{icon} {model_used}{fallback_msg}"
+            
+            # Show answer language info
+            answer_lang = st.session_state.get('preferred_answer_language', 'auto')
+            if answer_lang == 'auto':
+                lang_display = "تلقائي" if st.session_state.language == 'ar' else "Auto"
+                lang_flag = "🔄"
+            else:
+                lang_flags = {'ar': '🇸🇦', 'en': '🇺🇸', 'fr': '🇫🇷', 'es': '🇪🇸', 'de': '🇩🇪', 'zh': '🇨🇳'}
+                lang_names = {'ar': 'العربية', 'en': 'English', 'fr': 'Français', 'es': 'Español', 'de': 'Deutsch', 'zh': '中文'}
+                lang_flag = lang_flags.get(answer_lang, '🌐')
+                lang_display = lang_names.get(answer_lang, answer_lang)
+            
+            info_text = f"🔧 {'النموذج' if st.session_state.language == 'ar' else 'Model'}: {model_display} | 🌐 {'اللغة' if st.session_state.language == 'ar' else 'Language'}: {lang_flag} {lang_display}"
+            
+            st.markdown(f"<div style='background-color: rgba(0,0,0,0.1); padding: 8px; border-radius: 5px; margin: 5px 0;'><small style='color: {color}'>{info_text}</small></div>", unsafe_allow_html=True)
+        
+        # Show additional help for simple responses
+        if is_simple_response:
+            with st.expander("💡 نصائح للحصول على إجابات أفضل" if st.session_state.language == 'ar' else "💡 Tips for better answers"):
+                if st.session_state.language == 'ar':
+                    st.markdown("""
+                    **لماذا الإجابة مبسطة؟**
+                    - تم استنفاد الحد اليومي لخدمة Gemini AI المجانية (50 طلب/يوم)
+                    - النظام يستخدم إجابات مبسطة كبديل مؤقت
+                    
+                    **للحصول على إجابات أفضل:**
+                    - حاول مرة أخرى غداً (يتم تجديد الحد اليومي)
+                    - اطرح أسئلة أكثر تحديداً
+                    - ابحث في مصادر إضافية للموضوع
+                    """)
+                else:
+                    st.markdown("""
+                    **Why is the answer simplified?**
+                    - Daily limit for free Gemini AI service exceeded (50 requests/day)
+                    - System is using simplified responses as temporary fallback
+                    
+                    **For better answers:**
+                    - Try again tomorrow (daily limit resets)
+                    - Ask more specific questions
+                    - Search additional sources for the topic
+                    """)
+        
+        
+        # Action buttons for the response
+        col_copy, col_follow, col_close = st.columns(3)
+        
+        with col_copy:
+            if st.button("📋 نسخ" if st.session_state.language == 'ar' else "📋 Copy"):
+                # Format for copying
+                copy_text = f"السؤال: {question}\nالإجابة: {answer}" if st.session_state.language == 'ar' else f"Question: {question}\nAnswer: {answer}"
+                st.code(copy_text, language=None)
+                st.success("تم تنسيق النص للنسخ أعلاه" if st.session_state.language == 'ar' else "Text formatted for copying above")
+        
+        with col_follow:
+            if st.button("➕ سؤال متابعة" if st.session_state.language == 'ar' else "➕ Follow-up"):
+                # Keep modal open for follow-up question
+                st.rerun()
+        
+        with col_close:
+            if st.button("✅ إغلاق" if st.session_state.language == 'ar' else "✅ Close"):
+                st.session_state.show_question_modal = False
+                st.session_state.selected_text = None
+                st.session_state.selected_segment_id = None
+                st.rerun()
+    
+    else:
+        # Show error
+        st.error(f"خطأ: {error}" if st.session_state.language == 'ar' else f"Error: {error}")
+        
+        # Retry and close buttons
+        col_retry, col_close = st.columns(2)
+        
+        with col_retry:
+            if st.button("🔄 إعادة المحاولة" if st.session_state.language == 'ar' else "🔄 Retry"):
+                process_ai_question(question, is_template)
+                return
+        
+        with col_close:
+            if st.button("❌ إغلاق" if st.session_state.language == 'ar' else "❌ Close"):
+                st.session_state.show_question_modal = False
+                st.session_state.selected_text = None
+                st.session_state.selected_segment_id = None
+                st.rerun()
+
+# --- Export Modal Function ---
+def show_export_modal():
+    """Display export modal with preview and options"""
+    
+    # Initialize Google Docs auth
+    if 'google_auth' not in st.session_state:
+        st.session_state.google_auth = GoogleDocsAuth()
+    
+    google_auth = st.session_state.google_auth
+    
+    # Filter segments from export timestamp
+    if not st.session_state.export_timestamp or not st.session_state.broadcast_segments:
+        st.session_state.show_export_modal = False
+        return
+    
+    # Get segments after export timestamp
+    filtered_segments = []
+    for segment in st.session_state.broadcast_segments:
+        if segment.get('start_ms', 0) >= st.session_state.export_timestamp:
+            filtered_segments.append(segment)
+    
+    # Sort by start time (oldest first for export)
+    filtered_segments.sort(key=lambda s: s.get('start_ms', 0))
+    
+    if not filtered_segments:
+        st.warning("لا توجد مقاطع جديدة للتصدير منذ الضغط على الزر" if st.session_state.language == 'ar' else "No new segments to export since button press")
+        if st.button("إغلاق" if st.session_state.language == 'ar' else "Close"):
+            st.session_state.show_export_modal = False
+            st.rerun()
+        return
+    
+    # Export preview
+    st.subheader("📋 معاينة التصدير" if st.session_state.language == 'ar' else "📋 Export Preview")
+    
+    export_time = datetime.fromtimestamp(st.session_state.export_timestamp / 1000)
+    st.info(f"{'المقاطع من وقت' if st.session_state.language == 'ar' else 'Segments from'}: {export_time.strftime('%H:%M:%S')}")
+    st.info(f"{'عدد المقاطع' if st.session_state.language == 'ar' else 'Number of segments'}: {len(filtered_segments)}")
+    
+    # Show preview of segments
+    with st.expander("معاينة المحتوى" if st.session_state.language == 'ar' else "Content Preview", expanded=False):
+        for i, segment in enumerate(filtered_segments[:3]):  # Show first 3 segments
+            start_time = segment.get('start_ms', 0) / 1000
+            end_time = segment.get('end_ms', 0) / 1000
+            st.markdown(f"**[{start_time:.2f}s → {end_time:.2f}s]**")
+            st.write(segment.get('text', '')[:100] + "..." if len(segment.get('text', '')) > 100 else segment.get('text', ''))
+            if i < 2 and i < len(filtered_segments) - 1:
+                st.divider()
+        
+        if len(filtered_segments) > 3:
+            st.caption(f"... {'و' if st.session_state.language == 'ar' else 'and'} {len(filtered_segments) - 3} {'مقاطع أخرى' if st.session_state.language == 'ar' else 'more segments'}")
+    
+    # Export options
+    col1, col2 = st.columns(2)
+    
+    with col1:
+        format_options = {
+            "📄 Word Document": "word",
+            "📝 Google Docs": "google_docs"
+        }
+        selected_format = st.selectbox(
+            "تنسيق التصدير" if st.session_state.language == 'ar' else "Export Format",
+            options=list(format_options.keys()),
+            index=0
+        )
+        st.session_state.export_format = format_options[selected_format]
+    
+    with col2:
+        include_summary = st.checkbox(
+            "تضمين الملخص" if st.session_state.language == 'ar' else "Include Summary",
+            value=True
+        )
+    
+    # Google Docs authentication section
+    if st.session_state.export_format == 'google_docs':
+        st.markdown("---")
+        if google_auth.is_authenticated():
+            st.success("✅ " + ("متصل بـ Google Docs" if st.session_state.language == 'ar' else "Connected to Google Docs"))
+            col_logout, col_info = st.columns([1, 2])
+            with col_logout:
+                if st.button("🚪 " + ("تسجيل خروج" if st.session_state.language == 'ar' else "Logout")):
+                    google_auth.logout()
+                    st.rerun()
+            with col_info:
+                st.caption("سيتم إنشاء المستند في حسابك على Google" if st.session_state.language == 'ar' else "Document will be created in your Google account")
+        else:
+            st.warning("🔐 " + ("يجب تسجيل الدخول إلى Google Docs أولاً" if st.session_state.language == 'ar' else "Please authenticate with Google Docs first"))
+            
+            # Handle OAuth callback
+            auth_code = st.query_params.get("code")
+            if auth_code:
+                success, message = google_auth.handle_auth_callback(auth_code)
+                if success:
+                    st.success(message)
+                    # Clear the code from URL
+                    st.query_params.clear()
+                    st.rerun()
+                else:
+                    st.error(message)
+            
+            # Show authentication button
+            auth_url, error = google_auth.get_auth_url()
+            if auth_url:
+                st.markdown(f"""
+                <a href="{auth_url}" target="_blank">
+                    <button style="background-color: #4285f4; color: white; padding: 10px 20px; border: none; border-radius: 5px; cursor: pointer;">
+                        🔗 {"تسجيل الدخول إلى Google" if st.session_state.language == 'ar' else "Sign in with Google"}
+                    </button>
+                </a>
+                """, unsafe_allow_html=True)
+                st.caption("سيتم فتح نافذة جديدة للمصادقة" if st.session_state.language == 'ar' else "A new window will open for authentication")
+            else:
+                st.error(f"خطأ في إعداد Google API: {error}" if st.session_state.language == 'ar' else f"Google API setup error: {error}")
+                st.info("يرجى إعداد GOOGLE_CLIENT_ID و GOOGLE_CLIENT_SECRET في متغيرات البيئة" if st.session_state.language == 'ar' else "Please set GOOGLE_CLIENT_ID and GOOGLE_CLIENT_SECRET environment variables")
+    
+    # Export buttons
+    col_export, col_cancel = st.columns(2)
+    
+    with col_export:
+        # Disable export button if Google Docs is selected but not authenticated
+        export_disabled = (st.session_state.export_format == 'google_docs' and not google_auth.is_authenticated())
+        export_button_text = "🚀 تصدير" if st.session_state.language == 'ar' else "🚀 Export"
+        
+        if st.button(export_button_text, type="primary", disabled=export_disabled):
+            perform_export(filtered_segments, include_summary, google_auth)
+    
+    with col_cancel:
+        if st.button("❌ إلغاء" if st.session_state.language == 'ar' else "❌ Cancel"):
+            st.session_state.show_export_modal = False
+            st.rerun()
+
+# --- Export Execution Function ---
+def perform_export(segments, include_summary=True, google_auth=None):
+    """Perform the actual export operation"""
+    
+    try:
+        # Initialize exporter
+        translator = get_translator()
+        exporter = BroadcastExporter(translator)
+        
+        # Create export configuration
+        config = ExportConfig(
+            export_timestamp=st.session_state.export_timestamp,
+            format_type=st.session_state.export_format,
+            include_summary=include_summary,
+            ui_language=st.session_state.language,
+            target_language=st.session_state.get('broadcast_translation_lang', 'ar')
+        )
+        
+        # Prepare export content
+        content = exporter.prepare_export_content(segments, config)
+        
+        # Show progress
+        with st.spinner("جاري التصدير..." if st.session_state.language == 'ar' else "Exporting..."):
+            # Perform export with fallback
+            result, error = exporter.export_with_fallback(content, config, google_auth)
+        
+        if result and not error:
+            if config.format_type == 'word':
+                # Provide download link for Word document
+                with open(result, 'rb') as file:
+                    st.download_button(
+                        label="📥 تحميل الملف" if st.session_state.language == 'ar' else "📥 Download File",
+                        data=file.read(),
+                        file_name=os.path.basename(result),
+                        mime="application/vnd.openxmlformats-officedocument.wordprocessingml.document"
+                    )
+                st.success("تم إنشاء الملف بنجاح!" if st.session_state.language == 'ar' else "File created successfully!")
+            else:
+                # Google Docs URL
+                st.success("تم إنشاء المستند بنجاح!" if st.session_state.language == 'ar' else "Document created successfully!")
+                st.markdown(f"[فتح في Google Docs]({result})" if st.session_state.language == 'ar' else f"[Open in Google Docs]({result})")
+        else:
+            st.error(f"خطأ في التصدير: {error}" if st.session_state.language == 'ar' else f"Export error: {error}")
+    
+    except Exception as e:
+        st.error(f"خطأ غير متوقع: {str(e)}" if st.session_state.language == 'ar' else f"Unexpected error: {str(e)}")
+    
+    # Close modal after export attempt
+    if st.button("إغلاق" if st.session_state.language == 'ar' else "Close"):
+        st.session_state.show_export_modal = False
+        st.rerun()
+
+# Note: external live slice helper removed to keep the app simple and fully local
+
+# --- Step 2: Review and Customize (REMOVED) ---
+# This section was removed as requested by user to simplify the interface
+# Results are now shown directly in show_processing_results() function
+
+def reset_session():
+    """Resets the session state by clearing specific keys and re-initializing."""
+    log_to_browser_console("--- INFO: Resetting session state. ---")
+    keys_to_clear = ['step', 'audio_data', 'transcription_data', 'edited_text', 'video_style', 'new_recording']
+    for key in keys_to_clear:
+        if key in st.session_state:
+            del st.session_state[key]
+    initialize_session_state()
+
+# --- Entry Point ---
+if __name__ == "__main__":
+    if check_api_key():
+        initialize_session_state()
+        main()
diff --git a/app_config.py b/app_config.py
new file mode 100644
index 0000000000000000000000000000000000000000..3ab022686cb79e95f5c756ba59528f1363888fcd
--- /dev/null
+++ b/app_config.py
@@ -0,0 +1,59 @@
+"""
+Configuration Module for SyncMaster
+إعدادات التطبيق الأساسية
+"""
+
+import os
+import logging
+
+# Configure logging
+logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
+
+class AppConfig:
+    """Configuration class for SyncMaster application"""
+    
+    # Server settings
+    STREAMLIT_PORT = int(os.getenv('STREAMLIT_PORT', 5050))
+    RECORDER_PORT = int(os.getenv('RECORDER_PORT', 5001))
+    
+    # Development vs Production
+    IS_PRODUCTION = os.getenv('SPACE_ID') is not None or os.getenv('RAILWAY_ENVIRONMENT') is not None
+    
+    # Host settings
+    if IS_PRODUCTION:
+        STREAMLIT_HOST = "0.0.0.0"
+        RECORDER_HOST = "0.0.0.0"
+    else:
+        STREAMLIT_HOST = "localhost"
+        RECORDER_HOST = "localhost"
+    
+    # Integration settings
+    USE_INTEGRATED_SERVER = IS_PRODUCTION or os.getenv('USE_INTEGRATED_SERVER', 'true').lower() == 'true'
+    
+    # Logging
+    LOG_LEVEL = os.getenv('LOG_LEVEL', 'INFO')
+    
+    @classmethod
+    def get_streamlit_url(cls):
+        """Get the Streamlit application URL"""
+        return f"http://{cls.STREAMLIT_HOST}:{cls.STREAMLIT_PORT}"
+    
+    @classmethod
+    def get_recorder_url(cls):
+        """Get the recorder server URL"""
+        return f"http://{cls.RECORDER_HOST}:{cls.RECORDER_PORT}"
+    
+    @classmethod
+    def log_config(cls):
+        """Log current configuration"""
+        logging.info("📋 SyncMaster Configuration:")
+        logging.info(f"   • Production Mode: {cls.IS_PRODUCTION}")
+        logging.info(f"   • Integrated Server: {cls.USE_INTEGRATED_SERVER}")
+        logging.info(f"   • Streamlit: {cls.get_streamlit_url()}")
+        logging.info(f"   • Recorder: {cls.get_recorder_url()}")
+
+# Initialize configuration
+config = AppConfig()
+
+if __name__ == "__main__":
+    config.log_config()
diff --git a/app_launcher.py b/app_launcher.py
new file mode 100644
index 0000000000000000000000000000000000000000..03fd64be88e04d02fa22313a58fc2453a2a70ef8
--- /dev/null
+++ b/app_launcher.py
@@ -0,0 +1,43 @@
+#!/usr/bin/env python3
+"""
+App Launcher - يشغل التطبيق مع الخادم المدمج
+"""
+
+import os
+import sys
+
+# Add current directory to path
+sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
+
+# Force start integrated server
+print("🚀 Starting integrated recorder server...")
+try:
+    from integrated_server import integrated_server
+    
+    # Force start the server
+    if not integrated_server.is_running:
+        result = integrated_server.start_recorder_server()
+        if result:
+            print("✅ Recorder server started successfully")
+        else:
+            print("⚠️ Warning: Could not start recorder server")
+    else:
+        print("✅ Recorder server already running")
+        
+except Exception as e:
+    print(f"❌ Error starting recorder server: {e}")
+
+print("📱 Loading main application...")
+
+# Execute the app.py content directly
+if __name__ == "__main__":
+    # If running directly, execute app.py
+    exec(open('app.py').read())
+else:
+    # If imported by Streamlit, import and execute
+    try:
+        exec(open('app.py').read())
+        print("✅ Application loaded successfully")
+    except Exception as e:
+        print(f"❌ Error loading application: {e}")
+        raise
diff --git a/audio_processor.py b/audio_processor.py
new file mode 100644
index 0000000000000000000000000000000000000000..2d99f6a89f0ba04a76ba9fc7b5a409ce96f6672b
--- /dev/null
+++ b/audio_processor.py
@@ -0,0 +1,391 @@
+# audio_processor.py - Enhanced with AI Translation Support
+
+import os
+from dotenv import load_dotenv
+import tempfile
+from typing import List, Dict, Optional, Tuple
+import json
+import traceback
+
+# --- DEFINITIVE NUMBA FIX ---
+# This MUST be done BEFORE importing librosa
+os.environ["NUMBA_CACHE_DIR"] = "/tmp"
+
+# Now, import librosa safely
+import librosa
+# --- END OF FIX ---
+
+import google.generativeai as genai
+from translator import AITranslator
+import requests
+from google.api_core import exceptions as google_exceptions
+
+class AudioProcessor:
+    def __init__(self):
+        self.translator = None
+        self.init_error = None
+        self._initialize_translator()
+
+    def _initialize_translator(self):
+        """Initialize AI translator for multi-language support"""
+        try:
+            self.translator = AITranslator()
+            if self.translator.init_error:
+                print(f"--- WARNING: Translator has initialization error: {self.translator.init_error} ---")
+        except Exception as e:
+            print(f"--- WARNING: Translator initialization failed: {str(e)} ---")
+            self.translator = None
+    
+    def transcribe_audio(self, audio_file_path: str) -> Tuple[Optional[str], Optional[str], Optional[str]]:
+        """
+        Transcribes audio. Returns (text, error_message).
+        Uses Gemini first (if available), then falls back to Groq Whisper.
+        """
+        if not os.path.exists(audio_file_path):
+            return None, f"--- ERROR: Audio file for transcription not found at: {audio_file_path} ---", None
+
+        # Try Gemini first if available
+        gemini_err = None
+        try:
+            if self.translator and self.translator.model:
+                audio_file = genai.upload_file(path=audio_file_path)
+                prompt = (
+                    "You are an ASR system. Transcribe the audio accurately. "
+                    "Auto-detect the spoken language and return ONLY the verbatim transcript in that same language. "
+                    "Do not translate. Do not add labels or timestamps."
+                )
+                response = self.translator.model.generate_content([prompt, audio_file])
+                if response and hasattr(response, 'text') and response.text:
+                    return response.text.strip(), None, "Gemini"
+                else:
+                    gemini_err = "--- WARNING: Gemini returned an empty response for transcription. ---"
+        except google_exceptions.ResourceExhausted:
+            gemini_err = "--- QUOTA ERROR: You have exceeded the daily free usage limit for the AI service. Please wait for your quota to reset (usually within 24 hours) or upgrade your Google AI plan. ---"
+        except Exception:
+            gemini_err = f"--- FATAL ERROR during Gemini transcription: {traceback.format_exc()} ---"
+
+        # Fallback: Groq Whisper
+        text, groq_err = self._transcribe_with_groq(audio_file_path)
+        if text:
+            return text, None, "Groq Whisper"
+
+        # If all failed
+        combined_err = groq_err or gemini_err or "--- ERROR: No transcription provider available. ---"
+        return None, combined_err, None
+
+    def _transcribe_with_groq(self, audio_file_path: str) -> Tuple[Optional[str], Optional[str]]:
+        """Transcribe using Groq Whisper-compatible endpoint. Returns (text, error)."""
+        try:
+            load_dotenv()
+            groq_key = os.getenv("GROQ_API_KEY")
+            if not groq_key:
+                return None, "--- ERROR: GROQ_API_KEY not set. ---"
+            model = os.getenv("GROQ_WHISPER_MODEL", "whisper-large-v3")
+            url = "https://api.groq.com/openai/v1/audio/transcriptions"
+            headers = {"Authorization": f"Bearer {groq_key}"}
+            # Guess mime type by extension
+            filename = os.path.basename(audio_file_path)
+            mime = "audio/wav"
+            if filename.lower().endswith(".mp3"):
+                mime = "audio/mpeg"
+            elif filename.lower().endswith(".m4a"):
+                mime = "audio/mp4"
+            data = {
+                "model": model,
+                "response_format": "json",
+            }
+            with open(audio_file_path, "rb") as f:
+                files = {"file": (filename, f, mime)}
+                resp = requests.post(url, headers=headers, files=files, data=data, timeout=60)
+            if not resp.ok:
+                try:
+                    err = resp.json()
+                except Exception:
+                    err = {"error": resp.text}
+                return None, f"--- ERROR: Groq transcription error {resp.status_code}: {err} ---"
+            out = resp.json()
+            text = out.get("text")
+            if not text:
+                return None, "--- ERROR: Groq transcription returned no text. ---"
+            return text.strip(), None
+        except Exception:
+            return None, f"--- FATAL ERROR during Groq transcription: {traceback.format_exc()} ---"
+
+    def get_audio_duration(self, audio_file_path: str) -> Tuple[Optional[float], Optional[str]]:
+        """
+        Gets audio duration. Returns (duration, error_message).
+        """
+        try:
+            if not os.path.exists(audio_file_path):
+                return None, f"--- ERROR: Audio file for duration not found at: {audio_file_path} ---"
+            
+            duration = librosa.get_duration(path=audio_file_path)
+            if duration is None or duration < 0.1:
+                return None, f"--- ERROR: librosa returned an invalid duration: {duration}s ---"
+            return duration, None
+        except Exception as e:
+            error_msg = f"--- FATAL ERROR getting audio duration with librosa: {traceback.format_exc()} ---"
+            return None, error_msg
+    
+    def get_word_timestamps(self, audio_file_path: str) -> Tuple[List[Dict], List[str], Optional[str]]:
+        """
+        Generates timestamps. Returns (timestamps, log_messages).
+        """
+        logs = ["--- INFO: Starting get_word_timestamps... ---"]
+        
+        transcription, error, model_used = self.transcribe_audio(audio_file_path)
+        if error:
+            logs.append(error)
+            return [], logs, model_used
+        logs.append(f"--- DEBUG: Transcription successful. Text: '{transcription[:50]}...'")
+
+        audio_duration, error = self.get_audio_duration(audio_file_path)
+        if error:
+            logs.append(error)
+            return [], logs, model_used
+        logs.append(f"--- DEBUG: Audio duration successful. Duration: {audio_duration:.2f}s")
+        
+        words = transcription.split()
+        if not words:
+            logs.append("--- WARNING: Transcription resulted in zero words. ---")
+            return [], logs, model_used
+
+        logs.append(f"--- INFO: Distributing {len(words)} words across the duration. ---")
+        word_timestamps = []
+        total_words = len(words)
+        usable_duration = max(0, audio_duration - 1.0)
+
+        for i, word in enumerate(words):
+            start_time = 0.5 + (i * (usable_duration / total_words))
+            end_time = 0.5 + ((i + 1) * (usable_duration / total_words))
+            word_timestamps.append({'word': word.strip(), 'start': round(start_time, 3), 'end': round(end_time, 3)})
+
+        logs.append(f"--- SUCCESS: Generated {len(word_timestamps)} word timestamps. ---")
+        return word_timestamps, logs, model_used
+    
+    def get_word_timestamps_with_translation(self, audio_file_path: str, target_language: str = 'ar') -> Tuple[Dict, List[str]]:
+        """
+        Enhanced function that provides both transcription and translation
+        
+        Args:
+            audio_file_path: Path to audio file
+            target_language: Target language for translation ('ar' for Arabic)
+        
+        Returns:
+            Tuple of (result_dict, log_messages)
+            result_dict contains: {
+                'original_text': str,
+                'translated_text': str,
+                'word_timestamps': List[Dict],
+                'translated_timestamps': List[Dict],
+                'language_detected': str,
+                'target_language': str
+            }
+        """
+        logs = ["--- INFO: Starting enhanced transcription with translation... ---"]
+        
+        # Get original transcription and timestamps
+        word_timestamps, transcription_logs, model_used = self.get_word_timestamps(audio_file_path)
+        logs.extend(transcription_logs)
+
+        if not word_timestamps:
+            # Fallback: try plain transcription (Gemini → Groq) then synthesize timestamps
+            logs.append("--- INFO: Falling back to plain transcription because timestamps are empty. ---")
+            plain_text, err, model_used_fallback = self.transcribe_audio(audio_file_path)
+            if model_used_fallback:
+                model_used = model_used_fallback
+            if not plain_text:
+                logs.append(err or "--- ERROR: Plain transcription fallback failed ---")
+                return {}, logs
+            logs.append(f"--- SUCCESS: Plain transcription fallback succeeded. Model: {model_used}")
+            # Synthesize naive word-level timestamps across duration
+            try:
+                duration, derr = self.get_audio_duration(audio_file_path)
+                if derr:
+                    logs.append(derr)
+                    duration = 0.0
+                words = plain_text.split()
+                if not words:
+                    logs.append("--- WARNING: Fallback transcription produced zero words. ---")
+                    return {}, logs
+                if duration and duration > 0.1:
+                    usable_duration = max(0, duration - 1.0)
+                    start_offset = 0.5
+                else:
+                    # If duration not available, assume ~0.4s per word
+                    usable_duration = 0.4 * max(1, len(words))
+                    start_offset = 0.0
+                word_timestamps = []
+                total_words = len(words)
+                for i, w in enumerate(words):
+                    start_time = start_offset + (i * (usable_duration / total_words))
+                    end_time = start_offset + ((i + 1) * (usable_duration / total_words))
+                    word_timestamps.append({'word': w.strip(), 'start': round(start_time, 3), 'end': round(end_time, 3)})
+                logs.append(f"--- INFO: Synthesized {len(word_timestamps)} timestamps from fallback transcript. ---")
+            except Exception:
+                logs.append(f"--- FATAL ERROR synthesizing timestamps: {traceback.format_exc()} ---")
+                return {}, logs
+
+        # Extract original text
+        original_text = " ".join([d['word'] for d in word_timestamps])
+        logs.append(f"--- INFO: Original transcription: '{original_text[:50]}...' ---")
+
+        # Initialize result dictionary
+        result = {
+            'original_text': original_text,
+            'translated_text': '',
+            'word_timestamps': word_timestamps,
+            'translated_timestamps': [],
+            'language_detected': 'unknown',
+            'target_language': target_language,
+            'translation_success': False,
+            'transcription_model': model_used
+        }
+        
+        # Check if translator is available
+        if not self.translator:
+            logs.append("--- WARNING: Translator not available, returning original text only ---")
+            result['translated_text'] = original_text
+            return result, logs
+        
+        try:
+            # Translate the text
+            translated_text, translation_error = self.translator.translate_text(
+                original_text, 
+                target_language=target_language
+            )
+            
+            if translated_text:
+                result['translated_text'] = translated_text
+                result['translation_success'] = True
+                logs.append(f"--- SUCCESS: Translation completed: '{translated_text[:50]}...' ---")
+                
+                # Create translated timestamps by mapping words
+                translated_timestamps = self._create_translated_timestamps(
+                    word_timestamps, 
+                    original_text, 
+                    translated_text
+                )
+                result['translated_timestamps'] = translated_timestamps
+                logs.append(f"--- INFO: Created {len(translated_timestamps)} translated timestamps ---")
+                
+            else:
+                logs.append(f"--- ERROR: Translation failed: {translation_error} ---")
+                result['translated_text'] = original_text  # Fallback to original
+                result['translated_timestamps'] = word_timestamps  # Use original timestamps
+                
+        except Exception as e:
+            error_msg = f"--- FATAL ERROR during translation process: {traceback.format_exc()} ---"
+            logs.append(error_msg)
+            result['translated_text'] = original_text  # Fallback
+            result['translated_timestamps'] = word_timestamps
+        
+        return result, logs
+    
+    def _create_translated_timestamps(self, original_timestamps: List[Dict], original_text: str, translated_text: str) -> List[Dict]:
+        """
+        Create timestamps for translated text by proportional mapping
+        
+        Args:
+            original_timestamps: Original word timestamps
+            original_text: Original transcribed text
+            translated_text: Translated text
+        
+        Returns:
+            List of translated word timestamps
+        """
+        try:
+            translated_words = translated_text.split()
+            if not translated_words:
+                return []
+            
+            # Get total duration from original timestamps
+            if not original_timestamps:
+                return []
+            
+            start_time = original_timestamps[0]['start']
+            end_time = original_timestamps[-1]['end']
+            total_duration = end_time - start_time
+            
+            # Create proportional timestamps for translated words
+            translated_timestamps = []
+            word_count = len(translated_words)
+            
+            for i, word in enumerate(translated_words):
+                # Calculate proportional timing
+                word_start = start_time + (i * total_duration / word_count)
+                word_end = start_time + ((i + 1) * total_duration / word_count)
+                
+                translated_timestamps.append({
+                    'word': word.strip(),
+                    'start': round(word_start, 3),
+                    'end': round(word_end, 3)
+                })
+            
+            return translated_timestamps
+            
+        except Exception as e:
+            print(f"--- ERROR creating translated timestamps: {str(e)} ---")
+            return []
+    
+    def batch_translate_transcription(self, audio_file_path: str, target_languages: List[str]) -> Tuple[Dict, List[str]]:
+        """
+        Transcribe audio and translate to multiple languages
+        
+        Args:
+            audio_file_path: Path to audio file
+            target_languages: List of target language codes
+        
+        Returns:
+            Tuple of (results_dict, log_messages)
+        """
+        logs = ["--- INFO: Starting batch translation process... ---"]
+        
+        # Get original transcription
+        word_timestamps, transcription_logs = self.get_word_timestamps(audio_file_path)
+        logs.extend(transcription_logs)
+        
+        if not word_timestamps:
+            return {}, logs
+        
+        original_text = " ".join([d['word'] for d in word_timestamps])
+        
+        # Initialize results
+        results = {
+            'original': {
+                'text': original_text,
+                'timestamps': word_timestamps,
+                'language': 'detected'
+            },
+            'translations': {}
+        }
+        
+        # Translate to each target language
+        if self.translator:
+            for lang_code in target_languages:
+                try:
+                    translated_text, error = self.translator.translate_text(original_text, lang_code)
+                    if translated_text:
+                        translated_timestamps = self._create_translated_timestamps(
+                            word_timestamps, original_text, translated_text
+                        )
+                        results['translations'][lang_code] = {
+                            'text': translated_text,
+                            'timestamps': translated_timestamps,
+                            'success': True
+                        }
+                        logs.append(f"--- SUCCESS: Translation to {lang_code} completed ---")
+                    else:
+                        results['translations'][lang_code] = {
+                            'text': original_text,
+                            'timestamps': word_timestamps,
+                            'success': False,
+                            'error': error
+                        }
+                        logs.append(f"--- ERROR: Translation to {lang_code} failed: {error} ---")
+                except Exception as e:
+                    logs.append(f"--- FATAL ERROR translating to {lang_code}: {str(e)} ---")
+        else:
+            logs.append("--- WARNING: Translator not available for batch translation ---")
+        
+        return results, logs
diff --git a/check_credentials.py b/check_credentials.py
new file mode 100644
index 0000000000000000000000000000000000000000..bc67d12d42f4fec08135a9f122ab509100b2e28a
--- /dev/null
+++ b/check_credentials.py
@@ -0,0 +1,118 @@
+#!/usr/bin/env python3
+# check_credentials.py - أداة فحص ملف بيانات الاعتماد
+
+import os
+import json
+
+def check_credentials():
+    """فحص ملف credentials.json والتأكد من صحته"""
+    
+    print("🔍 فحص ملف بيانات الاعتماد...")
+    print("=" * 50)
+    
+    # فحص وجود الملف
+    if not os.path.exists('credentials.json'):
+        print("❌ ملف credentials.json غير موجود!")
+        print("💡 تأكد من وضع الملف في نفس مجلد app.py")
+        return False
+    
+    print("✅ ملف credentials.json موجود")
+    
+    # فحص محتوى الملف
+    try:
+        with open('credentials.json', 'r') as f:
+            creds = json.load(f)
+        
+        print("✅ الملف يحتوي على JSON صحيح")
+        
+        # فحص البنية
+        if 'installed' not in creds:
+            print("❌ الملف لا يحتوي على قسم 'installed'")
+            return False
+        
+        installed = creds['installed']
+        
+        # فحص الحقول المطلوبة
+        required_fields = ['client_id', 'client_secret', 'auth_uri', 'token_uri']
+        missing_fields = []
+        
+        for field in required_fields:
+            if field not in installed:
+                missing_fields.append(field)
+        
+        if missing_fields:
+            print(f"❌ الحقول المفقودة: {', '.join(missing_fields)}")
+            return False
+        
+        # فحص إذا كانت البيانات وهمية
+        client_id = installed.get('client_id', '')
+        client_secret = installed.get('client_secret', '')
+        
+        if client_id.startswith('YOUR_CLIENT_ID'):
+            print("❌ client_id لا يزال يحتوي على القيمة الافتراضية!")
+            print("💡 يجب استبدال الملف بملف حقيقي من Google Cloud Console")
+            return False
+        
+        if client_secret.startswith('YOUR_CLIENT_SECRET'):
+            print("❌ client_secret لا يزال يحتوي على القيمة الافتراضية!")
+            print("💡 يجب استبدال الملف بملف حقيقي من Google Cloud Console")
+            return False
+        
+        print("✅ جميع الحقول المطلوبة موجودة")
+        print(f"✅ Client ID: {client_id[:20]}...")
+        print(f"✅ Project ID: {installed.get('project_id', 'غير محدد')}")
+        
+        return True
+        
+    except json.JSONDecodeError:
+        print("❌ الملف لا يحتوي على JSON صحيح!")
+        return False
+    except Exception as e:
+        print(f"❌ خطأ في قراءة الملف: {e}")
+        return False
+
+def check_token():
+    """فحص ملف token.json إذا كان موجوداً"""
+    
+    print("\n🔍 فحص ملف المصادقة...")
+    print("=" * 50)
+    
+    if os.path.exists('token.json'):
+        print("✅ ملف token.json موجود")
+        try:
+            with open('token.json', 'r') as f:
+                token = json.load(f)
+            
+            if 'token' in token:
+                print("✅ يحتوي على رمز مصادقة")
+            
+            if 'refresh_token' in token:
+                print("✅ يحتوي على رمز التحديث")
+            
+            if 'expiry' in token:
+                print(f"⏰ تاريخ انتهاء الصلاحية: {token['expiry']}")
+            
+        except Exception as e:
+            print(f"⚠️ مشكلة في ملف token.json: {e}")
+            print("💡 يمكنك حذف الملف وإعادة المصادقة")
+    else:
+        print("ℹ️ ملف token.json غير موجود (طبيعي في أول استخدام)")
+
+def main():
+    print("🚀 أداة فحص بيانات الاعتماد لـ Google Docs")
+    print("=" * 60)
+    
+    creds_ok = check_credentials()
+    check_token()
+    
+    print("\n" + "=" * 60)
+    
+    if creds_ok:
+        print("🎉 ملف بيانات الاعتماد صحيح!")
+        print("💡 يمكنك الآن استخدام زر التصدير")
+    else:
+        print("❌ يجب إصلاح ملف بيانات الاعتماد أولاً")
+        print("📋 راجع ملف GOOGLE_SETUP_SIMPLE.md للحصول على التعليمات")
+
+if __name__ == "__main__":
+    main()
\ No newline at end of file
diff --git a/comprehensive_test.py b/comprehensive_test.py
new file mode 100644
index 0000000000000000000000000000000000000000..1fc1143d7e4b6d5ccd82cd4ec5e54e1d57439b69
--- /dev/null
+++ b/comprehensive_test.py
@@ -0,0 +1,225 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+اختبار شامل للتحقق من إصلاح جميع المشاكل
+"""
+
+import requests
+import json
+import time
+
+def test_server_health():
+    """اختبار صحة الخادم"""
+    print("🏥 اختبار صحة الخادم...")
+    
+    try:
+        response = requests.get('http://localhost:5001/record', timeout=5)
+        if response.status_code == 200:
+            data = response.json()
+            print(f"✅ الخادم يعمل: {data.get('message')}")
+            return True
+        else:
+            print(f"❌ مشكلة في الخادم: {response.status_code}")
+            return False
+    except Exception as e:
+        print(f"❌ لا يمكن الوصول للخادم: {e}")
+        return False
+
+def test_cors_headers():
+    """اختبار CORS headers"""
+    print("\n🔧 اختبار CORS headers...")
+    
+    try:
+        # اختبار OPTIONS request
+        response = requests.options('http://localhost:5001/summarize', timeout=5)
+        
+        print(f"Status Code: {response.status_code}")
+        
+        # فحص CORS headers
+        cors_origin = response.headers.get('Access-Control-Allow-Origin')
+        cors_methods = response.headers.get('Access-Control-Allow-Methods')
+        cors_headers = response.headers.get('Access-Control-Allow-Headers')
+        
+        print(f"CORS Origin: '{cors_origin}'")
+        print(f"CORS Methods: '{cors_methods}'")
+        print(f"CORS Headers: '{cors_headers}'")
+        
+        # التحقق من عدم وجود قيم مكررة
+        if cors_origin and ',' in cors_origin and cors_origin.count('*') > 1:
+            print("❌ مشكلة: CORS Origin يحتوي على قيم مكررة!")
+            return False
+        elif cors_origin == '*':
+            print("✅ CORS Origin صحيح")
+            return True
+        else:
+            print(f"⚠️ CORS Origin غير متوقع: {cors_origin}")
+            return False
+            
+    except Exception as e:
+        print(f"❌ خطأ في اختبار CORS: {e}")
+        return False
+
+def test_summarization():
+    """اختبار وظيفة التلخيص"""
+    print("\n🤖 اختبار وظيفة التلخيص...")
+    
+    test_data = {
+        "text": "Hello, how are you? What are you doing today? Tell me about your work and your plans.",
+        "language": "arabic",
+        "type": "full"
+    }
+    
+    try:
+        response = requests.post(
+            'http://localhost:5001/summarize',
+            json=test_data,
+            headers={'Content-Type': 'application/json'},
+            timeout=30
+        )
+        
+        print(f"Status Code: {response.status_code}")
+        
+        if response.status_code == 200:
+            data = response.json()
+            if data.get('success'):
+                print("✅ التلخيص نجح!")
+                summary = data.get('summary', '')
+                print(f"الملخص: {summary[:100]}...")
+                return True
+            else:
+                print(f"❌ فشل التلخيص: {data.get('error')}")
+                return False
+        else:
+            print(f"❌ خطأ HTTP: {response.status_code}")
+            print(f"الرد: {response.text}")
+            return False
+            
+    except Exception as e:
+        print(f"❌ خطأ في اختبار التلخيص: {e}")
+        return False
+
+def test_javascript_syntax():
+    """اختبار صيغة JavaScript"""
+    print("\n📝 اختبار صيغة JavaScript...")
+    
+    try:
+        with open('templates/recorder.html', 'r', encoding='utf-8') as f:
+            content = f.read()
+        
+        # فحص بسيط للأقواس
+        js_start = content.find('<script>')
+        js_end = content.find('</script>')
+        
+        if js_start == -1 or js_end == -1:
+            print("❌ لا يمكن العثور على JavaScript")
+            return False
+        
+        js_content = content[js_start:js_end]
+        
+        # عد الأقواس
+        open_braces = js_content.count('{')
+        close_braces = js_content.count('}')
+        
+        print(f"أقواس فتح: {open_braces}")
+        print(f"أقواس إغلاق: {close_braces}")
+        
+        if open_braces == close_braces:
+            print("✅ الأقواس متوازنة")
+            
+            # فحص للكلمات المفتاحية الأساسية
+            if 'function' in js_content and 'async function' in js_content:
+                print("✅ الدوال موجودة")
+                return True
+            else:
+                print("⚠️ لا يمكن العثور على الدوال")
+                return False
+        else:
+            print(f"❌ الأقواس غير متوازنة! الفرق: {open_braces - close_braces}")
+            return False
+            
+    except Exception as e:
+        print(f"❌ خطأ في فحص JavaScript: {e}")
+        return False
+
+def test_translation_endpoints():
+    """اختبار endpoints الترجمة"""
+    print("\n🌐 اختبار endpoints الترجمة...")
+    
+    try:
+        # اختبار قائمة اللغات
+        response = requests.get('http://localhost:5001/languages', timeout=5)
+        if response.status_code == 200:
+            print("✅ endpoint اللغات يعمل")
+        else:
+            print(f"⚠️ مشكلة في endpoint اللغات: {response.status_code}")
+        
+        # اختبار UI translations
+        response = requests.get('http://localhost:5001/ui-translations/en', timeout=5)
+        if response.status_code == 200:
+            print("✅ endpoint UI translations يعمل")
+        else:
+            print(f"⚠️ مشكلة في endpoint UI translations: {response.status_code}")
+        
+        return True
+        
+    except Exception as e:
+        print(f"❌ خطأ في اختبار endpoints الترجمة: {e}")
+        return False
+
+def comprehensive_test():
+    """اختبار شامل لجميع الوظائف"""
+    print("🚀 بدء الاختبار الشامل")
+    print("=" * 60)
+    
+    tests = [
+        ("صحة الخادم", test_server_health),
+        ("CORS Headers", test_cors_headers),
+        ("وظيفة التلخيص", test_summarization),
+        ("صيغة JavaScript", test_javascript_syntax),
+        ("endpoints الترجمة", test_translation_endpoints)
+    ]
+    
+    results = []
+    
+    for test_name, test_func in tests:
+        print(f"\n🧪 اختبار: {test_name}")
+        print("-" * 40)
+        
+        try:
+            result = test_func()
+            results.append((test_name, result))
+            
+            if result:
+                print(f"✅ {test_name}: نجح")
+            else:
+                print(f"❌ {test_name}: فشل")
+                
+        except Exception as e:
+            print(f"❌ {test_name}: خطأ - {e}")
+            results.append((test_name, False))
+    
+    # النتائج النهائية
+    print("\n" + "=" * 60)
+    print("📊 ملخص نتائج الاختبار:")
+    print("=" * 60)
+    
+    passed = 0
+    total = len(results)
+    
+    for test_name, result in results:
+        status = "✅ نجح" if result else "❌ فشل"
+        print(f"  {test_name}: {status}")
+        if result:
+            passed += 1
+    
+    print(f"\nالنتيجة النهائية: {passed}/{total} اختبارات نجحت")
+    
+    if passed == total:
+        print("🎉 جميع الاختبارات نجحت! النظام يعمل بشكل مثالي")
+        return True
+    else:
+        print(f"⚠️ {total - passed} اختبارات فشلت - هناك مشاكل تحتاج إصلاح")
+        return False
+
+if __name__ == "__main__":
+    comprehensive_test()
diff --git a/credentials.json b/credentials.json
new file mode 100644
index 0000000000000000000000000000000000000000..92c38d64c9875abdc3923836f5043452f06cb4cd
--- /dev/null
+++ b/credentials.json
@@ -0,0 +1,16 @@
+{
+  "web": {
+    "client_id": "739771741359-gk2mkvimn063a2msd6hmkkksn17iamre.apps.googleusercontent.com",
+    "project_id": "syncmaster-export",
+    "auth_uri": "https://accounts.google.com/o/oauth2/auth",
+    "token_uri": "https://oauth2.googleapis.com/token",
+    "auth_provider_x509_cert_url": "https://www.googleapis.com/oauth2/v1/certs",
+    "client_secret": "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",
+    "redirect_uris": [
+      "http://localhost:8502",
+      "http://localhost:8502/",
+      "http://127.0.0.1:8502",
+      "http://127.0.0.1:8502/"
+    ]
+  }
+}
\ No newline at end of file
diff --git a/custom_components/st-audiorec/.streamlit/config.toml b/custom_components/st-audiorec/.streamlit/config.toml
new file mode 100644
index 0000000000000000000000000000000000000000..bf0031e4c869a683a873f56fb0d9f57610c77f69
--- /dev/null
+++ b/custom_components/st-audiorec/.streamlit/config.toml
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:8eec7cce049f088766524596c7dd6229756df0d6331c8cfab099df7d2ebc9d5d
+size 662
diff --git a/custom_components/st-audiorec/LICENCE b/custom_components/st-audiorec/LICENCE
new file mode 100644
index 0000000000000000000000000000000000000000..d650b45afd250d7fccb04e043c308e51e1495ad3
--- /dev/null
+++ b/custom_components/st-audiorec/LICENCE
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:784d3a6fdb08d429f5de43125e9962e780d34cdf9b5f14b681c9a2d8e905bfec
+size 1080
diff --git a/custom_components/st-audiorec/README.md b/custom_components/st-audiorec/README.md
new file mode 100644
index 0000000000000000000000000000000000000000..9d816a0bbc2b4ab53303cdf0b9c4885941b48e9c
--- /dev/null
+++ b/custom_components/st-audiorec/README.md
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:54716e3eaf4e6047fb50d99176bd2c6b24124b978af2eb30e44a8c6a74cdb9c0
+size 1993
diff --git a/custom_components/st-audiorec/demo.py b/custom_components/st-audiorec/demo.py
new file mode 100644
index 0000000000000000000000000000000000000000..584c34c7d809b1b921b48a21f5a1f767d8d44edd
--- /dev/null
+++ b/custom_components/st-audiorec/demo.py
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:efbe93ef9297821f3a1e1f1bdf0f75fb4a4351b154439d01d9ea0cbd49b996b8
+size 2430
diff --git a/custom_components/st-audiorec/setup.py b/custom_components/st-audiorec/setup.py
new file mode 100644
index 0000000000000000000000000000000000000000..a44c81b588130077a63244c4b34e9bbff9ed35ac
--- /dev/null
+++ b/custom_components/st-audiorec/setup.py
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:492fd555416f2807df31dc43e10b9d3cd8d5c18636c586c7f37988e1d8b854c1
+size 786
diff --git a/custom_components/st-audiorec/st_audiorec/__init__.py b/custom_components/st-audiorec/st_audiorec/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..9402f8d3e622f6dc0b8b4da5e8bbb0d4bd7e221d
--- /dev/null
+++ b/custom_components/st-audiorec/st_audiorec/__init__.py
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:3f714847f1f4a2490e5dd80bc1eeb7b6fcb7850a3e682b491a28dd30fead486c
+size 1622
diff --git a/custom_components/st-audiorec/st_audiorec/frontend/.prettierrc b/custom_components/st-audiorec/st_audiorec/frontend/.prettierrc
new file mode 100644
index 0000000000000000000000000000000000000000..9faab20a7a4c6ca95e11bdd12ba05e2d37b0299a
--- /dev/null
+++ b/custom_components/st-audiorec/st_audiorec/frontend/.prettierrc
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:3375a44313ae0b6753868a7ae00dc03f618b0c23785b15980482e6b9457ca0f8
+size 72
diff --git a/custom_components/st-audiorec/st_audiorec/frontend/build/asset-manifest.json b/custom_components/st-audiorec/st_audiorec/frontend/build/asset-manifest.json
new file mode 100644
index 0000000000000000000000000000000000000000..f433c00561348f5e2317797dc42312332a33c22f
--- /dev/null
+++ b/custom_components/st-audiorec/st_audiorec/frontend/build/asset-manifest.json
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:d923ea03d2475f02335299c4a15a1ca84291e9cbbcd558e6abdb318abe5ccc6f
+size 859
diff --git a/custom_components/st-audiorec/st_audiorec/frontend/build/bootstrap.min.css b/custom_components/st-audiorec/st_audiorec/frontend/build/bootstrap.min.css
new file mode 100644
index 0000000000000000000000000000000000000000..03e07abe9974c8069c536b70ba053cfca55fdb96
--- /dev/null
+++ b/custom_components/st-audiorec/st_audiorec/frontend/build/bootstrap.min.css
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:f396767523d7b7ce621d90aae93cbbd7a516275898efd19020be38aa5ae85d5c
+size 206913
diff --git a/custom_components/st-audiorec/st_audiorec/frontend/build/index.html b/custom_components/st-audiorec/st_audiorec/frontend/build/index.html
new file mode 100644
index 0000000000000000000000000000000000000000..0793473a9ca75ad29b054218c38b77f8e2e40eea
--- /dev/null
+++ b/custom_components/st-audiorec/st_audiorec/frontend/build/index.html
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:e007dc7fb036886292b996d076d57c6eb6eedf32b8e2c5489ad9f6d29d59f088
+size 2175
diff --git a/custom_components/st-audiorec/st_audiorec/frontend/build/precache-manifest.30096e2fd9f149157a833e729e772f72.js b/custom_components/st-audiorec/st_audiorec/frontend/build/precache-manifest.30096e2fd9f149157a833e729e772f72.js
new file mode 100644
index 0000000000000000000000000000000000000000..6e7f2579d2b9e09366cdc7b2e934e5016c19306b
--- /dev/null
+++ b/custom_components/st-audiorec/st_audiorec/frontend/build/precache-manifest.30096e2fd9f149157a833e729e772f72.js
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:e318206d88822468d480fd4047df1439dd2dadb500d846636314b39afabb8af4
+size 564
diff --git a/custom_components/st-audiorec/st_audiorec/frontend/build/service-worker.js b/custom_components/st-audiorec/st_audiorec/frontend/build/service-worker.js
new file mode 100644
index 0000000000000000000000000000000000000000..e345d9697d7cf95ac847063bb4827c81c6474ad7
--- /dev/null
+++ b/custom_components/st-audiorec/st_audiorec/frontend/build/service-worker.js
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:8243bfeb139d7acdf475a748daa48068cde6e5d62a4c2242326e3d6bbfbc6d78
+size 1183
diff --git a/custom_components/st-audiorec/st_audiorec/frontend/build/static/js/2.ca2bba73.chunk.js b/custom_components/st-audiorec/st_audiorec/frontend/build/static/js/2.ca2bba73.chunk.js
new file mode 100644
index 0000000000000000000000000000000000000000..bec1f4b3ccfdd683b57745bc8880b60f847cf29e
--- /dev/null
+++ b/custom_components/st-audiorec/st_audiorec/frontend/build/static/js/2.ca2bba73.chunk.js
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:8810a6d23c8292fa11953f5c2c762e6bd658f11316f12879d0a6d4e05f7df5a1
+size 465885
diff --git a/custom_components/st-audiorec/st_audiorec/frontend/build/static/js/2.ca2bba73.chunk.js.LICENSE.txt b/custom_components/st-audiorec/st_audiorec/frontend/build/static/js/2.ca2bba73.chunk.js.LICENSE.txt
new file mode 100644
index 0000000000000000000000000000000000000000..f385c58aa826c56e067878fa821c9cdeda28c776
--- /dev/null
+++ b/custom_components/st-audiorec/st_audiorec/frontend/build/static/js/2.ca2bba73.chunk.js.LICENSE.txt
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:83bbf722e5b20cfb2920ac1c234ffa5ccde3baa9d8d5a87b4cc90f81ef649a47
+size 1653
diff --git a/custom_components/st-audiorec/st_audiorec/frontend/build/static/js/2.ca2bba73.chunk.js.map b/custom_components/st-audiorec/st_audiorec/frontend/build/static/js/2.ca2bba73.chunk.js.map
new file mode 100644
index 0000000000000000000000000000000000000000..320ca4219c7b67a7b9cf34ae46459b7f72e33635
--- /dev/null
+++ b/custom_components/st-audiorec/st_audiorec/frontend/build/static/js/2.ca2bba73.chunk.js.map
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:25cecefabe1287205f5f99bfd33159566c8d97bc56dadba39d70fcaf160c7998
+size 1634044
diff --git a/custom_components/st-audiorec/st_audiorec/frontend/build/static/js/main.85742990.chunk.js b/custom_components/st-audiorec/st_audiorec/frontend/build/static/js/main.85742990.chunk.js
new file mode 100644
index 0000000000000000000000000000000000000000..ac69c1b6d1b96dfb532cb02a502714dc73035b07
--- /dev/null
+++ b/custom_components/st-audiorec/st_audiorec/frontend/build/static/js/main.85742990.chunk.js
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:28cf7e640dbe5e67fdde3e5e4eea1d9053901a0612be430efdd2968509feb279
+size 13457
diff --git a/custom_components/st-audiorec/st_audiorec/frontend/build/static/js/main.85742990.chunk.js.map b/custom_components/st-audiorec/st_audiorec/frontend/build/static/js/main.85742990.chunk.js.map
new file mode 100644
index 0000000000000000000000000000000000000000..1ed814a5550379f859a591d796de06cabb1f0a16
--- /dev/null
+++ b/custom_components/st-audiorec/st_audiorec/frontend/build/static/js/main.85742990.chunk.js.map
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:b9c4877643f7494e0fea5996bc57d8667c1258cb58311d1d530a957303ffd698
+size 38454
diff --git a/custom_components/st-audiorec/st_audiorec/frontend/build/static/js/runtime-main.11ec9aca.js b/custom_components/st-audiorec/st_audiorec/frontend/build/static/js/runtime-main.11ec9aca.js
new file mode 100644
index 0000000000000000000000000000000000000000..a87921d3e9f2b37dfbc3c8637d5f173ab028d631
--- /dev/null
+++ b/custom_components/st-audiorec/st_audiorec/frontend/build/static/js/runtime-main.11ec9aca.js
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:9d7973f912c527b00488df34a3789d515ddaa81aafb41c9e24a79faa86384a6d
+size 1598
diff --git a/custom_components/st-audiorec/st_audiorec/frontend/build/static/js/runtime-main.11ec9aca.js.map b/custom_components/st-audiorec/st_audiorec/frontend/build/static/js/runtime-main.11ec9aca.js.map
new file mode 100644
index 0000000000000000000000000000000000000000..166f7097396c0cd0f735f1a903d8c2795c847852
--- /dev/null
+++ b/custom_components/st-audiorec/st_audiorec/frontend/build/static/js/runtime-main.11ec9aca.js.map
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:f103d8abf2ee051ee5004a5cebac24b9120fd178ca04b1353b3c2fee903b2a99
+size 8317
diff --git a/custom_components/st-audiorec/st_audiorec/frontend/build/styles.css b/custom_components/st-audiorec/st_audiorec/frontend/build/styles.css
new file mode 100644
index 0000000000000000000000000000000000000000..a3c99718f73bf8b8a1b6d369c88ee8ea99ab8f70
--- /dev/null
+++ b/custom_components/st-audiorec/st_audiorec/frontend/build/styles.css
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:cf6e39bcb150811879a65286bc7b5646ce91a4fe06bdc47279f709352d06b3ce
+size 3005
diff --git a/custom_components/st-audiorec/st_audiorec/frontend/package.json b/custom_components/st-audiorec/st_audiorec/frontend/package.json
new file mode 100644
index 0000000000000000000000000000000000000000..96d89294cc2c930c9d624f6f806000d9d2114e25
--- /dev/null
+++ b/custom_components/st-audiorec/st_audiorec/frontend/package.json
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:b7d56e8585fd866ed7e923c7d236bc16572727379fa7c5210f864bbe415bb19d
+size 1257
diff --git a/custom_components/st-audiorec/st_audiorec/frontend/public/bootstrap.min.css b/custom_components/st-audiorec/st_audiorec/frontend/public/bootstrap.min.css
new file mode 100644
index 0000000000000000000000000000000000000000..03e07abe9974c8069c536b70ba053cfca55fdb96
--- /dev/null
+++ b/custom_components/st-audiorec/st_audiorec/frontend/public/bootstrap.min.css
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:f396767523d7b7ce621d90aae93cbbd7a516275898efd19020be38aa5ae85d5c
+size 206913
diff --git a/custom_components/st-audiorec/st_audiorec/frontend/public/index.html b/custom_components/st-audiorec/st_audiorec/frontend/public/index.html
new file mode 100644
index 0000000000000000000000000000000000000000..e13b32057e9a6ae662e68273b13173920c6b3d12
--- /dev/null
+++ b/custom_components/st-audiorec/st_audiorec/frontend/public/index.html
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:62d507b41ba09c5eabbebe6b946091aac4dbdc42b8144610292a629d07b43114
+size 819
diff --git a/custom_components/st-audiorec/st_audiorec/frontend/public/styles.css b/custom_components/st-audiorec/st_audiorec/frontend/public/styles.css
new file mode 100644
index 0000000000000000000000000000000000000000..a3c99718f73bf8b8a1b6d369c88ee8ea99ab8f70
--- /dev/null
+++ b/custom_components/st-audiorec/st_audiorec/frontend/public/styles.css
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:cf6e39bcb150811879a65286bc7b5646ce91a4fe06bdc47279f709352d06b3ce
+size 3005
diff --git a/custom_components/st-audiorec/st_audiorec/frontend/src/StreamlitAudioRecorder.tsx b/custom_components/st-audiorec/st_audiorec/frontend/src/StreamlitAudioRecorder.tsx
new file mode 100644
index 0000000000000000000000000000000000000000..e9faa81bdd5486e4ace0c61b1f6f1ce0bdc1888f
--- /dev/null
+++ b/custom_components/st-audiorec/st_audiorec/frontend/src/StreamlitAudioRecorder.tsx
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:5d8e12966a0a2f84f79befd0a0a8af2e32e73d557402d703b9104562a0973914
+size 22138
diff --git a/custom_components/st-audiorec/st_audiorec/frontend/src/index.tsx b/custom_components/st-audiorec/st_audiorec/frontend/src/index.tsx
new file mode 100644
index 0000000000000000000000000000000000000000..5315b37d8ede8dc851e036f6ccb969065483edba
--- /dev/null
+++ b/custom_components/st-audiorec/st_audiorec/frontend/src/index.tsx
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:823a6cdb8619acf67b20f8652ad380d361e723214c145f4e68f28fb02276dc3e
+size 236
diff --git a/custom_components/st-audiorec/st_audiorec/frontend/src/react-app-env.d.ts b/custom_components/st-audiorec/st_audiorec/frontend/src/react-app-env.d.ts
new file mode 100644
index 0000000000000000000000000000000000000000..2140b812b05d18474b51e064666e8ec14ad591f7
--- /dev/null
+++ b/custom_components/st-audiorec/st_audiorec/frontend/src/react-app-env.d.ts
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:dde16261952fc59aa0f2f4cd5364267a8a93b80499da193ac5e41997bb31e9c9
+size 81
diff --git a/custom_components/st-audiorec/st_audiorec/frontend/tsconfig.json b/custom_components/st-audiorec/st_audiorec/frontend/tsconfig.json
new file mode 100644
index 0000000000000000000000000000000000000000..16c1946b4c6aab56c0b1963bc291215eef3d95cb
--- /dev/null
+++ b/custom_components/st-audiorec/st_audiorec/frontend/tsconfig.json
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:74fb6cf888ac20a39e3f52b5bcce2b3ff0500c0090145f9b9df8367e12d4172c
+size 539
diff --git a/database.py b/database.py
new file mode 100644
index 0000000000000000000000000000000000000000..2014a76a261352423ff72bdaf06af2dc4d15dcfa
--- /dev/null
+++ b/database.py
@@ -0,0 +1,231 @@
+# database.py - نظام قاعدة البيانات البسيطة للملاحظات
+
+import sqlite3
+import json
+import os
+from datetime import datetime
+from typing import List, Dict, Optional
+
+class NotesDatabase:
+    """قاعدة بيانات بسيطة لحفظ الملاحظات والملخصات"""
+    
+    def __init__(self, db_path: str = "lecture_notes.db"):
+        self.db_path = db_path
+        self.init_database()
+    
+    def init_database(self):
+        """إنشاء قاعدة البيانات والجداول"""
+        with sqlite3.connect(self.db_path) as conn:
+            cursor = conn.cursor()
+            
+            # جدول الملاحظات الرئيسي
+            cursor.execute('''
+                CREATE TABLE IF NOT EXISTS lecture_notes (
+                    id INTEGER PRIMARY KEY AUTOINCREMENT,
+                    title TEXT NOT NULL,
+                    original_text TEXT NOT NULL,
+                    translated_text TEXT,
+                    summary TEXT,
+                    key_points TEXT,
+                    subject TEXT,
+                    date_created TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+                    date_modified TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+                    audio_file_path TEXT,
+                    language_detected TEXT,
+                    target_language TEXT,
+                    markers TEXT
+                )
+            ''')
+            
+            # جدول الملخصات السريعة
+            cursor.execute('''
+                CREATE TABLE IF NOT EXISTS quick_summaries (
+                    id INTEGER PRIMARY KEY AUTOINCREMENT,
+                    note_id INTEGER,
+                    summary_type TEXT,
+                    content TEXT,
+                    date_created TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+                    FOREIGN KEY (note_id) REFERENCES lecture_notes (id)
+                )
+            ''')
+            
+            conn.commit()
+    
+    def save_lecture_note(self, data: Dict) -> int:
+        """حفظ ملاحظة محاضرة جديدة"""
+        with sqlite3.connect(self.db_path) as conn:
+            cursor = conn.cursor()
+            
+            cursor.execute('''
+                INSERT INTO lecture_notes 
+                (title, original_text, translated_text, summary, key_points, 
+                 subject, audio_file_path, language_detected, target_language, markers)
+                VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+            ''', (
+                data.get('title', 'محاضرة جديدة'),
+                data.get('original_text', ''),
+                data.get('translated_text', ''),
+                data.get('summary', ''),
+                data.get('key_points', ''),
+                data.get('subject', ''),
+                data.get('audio_file_path', ''),
+                data.get('language_detected', ''),
+                data.get('target_language', ''),
+                json.dumps(data.get('markers', []))
+            ))
+            
+            note_id = cursor.lastrowid
+            conn.commit()
+            return note_id
+    
+    def get_all_notes(self, limit: int = 50) -> List[Dict]:
+        """استرجاع جميع الملاحظات"""
+        with sqlite3.connect(self.db_path) as conn:
+            cursor = conn.cursor()
+            
+            cursor.execute('''
+                SELECT * FROM lecture_notes 
+                ORDER BY date_created DESC 
+                LIMIT ?
+            ''', (limit,))
+            
+            columns = [description[0] for description in cursor.description]
+            notes = []
+            
+            for row in cursor.fetchall():
+                note = dict(zip(columns, row))
+                # تحويل markers من JSON string إلى list
+                if note['markers']:
+                    try:
+                        note['markers'] = json.loads(note['markers'])
+                    except:
+                        note['markers'] = []
+                notes.append(note)
+            
+            return notes
+    
+    def get_note_by_id(self, note_id: int) -> Optional[Dict]:
+        """استرجاع ملاحظة محددة بالـ ID"""
+        with sqlite3.connect(self.db_path) as conn:
+            cursor = conn.cursor()
+            
+            cursor.execute('SELECT * FROM lecture_notes WHERE id = ?', (note_id,))
+            row = cursor.fetchone()
+            
+            if row:
+                columns = [description[0] for description in cursor.description]
+                note = dict(zip(columns, row))
+                if note['markers']:
+                    try:
+                        note['markers'] = json.loads(note['markers'])
+                    except:
+                        note['markers'] = []
+                return note
+            
+            return None
+    
+    def update_note(self, note_id: int, data: Dict) -> bool:
+        """تحديث ملاحظة موجودة"""
+        with sqlite3.connect(self.db_path) as conn:
+            cursor = conn.cursor()
+            
+            # بناء query التحديث بناءً على البيانات الموجودة
+            update_fields = []
+            values = []
+            
+            for field in ['title', 'summary', 'key_points', 'subject']:
+                if field in data:
+                    update_fields.append(f"{field} = ?")
+                    values.append(data[field])
+            
+            if not update_fields:
+                return False
+            
+            update_fields.append("date_modified = CURRENT_TIMESTAMP")
+            values.append(note_id)
+            
+            query = f"UPDATE lecture_notes SET {', '.join(update_fields)} WHERE id = ?"
+            
+            cursor.execute(query, values)
+            conn.commit()
+            
+            return cursor.rowcount > 0
+    
+    def delete_note(self, note_id: int) -> bool:
+        """حذف ملاحظة"""
+        with sqlite3.connect(self.db_path) as conn:
+            cursor = conn.cursor()
+            
+            # حذف الملخصات المرتبطة أولاً
+            cursor.execute('DELETE FROM quick_summaries WHERE note_id = ?', (note_id,))
+            
+            # ثم حذف الملاحظة
+            cursor.execute('DELETE FROM lecture_notes WHERE id = ?', (note_id,))
+            
+            conn.commit()
+            return cursor.rowcount > 0
+    
+    def search_notes(self, query: str) -> List[Dict]:
+        """البحث في الملاحظات"""
+        with sqlite3.connect(self.db_path) as conn:
+            cursor = conn.cursor()
+            
+            search_query = f"%{query}%"
+            cursor.execute('''
+                SELECT * FROM lecture_notes 
+                WHERE title LIKE ? OR original_text LIKE ? 
+                OR translated_text LIKE ? OR summary LIKE ?
+                ORDER BY date_created DESC
+            ''', (search_query, search_query, search_query, search_query))
+            
+            columns = [description[0] for description in cursor.description]
+            notes = []
+            
+            for row in cursor.fetchall():
+                note = dict(zip(columns, row))
+                if note['markers']:
+                    try:
+                        note['markers'] = json.loads(note['markers'])
+                    except:
+                        note['markers'] = []
+                notes.append(note)
+            
+            return notes
+    
+    def get_notes_by_subject(self, subject: str) -> List[Dict]:
+        """استرجاع الملاحظات حسب المادة"""
+        with sqlite3.connect(self.db_path) as conn:
+            cursor = conn.cursor()
+            
+            cursor.execute('''
+                SELECT * FROM lecture_notes 
+                WHERE subject = ?
+                ORDER BY date_created DESC
+            ''', (subject,))
+            
+            columns = [description[0] for description in cursor.description]
+            notes = []
+            
+            for row in cursor.fetchall():
+                note = dict(zip(columns, row))
+                if note['markers']:
+                    try:
+                        note['markers'] = json.loads(note['markers'])
+                    except:
+                        note['markers'] = []
+                notes.append(note)
+            
+            return notes
+    
+    def get_subjects(self) -> List[str]:
+        """استرجاع قائمة المواد الدراسية"""
+        with sqlite3.connect(self.db_path) as conn:
+            cursor = conn.cursor()
+            
+            cursor.execute('''
+                SELECT DISTINCT subject FROM lecture_notes 
+                WHERE subject IS NOT NULL AND subject != ''
+                ORDER BY subject
+            ''')
+            
+            return [row[0] for row in cursor.fetchall()]
diff --git a/debug_ai_questions.py b/debug_ai_questions.py
new file mode 100644
index 0000000000000000000000000000000000000000..ca6b123a087b00330e9e694182e3441a7de2c49f
--- /dev/null
+++ b/debug_ai_questions.py
@@ -0,0 +1,181 @@
+# debug_ai_questions.py - Debug AI Questions issue
+
+import os
+import sys
+from dotenv import load_dotenv
+
+def debug_translator_state():
+    """Debug translator state and configuration"""
+    
+    print("🔍 Debugging Translator State...")
+    print("=" * 60)
+    
+    # Force reload environment
+    load_dotenv(override=True)
+    
+    # Clear module cache
+    if 'translator' in sys.modules:
+        del sys.modules['translator']
+    
+    # Fresh import
+    from translator import get_translator
+    
+    translator = get_translator()
+    
+    print(f"📋 OpenRouter Model: {translator.openrouter_model}")
+    print(f"🔑 OpenRouter API Key: {translator.openrouter_api_key[:20]}...{translator.openrouter_api_key[-10:]}")
+    
+    # Test OpenRouter directly
+    print("\n🧪 Testing OpenRouter directly...")
+    try:
+        result, error = translator._openrouter_complete("Say hello in Arabic")
+        if result:
+            print(f"✅ OpenRouter working: {result[:50]}...")
+        else:
+            print(f"❌ OpenRouter failed: {error}")
+    except Exception as e:
+        print(f"💥 OpenRouter exception: {str(e)}")
+    
+    return translator
+
+def debug_ai_questions_engine():
+    """Debug AI Questions engine"""
+    
+    print("\n🔍 Debugging AI Questions Engine...")
+    print("=" * 60)
+    
+    # Clear module cache
+    if 'ai_questions' in sys.modules:
+        del sys.modules['ai_questions']
+    
+    # Fresh import
+    from ai_questions import get_ai_question_engine
+    
+    engine = get_ai_question_engine()
+    
+    print(f"🔧 Engine translator model: {engine.translator.openrouter_model}")
+    
+    # Test model availability
+    models_status = engine.check_model_availability()
+    
+    print("\n📊 Model Status:")
+    for model, status in models_status.items():
+        icon = status.get('icon', '❓')
+        available = status.get('available', False)
+        status_text = "✅ Available" if available else "❌ Unavailable"
+        print(f"  {icon} {model}: {status_text}")
+    
+    return engine
+
+def debug_question_processing():
+    """Debug the actual question processing"""
+    
+    print("\n🔍 Debugging Question Processing...")
+    print("=" * 60)
+    
+    engine = debug_ai_questions_engine()
+    
+    # Test with OpenRouter specifically
+    print("\n🎯 Testing OpenRouter AI specifically...")
+    
+    test_text = "Hello and what are you doing? This is a test and I want to test my voice."
+    test_question = "Explain this text in detail"
+    
+    try:
+        # Test the _get_ai_response method directly
+        context = engine._prepare_question_context(
+            selected_text=test_text,
+            question=test_question,
+            session=None,  # We'll pass None for this test
+            ui_language='en'
+        )
+        
+        print(f"📝 Prepared context: {context[:100]}...")
+        
+        # Test with preferred model = OpenRouter AI
+        response, error, model_used = engine._get_ai_response_with_model(
+            context=context,
+            ui_language='en',
+            preferred_model='OpenRouter AI'
+        )
+        
+        if response:
+            print(f"✅ OpenRouter AI response: {response[:100]}...")
+            print(f"🔧 Model used: {model_used}")
+        else:
+            print(f"❌ OpenRouter AI failed: {error}")
+            
+            # Try with auto model
+            print("\n🔄 Trying with auto model...")
+            response, error, model_used = engine._get_ai_response_with_model(
+                context=context,
+                ui_language='en',
+                preferred_model='auto'
+            )
+            
+            if response:
+                print(f"✅ Auto model response: {response[:100]}...")
+                print(f"🔧 Model used: {model_used}")
+            else:
+                print(f"❌ Auto model also failed: {error}")
+        
+    except Exception as e:
+        print(f"💥 Question processing failed: {str(e)}")
+        import traceback
+        traceback.print_exc()
+
+def debug_full_question_flow():
+    """Debug the full question flow"""
+    
+    print("\n🔍 Debugging Full Question Flow...")
+    print("=" * 60)
+    
+    engine = debug_ai_questions_engine()
+    
+    test_text = "Hello and what are you doing? This is a test and I want to test my voice."
+    test_question = "Explain this text in detail"
+    
+    try:
+        response, error, session_id, model_used = engine.process_question(
+            selected_text=test_text,
+            question=test_question,
+            segment_info={"id": "test_segment"},
+            ui_language='en',
+            preferred_model='OpenRouter AI'
+        )
+        
+        if response:
+            print(f"✅ Full flow success: {response[:100]}...")
+            print(f"🔧 Model used: {model_used}")
+            print(f"📋 Session ID: {session_id}")
+        else:
+            print(f"❌ Full flow failed: {error}")
+            
+    except Exception as e:
+        print(f"💥 Full flow exception: {str(e)}")
+        import traceback
+        traceback.print_exc()
+
+def main():
+    """Main debug function"""
+    
+    print("🚀 AI Questions Debug Tool")
+    print("=" * 60)
+    
+    # Debug translator
+    translator = debug_translator_state()
+    
+    # Debug AI questions engine
+    engine = debug_ai_questions_engine()
+    
+    # Debug question processing
+    debug_question_processing()
+    
+    # Debug full flow
+    debug_full_question_flow()
+    
+    print("\n" + "=" * 60)
+    print("🎯 Debug Complete!")
+
+if __name__ == "__main__":
+    main()
\ No newline at end of file
diff --git a/debug_specific_issue.py b/debug_specific_issue.py
new file mode 100644
index 0000000000000000000000000000000000000000..9f8e7ddb3c938a3dddc6cff1068c64da2c43c328
--- /dev/null
+++ b/debug_specific_issue.py
@@ -0,0 +1,188 @@
+# debug_specific_issue.py - Debug the specific issue with OpenRouter model
+
+import os
+import sys
+from dotenv import load_dotenv
+
+def debug_openrouter_issue():
+    """Debug the specific OpenRouter model issue"""
+    
+    print("🔍 Debugging OpenRouter Model Issue")
+    print("=" * 60)
+    
+    # Load environment
+    load_dotenv()
+    
+    # Check environment
+    print(f"📋 OPENROUTER_MODEL: {os.getenv('OPENROUTER_MODEL')}")
+    print(f"🔑 OPENROUTER_API_KEY: {os.getenv('OPENROUTER_API_KEY')[:20]}...")
+    
+    # Import and test translator
+    try:
+        from translator import get_translator
+        translator = get_translator()
+        
+        print(f"📋 Translator model: {translator.openrouter_model}")
+        
+        # Test direct OpenRouter call
+        test_prompt = "Hello, respond with 'Test successful' in Arabic."
+        
+        print(f"\n🧪 Testing OpenRouter with prompt: {test_prompt}")
+        
+        response, error = translator._openrouter_complete(test_prompt)
+        
+        if response:
+            print(f"✅ Success: {response}")
+            return True
+        else:
+            print(f"❌ Error: {error}")
+            
+            # Check if error mentions old model
+            if "meta-llama-3-70b-instruct" in str(error):
+                print("🚨 ERROR: Old model found in error message!")
+                print("🔍 This means the old model is being used somewhere...")
+                
+                # Let's check the source code of _openrouter_complete
+                import inspect
+                source = inspect.getsource(translator._openrouter_complete)
+                
+                # Look for hardcoded models
+                lines = source.split('\n')
+                for i, line in enumerate(lines):
+                    if 'meta-llama' in line and '70b' in line:
+                        print(f"🚨 Found old model in line {i}: {line.strip()}")
+                
+                return False
+            else:
+                print("ℹ️ Error doesn't mention old model")
+                return False
+                
+    except Exception as e:
+        print(f"💥 Exception: {str(e)}")
+        return False
+
+def test_ai_questions_engine():
+    """Test AI Questions Engine specifically"""
+    
+    print("\n🤖 Testing AI Questions Engine")
+    print("=" * 60)
+    
+    try:
+        from translator import get_translator
+        from ai_questions import AIQuestionEngine
+        
+        translator = get_translator()
+        engine = AIQuestionEngine(translator)
+        
+        # Test with OpenRouter AI specifically
+        test_text = "Hello, this is a test text."
+        test_question = "What does this text mean?"
+        
+        print(f"📝 Test text: {test_text}")
+        print(f"❓ Test question: {test_question}")
+        print(f"🎯 Preferred model: OpenRouter AI")
+        
+        answer, error, session_id, model_used = engine.process_question(
+            selected_text=test_text,
+            question=test_question,
+            segment_info={"id": "test_segment"},
+            ui_language='en',
+            preferred_model='OpenRouter AI'
+        )
+        
+        if answer:
+            print(f"✅ Success!")
+            print(f"📝 Answer: {answer[:100]}...")
+            print(f"🔧 Model used: {model_used}")
+            return True
+        else:
+            print(f"❌ Error: {error}")
+            
+            # Check if error mentions old model
+            if "meta-llama-3-70b-instruct" in str(error):
+                print("🚨 ERROR: Old model found in AI Questions error!")
+                return False
+            else:
+                print("ℹ️ Error doesn't mention old model")
+                return False
+                
+    except Exception as e:
+        print(f"💥 Exception: {str(e)}")
+        
+        # Check if exception mentions old model
+        if "meta-llama-3-70b-instruct" in str(e):
+            print("🚨 ERROR: Old model found in exception!")
+            return False
+        else:
+            print("ℹ️ Exception doesn't mention old model")
+            return False
+
+def check_for_cached_instances():
+    """Check for any cached instances that might have old model"""
+    
+    print("\n🗂️ Checking for Cached Instances")
+    print("=" * 60)
+    
+    # Check if there are any cached translator instances
+    try:
+        import streamlit as st
+        
+        # Simulate session state
+        if hasattr(st, 'session_state'):
+            print("📋 Streamlit session state available")
+            
+            # Look for any cached instances
+            cached_keys = []
+            for key in st.session_state.keys():
+                if any(term in key.lower() for term in ['translator', 'ai', 'question', 'model']):
+                    cached_keys.append(key)
+            
+            if cached_keys:
+                print(f"🗑️ Found cached keys: {cached_keys}")
+                
+                # Clear them
+                for key in cached_keys:
+                    del st.session_state[key]
+                    
+                print("✅ Cleared cached instances")
+            else:
+                print("✅ No cached instances found")
+                
+        else:
+            print("ℹ️ Streamlit session state not available")
+            
+    except Exception as e:
+        print(f"ℹ️ Streamlit not available: {str(e)}")
+
+def main():
+    """Main debug function"""
+    
+    print("🚀 Specific OpenRouter Issue Debug")
+    print("=" * 60)
+    
+    # Step 1: Check for cached instances
+    check_for_cached_instances()
+    
+    # Step 2: Test translator directly
+    translator_ok = debug_openrouter_issue()
+    
+    # Step 3: Test AI Questions engine
+    ai_questions_ok = test_ai_questions_engine()
+    
+    print("\n" + "=" * 60)
+    print("📊 Debug Results:")
+    print(f"  Translator: {'✅ OK' if translator_ok else '❌ FAILED'}")
+    print(f"  AI Questions: {'✅ OK' if ai_questions_ok else '❌ FAILED'}")
+    
+    if translator_ok and ai_questions_ok:
+        print("\n🎉 All tests passed! The issue might be resolved.")
+    else:
+        print("\n⚠️ Issue still exists. Need further investigation.")
+        
+        if not translator_ok:
+            print("💡 The problem is in the translator module")
+        if not ai_questions_ok:
+            print("💡 The problem is in the AI questions engine")
+
+if __name__ == "__main__":
+    main()
\ No newline at end of file
diff --git a/diagnose_summary.py b/diagnose_summary.py
new file mode 100644
index 0000000000000000000000000000000000000000..95de76c61f715fc16a049cb297320e711728b92b
--- /dev/null
+++ b/diagnose_summary.py
@@ -0,0 +1,257 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+ملف تشخيص مشكلة زر التلخيص - معالجة شاملة
+"""
+
+import subprocess
+import sys
+import json
+import requests
+import time
+import os
+
+def check_server_process():
+    """التحقق من عملية الخادم"""
+    print("🔍 البحث عن عملية الخادم...")
+    
+    try:
+        # البحث في العمليات الجارية
+        result = subprocess.run(
+            ['tasklist', '/FI', 'IMAGENAME eq python.exe'],
+            capture_output=True, text=True, shell=True
+        )
+        
+        python_processes = []
+        for line in result.stdout.split('\n'):
+            if 'python.exe' in line:
+                python_processes.append(line.strip())
+        
+        print(f"عدد العمليات Python الجارية: {len(python_processes)}")
+        
+        if python_processes:
+            print("✅ العمليات الموجودة:")
+            for proc in python_processes[:5]:  # أول 5 فقط
+                print(f"  {proc}")
+        
+        return len(python_processes) > 0
+        
+    except Exception as e:
+        print(f"❌ خطأ في فحص العمليات: {e}")
+        return False
+
+def check_port_status():
+    """فحص حالة المنافذ"""
+    print("\n🌐 فحص حالة المنافذ...")
+    
+    ports_to_check = [5001, 5054, 8501]
+    port_status = {}
+    
+    for port in ports_to_check:
+        try:
+            result = subprocess.run(
+                ['netstat', '-an'],
+                capture_output=True, text=True, shell=True
+            )
+            
+            is_listening = f':{port}' in result.stdout and 'LISTENING' in result.stdout
+            port_status[port] = is_listening
+            
+            status_emoji = "✅" if is_listening else "❌"
+            print(f"  {status_emoji} Port {port}: {'LISTENING' if is_listening else 'NOT LISTENING'}")
+            
+        except Exception as e:
+            print(f"  ❌ Port {port}: خطأ في الفحص - {e}")
+            port_status[port] = False
+    
+    return port_status
+
+def test_cors_issue():
+    """اختبار مشكلة CORS"""
+    print("\n🔧 اختبار مشكلة CORS...")
+    
+    try:
+        # طلب OPTIONS
+        response = requests.options(
+            'http://localhost:5001/summarize',
+            timeout=5
+        )
+        
+        print(f"Status Code: {response.status_code}")
+        
+        # فحص CORS headers
+        headers = dict(response.headers)
+        cors_origin = headers.get('Access-Control-Allow-Origin', 'غير موجود')
+        
+        print(f"CORS Origin: '{cors_origin}'")
+        
+        # تحقق من المشكلة
+        if ',' in cors_origin:
+            print("❌ مشكلة CORS: القيمة تحتوي على فواصل متعددة!")
+            print("    هذا يسبب الخطأ: 'multiple values *, *'")
+            return False
+        elif cors_origin == '*':
+            print("✅ CORS header صحيح")
+            return True
+        else:
+            print(f"⚠️ CORS header غير متوقع: {cors_origin}")
+            return False
+            
+    except requests.exceptions.ConnectionError:
+        print("❌ لا يمكن الاتصال بالخادم - الخادم غير مشتغل")
+        return False
+    except Exception as e:
+        print(f"❌ خطأ في اختبار CORS: {e}")
+        return False
+
+def test_summarize_functionality():
+    """اختبار وظيفة التلخيص"""
+    print("\n🤖 اختبار وظيفة التلخيص...")
+    
+    test_data = {
+        "text": "Hello, how are you? What are you doing today? Tell me about your work.",
+        "language": "arabic",
+        "type": "full"
+    }
+    
+    try:
+        response = requests.post(
+            'http://localhost:5001/summarize',
+            json=test_data,
+            headers={'Content-Type': 'application/json'},
+            timeout=30
+        )
+        
+        print(f"Status Code: {response.status_code}")
+        
+        if response.status_code == 200:
+            data = response.json()
+            print(f"Response Keys: {list(data.keys())}")
+            
+            if data.get('success'):
+                print("✅ التلخيص نجح!")
+                print(f"Summary Type: {data.get('type', 'غير محدد')}")
+                
+                if 'summary' in data:
+                    summary_preview = str(data['summary'])[:100] + "..."
+                    print(f"Summary Preview: {summary_preview}")
+                    return True
+                else:
+                    print("⚠️ لا يوجد ملخص في الاستجابة")
+                    return False
+            else:
+                print(f"❌ فشل التلخيص: {data.get('error', 'خطأ غير معروف')}")
+                return False
+        else:
+            error_text = response.text[:200]
+            print(f"❌ خطأ HTTP {response.status_code}: {error_text}")
+            return False
+            
+    except requests.exceptions.Timeout:
+        print("❌ انتهت مهلة الطلب - الخادم بطيء أو لا يستجيب")
+        return False
+    except Exception as e:
+        print(f"❌ خطأ في اختبار التلخيص: {e}")
+        return False
+
+def check_dependencies():
+    """فحص المكتبات المطلوبة"""
+    print("\n📦 فحص المكتبات المطلوبة...")
+    
+    required_packages = [
+        'flask', 'flask-cors', 'requests', 
+        'google-generativeai', 'librosa', 'soundfile'
+    ]
+    
+    missing_packages = []
+    
+    for package in required_packages:
+        try:
+            result = subprocess.run(
+                [sys.executable, '-c', f'import {package.replace("-", "_")}'],
+                capture_output=True, text=True
+            )
+            
+            if result.returncode == 0:
+                print(f"  ✅ {package}")
+            else:
+                print(f"  ❌ {package} - غير مثبت")
+                missing_packages.append(package)
+                
+        except Exception as e:
+            print(f"  ❌ {package} - خطأ في الفحص: {e}")
+            missing_packages.append(package)
+    
+    if missing_packages:
+        print(f"\n⚠️ المكتبات المفقودة: {', '.join(missing_packages)}")
+        print("تشغيل الأمر: pip install " + " ".join(missing_packages))
+        return False
+    else:
+        print("\n✅ جميع المكتبات مثبتة")
+        return True
+
+def restart_server_suggestion():
+    """اقتراحات لإعادة تشغيل الخادم"""
+    print("\n🔄 اقتراحات الإصلاح:")
+    print("1. إيقاف الخادم الحالي (Ctrl+C في التيرمينال)")
+    print("2. تشغيل الخادم مرة أخرى:")
+    print("   python recorder_server.py")
+    print("\n3. أو استخدام ملف البدء:")
+    print("   python start_debug.py")
+    print("\n4. التحقق من تشغيل الخادم:")
+    print("   curl http://localhost:5001/record")
+
+def main():
+    """الدالة الرئيسية للتشخيص"""
+    print("=" * 60)
+    print("🚀 تشخيص شامل لمشكلة زر التلخيص")
+    print("=" * 60)
+    
+    # فحص العمليات
+    has_python_process = check_server_process()
+    
+    # فحص المنافذ
+    port_status = check_port_status()
+    
+    # فحص المكتبات
+    dependencies_ok = check_dependencies()
+    
+    # إذا كان المنفذ مفتوح، اختبر CORS والتلخيص
+    if port_status.get(5001, False):
+        cors_ok = test_cors_issue()
+        if cors_ok:
+            summarize_ok = test_summarize_functionality()
+        else:
+            summarize_ok = False
+            print("\n❌ لا يمكن اختبار التلخيص بسبب مشكلة CORS")
+    else:
+        cors_ok = False
+        summarize_ok = False
+        print("\n❌ لا يمكن اختبار CORS/التلخيص - الخادم غير مشتغل")
+    
+    # النتيجة النهائية
+    print("\n" + "=" * 60)
+    print("📊 ملخص التشخيص:")
+    print("=" * 60)
+    
+    print(f"  📦 المكتبات: {'✅ موجودة' if dependencies_ok else '❌ مفقودة'}")
+    print(f"  🔧 عملية Python: {'✅ تعمل' if has_python_process else '❌ لا تعمل'}")
+    print(f"  🌐 المنفذ 5001: {'✅ مفتوح' if port_status.get(5001) else '❌ مغلق'}")
+    print(f"  🔧 CORS: {'✅ صحيح' if cors_ok else '❌ مشكلة'}")
+    print(f"  🤖 التلخيص: {'✅ يعمل' if summarize_ok else '❌ لا يعمل'}")
+    
+    if summarize_ok:
+        print("\n🎉 جميع الاختبارات نجحت! المشكلة محلولة.")
+    elif not port_status.get(5001):
+        print("\n🔄 يجب تشغيل الخادم أولاً")
+        restart_server_suggestion()
+    elif not cors_ok:
+        print("\n🔄 مشكلة CORS - يجب إعادة تشغيل الخادم")
+        restart_server_suggestion()
+    else:
+        print("\n🔍 هناك مشكلة أخرى تحتاج لمزيد من التحقق")
+    
+    print("=" * 60)
+
+if __name__ == "__main__":
+    main()
diff --git a/exporter.py b/exporter.py
new file mode 100644
index 0000000000000000000000000000000000000000..eb03b6d09b720a007f42e84407f7f578b6517bec
--- /dev/null
+++ b/exporter.py
@@ -0,0 +1,352 @@
+# exporter.py - Broadcast Export Engine for SyncMaster Enhanced
+
+import os
+import time
+from datetime import datetime
+from typing import List, Dict, Optional, Tuple, Any
+from dataclasses import dataclass
+import tempfile
+import json
+
+# Document generation
+from docx import Document
+from docx.shared import Inches, Pt
+from docx.enum.text import WD_ALIGN_PARAGRAPH
+from docx.oxml.ns import qn
+
+# Google Docs integration
+try:
+    from googleapiclient.discovery import build
+    from google.auth.transport.requests import Request
+    from google.oauth2.credentials import Credentials
+    from google_auth_oauthlib.flow import InstalledAppFlow
+    GOOGLE_DOCS_AVAILABLE = True
+except ImportError:
+    GOOGLE_DOCS_AVAILABLE = False
+
+@dataclass
+class ExportConfig:
+    """Configuration for export operations"""
+    export_timestamp: int  # Unix timestamp in milliseconds
+    format_type: str      # 'word' or 'google_docs'
+    include_summary: bool # Whether to include AI summary
+    ui_language: str      # 'ar' or 'en' for interface
+    target_language: str  # Translation language for summary
+
+@dataclass
+class ExportContent:
+    """Structured content for export"""
+    title: str
+    export_time: str
+    segments: List[Dict[str, Any]]
+    summary: Optional[str]
+    metadata: Dict[str, Any]
+
+class BroadcastExporter:
+    """
+    Main export engine for SyncMaster broadcast content
+    """
+    
+    def __init__(self, translator_instance=None):
+        self.translator = translator_instance
+        self.supported_formats = ['word', 'google_docs']
+        
+        # Google Docs configuration
+        self.google_scopes = ['https://www.googleapis.com/auth/documents']
+        self.google_creds = None
+        
+        # UI translations
+        self.ui_texts = {
+            'ar': {
+                'title': 'محاضرة - تصدير البرودكاست',
+                'export_time': 'وقت التصدير',
+                'broadcast_section': 'البرودكاست المُصدر',
+                'summary_section': 'الملخص',
+                'original_text': 'النص الأصلي',
+                'translation': 'الترجمة',
+                'time_range': 'المدى الزمني',
+                'model_used': 'النموذج المستخدم'
+            },
+            'en': {
+                'title': 'Lecture - Broadcast Export',
+                'export_time': 'Export Time',
+                'broadcast_section': 'Exported Broadcast',
+                'summary_section': 'Summary',
+                'original_text': 'Original Text',
+                'translation': 'Translation',
+                'time_range': 'Time Range',
+                'model_used': 'Model Used'
+            }
+        }
+    
+    def filter_segments_from_timestamp(self, segments: List[Dict], export_timestamp: int) -> List[Dict]:
+        """
+        Filter broadcast segments from export timestamp
+        
+        Args:
+            segments: List of broadcast segments
+            export_timestamp: Timestamp in milliseconds
+            
+        Returns:
+            Filtered list of segments after the export timestamp
+        """
+        if not segments:
+            return []
+        
+        filtered_segments = []
+        for segment in segments:
+            # Check if segment starts after export timestamp
+            segment_start = segment.get('start_ms', 0)
+            if segment_start >= export_timestamp:
+                filtered_segments.append(segment)
+        
+        # Sort by start time (oldest first for export)
+        filtered_segments.sort(key=lambda s: s.get('start_ms', 0))
+        return filtered_segments
+    
+    def prepare_export_content(self, segments: List[Dict], config: ExportConfig) -> ExportContent:
+        """
+        Prepare structured content for export
+        
+        Args:
+            segments: Filtered broadcast segments
+            config: Export configuration
+            
+        Returns:
+            Structured export content
+        """
+        ui_lang = config.ui_language
+        texts = self.ui_texts.get(ui_lang, self.ui_texts['en'])
+        
+        # Create title with timestamp
+        export_datetime = datetime.fromtimestamp(config.export_timestamp / 1000)
+        title = f"{texts['title']} - {export_datetime.strftime('%Y-%m-%d %H:%M:%S')}"
+        
+        # Format export time
+        export_time = export_datetime.strftime('%Y-%m-%d %H:%M:%S')
+        
+        # Generate summary if requested
+        summary = None
+        if config.include_summary and segments and self.translator:
+            summary = self._generate_export_summary(segments, config.target_language)
+        
+        # Prepare metadata
+        metadata = {
+            'export_timestamp': config.export_timestamp,
+            'segment_count': len(segments),
+            'ui_language': ui_lang,
+            'target_language': config.target_language,
+            'generated_at': datetime.now().isoformat()
+        }
+        
+        return ExportContent(
+            title=title,
+            export_time=export_time,
+            segments=segments,
+            summary=summary,
+            metadata=metadata
+        )
+    
+    def export_to_word(self, content: ExportContent, config: ExportConfig) -> Tuple[str, Optional[str]]:
+        """
+        Generate Word document from export content
+        
+        Args:
+            content: Structured export content
+            config: Export configuration
+            
+        Returns:
+            Tuple of (file_path, error_message)
+        """
+        try:
+            doc = Document()
+            ui_lang = config.ui_language
+            texts = self.ui_texts.get(ui_lang, self.ui_texts['en'])
+            
+            # Set document direction for Arabic
+            if ui_lang == 'ar':
+                sections = doc.sections
+                for section in sections:
+                    sectPr = section._sectPr
+                    sectPr.set(qn('w:bidi'), '1')
+            
+            # Title
+            title_para = doc.add_heading(content.title, level=1)
+            if ui_lang == 'ar':
+                title_para.alignment = WD_ALIGN_PARAGRAPH.RIGHT
+            
+            # Export time
+            time_para = doc.add_paragraph(f"{texts['export_time']}: {content.export_time}")
+            if ui_lang == 'ar':
+                time_para.alignment = WD_ALIGN_PARAGRAPH.RIGHT
+            
+            doc.add_paragraph("=" * 50)
+            
+            # Broadcast section
+            broadcast_heading = doc.add_heading(texts['broadcast_section'], level=2)
+            if ui_lang == 'ar':
+                broadcast_heading.alignment = WD_ALIGN_PARAGRAPH.RIGHT
+            
+            doc.add_paragraph("=" * 50)
+            
+            # Add segments
+            for segment in content.segments:
+                # Time range
+                start_time = segment.get('start_ms', 0) / 1000
+                end_time = segment.get('end_ms', 0) / 1000
+                time_range = f"[{start_time:.2f}s → {end_time:.2f}s]"
+                
+                time_para = doc.add_paragraph()
+                time_run = time_para.add_run(f"{texts['time_range']}: {time_range}")
+                time_run.bold = True
+                if ui_lang == 'ar':
+                    time_para.alignment = WD_ALIGN_PARAGRAPH.RIGHT
+                
+                # Original text
+                original_text = segment.get('text', '')
+                if original_text:
+                    orig_para = doc.add_paragraph()
+                    orig_run = orig_para.add_run(f"{texts['original_text']}: ")
+                    orig_run.bold = True
+                    orig_para.add_run(original_text)
+                    if ui_lang == 'ar':
+                        orig_para.alignment = WD_ALIGN_PARAGRAPH.RIGHT
+                
+                # Translation
+                translations = segment.get('translations', {})
+                if translations:
+                    for lang_code, translation in translations.items():
+                        if translation:
+                            trans_para = doc.add_paragraph()
+                            trans_run = trans_para.add_run(f"{texts['translation']} ({lang_code.upper()}): ")
+                            trans_run.bold = True
+                            trans_para.add_run(translation)
+                            if ui_lang == 'ar':
+                                trans_para.alignment = WD_ALIGN_PARAGRAPH.RIGHT
+                
+                # Model used
+                model_used = segment.get('transcription_model')
+                if model_used:
+                    model_para = doc.add_paragraph(f"{texts['model_used']}: {model_used}")
+                    model_para.style = 'Caption'
+                    if ui_lang == 'ar':
+                        model_para.alignment = WD_ALIGN_PARAGRAPH.RIGHT
+                
+                doc.add_paragraph("-" * 30)
+            
+            # Summary section
+            if content.summary:
+                doc.add_page_break()
+                summary_heading = doc.add_heading(texts['summary_section'], level=2)
+                if ui_lang == 'ar':
+                    summary_heading.alignment = WD_ALIGN_PARAGRAPH.RIGHT
+                
+                doc.add_paragraph("=" * 50)
+                
+                summary_para = doc.add_paragraph(content.summary)
+                if ui_lang == 'ar':
+                    summary_para.alignment = WD_ALIGN_PARAGRAPH.RIGHT
+            
+            # Save document
+            timestamp = int(time.time())
+            filename = f"broadcast_export_{timestamp}.docx"
+            temp_dir = tempfile.gettempdir()
+            file_path = os.path.join(temp_dir, filename)
+            
+            doc.save(file_path)
+            return file_path, None
+            
+        except Exception as e:
+            return None, f"Error generating Word document: {str(e)}"
+    
+    def export_to_google_docs(self, content: ExportContent, config: ExportConfig, google_auth) -> Tuple[Optional[str], Optional[str]]:
+        """
+        Create Google Docs document from export content
+        
+        Args:
+            content: Structured export content
+            config: Export configuration
+            google_auth: GoogleDocsAuth instance
+            
+        Returns:
+            Tuple of (document_url, error_message)
+        """
+        if not GOOGLE_DOCS_AVAILABLE:
+            return None, "Google Docs integration not available. Please install required packages."
+        
+        try:
+            # Import here to avoid circular imports
+            from google_docs_config import prepare_google_docs_content
+            
+            # Prepare content requests
+            content_requests = prepare_google_docs_content(content, config)
+            
+            # Create document using GoogleDocsAuth
+            doc_url, error = google_auth.create_document(content.title, content_requests)
+            
+            if error:
+                return None, error
+            
+            return doc_url, None
+            
+        except Exception as e:
+            return None, f"Error creating Google Docs document: {str(e)}"
+    
+    def _generate_export_summary(self, segments: List[Dict], target_language: str = 'ar') -> Optional[str]:
+        """Generate summary for export content"""
+        if not self.translator or not segments:
+            return None
+        
+        try:
+            # Combine all segment texts
+            combined_text = " ".join([
+                segment.get('text', '') for segment in segments 
+                if segment.get('text')
+            ])
+            
+            if not combined_text.strip():
+                return None
+            
+            # Generate summary using translator
+            if hasattr(self.translator, 'summarize_text'):
+                summary, error = self.translator.summarize_text(combined_text, target_language)
+                return summary if summary else None
+            elif hasattr(self.translator, 'summarize_text_arabic'):
+                summary, error = self.translator.summarize_text_arabic(combined_text)
+                return summary if summary else None
+            
+        except Exception:
+            pass
+        
+        return None
+    
+
+    
+    def export_with_fallback(self, content: ExportContent, config: ExportConfig, google_auth=None) -> Tuple[Optional[str], Optional[str]]:
+        """
+        Export with automatic fallback handling
+        
+        Args:
+            content: Export content
+            config: Export configuration
+            google_auth: GoogleDocsAuth instance (optional)
+            
+        Returns:
+            Tuple of (result_path_or_url, error_message)
+        """
+        try:
+            if config.format_type == 'google_docs' and google_auth:
+                result, error = self.export_to_google_docs(content, config, google_auth)
+                if result:
+                    return result, None
+                # Fallback to Word if Google Docs fails
+                config.format_type = 'word'
+            
+            # Export to Word
+            if config.format_type == 'word':
+                return self.export_to_word(content, config)
+            
+            return None, f"Unsupported export format: {config.format_type}"
+            
+        except Exception as e:
+            return None, f"Export failed: {str(e)}"
\ No newline at end of file
diff --git a/fast_loading.py b/fast_loading.py
new file mode 100644
index 0000000000000000000000000000000000000000..bfec7aad96d82e992bbd90089ae3e92917cc0e09
--- /dev/null
+++ b/fast_loading.py
@@ -0,0 +1,52 @@
+"""
+Fast Loading Configuration for Streamlit
+تحسين سرعة تحميل Streamlit
+"""
+
+import streamlit as st
+
+def apply_fast_loading_config():
+    """Apply configurations for faster loading"""
+    
+    # Custom CSS to prevent flash of unstyled content
+    st.markdown("""
+    <style>
+    /* Hide loading spinner faster */
+    .stSpinner {
+        display: none !important;
+    }
+    
+    /* Faster fade-in */
+    .main .block-container {
+        animation: fadeIn 0.1s ease-in-out;
+    }
+    
+    @keyframes fadeIn {
+        from { opacity: 0; }
+        to { opacity: 1; }
+    }
+    
+    /* Optimize fonts loading */
+    body {
+        font-display: swap;
+    }
+    
+    /* Remove unnecessary margins */
+    .block-container {
+        padding-top: 1rem;
+    }
+    </style>
+    """, unsafe_allow_html=True)
+
+def show_instant_content():
+    """Show content immediately without waiting"""
+    st.markdown("""
+    <div style="text-align: center; padding: 20px;">
+        <h1>🎵 SyncMaster</h1>
+        <p>منصة المزامنة الذكية بين الصوت والنص</p>
+        <div style="background: linear-gradient(45deg, #1f77b4, #17becf); 
+                    color: white; padding: 10px; border-radius: 5px; margin: 10px;">
+            ✅ التطبيق جاهز للاستخدام
+        </div>
+    </div>
+    """, unsafe_allow_html=True)
diff --git a/final_ai_questions_test.py b/final_ai_questions_test.py
new file mode 100644
index 0000000000000000000000000000000000000000..f58fca6b59d735151388a21a75a1702083134036
--- /dev/null
+++ b/final_ai_questions_test.py
@@ -0,0 +1,179 @@
+# final_ai_questions_test.py - Final test for AI Questions
+
+import os
+import sys
+import time
+from dotenv import load_dotenv
+
+def simulate_streamlit_environment():
+    """Simulate Streamlit environment"""
+    
+    print("🔍 Simulating Streamlit Environment...")
+    
+    # Import streamlit
+    import streamlit as st
+    
+    # Clear any existing session state
+    if hasattr(st, 'session_state'):
+        for key in list(st.session_state.keys()):
+            if any(term in key.lower() for term in ['translator', 'ai', 'question', 'model']):
+                del st.session_state[key]
+    
+    print("✅ Streamlit environment simulated")
+
+def test_fresh_ai_questions():
+    """Test AI Questions with completely fresh instances"""
+    
+    print("\n🔍 Testing Fresh AI Questions...")
+    print("=" * 60)
+    
+    # Force reload environment
+    load_dotenv(override=True)
+    
+    # Clear all module cache
+    modules_to_clear = ['translator', 'ai_questions', 'exporter']
+    for module in modules_to_clear:
+        if module in sys.modules:
+            del sys.modules[module]
+    
+    # Fresh imports
+    from translator import get_translator
+    from ai_questions import get_ai_question_engine
+    
+    # Get fresh instances
+    translator = get_translator()
+    engine = get_ai_question_engine()
+    
+    print(f"📋 Translator Model: {translator.openrouter_model}")
+    print(f"🔧 Engine Translator Model: {engine.translator.openrouter_model}")
+    
+    # Test the complete flow
+    test_cases = [
+        {
+            'text': "Hello and what are you doing? This is a test and I want to test my voice. Everything is working fine.",
+            'question': "Explain this text in detail",
+            'model': 'OpenRouter AI'
+        },
+        {
+            'text': "Artificial intelligence is transforming the world.",
+            'question': "What is this about?",
+            'model': 'auto'
+        }
+    ]
+    
+    success_count = 0
+    
+    for i, test_case in enumerate(test_cases, 1):
+        print(f"\n🧪 Test Case {i}: {test_case['model']} model")
+        print(f"📝 Text: {test_case['text'][:50]}...")
+        print(f"❓ Question: {test_case['question']}")
+        
+        try:
+            start_time = time.time()
+            
+            response, error, session_id, model_used = engine.process_question(
+                selected_text=test_case['text'],
+                question=test_case['question'],
+                segment_info={"id": f"test_{i}"},
+                ui_language='en',
+                preferred_model=test_case['model']
+            )
+            
+            end_time = time.time()
+            response_time = int((end_time - start_time) * 1000)
+            
+            if response:
+                print(f"✅ Success! Response: {response[:100]}...")
+                print(f"🔧 Model Used: {model_used}")
+                print(f"⏱️ Response Time: {response_time}ms")
+                print(f"📋 Session ID: {session_id}")
+                
+                # Check if old model error appears
+                if "meta-llama-3-70b-instruct" in str(response) or "meta-llama-3-70b-instruct" in str(error):
+                    print("🚨 ERROR: Old model reference found in response!")
+                    return False
+                
+                success_count += 1
+            else:
+                print(f"❌ Failed: {error}")
+                
+                # Check if it's the old model error
+                if "meta-llama-3-70b-instruct" in str(error):
+                    print("🚨 ERROR: Still getting old model error!")
+                    return False
+                else:
+                    print("ℹ️ Different error (not old model)")
+            
+        except Exception as e:
+            print(f"💥 Exception: {str(e)}")
+            
+            # Check if exception mentions old model
+            if "meta-llama-3-70b-instruct" in str(e):
+                print("🚨 ERROR: Exception mentions old model!")
+                return False
+            else:
+                print("ℹ️ Different exception (not old model)")
+    
+    print(f"\n📊 Success Rate: {success_count}/{len(test_cases)}")
+    return success_count > 0
+
+def test_model_availability():
+    """Test model availability check"""
+    
+    print("\n🔍 Testing Model Availability...")
+    print("=" * 60)
+    
+    try:
+        from ai_questions import get_ai_question_engine
+        
+        engine = get_ai_question_engine()
+        models_status = engine.check_model_availability()
+        
+        print("📊 Model Status:")
+        for model, status in models_status.items():
+            icon = status.get('icon', '❓')
+            available = status.get('available', False)
+            status_text = "✅ Available" if available else "❌ Unavailable"
+            print(f"  {icon} {model}: {status_text}")
+        
+        # Check if OpenRouter is available
+        openrouter_status = models_status.get('OpenRouter AI', {})
+        return openrouter_status.get('available', False)
+        
+    except Exception as e:
+        print(f"💥 Model availability check failed: {str(e)}")
+        return False
+
+def main():
+    """Main test function"""
+    
+    print("🚀 Final AI Questions Test")
+    print("=" * 60)
+    
+    # Simulate Streamlit environment
+    simulate_streamlit_environment()
+    
+    # Test model availability
+    availability_ok = test_model_availability()
+    
+    # Test fresh AI questions
+    questions_ok = test_fresh_ai_questions()
+    
+    print("\n" + "=" * 60)
+    print("📊 Final Test Results:")
+    print(f"  Model Availability: {'✅ PASS' if availability_ok else '❌ FAIL'}")
+    print(f"  AI Questions Test: {'✅ PASS' if questions_ok else '❌ FAIL'}")
+    
+    if availability_ok and questions_ok:
+        print("\n🎉 ALL TESTS PASSED!")
+        print("💡 AI Questions should work perfectly now!")
+        print("🚀 The old model error is completely resolved!")
+    else:
+        print("\n⚠️ Some issues remain:")
+        if not availability_ok:
+            print("  - Model availability check failed")
+        if not questions_ok:
+            print("  - AI Questions test failed")
+
+if __name__ == "__main__":
+    main()
\ No newline at end of file
diff --git a/final_test.py b/final_test.py
new file mode 100644
index 0000000000000000000000000000000000000000..d267a28fd044c8e406f7f431c4ab372cef279d9f
--- /dev/null
+++ b/final_test.py
@@ -0,0 +1,150 @@
+# final_test.py - Final comprehensive test
+
+import os
+import sys
+from dotenv import load_dotenv
+
+def test_environment():
+    """Test environment configuration"""
+    print("🔍 Testing Environment Configuration...")
+    
+    load_dotenv(override=True)
+    
+    required_vars = {
+        'OPENROUTER_API_KEY': os.getenv('OPENROUTER_API_KEY'),
+        'OPENROUTER_MODEL': os.getenv('OPENROUTER_MODEL'),
+        'GROQ_API_KEY': os.getenv('GROQ_API_KEY'),
+        'GEMINI_API_KEY': os.getenv('GEMINI_API_KEY')
+    }
+    
+    all_good = True
+    for var, value in required_vars.items():
+        if value:
+            if 'KEY' in var:
+                print(f"✅ {var}: {value[:15]}...{value[-8:]}")
+            else:
+                print(f"✅ {var}: {value}")
+        else:
+            print(f"❌ {var}: Missing")
+            all_good = False
+    
+    return all_good
+
+def test_translator_fresh():
+    """Test translator with fresh import"""
+    print("\n🔍 Testing Translator (Fresh Import)...")
+    
+    try:
+        # Clear module cache
+        if 'translator' in sys.modules:
+            del sys.modules['translator']
+        
+        # Fresh import
+        from translator import get_translator
+        
+        translator = get_translator()
+        print(f"📋 OpenRouter Model: {translator.openrouter_model}")
+        
+        # Test OpenRouter
+        result, error = translator._openrouter_complete("Say 'Hello' in Arabic")
+        
+        if result:
+            print(f"✅ OpenRouter working: {result[:50]}...")
+            return True
+        else:
+            print(f"❌ OpenRouter failed: {error}")
+            return False
+            
+    except Exception as e:
+        print(f"❌ Translator test failed: {str(e)}")
+        return False
+
+def test_ai_questions_fresh():
+    """Test AI questions with fresh import"""
+    print("\n🔍 Testing AI Questions (Fresh Import)...")
+    
+    try:
+        # Clear module cache
+        if 'ai_questions' in sys.modules:
+            del sys.modules['ai_questions']
+        
+        # Fresh import
+        from ai_questions import get_ai_question_engine
+        
+        engine = get_ai_question_engine()
+        
+        # Test question processing
+        response, error, session_id, model_used = engine.process_question(
+            selected_text="This is a test text about artificial intelligence.",
+            question="What is this text about?",
+            segment_info={"id": "test"},
+            ui_language='en',
+            preferred_model='auto'
+        )
+        
+        if response:
+            print(f"✅ AI Questions working: {response[:50]}...")
+            print(f"🔧 Model used: {model_used}")
+            return True
+        else:
+            print(f"❌ AI Questions failed: {error}")
+            return False
+            
+    except Exception as e:
+        print(f"❌ AI Questions test failed: {str(e)}")
+        return False
+
+def test_app_imports():
+    """Test app.py imports"""
+    print("\n🔍 Testing App Imports...")
+    
+    try:
+        # Test critical imports
+        from translator import get_translator
+        from ai_questions import get_ai_question_engine
+        from exporter import BroadcastExporter
+        from style_fixes import apply_custom_styling
+        
+        print("✅ All critical imports successful")
+        return True
+        
+    except Exception as e:
+        print(f"❌ Import test failed: {str(e)}")
+        return False
+
+def main():
+    """Run all final tests"""
+    
+    print("🚀 Final Comprehensive Test")
+    print("=" * 60)
+    
+    # Test environment
+    env_ok = test_environment()
+    
+    # Test translator
+    translator_ok = test_translator_fresh()
+    
+    # Test AI questions
+    ai_questions_ok = test_ai_questions_fresh()
+    
+    # Test app imports
+    imports_ok = test_app_imports()
+    
+    print("\n" + "=" * 60)
+    print("📊 Final Test Results:")
+    print(f"  Environment: {'✅ PASS' if env_ok else '❌ FAIL'}")
+    print(f"  Translator: {'✅ PASS' if translator_ok else '❌ FAIL'}")
+    print(f"  AI Questions: {'✅ PASS' if ai_questions_ok else '❌ FAIL'}")
+    print(f"  App Imports: {'✅ PASS' if imports_ok else '❌ FAIL'}")
+    
+    if all([env_ok, translator_ok, ai_questions_ok, imports_ok]):
+        print("\n🎉 ALL TESTS PASSED!")
+        print("💡 Your app should work perfectly now!")
+        print("🚀 Run: streamlit run app.py")
+        return True
+    else:
+        print("\n⚠️ Some tests failed. Check the logs above.")
+        return False
+
+if __name__ == "__main__":
+    main()
\ No newline at end of file
diff --git a/fix_model_issue.py b/fix_model_issue.py
new file mode 100644
index 0000000000000000000000000000000000000000..7148aabf233d4db5bc82dac2095940eeb833cf20
--- /dev/null
+++ b/fix_model_issue.py
@@ -0,0 +1,160 @@
+# fix_model_issue.py - Fix the OpenRouter model issue
+
+import os
+from dotenv import load_dotenv
+
+def fix_openrouter_model():
+    """Fix OpenRouter model configuration"""
+    
+    print("🔧 Fixing OpenRouter model configuration...")
+    
+    # Reload environment variables
+    load_dotenv(override=True)
+    
+    # Check current configuration
+    current_model = os.getenv("OPENROUTER_MODEL")
+    print(f"📋 Current OPENROUTER_MODEL: {current_model}")
+    
+    # Update .env file if needed
+    env_file = ".env"
+    
+    try:
+        with open(env_file, 'r', encoding='utf-8') as f:
+            content = f.read()
+        
+        # Replace old model with new one
+        old_models = [
+            "meta-llama-3-70b-instruct",
+            "meta-llama/llama-3-70b-instruct",
+            "meta-llama-3.1-70b-instruct"
+        ]
+        
+        new_model = "meta-llama/llama-3.2-3b-instruct:free"
+        
+        updated = False
+        for old_model in old_models:
+            if old_model in content:
+                content = content.replace(f"OPENROUTER_MODEL={old_model}", f"OPENROUTER_MODEL={new_model}")
+                updated = True
+                print(f"✅ Replaced {old_model} with {new_model}")
+        
+        if updated:
+            with open(env_file, 'w', encoding='utf-8') as f:
+                f.write(content)
+            print("✅ .env file updated successfully")
+        else:
+            print("ℹ️ No old models found in .env file")
+        
+        # Reload environment variables again
+        load_dotenv(override=True)
+        
+        # Verify the change
+        updated_model = os.getenv("OPENROUTER_MODEL")
+        print(f"✅ Updated OPENROUTER_MODEL: {updated_model}")
+        
+        return True
+        
+    except Exception as e:
+        print(f"❌ Error updating .env file: {str(e)}")
+        return False
+
+def test_openrouter_with_new_model():
+    """Test OpenRouter with the new model"""
+    
+    print("\n🧪 Testing OpenRouter with new model...")
+    
+    try:
+        from translator import get_translator
+        
+        # Force reload translator
+        import importlib
+        import translator
+        importlib.reload(translator)
+        
+        # Get fresh translator instance
+        translator_instance = get_translator()
+        
+        print(f"📋 Translator OpenRouter model: {translator_instance.openrouter_model}")
+        
+        # Test simple translation
+        test_text = "Hello, this is a test."
+        
+        try:
+            result, error = translator_instance._openrouter_complete(f"Translate to Arabic: {test_text}")
+            
+            if result:
+                print(f"✅ OpenRouter test successful!")
+                print(f"📝 Result: {result[:100]}...")
+                return True
+            else:
+                print(f"❌ OpenRouter test failed: {error}")
+                return False
+                
+        except Exception as e:
+            print(f"❌ OpenRouter test error: {str(e)}")
+            return False
+            
+    except Exception as e:
+        print(f"❌ Error testing OpenRouter: {str(e)}")
+        return False
+
+def clear_python_cache():
+    """Clear Python cache files"""
+    
+    print("\n🧹 Clearing Python cache...")
+    
+    import shutil
+    import glob
+    
+    try:
+        # Remove __pycache__ directories
+        pycache_dirs = glob.glob("**/__pycache__", recursive=True)
+        for cache_dir in pycache_dirs:
+            shutil.rmtree(cache_dir, ignore_errors=True)
+            print(f"🗑️ Removed {cache_dir}")
+        
+        # Remove .pyc files
+        pyc_files = glob.glob("**/*.pyc", recursive=True)
+        for pyc_file in pyc_files:
+            os.remove(pyc_file)
+            print(f"🗑️ Removed {pyc_file}")
+        
+        print("✅ Python cache cleared")
+        return True
+        
+    except Exception as e:
+        print(f"❌ Error clearing cache: {str(e)}")
+        return False
+
+def main():
+    """Main function to fix the model issue"""
+    
+    print("=" * 60)
+    print("🚀 OpenRouter Model Fix Tool")
+    print("=" * 60)
+    
+    # Step 1: Fix model configuration
+    fix_success = fix_openrouter_model()
+    
+    # Step 2: Clear Python cache
+    cache_success = clear_python_cache()
+    
+    # Step 3: Test with new model
+    test_success = test_openrouter_with_new_model()
+    
+    print("\n" + "=" * 60)
+    print("📊 Fix Results:")
+    print(f"  Model Config: {'✅ FIXED' if fix_success else '❌ FAILED'}")
+    print(f"  Cache Clear: {'✅ CLEARED' if cache_success else '❌ FAILED'}")
+    print(f"  OpenRouter Test: {'✅ WORKING' if test_success else '❌ FAILED'}")
+    
+    if fix_success and test_success:
+        print("\n🎉 OpenRouter model issue has been fixed!")
+        print("💡 You can now restart your Streamlit app.")
+    else:
+        print("\n⚠️ Some issues remain. Please check the logs above.")
+    
+    return fix_success and test_success
+
+if __name__ == "__main__":
+    main()
\ No newline at end of file
diff --git a/force_reset_models.py b/force_reset_models.py
new file mode 100644
index 0000000000000000000000000000000000000000..4d687b648a07905d36ca26b26a65b08aacffd92a
--- /dev/null
+++ b/force_reset_models.py
@@ -0,0 +1,214 @@
+# force_reset_models.py - Force reset all AI models and cache
+
+import os
+import sys
+import shutil
+import glob
+from dotenv import load_dotenv
+
+def force_clear_all_cache():
+    """Force clear all Python cache and compiled files"""
+    
+    print("🧹 Force clearing all cache...")
+    
+    try:
+        # Remove all __pycache__ directories
+        pycache_dirs = glob.glob("**/__pycache__", recursive=True)
+        for cache_dir in pycache_dirs:
+            shutil.rmtree(cache_dir, ignore_errors=True)
+            print(f"🗑️ Removed {cache_dir}")
+        
+        # Remove all .pyc files
+        pyc_files = glob.glob("**/*.pyc", recursive=True)
+        for pyc_file in pyc_files:
+            try:
+                os.remove(pyc_file)
+                print(f"🗑️ Removed {pyc_file}")
+            except:
+                pass
+        
+        # Remove .streamlit cache if exists
+        streamlit_cache = ".streamlit"
+        if os.path.exists(streamlit_cache):
+            shutil.rmtree(streamlit_cache, ignore_errors=True)
+            print(f"🗑️ Removed {streamlit_cache}")
+        
+        print("✅ All cache cleared")
+        return True
+        
+    except Exception as e:
+        print(f"❌ Error clearing cache: {str(e)}")
+        return False
+
+def force_reload_environment():
+    """Force reload environment variables"""
+    
+    print("🔄 Force reloading environment...")
+    
+    try:
+        # Clear environment variables
+        env_vars_to_clear = [
+            'OPENROUTER_MODEL',
+            'OPENROUTER_API_KEY',
+            'GROQ_API_KEY',
+            'GEMINI_API_KEY'
+        ]
+        
+        for var in env_vars_to_clear:
+            if var in os.environ:
+                del os.environ[var]
+                print(f"🗑️ Cleared {var} from environment")
+        
+        # Reload from .env file
+        load_dotenv(override=True)
+        
+        # Verify reload
+        for var in env_vars_to_clear:
+            value = os.getenv(var)
+            if value:
+                if 'KEY' in var:
+                    print(f"✅ Reloaded {var}: {value[:20]}...{value[-10:]}")
+                else:
+                    print(f"✅ Reloaded {var}: {value}")
+            else:
+                print(f"⚠️ {var}: Not found")
+        
+        return True
+        
+    except Exception as e:
+        print(f"❌ Error reloading environment: {str(e)}")
+        return False
+
+def force_reimport_modules():
+    """Force reimport all AI-related modules"""
+    
+    print("🔄 Force reimporting modules...")
+    
+    try:
+        # Modules to reimport
+        modules_to_reload = [
+            'translator',
+            'ai_questions',
+            'exporter'
+        ]
+        
+        for module_name in modules_to_reload:
+            if module_name in sys.modules:
+                del sys.modules[module_name]
+                print(f"🗑️ Removed {module_name} from sys.modules")
+        
+        # Force reimport
+        import importlib
+        
+        try:
+            import translator
+            importlib.reload(translator)
+            print("✅ Reloaded translator module")
+        except Exception as e:
+            print(f"⚠️ Could not reload translator: {str(e)}")
+        
+        try:
+            import ai_questions
+            importlib.reload(ai_questions)
+            print("✅ Reloaded ai_questions module")
+        except Exception as e:
+            print(f"⚠️ Could not reload ai_questions: {str(e)}")
+        
+        return True
+        
+    except Exception as e:
+        print(f"❌ Error reimporting modules: {str(e)}")
+        return False
+
+def test_after_reset():
+    """Test AI models after reset"""
+    
+    print("🧪 Testing after reset...")
+    
+    try:
+        from translator import get_translator
+        
+        translator = get_translator()
+        print(f"📋 OpenRouter Model: {translator.openrouter_model}")
+        
+        # Test OpenRouter
+        result, error = translator._openrouter_complete("Test message")
+        
+        if result:
+            print("✅ OpenRouter working after reset!")
+            return True
+        else:
+            print(f"❌ OpenRouter still failing: {error}")
+            return False
+            
+    except Exception as e:
+        print(f"❌ Test failed: {str(e)}")
+        return False
+
+def create_fresh_env_file():
+    """Create a fresh .env file with correct values"""
+    
+    print("📝 Creating fresh .env file...")
+    
+    env_content = """GEMINI_API_KEY=AIzaSyAS7JtrXjlNjyuo3RG5z6rkwocCwFy1YuA
+GROQ_API_KEY=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
+OPENROUTER_API_KEY=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
+OPENROUTER_MODEL=meta-llama/llama-3.2-3b-instruct:free
+GROQ_WHISPER_MODEL=whisper-large-v3
+
+# Google Docs API Configuration
+# Get these from: https://console.cloud.google.com/
+GOOGLE_CLIENT_ID=your_google_client_id_here
+GOOGLE_CLIENT_SECRET=your_google_client_secret_here
+"""
+    
+    try:
+        with open('.env', 'w', encoding='utf-8') as f:
+            f.write(env_content)
+        
+        print("✅ Fresh .env file created")
+        return True
+        
+    except Exception as e:
+        print(f"❌ Error creating .env file: {str(e)}")
+        return False
+
+def main():
+    """Main force reset function"""
+    
+    print("🚀 Force Reset AI Models")
+    print("=" * 60)
+    
+    # Step 1: Create fresh .env file
+    env_success = create_fresh_env_file()
+    
+    # Step 2: Clear all cache
+    cache_success = force_clear_all_cache()
+    
+    # Step 3: Reload environment
+    env_reload_success = force_reload_environment()
+    
+    # Step 4: Reimport modules
+    import_success = force_reimport_modules()
+    
+    # Step 5: Test after reset
+    test_success = test_after_reset()
+    
+    print("\n" + "=" * 60)
+    print("📊 Force Reset Results:")
+    print(f"  Fresh .env: {'✅ CREATED' if env_success else '❌ FAILED'}")
+    print(f"  Cache Clear: {'✅ CLEARED' if cache_success else '❌ FAILED'}")
+    print(f"  Env Reload: {'✅ RELOADED' if env_reload_success else '❌ FAILED'}")
+    print(f"  Module Import: {'✅ IMPORTED' if import_success else '❌ FAILED'}")
+    print(f"  Final Test: {'✅ WORKING' if test_success else '❌ FAILED'}")
+    
+    if all([env_success, cache_success, env_reload_success, test_success]):
+        print("\n🎉 Force reset successful! AI models should work now.")
+        print("💡 Now restart your Streamlit app: streamlit run app.py")
+    else:
+        print("\n⚠️ Some issues remain. Check the logs above.")
+    
+    return test_success
+
+if __name__ == "__main__":
+    main()
\ No newline at end of file
diff --git a/google_docs_config.py b/google_docs_config.py
new file mode 100644
index 0000000000000000000000000000000000000000..419cd4e5008dcea7794612e51c3293764a22e9a0
--- /dev/null
+++ b/google_docs_config.py
@@ -0,0 +1,210 @@
+# google_docs_config.py - Simplified Google Docs Integration
+
+import os
+import json
+import tempfile
+from typing import Optional, Tuple
+import streamlit as st
+
+try:
+    from googleapiclient.discovery import build
+    from google.auth.transport.requests import Request
+    from google.oauth2.credentials import Credentials
+    from google_auth_oauthlib.flow import InstalledAppFlow
+    GOOGLE_AVAILABLE = True
+except ImportError:
+    GOOGLE_AVAILABLE = False
+
+class GoogleDocsManager:
+    """Simplified Google Docs manager for direct export"""
+    
+    def __init__(self):
+        self.SCOPES = ['https://www.googleapis.com/auth/documents']
+        self.creds = None
+        self.service = None
+    
+    def authenticate(self) -> bool:
+        """Authenticate with Google Docs API"""
+        if not GOOGLE_AVAILABLE:
+            return False
+        
+        try:
+            # Check if we have stored credentials
+            if os.path.exists('token.json'):
+                self.creds = Credentials.from_authorized_user_file('token.json', self.SCOPES)
+            
+            # If there are no (valid) credentials available, let the user log in
+            if not self.creds or not self.creds.valid:
+                if self.creds and self.creds.expired and self.creds.refresh_token:
+                    self.creds.refresh(Request())
+                else:
+                    # Create credentials.json if it doesn't exist
+                    self._create_credentials_file()
+                    
+                    if os.path.exists('credentials.json'):
+                        # Use web flow for Streamlit app
+                        flow = InstalledAppFlow.from_client_secrets_file('credentials.json', self.SCOPES)
+                        # Use a different port to avoid conflict with Streamlit
+                        self.creds = flow.run_local_server(port=8502, open_browser=True)
+                    else:
+                        return False
+                
+                # Save the credentials for the next run
+                with open('token.json', 'w') as token:
+                    token.write(self.creds.to_json())
+            
+            self.service = build('docs', 'v1', credentials=self.creds)
+            return True
+            
+        except Exception as e:
+            st.error(f"Google authentication error: {str(e)}")
+            return False
+    
+    def _create_credentials_file(self):
+        """Create a basic credentials.json file template"""
+        credentials_template = {
+            "installed": {
+                "client_id": "YOUR_CLIENT_ID.apps.googleusercontent.com",
+                "project_id": "your-project-id",
+                "auth_uri": "https://accounts.google.com/o/oauth2/auth",
+                "token_uri": "https://oauth2.googleapis.com/token",
+                "auth_provider_x509_cert_url": "https://www.googleapis.com/oauth2/v1/certs",
+                "client_secret": "YOUR_CLIENT_SECRET",
+                "redirect_uris": ["http://localhost"]
+            }
+        }
+        
+        if not os.path.exists('credentials.json'):
+            with open('credentials.json', 'w') as f:
+                json.dump(credentials_template, f, indent=2)
+            
+            st.warning("""
+            📝 Google Docs Setup Required:
+            
+            1. Go to https://console.cloud.google.com/
+            2. Create a new project or select existing one
+            3. Enable Google Docs API
+            4. Create credentials (OAuth 2.0 Client ID)
+            5. Download the credentials.json file
+            6. Replace the generated credentials.json with your downloaded file
+            7. Restart the application
+            """)
+    
+    def create_document(self, title: str, content: str) -> Tuple[Optional[str], Optional[str]]:
+        """Create a Google Docs document with content"""
+        if not self.service:
+            if not self.authenticate():
+                return None, "Failed to authenticate with Google Docs"
+        
+        try:
+            # Create document
+            document = {'title': title}
+            doc = self.service.documents().create(body=document).execute()
+            document_id = doc.get('documentId')
+            
+            # Add content if provided
+            if content.strip():
+                requests = [
+                    {
+                        'insertText': {
+                            'location': {'index': 1},
+                            'text': content
+                        }
+                    }
+                ]
+                
+                self.service.documents().batchUpdate(
+                    documentId=document_id,
+                    body={'requests': requests}
+                ).execute()
+            
+            # Return shareable URL
+            doc_url = f"https://docs.google.com/document/d/{document_id}/edit"
+            return doc_url, None
+            
+        except Exception as e:
+            return None, f"Error creating Google Docs document: {str(e)}"
+    
+    def logout(self) -> bool:
+        """Logout from Google account by removing stored credentials"""
+        try:
+            # Remove token file
+            if os.path.exists('token.json'):
+                os.remove('token.json')
+            
+            # Clear current credentials
+            self.creds = None
+            self.service = None
+            
+            return True
+        except Exception as e:
+            print(f"Error during logout: {e}")
+            return False
+    
+    def is_authenticated(self) -> bool:
+        """Check if user is currently authenticated"""
+        return self.creds is not None and self.creds.valid
+    
+    def get_current_user_email(self) -> Optional[str]:
+        """Get the email of the currently authenticated user"""
+        if self.is_authenticated():
+            try:
+                # This would require additional API call to get user info
+                # For now, we'll return a placeholder
+                return "authenticated_user@gmail.com"
+            except Exception:
+                return None
+        return None
+
+    def export_broadcast_to_docs(self, segments, ui_language='ar') -> Tuple[Optional[str], Optional[str]]:
+        """Export broadcast segments directly to Google Docs"""
+        
+        # Create title
+        from datetime import datetime
+        timestamp = datetime.now().strftime('%Y-%m-%d %H:%M:%S')
+        title = f"محاضرة - تصدير البرودكاست - {timestamp}" if ui_language == 'ar' else f"Lecture - Broadcast Export - {timestamp}"
+        
+        # Prepare content
+        content_lines = []
+        content_lines.append(f"{'تصدير البرودكاست' if ui_language == 'ar' else 'Broadcast Export'}")
+        content_lines.append(f"{'التاريخ والوقت' if ui_language == 'ar' else 'Date & Time'}: {timestamp}")
+        content_lines.append("=" * 50)
+        content_lines.append("")
+        
+        if segments:
+            content_lines.append(f"{'المقاطع النصية' if ui_language == 'ar' else 'Text Segments'}:")
+            content_lines.append("-" * 30)
+            
+            for segment in segments:
+                start_time = segment.get('start_ms', 0) / 1000
+                end_time = segment.get('end_ms', 0) / 1000
+                
+                content_lines.append(f"[{start_time:.2f}s → {end_time:.2f}s]")
+                
+                # Original text
+                original_text = segment.get('text', '')
+                if original_text:
+                    content_lines.append(f"{'النص الأصلي' if ui_language == 'ar' else 'Original'}: {original_text}")
+                
+                # Translation
+                translations = segment.get('translations', {})
+                for lang_code, translation in translations.items():
+                    if translation:
+                        content_lines.append(f"{'الترجمة' if ui_language == 'ar' else 'Translation'} ({lang_code.upper()}): {translation}")
+                
+                # Model used
+                model_used = segment.get('transcription_model')
+                if model_used:
+                    content_lines.append(f"{'النموذج المستخدم' if ui_language == 'ar' else 'Model Used'}: {model_used}")
+                
+                content_lines.append("")
+        else:
+            content_lines.append(f"{'لا توجد مقاطع نصية متاحة' if ui_language == 'ar' else 'No text segments available'}")
+        
+        content = "\n".join(content_lines)
+        
+        # Create document
+        return self.create_document(title, content)
+
+# Global instance
+google_docs_manager = GoogleDocsManager()
\ No newline at end of file
diff --git a/main.py b/main.py
new file mode 100644
index 0000000000000000000000000000000000000000..90a0ea6a19aa1c2c32980c6bc32ff8a9d07a83b1
--- /dev/null
+++ b/main.py
@@ -0,0 +1,49 @@
+#!/usr/bin/env python3
+"""
+Simple launcher for SyncMaster with integrated server
+مُشغل بسيط مع خادم متكامل - مثالي لـ HuggingFace
+"""
+
+import streamlit as st
+import os
+import sys
+import time
+
+# Add current directory to path
+sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
+
+# Initialize integrated server first
+recorder_server_started = False
+
+def start_integrated_server():
+    """Start the integrated recorder server"""
+    global recorder_server_started
+    
+    if recorder_server_started:
+        return True
+    
+    try:
+        from integrated_server import ensure_recorder_server
+        result = ensure_recorder_server()
+        if result:
+            recorder_server_started = True
+            st.success("✅ Integrated recorder server is running on port 5001")
+        else:
+            st.warning("⚠️ Could not start integrated recorder server")
+        return result
+    except Exception as e:
+        st.error(f"❌ Error starting integrated recorder server: {e}")
+        return False
+
+# Start the integrated server when the module loads
+start_integrated_server()
+
+# Import the main app module
+try:
+    import app
+except Exception as e:
+    st.error(f"❌ Error loading main application: {e}")
+    st.stop()
+
+if __name__ == "__main__":
+    print("🚀 SyncMaster main.py executed directly")
diff --git a/mp3_embedder.py b/mp3_embedder.py
new file mode 100644
index 0000000000000000000000000000000000000000..6fe4e6cab2c4acf67c557aa76e8b4332a8961670
--- /dev/null
+++ b/mp3_embedder.py
@@ -0,0 +1,323 @@
+from mutagen.mp3 import MP3
+from mutagen.id3 import ID3, SYLT, USLT, Encoding
+import os
+import tempfile
+import shutil
+import subprocess
+from typing import List, Dict, Tuple
+
+# --- Helper function to check for ffmpeg ---
+def is_ffmpeg_available():
+    """Check if ffmpeg is installed and accessible in the system's PATH."""
+    return shutil.which("ffmpeg") is not None
+
+class MP3Embedder:
+    """Handles embedding SYLT synchronized lyrics into MP3 files with robust error handling."""
+    
+    def __init__(self):
+        """Initialize the MP3 embedder."""
+        self.temp_dir = "/tmp/audio_sync"
+        os.makedirs(self.temp_dir, exist_ok=True)
+
+        self.ffmpeg_available = is_ffmpeg_available()
+
+    def embed_sylt_lyrics(self, audio_path: str, word_timestamps: List[Dict], 
+                         text: str, output_filename: str) -> Tuple[str, List[str]]:
+        """
+        Embeds SYLT synchronized lyrics into an MP3 file and returns logs.
+        
+        Returns:
+            A tuple containing:
+            - The path to the output MP3 file.
+            - A list of log messages detailing the process.
+        """
+        log_messages = []
+        def log_and_print(message):
+            log_messages.append(message)
+            print(f"MP3_EMBEDDER: {message}")
+        log_and_print(f"--- MP3Embedder initialized. ffmpeg available: {self.ffmpeg_available} ---")
+        log_and_print(f"--- Starting SYLT embedding for: {os.path.basename(audio_path)} ---")
+        output_path = os.path.join(self.temp_dir, output_filename)
+        try:
+            # --- Step 1: Ensure the file is in MP3 format ---
+            if not audio_path.lower().endswith('.mp3'):
+                if self.ffmpeg_available:
+                    log_and_print(f"'{os.path.basename(audio_path)}' is not an MP3. Converting with ffmpeg...")
+                    try:
+                        subprocess.run(
+                            ['ffmpeg', '-i', audio_path, '-codec:a', 'libmp3lame', '-q:a', '2', output_path],
+                            check=True, capture_output=True, text=True
+                        )
+                        log_and_print("--- ffmpeg conversion successful. ---")
+                    except subprocess.CalledProcessError as e:
+                        log_and_print("--- ERROR: ffmpeg conversion failed. ---")
+                        log_and_print(f"--- ffmpeg stderr: {e.stderr} ---")
+                        log_and_print("--- Fallback: Copying original file without conversion. ---")
+                        shutil.copy2(audio_path, output_path)
+                else:
+                    log_and_print("--- WARNING: ffmpeg is not available. Cannot convert non-MP3 file. Copying directly. ---")
+                    shutil.copy2(audio_path, output_path)
+            else:
+                log_and_print("--- Audio is already MP3. Copying to temporary location. ---")
+                shutil.copy2(audio_path, output_path)
+
+            # --- Step 2: Create SYLT data ---
+            log_and_print("--- Creating SYLT data from timestamps... ---")
+            sylt_data = self._create_sylt_data(word_timestamps)
+            if not sylt_data:
+                log_and_print("--- WARNING: No SYLT data could be created. Skipping embedding. ---")
+                return output_path, log_messages
+
+            log_and_print(f"--- Created {len(sylt_data)} SYLT entries. ---")
+
+            # --- Step 3: Embed data into the MP3 file ---
+            try:
+                log_and_print("--- Loading MP3 file with mutagen... ---")
+                audio_file = MP3(output_path, ID3=ID3)
+                
+                if audio_file.tags is None:
+                    log_and_print("--- No ID3 tags found. Creating new ones. ---")
+                    audio_file.add_tags()
+
+                # --- Embed SYLT (Synchronized Lyrics) ---
+                log_and_print("--- Creating and adding SYLT frame... ---")
+                sylt_frame = SYLT(
+                    encoding=Encoding.UTF8,
+                    lang='eng',
+                    format=2,
+                    type=1,
+                    text=sylt_data
+                )
+                audio_file.tags.delall('SYLT')
+                audio_file.tags.add(sylt_frame)
+
+                # --- Embed USLT (Unsynchronized Lyrics) as a fallback ---
+                log_and_print("--- Creating and adding USLT frame... ---")
+                uslt_frame = USLT(
+                    encoding=Encoding.UTF8,
+                    lang='eng',
+                    desc='',
+                    text=text
+                )
+                audio_file.tags.delall('USLT')
+                audio_file.tags.add(uslt_frame)
+
+                audio_file.save()
+                log_and_print("--- Successfully embedded SYLT and USLT frames. ---")
+                
+            except Exception as e:
+                log_and_print(f"--- ERROR: Failed to embed SYLT/USLT: {e} ---")
+            return output_path, log_messages
+
+        except Exception as e:
+            log_and_print(f"--- ERROR: Unexpected error in embed_sylt_lyrics: {e} ---")
+            return output_path, log_messages
+
+    def _create_sylt_data(self, word_timestamps: List[Dict]) -> List[tuple]:
+        """
+        Create SYLT data format from word timestamps
+        
+        Args:
+            word_timestamps: List of word timestamp dictionaries
+            
+        Returns:
+            List of tuples (text, timestamp_in_milliseconds)
+        """
+        # Debug print to check incoming data
+        print(f"DEBUG: word_timestamps received in _create_sylt_data: {word_timestamps}")
+        try:
+            sylt_data = []
+            
+            for word_data in word_timestamps:
+                word = word_data.get('word', '').strip()
+                start_time = word_data.get('start', 0)
+                
+                if word:
+                    # Convert seconds to milliseconds
+                    timestamp_ms = int(start_time * 1000)
+                    sylt_data.append((word, timestamp_ms))
+            
+            return sylt_data
+            
+        except Exception as e:
+            print(f"Error creating SYLT data: {str(e)}")
+            return []
+    
+    def _create_line_based_sylt_data(self, word_timestamps: List[Dict], max_words_per_line: int = 6) -> List[tuple]:
+        """
+        Create line-based SYLT data (alternative approach)
+        
+        Args:
+            word_timestamps: List of word timestamp dictionaries
+            max_words_per_line: Maximum words per line
+            
+        Returns:
+            List of tuples (line_text, timestamp_in_milliseconds)
+        """
+        try:
+            sylt_data = []
+            current_line = []
+            
+            for word_data in word_timestamps:
+                current_line.append(word_data)
+                
+                # Check if we should end this line
+                if len(current_line) >= max_words_per_line:
+                    if current_line:
+                        line_text = ' '.join([w.get('word', '') for w in current_line]).strip()
+                        start_time = current_line[0].get('start', 0)
+                        timestamp_ms = int(start_time * 1000)
+                        
+                        if line_text:
+                            sylt_data.append((line_text, timestamp_ms))
+                        
+                        current_line = []
+            
+            # Add remaining words as final line
+            if current_line:
+                line_text = ' '.join([w.get('word', '') for w in current_line]).strip()
+                start_time = current_line[0].get('start', 0)
+                timestamp_ms = int(start_time * 1000)
+                
+                if line_text:
+                    sylt_data.append((line_text, timestamp_ms))
+            
+            return sylt_data
+            
+        except Exception as e:
+            print(f"Error creating line-based SYLT data: {str(e)}")
+            return []
+    
+    def verify_sylt_embedding(self, mp3_path: str) -> Dict:
+        """
+        Verify that SYLT lyrics are properly embedded
+        
+        Args:
+            mp3_path: Path to the MP3 file
+            
+        Returns:
+            Dictionary with verification results
+        """
+        try:
+            audio_file = MP3(mp3_path)
+            
+            result = {
+                'has_sylt': False,
+                'has_uslt': False,
+                'sylt_entries': 0,
+                'error': None
+            }
+            
+            if audio_file.tags:
+                # Check for SYLT
+                sylt_frames = audio_file.tags.getall('SYLT')
+                if sylt_frames:
+                    result['has_sylt'] = True
+                    result['sylt_entries'] = len(sylt_frames[0].text) if sylt_frames[0].text else 0
+                
+                # Check for USLT (fallback)
+                uslt_frames = audio_file.tags.getall('USLT')
+                if uslt_frames:
+                    result['has_uslt'] = True
+            
+            return result
+            
+        except Exception as e:
+            return {
+                'has_sylt': False,
+                'has_uslt': False,
+                'sylt_entries': 0,
+                'error': str(e)
+            }
+    
+    def extract_sylt_lyrics(self, mp3_path: str) -> List[Dict]:
+        """
+        Extract SYLT lyrics from an MP3 file (for debugging)
+        
+        Args:
+            mp3_path: Path to the MP3 file
+            
+        Returns:
+            List of dictionaries with text and timestamp
+        """
+        try:
+            audio_file = MP3(mp3_path)
+            lyrics_data = []
+            
+            if audio_file.tags:
+                sylt_frames = audio_file.tags.getall('SYLT')
+                
+                for frame in sylt_frames:
+                    if frame.text:
+                        for text, timestamp_ms in frame.text:
+                            lyrics_data.append({
+                                'text': text,
+                                'timestamp': timestamp_ms / 1000.0  # Convert to seconds
+                            })
+            
+            return lyrics_data
+            
+        except Exception as e:
+            print(f"Error extracting SYLT lyrics: {str(e)}")
+            return []
+    
+    def create_lrc_file(self, word_timestamps: List[Dict], output_path: str) -> str:
+        """
+        Create an LRC (lyrics) file as an additional export option
+        
+        Args:
+            word_timestamps: List of word timestamp dictionaries
+            output_path: Path for the output LRC file
+            
+        Returns:
+            Path to the created LRC file
+        """
+        try:
+            lrc_lines = []
+            
+            # Group words into lines
+            current_line = []
+            for word_data in word_timestamps:
+                current_line.append(word_data)
+                
+                if len(current_line) >= 8:  # 8 words per line
+                    if current_line:
+                        line_text = ' '.join([w.get('word', '') for w in current_line])
+                        start_time = current_line[0].get('start', 0)
+                        
+                        # Format timestamp as [mm:ss.xx]
+                        minutes = int(start_time // 60)
+                        seconds = start_time % 60
+                        timestamp_str = f"[{minutes:02d}:{seconds:05.2f}]"
+                        
+                        lrc_lines.append(f"{timestamp_str}{line_text}")
+                        current_line = []
+            
+            # Add remaining words
+            if current_line:
+                line_text = ' '.join([w.get('word', '') for w in current_line])
+                start_time = current_line[0].get('start', 0)
+                
+                minutes = int(start_time // 60)
+                seconds = start_time % 60
+                timestamp_str = f"[{minutes:02d}:{seconds:05.2f}]"
+                
+                lrc_lines.append(f"{timestamp_str}{line_text}")
+            
+            # Write LRC file
+            with open(output_path, 'w', encoding='utf-8') as f:
+                f.write('\n'.join(lrc_lines))
+            
+            return output_path
+            
+        except Exception as e:
+            raise Exception(f"Error creating LRC file: {str(e)}")
+    
+    def __del__(self):
+        """Clean up temporary files"""
+        import shutil
+        if hasattr(self, 'temp_dir') and os.path.exists(self.temp_dir):
+            try:
+                shutil.rmtree(self.temp_dir)
+            except:
+                pass
diff --git a/package.json b/package.json
new file mode 100644
index 0000000000000000000000000000000000000000..595e35427c025edecf830a060bad16b3040d346a
--- /dev/null
+++ b/package.json
@@ -0,0 +1,19 @@
+{
+  "name": "syncmaster",
+  "version": "0.1.0",
+  "private": true,
+  "description": "AI Audio-Text Synchronization Platform – convenience wrapper for Streamlit dev server with integrated recorder",
+  "scripts": {
+    "dev": "streamlit run app.py --server.port 5050 --server.address localhost",
+    "start": "streamlit run app.py --server.port 5050 --server.address 0.0.0.0",
+    "dev-launcher": "streamlit run app_launcher.py --server.port 5050 --server.address localhost",
+    "dev-separate": "python startup.py",
+    "build": "echo 'Installing Python dependencies...' && pip install -r requirements.txt"
+  },
+  "dependencies": {
+    "streamlit": "^1.28.0"
+  },
+  "keywords": ["ai", "audio", "transcription", "synchronization", "streamlit"],
+  "author": "SyncMaster Team",
+  "license": "MIT"
+} 
\ No newline at end of file
diff --git a/packages.txt b/packages.txt
new file mode 100644
index 0000000000000000000000000000000000000000..c29778ed64799e5eb9a8bf0607a6e8036271b4e3
--- /dev/null
+++ b/packages.txt
@@ -0,0 +1,5 @@
+ffmpeg
+libavcodec-extra
+libavformat-dev
+libavutil-dev
+libmp3lame0
diff --git a/performance_test.py b/performance_test.py
new file mode 100644
index 0000000000000000000000000000000000000000..14f6d6a3939f2a18854e507d741dc48e12385188
--- /dev/null
+++ b/performance_test.py
@@ -0,0 +1,59 @@
+"""
+Performance Test for SyncMaster
+اختبار أداء التطبيق
+"""
+
+import time
+import requests
+import threading
+
+def test_load_time(url, test_name):
+    """Test page load time"""
+    try:
+        start = time.time()
+        response = requests.get(url, timeout=10)
+        end = time.time()
+        
+        load_time = end - start
+        status = response.status_code
+        
+        print(f"🧪 {test_name}:")
+        print(f"   ⏱️ Load Time: {load_time:.3f} seconds")
+        print(f"   📊 Status: {status}")
+        print(f"   ✅ {'FAST' if load_time < 0.5 else 'SLOW' if load_time > 1.0 else 'OK'}")
+        print()
+        
+        return load_time, status
+    except Exception as e:
+        print(f"❌ {test_name} failed: {e}")
+        return None, None
+
+def run_performance_tests():
+    """Run comprehensive performance tests"""
+    print("🚀 SyncMaster Performance Test")
+    print("=" * 40)
+    
+    # Test multiple requests to see consistency
+    tests = [
+        ("First Load", "http://localhost:5050"),
+        ("Second Load", "http://localhost:5050"),
+        ("Third Load", "http://localhost:5050"),
+        ("Recorder API", "http://localhost:5001/record")
+    ]
+    
+    results = []
+    for test_name, url in tests:
+        load_time, status = test_load_time(url, test_name)
+        if load_time:
+            results.append(load_time)
+        time.sleep(0.5)  # Small delay between tests
+    
+    if results:
+        avg_time = sum(results) / len(results)
+        print(f"📊 Average Load Time: {avg_time:.3f} seconds")
+        print(f"🎯 Performance Rating: {'EXCELLENT' if avg_time < 0.2 else 'GOOD' if avg_time < 0.5 else 'NEEDS IMPROVEMENT'}")
+    
+    return results
+
+if __name__ == "__main__":
+    run_performance_tests()
diff --git a/pyproject.toml b/pyproject.toml
new file mode 100644
index 0000000000000000000000000000000000000000..0c8c66ee16e4e3641b329adecae1fccb8df63079
--- /dev/null
+++ b/pyproject.toml
@@ -0,0 +1,15 @@
+[project]
+name = "repl-nix-workspace"
+version = "0.1.0"
+description = "Add your description here"
+requires-python = ">=3.11"
+dependencies = [
+    "google-genai>=1.23.0",
+    "librosa>=0.11.0",
+    "moviepy>=2.2.1",
+    "mutagen>=1.47.0",
+    "numpy>=2.2.6",
+    "openai>=1.93.0",
+    "sift-stack-py>=0.7.0",
+    "streamlit>=1.46.1",
+]
diff --git a/requirements.txt b/requirements.txt
new file mode 100644
index 0000000000000000000000000000000000000000..32f55d62ce1c8e864b43856c59778848354c92d5
--- /dev/null
+++ b/requirements.txt
@@ -0,0 +1,15 @@
+streamlit
+streamlit-audiorec
+python-dotenv
+google-generativeai
+librosa
+soundfile
+mutagen
+fastapi
+uvicorn[standard]
+websockets
+requests
+python-docx
+google-api-python-client
+google-auth-httplib2
+google-auth-oauthlib
diff --git a/run_live.py b/run_live.py
new file mode 100644
index 0000000000000000000000000000000000000000..aba8b179748ac6869be88f315c381bdfaabf948b
--- /dev/null
+++ b/run_live.py
@@ -0,0 +1,20 @@
+#!/usr/bin/env python3
+"""
+Dev launcher: starts FastAPI WS server (uvicorn) on 5001 and Streamlit app on 5050.
+"""
+import subprocess, sys, time, os
+
+def main():
+    env = os.environ.copy()
+    env.setdefault("SYNC_SERVER_BASE", "http://localhost:5001")
+
+    ws = subprocess.Popen([sys.executable, "-m", "uvicorn", "ws_server:app", "--host", "0.0.0.0", "--port", "5001"], env=env)
+    time.sleep(1.5)
+    try:
+        st = subprocess.Popen([sys.executable, "-m", "streamlit", "run", "app.py", "--server.port", "5050", "--server.address", "localhost"], env=env)
+        st.wait()
+    finally:
+        ws.terminate()
+
+if __name__ == "__main__":
+    main()
diff --git a/setup_enhanced.py b/setup_enhanced.py
new file mode 100644
index 0000000000000000000000000000000000000000..f1d526f7b3169c3f05e664c971c04c723e404c63
--- /dev/null
+++ b/setup_enhanced.py
@@ -0,0 +1,196 @@
+# SyncMaster Enhanced Setup Script
+# تشغيل SyncMaster المحسن مع دعم الترجمة
+
+import subprocess
+import sys
+import os
+import time
+from pathlib import Path
+
+def print_header():
+    print("=" * 60)
+    print("🎵 SyncMaster Enhanced - AI-Powered Translation Setup")
+    print("منصة المزامنة الذكية مع دعم الترجمة بالذكاء الاصطناعي")
+    print("=" * 60)
+
+def check_python_version():
+    """Check if Python version is compatible"""
+    if sys.version_info < (3, 8):
+        print("❌ Error: Python 3.8 or higher is required.")
+        print("خطأ: يتطلب Python 3.8 أو أحدث")
+        return False
+    print(f"✅ Python version: {sys.version}")
+    return True
+
+def install_requirements():
+    """Install required packages"""
+    print("\n📦 Installing required packages...")
+    print("تثبيت الحزم المطلوبة...")
+    
+    try:
+        subprocess.check_call([sys.executable, "-m", "pip", "install", "-r", "requirements.txt"])
+        print("✅ All packages installed successfully!")
+        print("تم تثبيت جميع الحزم بنجاح!")
+        return True
+    except subprocess.CalledProcessError as e:
+        print(f"❌ Error installing packages: {e}")
+        print(f"خطأ في تثبيت الحزم: {e}")
+        return False
+
+def check_env_file():
+    """Check if .env file exists and has required keys"""
+    env_path = Path(".env")
+    if not env_path.exists():
+        print("❌ .env file not found!")
+        print("ملف .env غير موجود!")
+        create_env_file()
+        return False
+    
+    with open(env_path, 'r') as f:
+        content = f.read()
+        if "GEMINI_API_KEY" not in content:
+            print("❌ GEMINI_API_KEY not found in .env file!")
+            print("مفتاح GEMINI_API_KEY غير موجود في ملف .env!")
+            return False
+    
+    print("✅ Environment file configured correctly!")
+    print("ملف البيئة مُعدّ بشكل صحيح!")
+    return True
+
+def create_env_file():
+    """Create a template .env file"""
+    print("\n📝 Creating .env template file...")
+    print("إنشاء ملف قالب .env...")
+    
+    env_content = """# SyncMaster Configuration
+# إعدادات SyncMaster
+
+# Gemini AI API Key (Required for transcription and translation)
+# مفتاح Gemini AI (مطلوب للنسخ والترجمة)
+GEMINI_API_KEY=your_gemini_api_key_here
+
+# Optional: Set default language (en/ar)
+# اختياري: تعيين اللغة الافتراضية
+DEFAULT_LANGUAGE=en
+
+# Optional: Enable translation by default
+# اختياري: تفعيل الترجمة افتراضياً
+ENABLE_TRANSLATION=true
+
+# Optional: Default target language for translation
+# اختياري: اللغة المستهدفة للترجمة افتراضياً
+DEFAULT_TARGET_LANGUAGE=ar
+"""
+    
+    with open(".env", "w", encoding="utf-8") as f:
+        f.write(env_content)
+    
+    print("✅ .env template created!")
+    print("تم إنشاء قالب .env!")
+    print("\n🔑 Please edit .env file and add your Gemini API key:")
+    print("يرجى تحرير ملف .env وإضافة مفتاح Gemini API الخاص بك:")
+    print("GEMINI_API_KEY=your_actual_api_key")
+
+def start_recorder_server():
+    """Start the Flask recorder server"""
+    print("\n🚀 Starting recorder server...")
+    print("بدء تشغيل خادم التسجيل...")
+    
+    try:
+        # Start recorder server in background
+        process = subprocess.Popen([
+            sys.executable, "recorder_server.py"
+        ], stdout=subprocess.PIPE, stderr=subprocess.PIPE)
+        
+        print("✅ Recorder server started on http://localhost:5001")
+        print("تم بدء تشغيل خادم التسجيل على http://localhost:5001")
+        return process
+    except Exception as e:
+        print(f"❌ Error starting recorder server: {e}")
+        print(f"خطأ في بدء تشغيل خادم التسجيل: {e}")
+        return None
+
+def start_streamlit_app():
+    """Start the main Streamlit application"""
+    print("\n🌟 Starting SyncMaster main application...")
+    print("بدء تشغيل تطبيق SyncMaster الرئيسي...")
+    
+    try:
+        subprocess.run([
+            sys.executable, "-m", "streamlit", "run", "app.py",
+            "--server.port", "8501",
+            "--server.address", "localhost"
+        ])
+    except KeyboardInterrupt:
+        print("\n👋 Application stopped by user.")
+        print("تم إيقاف التطبيق بواسطة المستخدم.")
+    except Exception as e:
+        print(f"❌ Error starting Streamlit app: {e}")
+        print(f"خطأ في بدء تشغيل تطبيق Streamlit: {e}")
+
+def print_usage_instructions():
+    """Print usage instructions"""
+    print("\n📖 Usage Instructions / تعليمات الاستخدام:")
+    print("-" * 40)
+    print("1. Open your browser and go to: http://localhost:8501")
+    print("   افتح متصفحك واذهب إلى: http://localhost:8501")
+    print("\n2. For recording, the recorder interface is at: http://localhost:5001")
+    print("   للتسجيل، واجهة التسجيل متاحة على: http://localhost:5001")
+    print("\n3. Choose your language (English/العربية) from the sidebar")
+    print("   اختر لغتك (English/العربية) من الشريط الجانبي")
+    print("\n4. Enable translation and select target language")
+    print("   فعّل الترجمة واختر اللغة المستهدفة")
+    print("\n5. Upload audio or record directly from microphone")
+    print("   ارفع ملف صوتي أو سجل مباشرة من الميكروفون")
+    print("\n📚 For detailed instructions, see README_AR.md")
+    print("للتعليمات المفصلة، راجع ملف README_AR.md")
+
+def main():
+    """Main setup function"""
+    print_header()
+    
+    # Check Python version
+    if not check_python_version():
+        return
+    
+    # Install requirements
+    if not install_requirements():
+        return
+    
+    # Check environment configuration
+    if not check_env_file():
+        print("\n⚠️  Please configure your .env file before running the application.")
+        print("يرجى إعداد ملف .env قبل تشغيل التطبيق.")
+        return
+    
+    print("\n🎉 Setup completed successfully!")
+    print("تم الإعداد بنجاح!")
+    
+    print_usage_instructions()
+    
+    # Ask user if they want to start the application
+    print("\n" + "=" * 60)
+    start_now = input("Start SyncMaster now? (y/n) / تشغيل SyncMaster الآن؟ (y/n): ").lower().strip()
+    
+    if start_now in ['y', 'yes', 'نعم']:
+        # Start recorder server
+        recorder_process = start_recorder_server()
+        
+        # Wait a moment for server to start
+        time.sleep(2)
+        
+        # Start main application
+        try:
+            start_streamlit_app()
+        finally:
+            # Clean up recorder server
+            if recorder_process:
+                recorder_process.terminate()
+                print("\n🧹 Cleaning up processes...")
+                print("تنظيف العمليات...")
+    else:
+        print("\n👋 Setup complete. Run 'python setup_enhanced.py' when ready.")
+        print("الإعداد مكتمل. شغّل 'python setup_enhanced.py' عندما تكون جاهزاً.")
+
+if __name__ == "__main__":
+    main()
diff --git a/simple_debug.py b/simple_debug.py
new file mode 100644
index 0000000000000000000000000000000000000000..2776e6f8aa59b9128c886e66bd6a880ace4db1c2
--- /dev/null
+++ b/simple_debug.py
@@ -0,0 +1,132 @@
+# simple_debug.py - Simple debug for AI Questions
+
+import os
+import sys
+from dotenv import load_dotenv
+
+def check_translator_config():
+    """Check translator configuration"""
+    
+    print("🔍 Checking Translator Configuration...")
+    
+    # Force reload
+    load_dotenv(override=True)
+    
+    if 'translator' in sys.modules:
+        del sys.modules['translator']
+    
+    from translator import get_translator
+    
+    translator = get_translator()
+    
+    print(f"📋 OpenRouter Model: {translator.openrouter_model}")
+    print(f"🔑 Has API Key: {'Yes' if translator.openrouter_api_key else 'No'}")
+    
+    # Check the candidates list
+    print(f"📝 Checking candidates in _openrouter_complete method...")
+    
+    # Read the translator.py file to see the candidates
+    try:
+        with open('translator.py', 'r', encoding='utf-8') as f:
+            content = f.read()
+        
+        # Find the candidates section
+        if 'candidates = [' in content:
+            start = content.find('candidates = [')
+            end = content.find(']', start) + 1
+            candidates_section = content[start:end]
+            print(f"📋 Candidates section:\n{candidates_section}")
+        else:
+            print("❌ Could not find candidates section")
+            
+    except Exception as e:
+        print(f"❌ Error reading translator.py: {str(e)}")
+    
+    return translator
+
+def check_ai_questions_config():
+    """Check AI questions configuration"""
+    
+    print("\n🔍 Checking AI Questions Configuration...")
+    
+    if 'ai_questions' in sys.modules:
+        del sys.modules['ai_questions']
+    
+    from ai_questions import get_ai_question_engine
+    
+    engine = get_ai_question_engine()
+    
+    print(f"🔧 Engine has translator: {'Yes' if engine.translator else 'No'}")
+    
+    if engine.translator:
+        print(f"📋 Engine translator model: {engine.translator.openrouter_model}")
+    
+    return engine
+
+def find_old_model_references():
+    """Find any remaining references to old model"""
+    
+    print("\n🔍 Searching for old model references...")
+    
+    files_to_check = ['translator.py', 'ai_questions.py', 'app.py']
+    old_models = ['meta-llama-3-70b-instruct', 'llama-3-70b-instruct', 'meta-llama/llama-3-70b-instruct']
+    
+    for file_name in files_to_check:
+        try:
+            with open(file_name, 'r', encoding='utf-8') as f:
+                content = f.read()
+            
+            for old_model in old_models:
+                if old_model in content:
+                    print(f"❌ Found '{old_model}' in {file_name}")
+                    # Find the line number
+                    lines = content.split('\n')
+                    for i, line in enumerate(lines):
+                        if old_model in line:
+                            print(f"   Line {i+1}: {line.strip()}")
+                else:
+                    print(f"✅ No '{old_model}' in {file_name}")
+                    
+        except Exception as e:
+            print(f"❌ Error checking {file_name}: {str(e)}")
+
+def check_env_file():
+    """Check .env file content"""
+    
+    print("\n🔍 Checking .env file...")
+    
+    try:
+        with open('.env', 'r', encoding='utf-8') as f:
+            content = f.read()
+        
+        print("📋 .env file content:")
+        for line in content.split('\n'):
+            if 'OPENROUTER' in line:
+                print(f"  {line}")
+                
+    except Exception as e:
+        print(f"❌ Error reading .env: {str(e)}")
+
+def main():
+    """Main debug function"""
+    
+    print("🚀 Simple AI Questions Debug")
+    print("=" * 50)
+    
+    # Check environment
+    check_env_file()
+    
+    # Check translator
+    translator = check_translator_config()
+    
+    # Check AI questions
+    engine = check_ai_questions_config()
+    
+    # Find old references
+    find_old_model_references()
+    
+    print("\n" + "=" * 50)
+    print("🎯 Debug Complete!")
+
+if __name__ == "__main__":
+    main()
\ No newline at end of file
diff --git a/smoke_test.py b/smoke_test.py
new file mode 100644
index 0000000000000000000000000000000000000000..85792c9ef027a1c2df78915d9ec95991181f7ce3
--- /dev/null
+++ b/smoke_test.py
@@ -0,0 +1,53 @@
+#!/usr/bin/env python3
+import asyncio, json, base64, time
+import websockets
+import requests
+
+WS = "ws://localhost:5001/ws/stream/test-sess"
+REST = "http://localhost:5001"
+
+async def send_chunks():
+    async with websockets.connect(WS) as ws:
+        start = int(time.time() * 1000)
+        for i in range(3):
+            t0 = start + i*500
+            t1 = t0 + 500
+            # send tiny fake payload
+            payload = {
+                "type": "audio.chunk",
+                "session_id": "test-sess",
+                "seq": i,
+                "t0_ms": t0,
+                "t1_ms": t1,
+                "mime": "audio/webm;codecs=opus",
+                "b64": base64.b64encode(b"fake").decode("ascii"),
+            }
+            await ws.send(json.dumps(payload))
+            ack = await ws.recv()
+            print("ACK:", ack)
+
+def request_transcribe():
+    r = requests.post(f"{REST}/transcribe_slice", json={
+        "session_id": "test-sess",
+        "slice_id": "slice-1",
+        "offset_ms": 1500,
+        "requested_tier": "A"
+    }, timeout=5)
+    r.raise_for_status()
+    job_id = r.json()["job_id"]
+    print("job_id:", job_id)
+    for _ in range(40):
+        jr = requests.get(f"{REST}/job/{job_id}", timeout=5)
+        if jr.status_code != 200:
+            time.sleep(0.1)
+            continue
+        d = jr.json()
+        if d.get("status") == "done":
+            print("RESULT:", json.dumps(d["result"], ensure_ascii=False))
+            return
+        time.sleep(0.1)
+    print("Timed out waiting for result")
+
+if __name__ == "__main__":
+    asyncio.run(send_chunks())
+    request_transcribe()
diff --git a/start_debug.py b/start_debug.py
new file mode 100644
index 0000000000000000000000000000000000000000..c4008b367564832ce5b06eb77c1721b7628f1382
--- /dev/null
+++ b/start_debug.py
@@ -0,0 +1,209 @@
+#!/usr/bin/env python3
+"""
+Enhanced startup script for SyncMaster with debugging capabilities
+نص بدء التشغيل المحسن لـ SyncMaster مع قدرات التتبع
+"""
+
+import os
+import sys
+import time
+import socket
+import subprocess
+import psutil
+from pathlib import Path
+
+def check_port_available(port):
+    """Check if a port is available"""
+    try:
+        with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s:
+            s.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
+            s.bind(('localhost', port))
+            return True
+    except:
+        return False
+
+def kill_processes_on_port(port):
+    """Kill processes using a specific port"""
+    try:
+        for proc in psutil.process_iter(['pid', 'name', 'connections']):
+            try:
+                connections = proc.info['connections']
+                if connections:
+                    for conn in connections:
+                        if conn.laddr.port == port:
+                            print(f"🔄 Killing process {proc.info['name']} (PID: {proc.info['pid']}) using port {port}")
+                            proc.kill()
+                            time.sleep(1)
+            except (psutil.NoSuchProcess, psutil.AccessDenied):
+                continue
+    except Exception as e:
+        print(f"⚠️ Error killing processes on port {port}: {e}")
+
+def check_dependencies():
+    """Check if required dependencies are installed"""
+    required_packages = [
+        'streamlit', 'flask', 'librosa', 'soundfile', 
+        'google-generativeai', 'python-dotenv'
+    ]
+    
+    missing_packages = []
+    for package in required_packages:
+        try:
+            __import__(package.replace('-', '_'))
+        except ImportError:
+            missing_packages.append(package)
+    
+    if missing_packages:
+        print(f"❌ Missing packages: {', '.join(missing_packages)}")
+        print("📦 Installing missing packages...")
+        subprocess.run([sys.executable, '-m', 'pip', 'install'] + missing_packages)
+        return False
+    return True
+
+def check_env_file():
+    """Check if .env file exists and has required keys"""
+    env_path = Path('.env')
+    if not env_path.exists():
+        print("❌ .env file not found!")
+        print("📝 Creating sample .env file...")
+        with open('.env', 'w') as f:
+            f.write("GEMINI_API_KEY=your_api_key_here\n")
+        print("✅ Please add your Gemini API key to .env file")
+        return False
+    
+    # Check if API key is set
+    try:
+        from dotenv import load_dotenv
+        load_dotenv()
+        api_key = os.getenv("GEMINI_API_KEY")
+        if not api_key or api_key == "your_api_key_here":
+            print("⚠️ GEMINI_API_KEY not properly set in .env file")
+            return False
+    except Exception as e:
+        print(f"❌ Error reading .env file: {e}")
+        return False
+    
+    return True
+
+def start_recorder_server():
+    """Start the recorder server"""
+    print("🎙️ Starting recorder server...")
+    
+    # Kill any existing processes on port 5001
+    if not check_port_available(5001):
+        print("🔄 Port 5001 is busy, killing existing processes...")
+        kill_processes_on_port(5001)
+        time.sleep(2)
+    
+    if check_port_available(5001):
+        try:
+            # Start recorder server
+            server_process = subprocess.Popen(
+                [sys.executable, 'recorder_server.py'],
+                stdout=subprocess.PIPE,
+                stderr=subprocess.PIPE,
+                creationflags=subprocess.CREATE_NEW_CONSOLE if os.name == 'nt' else 0
+            )
+            
+            # Wait for server to start
+            time.sleep(3)
+            
+            # Test server connection
+            import requests
+            try:
+                response = requests.get('http://localhost:5001/record', timeout=5)
+                if response.status_code == 200:
+                    print("✅ Recorder server started successfully on port 5001")
+                    return server_process
+                else:
+                    raise Exception(f"Server responded with status {response.status_code}")
+            except Exception as e:
+                print(f"❌ Failed to connect to recorder server: {e}")
+                server_process.terminate()
+                return None
+                
+        except Exception as e:
+            print(f"❌ Failed to start recorder server: {e}")
+            return None
+    else:
+        print("❌ Port 5001 is still not available")
+        return None
+
+def start_main_app():
+    """Start the main Streamlit application"""
+    print("🚀 Starting main SyncMaster application...")
+    
+    # Find available port for Streamlit
+    streamlit_port = 8501
+    while not check_port_available(streamlit_port) and streamlit_port < 8510:
+        streamlit_port += 1
+    
+    if streamlit_port >= 8510:
+        print("❌ No available ports for Streamlit (tried 8501-8509)")
+        return None
+    
+    try:
+        # Start Streamlit app
+        subprocess.run([
+            sys.executable, '-m', 'streamlit', 'run', 'app.py',
+            '--server.port', str(streamlit_port),
+            '--server.address', 'localhost',
+            '--browser.gatherUsageStats', 'false'
+        ])
+    except KeyboardInterrupt:
+        print("\n🛑 Application stopped by user")
+    except Exception as e:
+        print(f"❌ Failed to start main application: {e}")
+
+def main():
+    """Main startup function"""
+    print("=" * 60)
+    print("🎵 SyncMaster Enhanced - Startup Script")
+    print("منصة المزامنة الذكية - سكريبت البدء")
+    print("=" * 60)
+    
+    # Change to script directory
+    script_dir = Path(__file__).parent
+    os.chdir(script_dir)
+    print(f"📁 Working directory: {script_dir}")
+    
+    # Step 1: Check dependencies
+    print("\n📦 Checking dependencies...")
+    if not check_dependencies():
+        print("❌ Please restart after installing dependencies")
+        return
+    print("✅ All dependencies available")
+    
+    # Step 2: Check environment file
+    print("\n🔑 Checking environment configuration...")
+    if not check_env_file():
+        print("❌ Please configure .env file and restart")
+        return
+    print("✅ Environment configuration OK")
+    
+    # Step 3: Start recorder server
+    print("\n🎙️ Starting recording server...")
+    server_process = start_recorder_server()
+    if not server_process:
+        print("❌ Failed to start recorder server")
+        return
+    
+    # Step 4: Start main application
+    print("\n🌐 Starting web interface...")
+    print("📱 The application will open in your browser")
+    print("🎙️ Recording interface: http://localhost:5001")
+    print("💻 Main interface: http://localhost:8501")
+    print("\nPress Ctrl+C to stop all services")
+    
+    try:
+        start_main_app()
+    finally:
+        # Cleanup
+        print("\n🧹 Cleaning up...")
+        if server_process:
+            server_process.terminate()
+            print("✅ Recorder server stopped")
+        print("👋 Goodbye!")
+
+if __name__ == "__main__":
+    main()
diff --git a/start_enhanced.bat b/start_enhanced.bat
new file mode 100644
index 0000000000000000000000000000000000000000..60b125be7bf0c1ec1b60ec7586e259b9c523b219
--- /dev/null
+++ b/start_enhanced.bat
@@ -0,0 +1,57 @@
+@echo off
+echo ===============================================
+echo SyncMaster Enhanced - Quick Start
+echo منصة المزامنة الذكية - البدء السريع  
+echo ===============================================
+echo.
+
+echo ✅ All system tests passed! / جميع الاختبارات نجحت!
+echo 🚀 Starting SyncMaster Enhanced...
+echo.
+
+REM Check if Python is installed
+python --version >nul 2>&1
+if errorlevel 1 (
+    echo ❌ ERROR: Python is not installed or not in PATH
+    echo خطأ: Python غير مثبت أو غير موجود في PATH
+    echo Please install Python 3.8+ from python.org
+    pause
+    exit /b 1
+)
+
+REM Check if .env file exists
+if not exist ".env" (
+    echo ⚠️ WARNING: .env file not found!
+    echo تحذير: ملف .env غير موجود!
+    echo Creating sample .env file...
+    echo GEMINI_API_KEY=your_api_key_here > .env
+    echo Please add your Gemini API key to .env file
+    echo يرجى إضافة مفتاح Gemini API إلى ملف .env
+    pause
+    exit /b 1
+)
+
+echo 🔍 Running system test...
+echo تشغيل اختبار النظام...
+python test_system.py
+if errorlevel 1 (
+    echo ❌ System test failed! Please fix issues first.
+    echo فشل اختبار النظام! يرجى إصلاح المشاكل أولاً.
+    pause
+    exit /b 1
+)
+
+echo.
+echo ✅ System test passed! Starting application...
+echo نجح اختبار النظام! بدء تشغيل التطبيق...
+echo.
+
+REM Use debug startup for better error handling
+echo 🚀 Starting with advanced debugging...
+echo بدء التشغيل مع التشخيص المتقدم...
+python start_debug.py
+
+echo.
+echo 👋 Application stopped. Press any key to exit.
+echo تم إيقاف التطبيق. اضغط أي زر للخروج.
+pause
diff --git a/startup.py b/startup.py
new file mode 100644
index 0000000000000000000000000000000000000000..0bcbfe5db61129459d957a46962a3c6dd35bdade
--- /dev/null
+++ b/startup.py
@@ -0,0 +1,218 @@
+#!/usr/bin/env python3
+"""
+Startup Script for SyncMaster
+نقطة دخول موحدة تضمن تشغيل جميع المكونات المطلوبة
+"""
+
+import os
+import sys
+import time
+import logging
+import subprocess
+import signal
+import atexit
+from pathlib import Path
+
+# Configure logging
+logging.basicConfig(
+    level=logging.INFO,
+    format='%(asctime)s - %(levelname)s - %(message)s'
+)
+
+class SyncMasterLauncher:
+    def __init__(self):
+        self.recorder_process = None
+        self.streamlit_process = None
+        self.cleanup_registered = False
+        
+    def setup_cleanup(self):
+        """Setup cleanup handlers"""
+        if not self.cleanup_registered:
+            atexit.register(self.cleanup)
+            signal.signal(signal.SIGINT, self.signal_handler)
+            signal.signal(signal.SIGTERM, self.signal_handler)
+            self.cleanup_registered = True
+    
+    def signal_handler(self, signum, frame):
+        """Handle termination signals"""
+        logging.info(f"Received signal {signum}, cleaning up...")
+        self.cleanup()
+        sys.exit(0)
+    
+    def cleanup(self):
+        """Clean up all processes"""
+        logging.info("🧹 Cleaning up processes...")
+        
+        if self.recorder_process and self.recorder_process.poll() is None:
+            try:
+                self.recorder_process.terminate()
+                self.recorder_process.wait(timeout=5)
+                logging.info("✅ Recorder server terminated")
+            except:
+                try:
+                    self.recorder_process.kill()
+                    logging.info("⚠️ Recorder server killed")
+                except:
+                    pass
+        
+        if self.streamlit_process and self.streamlit_process.poll() is None:
+            try:
+                self.streamlit_process.terminate()
+                self.streamlit_process.wait(timeout=5)
+                logging.info("✅ Streamlit server terminated")
+            except:
+                try:
+                    self.streamlit_process.kill()
+                    logging.info("⚠️ Streamlit server killed")
+                except:
+                    pass
+    
+    def start_recorder_server(self):
+        """Start the recorder server"""
+        try:
+            logging.info("🚀 Starting recorder server...")
+            self.recorder_process = subprocess.Popen(
+                [sys.executable, 'recorder_server.py'],
+                stdout=subprocess.PIPE,
+                stderr=subprocess.PIPE
+            )
+            
+            # Wait for server to start
+            time.sleep(3)
+            
+            # Check if process is running
+            if self.recorder_process.poll() is None:
+                # Verify server is responding
+                try:
+                    import requests
+                    response = requests.get('http://localhost:5001/record', timeout=5)
+                    if response.status_code == 200:
+                        logging.info("✅ Recorder server started successfully on port 5001")
+                        return True
+                    else:
+                        logging.warning(f"⚠️ Recorder server responded with status: {response.status_code}")
+                except Exception as e:
+                    logging.warning(f"⚠️ Could not verify recorder server: {e}")
+                
+                # Server process is running even if verification failed
+                return True
+            else:
+                logging.error("❌ Recorder server process failed to start")
+                return False
+                
+        except Exception as e:
+            logging.error(f"❌ Failed to start recorder server: {e}")
+            return False
+    
+    def start_streamlit_app(self, port=5050, host="0.0.0.0"):
+        """Start the Streamlit application"""
+        try:
+            logging.info(f"🚀 Starting Streamlit app on {host}:{port}...")
+            
+            cmd = [
+                sys.executable, '-m', 'streamlit', 'run', 'app.py',
+                '--server.port', str(port),
+                '--server.address', host,
+                '--server.headless', 'true',
+                '--browser.gatherUsageStats', 'false'
+            ]
+            
+            self.streamlit_process = subprocess.Popen(cmd)
+            
+            # Wait a bit for Streamlit to start
+            time.sleep(5)
+            
+            if self.streamlit_process.poll() is None:
+                logging.info(f"✅ Streamlit app started successfully on http://{host}:{port}")
+                return True
+            else:
+                logging.error("❌ Streamlit app failed to start")
+                return False
+                
+        except Exception as e:
+            logging.error(f"❌ Failed to start Streamlit app: {e}")
+            return False
+    
+    def launch_integrated(self):
+        """Launch with integrated server (recommended for HuggingFace)"""
+        logging.info("🚀 Launching SyncMaster with integrated server...")
+        self.setup_cleanup()
+        
+        # Start Streamlit with integrated server
+        try:
+            # Import to trigger integrated server startup
+            import app
+            
+            # Run Streamlit
+            import streamlit.web.cli as stcli
+            import sys
+            
+            # Set command line arguments for Streamlit
+            sys.argv = [
+                "streamlit", "run", "app.py",
+                "--server.port", "5050",
+                "--server.address", "0.0.0.0",
+                "--server.headless", "true",
+                "--browser.gatherUsageStats", "false"
+            ]
+            
+            # Run Streamlit CLI
+            stcli.main()
+            
+        except Exception as e:
+            logging.error(f"❌ Failed to launch integrated mode: {e}")
+            return False
+    
+    def launch_separate(self):
+        """Launch with separate processes (development mode)"""
+        logging.info("🚀 Launching SyncMaster with separate processes...")
+        self.setup_cleanup()
+        
+        # Start recorder server first
+        if not self.start_recorder_server():
+            logging.error("❌ Failed to start recorder server, aborting...")
+            return False
+        
+        # Start Streamlit app
+        if not self.start_streamlit_app():
+            logging.error("❌ Failed to start Streamlit app, aborting...")
+            self.cleanup()
+            return False
+        
+        logging.info("✅ All services started successfully!")
+        logging.info("🌐 Access the application at: http://localhost:5050")
+        logging.info("🎙️ Recorder API available at: http://localhost:5001")
+        
+        try:
+            # Keep the main process alive
+            while True:
+                time.sleep(1)
+                
+                # Check if processes are still running
+                if self.recorder_process and self.recorder_process.poll() is not None:
+                    logging.error("❌ Recorder server process died")
+                    break
+                
+                if self.streamlit_process and self.streamlit_process.poll() is not None:
+                    logging.error("❌ Streamlit app process died")
+                    break
+                    
+        except KeyboardInterrupt:
+            logging.info("👋 Shutting down...")
+        finally:
+            self.cleanup()
+
+def main():
+    """Main entry point"""
+    launcher = SyncMasterLauncher()
+    
+    # Check if running in HuggingFace or similar environment
+    if os.getenv('SPACE_ID') or '--integrated' in sys.argv:
+        # Use integrated mode for cloud deployments
+        launcher.launch_integrated()
+    else:
+        # Use separate processes for local development
+        launcher.launch_separate()
+
+if __name__ == "__main__":
+    main()
diff --git a/style_fixes.py b/style_fixes.py
new file mode 100644
index 0000000000000000000000000000000000000000..f6ecb844f81fc60f8e70df3168afd1a0d045ab43
--- /dev/null
+++ b/style_fixes.py
@@ -0,0 +1,392 @@
+# style_fixes.py - CSS fixes for better UI appearance
+
+def get_custom_css():
+    """Return custom CSS for Dark Theme with chat bubble styling"""
+    return """
+    <style>
+    /* ===== DARK THEME BASE ===== */
+    .stApp {
+        background-color: #000000 !important;
+        color: #ffffff !important;
+    }
+    
+    /* Main container dark background */
+    .main .block-container {
+        background-color: #000000 !important;
+        color: #ffffff !important;
+        padding-top: 2rem;
+        padding-bottom: 2rem;
+    }
+    
+    /* Sidebar dark theme */
+    .css-1d391kg {
+        background-color: #1a1a1a !important;
+    }
+    
+    /* ===== TEXT COLORS FOR DARK THEME ===== */
+    .stMarkdown, .stMarkdown p, .stMarkdown div {
+        color: #ffffff !important;
+    }
+    
+    /* Headers in white */
+    h1, h2, h3, h4, h5, h6 {
+        color: #ffffff !important;
+    }
+    
+    /* Input fields dark theme */
+    .stTextInput > div > div > input {
+        background-color: #2d2d2d !important;
+        color: #ffffff !important;
+        border: 1px solid #444444 !important;
+        border-radius: 10px !important;
+    }
+    
+    .stTextInput > div > div > input:focus {
+        border-color: #25D366 !important;
+        box-shadow: 0 0 0 2px rgba(37, 211, 102, 0.2) !important;
+    }
+    
+    .stSelectbox > div > div > div {
+        background-color: #2d2d2d !important;
+        color: #ffffff !important;
+        border: 1px solid #444444 !important;
+        border-radius: 10px !important;
+    }
+    
+    .stTextArea > div > div > textarea {
+        background-color: #2d2d2d !important;
+        color: #ffffff !important;
+        border: 1px solid #444444 !important;
+        border-radius: 10px !important;
+    }
+    
+    .stCheckbox > label {
+        color: #ffffff !important;
+    }
+    
+    .stRadio > label {
+        color: #ffffff !important;
+    }
+    
+    .stSlider > div > div > div > div {
+        background-color: #25D366 !important;
+    }
+    
+    /* ===== CHAT BUBBLE STYLING FOR BROADCAST ===== */
+    .broadcast-bubble {
+        background: linear-gradient(135deg, #25D366 0%, #128C7E 100%) !important;
+        color: #ffffff !important;
+        padding: 15px 20px;
+        border-radius: 18px 18px 18px 5px;
+        margin: 8px 0;
+        max-width: 85%;
+        box-shadow: 0 2px 8px rgba(37, 211, 102, 0.3);
+        position: relative;
+        word-wrap: break-word;
+        font-size: 14px;
+        line-height: 1.4;
+    }
+    
+    .broadcast-bubble::before {
+        content: '';
+        position: absolute;
+        bottom: 0;
+        left: -8px;
+        width: 0;
+        height: 0;
+        border: 8px solid transparent;
+        border-bottom-color: #25D366;
+        border-left: 0;
+        border-bottom-left-radius: 16px 14px;
+        transform: translate(0, 0);
+    }
+    
+    /* Selected broadcast bubble */
+    .broadcast-bubble-selected {
+        background: linear-gradient(135deg, #007bff 0%, #0056b3 100%) !important;
+        color: #ffffff !important;
+        padding: 15px 20px;
+        border-radius: 18px 18px 18px 5px;
+        margin: 8px 0;
+        max-width: 85%;
+        box-shadow: 0 2px 8px rgba(0, 123, 255, 0.4);
+        position: relative;
+        word-wrap: break-word;
+        font-size: 14px;
+        line-height: 1.4;
+        border: 2px solid #17a2b8;
+    }
+    
+    .broadcast-bubble-selected::before {
+        content: '';
+        position: absolute;
+        bottom: 0;
+        left: -8px;
+        width: 0;
+        height: 0;
+        border: 8px solid transparent;
+        border-bottom-color: #007bff;
+        border-left: 0;
+        border-bottom-left-radius: 16px 14px;
+        transform: translate(0, 0);
+    }
+    
+    /* Timestamp styling for broadcast */
+    .broadcast-timestamp {
+        font-size: 11px;
+        color: rgba(255, 255, 255, 0.7) !important;
+        margin-top: 5px;
+        text-align: right;
+    }
+    
+    /* ===== WHITE CONTAINERS FOR TRANSLATION & ORIGINAL TEXT ===== */
+    .white-container {
+        background-color: #ffffff !important;
+        color: #000000 !important;
+        padding: 20px;
+        border-radius: 15px;
+        margin: 15px 0;
+        box-shadow: 0 4px 12px rgba(255, 255, 255, 0.1);
+        border: 1px solid #333333;
+    }
+    
+    .white-container h3 {
+        color: #000000 !important;
+        margin-bottom: 15px;
+    }
+    
+    .white-container p, .white-container div {
+        color: #000000 !important;
+        line-height: 1.6;
+    }
+    
+    /* ===== BUTTON STYLING FOR DARK THEME ===== */
+    .stButton > button {
+        background: linear-gradient(135deg, #25D366 0%, #128C7E 100%) !important;
+        color: #ffffff !important;
+        border: none !important;
+        border-radius: 25px !important;
+        padding: 10px 20px !important;
+        font-weight: 600 !important;
+        transition: all 0.3s ease !important;
+        box-shadow: 0 4px 12px rgba(37, 211, 102, 0.3) !important;
+        min-height: 40px !important;
+    }
+    
+    .stButton > button:hover {
+        transform: translateY(-2px) !important;
+        box-shadow: 0 6px 16px rgba(37, 211, 102, 0.4) !important;
+        background: linear-gradient(135deg, #128C7E 0%, #25D366 100%) !important;
+    }
+    
+    /* Primary button styling */
+    .stButton > button[kind="primary"] {
+        background: linear-gradient(135deg, #007bff 0%, #0056b3 100%) !important;
+        box-shadow: 0 4px 12px rgba(0, 123, 255, 0.3) !important;
+    }
+    
+    .stButton > button[kind="primary"]:hover {
+        background: linear-gradient(135deg, #0056b3 0%, #007bff 100%) !important;
+        box-shadow: 0 6px 16px rgba(0, 123, 255, 0.4) !important;
+    }
+    
+    /* Secondary button styling */
+    .stButton > button[kind="secondary"] {
+        background: linear-gradient(135deg, #6c757d 0%, #495057 100%) !important;
+        box-shadow: 0 4px 12px rgba(108, 117, 125, 0.3) !important;
+    }
+    
+    /* ===== EXPANDER STYLING ===== */
+    .streamlit-expanderHeader {
+        background-color: #2d2d2d !important;
+        color: #ffffff !important;
+        border-radius: 10px !important;
+    }
+    
+    .streamlit-expanderContent {
+        background-color: #1a1a1a !important;
+        border-radius: 0 0 10px 10px !important;
+    }
+    
+    /* ===== MODAL AND POPUP STYLING ===== */
+    .modal-content {
+        background-color: #2d2d2d !important;
+        color: #ffffff !important;
+        border-radius: 15px !important;
+        padding: 25px !important;
+        box-shadow: 0 8px 32px rgba(0, 0, 0, 0.5) !important;
+        border: 1px solid #444444 !important;
+    }
+    
+    /* ===== STATUS INDICATORS ===== */
+    .status-success {
+        color: #28a745 !important;
+        font-weight: bold;
+        text-shadow: 0 0 5px rgba(40, 167, 69, 0.5);
+    }
+    
+    .status-error {
+        color: #dc3545 !important;
+        font-weight: bold;
+        text-shadow: 0 0 5px rgba(220, 53, 69, 0.5);
+    }
+    
+    .status-warning {
+        color: #ffc107 !important;
+        font-weight: bold;
+        text-shadow: 0 0 5px rgba(255, 193, 7, 0.5);
+    }
+    
+    /* Streamlit alert boxes */
+    .stAlert {
+        background-color: rgba(45, 45, 45, 0.8) !important;
+        border: 1px solid #444444 !important;
+        border-radius: 10px !important;
+        color: #ffffff !important;
+    }
+    
+    .stSuccess {
+        background-color: rgba(40, 167, 69, 0.2) !important;
+        border-left: 4px solid #28a745 !important;
+        color: #ffffff !important;
+    }
+    
+    .stError {
+        background-color: rgba(220, 53, 69, 0.2) !important;
+        border-left: 4px solid #dc3545 !important;
+        color: #ffffff !important;
+    }
+    
+    .stWarning {
+        background-color: rgba(255, 193, 7, 0.2) !important;
+        border-left: 4px solid #ffc107 !important;
+        color: #ffffff !important;
+    }
+    
+    .stInfo {
+        background-color: rgba(23, 162, 184, 0.2) !important;
+        border-left: 4px solid #17a2b8 !important;
+        color: #ffffff !important;
+    }
+    
+    /* ===== RECORDING CONTROLS ===== */
+    .recording-controls {
+        background: linear-gradient(135deg, #2d2d2d 0%, #1a1a1a 100%) !important;
+        padding: 20px !important;
+        border-radius: 15px !important;
+        margin: 15px 0 !important;
+        border: 1px solid #444444 !important;
+        box-shadow: 0 4px 12px rgba(0, 0, 0, 0.3) !important;
+    }
+    
+    /* ===== PROCESSING RESULTS ===== */
+    .processing-results {
+        background: linear-gradient(135deg, #2d2d2d 0%, #1a1a1a 100%) !important;
+        color: #ffffff !important;
+        border: 1px solid #444444 !important;
+        border-radius: 15px !important;
+        padding: 25px !important;
+        margin: 20px 0 !important;
+        box-shadow: 0 4px 12px rgba(0, 0, 0, 0.3) !important;
+    }
+    
+    /* ===== SIDEBAR STYLING ===== */
+    .css-1d391kg, .css-1lcbmhc {
+        background: linear-gradient(180deg, #1a1a1a 0%, #0d0d0d 100%) !important;
+        border-right: 1px solid #333333 !important;
+    }
+    
+    /* ===== HIDE STREAMLIT ELEMENTS ===== */
+    #MainMenu {visibility: hidden;}
+    footer {visibility: hidden;}
+    header {visibility: hidden;}
+    .stDeployButton {visibility: hidden;}
+    
+    /* ===== SCROLLBAR STYLING ===== */
+    ::-webkit-scrollbar {
+        width: 8px;
+        height: 8px;
+    }
+    
+    ::-webkit-scrollbar-track {
+        background: #1a1a1a;
+        border-radius: 4px;
+    }
+    
+    ::-webkit-scrollbar-thumb {
+        background: linear-gradient(135deg, #25D366 0%, #128C7E 100%);
+        border-radius: 4px;
+    }
+    
+    ::-webkit-scrollbar-thumb:hover {
+        background: linear-gradient(135deg, #128C7E 0%, #25D366 100%);
+    }
+    
+    /* ===== CUSTOM ANIMATIONS ===== */
+    @keyframes fadeInUp {
+        from {
+            opacity: 0;
+            transform: translateY(20px);
+        }
+        to {
+            opacity: 1;
+            transform: translateY(0);
+        }
+    }
+    
+    .broadcast-bubble, .broadcast-bubble-selected {
+        animation: fadeInUp 0.3s ease-out;
+    }
+    
+    /* ===== RESPONSIVE DESIGN ===== */
+    @media (max-width: 768px) {
+        .broadcast-bubble, .broadcast-bubble-selected {
+            max-width: 95%;
+            padding: 12px 16px;
+        }
+        
+        .white-container {
+            padding: 15px;
+            margin: 10px 0;
+        }
+    }
+    </style>
+    """
+
+def apply_custom_styling():
+    """Apply custom CSS styling to the Streamlit app"""
+    import streamlit as st
+    st.markdown(get_custom_css(), unsafe_allow_html=True)
+
+def create_broadcast_bubble(text, timestamp=None, is_selected=False):
+    """Create a WhatsApp-style chat bubble for broadcast messages"""
+    bubble_class = "broadcast-bubble-selected" if is_selected else "broadcast-bubble"
+    
+    timestamp_html = ""
+    if timestamp:
+        timestamp_html = f'<div class="broadcast-timestamp">{timestamp}</div>'
+    
+    return f"""
+    <div class="{bubble_class}">
+        {text}
+        {timestamp_html}
+    </div>
+    """
+
+def create_white_container(title, content, title_icon="📝"):
+    """Create a white container for translation and original text"""
+    return f"""
+    <div class="white-container">
+        <h3>{title_icon} {title}</h3>
+        <div>{content}</div>
+    </div>
+    """
+
+def create_processing_result_container(title, content):
+    """Create a dark container for processing results"""
+    return f"""
+    <div class="processing-results">
+        <h3>{title}</h3>
+        <div>{content}</div>
+    </div>
+    """
\ No newline at end of file
diff --git a/summarizer.py b/summarizer.py
new file mode 100644
index 0000000000000000000000000000000000000000..ee44749868d645f8ba099a1b069766696de38a0f
--- /dev/null
+++ b/summarizer.py
@@ -0,0 +1,299 @@
+# summarizer.py - نظام الملخص الذكي للمحاضرات
+
+from translator import get_translator
+from typing import Tuple, List, Dict, Optional
+import re
+
+class LectureSummarizer:
+    """نظام الملخص الذكي للمحاضرات الدراسية"""
+    
+    def __init__(self):
+        self.translator = get_translator()
+    
+    def generate_summary(self, text: str, language: str = 'ar') -> Tuple[Optional[str], Optional[str]]:
+        """
+        إنشاء ملخص ذكي للنص
+        
+        Args:
+            text: النص المراد تلخيصه
+            language: لغة الملخص ('ar' للعربية، 'en' للإنجليزية)
+        
+        Returns:
+            Tuple of (summary, error_message)
+        """
+        if not self.translator or not self.translator.model:
+            return None, "خدمة الذكاء الاصطناعي غير متوفرة"
+        
+        if not text or len(text.strip()) < 50:
+            return None, "النص قصير جداً لإنشاء ملخص مفيد"
+        
+        try:
+            prompt = self._create_summary_prompt(text, language)
+            
+            response = self.translator.model.generate_content(prompt)
+            
+            if response and hasattr(response, 'text') and response.text:
+                summary = response.text.strip()
+                summary = self._clean_summary_output(summary)
+                return summary, None
+            else:
+                return None, "فشل في إنشاء الملخص"
+                
+        except Exception as e:
+            return None, f"خطأ في إنشاء الملخص: {str(e)}"
+    
+    def extract_key_points(self, text: str, language: str = 'ar') -> Tuple[Optional[List[str]], Optional[str]]:
+        """
+        استخراج النقاط الرئيسية من النص
+        
+        Args:
+            text: النص المراد استخراج النقاط منه
+            language: لغة النقاط
+        
+        Returns:
+            Tuple of (key_points_list, error_message)
+        """
+        if not self.translator or not self.translator.model:
+            return None, "خدمة الذكاء الاصطناعي غير متوفرة"
+        
+        try:
+            prompt = self._create_key_points_prompt(text, language)
+            
+            response = self.translator.model.generate_content(prompt)
+
+            if response and hasattr(response, 'text') and response.text:
+                key_points_text = response.text.strip()
+                key_points = self._parse_key_points(key_points_text)
+                return key_points, None
+            else:
+                return None, "فشل في استخراج النقاط الرئيسية"
+                
+        except Exception as e:
+            return None, f"خطأ في استخراج النقاط: {str(e)}"
+    
+    def generate_study_notes(self, text: str, subject: str = "", language: str = 'ar') -> Tuple[Optional[Dict], Optional[str]]:
+        """
+        إنشاء مذكرة دراسية شاملة
+        
+        Args:
+            text: النص الأصلي
+            subject: المادة الدراسية
+            language: لغة المذكرة
+        
+        Returns:
+            Tuple of (study_notes_dict, error_message)
+        """
+        try:
+            # إنشاء الملخص
+            summary, summary_error = self.generate_summary(text, language)
+            if summary_error and not summary:
+                return None, summary_error
+            
+            # استخراج النقاط الرئيسية
+            key_points, points_error = self.extract_key_points(text, language)
+            if points_error and not key_points:
+                key_points = []
+            
+            # إنشاء أسئلة مراجعة
+            review_questions, questions_error = self.generate_review_questions(text, language)
+            if questions_error and not review_questions:
+                review_questions = []
+            
+            study_notes = {
+                'summary': summary or "لم يتم إنشاء ملخص",
+                'key_points': key_points or [],
+                'review_questions': review_questions or [],
+                'subject': subject,
+                'word_count': len(text.split()),
+                'estimated_reading_time': max(1, len(text.split()) // 200)  # دقائق تقريبية
+            }
+            
+            return study_notes, None
+            
+        except Exception as e:
+            return None, f"خطأ في إنشاء المذكرة: {str(e)}"
+    
+    def generate_review_questions(self, text: str, language: str = 'ar') -> Tuple[Optional[List[str]], Optional[str]]:
+        """
+        إنشاء أسئلة مراجعة من النص
+        
+        Args:
+            text: النص المراد إنشاء أسئلة منه
+            language: لغة الأسئلة
+        
+        Returns:
+            Tuple of (questions_list, error_message)
+        """
+        if not self.translator or not self.translator.model:
+            return None, "خدمة الذكاء الاصطناعي غير متوفرة"
+        
+        try:
+            prompt = self._create_questions_prompt(text, language)
+            
+            response = self.translator.model.generate_content(prompt)
+            
+            if response and hasattr(response, 'text') and response.text:
+                questions_text = response.text.strip()
+                questions = self._parse_questions(questions_text)
+                return questions, None
+            else:
+                return None, "فشل في إنشاء أسئلة المراجعة"
+                
+        except Exception as e:
+            return None, f"خطأ في إنشاء الأسئلة: {str(e)}"
+    
+    def _create_summary_prompt(self, text: str, language: str) -> str:
+        """إنشاء prompt للملخص"""
+        if language == 'ar':
+            return f"""
+قم بإنشاء ملخص شامل ومفيد لهذا النص من محاضرة دراسية:
+
+متطلبات الملخص:
+1. اكتب بالعربية الفصحى الواضحة
+2. اذكر الموضوع الرئيسي والأفكار المهمة
+3. رتب المعلومات بشكل منطقي
+4. اجعل الملخص مناسب للطلاب الجامعيين
+5. لا تتجاوز 200 كلمة
+6. أضف العناوين الفرعية إذا لزم الأمر
+
+النص:
+{text}
+
+الملخص:
+"""
+        else:
+            return f"""
+Create a comprehensive and useful summary of this lecture text:
+
+Requirements:
+1. Write in clear, academic English
+2. Mention the main topic and important ideas  
+3. Organize information logically
+4. Make it suitable for university students
+5. Don't exceed 200 words
+6. Add subheadings if necessary
+
+Text:
+{text}
+
+Summary:
+"""
+    
+    def _create_key_points_prompt(self, text: str, language: str) -> str:
+        """إنشاء prompt للنقاط الرئيسية"""
+        if language == 'ar':
+            return f"""
+استخرج أهم النقاط الرئيسية من هذا النص:
+
+متطلبات:
+1. اكتب كل نقطة في سطر منفصل
+2. ابدأ كل نقطة بـ "•" 
+3. اجعل كل نقطة واضحة ومفيدة للدراسة
+4. لا تزيد عن 8 نقاط
+5. رتب النقاط حسب الأهمية
+
+النص:
+{text}
+
+النقاط الرئيسية:
+"""
+        else:
+            return f"""
+Extract the most important key points from this text:
+
+Requirements:
+1. Write each point on a separate line
+2. Start each point with "•"
+3. Make each point clear and useful for studying
+4. No more than 8 points
+5. Order points by importance
+
+Text:
+{text}
+
+Key Points:
+"""
+    
+    def _create_questions_prompt(self, text: str, language: str) -> str:
+        """إنشاء prompt لأسئلة المراجعة"""
+        if language == 'ar':
+            return f"""
+أنشئ أسئلة مراجعة مفيدة من هذا النص:
+
+متطلبات:
+1. اكتب كل سؤال في سطر منفصل
+2. ابدأ كل سؤال برقم (1، 2، 3...)
+3. اجعل الأسئلة تغطي المفاهيم المهمة
+4. تنوع في أنواع الأسئلة (ما، كيف، لماذا، اشرح)
+5. لا تزيد عن 6 أسئلة
+6. اجعل الأسئلة مناسبة للامتحانات
+
+النص:
+{text}
+
+أسئلة المراجعة:
+"""
+        else:
+            return f"""
+Create useful review questions from this text:
+
+Requirements:
+1. Write each question on a separate line
+2. Start each question with a number (1, 2, 3...)
+3. Make questions cover important concepts
+4. Vary question types (what, how, why, explain)
+5. No more than 6 questions
+6. Make questions suitable for exams
+
+Text:
+{text}
+
+Review Questions:
+"""
+    
+    def _clean_summary_output(self, text: str) -> str:
+        """تنظيف نص الملخص"""
+        # إزالة الرموز غير المرغوبة
+        text = re.sub(r'\*+', '', text)
+        text = re.sub(r'#+', '', text)
+        text = text.strip()
+        
+        # تنظيف الأسطر الفارغة الزائدة
+        text = re.sub(r'\n\s*\n', '\n\n', text)
+        
+        return text
+    
+    def _parse_key_points(self, text: str) -> List[str]:
+        """تحليل النقاط الرئيسية من النص"""
+        points = []
+        lines = text.split('\n')
+        
+        for line in lines:
+            line = line.strip()
+            if line and (line.startswith('•') or line.startswith('-') or line.startswith('*')):
+                # إزالة الرمز من البداية
+                point = re.sub(r'^[•\-\*]\s*', '', line)
+                if point:
+                    points.append(point)
+            elif line and re.match(r'^\d+\.', line):
+                # نقاط مرقمة
+                point = re.sub(r'^\d+\.\s*', '', line)
+                if point:
+                    points.append(point)
+        
+        return points[:8]  # حد أقصى 8 نقاط
+    
+    def _parse_questions(self, text: str) -> List[str]:
+        """تحليل الأسئلة من النص"""
+        questions = []
+        lines = text.split('\n')
+        
+        for line in lines:
+            line = line.strip()
+            if line and ('؟' in line or '?' in line):
+                # إزالة الترقيم من البداية
+                question = re.sub(r'^\d+[\.\-\)]\s*', '', line)
+                if question:
+                    questions.append(question)
+        
+        return questions[:6]  # حد أقصى 6 أسئلة
diff --git a/test_dark_theme.py b/test_dark_theme.py
new file mode 100644
index 0000000000000000000000000000000000000000..8174ec6d254211b83e833306dd483e0b229d70e3
--- /dev/null
+++ b/test_dark_theme.py
@@ -0,0 +1,78 @@
+# test_dark_theme.py - Test the new dark theme design
+
+import streamlit as st
+from style_fixes import apply_custom_styling, create_broadcast_bubble, create_white_container, create_processing_result_container
+
+def main():
+    st.set_page_config(
+        page_title="Dark Theme Test",
+        page_icon="🌙",
+        layout="wide"
+    )
+    
+    # Apply dark theme
+    apply_custom_styling()
+    
+    st.title("🌙 Dark Theme Test")
+    st.markdown("Testing the new dark theme with chat bubbles and white containers")
+    
+    # Test broadcast bubbles
+    st.header("📻 Broadcast Messages (Chat Bubbles)")
+    
+    # Sample messages
+    messages = [
+        {"text": "مرحباً بكم في هذا الاختبار للتصميم الجديد", "timestamp": "12:30", "selected": False},
+        {"text": "This is a test message in English to see how it looks", "timestamp": "12:31", "selected": True},
+        {"text": "هذه رسالة طويلة نسبياً لاختبار كيف تبدو الفقاعات مع النصوص الطويلة والتأكد من أن التصميم يعمل بشكل صحيح", "timestamp": "12:32", "selected": False},
+        {"text": "Another English message with some technical terms like AI, machine learning, and natural language processing", "timestamp": "12:33", "selected": False}
+    ]
+    
+    for msg in messages:
+        bubble_html = create_broadcast_bubble(msg["text"], msg["timestamp"], msg["selected"])
+        st.markdown(bubble_html, unsafe_allow_html=True)
+        st.markdown("<br>", unsafe_allow_html=True)
+    
+    # Test white containers
+    st.header("📝 White Containers")
+    
+    # Original text container
+    original_text = "This is the original text that was transcribed from audio. It should appear in a white container with black text for good readability."
+    original_container = create_white_container("Original Text", original_text, "📝")
+    st.markdown(original_container, unsafe_allow_html=True)
+    
+    # Translation container
+    translation_text = "هذا هو النص المترجم الذي تم تحويله من الصوت. يجب أن يظهر في حاوية بيضاء مع نص أسود لسهولة القراءة."
+    translation_container = create_white_container("الترجمة", translation_text, "🌐")
+    st.markdown(translation_container, unsafe_allow_html=True)
+    
+    # Test buttons
+    st.header("🔘 Buttons Test")
+    
+    col1, col2, col3 = st.columns(3)
+    
+    with col1:
+        st.button("🎯 Primary Button", type="primary")
+    
+    with col2:
+        st.button("⚙️ Secondary Button", type="secondary")
+    
+    with col3:
+        st.button("🔄 Normal Button")
+    
+    # Test sidebar
+    with st.sidebar:
+        st.header("🎛️ Sidebar Test")
+        st.selectbox("Language", ["العربية", "English"])
+        st.checkbox("Enable Dark Mode")
+        st.slider("Volume", 0, 100, 50)
+    
+    # Test expander
+    with st.expander("🔍 Expandable Section"):
+        st.write("This content is inside an expander to test the dark theme styling.")
+        st.info("This is an info message")
+        st.success("This is a success message")
+        st.warning("This is a warning message")
+        st.error("This is an error message")
+
+if __name__ == "__main__":
+    main()
\ No newline at end of file
diff --git a/test_fallback_models.py b/test_fallback_models.py
new file mode 100644
index 0000000000000000000000000000000000000000..840bc2cac72368f4a0169f0ce9010449fb356e51
--- /dev/null
+++ b/test_fallback_models.py
@@ -0,0 +1,184 @@
+# test_fallback_models.py - Test fallback models
+
+import os
+import sys
+from dotenv import load_dotenv
+
+def test_openrouter_fallback():
+    """Test OpenRouter with fallback models"""
+    
+    print("🔍 Testing OpenRouter Fallback Models...")
+    print("=" * 60)
+    
+    # Force reload
+    load_dotenv(override=True)
+    
+    # Clear module cache
+    if 'translator' in sys.modules:
+        del sys.modules['translator']
+    
+    # Fresh import
+    from translator import get_translator
+    
+    translator = get_translator()
+    
+    print(f"📋 Primary Model: {translator.openrouter_model}")
+    
+    # Test the _openrouter_complete method
+    try:
+        print("\n🧪 Testing OpenRouter with fallback...")
+        result, error = translator._openrouter_complete("Say 'Test successful' in Arabic")
+        
+        if result:
+            print(f"✅ OpenRouter Success: {result[:100]}...")
+        else:
+            print(f"❌ OpenRouter Failed: {error}")
+            
+            # Check if error mentions the old model
+            if "meta-llama-3-70b-instruct" in str(error):
+                print("🚨 ERROR: Still using old model!")
+                return False
+            else:
+                print("ℹ️ Error is not related to old model")
+        
+        return True
+        
+    except Exception as e:
+        print(f"💥 Exception: {str(e)}")
+        
+        # Check if exception mentions the old model
+        if "meta-llama-3-70b-instruct" in str(e):
+            print("🚨 ERROR: Exception mentions old model!")
+            return False
+        else:
+            print("ℹ️ Exception is not related to old model")
+        
+        return False
+
+def test_ai_questions_with_fallback():
+    """Test AI Questions with fallback"""
+    
+    print("\n🔍 Testing AI Questions with Fallback...")
+    print("=" * 60)
+    
+    # Clear module cache
+    if 'ai_questions' in sys.modules:
+        del sys.modules['ai_questions']
+    
+    # Fresh import
+    from ai_questions import get_ai_question_engine
+    
+    engine = get_ai_question_engine()
+    
+    try:
+        print("🧪 Testing AI Questions...")
+        
+        response, error, session_id, model_used = engine.process_question(
+            selected_text="Hello and what are you doing? This is a test.",
+            question="Explain this text in detail",
+            segment_info={"id": "test"},
+            ui_language='en',
+            preferred_model='OpenRouter AI'
+        )
+        
+        if response:
+            print(f"✅ AI Questions Success: {response[:100]}...")
+            print(f"🔧 Model Used: {model_used}")
+            return True
+        else:
+            print(f"❌ AI Questions Failed: {error}")
+            
+            # Check if error mentions the old model
+            if "meta-llama-3-70b-instruct" in str(error):
+                print("🚨 ERROR: AI Questions still using old model!")
+                return False
+            else:
+                print("ℹ️ Error is not related to old model")
+                return False
+        
+    except Exception as e:
+        print(f"💥 AI Questions Exception: {str(e)}")
+        
+        # Check if exception mentions the old model
+        if "meta-llama-3-70b-instruct" in str(e):
+            print("🚨 ERROR: AI Questions exception mentions old model!")
+            return False
+        else:
+            print("ℹ️ Exception is not related to old model")
+            return False
+
+def check_session_state_issue():
+    """Check if there's a session state issue"""
+    
+    print("\n🔍 Checking Session State Issue...")
+    print("=" * 60)
+    
+    # The issue might be that Streamlit is caching the old translator instance
+    # Let's simulate what happens in Streamlit
+    
+    try:
+        # Import streamlit to see if it affects the issue
+        import streamlit as st
+        
+        print("📋 Streamlit imported successfully")
+        
+        # Check if there are any cached instances
+        if hasattr(st, 'session_state'):
+            print("📋 Session state available")
+            
+            # Clear any cached translator instances
+            keys_to_clear = []
+            for key in st.session_state.keys():
+                if 'translator' in key.lower() or 'ai' in key.lower():
+                    keys_to_clear.append(key)
+            
+            if keys_to_clear:
+                print(f"🗑️ Found cached keys: {keys_to_clear}")
+                for key in keys_to_clear:
+                    del st.session_state[key]
+                print("✅ Cleared cached instances")
+            else:
+                print("ℹ️ No cached instances found")
+        else:
+            print("ℹ️ Session state not available (normal in script mode)")
+        
+        return True
+        
+    except Exception as e:
+        print(f"💥 Session state check failed: {str(e)}")
+        return False
+
+def main():
+    """Main test function"""
+    
+    print("🚀 Fallback Models Test")
+    print("=" * 60)
+    
+    # Test OpenRouter fallback
+    openrouter_ok = test_openrouter_fallback()
+    
+    # Test AI Questions fallback
+    ai_questions_ok = test_ai_questions_with_fallback()
+    
+    # Check session state
+    session_ok = check_session_state_issue()
+    
+    print("\n" + "=" * 60)
+    print("📊 Test Results:")
+    print(f"  OpenRouter Fallback: {'✅ PASS' if openrouter_ok else '❌ FAIL'}")
+    print(f"  AI Questions Fallback: {'✅ PASS' if ai_questions_ok else '❌ FAIL'}")
+    print(f"  Session State Check: {'✅ PASS' if session_ok else '❌ FAIL'}")
+    
+    if openrouter_ok and ai_questions_ok:
+        print("\n🎉 Fallback models are working!")
+        print("💡 The old model error should be resolved.")
+    else:
+        print("\n⚠️ Some issues remain.")
+        
+        if not openrouter_ok:
+            print("🔧 OpenRouter fallback needs fixing")
+        if not ai_questions_ok:
+            print("🔧 AI Questions fallback needs fixing")
+
+if __name__ == "__main__":
+    main()
\ No newline at end of file
diff --git a/test_google_auth.py b/test_google_auth.py
new file mode 100644
index 0000000000000000000000000000000000000000..4f6ab002c85c6d860a1efd503137b445811af271
--- /dev/null
+++ b/test_google_auth.py
@@ -0,0 +1,129 @@
+#!/usr/bin/env python3
+# test_google_auth.py - اختبار مصادقة Google Docs
+
+import os
+import json
+
+def test_credentials_file():
+    """اختبار ملف credentials.json"""
+    print("🔍 اختبار ملف credentials.json...")
+    
+    if not os.path.exists('credentials.json'):
+        print("❌ ملف credentials.json غير موجود!")
+        print("💡 تأكد من تحميل الملف من Google Cloud Console")
+        return False
+    
+    try:
+        with open('credentials.json', 'r') as f:
+            creds = json.load(f)
+        
+        if 'installed' not in creds:
+            print("❌ تنسيق الملف خاطئ - يجب أن يحتوي على 'installed'")
+            return False
+        
+        installed = creds['installed']
+        client_id = installed.get('client_id', '')
+        
+        if 'YOUR_CLIENT_ID' in client_id:
+            print("❌ الملف يحتوي على بيانات تجريبية!")
+            print("💡 يجب تحميل ملف حقيقي من Google Cloud Console")
+            return False
+        
+        print("✅ ملف credentials.json صحيح")
+        print(f"   Client ID: {client_id[:30]}...")
+        print(f"   Project ID: {installed.get('project_id', 'غير محدد')}")
+        return True
+        
+    except Exception as e:
+        print(f"❌ خطأ في قراءة الملف: {e}")
+        return False
+
+def test_google_auth():
+    """اختبار المصادقة مع Google"""
+    print("\n🔍 اختبار المصادقة مع Google...")
+    
+    try:
+        from google_docs_config import google_docs_manager
+        
+        print("✅ تم استيراد google_docs_manager بنجاح")
+        
+        # محاولة المصادقة
+        print("🔄 محاولة المصادقة...")
+        success = google_docs_manager.authenticate()
+        
+        if success:
+            print("✅ المصادقة نجحت!")
+            return True
+        else:
+            print("❌ فشلت المصادقة")
+            return False
+            
+    except ImportError as e:
+        print(f"❌ خطأ في الاستيراد: {e}")
+        return False
+    except Exception as e:
+        print(f"❌ خطأ في المصادقة: {e}")
+        return False
+
+def test_document_creation():
+    """اختبار إنشاء مستند تجريبي"""
+    print("\n🔍 اختبار إنشاء مستند...")
+    
+    try:
+        from google_docs_config import google_docs_manager
+        
+        # إنشاء مستند تجريبي
+        title = "اختبار SyncMaster"
+        content = "هذا مستند تجريبي لاختبار التكامل مع Google Docs"
+        
+        doc_url, error = google_docs_manager.create_document(title, content)
+        
+        if doc_url:
+            print("✅ تم إنشاء المستند بنجاح!")
+            print(f"🔗 رابط المستند: {doc_url}")
+            return True
+        else:
+            print(f"❌ فشل إنشاء المستند: {error}")
+            return False
+            
+    except Exception as e:
+        print(f"❌ خطأ في إنشاء المستند: {e}")
+        return False
+
+def main():
+    print("🚀 اختبار شامل لتكامل Google Docs")
+    print("=" * 60)
+    
+    # اختبار ملف البيانات
+    creds_ok = test_credentials_file()
+    
+    if not creds_ok:
+        print("\n❌ يجب إصلاح ملف credentials.json أولاً")
+        print("📋 راجع ملف GOOGLE_SETUP_EASY.md")
+        return
+    
+    # اختبار المصادقة
+    auth_ok = test_google_auth()
+    
+    if not auth_ok:
+        print("\n❌ فشلت المصادقة")
+        print("💡 تأكد من:")
+        print("   - تفعيل Google Docs API في مشروعك")
+        print("   - إعداد OAuth Consent Screen")
+        print("   - استخدام نفس حساب Google")
+        return
+    
+    # اختبار إنشاء مستند
+    doc_ok = test_document_creation()
+    
+    print("\n" + "=" * 60)
+    
+    if creds_ok and auth_ok and doc_ok:
+        print("🎉 جميع الاختبارات نجحت!")
+        print("✅ يمكنك الآن استخدام زر التصدير في التطبيق")
+    else:
+        print("❌ بعض الاختبارات فشلت")
+        print("📋 راجع الأخطاء أعلاه وأعد المحاولة")
+
+if __name__ == "__main__":
+    main()
\ No newline at end of file
diff --git a/test_models.py b/test_models.py
new file mode 100644
index 0000000000000000000000000000000000000000..89e202944f07f1182576f0c6aecccf3fd7b42f87
--- /dev/null
+++ b/test_models.py
@@ -0,0 +1,104 @@
+# test_models.py - Test AI models functionality
+
+from translator import get_translator
+from ai_questions import get_ai_question_engine
+import time
+
+def test_openrouter_models():
+    """Test OpenRouter models with updated list"""
+    print("🔍 Testing OpenRouter models...")
+    
+    translator = get_translator()
+    
+    if not translator.openrouter_api_key:
+        print("❌ OpenRouter API key not found")
+        return False
+    
+    # Test with a simple prompt
+    test_prompt = "Explain what artificial intelligence is in one sentence."
+    
+    try:
+        response, error = translator._openrouter_complete(test_prompt)
+        
+        if response:
+            print(f"✅ OpenRouter test successful")
+            print(f"📝 Response: {response[:100]}...")
+            return True
+        else:
+            print(f"❌ OpenRouter test failed: {error}")
+            return False
+            
+    except Exception as e:
+        print(f"❌ OpenRouter test error: {str(e)}")
+        return False
+
+def test_ai_question_engine():
+    """Test AI question engine with different models"""
+    print("\n🤖 Testing AI Question Engine...")
+    
+    engine = get_ai_question_engine()
+    
+    # Test model availability
+    models_status = engine.check_model_availability()
+    
+    print("📊 Model Status:")
+    for model, status in models_status.items():
+        icon = status.get('icon', '❓')
+        available = status.get('available', False)
+        status_text = "✅ Available" if available else "❌ Unavailable"
+        print(f"  {icon} {model}: {status_text}")
+    
+    # Test a simple question
+    test_text = "Artificial intelligence is a technology that enables machines to learn and make decisions."
+    test_question = "What is artificial intelligence?"
+    
+    try:
+        # Try asking a question directly
+        response, error, session_id, model_used = engine.process_question(
+            selected_text=test_text,
+            question=test_question,
+            segment_info={"id": "test_segment"},
+            ui_language='en',
+            preferred_model='auto'
+        )
+        
+        if response:
+            print(f"✅ Question answered successfully")
+            print(f"📝 Answer: {response[:100]}...")
+            print(f"🔧 Model used: {model_used}")
+            print(f"📋 Session ID: {session_id}")
+            return True
+        else:
+            print(f"❌ No answer received: {error}")
+            return False
+            
+    except Exception as e:
+        print(f"❌ AI Question Engine test error: {str(e)}")
+        return False
+
+def main():
+    """Run all model tests"""
+    print("=" * 60)
+    print("🚀 Testing AI Models")
+    print("=" * 60)
+    
+    # Test OpenRouter
+    openrouter_ok = test_openrouter_models()
+    
+    # Test AI Question Engine
+    ai_questions_ok = test_ai_question_engine()
+    
+    print("\n" + "=" * 60)
+    print("📊 Test Results:")
+    print(f"  OpenRouter: {'✅ PASS' if openrouter_ok else '❌ FAIL'}")
+    print(f"  AI Questions: {'✅ PASS' if ai_questions_ok else '❌ FAIL'}")
+    
+    if openrouter_ok and ai_questions_ok:
+        print("🎉 All tests passed!")
+        return True
+    else:
+        print("⚠️ Some tests failed. Check the logs above.")
+        return False
+
+if __name__ == "__main__":
+    main()
\ No newline at end of file
diff --git a/test_openrouter_direct.py b/test_openrouter_direct.py
new file mode 100644
index 0000000000000000000000000000000000000000..d2355c4fc23936f9eb5405686af4d29ef0f7c884
--- /dev/null
+++ b/test_openrouter_direct.py
@@ -0,0 +1,200 @@
+# test_openrouter_direct.py - Direct OpenRouter API test
+
+import requests
+import json
+import os
+from dotenv import load_dotenv
+
+def test_openrouter_api_direct():
+    """Test OpenRouter API directly with curl-like request"""
+    
+    print("🔍 Testing OpenRouter API directly...")
+    print("=" * 60)
+    
+    # Load environment variables
+    load_dotenv()
+    
+    api_key = os.getenv("OPENROUTER_API_KEY")
+    if not api_key:
+        print("❌ OPENROUTER_API_KEY not found in environment")
+        return False
+    
+    print(f"🔑 API Key: {api_key[:20]}...{api_key[-10:]}")
+    
+    # Test different models
+    models_to_test = [
+        "meta-llama/llama-3.2-3b-instruct:free",
+        "meta-llama/llama-3.1-8b-instruct:free",
+        "google/gemma-2-9b-it:free",
+        "qwen/qwen-2.5-7b-instruct:free",
+        "microsoft/phi-3-mini-128k-instruct:free"
+    ]
+    
+    url = "https://openrouter.ai/api/v1/chat/completions"
+    headers = {
+        "Authorization": f"Bearer {api_key}",
+        "HTTP-Referer": "http://localhost",
+        "X-Title": "LocalApp",
+        "Content-Type": "application/json"
+    }
+    
+    test_message = "Hello, please respond with 'API test successful' in Arabic."
+    
+    for model in models_to_test:
+        print(f"\n🧪 Testing model: {model}")
+        print("-" * 40)
+        
+        payload = {
+            "model": model,
+            "messages": [
+                {"role": "system", "content": "You are a helpful assistant."},
+                {"role": "user", "content": test_message}
+            ],
+            "max_tokens": 100,
+            "temperature": 0.7
+        }
+        
+        try:
+            print(f"📤 Sending request to: {url}")
+            print(f"📋 Payload: {json.dumps(payload, indent=2)}")
+            
+            response = requests.post(url, headers=headers, json=payload, timeout=30)
+            
+            print(f"📥 Response Status: {response.status_code}")
+            print(f"📥 Response Headers: {dict(response.headers)}")
+            
+            if response.status_code == 200:
+                data = response.json()
+                print(f"✅ Success! Response: {json.dumps(data, indent=2)}")
+                
+                if 'choices' in data and data['choices']:
+                    content = data['choices'][0].get('message', {}).get('content', '')
+                    print(f"💬 AI Response: {content}")
+                    return True
+                else:
+                    print("⚠️ No choices in response")
+            else:
+                print(f"❌ Error {response.status_code}: {response.text}")
+                
+        except requests.exceptions.Timeout:
+            print("⏰ Request timed out")
+        except requests.exceptions.RequestException as e:
+            print(f"🌐 Network error: {str(e)}")
+        except Exception as e:
+            print(f"💥 Unexpected error: {str(e)}")
+    
+    return False
+
+def test_openrouter_models_list():
+    """Get list of available models from OpenRouter"""
+    
+    print("\n🔍 Getting available models from OpenRouter...")
+    print("=" * 60)
+    
+    load_dotenv()
+    api_key = os.getenv("OPENROUTER_API_KEY")
+    
+    if not api_key:
+        print("❌ OPENROUTER_API_KEY not found")
+        return
+    
+    url = "https://openrouter.ai/api/v1/models"
+    headers = {
+        "Authorization": f"Bearer {api_key}",
+        "Content-Type": "application/json"
+    }
+    
+    try:
+        response = requests.get(url, headers=headers, timeout=30)
+        
+        if response.status_code == 200:
+            data = response.json()
+            models = data.get('data', [])
+            
+            print(f"📊 Found {len(models)} models")
+            
+            # Filter for free models
+            free_models = []
+            llama_models = []
+            
+            for model in models:
+                model_id = model.get('id', '')
+                pricing = model.get('pricing', {})
+                
+                # Check if it's free
+                prompt_cost = pricing.get('prompt', '0')
+                completion_cost = pricing.get('completion', '0')
+                
+                if prompt_cost == '0' and completion_cost == '0':
+                    free_models.append(model_id)
+                
+                # Check if it's a Llama model
+                if 'llama' in model_id.lower():
+                    llama_models.append({
+                        'id': model_id,
+                        'prompt_cost': prompt_cost,
+                        'completion_cost': completion_cost
+                    })
+            
+            print(f"\n🆓 Free models ({len(free_models)}):")
+            for model in free_models[:10]:  # Show first 10
+                print(f"  - {model}")
+            
+            print(f"\n🦙 Llama models ({len(llama_models)}):")
+            for model in llama_models[:10]:  # Show first 10
+                print(f"  - {model['id']} (prompt: ${model['prompt_cost']}, completion: ${model['completion_cost']})")
+                
+        else:
+            print(f"❌ Error getting models: {response.status_code} - {response.text}")
+            
+    except Exception as e:
+        print(f"💥 Error: {str(e)}")
+
+def check_current_env_config():
+    """Check current environment configuration"""
+    
+    print("\n🔍 Checking current environment configuration...")
+    print("=" * 60)
+    
+    load_dotenv()
+    
+    config = {
+        'OPENROUTER_API_KEY': os.getenv("OPENROUTER_API_KEY"),
+        'OPENROUTER_MODEL': os.getenv("OPENROUTER_MODEL"),
+        'GROQ_API_KEY': os.getenv("GROQ_API_KEY"),
+        'GEMINI_API_KEY': os.getenv("GEMINI_API_KEY")
+    }
+    
+    for key, value in config.items():
+        if value:
+            if 'KEY' in key:
+                print(f"✅ {key}: {value[:20]}...{value[-10:] if len(value) > 30 else value}")
+            else:
+                print(f"✅ {key}: {value}")
+        else:
+            print(f"❌ {key}: Not set")
+
+def main():
+    """Main test function"""
+    
+    print("🚀 OpenRouter Direct API Test")
+    print("=" * 60)
+    
+    # Check environment
+    check_current_env_config()
+    
+    # Get available models
+    test_openrouter_models_list()
+    
+    # Test API directly
+    success = test_openrouter_api_direct()
+    
+    print("\n" + "=" * 60)
+    if success:
+        print("🎉 OpenRouter API is working!")
+    else:
+        print("❌ OpenRouter API test failed")
+        print("💡 Try checking your API key or model availability")
+
+if __name__ == "__main__":
+    main()
\ No newline at end of file
diff --git a/test_recording.py b/test_recording.py
new file mode 100644
index 0000000000000000000000000000000000000000..b5e533256bf28467e1362a00c86c14bcd1b3d5cc
--- /dev/null
+++ b/test_recording.py
@@ -0,0 +1,134 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+اختبار زر التسجيل - محاكاة ملف صوتي
+"""
+
+import requests
+import io
+import wave
+import struct
+import random
+
+def create_test_audio():
+    """إنشاء ملف صوتي تجريبي"""
+    # إنشاء صوت تجريبي (silence مع بعض الضوضاء)
+    duration = 2  # ثانيتين
+    sample_rate = 44100
+    samples = duration * sample_rate
+    
+    # إنشاء بيانات صوتية بسيطة
+    audio_data = []
+    for i in range(samples):
+        # ضوضاء بسيطة
+        value = int(random.uniform(-1000, 1000))
+        audio_data.append(value)
+    
+    # إنشاء ملف WAV في الذاكرة
+    buffer = io.BytesIO()
+    with wave.open(buffer, 'wb') as wav_file:
+        wav_file.setnchannels(1)  # Mono
+        wav_file.setsampwidth(2)  # 16-bit
+        wav_file.setframerate(sample_rate)
+        
+        # كتابة البيانات
+        for sample in audio_data:
+            wav_file.writeframes(struct.pack('<h', sample))
+    
+    buffer.seek(0)
+    return buffer
+
+def test_recording_endpoint():
+    """اختبار endpoint التسجيل"""
+    print("🎙️ اختبار endpoint التسجيل...")
+    
+    try:
+        # إنشاء ملف صوتي تجريبي
+        audio_buffer = create_test_audio()
+        
+        # إعداد البيانات
+        files = {
+            'audio_data': ('test_audio.wav', audio_buffer, 'audio/wav')
+        }
+        
+        data = {
+            'markers': '[]',
+            'target_language': 'ar',
+            'enable_translation': 'true'
+        }
+        
+        print("📤 إرسال طلب التسجيل...")
+        response = requests.post(
+            'http://localhost:5001/record',
+            files=files,
+            data=data,
+            timeout=30
+        )
+        
+        print(f"Status Code: {response.status_code}")
+        
+        if response.status_code == 200:
+            result = response.json()
+            print(f"Success: {result.get('success')}")
+            
+            if result.get('success'):
+                print("✅ التسجيل نجح!")
+                print(f"Original Text: {result.get('original_text', 'غير موجود')}")
+                print(f"Translation Enabled: {result.get('translation_enabled')}")
+                print(f"Target Language: {result.get('target_language')}")
+                return True
+            else:
+                print(f"❌ فشل التسجيل: {result.get('error')}")
+                return False
+        else:
+            print(f"❌ خطأ HTTP: {response.status_code}")
+            print(f"Response: {response.text}")
+            return False
+            
+    except Exception as e:
+        print(f"❌ خطأ في اختبار التسجيل: {e}")
+        return False
+
+def test_options_request():
+    """اختبار طلب OPTIONS للتسجيل"""
+    print("\n🔧 اختبار طلب OPTIONS للتسجيل...")
+    
+    try:
+        response = requests.options('http://localhost:5001/record', timeout=5)
+        print(f"Status Code: {response.status_code}")
+        
+        if response.status_code == 204:
+            print("✅ طلب OPTIONS نجح")
+            return True
+        else:
+            print(f"❌ مشكلة في طلب OPTIONS: {response.status_code}")
+            return False
+            
+    except Exception as e:
+        print(f"❌ خطأ في طلب OPTIONS: {e}")
+        return False
+
+def main():
+    """الدالة الرئيسية لاختبار التسجيل"""
+    print("🚀 اختبار وظيفة التسجيل")
+    print("=" * 50)
+    
+    # اختبار OPTIONS أولاً
+    options_ok = test_options_request()
+    
+    if options_ok:
+        # اختبار التسجيل الفعلي
+        recording_ok = test_recording_endpoint()
+        
+        if recording_ok:
+            print("\n🎉 جميع اختبارات التسجيل نجحت!")
+            print("✅ زر التسجيل يعمل بشكل مثالي")
+        else:
+            print("\n❌ هناك مشكلة في وظيفة التسجيل")
+    else:
+        print("\n❌ مشكلة في CORS للتسجيل")
+    
+    print("=" * 50)
+
+if __name__ == "__main__":
+    main()
diff --git a/test_server_translation.py b/test_server_translation.py
new file mode 100644
index 0000000000000000000000000000000000000000..dc6e760e5be21304b0b673903631066b688d6f92
--- /dev/null
+++ b/test_server_translation.py
@@ -0,0 +1,78 @@
+# test_server_translation.py - Test server translation response
+
+import requests
+import json
+import tempfile
+import wave
+import numpy as np
+
+def create_test_audio():
+    """Create a simple test audio file"""
+    sample_rate = 16000
+    duration = 2  # seconds
+    frequency = 440  # Hz (A note)
+    
+    # Generate sine wave
+    t = np.linspace(0, duration, int(sample_rate * duration))
+    audio_data = (0.3 * np.sin(2 * np.pi * frequency * t) * 32767).astype(np.int16)
+    
+    # Create temporary WAV file
+    with tempfile.NamedTemporaryFile(delete=False, suffix='.wav') as tmp_file:
+        with wave.open(tmp_file.name, 'w') as wav_file:
+            wav_file.setnchannels(1)  # Mono
+            wav_file.setsampwidth(2)  # 2 bytes per sample
+            wav_file.setframerate(sample_rate)
+            wav_file.writeframes(audio_data.tobytes())
+        return tmp_file.name
+
+def test_server_translation():
+    print("🔍 Testing Server Translation Response...")
+    
+    # Create test audio
+    audio_file = create_test_audio()
+    print(f"📁 Created test audio: {audio_file}")
+    
+    try:
+        # Prepare request data
+        with open(audio_file, 'rb') as f:
+            files = {'audio': f}
+            data = {
+                'target_language': 'ar',
+                'enable_translation': 'true',
+                'markers': '[]'
+            }
+            
+            # Send request to server
+            response = requests.post('http://localhost:5001/record', files=files, data=data)
+            
+            if response.status_code == 200:
+                result = response.json()
+                print(f"✅ Server Response Received")
+                print(f"📊 Success: {result.get('success')}")
+                print(f"🔤 Original text: {result.get('original_text', 'None')}")
+                print(f"🔄 Translated text: {result.get('translated_text', 'None')}")
+                print(f"🌍 Translation enabled: {result.get('translation_enabled')}")
+                print(f"✅ Translation success: {result.get('translation_success')}")
+                print(f"🌐 Target language: {result.get('target_language')}")
+                print(f"🔍 Detected language: {result.get('language_detected')}")
+                
+                # Check if texts are different
+                original = result.get('original_text', '')
+                translated = result.get('translated_text', '')
+                print(f"🔄 Texts are different: {original != translated}")
+                
+            else:
+                print(f"❌ Server error: {response.status_code}")
+                print(f"Response: {response.text}")
+                
+    except Exception as e:
+        print(f"❌ Test failed: {str(e)}")
+    
+    finally:
+        # Clean up
+        import os
+        if os.path.exists(audio_file):
+            os.unlink(audio_file)
+
+if __name__ == "__main__":
+    test_server_translation()
diff --git a/test_servers.py b/test_servers.py
new file mode 100644
index 0000000000000000000000000000000000000000..414d833bd4ebbbc9a126a9e650fdbc78a41e637f
--- /dev/null
+++ b/test_servers.py
@@ -0,0 +1,17 @@
+import requests
+
+print('🧪 Testing servers...')
+
+try:
+    r1 = requests.get('http://localhost:5050', timeout=5)
+    print(f'✅ Streamlit: OK - {r1.status_code}')
+except Exception as e:
+    print(f'❌ Streamlit: FAILED - {e}')
+
+try:
+    r2 = requests.get('http://localhost:5001/record', timeout=5)
+    print(f'✅ Recorder: OK - {r2.status_code}')
+except Exception as e:
+    print(f'❌ Recorder: FAILED - {e}')
+
+print('🏁 Test completed')
diff --git a/test_streamlit_environment.py b/test_streamlit_environment.py
new file mode 100644
index 0000000000000000000000000000000000000000..5fd22eaab9438473897bf16597abdfd916f0a556
--- /dev/null
+++ b/test_streamlit_environment.py
@@ -0,0 +1,133 @@
+# test_streamlit_environment.py - Test in Streamlit environment
+
+import streamlit as st
+import os
+from dotenv import load_dotenv
+
+def main():
+    st.title("🔍 OpenRouter Model Debug")
+    
+    # Load environment
+    load_dotenv()
+    
+    st.write("## Environment Check")
+    st.write(f"**OPENROUTER_MODEL**: {os.getenv('OPENROUTER_MODEL')}")
+    st.write(f"**OPENROUTER_API_KEY**: {os.getenv('OPENROUTER_API_KEY')[:20]}...")
+    
+    # Initialize session state
+    if 'preferred_ai_model' not in st.session_state:
+        st.session_state.preferred_ai_model = 'auto'
+    
+    st.write("## Session State Check")
+    st.write(f"**preferred_ai_model**: {st.session_state.preferred_ai_model}")
+    
+    # Test translator
+    st.write("## Translator Test")
+    
+    try:
+        from translator import get_translator
+        translator = get_translator()
+        
+        st.write(f"**Translator model**: {translator.openrouter_model}")
+        
+        if st.button("Test OpenRouter Direct"):
+            with st.spinner("Testing..."):
+                response, error = translator._openrouter_complete("Hello, respond with 'Test successful' in Arabic.")
+                
+                if response:
+                    st.success(f"✅ Success: {response}")
+                else:
+                    st.error(f"❌ Error: {error}")
+                    
+                    if "meta-llama-3-70b-instruct" in str(error):
+                        st.error("🚨 OLD MODEL DETECTED IN ERROR!")
+                    
+    except Exception as e:
+        st.error(f"💥 Exception: {str(e)}")
+        
+        if "meta-llama-3-70b-instruct" in str(e):
+            st.error("🚨 OLD MODEL DETECTED IN EXCEPTION!")
+    
+    # Test AI Questions
+    st.write("## AI Questions Test")
+    
+    # Model selection
+    model_options = {
+        "🔄 Auto": "auto",
+        "🤖 Gemini AI": "Gemini AI", 
+        "⚡ Groq AI": "Groq AI",
+        "🌐 OpenRouter AI": "OpenRouter AI",
+        "🛡️ Simple Response": "Simple Response"
+    }
+    
+    selected_model_display = st.selectbox(
+        "Choose Model",
+        options=list(model_options.keys()),
+        index=3  # Default to OpenRouter AI
+    )
+    
+    selected_model = model_options[selected_model_display]
+    st.session_state.preferred_ai_model = selected_model
+    
+    st.write(f"**Selected Model**: {selected_model}")
+    
+    if st.button("Test AI Questions"):
+        try:
+            from ai_questions import AIQuestionEngine
+            
+            translator = get_translator()
+            engine = AIQuestionEngine(translator)
+            
+            with st.spinner("Processing question..."):
+                answer, error, session_id, model_used = engine.process_question(
+                    selected_text="Hello, this is a test text.",
+                    question="What does this text mean?",
+                    segment_info={"id": "test_segment"},
+                    ui_language='en',
+                    preferred_model=selected_model
+                )
+                
+                if answer:
+                    st.success("✅ Success!")
+                    st.write(f"**Answer**: {answer[:200]}...")
+                    st.write(f"**Model Used**: {model_used}")
+                else:
+                    st.error(f"❌ Error: {error}")
+                    
+                    if "meta-llama-3-70b-instruct" in str(error):
+                        st.error("🚨 OLD MODEL DETECTED IN AI QUESTIONS ERROR!")
+                        
+                        # Show detailed error analysis
+                        st.write("### Error Analysis")
+                        st.code(error)
+                        
+        except Exception as e:
+            st.error(f"💥 Exception: {str(e)}")
+            
+            if "meta-llama-3-70b-instruct" in str(e):
+                st.error("🚨 OLD MODEL DETECTED IN AI QUESTIONS EXCEPTION!")
+                
+                # Show detailed exception analysis
+                st.write("### Exception Analysis")
+                st.code(str(e))
+    
+    # Clear cache button
+    if st.button("🗑️ Clear All Cache"):
+        # Clear Streamlit cache
+        st.cache_data.clear()
+        st.cache_resource.clear()
+        
+        # Clear session state
+        keys_to_clear = []
+        for key in list(st.session_state.keys()):
+            if any(term in key.lower() for term in ['translator', 'ai', 'question', 'model']):
+                keys_to_clear.append(key)
+        
+        for key in keys_to_clear:
+            del st.session_state[key]
+        
+        st.success("✅ Cache cleared! Please refresh the page.")
+        st.rerun()
+
+if __name__ == "__main__":
+    main()
\ No newline at end of file
diff --git a/test_summarize.py b/test_summarize.py
new file mode 100644
index 0000000000000000000000000000000000000000..373bcf6463e913e0d694ba2f76048483cb11bbe8
--- /dev/null
+++ b/test_summarize.py
@@ -0,0 +1,117 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+اختبار مشكلة endpoint التلخيص
+"""
+
+import requests
+import json
+
+def test_cors_preflight():
+    """اختبار طلب OPTIONS (CORS preflight)"""
+    print("🔍 اختبار CORS preflight...")
+    
+    try:
+        response = requests.options('http://localhost:5001/summarize')
+        print(f"Status Code: {response.status_code}")
+        print(f"Headers: {dict(response.headers)}")
+        
+        # تحقق من CORS headers
+        cors_origin = response.headers.get('Access-Control-Allow-Origin')
+        print(f"CORS Origin: '{cors_origin}'")
+        
+        if cors_origin and ',' in cors_origin:
+            print("❌ مشكلة: CORS header يحتوي على قيم متعددة!")
+            return False
+        elif cors_origin == '*':
+            print("✅ CORS header صحيح")
+            return True
+        else:
+            print(f"⚠️ CORS header غير متوقع: {cors_origin}")
+            return False
+            
+    except Exception as e:
+        print(f"❌ خطأ في طلب OPTIONS: {e}")
+        return False
+
+def test_summarize_endpoint():
+    """اختبار endpoint التلخيص"""
+    print("\n🤖 اختبار endpoint التلخيص...")
+    
+    test_data = {
+        "text": "Hello, how are you? What are you doing today? Tell me.",
+        "language": "arabic"
+    }
+    
+    try:
+        response = requests.post(
+            'http://localhost:5001/summarize',
+            json=test_data,
+            headers={'Content-Type': 'application/json'}
+        )
+        
+        print(f"Status Code: {response.status_code}")
+        print(f"Response: {response.text}")
+        
+        if response.status_code == 200:
+            data = response.json()
+            if data.get('success'):
+                print("✅ التلخيص نجح!")
+                return True
+            else:
+                print(f"❌ فشل التلخيص: {data.get('error')}")
+                return False
+        else:
+            print(f"❌ خطأ HTTP: {response.status_code}")
+            return False
+            
+    except Exception as e:
+        print(f"❌ خطأ في طلب POST: {e}")
+        return False
+
+def test_server_status():
+    """اختبار حالة الخادم"""
+    print("🌐 اختبار حالة الخادم...")
+    
+    try:
+        response = requests.get('http://localhost:5001/record')
+        print(f"Status Code: {response.status_code}")
+        
+        if response.status_code == 200:
+            data = response.json()
+            print(f"Server Status: {data.get('status')}")
+            return True
+        else:
+            print(f"❌ الخادم غير متاح: {response.status_code}")
+            return False
+            
+    except Exception as e:
+        print(f"❌ لا يمكن الوصول للخادم: {e}")
+        return False
+
+if __name__ == "__main__":
+    print("=" * 50)
+    print("🚀 بدء اختبار مشكلة التلخيص")
+    print("=" * 50)
+    
+    # اختبار حالة الخادم
+    server_ok = test_server_status()
+    
+    if server_ok:
+        # اختبار CORS
+        cors_ok = test_cors_preflight()
+        
+        if cors_ok:
+            # اختبار التلخيص
+            summarize_ok = test_summarize_endpoint()
+            
+            if summarize_ok:
+                print("\n🎉 جميع الاختبارات نجحت!")
+            else:
+                print("\n❌ فشل في اختبار التلخيص")
+        else:
+            print("\n❌ مشكلة في CORS - يجب إعادة تشغيل الخادم")
+    else:
+        print("\n❌ الخادم غير متاح - يجب تشغيله أولاً")
+    
+    print("=" * 50)
diff --git a/test_summary_button.py b/test_summary_button.py
new file mode 100644
index 0000000000000000000000000000000000000000..51379ffcede3e1a0540b19ed3bc6191603719400
--- /dev/null
+++ b/test_summary_button.py
@@ -0,0 +1,113 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+اختبار سريع ومبسط لزر التلخيص
+"""
+
+import requests
+import json
+
+def test_summary_button():
+    """محاكاة نفس الطلب الذي يرسله زر التلخيص"""
+    
+    print("🤖 اختبار زر التلخيص...")
+    print("=" * 50)
+    
+    # نفس البيانات التي ترسلها الواجهة
+    test_data = {
+        "text": "Hello, how are you? What are you doing today? Tell me.",
+        "language": "arabic",
+        "type": "full"
+    }
+    
+    try:
+        print("📤 إرسال طلب التلخيص...")
+        print(f"البيانات: {test_data}")
+        
+        response = requests.post(
+            'http://localhost:5001/summarize',
+            json=test_data,
+            headers={
+                'Content-Type': 'application/json',
+                'Accept': 'application/json'
+            },
+            timeout=30
+        )
+        
+        print(f"\n📥 استلام الرد:")
+        print(f"Status Code: {response.status_code}")
+        print(f"Headers: {dict(response.headers)}")
+        
+        if response.status_code == 200:
+            data = response.json()
+            print(f"\n✅ نجح التلخيص!")
+            print(f"Keys في الرد: {list(data.keys())}")
+            
+            if data.get('success'):
+                print(f"نوع التلخيص: {data.get('type')}")
+                
+                if 'summary' in data:
+                    summary = data['summary']
+                    print(f"\nالملخص:")
+                    print("-" * 30)
+                    print(summary)
+                    print("-" * 30)
+                    return True
+                else:
+                    print("⚠️ لا يوجد ملخص في الرد")
+                    return False
+            else:
+                print(f"❌ فشل التلخيص: {data.get('error')}")
+                return False
+        else:
+            print(f"❌ خطأ HTTP: {response.status_code}")
+            print(f"الرد: {response.text}")
+            return False
+            
+    except Exception as e:
+        print(f"❌ خطأ في الطلب: {e}")
+        return False
+
+def test_cors_manually():
+    """اختبار CORS يدوياً"""
+    print("\n🔧 اختبار CORS...")
+    
+    try:
+        # طلب OPTIONS أولاً
+        options_response = requests.options('http://localhost:5001/summarize')
+        print(f"OPTIONS Status: {options_response.status_code}")
+        
+        cors_origin = options_response.headers.get('Access-Control-Allow-Origin')
+        print(f"CORS Origin: '{cors_origin}'")
+        
+        if cors_origin == '*':
+            print("✅ CORS صحيح")
+            return True
+        else:
+            print(f"❌ مشكلة CORS: {cors_origin}")
+            return False
+            
+    except Exception as e:
+        print(f"❌ خطأ في اختبار CORS: {e}")
+        return False
+
+if __name__ == "__main__":
+    print("🚀 اختبار زر التلخيص المحدث")
+    print("=" * 50)
+    
+    # اختبار CORS
+    cors_ok = test_cors_manually()
+    
+    if cors_ok:
+        # اختبار التلخيص
+        summary_ok = test_summary_button()
+        
+        if summary_ok:
+            print("\n🎉 جميع الاختبارات نجحت!")
+            print("✅ زر التلخيص يعمل بشكل صحيح")
+        else:
+            print("\n❌ هناك مشكلة في التلخيص")
+    else:
+        print("\n❌ مشكلة CORS تمنع التلخيص")
+    
+    print("=" * 50)
diff --git a/test_system.py b/test_system.py
new file mode 100644
index 0000000000000000000000000000000000000000..ac48f62d1a4e3b81c46958c52855cd1f9018b311
--- /dev/null
+++ b/test_system.py
@@ -0,0 +1,241 @@
+#!/usr/bin/env python3
+"""
+System Test Script for SyncMaster Enhanced
+سكريبت اختبار النظام لـ SyncMaster المحسن
+"""
+
+import os
+import sys
+import traceback
+from pathlib import Path
+
+def test_imports():
+    """Test all required imports"""
+    print("🔍 Testing imports...")
+    
+    tests = [
+        ('google.genai', 'Google Generative AI'),
+        ('librosa', 'LibROSA'),
+        ('soundfile', 'SoundFile'),
+        ('streamlit', 'Streamlit'),
+        ('flask', 'Flask'),
+        ('dotenv', 'Python-dotenv'),
+    ]
+    
+    failed_imports = []
+    
+    for module, name in tests:
+        try:
+            __import__(module)
+            print(f"  ✅ {name}")
+        except ImportError as e:
+            print(f"  ❌ {name}: {e}")
+            failed_imports.append(name)
+    
+    return len(failed_imports) == 0
+
+def test_env_file():
+    """Test environment configuration"""
+    print("\n🔑 Testing environment...")
+    
+    if not Path('.env').exists():
+        print("  ❌ .env file not found")
+        return False
+    
+    try:
+        from dotenv import load_dotenv
+        load_dotenv()
+        
+        api_key = os.getenv("GEMINI_API_KEY")
+        if not api_key:
+            print("  ❌ GEMINI_API_KEY not found in .env")
+            return False
+        elif api_key == "your_api_key_here":
+            print("  ⚠️ GEMINI_API_KEY needs to be replaced with actual key")
+            return False
+        else:
+            print(f"  ✅ GEMINI_API_KEY configured (length: {len(api_key)})")
+            return True
+            
+    except Exception as e:
+        print(f"  ❌ Error reading .env: {e}")
+        return False
+
+def test_translator():
+    """Test translator initialization"""
+    print("\n🌐 Testing translator...")
+    
+    try:
+        from translator import AITranslator, get_translator
+        
+        # Test direct initialization
+        translator = AITranslator()
+        if translator.init_error:
+            print(f"  ❌ Translator init error: {translator.init_error}")
+            return False
+        
+        print("  ✅ Translator initialized successfully")
+        
+        # Test simple translation
+        test_text = "Hello, this is a test"
+        translated, error = translator.translate_text(test_text, 'ar')
+        
+        if error:
+            print(f"  ❌ Translation test failed: {error}")
+            return False
+        elif translated:
+            print(f"  ✅ Translation test successful: '{test_text}' → '{translated}'")
+            return True
+        else:
+            print("  ⚠️ Translation returned empty result")
+            return False
+            
+    except Exception as e:
+        print(f"  ❌ Translator test failed: {e}")
+        print(f"  🔍 Traceback: {traceback.format_exc()}")
+        return False
+
+def test_audio_processor():
+    """Test audio processor initialization"""
+    print("\n🎵 Testing audio processor...")
+    
+    try:
+        from audio_processor import AudioProcessor
+        
+        processor = AudioProcessor()
+        if processor.init_error:
+            print(f"  ❌ Audio processor init error: {processor.init_error}")
+            return False
+        
+        print("  ✅ Audio processor initialized successfully")
+        
+        # Check if translator is available
+        if processor.translator:
+            print("  ✅ Translator integration available")
+        else:
+            print("  ⚠️ Translator integration not available")
+        
+        return True
+        
+    except Exception as e:
+        print(f"  ❌ Audio processor test failed: {e}")
+        print(f"  🔍 Traceback: {traceback.format_exc()}")
+        return False
+
+def test_server_components():
+    """Test server components"""
+    print("\n🖥️ Testing server components...")
+    
+    try:
+        from recorder_server import app
+        print("  ✅ Recorder server imports OK")
+        
+        # Test routes
+        with app.test_client() as client:
+            # Test health check
+            response = client.get('/record')
+            if response.status_code == 200:
+                print("  ✅ Health check endpoint working")
+            else:
+                print(f"  ⚠️ Health check returned {response.status_code}")
+            
+            # Test languages endpoint
+            response = client.get('/languages')
+            if response.status_code == 200:
+                print("  ✅ Languages endpoint working")
+            else:
+                print(f"  ⚠️ Languages endpoint returned {response.status_code}")
+        
+        return True
+        
+    except Exception as e:
+        print(f"  ❌ Server test failed: {e}")
+        print(f"  🔍 Traceback: {traceback.format_exc()}")
+        return False
+
+def test_ui_translations():
+    """Test UI translations"""
+    print("\n🎨 Testing UI translations...")
+    
+    try:
+        from translator import UI_TRANSLATIONS, get_translation
+        
+        # Test English translations
+        en_keys = len(UI_TRANSLATIONS.get('en', {}))
+        ar_keys = len(UI_TRANSLATIONS.get('ar', {}))
+        
+        print(f"  ✅ English translations: {en_keys} keys")
+        print(f"  ✅ Arabic translations: {ar_keys} keys")
+        
+        if en_keys != ar_keys:
+            print(f"  ⚠️ Translation key count mismatch: EN={en_keys}, AR={ar_keys}")
+        
+        # Test translation function
+        test_key = 'start_recording'
+        en_text = get_translation(test_key, 'en')
+        ar_text = get_translation(test_key, 'ar')
+        
+        print(f"  ✅ Test translation: '{en_text}' → '{ar_text}'")
+        
+        return True
+        
+    except Exception as e:
+        print(f"  ❌ UI translations test failed: {e}")
+        return False
+
+def main():
+    """Run all tests"""
+    print("=" * 60)
+    print("🧪 SyncMaster Enhanced - System Test")
+    print("اختبار النظام الشامل لـ SyncMaster المحسن")
+    print("=" * 60)
+    
+    # Change to script directory
+    script_dir = Path(__file__).parent
+    os.chdir(script_dir)
+    print(f"📁 Working directory: {script_dir}")
+    
+    tests = [
+        ("Import Test", test_imports),
+        ("Environment Test", test_env_file),
+        ("Translator Test", test_translator),
+        ("Audio Processor Test", test_audio_processor),
+        ("Server Components Test", test_server_components),
+        ("UI Translations Test", test_ui_translations),
+    ]
+    
+    results = {}
+    
+    for test_name, test_func in tests:
+        try:
+            results[test_name] = test_func()
+        except Exception as e:
+            print(f"\n❌ {test_name} crashed: {e}")
+            results[test_name] = False
+    
+    # Summary
+    print("\n" + "=" * 60)
+    print("📊 TEST SUMMARY / ملخص الاختبار")
+    print("=" * 60)
+    
+    passed = sum(results.values())
+    total = len(results)
+    
+    for test_name, result in results.items():
+        status = "✅ PASS" if result else "❌ FAIL"
+        print(f"  {status} {test_name}")
+    
+    print(f"\n🎯 Results: {passed}/{total} tests passed")
+    
+    if passed == total:
+        print("🎉 All tests passed! System is ready to use.")
+        print("🚀 You can now run: python start_debug.py")
+    else:
+        print("⚠️ Some tests failed. Please fix the issues before running the application.")
+        print("📝 Check the error messages above for details.")
+    
+    return passed == total
+
+if __name__ == "__main__":
+    success = main()
+    sys.exit(0 if success else 1)
diff --git a/test_translation.py b/test_translation.py
new file mode 100644
index 0000000000000000000000000000000000000000..e0858439c6c1db68a8a4a69b4b2ea23e3dbc366f
--- /dev/null
+++ b/test_translation.py
@@ -0,0 +1,39 @@
+# test_translation.py - Quick translation test
+
+from translator import get_translator
+import json
+
+def test_translation():
+    print("🔍 Testing AI Translation System...")
+    
+    # Get translator instance
+    translator = get_translator()
+    
+    if translator.init_error:
+        print(f"❌ Translation Error: {translator.init_error}")
+        return
+    
+    print("✅ Translator initialized successfully")
+    
+    # Test translation
+    test_text = "Hello, this is a test for the translation system"
+    print(f"\n🔤 Original text: {test_text}")
+    
+    translated_text, error = translator.translate_text(test_text, target_language='ar')
+    
+    if translated_text:
+        print(f"✅ Arabic translation: {translated_text}")
+        print(f"📊 Translation success: True")
+        print(f"🔄 Texts are different: {translated_text != test_text}")
+    else:
+        print(f"❌ Translation failed: {error}")
+    
+    # Test language detection
+    detected_lang, detect_error = translator.detect_language(test_text)
+    if detected_lang:
+        print(f"🌍 Detected language: {detected_lang}")
+    else:
+        print(f"❌ Language detection failed: {detect_error}")
+
+if __name__ == "__main__":
+    test_translation()
diff --git a/tmp1dop8abr.json b/tmp1dop8abr.json
new file mode 100644
index 0000000000000000000000000000000000000000..162ea10fb753ced6a6099f9d6b3e8717c8138b27
--- /dev/null
+++ b/tmp1dop8abr.json
@@ -0,0 +1,160 @@
+{
+  "original_text": "Hello, how are you? What are you doing? I hope everything is good and okay.",
+  "translated_text": "مرحبًا، كيف حالك؟ ماذا تفعل؟ أتمنى أن يكون كل شيء بخير وعلى ما يرام.",
+  "word_timestamps": [
+    {
+      "word": "Hello,",
+      "start": 0.5,
+      "end": 0.737
+    },
+    {
+      "word": "how",
+      "start": 0.737,
+      "end": 0.975
+    },
+    {
+      "word": "are",
+      "start": 0.975,
+      "end": 1.212
+    },
+    {
+      "word": "you?",
+      "start": 1.212,
+      "end": 1.449
+    },
+    {
+      "word": "What",
+      "start": 1.449,
+      "end": 1.687
+    },
+    {
+      "word": "are",
+      "start": 1.687,
+      "end": 1.924
+    },
+    {
+      "word": "you",
+      "start": 1.924,
+      "end": 2.161
+    },
+    {
+      "word": "doing?",
+      "start": 2.161,
+      "end": 2.399
+    },
+    {
+      "word": "I",
+      "start": 2.399,
+      "end": 2.636
+    },
+    {
+      "word": "hope",
+      "start": 2.636,
+      "end": 2.873
+    },
+    {
+      "word": "everything",
+      "start": 2.873,
+      "end": 3.111
+    },
+    {
+      "word": "is",
+      "start": 3.111,
+      "end": 3.348
+    },
+    {
+      "word": "good",
+      "start": 3.348,
+      "end": 3.585
+    },
+    {
+      "word": "and",
+      "start": 3.585,
+      "end": 3.823
+    },
+    {
+      "word": "okay.",
+      "start": 3.823,
+      "end": 4.06
+    }
+  ],
+  "translated_timestamps": [
+    {
+      "word": "مرحبًا،",
+      "start": 0.5,
+      "end": 0.754
+    },
+    {
+      "word": "كيف",
+      "start": 0.754,
+      "end": 1.009
+    },
+    {
+      "word": "حالك؟",
+      "start": 1.009,
+      "end": 1.263
+    },
+    {
+      "word": "ماذا",
+      "start": 1.263,
+      "end": 1.517
+    },
+    {
+      "word": "تفعل؟",
+      "start": 1.517,
+      "end": 1.771
+    },
+    {
+      "word": "أتمنى",
+      "start": 1.771,
+      "end": 2.026
+    },
+    {
+      "word": "أن",
+      "start": 2.026,
+      "end": 2.28
+    },
+    {
+      "word": "يكون",
+      "start": 2.28,
+      "end": 2.534
+    },
+    {
+      "word": "كل",
+      "start": 2.534,
+      "end": 2.789
+    },
+    {
+      "word": "شيء",
+      "start": 2.789,
+      "end": 3.043
+    },
+    {
+      "word": "بخير",
+      "start": 3.043,
+      "end": 3.297
+    },
+    {
+      "word": "وعلى",
+      "start": 3.297,
+      "end": 3.551
+    },
+    {
+      "word": "ما",
+      "start": 3.551,
+      "end": 3.806
+    },
+    {
+      "word": "يرام.",
+      "start": 3.806,
+      "end": 4.06
+    }
+  ],
+  "audio_bytes": "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",
+  "original_suffix": ".wav",
+  "markers": [],
+  "target_language": "ar",
+  "translation_enabled": true,
+  "translation_success": true,
+  "language_detected": "en"
+}
\ No newline at end of file
diff --git a/token.json b/token.json
new file mode 100644
index 0000000000000000000000000000000000000000..80605349aea051396caa8ea5530d1cbd0aa09546
--- /dev/null
+++ b/token.json
@@ -0,0 +1 @@
+{"token": "ya29.a0AS3H6NwkupTfaaRTSlG8nHSa704w-Ci0FCnLzQrh5TfkNlrO5NoHV8nHgmAZNzVQ9QL2wLbyhoupV4nk125svdeAv5o5q1FGlt8WtBmH_FJL_9f6f89JmLTyvjeX8m1iFnj9pTv1DfMipXGghYKgvoLR05bZ1NJJUBwlWE2ZaCgYKAesSARISFQHGX2MiD1KHTpYpYs-cMcwYpfuTZg0175", "refresh_token": "1//0g9JuyLXTLXoyCgYIARAAGBASNwF-L9IrFWZcmX21Dara-R7chigMnoJDSueVi3CllQvlr1sEbndC7_9nzIoCsxWD97G95fix5ik", "token_uri": "https://oauth2.googleapis.com/token", "client_id": "739771741359-gk2mkvimn063a2msd6hmkkksn17iamre.apps.googleusercontent.com", "client_secret": "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", "scopes": ["https://www.googleapis.com/auth/documents"], "universe_domain": "googleapis.com", "account": "", "expiry": "2025-08-12T04:36:23Z"}
\ No newline at end of file
diff --git a/translator.py b/translator.py
new file mode 100644
index 0000000000000000000000000000000000000000..07b63e6d777a87d0f0d9202bbdee5232be880530
--- /dev/null
+++ b/translator.py
@@ -0,0 +1,574 @@
+# translator.py - AI-Powered Translation System with Arabic Support
+
+import os
+from dotenv import load_dotenv
+import json
+import traceback
+from typing import Dict, List, Optional, Tuple
+import google.generativeai as genai
+import requests
+import streamlit as st
+
+class AITranslator:
+    """
+    AI-powered translator using Gemini API with specialized Arabic support
+    """
+    
+    def __init__(self):
+        self.model: Optional[object] = None
+        self.init_error: Optional[str] = None
+        self.supported_languages = {
+            'ar': 'Arabic (العربية)',
+            'en': 'English',
+            'fr': 'French (Français)', 
+            'es': 'Spanish (Español)',
+            'de': 'German (Deutsch)',
+            'zh': 'Chinese (中文)',
+            'hi': 'Hindi (हिन्दी)',
+            'ur': 'Urdu (اردو)'
+        }
+        # Initialize providers
+        load_dotenv()
+        self._initialize_gemini()
+        # Groq
+        self.groq_api_key = os.getenv("GROQ_API_KEY")
+        self.groq_model = os.getenv("GROQ_MODEL", "llama-3.3-70b-versatile")
+        # OpenRouter (prefer free models)
+        self.openrouter_api_key = os.getenv("OPENROUTER_API_KEY")
+        self.openrouter_model = os.getenv("OPENROUTER_MODEL")  # if not set, try common free models
+        self.openrouter_site_url = os.getenv("OPENROUTER_SITE_URL", "http://localhost")
+        self.openrouter_site_title = os.getenv("OPENROUTER_SITE_TITLE", "LocalApp")
+    
+    def _initialize_gemini(self):
+        """Initialize Gemini AI client using the new API structure."""
+        try:
+            load_dotenv()
+            api_key = os.getenv("GEMINI_API_KEY")
+            if not api_key:
+                # This error is handled by the main app now, but we keep a fallback.
+                self.init_error = "GEMINI_API_KEY not found."
+                return
+
+            genai.configure(api_key=api_key)
+            self.model = genai.GenerativeModel('gemini-1.5-flash')
+        except Exception as e:
+            self.init_error = f"FATAL ERROR during Gemini Init: {str(e)}"
+            self.model = None
+    
+    def translate_text(self, text: str, target_language: str = 'ar', source_language: str = 'auto') -> Tuple[Optional[str], Optional[str]]:
+        """
+        Translate text to target language using Gemini AI
+        
+        Args:
+            text: Text to translate
+            target_language: Target language code ('ar' for Arabic)
+            source_language: Source language code ('auto' for auto-detection)
+        
+        Returns:
+            Tuple of (translated_text, error_message)
+        """
+        if not text or not text.strip():
+            return None, "ERROR: Empty text provided for translation."
+        
+        try:
+            target_lang_name = self.supported_languages.get(target_language, target_language)
+            prompt = self._create_translation_prompt(text, target_lang_name, target_language)
+
+            # Primary: Gemini
+            gem_err = None
+            if self.model:
+                try:
+                    response = self.model.generate_content(prompt)
+                    if response and hasattr(response, 'text') and response.text:
+                        translated_text = response.text.strip()
+                        translated_text = self._clean_translation_output(translated_text)
+                        return translated_text, None
+                    gem_err = "WARNING: Gemini returned empty translation response."
+                except Exception:
+                    gem_err = f"Gemini translation failed: {traceback.format_exc()}"
+
+            # Fallback: OpenRouter (free models if possible)
+            rtxt, rerr = self._openrouter_complete(prompt)
+            if rtxt:
+                return self._clean_translation_output(rtxt), None
+            # Fallback: Groq
+            gtxt, gerr = self._groq_complete(prompt)
+            if gtxt:
+                return self._clean_translation_output(gtxt), None
+            return None, gerr or rerr or gem_err
+        except Exception:
+            error_msg = f"FATAL ERROR during translation: {traceback.format_exc()}"
+            return None, error_msg
+    
+    def _create_translation_prompt(self, text: str, target_lang_name: str, target_lang_code: str) -> str:
+        """Create optimized prompt for translation"""
+        
+        if target_lang_code == 'ar':
+            # Specialized prompt for Arabic translation
+            prompt = f"""
+Translate the following text to Arabic (العربية) with these requirements:
+1. Maintain the original meaning accurately
+2. Use Modern Standard Arabic (MSA) appropriate for academic contexts
+3. Preserve technical terms when appropriate
+4. Make it natural and fluent for Arabic speakers
+5. For educational content, use clear and accessible language
+6. Return ONLY the translated text without any explanations or formatting
+
+Text to translate:
+{text}
+"""
+        else:
+            # General prompt for other languages
+            prompt = f"""
+Translate the following text to {target_lang_name} accurately while:
+1. Maintaining the original meaning
+2. Using appropriate formal/academic tone if the content appears educational
+3. Preserving any technical terms appropriately
+4. Making it natural and fluent for native speakers
+5. Return ONLY the translated text without explanations
+
+Text to translate:
+{text}
+"""
+        
+        return prompt
+    
+    def _clean_translation_output(self, text: str) -> str:
+        """Clean up translation output from any unwanted formatting"""
+        # Remove common markdown artifacts
+        text = text.replace('**', '').replace('*', '')
+        text = text.replace('```', '').replace('`', '')
+        
+        # Remove any leading/trailing quotes
+        text = text.strip('"\'')
+        
+        # Clean up extra whitespace
+        text = ' '.join(text.split())
+        
+        return text
+
+    def explain_text_arabic(self, text: str, source_language: str = 'auto') -> Tuple[Optional[str], Optional[str]]:
+        """Generate a detailed Arabic explanation (not a literal translation)."""
+    # Don't hard fail if Gemini is unavailable; we'll fallback.
+        if not text or not text.strip():
+            return None, "ERROR: Empty text provided for explanation."
+
+        try:
+            prompt = f"""
+أنت مُعلّم جامعي خبير. اشرح النص التالي باللغة العربية الفصحى المبسّطة كأنك تشرح لطلاب فصل دراسي. لا تترجم حرفياً؛ قدّم شرحاً تعليمياً منظّماً يساعد على الفهم والتطبيق.
+
+المتطلبات:
+1) تمهيد مختصر للفكرة العامة.
+2) شرح تفصيلي منظّم بعناوين فرعية، وتقسيم للأفكار.
+3) أمثلة تطبيقية واقعية (٣–٥) توضّح الفكرة.
+4) نقاط مُلخّصة أساسية (قائمة نقاط) تُثبّت المفاهيم.
+5) مصطلحات رئيسية وتعريفات موجزة إن وُجدت.
+6) أسئلة للمراجعة والتحفيز على التفكير.
+7) أخطاء شائعة يجب تجنّبها إن وُجدت.
+8) نصائح للتذكّر والاستذكار.
+
+إرشادات الإخراج:
+- استخدم العربية الفصحى سهلة وواضحة.
+- استخدم عناوين فرعية واضحة ونقاط تعداد (بدون تنسيق برمجي).
+- إذا كان النص الأصلي بغير العربية، انقله ذهنياً للشرح بالعربية دون سرد ترجمة حرفية.
+- أعِد الناتج كنص عربي فقط دون أكواد أو علامات Markdown إضافية.
+
+النص:
+{text}
+"""
+            # Primary: Gemini
+            gem_err = None
+            if self.model:
+                try:
+                    response = self.model.generate_content(prompt)
+                    if response and hasattr(response, 'text') and response.text:
+                        out = response.text.strip().replace('```', '').replace('`', '')
+                        return out, None
+                    gem_err = "WARNING: Gemini returned empty explanation response."
+                except Exception:
+                    gem_err = f"Gemini explanation failed: {traceback.format_exc()}"
+            # Fallback: OpenRouter (free)
+            rtxt, rerr = self._openrouter_complete(prompt)
+            if rtxt:
+                out = rtxt.strip().replace('```', '').replace('`', '')
+                return out, None
+            # Fallback: Groq
+            gtxt, gerr = self._groq_complete(prompt)
+            if gtxt:
+                out = gtxt.strip().replace('```', '').replace('`', '')
+                return out, None
+            return None, gerr or rerr or gem_err
+        except Exception:
+            return None, f"FATAL ERROR during Arabic explanation: {traceback.format_exc()}"
+
+    def summarize_text_arabic(self, text: str, source_language: str = 'auto') -> Tuple[Optional[str], Optional[str]]:
+        """Generate a concise Arabic bullet-point summary tied to the provided text with relevant examples."""
+        if not text or not text.strip():
+            return None, "ERROR: Empty text provided for summary."
+
+        try:
+            prompt = f"""
+اكتب ملخصاً بالعربية الفصحى للنص التالي، يبدأ بفقرة موجزة توضّح موضوع النص وما يدور حوله (شرح موجز دقيق)، ثم يتلوها نقاط رئيسية مُنظمة، وأبرز بعد ذلك "ملاحظات مهمة" يجب الانتباه لها، مع أمثلة موجزة ذات صلة. اجعل الناتج كله ضمن نص واحد دون تنسيقات برمجية.
+
+المخرجات ضمن نفس النص وبالترتيب:
+أولاً) فقرة موجزة تُعرّف موضوع النص وتلخّصه في 2–4 جُمل.
+ثانياً) نقاط رئيسية (3–7 نقاط) قصيرة وواضحة.
+ثالثاً) ملاحظات مهمة يجب الانتباه لها (1–4 نقاط) مميزة لفظياً (مثلاً: ملاحظة مهمة: ...).
+رابعاً) أمثلة موجزة ذات صلة (2–3) إن أمكن.
+خامساً) قائمة مصطلحات رئيسية (3–8) مع تعريف عربي موجز لكل مصطلح إن وُجدت.
+
+تعليمات الأسلوب:
+- لا تُطِل؛ كن موجزاً ودقيقاً ومباشراً.
+- لا تستخدم ترقيم برمجي أو Markdown؛ استخدم نصاً عادياً مع فواصل وأسطر فقط.
+- لا تُدخل معلومات غير موجودة في النص.
+
+النص:
+{text}
+"""
+            # Primary: Gemini
+            gem_err = None
+            if self.model:
+                try:
+                    response = self.model.generate_content(prompt)
+                    if response and hasattr(response, 'text') and response.text:
+                        out = response.text.strip().replace('```', '').replace('`', '')
+                        return out, None
+                    gem_err = "WARNING: Gemini returned empty summary response."
+                except Exception:
+                    gem_err = f"Gemini summary failed: {traceback.format_exc()}"
+            # Fallback: OpenRouter
+            rtxt, rerr = self._openrouter_complete(prompt)
+            if rtxt:
+                out = rtxt.strip().replace('```', '').replace('`', '')
+                return out, None
+            # Fallback: Groq
+            gtxt, gerr = self._groq_complete(prompt)
+            if gtxt:
+                out = gtxt.strip().replace('```', '').replace('`', '')
+                return out, None
+            return None, gerr or rerr or gem_err
+        except Exception:
+            return None, f"FATAL ERROR during Arabic summary: {traceback.format_exc()}"
+
+    def summarize_text(self, text: str, target_language: str = 'ar', source_language: str = 'auto') -> Tuple[Optional[str], Optional[str]]:
+        """Generate a concise bullet-point summary in the requested language.
+
+        Defaults to Arabic; mirrors the structure used in summarize_text_arabic.
+        """
+        if not text or not text.strip():
+            return None, "ERROR: Empty text provided for summary."
+
+        try:
+            target_lang_name = self.supported_languages.get(target_language, target_language)
+            prompt = f"""
+Write a concise summary in {target_lang_name} for the following text. Start with a brief overview paragraph (2–4 sentences), then list key bullet points, important notes (clearly marked), short relevant examples, and a small glossary of key terms with brief definitions if applicable. Keep it compact and accurate. Return plain text only (no code blocks or markdown).
+
+Text:
+{text}
+"""
+            # Primary: Gemini
+            gem_err = None
+            if self.model:
+                try:
+                    response = self.model.generate_content(prompt)
+                    if response and hasattr(response, 'text') and response.text:
+                        out = response.text.strip().replace('```', '').replace('`', '')
+                        return out, None
+                    gem_err = "WARNING: Gemini returned empty summary response."
+                except Exception:
+                    gem_err = f"Gemini summary failed: {traceback.format_exc()}"
+            # Fallback: OpenRouter
+            rtxt, rerr = self._openrouter_complete(prompt)
+            if rtxt:
+                out = rtxt.strip().replace('```', '').replace('`', '')
+                return out, None
+            # Fallback: Groq
+            gtxt, gerr = self._groq_complete(prompt)
+            if gtxt:
+                out = gtxt.strip().replace('```', '').replace('`', '')
+                return out, None
+            return None, gerr or rerr or gem_err
+        except Exception:
+            return None, f"FATAL ERROR during summary: {traceback.format_exc()}"
+
+    def _groq_complete(self, prompt: str) -> Tuple[Optional[str], Optional[str]]:
+        """Call Groq chat completions with a single-turn system+user prompt.
+
+        Returns (text, error). Uses GROQ_API_KEY and default model if available.
+        """
+        try:
+            if not self.groq_api_key:
+                return None, "GROQ_API_KEY not set."
+            url = "https://api.groq.com/openai/v1/chat/completions"
+            headers = {
+                "Authorization": f"Bearer {self.groq_api_key}",
+                "Content-Type": "application/json",
+            }
+            body = {
+                "model": self.groq_model,
+                "messages": [
+                    {"role": "system", "content": "You are a helpful assistant."},
+                    {"role": "user", "content": prompt},
+                ],
+            }
+            resp = requests.post(url, headers=headers, json=body, timeout=30)
+            if not resp.ok:
+                try:
+                    err = resp.json()
+                except Exception:
+                    err = {"error": resp.text}
+                return None, f"Groq error {resp.status_code}: {err}"
+            data = resp.json()
+            choices = data.get("choices") or []
+            if not choices:
+                return None, "Groq returned no choices."
+            content = choices[0].get("message", {}).get("content")
+            if not content:
+                return None, "Groq returned empty content."
+            return content, None
+        except Exception:
+            return None, f"Groq request failed: {traceback.format_exc()}"
+
+    def _openrouter_complete(self, prompt: str) -> Tuple[Optional[str], Optional[str]]:
+        """Call OpenRouter chat completions. Tries configured model or a list of free candidates.
+
+        Returns (text, error).
+        """
+        try:
+            if not self.openrouter_api_key:
+                return None, "OPENROUTER_API_KEY not set."
+            url = "https://openrouter.ai/api/v1/chat/completions"
+            headers = {
+                "Authorization": f"Bearer {self.openrouter_api_key}",
+                "Content-Type": "application/json",
+                "HTTP-Referer": self.openrouter_site_url or "http://localhost",
+                "X-Title": self.openrouter_site_title or "LocalApp",
+            }
+            # Candidate list prioritizing common free models
+            # Always include fallback models for better reliability
+            fallback_models = [
+                "meta-llama/llama-3.2-3b-instruct:free",
+                "meta-llama/llama-3.1-8b-instruct:free", 
+                "google/gemma-2-9b-it:free",
+                "qwen/qwen-2.5-7b-instruct:free",
+                "microsoft/phi-3-mini-128k-instruct:free",
+                "huggingfaceh4/zephyr-7b-beta:free"
+            ]
+            
+            candidates = []
+            if self.openrouter_model:
+                # Start with preferred model, then add fallbacks
+                candidates = [self.openrouter_model]
+                # Add fallbacks that are different from the preferred model
+                for model in fallback_models:
+                    if model != self.openrouter_model and model not in candidates:
+                        candidates.append(model)
+            else:
+                candidates = fallback_models
+            last_err = None
+            for model in candidates:
+                body = {
+                    "model": model,
+                    "messages": [
+                        {"role": "system", "content": "You are a helpful assistant."},
+                        {"role": "user", "content": prompt},
+                    ],
+                }
+                try:
+                    resp = requests.post(url, headers=headers, json=body, timeout=45)
+                    if not resp.ok:
+                        try:
+                            err = resp.json()
+                        except Exception:
+                            err = {"error": resp.text}
+                        last_err = f"OpenRouter error {resp.status_code} for {model}: {err}"
+                        continue
+                    data = resp.json()
+                    choices = data.get("choices") or []
+                    if not choices:
+                        last_err = f"OpenRouter returned no choices for {model}."
+                        continue
+                    content = choices[0].get("message", {}).get("content")
+                    if not content:
+                        last_err = f"OpenRouter returned empty content for {model}."
+                        continue
+                    return content, None
+                except Exception:
+                    last_err = f"OpenRouter request failed for {model}: {traceback.format_exc()}"
+                    continue
+            return None, last_err or "OpenRouter request failed."
+        except Exception:
+            return None, f"OpenRouter wrapper failed: {traceback.format_exc()}"
+    
+    def translate_ui_elements(self, ui_dict: Dict[str, str], target_language: str = 'ar') -> Dict[str, str]:
+        """
+        Translate UI elements dictionary
+        
+        Args:
+            ui_dict: Dictionary of UI elements {key: english_text}
+            target_language: Target language code
+        
+        Returns:
+            Dictionary with translated values
+        """
+        translated_dict = {}
+        
+        for key, english_text in ui_dict.items():
+            translated_text, error = self.translate_text(english_text, target_language)
+            if translated_text:
+                translated_dict[key] = translated_text
+            else:
+                # Fallback to original text if translation fails
+                translated_dict[key] = english_text
+                print(f"Translation failed for '{key}': {error}")
+        
+        return translated_dict
+    
+    def batch_translate(self, texts: List[str], target_language: str = 'ar') -> List[Dict[str, str]]:
+        """
+        Translate multiple texts in batch
+        
+        Args:
+            texts: List of texts to translate
+            target_language: Target language code
+        
+        Returns:
+            List of dictionaries with original and translated text
+        """
+        results = []
+        
+        for i, text in enumerate(texts):
+            translated_text, error = self.translate_text(text, target_language)
+            
+            result = {
+                'index': i,
+                'original': text,
+                'translated': translated_text if translated_text else text,
+                'success': translated_text is not None,
+                'error': error
+            }
+            results.append(result)
+        
+        return results
+    
+    def get_supported_languages(self) -> Dict[str, str]:
+        """Get list of supported languages"""
+        return self.supported_languages.copy()
+
+
+# UI Translations Dictionary for Common Elements
+UI_TRANSLATIONS = {
+    'en': {
+        'start_recording': 'Start Recording',
+        'stop_recording': 'Stop Recording',
+        'pause_recording': 'Pause Recording',
+        'resume_recording': 'Resume Recording',
+        'mark_important': 'Mark Important',
+        'extract_text': 'Extract Text',
+        'rerecord': 'Re-record',
+        'processing': 'Processing...',
+        'ready_to_record': 'Ready to Record',
+        'recording': 'Recording...',
+        'paused': 'Paused',
+        'review_recording': 'Review your recording',
+        'processing_complete': 'Processing Complete!',
+        'upload_file': 'Upload a File',
+        'record_audio': 'Record Audio',
+        'choose_audio_file': 'Choose an audio file',
+        'supported_formats': 'Supported formats: MP3, WAV, M4A',
+        'microphone_permission': 'Microphone permission denied.',
+        'browser_not_supported': 'Your browser does not support audio recording.',
+        'quality': 'Quality',
+        'language': 'Language',
+        'settings': 'Settings',
+        'help': 'Help',
+        'about': 'About',
+        'simple_mode': 'Simple Mode',
+        'advanced_mode': 'Advanced Mode',
+        'lecture_mode': 'Lecture Mode',
+        'transcription': 'Transcription',
+        'translation': 'Translation',
+        'markers': 'Important Markers',
+        'duration': 'Duration',
+        'file_size': 'File Size',
+        'audio_level': 'Audio Level',
+        'error_occurred': 'An error occurred',
+        'try_again': 'Try Again',
+        'success': 'Success',
+        'failed': 'Failed',
+        'loading': 'Loading...',
+        'save': 'Save',
+        'cancel': 'Cancel',
+        'close': 'Close',
+        'download': 'Download',
+        'share': 'Share',
+        'copy': 'Copy',
+        'paste': 'Paste',
+        'clear': 'Clear',
+        'reset': 'Reset'
+    },
+    'ar': {
+        'start_recording': 'بدء التسجيل',
+        'stop_recording': 'إيقاف التسجيل',
+        'pause_recording': 'إيقاف مؤقت',
+        'resume_recording': 'استئناف التسجيل',
+        'mark_important': 'تعليم مهم',
+        'extract_text': 'استخراج النص',
+        'rerecord': 'إعادة تسجيل',
+        'processing': 'جاري المعالجة...',
+        'ready_to_record': 'جاهز للتسجيل',
+        'recording': 'جاري التسجيل...',
+        'paused': 'متوقف مؤقتاً',
+        'review_recording': 'مراجعة التسجيل',
+        'processing_complete': 'اكتملت المعالجة!',
+        'upload_file': 'رفع ملف',
+        'record_audio': 'تسجيل صوتي',
+        'choose_audio_file': 'اختر ملف صوتي',
+        'supported_formats': 'التنسيقات المدعومة: MP3, WAV, M4A',
+        'microphone_permission': 'تم رفض إذن الميكروفون.',
+        'browser_not_supported': 'متصفحك لا يدعم التسجيل الصوتي.',
+        'quality': 'الجودة',
+        'language': 'اللغة',
+        'settings': 'الإعدادات',
+        'help': 'المساعدة',
+        'about': 'حول',
+        'simple_mode': 'الوضع البسيط',
+        'advanced_mode': 'الوضع المتقدم',
+        'lecture_mode': 'وضع المحاضرة',
+        'transcription': 'النسخ النصي',
+        'translation': 'الترجمة',
+        'markers': 'العلامات المهمة',
+        'duration': 'المدة',
+        'file_size': 'حجم الملف',
+        'audio_level': 'مستوى الصوت',
+        'error_occurred': 'حدث خطأ',
+        'try_again': 'حاول مرة أخرى',
+        'success': 'نجح',
+        'failed': 'فشل',
+        'loading': 'جاري التحميل...',
+        'save': 'حفظ',
+        'cancel': 'إلغاء',
+        'close': 'إغلاق',
+        'download': 'تحميل',
+        'share': 'مشاركة',
+        'copy': 'نسخ',
+        'paste': 'لصق',
+        'clear': 'مسح',
+        'reset': 'إعادة تعيين'
+    }
+}
+
+
+# Helper function to get translations
+def get_translation(key: str, language: str = 'en') -> str:
+    """Get translation for a specific key and language"""
+    return UI_TRANSLATIONS.get(language, {}).get(key, UI_TRANSLATIONS['en'].get(key, key))
+
+
+@st.cache_resource
+def get_translator():
+    """
+    Get a singleton translator instance using Streamlit's resource caching.
+    This ensures the model is initialized only once per session.
+    """
+    return AITranslator()
diff --git a/utils.py b/utils.py
new file mode 100644
index 0000000000000000000000000000000000000000..4f95ca67c8705fe0d5a27c2c16533f9eda0fdae2
--- /dev/null
+++ b/utils.py
@@ -0,0 +1,355 @@
+import os
+import mimetypes
+import tempfile
+from pathlib import Path
+from typing import Optional, List, Dict
+import librosa
+import numpy as np
+
+def format_timestamp(seconds: float) -> str:
+    """
+    Format seconds into MM:SS.mmm format
+    
+    Args:
+        seconds: Time in seconds
+        
+    Returns:
+        Formatted timestamp string
+    """
+    minutes = int(seconds // 60)
+    remaining_seconds = seconds % 60
+    return f"{minutes:02d}:{remaining_seconds:06.3f}"
+
+def validate_audio_file(file_path: str) -> bool:
+    """
+    Validate if the file is a supported audio format
+    
+    Args:
+        file_path: Path to the audio file
+        
+    Returns:
+        True if valid, False otherwise
+    """
+    try:
+        if not os.path.exists(file_path):
+            return False
+        
+        # Check file extension
+        supported_extensions = ['.mp3', '.wav', '.m4a', '.flac', '.ogg']
+        file_extension = Path(file_path).suffix.lower()
+        
+        if file_extension not in supported_extensions:
+            return False
+        
+        # Check MIME type
+        mime_type, _ = mimetypes.guess_type(file_path)
+        if mime_type and not mime_type.startswith('audio/'):
+            return False
+        
+        # Try to load with librosa to verify it's a valid audio file
+        try:
+            librosa.load(file_path, duration=1.0)  # Load just 1 second for validation
+            return True
+        except:
+            return False
+            
+    except Exception:
+        return False
+
+def get_audio_info(file_path: str) -> Dict:
+    """
+    Get information about the audio file
+    
+    Args:
+        file_path: Path to the audio file
+        
+    Returns:
+        Dictionary with audio information
+    """
+    try:
+        # Load audio file
+        y, sr = librosa.load(file_path)
+        
+        duration = len(y) / sr
+        
+        return {
+            'duration': duration,
+            'sample_rate': sr,
+            'channels': 1 if len(y.shape) == 1 else y.shape[0],
+            'file_size': os.path.getsize(file_path),
+            'format': Path(file_path).suffix.lower()
+        }
+        
+    except Exception as e:
+        return {
+            'error': str(e),
+            'duration': 0,
+            'sample_rate': 0,
+            'channels': 0,
+            'file_size': 0,
+            'format': 'unknown'
+        }
+
+def clean_text(text: str) -> str:
+    """
+    Clean and normalize text for better processing
+    
+    Args:
+        text: Input text
+        
+    Returns:
+        Cleaned text
+    """
+    if not text:
+        return ""
+    
+    # Remove extra whitespace
+    text = ' '.join(text.split())
+    
+    # Remove common transcription artifacts
+    text = text.replace('[Music]', '')
+    text = text.replace('[Applause]', '')
+    text = text.replace('[Laughter]', '')
+    text = text.replace('(Music)', '')
+    text = text.replace('(Applause)', '')
+    text = text.replace('(Laughter)', '')
+    
+    # Clean up extra spaces
+    text = ' '.join(text.split())
+    
+    return text.strip()
+
+def split_text_into_chunks(text: str, max_chars_per_chunk: int = 100) -> List[str]:
+    """
+    Split text into chunks suitable for video display
+    
+    Args:
+        text: Input text
+        max_chars_per_chunk: Maximum characters per chunk
+        
+    Returns:
+        List of text chunks
+    """
+    if not text:
+        return []
+    
+    words = text.split()
+    chunks = []
+    current_chunk = []
+    current_length = 0
+    
+    for word in words:
+        word_length = len(word) + 1  # +1 for space
+        
+        if current_length + word_length > max_chars_per_chunk and current_chunk:
+            # Add current chunk and start new one
+            chunks.append(' '.join(current_chunk))
+            current_chunk = [word]
+            current_length = len(word)
+        else:
+            current_chunk.append(word)
+            current_length += word_length
+    
+    # Add final chunk
+    if current_chunk:
+        chunks.append(' '.join(current_chunk))
+    
+    return chunks
+
+def convert_color_hex_to_rgb(hex_color: str) -> tuple:
+    """
+    Convert hex color to RGB tuple
+    
+    Args:
+        hex_color: Hex color string (e.g., '#FF0000')
+        
+    Returns:
+        RGB tuple (r, g, b)
+    """
+    hex_color = hex_color.lstrip('#')
+    
+    if len(hex_color) != 6:
+        return (255, 255, 255)  # Default to white
+    
+    try:
+        r = int(hex_color[0:2], 16)
+        g = int(hex_color[2:4], 16)
+        b = int(hex_color[4:6], 16)
+        return (r, g, b)
+    except ValueError:
+        return (255, 255, 255)  # Default to white
+
+def convert_rgb_to_hex(r: int, g: int, b: int) -> str:
+    """
+    Convert RGB values to hex color string
+    
+    Args:
+        r, g, b: RGB color values (0-255)
+        
+    Returns:
+        Hex color string
+    """
+    return f"#{r:02x}{g:02x}{b:02x}"
+
+def estimate_video_file_size(duration: float, resolution: tuple = (1280, 720), 
+                           bitrate_kbps: int = 2000) -> int:
+    """
+    Estimate the file size of a video based on duration and quality
+    
+    Args:
+        duration: Video duration in seconds
+        resolution: Video resolution tuple (width, height)
+        bitrate_kbps: Video bitrate in kbps
+        
+    Returns:
+        Estimated file size in bytes
+    """
+    # Simple estimation: bitrate * duration / 8 (to convert bits to bytes)
+    estimated_size = (bitrate_kbps * 1000 * duration) / 8
+    return int(estimated_size)
+
+def create_safe_filename(filename: str) -> str:
+    """
+    Create a safe filename by removing/replacing invalid characters
+    
+    Args:
+        filename: Original filename
+        
+    Returns:
+        Safe filename
+    """
+    import re
+    
+    # Remove or replace invalid characters
+    safe_filename = re.sub(r'[<>:"/\\|?*]', '_', filename)
+    
+    # Remove extra underscores and spaces
+    safe_filename = re.sub(r'[_\s]+', '_', safe_filename)
+    
+    # Trim leading/trailing underscores
+    safe_filename = safe_filename.strip('_')
+    
+    # Ensure filename is not empty
+    if not safe_filename:
+        safe_filename = "output"
+    
+    return safe_filename
+
+def format_file_size(size_bytes: int) -> str:
+    """
+    Format file size in human-readable format
+    
+    Args:
+        size_bytes: File size in bytes
+        
+    Returns:
+        Formatted file size string
+    """
+    if size_bytes == 0:
+        return "0 B"
+    
+    size_names = ["B", "KB", "MB", "GB"]
+    i = int(np.floor(np.log(size_bytes) / np.log(1024)))
+    p = np.power(1024, i)
+    s = round(size_bytes / p, 2)
+    
+    return f"{s} {size_names[i]}"
+
+def validate_word_timestamps(word_timestamps: List[Dict]) -> List[Dict]:
+    """
+    Validate and clean word timestamps data
+    
+    Args:
+        word_timestamps: List of word timestamp dictionaries
+        
+    Returns:
+        Cleaned and validated word timestamps
+    """
+    validated_timestamps = []
+    
+    for word_data in word_timestamps:
+        # Ensure required fields exist
+        if not isinstance(word_data, dict):
+            continue
+        
+        word = word_data.get('word', '').strip()
+        start = word_data.get('start', 0)
+        end = word_data.get('end', 0)
+        
+        # Skip empty words
+        if not word:
+            continue
+        
+        # Ensure numeric timestamps
+        try:
+            start = float(start)
+            end = float(end)
+        except (ValueError, TypeError):
+            continue
+        
+        # Ensure logical timestamp order
+        if start < 0:
+            start = 0
+        if end <= start:
+            end = start + 0.1  # Minimum duration
+        
+        validated_timestamps.append({
+            'word': word,
+            'start': round(start, 3),
+            'end': round(end, 3)
+        })
+    
+    return validated_timestamps
+
+def merge_overlapping_timestamps(word_timestamps: List[Dict], 
+                               overlap_threshold: float = 0.05) -> List[Dict]:
+    """
+    Merge overlapping or very close word timestamps
+    
+    Args:
+        word_timestamps: List of word timestamp dictionaries
+        overlap_threshold: Threshold for merging close timestamps (seconds)
+        
+    Returns:
+        List with merged timestamps
+    """
+    if not word_timestamps:
+        return []
+    
+    merged_timestamps = []
+    current_group = [word_timestamps[0]]
+    
+    for word_data in word_timestamps[1:]:
+        last_end = current_group[-1]['end']
+        current_start = word_data['start']
+        
+        # Check if words should be merged
+        if current_start - last_end <= overlap_threshold:
+            current_group.append(word_data)
+        else:
+            # Merge current group and start new one
+            if len(current_group) == 1:
+                merged_timestamps.append(current_group[0])
+            else:
+                # Merge multiple words
+                merged_word = {
+                    'word': ' '.join([w['word'] for w in current_group]),
+                    'start': current_group[0]['start'],
+                    'end': current_group[-1]['end']
+                }
+                merged_timestamps.append(merged_word)
+            
+            current_group = [word_data]
+    
+    # Handle final group
+    if len(current_group) == 1:
+        merged_timestamps.append(current_group[0])
+    else:
+        merged_word = {
+            'word': ' '.join([w['word'] for w in current_group]),
+            'start': current_group[0]['start'],
+            'end': current_group[-1]['end']
+        }
+        merged_timestamps.append(merged_word)
+    
+    return merged_timestamps
diff --git a/video_generator.py b/video_generator.py
new file mode 100644
index 0000000000000000000000000000000000000000..42c169a77466292662b07663547aa59c6dec7f2c
--- /dev/null
+++ b/video_generator.py
@@ -0,0 +1,33 @@
+# START OF video_generator.py
+import os
+import tempfile
+import shutil
+from typing import List, Dict
+
+class VideoGenerator:
+    """A simplified and safe video generator."""
+    
+    def __init__(self):
+        self.temp_dir = tempfile.mkdtemp()
+        
+    def create_synchronized_video(self, audio_path: str, word_timestamps: List[Dict], 
+                                text: str, style_config: Dict, output_filename: str) -> str:
+        """
+        This is a fallback function. Instead of creating a video, 
+        it copies the audio file to a .m4a format to indicate a processed file.
+        This avoids using ffmpeg and external fonts, which can cause errors.
+        """
+        try:
+            # The safest operation is to just provide the audio back in a different format
+            output_path = os.path.join(self.temp_dir, output_filename.replace('.mp4', '.m4a'))
+            shutil.copy2(audio_path, output_path)
+            print(f"Fallback successful: Created audio file at {output_path}")
+            return output_path
+        except Exception as e:
+            print(f"Critical error in fallback video generation: {e}")
+            raise
+    
+    def __del__(self):
+        if hasattr(self, 'temp_dir') and os.path.exists(self.temp_dir):
+            shutil.rmtree(self.temp_dir, ignore_errors=True)
+# END OF video_generator.py
\ No newline at end of file
diff --git a/ws_server.py b/ws_server.py
new file mode 100644
index 0000000000000000000000000000000000000000..0649270d038a072affa3f66d26f87d991547fbe3
--- /dev/null
+++ b/ws_server.py
@@ -0,0 +1,281 @@
+"""
+Minimal FastAPI WebSocket server for streaming audio chunks with ACK and a simple per-session ring buffer,
+plus a REST endpoint to request slice transcription using a background worker (stub ASR).
+
+Run locally:
+    python -m uvicorn ws_server:app --host 0.0.0.0 --port 5001
+
+Endpoints:
+    WS /ws/stream/{session_id}
+    GET /buffer_window/{session_id}
+    POST /transcribe_slice
+    GET /job/{job_id}
+
+Protocol (JSON frames):
+    -> {"type":"audio.chunk","session_id":"...","seq":int,"t0_ms":int,"t1_ms":int,"mime":"audio/webm;codecs=opus","b64":"..."}
+    <- {"type":"audio.ack","session_id":"...","seq":int,"backlog_ms":int}
+"""
+from __future__ import annotations
+
+import base64
+import time
+from collections import deque, defaultdict
+from dataclasses import dataclass
+from typing import Deque, Dict, List, Optional
+import asyncio
+import uuid
+
+from fastapi import FastAPI, WebSocket, WebSocketDisconnect
+from fastapi.middleware.cors import CORSMiddleware
+from fastapi import Body
+from pydantic import BaseModel
+
+
+@dataclass
+class AudioChunk:
+    t0_ms: int
+    t1_ms: int
+    mime: str
+    data: bytes
+
+
+class SessionBuffer:
+    """Simple time-retention ring using deque per session."""
+
+    def __init__(self, retention_ms: int = 10 * 60 * 1000):  # 10 minutes
+        self.retention_ms = retention_ms
+        self.q: Deque[AudioChunk] = deque()
+
+    def push(self, chunk: AudioChunk):
+        self.q.append(chunk)
+        self._evict(chunk.t1_ms - self.retention_ms)
+
+    def _evict(self, threshold_ms: int):
+        while self.q and self.q[0].t1_ms < threshold_ms:
+            self.q.popleft()
+
+    def backlog_ms(self) -> int:
+        if not self.q:
+            return 0
+        return self.q[-1].t1_ms - self.q[0].t0_ms
+
+    def get_range(self, start_ms: int, end_ms: int) -> List[AudioChunk]:
+        return [c for c in self.q if not (c.t1_ms <= start_ms or c.t0_ms >= end_ms)]
+
+    def window(self) -> Dict[str, int]:
+        if not self.q:
+            return {"head_ms": 0, "tail_ms": 0}
+        return {"head_ms": self.q[0].t0_ms, "tail_ms": self.q[-1].t1_ms}
+
+
+app = FastAPI(title="SyncMaster WS Server")
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+
+sessions: Dict[str, SessionBuffer] = {}
+
+
+class ConnectionManager:
+    def __init__(self):
+        self.clients: Dict[str, List[WebSocket]] = defaultdict(list)
+
+    async def connect(self, session_id: str, websocket: WebSocket):
+        await websocket.accept()
+        self.clients[session_id].append(websocket)
+
+    def disconnect(self, session_id: str, websocket: WebSocket):
+        if websocket in self.clients.get(session_id, []):
+            self.clients[session_id].remove(websocket)
+        if not self.clients.get(session_id):
+            self.clients.pop(session_id, None)
+
+    async def send_json(self, session_id: str, message: dict):
+        for ws in list(self.clients.get(session_id, [])):
+            try:
+                await ws.send_json(message)
+            except Exception:
+                # drop broken connections
+                self.disconnect(session_id, ws)
+
+
+manager = ConnectionManager()
+
+
+@app.websocket("/ws/stream/{session_id}")
+async def ws_stream(websocket: WebSocket, session_id: str):
+    await manager.connect(session_id, websocket)
+    try:
+        while True:
+            msg = await websocket.receive_json()
+            mtype = msg.get("type")
+
+            if mtype == "ping":
+                await websocket.send_json({"type": "pong", "ts_ms": int(time.time() * 1000)})
+                continue
+
+            if mtype == "audio.chunk":
+                # trust path param; payload session_id optional
+                seq = int(msg.get("seq", 0))
+                t0_ms = int(msg.get("t0_ms", 0))
+                t1_ms = int(msg.get("t1_ms", 0))
+                mime = msg.get("mime", "audio/webm;codecs=opus")
+                b64 = msg.get("b64", "")
+                try:
+                    data = base64.b64decode(b64) if b64 else b""
+                except Exception:
+                    data = b""
+
+                buf = sessions.setdefault(session_id, SessionBuffer())
+                buf.push(AudioChunk(t0_ms=t0_ms, t1_ms=t1_ms, mime=mime, data=data))
+
+                await websocket.send_json(
+                    {
+                        "type": "audio.ack",
+                        "session_id": session_id,
+                        "seq": seq,
+                        "backlog_ms": buf.backlog_ms(),
+                    }
+                )
+                continue
+
+            await websocket.send_json({"type": "error", "message": f"unknown type: {mtype}"})
+
+    except WebSocketDisconnect:
+        manager.disconnect(session_id, websocket)
+        return
+
+
+@app.get("/health")
+async def health():
+    return {"status": "ok"}
+
+
+@app.get("/buffer_window/{session_id}")
+async def buffer_window(session_id: str):
+    buf = sessions.get(session_id)
+    if not buf:
+        return {"head_ms": 0, "tail_ms": 0, "backlog_ms": 0}
+    w = buf.window()
+    return {**w, "backlog_ms": buf.backlog_ms()}
+
+
+class TranscribeRequest(BaseModel):
+    session_id: Optional[str] = None
+    slice_id: str
+    start_ms: Optional[int] = None
+    end_ms: Optional[int] = None
+    requested_tier: str = "A"  # A or B
+    offset_ms: Optional[int] = None  # optional: last N ms if start/end not provided
+
+
+jobs: Dict[str, Dict] = {}
+
+
+def _make_stub_result(session_id: str, slice_id: str, start_ms: int, end_ms: int, tier: str) -> Dict:
+    dur = max(0, end_ms - start_ms)
+    # Stub transcript
+    text = f"Stub transcript for session {session_id} from {start_ms} to {end_ms}."
+    # Create a couple of segments and words deterministically
+    segs = [
+        {"start_ms": start_ms, "end_ms": min(end_ms, start_ms + 700), "text": "Hello", "confidence": 0.91},
+        {"start_ms": min(end_ms, start_ms + 700), "end_ms": end_ms, "text": "world", "confidence": 0.88},
+    ]
+    words = [
+        {"start_ms": start_ms + 10, "end_ms": start_ms + 120, "word": "lecture", "confidence": 0.88},
+        {"start_ms": start_ms + 130, "end_ms": start_ms + 220, "word": "assistant", "confidence": 0.86},
+    ]
+    return {
+        "slice_id": slice_id,
+        "session_id": session_id,
+        "start_ms": start_ms,
+        "end_ms": end_ms,
+        "duration_ms": dur,
+        "transcript": text,
+        "segments": segs,
+        "words": words,
+        "status_text": f"✅ Transcript ready — {dur//1000}s",
+        "notes": "stub",
+        "quality_tier": tier,
+    }
+
+
+async def _worker_run(job_id: str):
+    job = jobs.get(job_id)
+    if not job:
+        return
+    job["status"] = "processing"
+    req: TranscribeRequest = job["req"]
+    session_id = req.session_id or _pick_single_session_id()
+    if not session_id:
+        job["status"] = "error"
+        job["error"] = "no session available"
+        return
+    buf = sessions.get(session_id)
+    if not buf:
+        job["status"] = "error"
+        job["error"] = "session buffer missing"
+        return
+
+    # Determine range
+    if req.start_ms is None or req.end_ms is None:
+        w = buf.window()
+        tail = w["tail_ms"]
+        off = int(req.offset_ms or 30000)
+        start_ms = max(w["head_ms"], tail - off)
+        end_ms = tail
+    else:
+        start_ms = int(req.start_ms)
+        end_ms = int(req.end_ms)
+
+    # Simulate progress
+    await manager.send_json(session_id, {"type": "transcribe.accepted", "slice_id": req.slice_id, "queue_pos": 0})
+    await asyncio.sleep(0.1)
+    await manager.send_json(session_id, {"type": "transcribe.progress", "slice_id": req.slice_id, "pct": 30})
+    await asyncio.sleep(0.1)
+    await manager.send_json(session_id, {"type": "transcribe.progress", "slice_id": req.slice_id, "pct": 70})
+
+    # Build stub result (replace with actual ASR integration)
+    result = _make_stub_result(session_id, req.slice_id, start_ms, end_ms, req.requested_tier)
+    job["result"] = result
+    job["status"] = "done"
+
+    await manager.send_json(session_id, {"type": "transcribe.result", **result})
+
+
+def _pick_single_session_id() -> Optional[str]:
+    if len(sessions) == 1:
+        return next(iter(sessions.keys()))
+    return None
+
+
+@app.post("/transcribe_slice")
+async def transcribe_slice(req: TranscribeRequest = Body(...)):
+    # Fill default session if not provided and only one exists
+    if not req.session_id:
+        sid = _pick_single_session_id()
+        if sid:
+            req.session_id = sid
+
+    job_id = str(uuid.uuid4())
+    jobs[job_id] = {"status": "queued", "req": req}
+    asyncio.create_task(_worker_run(job_id))
+    return {"job_id": job_id, "eta_ms": 1500}
+
+
+@app.get("/job/{job_id}")
+async def get_job(job_id: str):
+    job = jobs.get(job_id)
+    if not job:
+        return {"status": "not_found"}
+    resp = {"status": job.get("status")}
+    if job.get("status") == "done":
+        resp["result"] = job.get("result")
+    if job.get("status") == "error":
+        resp["error"] = job.get("error")
+    return resp