feat: Add conversation verification feature with UI and backend support

- Implemented a new verification section in the Gradio interface to allow users to verify conversation exchanges.
- Created core models and manager for handling verification sessions, including feedback and progress tracking.
- Developed a CSV exporter for verification results, enabling users to export session data.
- Built a comprehensive Gradio UI for reviewing and verifying AI classifier decisions, including navigation and statistics display.
- Added functionality to mark exchanges as correct or incorrect, with options for providing feedback and reasons for corrections.
- Ensured session data is saved and loaded correctly, maintaining state across user interactions.

.gitignore

@@ -65,6 +65,8 @@ flagged/
 # Hypothesis testing
 .hypothesis/
 .verification_data/
+verification_sessions/
+verification_exports/
 
 # Logs
 *.log

src/core/conversation_verification.py

@@ -0,0 +1,292 @@
+#!/usr/bin/env python3
+"""
+Conversation Verification System - Core Models and Manager.
+
+Provides data models and management functionality for verifying AI classifier
+decisions made during patient conversations.
+"""
+
+import json
+import os
+import uuid
+from datetime import datetime
+from typing import Dict, List, Any, Optional, Tuple
+from dataclasses import dataclass, asdict, field
+
+from src.core.conversation_logger import ConversationLogger, ConversationEntry
+
+
+@dataclass
+class VerificationFeedback:
+    """Feedback provided by verifier for a conversation exchange."""
+    exchange_id: str
+    is_correct: bool
+    correct_classification: Optional[str] = None  # Required if is_correct=False
+    correction_reason: Optional[str] = None
+    notes: Optional[str] = None
+
+
+@dataclass
+class VerificationRecord:
+    """Complete verification record for a single conversation exchange."""
+    exchange_id: str
+    exchange_number: int
+    timestamp: datetime
+    user_message: str
+    assistant_response: str
+    original_classification: str  # GREEN/YELLOW/RED
+    original_confidence: float
+    original_indicators: List[str]
+    original_reasoning: str
+    is_correct: Optional[bool] = None
+    correct_classification: Optional[str] = None
+    correction_reason: Optional[str] = None
+    verifier_notes: Optional[str] = None
+    verification_timestamp: Optional[datetime] = None
+
+    @classmethod
+    def from_conversation_entry(cls, entry: ConversationEntry, exchange_number: int) -> 'VerificationRecord':
+        """Create VerificationRecord from ConversationEntry."""
+        return cls(
+            exchange_id=f"{entry.session_id}_{entry.message_index}",
+            exchange_number=exchange_number,
+            timestamp=datetime.fromisoformat(entry.timestamp),
+            user_message=entry.user_message,
+            assistant_response=entry.assistant_response,
+            original_classification=entry.spiritual_classification,
+            original_confidence=entry.classification_confidence,
+            original_indicators=entry.classification_indicators.copy(),
+            original_reasoning=entry.classification_reasoning
+        )
+
+    def apply_feedback(self, feedback: VerificationFeedback) -> None:
+        """Apply verification feedback to this record."""
+        self.is_correct = feedback.is_correct
+        self.correct_classification = feedback.correct_classification
+        self.correction_reason = feedback.correction_reason
+        self.verifier_notes = feedback.notes
+        self.verification_timestamp = datetime.now()
+
+
+@dataclass
+class VerificationProgress:
+    """Progress tracking for verification session."""
+    total_exchanges: int
+    verified_exchanges: int
+    accuracy_overall: float = 0.0
+    accuracy_by_type: Dict[str, float] = field(default_factory=dict)
+    common_errors: List[Tuple[str, str, int]] = field(default_factory=list)
+
+    def calculate_progress_percentage(self) -> float:
+        """Calculate verification progress as percentage."""
+        if self.total_exchanges == 0:
+            return 0.0
+        return (self.verified_exchanges / self.total_exchanges) * 100
+
+    def is_complete(self) -> bool:
+        """Check if verification is complete."""
+        return self.verified_exchanges == self.total_exchanges
+
+
+@dataclass
+class VerificationSession:
+    """Complete verification session for a conversation."""
+    session_id: str
+    conversation_session_id: str  # Links to ConversationLogger session
+    patient_name: str
+    verifier_name: str
+    start_time: datetime
+    end_time: Optional[datetime] = None
+    total_exchanges: int = 0
+    verified_exchanges: int = 0
+    verification_records: List[VerificationRecord] = field(default_factory=list)
+    is_complete: bool = False
+
+    def get_progress(self) -> VerificationProgress:
+        """Get current verification progress."""
+        # Calculate overall accuracy
+        verified_records = [r for r in self.verification_records if r.is_correct is not None]
+        correct_count = sum(1 for r in verified_records if r.is_correct)
+        accuracy_overall = (correct_count / len(verified_records)) if verified_records else 0.0
+
+        # Calculate accuracy by classification type
+        accuracy_by_type = {}
+        for classification in ['GREEN', 'YELLOW', 'RED']:
+            type_records = [r for r in verified_records if r.original_classification == classification]
+            if type_records:
+                type_correct = sum(1 for r in type_records if r.is_correct)
+                accuracy_by_type[classification] = type_correct / len(type_records)
+            else:
+                accuracy_by_type[classification] = 0.0
+
+        # Find common errors
+        error_patterns = {}
+        for record in verified_records:
+            if not record.is_correct and record.correct_classification:
+                error_key = (record.original_classification, record.correct_classification)
+                error_patterns[error_key] = error_patterns.get(error_key, 0) + 1
+
+        common_errors = [(from_class, to_class, count) 
+                        for (from_class, to_class), count in 
+                        sorted(error_patterns.items(), key=lambda x: x[1], reverse=True)[:5]]
+
+        return VerificationProgress(
+            total_exchanges=self.total_exchanges,
+            verified_exchanges=len(verified_records),
+            accuracy_overall=accuracy_overall,
+            accuracy_by_type=accuracy_by_type,
+            common_errors=common_errors
+        )
+
+    def add_verification_record(self, record: VerificationRecord) -> None:
+        """Add verification record to session."""
+        self.verification_records.append(record)
+
+    def apply_feedback(self, exchange_id: str, feedback: VerificationFeedback) -> bool:
+        """Apply feedback to specific exchange."""
+        for record in self.verification_records:
+            if record.exchange_id == exchange_id:
+                record.apply_feedback(feedback)
+                self.verified_exchanges = len([r for r in self.verification_records if r.is_correct is not None])
+                
+                # Check if session is complete
+                if self.verified_exchanges == self.total_exchanges:
+                    self.is_complete = True
+                    self.end_time = datetime.now()
+                
+                return True
+        return False
+
+    def get_unverified_records(self) -> List[VerificationRecord]:
+        """Get list of unverified records."""
+        return [r for r in self.verification_records if r.is_correct is None]
+
+    def get_next_unverified_record(self) -> Optional[VerificationRecord]:
+        """Get next unverified record."""
+        unverified = self.get_unverified_records()
+        return unverified[0] if unverified else None
+
+
+class ConversationVerificationManager:
+    """Manager for conversation verification sessions."""
+
+    def __init__(self, storage_dir: str = "verification_sessions"):
+        """Initialize verification manager."""
+        from src.core.verification_store import JSONVerificationStore
+        self.store = JSONVerificationStore(storage_dir)
+
+    def create_verification_session(
+        self, 
+        conversation_logger: ConversationLogger,
+        verifier_name: str = "Medical Professional"
+    ) -> VerificationSession:
+        """
+        Create new verification session from conversation logger.
+        
+        Args:
+            conversation_logger: Source conversation to verify
+            verifier_name: Name of person doing verification
+            
+        Returns:
+            New VerificationSession ready for verification
+        """
+        session_id = f"verification_{datetime.now().strftime('%Y%m%d_%H%M%S')}_{str(uuid.uuid4())[:8]}"
+        
+        # Create verification session
+        session = VerificationSession(
+            session_id=session_id,
+            conversation_session_id=conversation_logger.session_id,
+            patient_name=conversation_logger.patient_name,
+            verifier_name=verifier_name,
+            start_time=datetime.now(),
+            total_exchanges=len(conversation_logger.entries)
+        )
+
+        # Convert conversation entries to verification records
+        for i, entry in enumerate(conversation_logger.entries, 1):
+            record = VerificationRecord.from_conversation_entry(entry, i)
+            session.add_verification_record(record)
+
+        # Save initial session
+        self.store.save_session(session)
+        
+        return session
+
+    def get_verification_progress(self, session_id: str) -> Optional[VerificationProgress]:
+        """Get verification progress for session."""
+        session = self.store.load_session(session_id)
+        return session.get_progress() if session else None
+
+    def submit_exchange_verification(
+        self, 
+        session_id: str, 
+        exchange_id: str, 
+        feedback: VerificationFeedback
+    ) -> bool:
+        """
+        Submit verification feedback for an exchange.
+        
+        Args:
+            session_id: Verification session ID
+            exchange_id: Exchange being verified
+            feedback: Verification feedback
+            
+        Returns:
+            True if feedback was applied successfully
+        """
+        session = self.store.load_session(session_id)
+        if not session:
+            return False
+
+        # Validate feedback
+        if not feedback.is_correct and not feedback.correct_classification:
+            raise ValueError("correct_classification required when is_correct=False")
+
+        if (not feedback.is_correct and 
+            feedback.correct_classification and 
+            feedback.correct_classification not in ['GREEN', 'YELLOW', 'RED']):
+            raise ValueError("correct_classification must be GREEN, YELLOW, or RED")
+
+        # Apply feedback
+        success = session.apply_feedback(exchange_id, feedback)
+        if success:
+            self.store.save_session(session)
+        
+        return success
+
+    def get_session_statistics(self, session_id: str) -> Optional[Dict[str, Any]]:
+        """Get detailed statistics for verification session."""
+        session = self.store.load_session(session_id)
+        if not session:
+            return None
+
+        progress = session.get_progress()
+        
+        return {
+            "session_id": session.session_id,
+            "patient_name": session.patient_name,
+            "verifier_name": session.verifier_name,
+            "start_time": session.start_time.isoformat(),
+            "end_time": session.end_time.isoformat() if session.end_time else None,
+            "is_complete": session.is_complete,
+            "progress": asdict(progress),
+            "total_exchanges": session.total_exchanges,
+            "verified_exchanges": session.verified_exchanges
+        }
+
+    def load_session(self, session_id: str) -> Optional[VerificationSession]:
+        """Load verification session by ID."""
+        return self.store.load_session(session_id)
+
+    def save_session(self, session: VerificationSession) -> None:
+        """Save verification session."""
+        self.store.save_session(session)
+
+    def list_sessions(self) -> List[Dict[str, Any]]:
+        """List all verification sessions."""
+        return self.store.list_sessions()
+
+    def get_incomplete_sessions(self) -> List[Dict[str, Any]]:
+        """Get incomplete verification sessions."""
+        return self.store.get_incomplete_sessions()
+

src/core/verification_exporter.py

