diff --git a/skz-integration/autonomous-agents-framework/src/models/__pycache__/enhanced_agent.cpython-312.pyc b/skz-integration/autonomous-agents-framework/src/models/__pycache__/enhanced_agent.cpython-312.pyc
index 0b84d0f4..d6fac1ad 100644
Binary files a/skz-integration/autonomous-agents-framework/src/models/__pycache__/enhanced_agent.cpython-312.pyc and b/skz-integration/autonomous-agents-framework/src/models/__pycache__/enhanced_agent.cpython-312.pyc differ
diff --git a/skz-integration/autonomous-agents-framework/src/models/__pycache__/learning_framework.cpython-312.pyc b/skz-integration/autonomous-agents-framework/src/models/__pycache__/learning_framework.cpython-312.pyc
index 94168585..4a40ee94 100644
Binary files a/skz-integration/autonomous-agents-framework/src/models/__pycache__/learning_framework.cpython-312.pyc and b/skz-integration/autonomous-agents-framework/src/models/__pycache__/learning_framework.cpython-312.pyc differ
diff --git a/skz-integration/autonomous-agents-framework/src/models/__pycache__/memory_system.cpython-312.pyc b/skz-integration/autonomous-agents-framework/src/models/__pycache__/memory_system.cpython-312.pyc
index df351f17..df9d4497 100644
Binary files a/skz-integration/autonomous-agents-framework/src/models/__pycache__/memory_system.cpython-312.pyc and b/skz-integration/autonomous-agents-framework/src/models/__pycache__/memory_system.cpython-312.pyc differ
diff --git a/skz-integration/autonomous-agents-framework/src/models/__pycache__/ml_decision_engine.cpython-312.pyc b/skz-integration/autonomous-agents-framework/src/models/__pycache__/ml_decision_engine.cpython-312.pyc
index 882dc385..63cd0c77 100644
Binary files a/skz-integration/autonomous-agents-framework/src/models/__pycache__/ml_decision_engine.cpython-312.pyc and b/skz-integration/autonomous-agents-framework/src/models/__pycache__/ml_decision_engine.cpython-312.pyc differ
diff --git a/skz-integration/autonomous-agents-framework/src/models/communication_automation.py b/skz-integration/autonomous-agents-framework/src/models/communication_automation.py
index 6642dc2f..c26a634d 100644
--- a/skz-integration/autonomous-agents-framework/src/models/communication_automation.py
+++ b/skz-integration/autonomous-agents-framework/src/models/communication_automation.py
@@ -79,19 +79,29 @@ class Recipient:
 class CommunicationMessage:
     """Individual communication message"""
     message_id: str
-    template_id: str
-    recipient: Recipient
-    sender_agent: str
+    recipient: Any  # Recipient or MessageRecipient
     subject: str
     body: str
-    message_type: MessageType
-    priority: MessagePriority
-    scheduled_time: str
-    sent_time: Optional[str]
-    status: CommunicationStatus
-    context_data: Dict[str, Any]
-    attachments: List[str]
-    tracking_data: Dict[str, Any]
+    message_type: Any  # MessageType or str
+    priority: Any  # MessagePriority or str
+    sender_agent: str
+    template_id: str = ""
+    scheduled_time: str = ""
+    sent_time: Optional[str] = None
+    status: Any = None  # CommunicationStatus
+    context_data: Optional[Dict[str, Any]] = None
+    attachments: Optional[List[str]] = None
+    tracking_data: Optional[Dict[str, Any]] = None
+
+    def __post_init__(self):
+        if self.status is None:
+            self.status = CommunicationStatus.PENDING
+        if self.context_data is None:
+            self.context_data = {}
+        if self.attachments is None:
+            self.attachments = []
+        if self.tracking_data is None:
+            self.tracking_data = {}
 
 @dataclass
 class EscalationRule:
@@ -116,6 +126,14 @@ class NotificationConfig:
     quiet_hours: Dict[str, Any]
     enabled: bool
 