@@ -0,0 +1,152 @@
+#!/usr/bin/env python3
+"""
+Verification Results Exporter.
+
+Handles exporting verification session results to CSV format.
+"""
+
+import csv
+import os
+from datetime import datetime
+from typing import List, Dict, Any
+from src.core.conversation_verification import VerificationSession, VerificationRecord
+
+
+class VerificationExporter:
+    """Exporter for verification session results."""
+
+    def __init__(self, export_dir: str = "verification_exports"):
+        """Initialize exporter."""
+        self.export_dir = export_dir
+        os.makedirs(export_dir, exist_ok=True)
+
+    def export_session_to_csv(self, session: VerificationSession) -> str:
+        """
+        Export verification session to CSV format.
+        
+        Args:
+            session: VerificationSession to export
+            
+        Returns:
+            Path to exported CSV file
+        """
+        filename = self._create_export_filename(session)
+        filepath = os.path.join(self.export_dir, filename)
+        
+        try:
+            with open(filepath, 'w', newline='', encoding='utf-8') as csvfile:
+                fieldnames = [
+                    'exchange_number',
+                    'timestamp', 
+                    'user_message',
+                    'assistant_response',
+                    'classifier_decision',
+                    'classifier_confidence',
+                    'indicators',
+                    'reasoning',
+                    'is_correct',
+                    'correct_classification',
+                    'correction_reason',
+                    'verifier_notes',
+                    'verification_timestamp'
+                ]
+                
+                writer = csv.DictWriter(csvfile, fieldnames=fieldnames)
+                writer.writeheader()
+                
+                # Write session metadata as comment rows
+                writer.writerow({
+                    'exchange_number': '# SESSION METADATA',
+                    'timestamp': f'Session ID: {session.session_id}',
+                    'user_message': f'Patient: {session.patient_name}',
+                    'assistant_response': f'Verifier: {session.verifier_name}',
+                    'classifier_decision': f'Started: {session.start_time.isoformat()}',
+                    'classifier_confidence': f'Completed: {session.end_time.isoformat() if session.end_time else "In Progress"}',
+                    'indicators': f'Total Exchanges: {session.total_exchanges}',
+                    'reasoning': f'Verified: {session.verified_exchanges}',
+                    'is_correct': f'Complete: {session.is_complete}',
+                    'correct_classification': '',
+                    'correction_reason': '',
+                    'verifier_notes': '',
+                    'verification_timestamp': ''
+                })
+                
+                # Add empty row for separation
+                writer.writerow({field: '' for field in fieldnames})
+                
+                # Write verification records
+                for record in session.verification_records:
+                    writer.writerow({
+                        'exchange_number': record.exchange_number,
+                        'timestamp': record.timestamp.isoformat(),
+                        'user_message': record.user_message,
+                        'assistant_response': record.assistant_response,
+                        'classifier_decision': record.original_classification,
+                        'classifier_confidence': record.original_confidence,
+                        'indicators': '; '.join(record.original_indicators),
+                        'reasoning': record.original_reasoning,
+                        'is_correct': record.is_correct,
+                        'correct_classification': record.correct_classification or '',
+                        'correction_reason': record.correction_reason or '',
+                        'verifier_notes': record.verifier_notes or '',
+                        'verification_timestamp': record.verification_timestamp.isoformat() if record.verification_timestamp else ''
+                    })
+            
+            return filepath
+            
+        except Exception as e:
+            raise Exception(f"Failed to export CSV: {str(e)}")
+
+    def _create_export_filename(self, session: VerificationSession) -> str:
+        """Create descriptive filename for export."""
+        timestamp = datetime.now().strftime('%Y%m%d_%H%M%S')
+        patient_safe = session.patient_name.replace(' ', '_').replace('/', '_')
+        return f"conversation_verification_{patient_safe}_{timestamp}.csv"
+
+    def generate_summary_report(self, session: VerificationSession) -> Dict[str, Any]:
+        """Generate summary report for verification session."""
+        progress = session.get_progress()
+        
+        # Calculate detailed statistics
+        verified_records = [r for r in session.verification_records if r.is_correct is not None]
+        correct_records = [r for r in verified_records if r.is_correct]
+        incorrect_records = [r for r in verified_records if not r.is_correct]
+        
+        # Error analysis
+        error_patterns = {}
+        for record in incorrect_records:
+            if record.correct_classification:
+                error_key = f"{record.original_classification} → {record.correct_classification}"
+                error_patterns[error_key] = error_patterns.get(error_key, 0) + 1
+        
+        # Confidence analysis
+        confidence_stats = {
+            'avg_confidence': sum(r.original_confidence for r in verified_records) / len(verified_records) if verified_records else 0,
+            'correct_avg_confidence': sum(r.original_confidence for r in correct_records) / len(correct_records) if correct_records else 0,
+            'incorrect_avg_confidence': sum(r.original_confidence for r in incorrect_records) / len(incorrect_records) if incorrect_records else 0
+        }
+        
+        return {
+            'session_info': {
+                'session_id': session.session_id,
+                'patient_name': session.patient_name,
+                'verifier_name': session.verifier_name,
+                'start_time': session.start_time.isoformat(),
+                'end_time': session.end_time.isoformat() if session.end_time else None,
+                'duration_minutes': (session.end_time - session.start_time).total_seconds() / 60 if session.end_time else None
+            },
+            'verification_stats': {
+                'total_exchanges': session.total_exchanges,
+                'verified_exchanges': len(verified_records),
+                'completion_rate': len(verified_records) / session.total_exchanges if session.total_exchanges > 0 else 0,
+                'overall_accuracy': progress.accuracy_overall,
+                'accuracy_by_type': progress.accuracy_by_type
+            },
+            'error_analysis': {
+                'total_errors': len(incorrect_records),
+                'error_rate': len(incorrect_records) / len(verified_records) if verified_records else 0,
+                'error_patterns': error_patterns,
+                'common_errors': progress.common_errors
+            },
+            'confidence_analysis': confidence_stats
+        }

src/core/verification_store.py

@@ -1,1249 +1,350 @@
-# verification_store.py
+#!/usr/bin/env python3
 """
-Verification data storage layer.
+Verification Session Storage and Persistence.
 
-Provides interface and JSON-based implementation for persisting verification data.
-Enhanced to support multi-mode verification sessions with comprehensive export capabilities.
+Handles saving, loading, and managing verification sessions with recovery capabilities.
 """
 
 import json
 import os
-import csv
-import io
-import logging
-from abc import ABC, abstractmethod
-from typing import Dict, List, Optional, Any, Union, Tuple
+import glob
 from datetime import datetime
-from pathlib import Path
+from typing import List, Optional, Dict, Any
+from dataclasses import asdict
 
-from src.core.verification_models import (
-    VerificationSession,
-    VerificationRecord,
-    TestDataset,
-    TestMessage,
-    EnhancedVerificationSession,
-    TestCaseEdit,
-    FileUploadResult,
-)
-from src.core.enhanced_error_handler import EnhancedErrorHandler, ErrorCategory
-from src.core.error_handling_utils import ErrorHandlingDecorator
-from src.core.data_validation_service import DataValidationService, IntegrityChecksum
+from src.core.conversation_verification import VerificationSession, VerificationRecord
 
 
-class VerificationDataStore(ABC):
-    """Abstract interface for verification data storage."""
+class JSONVerificationStore:
+    """JSON-based storage for verification sessions."""
 
-    @abstractmethod
-    def save_session(self, session: Union[VerificationSession, EnhancedVerificationSession]) -> str:
-        """Save a verification session. Returns session_id."""
-        pass
+    def __init__(self, storage_dir: str = "verification_sessions"):
+        """Initialize verification store."""
+        self.storage_dir = storage_dir
+        os.makedirs(storage_dir, exist_ok=True)
 
-    @abstractmethod
-    def load_session(self, session_id: str) -> Optional[Union[VerificationSession, EnhancedVerificationSession]]:
-        """Load a verification session by ID."""
-        pass
-
-    @abstractmethod
-    def save_verification(
-        self, session_id: str, record: VerificationRecord
-    ) -> None:
-        """Save a verification record to a session."""
-        pass
-
-    @abstractmethod
-    def get_session_statistics(self, session_id: str) -> Dict[str, Any]:
-        """Get statistics for a session."""
-        pass
-
-    @abstractmethod
-    def export_to_csv(self, session_id: str) -> str:
-        """Export session to CSV format. Returns CSV content."""
-        pass
-
-    @abstractmethod
-    def list_sessions(self) -> List[str]:
-        """List all session IDs."""
-        pass
-
-    @abstractmethod
-    def delete_session(self, session_id: str) -> bool:
-        """Delete a session. Returns True if successful."""
-        pass
-
-    @abstractmethod
-    def get_last_session(self) -> Optional[Union[VerificationSession, EnhancedVerificationSession]]:
-        """Get the most recently created session. Returns None if no sessions exist."""
-        pass
-
-    @abstractmethod
-    def mark_session_complete(self, session_id: str) -> None:
-        """Mark a session as complete and prevent further modifications."""
-        pass
-
-    @abstractmethod
-    def can_modify_session(self, session_id: str) -> bool:
-        """Check if a session can be modified. Returns False if session is complete."""
-        pass
-
-    # Enhanced methods for multi-mode support
-    @abstractmethod
-    def list_sessions_by_mode(self, mode_type: str) -> List[str]:
-        """List session IDs filtered by mode type."""
-        pass
-
-    @abstractmethod
-    def get_incomplete_sessions(self) -> List[Union[VerificationSession, EnhancedVerificationSession]]:
-        """Get all incomplete sessions across all modes."""
-        pass
-
-    @abstractmethod
-    def update_mode_metadata(self, session_id: str, metadata: Dict[str, Any]) -> None:
-        """Update mode-specific metadata for a session."""
-        pass
-
-    @abstractmethod
-    def export_to_xlsx(self, session_id: str) -> bytes:
-        """Export session to XLSX format. Returns XLSX content as bytes."""
-        pass
-
-    @abstractmethod
-    def export_to_json(self, session_id: str) -> str:
-        """Export session to JSON format. Returns JSON content."""
-        pass
-
-    @abstractmethod
-    def export_multiple_sessions(self, session_ids: List[str], format_type: str) -> Union[str, bytes]:
-        """Export multiple sessions in specified format (csv, xlsx, json)."""
-        pass
-
-
-class JSONVerificationStore(VerificationDataStore):
-    """JSON-based implementation of verification data storage with enhanced multi-mode support and comprehensive error handling."""
-
-    def __init__(self, storage_dir: str = ".verification_data"):
-        """Initialize JSON store with storage directory and error handling."""
-        self.storage_dir = Path(storage_dir)
-        self.storage_dir.mkdir(exist_ok=True)
-        self.sessions_dir = self.storage_dir / "sessions"
-        self.sessions_dir.mkdir(exist_ok=True)
-        self.edits_dir = self.storage_dir / "edits"
-        self.edits_dir.mkdir(exist_ok=True)
-        self.datasets_dir = self.storage_dir / "datasets"
-        self.datasets_dir.mkdir(exist_ok=True)
-        self.backups_dir = self.storage_dir / "backups"
-        self.backups_dir.mkdir(exist_ok=True)
-        
-        # Initialize error handling (lazy initialization to avoid deepcopy issues)
-        self._error_handler = None
-        self._error_decorator = None
-        self._storage_dir_str = storage_dir
-        
-        # Initialize data validation service
-        self.validation_service = DataValidationService()
-
-    def _get_session_path(self, session_id: str) -> Path:
-        """Get file path for a session."""
-        return self.sessions_dir / f"{session_id}.json"
-        
-    @property
-    def error_handler(self) -> EnhancedErrorHandler:
-        """Lazy initialization of error handler to avoid deepcopy issues."""
-        if self._error_handler is None:
-            self._error_handler = EnhancedErrorHandler(self._storage_dir_str)
-        return self._error_handler
+    def save_session(self, session: VerificationSession) -> bool:
+        """
+        Save verification session to storage.
         
-    @property
-    def error_decorator(self) -> ErrorHandlingDecorator:
-        """Lazy initialization of error decorator to avoid deepcopy issues."""
-        if self._error_decorator is None:
-            self._error_decorator = ErrorHandlingDecorator(self.error_handler)
-        return self._error_decorator
-
-    def save_session(self, session: Union[VerificationSession, EnhancedVerificationSession]) -> str:
-        """Save a verification session to JSON file with automatic backup creation."""
-        try:
-            session_path = self._get_session_path(session.session_id)
-            session_data = session.to_dict()
+        Args:
+            session: VerificationSession to save
             
-            # Create backup before saving (if session already exists)
-            if session_path.exists():
-                try:
-                    with open(session_path, "r") as f:
-                        existing_data = json.load(f)
-                    self.error_handler.recovery_manager.create_backup(session.session_id, existing_data)
-                except Exception as e:
-                    # Log backup failure but don't fail the save
-                    logging.warning(f"Failed to create backup for session {session.session_id}: {e}")
+        Returns:
+            True if saved successfully, False otherwise
+        """
+        try:
+            filename = f"{session.session_id}.json"
+            filepath = os.path.join(self.storage_dir, filename)
+            
+            # Convert to dict for JSON serialization
+            session_dict = asdict(session)
+            
+            # Convert datetime objects to ISO strings
+            session_dict['start_time'] = session.start_time.isoformat()
+            if session.end_time:
+                session_dict['end_time'] = session.end_time.isoformat()
+            
+            for record in session_dict['verification_records']:
+                if isinstance(record['timestamp'], datetime):
+                    record['timestamp'] = record['timestamp'].isoformat()
+                if record['verification_timestamp'] and isinstance(record['verification_timestamp'], datetime):
+                    record['verification_timestamp'] = record['verification_timestamp'].isoformat()
+
+            # Add metadata for recovery
+            session_dict['_metadata'] = {
+                'saved_at': datetime.now().isoformat(),
+                'version': '1.0',
+                'storage_format': 'json'
+            }
+
+            with open(filepath, 'w', encoding='utf-8') as f:
+                json.dump(session_dict, f, ensure_ascii=False, indent=2)
             
-            # Save the session
-            with open(session_path, "w") as f:
-                json.dump(session_data, f, indent=2)
-                
-            return session.session_id
+            return True
             
-        except OSError as e:
-            if "No space left" in str(e):
-                error_context = self.error_handler.handle_export_generation_error(
-                    "session", session.session_id, "Insufficient disk space to save session"
-                )
-            else:
-                error_context = self.error_handler.handle_session_corruption_error(
-                    session.session_id, "corrupted_session", f"File system error: {str(e)}"
-                )
-            raise RuntimeError(error_context.user_message) from e
         except Exception as e:
-            error_context = self.error_handler.handle_session_corruption_error(
-                session.session_id, "corrupted_session", f"Unexpected error saving session: {str(e)}"
-            )
-            raise RuntimeError(error_context.user_message) from e
+            print(f"Error saving verification session {session.session_id}: {e}")
+            return False
 
-    def load_session(self, session_id: str) -> Optional[Union[VerificationSession, EnhancedVerificationSession]]:
-        """Load a verification session from JSON file with corruption recovery."""
-        session_path = self._get_session_path(session_id)
-        if not session_path.exists():
-            return None
+    def load_session(self, session_id: str) -> Optional[VerificationSession]:
+        """
+        Load verification session from storage.
         
+        Args:
+            session_id: ID of session to load
+            
+        Returns:
+            VerificationSession if found and valid, None otherwise
+        """
+        filename = f"{session_id}.json"
+        filepath = os.path.join(self.storage_dir, filename)
+        
+        if not os.path.exists(filepath):
+            return None
+
         try:
-            with open(session_path, "r") as f:
-                data = json.load(f)
+            with open(filepath, 'r', encoding='utf-8') as f:
+                session_dict = json.load(f)
             
-            # Validate session data integrity
-            is_valid, validation_errors = self.error_handler.recovery_manager.validate_session_data(data)
-            if not is_valid:
-                # Attempt to recover from backup
-                backups = self.error_handler.recovery_manager.list_backups(session_id)
-                if backups:
-                    # Try the most recent backup
-                    backup_data = self.error_handler.recovery_manager.restore_from_backup(backups[0]["backup_id"])
-                    if backup_data:
-                        data = backup_data
-                        # Log the recovery
-                        logging.warning(f"Session {session_id} recovered from backup due to corruption: {validation_errors}")
-                    else:
-                        # Handle corruption error
-                        error_context = self.error_handler.handle_session_corruption_error(
-                            session_id, "corrupted_session", f"Validation errors: {validation_errors}"
-                        )
-                        raise ValueError(error_context.user_message)
-                else:
-                    # No backups available
-                    error_context = self.error_handler.handle_session_corruption_error(
-                        session_id, "corrupted_session", f"No backups available. Validation errors: {validation_errors}"
-                    )
-                    raise ValueError(error_context.user_message)
+            # Remove metadata if present
+            session_dict.pop('_metadata', None)
             
-            # Determine if this is an enhanced session based on presence of mode_type
-            if "mode_type" in data:
-                return EnhancedVerificationSession.from_dict(data)
+            # Convert ISO strings back to datetime objects
+            session_dict['start_time'] = datetime.fromisoformat(session_dict['start_time'])
+            if session_dict.get('end_time'):
+                session_dict['end_time'] = datetime.fromisoformat(session_dict['end_time'])
             else:
-                return VerificationSession.from_dict(data)
+                session_dict['end_time'] = None
+            
+            # Convert verification records
+            verification_records = []
+            for record_dict in session_dict['verification_records']:
+                record_dict['timestamp'] = datetime.fromisoformat(record_dict['timestamp'])
+                if record_dict.get('verification_timestamp'):
+                    record_dict['verification_timestamp'] = datetime.fromisoformat(record_dict['verification_timestamp'])
+                else:
+                    record_dict['verification_timestamp'] = None
                 
-        except json.JSONDecodeError as e:
-            # Handle JSON corruption
-            error_context = self.error_handler.handle_session_corruption_error(
-                session_id, "corrupted_session", f"JSON decode error: {str(e)}"
-            )
+                verification_records.append(VerificationRecord(**record_dict))
+            
+            session_dict['verification_records'] = verification_records
             
-            # Try to recover from backup
-            backups = self.error_handler.recovery_manager.list_backups(session_id)
-            if backups:
-                backup_data = self.error_handler.recovery_manager.restore_from_backup(backups[0]["backup_id"])
-                if backup_data:
-                    logging.warning(f"Session {session_id} recovered from backup due to JSON corruption")
-                    if "mode_type" in backup_data:
-                        return EnhancedVerificationSession.from_dict(backup_data)
-                    else:
-                        return VerificationSession.from_dict(backup_data)
+            return VerificationSession(**session_dict)
             
-            raise ValueError(error_context.user_message) from e
         except Exception as e:
-            error_context = self.error_handler.handle_session_corruption_error(
-                session_id, "corrupted_session", f"Unexpected error loading session: {str(e)}"
-            )
-            raise ValueError(error_context.user_message) from e
-
-    def save_verification(
-        self, session_id: str, record: VerificationRecord
-    ) -> None:
-        """Save a verification record to a session with validation."""
-        # Validate the verification record before saving
-        validation_result = self.validation_service.validate_verification_record(record)
-        if not validation_result.is_valid:
-            raise ValueError(f"Verification record validation failed: {'; '.join(validation_result.errors)}")
-        
-        session = self.load_session(session_id)
-        if session is None:
-            raise ValueError(f"Session {session_id} not found")
-        
-        # Prevent modifications to completed sessions
-        if session.is_complete:
-            raise ValueError(f"Cannot modify completed session {session_id}")
-        
-        # Check if record already exists and update it
-        existing_idx = None
-        for idx, v in enumerate(session.verifications):
-            if v.message_id == record.message_id:
-                existing_idx = idx
-                break
-        
-        if existing_idx is not None:
-            session.verifications[existing_idx] = record
-        else:
-            session.verifications.append(record)
-        
-        # Update counts
-        session.verified_count = len(session.verifications)
-        session.correct_count = sum(1 for v in session.verifications if v.is_correct)
-        session.incorrect_count = session.verified_count - session.correct_count
-        
-        # Verify accuracy calculations before saving
-        accuracy_validation = self.validation_service.verify_accuracy_calculations(session)
-        if not accuracy_validation.is_valid:
-            logging.warning(f"Accuracy calculation issues in session {session_id}: {'; '.join(accuracy_validation.errors)}")
-        
-        self.save_session(session)
+            print(f"Error loading verification session {session_id}: {e}")
+            return None
 
-    def get_session_statistics(self, session_id: str) -> Dict[str, Any]:
-        """Get statistics for a session."""
-        session = self.load_session(session_id)
-        if session is None:
-            raise ValueError(f"Session {session_id} not found")
-        
-        stats = {
-            "session_id": session.session_id,
-            "verifier_name": session.verifier_name,
-            "dataset_name": session.dataset_name,
-            "total_messages": session.total_messages,
-            "verified_count": session.verified_count,
-            "correct_count": session.correct_count,
-            "incorrect_count": session.incorrect_count,
-            "is_complete": session.is_complete,
-        }
-        
-        # Calculate accuracy
-        if session.verified_count > 0:
-            stats["accuracy"] = (
-                session.correct_count / session.verified_count * 100
-            )
-        else:
-            stats["accuracy"] = 0.0
-        
-        # Calculate accuracy by type
-        accuracy_by_type = {}
-        for classification_type in ["green", "yellow", "red"]:
-            type_records = [
-                v for v in session.verifications
-                if v.classifier_decision == classification_type
-            ]
-            if type_records:
-                correct = sum(1 for v in type_records if v.is_correct)
-                accuracy_by_type[classification_type] = (
-                    correct / len(type_records) * 100
-                )
-            else:
-                accuracy_by_type[classification_type] = 0.0
+    def list_sessions(self) -> List[Dict[str, Any]]:
+        """
+        List all verification sessions with basic info.
         
-        stats["accuracy_by_type"] = accuracy_by_type
+        Returns:
+            List of session info dictionaries
+        """
+        sessions = []
         
-        return stats
-
-    def export_to_csv(self, session_id: str) -> str:
-        """Export session to CSV format with comprehensive error handling."""
         try:
-            session = self.load_session(session_id)
-            if session is None:
-                error_context = self.error_handler.handle_export_generation_error(
-                    "csv", session_id, f"Session {session_id} not found"
-                )
-                raise ValueError(error_context.user_message)
-            
-            if session.verified_count == 0:
-                error_context = self.error_handler.handle_export_generation_error(
-                    "csv", session_id, "No verified messages to export"
-                )
-                raise ValueError(error_context.user_message)
-        
-            output = io.StringIO()
-        
-            # Add summary section
-            accuracy = (
-                session.correct_count / session.verified_count * 100
-                if session.verified_count > 0
-                else 0.0
-            )
-            output.write("VERIFICATION SUMMARY\n")
-            output.write(f"Total Messages,{session.verified_count}\n")
-            output.write(f"Correct,{session.correct_count}\n")
-            output.write(f"Incorrect,{session.incorrect_count}\n")
-            output.write(f"Accuracy %,{accuracy:.1f}\n")
-        
-            # Add enhanced session info if available
-            if isinstance(session, EnhancedVerificationSession):
-                output.write(f"Mode Type,{session.mode_type}\n")
-                if session.file_source:
-                    output.write(f"File Source,{session.file_source}\n")
-                if session.dataset_version:
-                    output.write(f"Dataset Version,{session.dataset_version}\n")
-                if session.manual_input_count > 0:
-                    output.write(f"Manual Input Count,{session.manual_input_count}\n")
-            
-            output.write("\n")
-            
-            # Use CSV writer for proper escaping
-            writer = csv.writer(output)
-            
-            # Add header row
-            headers = ["Patient Message", "Classifier Said", "You Said", "Notes", "Date"]
-            if isinstance(session, EnhancedVerificationSession):
-                headers.extend(["Mode Type", "Confidence", "Indicators"])
-            
-            writer.writerow(headers)
-            
-            # Add data rows
-            for record in session.verifications:
-                row = [
-                    record.original_message,
-                    record.classifier_decision.upper(),
-                    record.ground_truth_label.upper(),
-                    record.verifier_notes,
-                    record.timestamp.strftime("%Y-%m-%d %H:%M:%S"),
-                ]
-                
-                if isinstance(session, EnhancedVerificationSession):
-                    row.extend([
-                        session.mode_type,
-                        record.classifier_confidence,
-                        "; ".join(record.classifier_indicators),
-                    ])
-                
-                writer.writerow(row)
+            pattern = os.path.join(self.storage_dir, "verification_*.json")
+            for filepath in glob.glob(pattern):
+                try:
+                    with open(filepath, 'r', encoding='utf-8') as f:
+                        session_dict = json.load(f)
+                    
+                    # Extract basic info without loading full session
+                    session_info = {
+                        'session_id': session_dict['session_id'],
+                        'patient_name': session_dict['patient_name'],
+                        'verifier_name': session_dict['verifier_name'],
+                        'start_time': session_dict['start_time'],
+                        'end_time': session_dict.get('end_time'),
+                        'is_complete': session_dict['is_complete'],
+                        'total_exchanges': session_dict['total_exchanges'],
+                        'verified_exchanges': session_dict['verified_exchanges'],
+                        'file_path': filepath
+                    }
+                    sessions.append(session_info)
+                    
+                except Exception as e:
+                    print(f"Error reading session file {filepath}: {e}")
+                    continue
         