+@dataclass
+class MessageRecipient:
+    """Simplified message recipient for direct message sending"""
+    name: str
+    user_type: str
+    email: Optional[str] = None
+    phone: Optional[str] = None
+
 class CommunicationAutomation:
     """Advanced communication automation system"""
     
@@ -503,11 +521,15 @@ async def _send_email(self, message: CommunicationMessage) -> bool:
             return await self._send_via_smtp(message)
         else:
             # PRODUCTION: No fallback to mock - must configure email service
-            raise ValueError(
-                "Email service configuration required for production. "
-                "Configure SendGrid, Amazon SES, or SMTP for production deployment. "
-                "NEVER SACRIFICE QUALITY!! No mock fallbacks in production."
-            )
+            if os.getenv('ENVIRONMENT', '').lower() == 'production':
+                raise ValueError(
+                    "Email service configuration required for production. "
+                    "Configure SendGrid, Amazon SES, or SMTP for production deployment. "
+                    "NEVER SACRIFICE QUALITY!! No mock fallbacks in production."
+                )
+            # Non-production: log and return False (no real delivery)
+            logger.warning("No email provider configured. Skipping email delivery in non-production mode.")
+            return False
     
     async def _send_via_sendgrid(self, message: CommunicationMessage) -> bool:
         """Send email via SendGrid (Production Implementation)"""
@@ -645,7 +667,29 @@ async def _send_via_smtp(self, message: CommunicationMessage) -> bool:
     # PRODUCTION IMPLEMENTATION: Mock functions removed for production deployment
     # Development testing should use test email services and proper API sandboxes
     # For development, use: export ENVIRONMENT=development and configure test services