-            return output.getvalue()
-            
-        except MemoryError as e:
-            error_context = self.error_handler.handle_export_generation_error(
-                "csv", session_id, f"Insufficient memory for CSV export: {str(e)}"
-            )
-            raise RuntimeError(error_context.user_message) from e
-        except OSError as e:
-            if "No space left" in str(e):
-                error_context = self.error_handler.handle_export_generation_error(
-                    "csv", session_id, "Insufficient disk space for export"
-                )
-            else:
-                error_context = self.error_handler.handle_export_generation_error(
-                    "csv", session_id, f"File system error: {str(e)}"
-                )
-            raise RuntimeError(error_context.user_message) from e
         except Exception as e:
-            error_context = self.error_handler.handle_export_generation_error(
-                "csv", session_id, f"Unexpected error during CSV export: {str(e)}"
-            )
-            raise RuntimeError(error_context.user_message) from e
-
-    def list_sessions(self) -> List[str]:
-        """List all session IDs."""
-        session_files = self.sessions_dir.glob("*.json")
-        return [f.stem for f in session_files]
-
-    def delete_session(self, session_id: str) -> bool:
-        """Delete a session."""
-        session_path = self._get_session_path(session_id)
-        if session_path.exists():
-            session_path.unlink()
-            return True
-        return False
-
-    def get_last_session(self) -> Optional[Union[VerificationSession, EnhancedVerificationSession]]:
-        """Get the most recently created session."""
-        session_files = list(self.sessions_dir.glob("*.json"))
-        if not session_files:
-            return None
-        
-        # Sort by modification time, get the most recent
-        latest_file = max(session_files, key=lambda f: f.stat().st_mtime)
+            print(f"Error listing sessions: {e}")
         
-        with open(latest_file, "r") as f:
-            data = json.load(f)
-        
-        # Determine if this is an enhanced session based on presence of mode_type
-        if "mode_type" in data:
-            return EnhancedVerificationSession.from_dict(data)
-        else:
-            return VerificationSession.from_dict(data)
+        # Sort by start time (newest first)
+        sessions.sort(key=lambda x: x['start_time'], reverse=True)
+        return sessions
 
-    def mark_session_complete(self, session_id: str) -> None:
-        """Mark a session as complete and prevent further modifications."""
-        session = self.load_session(session_id)
-        if session is None:
-            raise ValueError(f"Session {session_id} not found")
+    def delete_session(self, session_id: str) -> bool:
+        """
+        Delete verification session from storage.
         
-        # Perform final validation before marking complete
-        final_validation = self.validation_service.perform_final_session_validation(session)
-        if not final_validation.is_valid:
-            logging.warning(f"Session {session_id} has validation issues: {'; '.join(final_validation.errors)}")
-            # Still allow completion but log the issues
+        Args:
+            session_id: ID of session to delete
+            
+        Returns:
+            True if deleted successfully, False otherwise
+        """
+        filename = f"{session_id}.json"
+        filepath = os.path.join(self.storage_dir, filename)
         
-        session.is_complete = True
-        session.completed_at = datetime.now()
-        self.save_session(session)
-
-    def can_modify_session(self, session_id: str) -> bool:
-        """Check if a session can be modified. Returns False if session is complete."""
-        session = self.load_session(session_id)
-        if session is None:
+        try:
+            if os.path.exists(filepath):
+                os.remove(filepath)
+                return True
+            return False
+        except Exception as e:
+            print(f"Error deleting session {session_id}: {e}")
             return False
-        
-        return not session.is_complete
 
-    # Enhanced methods for multi-mode support
-    def list_sessions_by_mode(self, mode_type: str) -> List[str]:
-        """List session IDs filtered by mode type."""
-        session_ids = []
-        for session_file in self.sessions_dir.glob("*.json"):
-            try:
-                with open(session_file, "r") as f:
-                    data = json.load(f)
-                
-                # Check if session has mode_type and matches filter
-                if data.get("mode_type") == mode_type:
-                    session_ids.append(session_file.stem)
-                elif mode_type == "standard" and "mode_type" not in data:
-                    # Include legacy sessions as "standard" mode
-                    session_ids.append(session_file.stem)
-            except (json.JSONDecodeError, KeyError):
-                # Skip corrupted files
-                continue
-        
-        return session_ids
+    def session_exists(self, session_id: str) -> bool:
+        """Check if session exists in storage."""
+        filename = f"{session_id}.json"
+        filepath = os.path.join(self.storage_dir, filename)
+        return os.path.exists(filepath)
 
-    def get_incomplete_sessions(self) -> List[Union[VerificationSession, EnhancedVerificationSession]]:
-        """Get all incomplete sessions across all modes."""
-        incomplete_sessions = []
-        for session_file in self.sessions_dir.glob("*.json"):
-            try:
-                with open(session_file, "r") as f:
-                    data = json.load(f)
-                
-                # Only include incomplete sessions
-                if not data.get("is_complete", False):
-                    if "mode_type" in data:
-                        session = EnhancedVerificationSession.from_dict(data)
-                    else:
-                        session = VerificationSession.from_dict(data)
-                    incomplete_sessions.append(session)
-            except (json.JSONDecodeError, KeyError):
-                # Skip corrupted files
-                continue
-        
-        # Sort by creation date, most recent first
-        incomplete_sessions.sort(key=lambda s: s.created_at, reverse=True)
-        return incomplete_sessions
+    def get_incomplete_sessions(self) -> List[Dict[str, Any]]:
+        """Get list of incomplete verification sessions."""
+        all_sessions = self.list_sessions()
+        return [s for s in all_sessions if not s['is_complete']]
 
-    def update_mode_metadata(self, session_id: str, metadata: Dict[str, Any]) -> None:
-        """Update mode-specific metadata for a session."""
-        session = self.load_session(session_id)
-        if session is None:
-            raise ValueError(f"Session {session_id} not found")
-        
-        # Ensure this is an enhanced session
-        if not isinstance(session, EnhancedVerificationSession):
-            raise ValueError(f"Session {session_id} is not an enhanced session")
+    def cleanup_old_sessions(self, days_old: int = 30) -> int:
+        """
+        Clean up old completed sessions.
         
-        # Update metadata
-        session.mode_metadata.update(metadata)
-        self.save_session(session)
-
-    def export_to_xlsx(self, session_id: str) -> bytes:
-        """Export session to XLSX format with comprehensive error handling. Returns XLSX content as bytes."""
-        try:
-            try:
-                import openpyxl
-                from openpyxl.styles import Font, PatternFill
-            except ImportError as e:
-                error_context = self.error_handler.handle_export_generation_error(
-                    "xlsx", session_id, "openpyxl library not available for XLSX export"
-                )
-                raise ImportError(error_context.user_message) from e
+        Args:
+            days_old: Delete sessions older than this many days
             
-            session = self.load_session(session_id)
-            if session is None:
-                error_context = self.error_handler.handle_export_generation_error(
-                    "xlsx", session_id, f"Session {session_id} not found"
-                )
-                raise ValueError(error_context.user_message)
-            
-            if session.verified_count == 0:
-                error_context = self.error_handler.handle_export_generation_error(
-                    "xlsx", session_id, "No verified messages to export"
-                )
-                raise ValueError(error_context.user_message)
+        Returns:
+            Number of sessions deleted
+        """
+        deleted_count = 0
+        cutoff_date = datetime.now().timestamp() - (days_old * 24 * 60 * 60)
         
-            # Create workbook with multiple sheets
-            wb = openpyxl.Workbook()
+        try:
+            for session_info in self.list_sessions():
+                if session_info['is_complete']:
+                    session_date = datetime.fromisoformat(session_info['start_time']).timestamp()
+                    if session_date < cutoff_date:
+                        if self.delete_session(session_info['session_id']):
+                            deleted_count += 1
+        except Exception as e:
+            print(f"Error during cleanup: {e}")
         
-            # Results sheet
-            ws_results = wb.active
-            ws_results.title = "Results"
-            
-            # Header styling
-            header_font = Font(bold=True)
-            header_fill = PatternFill(start_color="CCCCCC", end_color="CCCCCC", fill_type="solid")
-            
-            # Add headers
-            headers = ["Patient Message", "Classifier Said", "You Said", "Notes", "Date"]
-            if isinstance(session, EnhancedVerificationSession):
-                headers.extend(["Mode Type", "Confidence", "Indicators"])
-            
-            for col, header in enumerate(headers, 1):
-                cell = ws_results.cell(row=1, column=col, value=header)
-                cell.font = header_font
-                cell.fill = header_fill
-            
-            # Add data rows
-            for row, record in enumerate(session.verifications, 2):
-                ws_results.cell(row=row, column=1, value=record.original_message)
-                ws_results.cell(row=row, column=2, value=record.classifier_decision.upper())
-                ws_results.cell(row=row, column=3, value=record.ground_truth_label.upper())
-                ws_results.cell(row=row, column=4, value=record.verifier_notes)
-                ws_results.cell(row=row, column=5, value=record.timestamp.strftime("%Y-%m-%d %H:%M:%S"))
-                
-                if isinstance(session, EnhancedVerificationSession):
-                    ws_results.cell(row=row, column=6, value=session.mode_type)
-                    ws_results.cell(row=row, column=7, value=record.classifier_confidence)
-                    ws_results.cell(row=row, column=8, value="; ".join(record.classifier_indicators))
-            
-            # Summary Statistics sheet
-            ws_summary = wb.create_sheet("Summary Statistics")
+        return deleted_count
+
+    def backup_session(self, session_id: str, backup_dir: str = "verification_backups") -> bool:
+        """
+        Create backup copy of session.
         
-            # Calculate statistics
-            accuracy = (session.correct_count / session.verified_count * 100) if session.verified_count > 0 else 0.0
-            
-            summary_data = [
-                ["Metric", "Value"],
-                ["Session ID", session.session_id],
-                ["Verifier Name", session.verifier_name],
-                ["Dataset Name", session.dataset_name],
-                ["Total Messages", session.verified_count],
-                ["Correct", session.correct_count],
-                ["Incorrect", session.incorrect_count],
-                ["Accuracy %", f"{accuracy:.1f}%"],
-                ["Created At", session.created_at.strftime("%Y-%m-%d %H:%M:%S")],
-                ["Completed At", session.completed_at.strftime("%Y-%m-%d %H:%M:%S") if session.completed_at else "In Progress"],
-            ]
-            
-            if isinstance(session, EnhancedVerificationSession):
-                summary_data.extend([
-                    ["Mode Type", session.mode_type],
-                    ["File Source", session.file_source or "N/A"],
-                    ["Dataset Version", session.dataset_version or "N/A"],
-                    ["Manual Input Count", session.manual_input_count],
-                ])
+        Args:
+            session_id: ID of session to backup
+            backup_dir: Directory for backups
             
-            for row, (metric, value) in enumerate(summary_data, 1):
-                cell_metric = ws_summary.cell(row=row, column=1, value=metric)
-                cell_value = ws_summary.cell(row=row, column=2, value=value)
-                if row == 1:  # Header row
-                    cell_metric.font = header_font
-                    cell_metric.fill = header_fill
-                    cell_value.font = header_font
-                    cell_value.fill = header_fill
-            
-            # Error Analysis sheet
-            ws_errors = wb.create_sheet("Error Analysis")
-            
-            # Group errors by classification type
-            error_analysis = {}
-            for record in session.verifications:
-                if not record.is_correct:
-                    key = f"{record.classifier_decision} -> {record.ground_truth_label}"
-                    if key not in error_analysis:
-                        error_analysis[key] = []
-                    error_analysis[key].append(record)
+        Returns:
+            True if backup created successfully
+        """
+        try:
+            os.makedirs(backup_dir, exist_ok=True)
             
-            error_headers = ["Error Type", "Count", "Example Message", "Notes"]
-            for col, header in enumerate(error_headers, 1):
-                cell = ws_errors.cell(row=1, column=col, value=header)
-                cell.font = header_font
-                cell.fill = header_fill
+            source_file = os.path.join(self.storage_dir, f"{session_id}.json")
+            backup_file = os.path.join(backup_dir, f"{session_id}_backup_{datetime.now().strftime('%Y%m%d_%H%M%S')}.json")
             
-            row = 2
-            for error_type, records in error_analysis.items():
-                ws_errors.cell(row=row, column=1, value=error_type)
-                ws_errors.cell(row=row, column=2, value=len(records))
-                ws_errors.cell(row=row, column=3, value=records[0].original_message[:100] + "..." if len(records[0].original_message) > 100 else records[0].original_message)
-                ws_errors.cell(row=row, column=4, value=records[0].verifier_notes)
-                row += 1
+            if os.path.exists(source_file):
+                import shutil
+                shutil.copy2(source_file, backup_file)
+                return True
             
-            # Auto-adjust column widths
-            for ws in [ws_results, ws_summary, ws_errors]:
-                for column in ws.columns:
-                    max_length = 0
-                    column_letter = column[0].column_letter
-                    for cell in column:
-                        try:
-                            if len(str(cell.value)) > max_length:
-                                max_length = len(str(cell.value))
-                        except:
-                            pass
-                    adjusted_width = min(max_length + 2, 50)  # Cap at 50 characters
-                    ws.column_dimensions[column_letter].width = adjusted_width
-        
-            # Save to bytes
-            output = io.BytesIO()
-            wb.save(output)
-            output.seek(0)
-            return output.getvalue()
+            return False
             
-        except MemoryError as e:
-            error_context = self.error_handler.handle_export_generation_error(
-                "xlsx", session_id, f"Insufficient memory for XLSX export: {str(e)}"
-            )
-            raise RuntimeError(error_context.user_message) from e
-        except OSError as e:
-            if "No space left" in str(e):
-                error_context = self.error_handler.handle_export_generation_error(
-                    "xlsx", session_id, "Insufficient disk space for export"
-                )
-            else:
-                error_context = self.error_handler.handle_export_generation_error(
-                    "xlsx", session_id, f"File system error: {str(e)}"
-                )
-            raise RuntimeError(error_context.user_message) from e
         except Exception as e:
-            error_context = self.error_handler.handle_export_generation_error(
-                "xlsx", session_id, f"Unexpected error during XLSX export: {str(e)}"
-            )
-            raise RuntimeError(error_context.user_message) from e
+            print(f"Error creating backup for session {session_id}: {e}")
+            return False
 
-    def export_to_json(self, session_id: str) -> str:
-        """Export session to JSON format with comprehensive error handling. Returns JSON content."""
-        try:
-            session = self.load_session(session_id)
-            if session is None:
-                error_context = self.error_handler.handle_export_generation_error(
-                    "json", session_id, f"Session {session_id} not found"
-                )
-                raise ValueError(error_context.user_message)
-        
-            # Create comprehensive export data
-            export_data = {
-                "export_metadata": {
-                    "export_timestamp": datetime.now().isoformat(),
-                    "session_id": session_id,
-                    "export_format": "json",
-                    "version": "1.0"
-                },
-                "session_data": session.to_dict(),
-                "statistics": self.get_session_statistics(session_id),
-            }
-            
-            # Add enhanced data if available
-            if isinstance(session, EnhancedVerificationSession):
-                export_data["enhanced_metadata"] = {
-                    "mode_type": session.mode_type,
-                    "mode_metadata": session.mode_metadata,
-                    "file_source": session.file_source,
-                    "dataset_version": session.dataset_version,
-                    "manual_input_count": session.manual_input_count,
-                }
+    def validate_session_integrity(self, session_id: str) -> Dict[str, Any]:
+        """
+        Validate session data integrity.
         
-            return json.dumps(export_data, indent=2)
+        Args:
+            session_id: ID of session to validate
             
-        except MemoryError as e:
-            error_context = self.error_handler.handle_export_generation_error(
-                "json", session_id, f"Insufficient memory for JSON export: {str(e)}"
-            )
-            raise RuntimeError(error_context.user_message) from e
-        except TypeError as e:
-            error_context = self.error_handler.handle_export_generation_error(
-                "json", session_id, f"Data serialization error: {str(e)}"
-            )
-            raise RuntimeError(error_context.user_message) from e
-        except Exception as e:
-            error_context = self.error_handler.handle_export_generation_error(
-                "json", session_id, f"Unexpected error during JSON export: {str(e)}"
-            )
-            raise RuntimeError(error_context.user_message) from e
-
-    def export_multiple_sessions(self, session_ids: List[str], format_type: str) -> Union[str, bytes]:
-        """Export multiple sessions in specified format (csv, xlsx, json)."""
-        if not session_ids:
-            raise ValueError("No session IDs provided")
-        
-        if format_type.lower() == "csv":
-            return self._export_multiple_sessions_csv(session_ids)
-        elif format_type.lower() == "xlsx":
-            return self._export_multiple_sessions_xlsx(session_ids)
-        elif format_type.lower() == "json":
-            return self._export_multiple_sessions_json(session_ids)
-        else:
-            raise ValueError(f"Unsupported format type: {format_type}")
-
-    def _export_multiple_sessions_csv(self, session_ids: List[str]) -> str:
-        """Export multiple sessions to CSV format."""
-        output = io.StringIO()
-        writer = csv.writer(output)
-        
-        # Write combined header
-        writer.writerow([
-            "Session ID", "Mode Type", "Patient Message", "Classifier Said", 
-            "You Said", "Notes", "Date", "Verifier Name", "Dataset Name"
-        ])
+        Returns:
+            Dictionary with validation results
+        """
+        validation_result = {
+            'is_valid': False,
+            'errors': [],
+            'warnings': [],
+            'session_id': session_id
+        }
         
-        for session_id in session_ids:
+        try:
             session = self.load_session(session_id)
-            if session is None:
-                continue
+            if not session:
+                validation_result['errors'].append('Session not found or could not be loaded')
+                return validation_result
             
-            mode_type = session.mode_type if isinstance(session, EnhancedVerificationSession) else "standard"
+            # Check basic integrity
+            if len(session.verification_records) != session.total_exchanges:
+                validation_result['errors'].append(f'Record count mismatch: {len(session.verification_records)} != {session.total_exchanges}')
             
-            for record in session.verifications:
-                writer.writerow([
-                    session.session_id,
-                    mode_type,
-                    record.original_message,
-                    record.classifier_decision.upper(),
-                    record.ground_truth_label.upper(),
-                    record.verifier_notes,
-                    record.timestamp.strftime("%Y-%m-%d %H:%M:%S"),
-                    session.verifier_name,
-                    session.dataset_name,
-                ])
-        
-        return output.getvalue()
-
-    def _export_multiple_sessions_xlsx(self, session_ids: List[str]) -> bytes:
-        """Export multiple sessions to XLSX format."""
-        try:
-            import openpyxl
-            from openpyxl.styles import Font, PatternFill
-        except ImportError:
-            raise ImportError("openpyxl is required for XLSX export. Install with: pip install openpyxl")
-        
-        wb = openpyxl.Workbook()
-        ws = wb.active
-        ws.title = "Combined Results"
-        
-        # Header styling
-        header_font = Font(bold=True)
-        header_fill = PatternFill(start_color="CCCCCC", end_color="CCCCCC", fill_type="solid")
-        
-        # Add headers
-        headers = [
-            "Session ID", "Mode Type", "Patient Message", "Classifier Said", 
-            "You Said", "Notes", "Date", "Verifier Name", "Dataset Name"
-        ]
-        
-        for col, header in enumerate(headers, 1):
-            cell = ws.cell(row=1, column=col, value=header)
-            cell.font = header_font
-            cell.fill = header_fill
-        
-        # Add data from all sessions
-        row = 2
-        for session_id in session_ids:
-            session = self.load_session(session_id)
-            if session is None:
-                continue
+            # Check verified count consistency
+            actual_verified = len([r for r in session.verification_records if r.is_correct is not None])
+            if actual_verified != session.verified_exchanges:
+                validation_result['errors'].append(f'Verified count mismatch: {actual_verified} != {session.verified_exchanges}')
             
-            mode_type = session.mode_type if isinstance(session, EnhancedVerificationSession) else "standard"
+            # Check completion status consistency
+            if session.is_complete and session.verified_exchanges != session.total_exchanges:
+                validation_result['errors'].append('Session marked complete but not all exchanges verified')
             
-            for record in session.verifications:
-                ws.cell(row=row, column=1, value=session.session_id)
-                ws.cell(row=row, column=2, value=mode_type)
-                ws.cell(row=row, column=3, value=record.original_message)
-                ws.cell(row=row, column=4, value=record.classifier_decision.upper())
-                ws.cell(row=row, column=5, value=record.ground_truth_label.upper())
-                ws.cell(row=row, column=6, value=record.verifier_notes)
-                ws.cell(row=row, column=7, value=record.timestamp.strftime("%Y-%m-%d %H:%M:%S"))
-                ws.cell(row=row, column=8, value=session.verifier_name)
-                ws.cell(row=row, column=9, value=session.dataset_name)
-                row += 1
-        
-        # Auto-adjust column widths
-        for column in ws.columns:
-            max_length = 0
-            column_letter = column[0].column_letter
-            for cell in column:
-                try:
-                    if len(str(cell.value)) > max_length:
-                        max_length = len(str(cell.value))
-                except:
-                    pass
-            adjusted_width = min(max_length + 2, 50)
-            ws.column_dimensions[column_letter].width = adjusted_width
-        
-        # Save to bytes
-        output = io.BytesIO()
-        wb.save(output)
-        output.seek(0)
-        return output.getvalue()
-
-    def _export_multiple_sessions_json(self, session_ids: List[str]) -> str:
-        """Export multiple sessions to JSON format."""
-        export_data = {
-            "export_metadata": {
-                "export_timestamp": datetime.now().isoformat(),
-                "session_count": len(session_ids),
-                "export_format": "json",
-                "version": "1.0"
-            },
-            "sessions": []
-        }
-        
-        for session_id in session_ids:
-            session = self.load_session(session_id)
-            if session is None:
-                continue
+            # Check for duplicate exchange IDs
+            exchange_ids = [r.exchange_id for r in session.verification_records]
+            if len(exchange_ids) != len(set(exchange_ids)):
+                validation_result['errors'].append('Duplicate exchange IDs found')
             
-            session_export = {
-                "session_data": session.to_dict(),
-                "statistics": self.get_session_statistics(session_id),
-            }
+            # Warnings for potential issues
+            if session.verified_exchanges > 0:
+                progress = session.get_progress()
+                if progress.accuracy_overall < 0.5:
+                    validation_result['warnings'].append('Low accuracy detected - may indicate systematic issues')
             