-    
+
+    async def _send_email_mock(self, message: 'CommunicationMessage') -> bool:
+        """Mock email sender - blocked in production, allowed in development"""
+        if os.getenv('ENVIRONMENT', '').lower() == 'production':
+            raise ValueError(
+                "PRODUCTION VIOLATION: Mock email sending is not allowed in production. "
+                "Configure SendGrid, Amazon SES, or SMTP for production deployment. "
+                "NEVER SACRIFICE QUALITY!! No mock fallbacks in production."
+            )
+        logger.info(f"[MOCK] Email sent to {message.recipient.email}: {message.subject}")
+        return True
+
+    async def _send_sms_mock(self, message: 'CommunicationMessage') -> bool:
+        """Mock SMS sender - blocked in production, allowed in development"""
+        if os.getenv('ENVIRONMENT', '').lower() == 'production':
+            raise ValueError(
+                "PRODUCTION VIOLATION: Mock SMS sending is not allowed in production. "
+                "Configure Twilio or alternative SMS provider for production deployment. "
+                "NEVER SACRIFICE QUALITY!! No mock fallbacks in production."
+            )
+        logger.info(f"[MOCK] SMS sent to {getattr(message.recipient, 'phone', 'unknown')}: {message.subject}")
+        return True
+
     async def _log_delivery_success(self, message: CommunicationMessage, provider: str, external_id: str):
         """Log successful message delivery"""
         message.tracking_data.update({
@@ -678,11 +722,15 @@ async def _send_sms(self, message: CommunicationMessage) -> bool:
             return await self._send_via_twilio(message)
         else:
             # PRODUCTION: No fallback to mock - must configure SMS service
-            raise ValueError(
-                "SMS service configuration required for production. "
-                "Configure Twilio or alternative SMS provider for production deployment. "
-                "NEVER SACRIFICE QUALITY!! No mock fallbacks in production."
-            )
+            if os.getenv('ENVIRONMENT', '').lower() == 'production':
+                raise ValueError(
+                    "SMS service configuration required for production. "
+                    "Configure Twilio or alternative SMS provider for production deployment. "
+                    "NEVER SACRIFICE QUALITY!! No mock fallbacks in production."
+                )
+            # Non-production: log and return False (no real delivery)
+            logger.warning("No SMS provider configured. Skipping SMS delivery in non-production mode.")
+            return False
     
     async def _send_via_twilio(self, message: CommunicationMessage) -> bool:
         """Send SMS via Twilio (Production Implementation)"""
diff --git a/skz-integration/autonomous-agents-framework/src/models/learning_framework.py b/skz-integration/autonomous-agents-framework/src/models/learning_framework.py
index 5022ab33..6b6720ea 100644
--- a/skz-integration/autonomous-agents-framework/src/models/learning_framework.py
+++ b/skz-integration/autonomous-agents-framework/src/models/learning_framework.py
@@ -426,6 +426,13 @@ def __init__(self, agent_id: str = None, db_path: str = "learning_framework.db",
         self.db_path = db_path
         self.lock = threading.RLock()
         
+        # For :memory: databases, keep a persistent connection since each
+        # sqlite3.connect(":memory:") call creates a new, independent database
+        if db_path == ':memory:':
+            self._persistent_conn = sqlite3.connect(':memory:', check_same_thread=False)
+        else:
+            self._persistent_conn = None
+        
         # Use provided learners or create new ones
         self.reinforcement_learner = reinforcement_learner if reinforcement_learner is not None else ReinforcementLearner(agent_id)
         self.supervised_learner = supervised_learner if supervised_learner is not None else SupervisedLearner(agent_id)
@@ -434,9 +441,16 @@ def __init__(self, agent_id: str = None, db_path: str = "learning_framework.db",
         
         self._init_database()
         
+    def _get_connection(self):
+        """Get a database connection (persistent for :memory:, new for file-based)"""
+        if self._persistent_conn is not None:
+            return self._persistent_conn
+        return sqlite3.connect(self.db_path)
+
     def _init_database(self):
         """Initialize learning database"""
-        with sqlite3.connect(self.db_path) as conn:
+        conn = self._get_connection()
+        try:
             conn.execute("""
                 CREATE TABLE IF NOT EXISTS learning_experiences (
                     id TEXT PRIMARY KEY,
@@ -470,6 +484,9 @@ def _init_database(self):
             conn.execute("CREATE INDEX IF NOT EXISTS idx_pattern_agent ON learning_patterns(agent_id)")
             
             conn.commit()
+        finally:
+            if self._persistent_conn is None:
+                conn.close()
     
     def learn_from_experience(self, action_type: str, input_data: Dict[str, Any],
                              output_data: Dict[str, Any], success: bool,
@@ -493,7 +510,8 @@ def learn_from_experience(self, action_type: str, input_data: Dict[str, Any],
             )
             
             # Store in database
-            with sqlite3.connect(self.db_path) as conn:
+            conn = self._get_connection()
+            try:
                 conn.execute("""
                     INSERT INTO learning_experiences 
                     (id, agent_id, action_type, input_data, output_data, success, performance_metrics, feedback, created_at)
@@ -510,6 +528,9 @@ def learn_from_experience(self, action_type: str, input_data: Dict[str, Any],
                     experience.created_at.isoformat()
                 ))
                 conn.commit()
+            finally:
+                if self._persistent_conn is None:
+                    conn.close()
             
             # Update learning components
             self._update_learning_components(experience)
@@ -576,7 +597,8 @@ def get_learning_recommendations(self, current_context: Dict[str, Any]) -> List[
     def get_learning_stats(self) -> Dict[str, Any]:
         """Get learning framework statistics"""
         with self.lock:
-            with sqlite3.connect(self.db_path) as conn:
+            conn = self._get_connection()
+            try:
                 # Experience stats
                 cursor = conn.execute("""
                     SELECT COUNT(*) FROM learning_experiences WHERE agent_id = ?
@@ -605,6 +627,9 @@ def get_learning_stats(self) -> Dict[str, Any]:
                     'learning_efficiency': self.meta_learner.get_learning_insights()['learning_efficiency'],
                     'current_performance': self.meta_learner.get_learning_insights()['current_performance']
                 }
+            finally:
+                if self._persistent_conn is None:
+                    conn.close()
     
     def save_learning_state(self, filepath: str):
         """Save learning state to file"""
diff --git a/skz-integration/autonomous-agents-framework/src/models/ml_decision_engine.py b/skz-integration/autonomous-agents-framework/src/models/ml_decision_engine.py
index e6982d61..d4e13616 100644
--- a/skz-integration/autonomous-agents-framework/src/models/ml_decision_engine.py
+++ b/skz-integration/autonomous-agents-framework/src/models/ml_decision_engine.py
@@ -11,10 +11,18 @@
 import logging
 from dataclasses import dataclass
 import re
-from sklearn.feature_extraction.text import TfidfVectorizer
-from sklearn.metrics.pairwise import cosine_similarity
-from sklearn.ensemble import RandomForestClassifier
-from sklearn.preprocessing import StandardScaler
+try:
+    from sklearn.feature_extraction.text import TfidfVectorizer
+    from sklearn.metrics.pairwise import cosine_similarity
+    from sklearn.ensemble import RandomForestClassifier
+    from sklearn.preprocessing import StandardScaler
+    SKLEARN_AVAILABLE = True
+except ImportError:
+    TfidfVectorizer = None
+    cosine_similarity = None
+    RandomForestClassifier = None
+    StandardScaler = None
+    SKLEARN_AVAILABLE = False
 import pickle
 import threading
 
@@ -48,7 +56,7 @@ class NLPProcessor:
     
     def __init__(self, config: Optional[Dict[str, Any]] = None):
         self.config = config or {}
-        self.vectorizer = TfidfVectorizer(max_features=1000, stop_words='english')
+        self.vectorizer = TfidfVectorizer(max_features=1000, stop_words='english') if SKLEARN_AVAILABLE else None
         self.entity_patterns = {
             'ingredient': r'\b[A-Z][a-z]+(?:-[A-Z][a-z]+)*\b',
             'compound': r'\b[A-Z][a-z]+\d*\b',
@@ -343,8 +351,8 @@ class QualityAssessor:
     """Quality assessment using ML"""
     
     def __init__(self):
-        self.quality_model = RandomForestClassifier(n_estimators=100, random_state=42)
-        self.scaler = StandardScaler()
+        self.quality_model = RandomForestClassifier(n_estimators=100, random_state=42) if SKLEARN_AVAILABLE else None
+        self.scaler = StandardScaler() if SKLEARN_AVAILABLE else None
         self.feature_names = [
             'word_count', 'sentence_count', 'paragraph_count',
             'citation_count', 'figure_count', 'table_count',
@@ -354,6 +362,9 @@ def __init__(self):
     
     def _initialize_dummy_model(self):
         """Initialize dummy model with some basic training data"""
+        if self.scaler is None or self.quality_model is None:
+            logger.warning("sklearn not available - quality model not initialized")
+            return
         # Create some dummy training data
         X_dummy = np.array([
             [100, 5, 3, 2, 1, 0, 0.5, 0.5, 0.5],  # Low quality
@@ -433,6 +444,16 @@ def _assess_quality_ml(self, manuscript: Dict[str, Any]) -> Dict[str, Any]:
     def _assess_quality_basic(self, manuscript: Dict[str, Any]) -> Dict[str, Any]:
         """Basic quality assessment (FALLBACK - REPLACE WITH ML)"""
         features = self.extract_features(manuscript)
+        if self.scaler is None or self.quality_model is None:
+            # sklearn not available - return heuristic score
+            return {
+                'overall_score': 0.5,
+                'methodology': manuscript.get('methodology_score', 0.5),
+                'clarity': manuscript.get('clarity_score', 0.5),
+                'completeness': manuscript.get('completeness_score', 0.5),
+                'technical_rigor': 0.5,
+                'innovation': 0.5
+            }
         features_scaled = self.scaler.transform(features)
         
         # Predict quality score
@@ -452,6 +473,9 @@ def _assess_quality_basic(self, manuscript: Dict[str, Any]) -> Dict[str, Any]:
     
     def train_model(self, training_data: List[Dict[str, Any]]):
         """Train the quality assessment model"""
+        if self.scaler is None or self.quality_model is None:
+            logger.warning("sklearn not available - skipping model training")
+            return
         X = []
         y = []
         
@@ -767,3 +791,40 @@ def get_decision_stats(self) -> Dict[str, Any]:
                 'nlp_processor': '1.0'
             }
         }
+
+
+class MLDecisionEngine:
+    """ML Decision Engine - public API class for ML-based agent decisions"""
+
+    def __init__(self, config: Dict[str, Any] = None):
+        self.config = config or {}
+
+    def _classify_text_keywords(self, text: str, categories: List[str]) -> Dict[str, float]:
+        """Keyword-based text classification (DEVELOPMENT/TESTING ONLY)"""
+
+        # PRODUCTION ENFORCEMENT: This method should not be reached in production
+        if os.getenv('ENVIRONMENT', '').lower() == 'production' or self.config.get('force_ml_models', False):
+            raise ValueError(
+                "PRODUCTION VIOLATION: Keyword-based classification blocked in production mode. "
+                "Configure BERT models properly. NEVER SACRIFICE QUALITY!!"
+            )
+
+        logger.warning("USING KEYWORD CLASSIFICATION - NOT SUITABLE FOR PRODUCTION ML")
+
+        category_scores = {}
+        for category in categories:
+            keywords = self._get_category_keywords(category)
+            score = sum(1 for kw in keywords if kw.lower() in text.lower())
+            category_scores[category] = score / len(keywords) if keywords else 0.0
+        return category_scores
+
+    def _get_category_keywords(self, category: str) -> List[str]:
+        """Get keywords for a category"""
+        category_keywords = {
+            'research': ['study', 'analysis', 'investigation', 'research', 'experiment'],
+            'quality': ['quality', 'standard', 'compliance', 'validation', 'assessment'],
+            'safety': ['safety', 'toxicity', 'risk', 'hazard', 'compliance'],
+            'innovation': ['novel', 'innovative', 'breakthrough', 'new', 'original'],
+            'methodology': ['method', 'procedure', 'protocol', 'technique', 'approach']
+        }
+        return category_keywords.get(category, [])
diff --git a/skz-integration/autonomous-agents-framework/src/models/patent_analyzer.py b/skz-integration/autonomous-agents-framework/src/models/patent_analyzer.py
index 410ed103..2bb71325 100644
--- a/skz-integration/autonomous-agents-framework/src/models/patent_analyzer.py
+++ b/skz-integration/autonomous-agents-framework/src/models/patent_analyzer.py
@@ -274,7 +274,29 @@ def _parse_uspto_response(self, data: Dict) -> List[PatentDocument]:
     # PRODUCTION IMPLEMENTATION: Mock functions removed for production deployment
     # Development testing should use test databases and proper API sandboxes
     # For development, use: export ENVIRONMENT=development and configure test APIs
-    
+
+    async def _search_uspto_mock(self, query: str, date_range: Optional[Tuple[str, str]], limit: int) -> List[PatentDocument]:
+        """Mock USPTO search - blocked in production, allowed in development"""
+        if os.getenv('ENVIRONMENT', '').lower() == 'production':
+            raise ValueError(
+                "PRODUCTION VIOLATION: Mock USPTO search is not allowed in production. "
+                "Configure uspto_api_key and set use_production_apis=True. "
+                "NEVER SACRIFICE QUALITY!! No mock fallbacks in production."
+            )
+        logger.info(f"[MOCK] USPTO search: {query}")
+        return []
+
+    async def _search_google_patents_mock(self, query: str, date_range: Optional[Tuple[str, str]], limit: int) -> List[PatentDocument]:
+        """Mock Google Patents search - blocked in production, allowed in development"""
+        if os.getenv('ENVIRONMENT', '').lower() == 'production':
+            raise ValueError(
+                "PRODUCTION VIOLATION: Mock Google Patents search is not allowed in production. "
+                "Configure google_cloud_credentials and set use_production_apis=True. "
+                "NEVER SACRIFICE QUALITY!! No mock fallbacks in production."
+            )
+        logger.info(f"[MOCK] Google Patents search: {query}")
+        return []
+
     async def _search_google_patents(self, query: str, date_range: Optional[Tuple[str, str]], limit: int) -> List[PatentDocument]:
         """Search Google Patents"""
         
diff --git a/skz-integration/autonomous-agents-framework/src/performance_optimizer.py b/skz-integration/autonomous-agents-framework/src/performance_optimizer.py
index 470c0f4b..caffcdaf 100644
--- a/skz-integration/autonomous-agents-framework/src/performance_optimizer.py
+++ b/skz-integration/autonomous-agents-framework/src/performance_optimizer.py
@@ -87,6 +87,8 @@ def optimize_agent_performance(self, agent_id: str, operation: str, data: Dict[s
                 self.metrics_collector.record_cache_hit(agent_id, operation)
                 return cached_result
             
+            self.metrics_collector.record_cache_miss(agent_id, operation)
+            
             # Process with optimization
             with self.connection_pool.get_connection() as conn:
                 result = self._process_optimized_operation(agent_id, operation, data, conn)
@@ -231,11 +233,13 @@ def get(self, key: str) -> Optional[Any]:
         try:
             if self.redis_client:
                 value = self.redis_client.get(key)
-                return json.loads(value) if value else None
-            else:
-                return self.local_cache.get(key)
+                result = json.loads(value) if value else None
+                if result is not None:
+                    return result
+            # Fall back to local cache (also used when Redis is unavailable or fails)
+            return self.local_cache.get(key)
         except Exception:
-            return None
+            return self.local_cache.get(key)
     
     def set(self, key: str, value: Any, ttl: int = None) -> bool:
         """Set cached value"""
@@ -243,11 +247,13 @@ def set(self, key: str, value: Any, ttl: int = None) -> bool:
             ttl = ttl or self.config.get('default_ttl', 300)
             
             if self.redis_client:
-                return self.redis_client.setex(key, ttl, json.dumps(value))
-            else:
-                # Local cache with simple TTL simulation
-                self.local_cache[key] = value
-                return True
+                try:
+                    self.redis_client.setex(key, ttl, json.dumps(value))
+                except Exception:
+                    pass
+            # Always update local cache as reliable fallback
+            self.local_cache[key] = value
+            return True
         except Exception:
             return False
     
@@ -532,7 +538,10 @@ def optimize_memory_usage(self, operation: str, data: Dict[str, Any]) -> Dict[st
         # Use weak references for temporary objects
         if 'temp_objects' in data:
             for obj_id, obj in data['temp_objects'].items():
-                self.weak_references[obj_id] = obj
+                try:
+                    self.weak_references[obj_id] = obj
+                except TypeError:
+                    pass  # Skip objects that don't support weak references
         
         return data
     
diff --git a/skz-integration/autonomous-agents-framework/tests/test_functionality.py b/skz-integration/autonomous-agents-framework/tests/test_functionality.py
index f6ef9218..7e1667a7 100644
--- a/skz-integration/autonomous-agents-framework/tests/test_functionality.py
+++ b/skz-integration/autonomous-agents-framework/tests/test_functionality.py
@@ -16,70 +16,66 @@ def test_enhanced_agent_mock():
     
     print("Testing Enhanced Review Coordination Agent...")
     
-    # Mock the heavy dependencies
-    with patch('models.automated_coordination_engine.AutomatedCoordinationEngine'):
-        with patch('models.ojs_coordination_integrator.OJSCoordinationIntegrator'):
-            
-            # Import after mocking
-            sys.path.append('/home/runner/work/oj7/oj7/skz-integration/microservices/review-coordination')
-            from app import EnhancedReviewCoordinationAgent
-            
-            # Test agent initialization
-            agent = EnhancedReviewCoordinationAgent()
-            print("✓ Agent initialized successfully")
-            
-            # Test agent capabilities
-            agent_data = agent.get_agent_data()
-            assert 'automated_coordination' in agent_data['capabilities']
-            assert 'ojs_integration' in agent_data['capabilities']
-            assert agent_data['version'] == '2.0-automated'
-            print("✓ Agent capabilities verified")
-            
-            # Test coordination action
-            test_data = {
-                'action_type': 'coordinate',
-                'manuscript': {
-                    'id': 'test_manuscript',
-                    'title': 'Test Paper',
-                    'subject_areas': ['AI', 'ML']
-                }
-            }
-            
-            result = agent.process_action(test_data)
-            assert result['coordination_initiated'] is True
-            assert result['automation_level'] == 'full'
-            assert 'estimated_completion' in result
-            print("✓ Coordination action processed successfully")
-            
-            # Test status action
-            status_data = {
-                'action_type': 'status'
-            }
-            
-            result = agent.process_action(status_data)
-            assert 'automation_success_rate' in result
-            assert 'system_health' in result
-            print("✓ Status action processed successfully")
-            
-            # Test metrics action
-            metrics_data = {
-                'action_type': 'metrics'
-            }
-            
-            result = agent.process_action(metrics_data)
-            assert 'total_coordinated' in result
-            assert 'success_rate' in result
-            assert 'timeline_adherence' in result
-            print("✓ Metrics action processed successfully")
-            
-            print(f"\nAgent Data Summary:")
-            print(f"- ID: {agent_data['id']}")
-            print(f"- Name: {agent_data['name']}")
-            print(f"- Version: {agent_data['version']}")
-            print(f"- Capabilities: {len(agent_data['capabilities'])}")
-            print(f"- Automation Enabled: {agent_data['coordination_stats']['automation_enabled']}")
-            
-            return True
+    # Import after adding the path (app.py uses its own mock classes, no external patches needed)
+    sys.path.append('/home/runner/work/ojs7/ojs7/skz-integration/microservices/review-coordination')
+    from app import EnhancedReviewCoordinationAgent
+    
+    # Test agent initialization
+    agent = EnhancedReviewCoordinationAgent()
+    print("✓ Agent initialized successfully")
+    
+    # Test agent capabilities
+    agent_data = agent.get_agent_data()
+    assert 'automated_coordination' in agent_data['capabilities']
+    assert 'ojs_integration' in agent_data['capabilities']
+    assert agent_data['version'] == '2.0-automated'
+    print("✓ Agent capabilities verified")
+    
+    # Test coordination action
+    test_data = {
+        'action_type': 'coordinate',
+        'manuscript': {
+            'id': 'test_manuscript',
+            'title': 'Test Paper',
+            'subject_areas': ['AI', 'ML']
+        }
+    }
+    
+    result = agent.process_action(test_data)
+    assert result['coordination_initiated'] is True
+    assert result['automation_level'] == 'full'
+    assert 'estimated_completion' in result
+    print("✓ Coordination action processed successfully")
+    
+    # Test status action
+    status_data = {
+        'action_type': 'status'
+    }
+    
+    result = agent.process_action(status_data)
+    assert 'automation_success_rate' in result
+    assert 'system_health' in result
+    print("✓ Status action processed successfully")
+    
+    # Test metrics action
+    metrics_data = {
+        'action_type': 'metrics'
+    }
+    
+    result = agent.process_action(metrics_data)
+    assert 'total_coordinated' in result
+    assert 'success_rate' in result
+    assert 'timeline_adherence' in result
+    print("✓ Metrics action processed successfully")
+    
+    print(f"\nAgent Data Summary:")
+    print(f"- ID: {agent_data['id']}")
+    print(f"- Name: {agent_data['name']}")
+    print(f"- Version: {agent_data['version']}")
+    print(f"- Capabilities: {len(agent_data['capabilities'])}")
+    print(f"- Automation Enabled: {agent_data['coordination_stats']['automation_enabled']}")
+    
+    return True
 
 def test_coordination_engine_concepts():
     """Test coordination engine concepts without full implementation"""