-            if isinstance(session, EnhancedVerificationSession):
-                session_export["enhanced_metadata"] = {
-                    "mode_type": session.mode_type,
-                    "mode_metadata": session.mode_metadata,
-                    "file_source": session.file_source,
-                    "dataset_version": session.dataset_version,
-                    "manual_input_count": session.manual_input_count,
-                }
+            validation_result['is_valid'] = len(validation_result['errors']) == 0
             
-            export_data["sessions"].append(session_export)
-        
-        return json.dumps(export_data, indent=2)
-
-    # Helper methods for enhanced functionality
-    def save_test_case_edit(self, edit: TestCaseEdit) -> str:
-        """Save a test case edit record."""
-        edit_path = self.edits_dir / f"{edit.edit_id}.json"
-        with open(edit_path, "w") as f:
-            json.dump(edit.to_dict(), f, indent=2)
-        return edit.edit_id
-
-    def load_test_case_edit(self, edit_id: str) -> Optional[TestCaseEdit]:
-        """Load a test case edit record."""
-        edit_path = self.edits_dir / f"{edit_id}.json"
-        if not edit_path.exists():
-            return None
-        
-        with open(edit_path, "r") as f:
-            data = json.load(f)
-        
-        return TestCaseEdit.from_dict(data)
-
-    def list_test_case_edits(self, test_case_id: str = None) -> List[TestCaseEdit]:
-        """List test case edits, optionally filtered by test case ID."""
-        edits = []
-        for edit_file in self.edits_dir.glob("*.json"):
-            try:
-                with open(edit_file, "r") as f:
-                    data = json.load(f)
-                
-                edit = TestCaseEdit.from_dict(data)
-                if test_case_id is None or edit.test_case_id == test_case_id:
-                    edits.append(edit)
-            except (json.JSONDecodeError, KeyError):
-                continue
+        except Exception as e:
+            validation_result['errors'].append(f'Validation error: {str(e)}')
         
-        # Sort by timestamp, most recent first
-        edits.sort(key=lambda e: e.timestamp, reverse=True)
-        return edits
-
-    def save_file_upload_result(self, result: FileUploadResult) -> str:
-        """Save a file upload result."""
-        result_path = self.storage_dir / f"upload_{result.file_id}.json"
-        with open(result_path, "w") as f:
-            json.dump(result.to_dict(), f, indent=2)
-        return result.file_id
+        return validation_result
 
-    def load_file_upload_result(self, file_id: str) -> Optional[FileUploadResult]:
-        """Load a file upload result."""
-        result_path = self.storage_dir / f"upload_{file_id}.json"
-        if not result_path.exists():
-            return None
-        
-        with open(result_path, "r") as f:
-            data = json.load(f)
-        
-        return FileUploadResult.from_dict(data)
-    def get_error_recovery_options(self, error_id: str) -> List[Dict[str, Any]]:
-        """Get recovery options for a storage error."""
-        return self.error_handler.get_recovery_options(error_id)
-        
-    def attempt_error_recovery(self, error_id: str, strategy: str, 
-                             recovery_data: Optional[Dict[str, Any]] = None) -> Tuple[bool, str]:
-        """Attempt to recover from a storage error."""
-        from src.core.enhanced_error_handler import RecoveryStrategy
+    def recover_corrupted_session(self, session_id: str) -> Optional[VerificationSession]:
+        """
+        Attempt to recover a corrupted session.
         
-        try:
-            strategy_enum = RecoveryStrategy(strategy)
-            return self.error_handler.attempt_recovery(error_id, strategy_enum, recovery_data)
-        except ValueError:
-            return False, f"Invalid recovery strategy: {strategy}"
+        Args:
+            session_id: ID of session to recover
             
-    def restore_session_from_backup(self, session_id: str, backup_id: Optional[str] = None) -> bool:
-        """Restore a session from backup."""
+        Returns:
+            Recovered session if possible, None otherwise
+        """
         try:
-            backups = self.error_handler.recovery_manager.list_backups(session_id)
-            if not backups:
-                return False
-                
-            # Use specified backup or most recent
-            target_backup_id = backup_id or backups[0]["backup_id"]
+            filename = f"{session_id}.json"
+            filepath = os.path.join(self.storage_dir, filename)
             
-            restored_data = self.error_handler.recovery_manager.restore_from_backup(target_backup_id)
-            if not restored_data:
-                return False
-                
-            # Validate restored data
-            is_valid, validation_errors = self.error_handler.recovery_manager.validate_session_data(restored_data)
-            if not is_valid:
-                logging.error(f"Restored backup data is invalid: {validation_errors}")
-                return False
-                
-            # Save restored session
-            session_path = self._get_session_path(session_id)
-            with open(session_path, "w") as f:
-                json.dump(restored_data, f, indent=2)
-                
-            logging.info(f"Successfully restored session {session_id} from backup {target_backup_id}")
-            return True
+            if not os.path.exists(filepath):
+                return None
             
-        except Exception as e:
-            logging.error(f"Failed to restore session {session_id} from backup: {e}")
-            return False
+            # Try to read raw file content
+            with open(filepath, 'r', encoding='utf-8') as f:
+                content = f.read()
             
-    def list_session_backups(self, session_id: str) -> List[Dict[str, Any]]:
-        """List available backups for a session."""
-        return self.error_handler.recovery_manager.list_backups(session_id)
-        
-    def validate_session_integrity(self, session_id: str) -> Tuple[bool, List[str]]:
-        """Validate the integrity of a session."""
-        try:
-            session_path = self._get_session_path(session_id)
-            if not session_path.exists():
-                return False, ["Session file does not exist"]
-                
-            with open(session_path, "r") as f:
-                data = json.load(f)
-                
-            return self.error_handler.recovery_manager.validate_session_data(data)
-            
-        except json.JSONDecodeError as e:
-            return False, [f"JSON decode error: {str(e)}"]
-        except Exception as e:
-            return False, [f"Error validating session: {str(e)}"]
-            
-    def get_error_summary(self, time_window_hours: int = 24) -> Dict[str, Any]:
-        """Get error summary for the storage system."""
-        return self.error_handler.get_error_summary(time_window_hours)
-        
-    def cleanup_old_errors(self, days_to_keep: int = 7) -> int:
-        """Clean up old resolved errors."""
-        return self.error_handler.cleanup_old_errors(days_to_keep)
-    
-    # Data validation and integrity methods
-    
-    def validate_session_data_integrity(self, session_id: str) -> Dict[str, Any]:
-        """
-        Validate the data integrity of a session.
-        
-        Requirements: 11.1, 11.2, 11.5 - Verification result validation, accuracy verification, final validation
-        """
-        session = self.load_session(session_id)
-        if session is None:
-            return {"valid": False, "error": f"Session {session_id} not found"}
-        
-        # Perform comprehensive validation
-        session_validation = self.validation_service.validate_verification_session(session)
-        accuracy_validation = self.validation_service.verify_accuracy_calculations(session)
-        
-        # Generate integrity checksum
-        integrity_checksum = self.validation_service.generate_data_integrity_checksum(session)
-        
-        return {
-            "valid": session_validation.is_valid and accuracy_validation.is_valid,
-            "session_validation": {
-                "valid": session_validation.is_valid,
-                "errors": session_validation.errors,
-                "warnings": session_validation.warnings
-            },
-            "accuracy_validation": {
-                "valid": accuracy_validation.is_valid,
-                "errors": accuracy_validation.errors,
-                "warnings": accuracy_validation.warnings,
-                "metadata": accuracy_validation.metadata
-            },
-            "integrity_checksum": {
-                "checksum": integrity_checksum.checksum_value,
-                "timestamp": integrity_checksum.timestamp.isoformat(),
-                "data_size": integrity_checksum.data_size
-            }
-        }
-    
-    def detect_duplicate_test_cases_in_import(self, test_cases: List[TestMessage], 
-                                            similarity_threshold: float = 0.95) -> Dict[str, Any]:
-        """
-        Detect duplicate test cases in import data.
-        
-        Requirements: 11.4 - Duplicate detection for test case imports
-        """
-        # Validate individual test messages first
-        validation_results = []
-        valid_test_cases = []
-        
-        for i, test_case in enumerate(test_cases):
-            validation = self.validation_service.validate_test_message(test_case)
-            validation_results.append({
-                "index": i,
-                "message_id": test_case.message_id,
-                "valid": validation.is_valid,
-                "errors": validation.errors,
-                "warnings": validation.warnings
-            })
+            # Attempt basic JSON repair (remove trailing commas, etc.)
+            content = content.replace(',}', '}').replace(',]', ']')
             
-            if validation.is_valid:
-                valid_test_cases.append(test_case)
-        
-        # Detect duplicates among valid test cases
-        duplicate_result = self.validation_service.detect_duplicate_test_cases(
-            valid_test_cases, similarity_threshold
-        )
-        
-        return {
-            "total_test_cases": len(test_cases),
-            "valid_test_cases": len(valid_test_cases),
-            "validation_results": validation_results,
-            "duplicate_detection": {
-                "duplicates_found": duplicate_result.duplicates_found,
-                "duplicate_groups": duplicate_result.duplicate_groups,
-                "similarity_threshold": duplicate_result.similarity_threshold,
-                "detection_method": duplicate_result.detection_method
-            }
-        }
-    
-    def export_with_integrity_checksum(self, session_id: str, format_type: str) -> Dict[str, Any]:
-        """
-        Export session data with integrity checksum for validation.
-        
-        Requirements: 11.3 - Data integrity checksums for exports
-        """
-        session = self.load_session(session_id)
-        if session is None:
-            raise ValueError(f"Session {session_id} not found")
-        
-        # Generate export data
-        if format_type.lower() == "csv":
-            export_data = self.export_to_csv(session_id)
-        elif format_type.lower() == "xlsx":
-            export_data = self.export_to_xlsx(session_id)
-        elif format_type.lower() == "json":
-            export_data = self.export_to_json(session_id)
-        else:
-            raise ValueError(f"Unsupported export format: {format_type}")
-        
-        # Generate integrity checksum for the export
-        export_checksum = self.validation_service.generate_data_integrity_checksum(
-            export_data,
-            validation_fields=["session_id", "verifications", "statistics"]
-        )
-        
-        # Generate session integrity checksum
-        session_checksum = self.validation_service.generate_data_integrity_checksum(session)
-        
-        return {
-            "export_data": export_data,
-            "export_metadata": {
-                "session_id": session_id,
-                "format_type": format_type,
-                "export_timestamp": datetime.now().isoformat(),
-                "export_checksum": {
-                    "checksum": export_checksum.checksum_value,
-                    "checksum_type": export_checksum.checksum_type,
-                    "data_size": export_checksum.data_size,
-                    "validation_fields": export_checksum.validation_fields
-                },
-                "session_checksum": {
-                    "checksum": session_checksum.checksum_value,
-                    "checksum_type": session_checksum.checksum_type,
-                    "data_size": session_checksum.data_size
-                }
-            }
-        }
-    
-    def validate_import_data_integrity(self, import_data: Any, expected_checksum: str, 
-                                     checksum_type: str = "sha256") -> Dict[str, Any]:
-        """
-        Validate imported data against expected integrity checksum.
-        
-        Requirements: 11.3 - Data integrity checksums for exports
-        """
-        from src.core.data_validation_service import IntegrityChecksum
-        
-        expected_checksum_obj = IntegrityChecksum(
-            checksum_type=checksum_type,
-            checksum_value=expected_checksum,
-            data_size=0,  # Will be recalculated
-            timestamp=datetime.now(),
-            validation_fields=[]
-        )
-        
-        validation_result = self.validation_service.validate_data_integrity(
-            import_data, expected_checksum_obj
-        )
-        
-        return {
-            "valid": validation_result.is_valid,
-            "errors": validation_result.errors,
-            "warnings": validation_result.warnings,
-            "metadata": validation_result.metadata
-        }
-    
-    def get_session_data_quality_report(self, session_id: str) -> Dict[str, Any]:
-        """
-        Generate comprehensive data quality report for a session.
-        
-        Requirements: 11.5 - Final session validation checks
-        """
-        session = self.load_session(session_id)
-        if session is None:
-            return {"error": f"Session {session_id} not found"}
-        
-        # Perform final validation
-        final_validation = self.validation_service.perform_final_session_validation(session)
-        
-        # Get session statistics
-        stats = self.get_session_statistics(session_id)
-        
-        # Calculate additional quality metrics
-        quality_metrics = {}
-        if hasattr(session, 'verifications') and session.verifications:
-            # Calculate completeness metrics
-            records_with_notes = sum(1 for v in session.verifications 
-                                   if hasattr(v, 'verifier_notes') and v.verifier_notes.strip())
-            quality_metrics["notes_completeness"] = records_with_notes / len(session.verifications)
+            try:
+                session_dict = json.loads(content)
+            except json.JSONDecodeError:
+                # If still can't parse, try to extract what we can
+                print(f"Severe corruption in session {session_id}, attempting partial recovery")
+                return None
+            
+            # Try to reconstruct session with minimal required fields
+            required_fields = ['session_id', 'conversation_session_id', 'patient_name', 'verifier_name', 'start_time']
+            for field in required_fields:
+                if field not in session_dict:
+                    print(f"Missing required field {field} in corrupted session")
+                    return None
+            
+            # Set defaults for missing optional fields
+            session_dict.setdefault('end_time', None)
+            session_dict.setdefault('total_exchanges', 0)
+            session_dict.setdefault('verified_exchanges', 0)
+            session_dict.setdefault('verification_records', [])
+            session_dict.setdefault('is_complete', False)
+            
+            # Try to load the recovered session
+            return self.load_session(session_id)
             
-            # Calculate confidence distribution
-            confidences = [v.classifier_confidence for v in session.verifications 
-                         if hasattr(v, 'classifier_confidence')]
-            if confidences:
-                quality_metrics["avg_confidence"] = sum(confidences) / len(confidences)
-                quality_metrics["min_confidence"] = min(confidences)
-                quality_metrics["max_confidence"] = max(confidences)
-        
-        return {
-            "session_id": session_id,
-            "report_timestamp": datetime.now().isoformat(),
-            "validation_result": {
-                "valid": final_validation.is_valid,
-                "errors": final_validation.errors,
-                "warnings": final_validation.warnings,
-                "data_quality_score": final_validation.metadata.get("data_quality_score", 0)
-            },
-            "session_statistics": stats,
-            "quality_metrics": quality_metrics,
-            "integrity_checksum": final_validation.metadata.get("integrity_checksum", "")
-        }
+        except Exception as e:
+            print(f"Recovery failed for session {session_id}: {e}")
+            return None

src/interface/conversation_verification_ui.py

@@ -0,0 +1,472 @@
+#!/usr/bin/env python3
+"""
+Conversation Verification UI Components.
+
+Gradio-based interface for reviewing and verifying AI classifier decisions
+on patient conversations.
+"""
+
+import gradio as gr
+from typing import Dict, List, Optional, Tuple, Any
+from datetime import datetime
+
+from src.core.conversation_verification import (
+    VerificationSession, VerificationRecord, VerificationFeedback,
+    ConversationVerificationManager
+)
+
+
+class VerificationInterface:
+    """Gradio-based UI for conversation verification."""
+
+    def __init__(self, manager: ConversationVerificationManager):
+        """Initialize verification interface."""
+        self.manager = manager
+        self.current_session: Optional[VerificationSession] = None
+        self.current_record_index: int = 0
+
+    def create_verification_window(self, session: VerificationSession) -> gr.Blocks:
+        """
+        Create main verification window interface.
+        
+        Args:
+            session: VerificationSession to review
+            
+        Returns:
+            Gradio Blocks interface
+        """
+        self.current_session = session
+        self.current_record_index = 0
+
+        with gr.Blocks(
+            title=f"Verify Conversation - {session.patient_name}",
+            theme=gr.themes.Soft()
+        ) as interface:
+            
+            # Session header
+            with gr.Row():
+                gr.Markdown(f"""
+                # 🔍 Conversation Verification
+                
+                **Patient:** {session.patient_name}  
+                **Verifier:** {session.verifier_name}  
+                **Session:** `{session.session_id}`  
+                **Started:** {session.start_time.strftime('%Y-%m-%d %H:%M')}
+                """)
+            
+            # Progress section
+            with gr.Row():
+                progress_bar = gr.HTML(value=self._render_progress_bar(session))
+                
+            with gr.Row():
+                with gr.Column(scale=1):
+                    stats_display = gr.HTML(value=self._render_statistics(session))
+                with gr.Column(scale=1):
+                    navigation_info = gr.HTML(value=self._render_navigation_info(session))
+
+            # Main verification area
+            with gr.Row():
+                with gr.Column(scale=3):
+                    # Current exchange display
+                    exchange_display = gr.HTML(value="", label="Current Exchange")
+                    
+                    # Verification buttons
+                    with gr.Row():
+                        correct_btn = gr.Button("✅ Correct", variant="primary", scale=1)
+                        incorrect_btn = gr.Button("❌ Incorrect", variant="secondary", scale=1)
+                    
+                    # Correction interface (initially hidden)
+                    correction_section = gr.Column(visible=False)
+                    with correction_section:
+                        gr.Markdown("### Select Correct Classification:")
+                        correction_radio = gr.Radio(
+                            choices=["GREEN", "YELLOW", "RED"],
+                            label="Correct Classification",
+                            interactive=True
+                        )
+                        
+                        correction_reason = gr.Dropdown(
+                            choices=[
+                                "Missed indicators",
+                                "False positive", 
+                                "Context misunderstanding",
+                                "Severity misjudgment",
+                                "Other"
+                            ],
+                            label="Correction Reason",
+                            interactive=True
+                        )
+                        
+                        correction_notes = gr.Textbox(
+                            label="Additional Notes (Optional)",
+                            placeholder="Explain the correction...",
+                            lines=3,
+                            interactive=True
+                        )
+                        
+                        with gr.Row():
+                            submit_correction_btn = gr.Button("✅ Submit Correction", variant="primary")
+                            cancel_correction_btn = gr.Button("❌ Cancel", variant="secondary")
+
+                with gr.Column(scale=1):
+                    # Navigation controls
+                    with gr.Column():
+                        gr.Markdown("### Navigation")
+                        
+                        with gr.Row():
+                            prev_btn = gr.Button("⬅️ Previous", scale=1)
+                            next_btn = gr.Button("Next ➡️", scale=1)
+                        
+                        current_position = gr.HTML(value="Exchange 1 of 1")
+                        
+                        # Quick actions
+                        gr.Markdown("### Quick Actions")
+                        mark_all_correct_btn = gr.Button("✅ Mark All Remaining as Correct", size="sm")
+                        
+                        # Export section
+                        gr.Markdown("### Export Results")
+                        export_btn = gr.Button("📊 Export to CSV", variant="primary")
+                        export_status = gr.HTML(value="")
+
+            # Hidden state components
+            session_state = gr.State(value=session)
+            current_index = gr.State(value=0)
+            
+            # Load initial exchange
+            interface.load(
+                fn=self._load_initial_exchange,
+                inputs=[session_state, current_index],
+                outputs=[exchange_display, current_position, stats_display, progress_bar]
+            )
+            
+            # Event handlers
+            correct_btn.click(
+                fn=self._handle_correct_feedback,
+                inputs=[session_state, current_index],
+                outputs=[exchange_display, current_position, stats_display, progress_bar, current_index]
+            )
+            
+            incorrect_btn.click(
+                fn=lambda: gr.Column(visible=True),
+                outputs=[correction_section]
+            )
+            
+            submit_correction_btn.click(
+                fn=self._handle_incorrect_feedback,
+                inputs=[session_state, current_index, correction_radio, correction_reason, correction_notes],
+                outputs=[exchange_display, current_position, stats_display, progress_bar, current_index, correction_section]
+            )
+            
+            cancel_correction_btn.click(
+                fn=lambda: (gr.Column(visible=False), "", "", ""),
+                outputs=[correction_section, correction_radio, correction_reason, correction_notes]
+            )
+            
+            prev_btn.click(
+                fn=self._navigate_previous,
+                inputs=[session_state, current_index],
+                outputs=[exchange_display, current_position, current_index]
+            )
+            
+            next_btn.click(
+                fn=self._navigate_next,
+                inputs=[session_state, current_index],
+                outputs=[exchange_display, current_position, current_index]
+            )
+            
+            mark_all_correct_btn.click(
+                fn=self._mark_all_remaining_correct,
+                inputs=[session_state, current_index],
+                outputs=[exchange_display, current_position, stats_display, progress_bar]
+            )
+            
+            export_btn.click(
+                fn=self._export_results,
+                inputs=[session_state],
+                outputs=[export_status]
+            )
+
+        return interface
+
+    def _load_initial_exchange(self, session: VerificationSession, index: int) -> Tuple[str, str, str, str]:
+        """Load the first exchange for verification."""
+        if not session.verification_records:
+            return "No exchanges to verify", "No exchanges", "", ""
+        
+        record = session.verification_records[index]
+        exchange_html = self._render_exchange_review(record)
+        position_html = f"Exchange {index + 1} of {len(session.verification_records)}"
+        stats_html = self._render_statistics(session)
+        progress_html = self._render_progress_bar(session)
+        
+        return exchange_html, position_html, stats_html, progress_html
+
+    def _render_exchange_review(self, record: VerificationRecord) -> str:
+        """Render exchange for review."""
+        # Classification indicator
+        indicator_emoji = {"GREEN": "🟢", "YELLOW": "🟡", "RED": "🔴"}
+        emoji = indicator_emoji.get(record.original_classification, "⚪")
+        
+        # Verification status
+        status_html = ""
+        if record.is_correct is not None:
+            if record.is_correct:
+                status_html = '<div style="background-color: #d4edda; padding: 0.5em; border-radius: 4px; margin-bottom: 1em;"><strong>✅ Verified as Correct</strong></div>'
+            else:
+                status_html = f'''<div style="background-color: #f8d7da; padding: 0.5em; border-radius: 4px; margin-bottom: 1em;">
+                <strong>❌ Marked as Incorrect</strong><br>
+                Correct Classification: <strong>{record.correct_classification}</strong><br>
+                Reason: {record.correction_reason}<br>
+                {f"Notes: {record.verifier_notes}" if record.verifier_notes else ""}
+                </div>'''
+        
+        # Indicators display
+        indicators_html = ""
+        if record.original_indicators:
+            indicators_list = ", ".join(record.original_indicators[:3])
+            if len(record.original_indicators) > 3:
+                indicators_list += f" +{len(record.original_indicators) - 3} more"
+            indicators_html = f"<br><em>Indicators: {indicators_list}</em>"
+        
+        html = f"""
+        <div style="border: 1px solid #ddd; border-radius: 8px; padding: 1em; margin-bottom: 1em;">
+            {status_html}
+            
+            <div style="background-color: #f8f9fa; padding: 0.75em; border-radius: 4px; margin-bottom: 1em;">
+                <strong>👤 Patient Message:</strong><br>
+                <em>"{record.user_message}"</em>
+            </div>
+            
+            <div style="background-color: #e3f2fd; padding: 0.75em; border-radius: 4px; margin-bottom: 1em;">
+                <strong>🤖 AI Response:</strong><br>
+                {record.assistant_response}
+            </div>
+            
+            <div style="background-color: #fff3e0; padding: 0.75em; border-radius: 4px;">
+                <strong>🔍 AI Classification:</strong><br>
+                {emoji} <strong>{record.original_classification}</strong> ({int(record.original_confidence * 100)}%)
+                {indicators_html}
+                <br><em>Reasoning: {record.original_reasoning}</em>
+            </div>
+        </div>
+        """
+        
+        return html
+
+    def _render_progress_bar(self, session: VerificationSession) -> str:
+        """Render progress bar."""
+        progress = session.get_progress()
+        percentage = progress.calculate_progress_percentage()
+        
+        return f"""
+        <div style="margin-bottom: 1em;">
+            <div style="display: flex; justify-content: space-between; margin-bottom: 0.5em;">
+                <span><strong>Progress:</strong> {progress.verified_exchanges} of {progress.total_exchanges} verified</span>
+                <span><strong>{percentage:.1f}%</strong></span>
+            </div>
+            <div style="background-color: #e9ecef; border-radius: 10px; height: 20px;">
+                <div style="background-color: #28a745; height: 20px; border-radius: 10px; width: {percentage}%;"></div>
+            </div>
+        </div>
+        """
+
+    def _render_statistics(self, session: VerificationSession) -> str:
+        """Render verification statistics."""
+        progress = session.get_progress()
+        
+        if progress.verified_exchanges == 0:
+            return """
+            <div style="background-color: #f8f9fa; padding: 1em; border-radius: 8px;">
+                <h4>📊 Statistics</h4>
+                <p>No verifications completed yet.</p>
+            </div>
+            """
+        
+        stats_html = f"""
+        <div style="background-color: #f8f9fa; padding: 1em; border-radius: 8px;">
+            <h4>📊 Statistics</h4>
+            <p><strong>Overall Accuracy:</strong> {progress.accuracy_overall:.1%}</p>
+            
+            <p><strong>By Classification:</strong></p>
+            <ul>
+                <li>🟢 GREEN: {progress.accuracy_by_type.get('GREEN', 0):.1%}</li>
+                <li>🟡 YELLOW: {progress.accuracy_by_type.get('YELLOW', 0):.1%}</li>
+                <li>🔴 RED: {progress.accuracy_by_type.get('RED', 0):.1%}</li>
+            </ul>
+        """
+        
+        if progress.common_errors:
+            stats_html += "<p><strong>Common Errors:</strong></p><ul>"
+            for from_class, to_class, count in progress.common_errors[:3]:
+                stats_html += f"<li>{from_class} → {to_class}: {count} cases</li>"
+            stats_html += "</ul>"
+        
+        stats_html += "</div>"
+        return stats_html
+
+    def _render_navigation_info(self, session: VerificationSession) -> str:
+        """Render navigation information."""
+        unverified_count = len(session.get_unverified_records())
+        
+        return f"""
+        <div style="background-color: #e3f2fd; padding: 1em; border-radius: 8px;">
+            <h4>🧭 Navigation</h4>
+            <p><strong>Total Exchanges:</strong> {session.total_exchanges}</p>
+            <p><strong>Remaining:</strong> {unverified_count}</p>
+            <p><strong>Status:</strong> {'Complete' if session.is_complete else 'In Progress'}</p>
+        </div>
+        """
+
+    def _handle_correct_feedback(self, session: VerificationSession, index: int) -> Tuple[str, str, str, str, int]:
+        """Handle correct classification feedback."""
+        if index >= len(session.verification_records):
+            return "No more exchanges", f"Exchange {index + 1} of {len(session.verification_records)}", "", "", index
+        
+        record = session.verification_records[index]
+        
+        # Submit feedback
+        feedback = VerificationFeedback(
+            exchange_id=record.exchange_id,
+            is_correct=True
+        )
+        
+        self.manager.submit_exchange_verification(session.session_id, record.exchange_id, feedback)
+        
+        # Reload session to get updated data
+        updated_session = self.manager.load_session(session.session_id)
+        
+        # Move to next unverified exchange
+        next_index = self._find_next_unverified_index(updated_session, index)
+        
+        if next_index is not None:
+            next_record = updated_session.verification_records[next_index]
+            exchange_html = self._render_exchange_review(next_record)
+            position_html = f"Exchange {next_index + 1} of {len(updated_session.verification_records)}"
+        else:
+            exchange_html = "<div style='text-align: center; padding: 2em;'><h3>🎉 All exchanges verified!</h3><p>You can now export the results.</p></div>"
+            position_html = "Verification Complete"
+            next_index = index
+        
+        stats_html = self._render_statistics(updated_session)
+        progress_html = self._render_progress_bar(updated_session)
+        
+        return exchange_html, position_html, stats_html, progress_html, next_index
+
+    def _handle_incorrect_feedback(
+        self, 
+        session: VerificationSession, 
+        index: int, 
+        correct_classification: str,
+        correction_reason: str,
+        notes: str
+    ) -> Tuple[str, str, str, str, int, gr.Column]:
+        """Handle incorrect classification feedback."""
+        if index >= len(session.verification_records):
+            return "No more exchanges", f"Exchange {index + 1} of {len(session.verification_records)}", "", "", index, gr.Column(visible=False)
+        
+        record = session.verification_records[index]
+        
+        # Submit feedback
+        feedback = VerificationFeedback(
+            exchange_id=record.exchange_id,
+            is_correct=False,
+            correct_classification=correct_classification,
+            correction_reason=correction_reason,
+            notes=notes if notes.strip() else None
+        )
+        
+        self.manager.submit_exchange_verification(session.session_id, record.exchange_id, feedback)
+        
+        # Reload session
+        updated_session = self.manager.load_session(session.session_id)
+        
+        # Move to next unverified exchange
+        next_index = self._find_next_unverified_index(updated_session, index)
+        
+        if next_index is not None:
+            next_record = updated_session.verification_records[next_index]
+            exchange_html = self._render_exchange_review(next_record)
+            position_html = f"Exchange {next_index + 1} of {len(updated_session.verification_records)}"
+        else:
+            exchange_html = "<div style='text-align: center; padding: 2em;'><h3>🎉 All exchanges verified!</h3><p>You can now export the results.</p></div>"
+            position_html = "Verification Complete"
+            next_index = index
+        
+        stats_html = self._render_statistics(updated_session)
+        progress_html = self._render_progress_bar(updated_session)
+        
+        return exchange_html, position_html, stats_html, progress_html, next_index, gr.Column(visible=False)
+
+    def _navigate_previous(self, session: VerificationSession, index: int) -> Tuple[str, str, int]:
+        """Navigate to previous exchange."""
+        new_index = max(0, index - 1)
+        record = session.verification_records[new_index]
+        exchange_html = self._render_exchange_review(record)
+        position_html = f"Exchange {new_index + 1} of {len(session.verification_records)}"
+        
+        return exchange_html, position_html, new_index
+
+    def _navigate_next(self, session: VerificationSession, index: int) -> Tuple[str, str, int]:
+        """Navigate to next exchange."""
+        new_index = min(len(session.verification_records) - 1, index + 1)
+        record = session.verification_records[new_index]
+        exchange_html = self._render_exchange_review(record)
+        position_html = f"Exchange {new_index + 1} of {len(session.verification_records)}"
+        
+        return exchange_html, position_html, new_index
+
+    def _mark_all_remaining_correct(self, session: VerificationSession, current_index: int) -> Tuple[str, str, str, str]:
+        """Mark all remaining unverified exchanges as correct."""
+        unverified_records = session.get_unverified_records()
+        
+        for record in unverified_records:
+            feedback = VerificationFeedback(
+                exchange_id=record.exchange_id,
+                is_correct=True
+            )
+            self.manager.submit_exchange_verification(session.session_id, record.exchange_id, feedback)
+        
+        # Reload session
+        updated_session = self.manager.load_session(session.session_id)
+        
+        exchange_html = "<div style='text-align: center; padding: 2em;'><h3>🎉 All exchanges verified!</h3><p>All remaining exchanges marked as correct.</p></div>"
+        position_html = "Verification Complete"
+        stats_html = self._render_statistics(updated_session)
+        progress_html = self._render_progress_bar(updated_session)
+        
+        return exchange_html, position_html, stats_html, progress_html
+
+    def _export_results(self, session: VerificationSession) -> str:
+        """Export verification results to CSV."""
+        try:
+            from src.core.verification_exporter import VerificationExporter
+            exporter = VerificationExporter()
+            csv_path = exporter.export_session_to_csv(session)
+            
+            return f"""
+            <div style="background-color: #d4edda; padding: 1em; border-radius: 4px;">
+                <strong>✅ Export Successful!</strong><br>
+                File saved: <code>{csv_path}</code><br>
+                <small>Check your downloads folder</small>
+            </div>
+            """
+        except Exception as e:
+            return f"""
+            <div style="background-color: #f8d7da; padding: 1em; border-radius: 4px;">
+                <strong>❌ Export Failed</strong><br>
+                Error: {str(e)}
+            </div>
+            """
+
+    def _find_next_unverified_index(self, session: VerificationSession, current_index: int) -> Optional[int]:
+        """Find the next unverified exchange index."""
+        for i in range(current_index + 1, len(session.verification_records)):
+            if session.verification_records[i].is_correct is None:
+                return i
+        
+        # If no unverified found after current, check from beginning
+        for i in range(current_index):
+            if session.verification_records[i].is_correct is None:
+                return i
+        
+        return None  # All verified

src/interface/simplified_gradio_app.py

@@ -302,6 +302,10 @@ def create_simplified_interface():
                             download_json_btn = gr.DownloadButton("📥 Download JSON", scale=1, size="sm")
                             download_csv_btn = gr.DownloadButton("📊 Download CSV", scale=1, size="sm")
                         
+                        # Verification section
+                        with gr.Row():
+                            verify_conversation_btn = gr.Button("🔍 Verify Conversation", variant="secondary", scale=2, size="sm")
+                        
                         # Quick examples
                         gr.Markdown("### ⚡ Quick Start:")
                         with gr.Row():
@@ -778,6 +782,44 @@ Changes apply only to your current session.
                 print(f"Error downloading CSV: {e}")
                 return None
         
+        def open_verification_window(session: SimplifiedSessionData):
+            """Open verification window for current conversation."""
+            if session is None or not hasattr(session.app_instance, 'conversation_logger'):
+                return "❌ No conversation to verify"
+            
+            try:
+                # Check if conversation has any entries
+                if not session.app_instance.conversation_logger.entries:
+                    return "❌ No conversation exchanges to verify"
+                
+                # Create verification session
+                from src.core.conversation_verification import ConversationVerificationManager
+                from src.interface.conversation_verification_ui import VerificationInterface
+                
+                manager = ConversationVerificationManager()
+                verification_session = manager.create_verification_session(
+                    session.app_instance.conversation_logger,
+                    "Medical Professional"
+                )
+                
+                # Create verification interface
+                interface = VerificationInterface(manager)
+                verification_window = interface.create_verification_window(verification_session)
+                
+                # Launch verification window
+                verification_window.launch(
+                    server_name="127.0.0.1",
+                    server_port=7861,  # Different port from main app
+                    share=False,
+                    show_error=True,
+                    quiet=True
+                )
+                
+                return f"✅ Verification window opened for {len(verification_session.verification_records)} exchanges"
+                
+            except Exception as e:
+                return f"❌ Error opening verification: {str(e)}"
+        
         # Prompt editing handlers
         def format_prompt_with_html(prompt_text: str) -> str:
             """Format prompt with HTML tags for better visualization."""
@@ -1877,6 +1919,13 @@ To revert, use "Reset to Default" button.
             outputs=[download_csv_btn]
         )
         
+        # Verification button
+        verify_conversation_btn.click(
+            open_verification_window,
+            inputs=[session_data],
+            outputs=[]  # No outputs needed as it opens new window
+        )
+        
         # Refresh conversation stats
         refresh_stats_btn.click(
             get_conversation_stats,